move.h

Go to the documentation of this file.

 
#include "common.h"
 
#ifndef MOVE_H 
#define MOVE_H
 
/* #define DEBUG_WORM */
/* #define DEBUG_MOVE */
 
class Path;
class ActionBase;
 
// ========================================================================  
// MoveBase Class
// ========================================================================  
class MoveBase {
 
    public:
        MoveBase (Path &, ActionBase *, MTRand &, 
                ensemble _operateOnConfig=ANY, bool _varLength=false);
        virtual ~MoveBase();
    
        ensemble operateOnConfig;       
        bool variableLength;            
        string name1;
 
        virtual string getName() {return "base";}
 
        double getAcceptanceRatio() {
            return (numAttempted == 0 ? 0.0 : 1.0*numAccepted/(1.0*numAttempted));
        }
 
        double getTotAcceptanceRatio() {
            return (totAttempted == 0 ? 0.0 : 1.0*totAccepted/(1.0*totAttempted));
        }
 
        double getAcceptanceRatioLevel(int n) { 
            return (numAttemptedLevel(n) == 0 ? 0.0 : 
                    1.0*numAcceptedLevel(n)/(1.0*numAttemptedLevel(n)));
        }
 
        int getNumAttempted() { return numAttempted; }
        int getNumAccepted() { return numAccepted; }
        int getNumAttemptedLevel(int n) { return numAttemptedLevel(n); }
        int getNumAcceptedLevel(int n) { return numAcceptedLevel(n); }
 
        virtual bool attemptMove() = 0; 
 
        void resetTotAccept() { totAccepted = totAttempted = 0; }
        void resetAccept() { numAccepted = numAttempted = 0; }
 
    protected:
        friend class PathIntegralMonteCarlo;    // Friends for I/O
 
        Path &path;                     
        ActionBase *actionPtr;          
        MTRand &random;                 
 
        bool success;                   
 
        uint32 numAccepted;             
        uint32 numAttempted;            
        int numToMove;                  
        int numLevels;                  // The 2^numLevels = num slices moved
 
        static uint32 totAccepted;      
        static uint32 totAttempted;     
 
        Array <uint32,1> numAcceptedLevel;  
        Array <uint32,1> numAttemptedLevel; 
 
        Array <dVec,1> originalPos;     
        Array <dVec,1> newPos;          
        
        vector <iVec> winding;          
        vector <int> windingSector;     
        vector <double> cumrho0;        
 
        int maxWind;                    
        int numWind;                    
 
        double oldAction;               
        double newAction;               
        double deltaAction;             
 
        double sqrt2LambdaTau;          
        double sqrtLambdaTau;           
 
        beadLocator nBeadIndex;         
        dVec neighborPos;               
        dVec newRanPos;                 
 
        virtual void keepMove();        
        virtual void undoMove() = 0;    
 
        /* Returns a new bead position based on the staging algorithm */
        dVec newStagingPosition(const beadLocator &, const beadLocator &, const int, const int);
        dVec newStagingPosition(const beadLocator &, const beadLocator &, const int, const int, iVec &);
 
        iVec sampleWindingSector(const beadLocator &, const beadLocator &, const int, double &);
 
        iVec getWindingNumber(const beadLocator &, const beadLocator &);
 
        /* Return a new bead position which samples the free particle density matrix */
        dVec newFreeParticlePosition(const beadLocator &);
 
        /* Returns a new bead position based on the bisection algorithm */
        dVec newBisectionPosition(const beadLocator&, const int);   
 
        double newK,oldK;               
        double newV,oldV;               
 
        /* Debugging methods */
        void printMoveState(string);
        void checkMove(int,double);
};
 
// ========================================================================  
// Displace Move Class 
// ========================================================================  
class DisplaceMove: public MoveBase {
 
    public:
        DisplaceMove(Path &, ActionBase *, MTRand &, 
                ensemble _operateOnConfig=ANY);
        ~DisplaceMove();
    
        bool attemptMove();
        static const string name;
        string getName() {return name;}
 
    private:
        beadLocator beadIndex;  // The index of the bead being moved
        void undoMove();        // revert everything back
};
 
 
// ========================================================================
// End Staging Move Class
// ========================================================================
/* A derived class which performs a staiging move on the end of a path.
 */
class EndStagingMove: public MoveBase {
    
    public:
        EndStagingMove(Path &, ActionBase *, MTRand &, 
                ensemble _operateOnConfig=ANY);
        ~EndStagingMove();
 
        bool attemptMove();
        static const string name;
        string getName() {return name;}
 
    private:
        bool leftMoving;        // True if update moves left to right
        beadLocator leftBead;   // The left most bead being moved
        beadLocator rightBead;  // The left most bead being moved
        void undoMove();        // revert everything back
};
 
 
// ========================================================================
// End Staging Move Class
// ========================================================================
/* A derived class which performs a staiging move on the end of a path.
 */
class MidStagingMove: public MoveBase {
    
    public:
        MidStagingMove(Path &, ActionBase *, MTRand &,
                ensemble _operateOnConfig=ANY);
        ~MidStagingMove();
 
