constants.h

Go to the documentation of this file.

 
#ifndef CONSTANTS_H 
#define CONSTANTS_H
 
#include "common.h"
#include <boost/program_options.hpp>
 
/* For generating a unique GUID */
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
 
namespace po = boost::program_options;
 
// ========================================================================  
// ConstantParameters Class
// ========================================================================  
class ConstantParameters
{
    public:
        static ConstantParameters* getInstance();
 
        void initConstants(po::variables_map &);
 
        /* All the get methods */
        double T() const {return T_;}                   
        double imagTimeLength() const { return imagTimeLength_;}    
        double mu() const {return mu_;}                 
        double tau() const {return tau_;}               
        double m() const {return m_;}                   
        double lambda() const {return lambda_;}         
        double rc() const {return rc_;}                 
        double rc2() const {return rc2_;}               
        double C0() const {return C0_;}                 
        double C() const {return C_;}                   
        double V() const {return V_;}                   
        double L() const {return L_;}                   
        double comDelta() const {return comDelta_;}     
        double displaceDelta() const {return displaceDelta_;}       
        int virialWindow() const {return virialWindow_;}    
 
        double dBWavelength() const {return dBWavelength_;} 
        double rho0Norm(int M, int d) const {return ( pow((4.0*M_PI*lambda_*M*tau_),-0.5*d));}
        double fourLambdaTauInv() const { return (0.25 / (lambda_ * tau_)); }
 
        /* Get the move attempt probability */
        double attemptProb(string type) {
            if (attemptProb_.count(type))
                return attemptProb_[type];
            else {
                cerr << "Get: Attempt probability for " << type << " does not exist!" << endl;
                exit(EXIT_FAILURE);
                return 0.0;
            }
        }
 
        /* Set the move attempt probability */
        void setAttemptProb(string type,double prob) {
            attemptProb_[type] = prob;
            /* if (attemptProb_.count(type)) */
            /*     attemptProb_[type] = prob; */
            /* else { */
            /*     cerr << "Set: Attempt probability for " << type << " does not exist!" << endl; */
            /*     exit(EXIT_FAILURE); */
            /* } */
        }
 
        bool restart() const {return restart_;}                             
        bool wallClockOn() const {return wallClockOn_;}                     
        uint32 wallClock() const {return wallClock_;}                       
        bool canonical() const { return canonical_;}                        
        bool window() const { return window_;}                              
        bool startWithState() const { return startWithState_;}               
        int windowWidth() const { return windowWidth_;}                     
        bool gaussianEnsemble() const { return gaussianEnsemble_;}          
        double gaussianEnsembleSD() const { return gaussianEnsembleSD_;}    
        bool varUpdates() const {return varUpdates_;}                       
 
        int Mbar() {return Mbar_;}                      
        int b() {return b_;}                            
        int numTimeSlices() {return numTimeSlices_;}    
        int initialNumParticles() { return initialNumParticles_;}   
        int maxWind() { return maxWind_;}               
        string id() {return id_;}                       
        uint32 numEqSteps() {return numEqSteps_;}   
        int numBroken() {return numBroken_;}            //< Get number of broken paths
        double spatialSubregion() {return spatialSubregion_;}          //< Get size of subregion
        bool spatialSubregionOn() {return spatialSubregionOn_;}           //< Get subregion on/off
        int Npaths() {return Npaths_;}                  //< Get number of paths
 
        string intPotentialType() const {return intPotentialType_;} 
        string extPotentialType() const {return extPotentialType_;} 
        string waveFunctionType() const {return waveFunctionType_;} 
        double endFactor() const {return endFactor_;}        
        string actionType() const {return actionType_;}             
        string graphenelut3d_file_prefix() const {return graphenelut3d_file_prefix_;}       
 
        /* Trial wave funciton parameters */
        double R_LL_wfn() const {return R_LL_wfn_;}        
        double k_LL_wfn() const {return k_LL_wfn_;}        
    
