pimc.h

Go to the documentation of this file.

 
#ifndef PIMC_H 
#define PIMC_H
 
#include "common.h"
#include "communicator.h"
#include "estimator.h"
 
class Path;
class LookupTable;
class MoveBase;
class EstimatorBase;
 
typedef boost::ptr_vector<EstimatorBase> estimator_vector;
 
typedef boost::ptr_vector<MoveBase> move_vector;
 
// ========================================================================  
// PathIntegralMonteCarlo Class
// ========================================================================  
class PathIntegralMonteCarlo {
    public:
        PathIntegralMonteCarlo (boost::ptr_vector<Path> &,MTRand &, boost::ptr_vector<move_vector> &,
                                boost::ptr_vector<estimator_vector> &, const bool, uint32 binSize=100);
        ~PathIntegralMonteCarlo ();
 
 
        /* The equilibration relaxation */
        void equilStepDiagonal();
 
        bool  equilStepRelaxmu();
        bool  equilStepRelaxC0();
 
        void equilStep(const uint32, const bool, const bool);
 
        /* The actual monte carlo step */
        void step();
 
        /* Output results of the simulation */
        void finalOutput();
 
        /* Save the PIMC state to disk */
        void saveState(const int finalSave = 0);
 
        /* Output the world-line configurations in the protein databank format */
        void outputPDB();
 
        int numStoredBins;          
        int numDiagonal;            
        int numConfig;              
        int numCoMAttempted;        
        int prevNumCoMAttempted;    
        int numCoMAccepted;         
        int numDisplaceAttempted;   
        int numDisplaceAccepted;    
        int numMuAttempted;         
        int numNAttempted;          
        int numStepsAttempted;      
 
        void printWormState();
        string printHistogram();
 
    private:
        MTRand &random;             // The global random number generator
 
        int configNumber;           // The output configuration number
        int numImagTimeSweeps;      // Partitioning used for updates
        int numSteps;               // The number of steps performed during equilibration
        int numUpdates;             // The maximum number of updates per step.
        uint32 binSize;                // The maximum number measurements per bin.
        int numParticles;           // The number of particles
 
        int N0;                     
        bool foundmu;               
        bool foundC0;               
        double muFactor;            
        double bestmu;              
        int  bestPN;                
        double bestDiffAveN;        
        bool inWindow;              
 
        int sgnAveN;                
 
        Array<int,1> PN;            
        bool relaxmuMessage;        
        bool relaxC0Message;        
        bool equilMessage;          
        bool equilODMessage;        
        vector <double> C0Vals;     
        vector <double> diagFracVals;   
 
        double targetDiagFrac;      
        int sgnDiagFrac;            
        double shiftC0;             
        int barStepSize;            
        int numRemainingSteps;      
        int numBars;                
 
        uint32 Npaths;                 // Number of paths
    
        vector<string> stateStrings; // A vector of state strings from the last bin
 
        bool startWithState;        // Are we starting from a saved state
        bool success;               // Track move success/failure
    
        boost::ptr_vector<Path> &pathPtrVec; // The vector of all paths
        Path &path;                          // A reference to the first path in the path vector
 
        boost::ptr_vector<move_vector> &movePtrVec;  // Vector of all move_vectors
        move_vector &move;                           // A reference to the first move_vector
    
        boost::ptr_vector<estimator_vector> &estimatorPtrVec;  // Vector of estimators for 
                                                               // each path followed by multipath
        estimator_vector &estimator;                           // A reference to the first estimator_vector
 
        vector <double> attemptDiagProb;        // The cumulative diagonal attempt Probabilities
        vector <double> attemptOffDiagProb;     // The cumulative off-diagonal attempt Probabilities
 
        map <string,int> moveIndex;             // A map to keep track of move names and indices
        map <string,int> estimatorIndex;        // A map to keep track of estimator names and indices
 
        /* Output estimators to disk */
        void output();
 
        /* perform an iterative linear regrssion for C0 calculation */
        double linearRegressionC0();
 
        /* Load the PIMC state from disk */
        void loadState();
 
        /* Load classical or quantum initial states */
        void loadClassicalState(Array <dVec,2>&, Array <unsigned int, 2>&, int);
        void loadQuantumState(Array <dVec,2>&, Array <beadLocator,2>&, Array<beadLocator,2>&, int, int);
 
        /* Shuffle the offDiag move list, returning it in moves*/
        void shuffleMoves();
 
        /* Perform a Metropolis update */
        string update(const double,const int,const int);
 
};
 
#endif