        bool attemptMove();
        static const string name;
        string getName() {return name;}
    
    private:
        beadLocator leftBead;   // The left most bead being moved
        beadLocator rightBead;  // The left most bead being moved
        beadLocator midBeadL;   // Bead on left of break to be updated
        beadLocator midBeadR;   // Bead on right of break to be updated
        void undoMove();        // revert everything back
};
 
 
// ========================================================================
// SwapBreak Move Class
// ========================================================================
/* A derived class which swaps the location of a broken worldline.
*/
class SwapBreakMove: public MoveBase {
    
    public:
        SwapBreakMove(Path &, ActionBase *, MTRand &,
                ensemble _operateOnConfig=ANY);
        ~SwapBreakMove();
 
        bool attemptMove();
        static const string name;
        string getName() {return name;}
 
    private:
        void undoMove(){};
    
};
 
// ========================================================================  
// CenterOfMass Move Class 
// ========================================================================  
class CenterOfMassMove: public MoveBase {
 
    public:
        CenterOfMassMove(Path &, ActionBase *, MTRand &, 
                ensemble _operateOnConfig=ANY);
        ~CenterOfMassMove();
 
        bool attemptMove();
        static const string name;
        string getName() {return name;}
 
    private:
        beadLocator startBead,endBead;  // The start and end beads
        void undoMove();                // revert everything back
};
 
 
// ========================================================================  
// Staging Move Class 
// ========================================================================  
class StagingMove: public MoveBase {
 
    public:
        StagingMove(Path &, ActionBase *, MTRand &, 
                ensemble _operateOnConfig=ANY);
        ~StagingMove();
 
        bool attemptMove();
        static const string name;
        string getName() {return name;}
 
    private:
        beadLocator startBead,endBead;      // The start and end of the stage
 
        void undoMove();                    // Undo the move
 
        int stageLength;                    // The length of the stage
};
 
// ========================================================================  
// Bisection Move Class 
// ========================================================================  
class BisectionMove: public MoveBase {
 
    public:
        BisectionMove(Path &, ActionBase *, MTRand &,
                ensemble _operateOnConfig=ANY);
        ~BisectionMove();
    
        bool attemptMove();
        static const string name;
        string getName() {return name;}
 
    private:
        Array <bool,1> include;             // Which beads have been included?
 
        beadLocator startBead,endBead;
 
        int numActiveBeads;                 // The total number of active beads
        int level;                          // The current level
        int shift;                          // The distance between slices at a given level
 
        double oldDeltaAction;              // The old and new action differences
 
        void keepMove();                    // Keep the move
        void undoMove();                    // Undo the move
};
 
// ========================================================================  
// Open Move Class 
// ========================================================================  
class OpenMove: public MoveBase {
 
    public:
        OpenMove(Path &, ActionBase *, MTRand &, 
                ensemble _operateOnConfig=DIAGONAL, bool _varLength=true);
        ~OpenMove();
 
        bool attemptMove();
        static const string name;
        string getName() {return name;}
 
    private:
        beadLocator headBead, tailBead; // The temporary head and tail locatores
        int gapLength;                  // The proposed WL length to remove 
        int numLevels;                  // The 2^numLevels = num slices moved
 
        void undoMove();                // Undo a move
        void keepMove();                // keep the move
 
};
 
// ========================================================================  
// Close Move Class 
// ========================================================================  
class CloseMove: public MoveBase {
 
    public:
        CloseMove(Path &, ActionBase *, MTRand &, 
                ensemble _operateOnConfig=OFFDIAGONAL, bool _varLength=true);
        ~CloseMove();
 
        bool attemptMove();
        static const string name;
        string getName() {return name;}
 
    private:
        beadLocator headBead,tailBead;  // The temporary head and tail slices
        int numLevels;                      // The 2^numLevels = num slices moved
 
        Array <int,1> oldBeadOn;        // The old and new bead states
 
        void undoMove();                // Undo a move
        void keepMove();                // keep the move
};
 
// ========================================================================  
// Insert Move Class 
// ========================================================================  
class InsertMove: public MoveBase {
 
    public:
        InsertMove(Path &, ActionBase *, MTRand &, 
                ensemble _operateOnConfig=DIAGONAL, bool _varLength=true);
        ~InsertMove();
    
        bool attemptMove();
        static const string name;
        string getName() {return name;}
 
    private:
        beadLocator headBead,tailBead;  // The temporary head and tail beads
 
        int wormLength;                 // The proposed WL length to close
        int numLevels;                  // The 2^numLevels = num slices moved
 
        void undoMove();                // Undo a move
        void keepMove();                // keep the move
};
 
// ========================================================================  
// Remove Move Class 
// ========================================================================  
class RemoveMove: public MoveBase {
 
    public:
        RemoveMove(Path &, ActionBase *, MTRand &, 
                ensemble _operateOnConfig=OFFDIAGONAL, bool _varLength=true);
        ~RemoveMove();
 
        bool attemptMove();
        static const string name;
        string getName() {return name;}
 
    private:
        int numLevels;                  // The 2^numLevels = num slices moved
 