        /* Set methods */
        void setmu(double _mu) {mu_ = _mu;}             
        void setCoMDelta(double _comDelta) {comDelta_ = _comDelta;} 
        void setDisplaceDelta(double _displaceDelta) {displaceDelta_ = _displaceDelta;} 
 
        /* Increment/decrement methods */
        void shiftC0(double frac) {C0_ += frac*C0_; getC();}                
        void setC0(double _C0) {C0_ = _C0; getC();}                         
        void getC() {C_ = C0_ / (1.0*Mbar_*numTimeSlices_*V_);}             
        void shiftCoMDelta(double frac) {comDelta_ += frac*comDelta_; }     
        void shiftDisplaceDelta(double frac) {displaceDelta_ += frac*displaceDelta_; }      
        void shiftmu (double frac) { mu_ += frac; }                     
 
        bool saveStateFiles() { return saveStateFiles_;}                              
 
    protected:
        ConstantParameters();
        ConstantParameters(const ConstantParameters&);              
        ConstantParameters& operator= (const ConstantParameters&);  
 
    private:
        double T_;              // Temperature [K]
        double imagTimeLength_; // Temperature [K]
        double mu_;             // Chemical Potential [K]
        double tau_;            // Imaginary time step (tau = beta/numTimeSlices)
        double lambda_;         // hbar^2 / (2*mass*k_B) [K A^2]
        double m_;              // The particle mass
        double dBWavelength_;   // Thermal de Broglie wavelength
        double comDelta_;       // The size of center of mass move
        double displaceDelta_;  // The size of the displace move shift
 
        double rc_;             // The potential cutoff length
        double rc2_;            // The potential cutoff length squared
        double C0_;             // Worm probability constant [PRE 74, 036701 (2006)]
        double C_;              // Worm normalization factor
        double V_;              // The volume of the system
        double L_;              // The linear 'length' of the system 
 
        int Mbar_;                // Maximum worm algorithm trial length
        int b_;                   // The maximum number of levels
        int numTimeSlices_;       // Number of imaginary time slices
        int initialNumParticles_; // The initial number of particles
        int numBroken_;           // The number of broken paths
        double spatialSubregion_;      // The limits of the spatial sub region for EE
        bool spatialSubregionOn_;     // True if using a spatial subregion for EE
        int Npaths_;                // Number of paths used
 
        uint32 numEqSteps_;     // Number of equilibration steps
 
        bool restart_;              // Are we restarting the simulation
        uint32 wallClock_;          // The wall clock limit in seconds
        bool wallClockOn_;          // Is the wall clock on?
        bool canonical_;            // Are we in the canonical ensemble?
        bool window_;               // Are we using a particle number window?
        bool startWithState_;       // Are we starting from a supplied state?
        int windowWidth_;           // Half width of particle number window
        bool gaussianEnsemble_;     // Are we using gaussian ensemble weight?
        double gaussianEnsembleSD_; // Standard deviation of ensemble weight
        bool varUpdates_;           // Perform variable length diagonal updates
 
        string  id_;                // The unique simulation UUID
        string intPotentialType_;   // The type of interaction potential
        string extPotentialType_;   // The type of external potential
        string waveFunctionType_;   // The type of trial wave function
        double R_LL_wfn_;           // The length scale of the Lieb-Liniger wave function
        double k_LL_wfn_;           // The wave number of the Lieb-Liniger wave function
        double endFactor_;          // The multiplicative factor of the potential on end beads
        string actionType_;         // The type of action
 
        int virialWindow_;        // Window size for centroid virial estimator
        int maxWind_;             // The maximum winding number sampled
 
        bool saveStateFiles_;       // Are we saving a state file every MC bin?
        string graphenelut3d_file_prefix_; // GrapheneLUT3D file prefix <prefix>_{V,gradV,grad2V}.npy 
        
        map <string,double> attemptProb_;   // The move attempt probabilities
};
 
/**************************************************************************/
inline ConstantParameters* constants() {
    ConstantParameters *temp = ConstantParameters::getInstance();
    return temp;
}
 
#endif