        void undoMove();                // Undo a move
        void keepMove();                // keep the move
};
 
// ========================================================================  
// Advance Head Move Class 
// ========================================================================  
class AdvanceHeadMove: public MoveBase {
 
    public:
        AdvanceHeadMove(Path &, ActionBase *, MTRand &, 
                ensemble _operateOnConfig=OFFDIAGONAL, bool _varLength=true);
        ~AdvanceHeadMove();
        
        bool attemptMove();
        static const string name;
        string getName() {return name;}
 
    private:
        beadLocator headBead;           // The temporary new head
 
        int advanceLength;              // The proposed WL length to advance
        int numLevels;                  // The 2^numLevels = num slices moved
 
        void undoMove();                // Undo a move
        void keepMove();                // keep the move
 
        beadLocator startBead;          
        Array <dVec,1> newPos;                  // The modified particle positions
        Array <unsigned int,1> oldBeadOn;       // The old and new bead states
 
};
 
// ========================================================================  
// Advance Tail Move Class 
// ========================================================================  
class AdvanceTailMove: public MoveBase {
 
    public:
        AdvanceTailMove(Path &, ActionBase *, MTRand &, 
                ensemble _operateOnConfig=OFFDIAGONAL, bool _varLength=true);
        ~AdvanceTailMove();
    
        bool attemptMove();
        static const string name;
        string getName() {return name;}
 
    private:
        beadLocator tailBead;           // The temporary new tail
 
        int advanceLength;              // The proposed WL length to advance
        int numLevels;                  // The 2^numLevels = num slices moved
 
        void undoMove();                // Undo a move
        void keepMove();                // keep the move
};
 
// ========================================================================  
// Recede Head Move Class 
// ========================================================================  
class RecedeHeadMove: public MoveBase {
 
    public:
        RecedeHeadMove(Path &, ActionBase *, MTRand &,
                ensemble _operateOnConfig=OFFDIAGONAL, bool _varLength=true);
        ~RecedeHeadMove();
    
        bool attemptMove();
        static const string name;
        string getName() {return name;}
 
    private:
        beadLocator headBead;           // The proposed new head position
        int recedeLength;               // The number of slices to recede by
        int numLevels;                  // The 2^numLevels = num slices moved
 
        void undoMove();                // Undo a move
        void keepMove();                // keep the move
};
 
// ========================================================================  
// Recede Tail Move Class 
// ========================================================================  
class RecedeTailMove: public MoveBase {
 
    public:
        RecedeTailMove(Path &, ActionBase *, MTRand &,
                ensemble _operateOnConfig=OFFDIAGONAL, bool _varLength=true);
        ~RecedeTailMove();
        
        bool attemptMove();
        static const string name;
        string getName() {return name;}
 
    private:
        beadLocator tailBead;           // The proposed new head position
        int recedeLength;               // The number of slices to recede by
        int numLevels;                  // The 2^numLevels = num slices moved
 
        void undoMove();                // Undo a move
        void keepMove();                // keep the move
};
 
// ========================================================================  
// Swap Move Base Class 
// ========================================================================  
class SwapMoveBase: public MoveBase {
 
    public:
        SwapMoveBase(Path &, ActionBase *, MTRand &, 
                ensemble _operateOnConfig=OFFDIAGONAL);
        ~SwapMoveBase();
 
    protected:
        int swapLength;                     
        int numLevels;                      
        unsigned int sizeCDF;               
 
        vector <double> cumulant;           
 
        beadLocator pivot;                  
        beadLocator swap;                   
 
        double SigmaSwap;                   
 
        /* Returns the normalization factor for the probability dist. */
        double getNorm(const beadLocator&, const int sign=1);
        
        /* Gets the bead where the swap will pivot. */
        beadLocator selectPivotBead();
 
        /* An overloaded version which also gets the winding sector */
        beadLocator selectPivotBead(iVec&);
};
 
// ========================================================================  
// Swap Head Move Class 
// ========================================================================  
class SwapHeadMove: public SwapMoveBase {
 
    public:
        SwapHeadMove(Path &, ActionBase *, MTRand &,
                ensemble _operateOnConfig=OFFDIAGONAL);
        ~SwapHeadMove();
 
        bool attemptMove();
        static const string name;
        string getName() {return name;}
 
    private:
 
        double SigmaHead;       // The probability normalization factor
        beadLocator nextSwap;   // Used for re-linking
 
        void undoMove();        // Undo a move
        void keepMove();        // keep the move
};
 
// ========================================================================  
// Swap Tail Move Class 
// ========================================================================  
class SwapTailMove: public SwapMoveBase {
 
    public:
        SwapTailMove(Path &, ActionBase *, MTRand &,
                ensemble _operateOnConfig=OFFDIAGONAL);
        ~SwapTailMove();
        
        bool attemptMove();
        static const string name;
        string getName() {return name;}
 
    private:
 
        double SigmaTail;               // The probability normalization factor
        beadLocator prevSwap;           // Used for re-linking
 
        void undoMove();                // Undo a move
        void keepMove();                // keep the move
};
 
#endif