worm.h

Go to the documentation of this file.

 
#ifndef WORM_H 
#define WORM_H
 
#include "common.h"
#include "constants.h"
 
class Path;
// ========================================================================  
// Worm Class
// ========================================================================  
class Worm {
 
    public:
        Worm(int);
        ~Worm();
 
        beadLocator head;           
        beadLocator tail;           
        beadLocator special1;       
        beadLocator special2;       
        double maxWormCost;         
        dVec sep;                   
        int length;                 
        int gap;                    
        bool isConfigDiagonal;      
 
        /* Safe get methods for beads */
        inline int beadOn(int,int) const;
        inline int beadOn(const beadLocator&) const;
 
        /* Get the state of a bead */
        beadState getState (const beadLocator &) const;
 
        /* The worm-trajectory factor for interactions and external potentials*/
        double factor(const beadState, const beadLocator&) const;
        double factor(const beadState state1) const { return 1.0 - 0.5*(state1 != NONE);};
 
        /* Safely add/delete beads */
        inline void delBead(int,int);
        inline void addBead(int,int);
        inline void delBead(const beadLocator&);
        inline void addBead(const beadLocator&);
 
        /* Reset all worm parameters to null */
        void reset();                           
 
        /* Update all worm parameters */
        void update(Path &, const beadLocator &, const beadLocator &);
 
        /* Determine if a given beadLocator is on a worm */
        bool foundBead(const Path &, const beadLocator &);
 
        inline bool tooCostly() { 
            if (gap == 0) 
                return true;
            else
                return ((dot(sep,sep) * constants()->fourLambdaTauInv() / (1.0*gap)) > maxWormCost);
        }
        inline bool tooCostly(const dVec& _sep, int _gap) { 
            if (_gap == 0) 
                return true;
            else {
                return ((dot(_sep,_sep) * constants()->fourLambdaTauInv() / (1.0*_gap)) > maxWormCost);
            }
        }
 
        const Array <unsigned int, 2> & getBeads() const { return beads; }
 
        /* Test whether a given bead is on a worm */
        int getNumBeadsOn() const {return numBeadsOn;}
        void incNumBeadsOn() {++numBeadsOn;}
        void decNumBeadsOn() {--numBeadsOn;}
        void resetNumBeadsOn() {numBeadsOn = sum(beads);}
 
        friend class Path;                      // Path needs access to beads
        friend class PathIntegralMonteCarlo;    // Friends for I/O
 
    private:
        Array <unsigned int,2> beads;           // Is a bead present?
        int numBeadsOn;                         // How many beads are present
};
 
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
// INLINE FUNCTION DEFINITIONS
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
inline beadState Worm::getState(const beadLocator &beadIndex) const {
    if (all(beadIndex==head) || all(beadIndex==tail))
        return HEADTAIL;
    else if (all(beadIndex==special1) || all(beadIndex==special2))
        return SPECIAL;
    else
        return NONE;
}
 
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
inline void Worm::delBead(int slice, int ptcl) {
    PIMC_ASSERT((slice >= 0) && (slice < constants()->numTimeSlices()));
    beads(slice,ptcl) = 0;
}
 
inline void Worm::delBead(const beadLocator &beadIndex) {
    PIMC_ASSERT((beadIndex[0] >= 0) && (beadIndex[0] < constants()->numTimeSlices()));
    beads(beadIndex) = 0;
}
 
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
inline void Worm::addBead(int slice, int ptcl) {
    PIMC_ASSERT((slice >= 0) && (slice < constants()->numTimeSlices()));
    beads(slice,ptcl) = 1;
}
 
inline void Worm::addBead(const beadLocator &beadIndex) {
    PIMC_ASSERT((beadIndex[0] >= 0) && (beadIndex[0] < constants()->numTimeSlices()));
    beads(beadIndex) = 1;
}
 
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
inline int Worm::beadOn(int slice, int ptcl) const {
    PIMC_ASSERT((slice >=0) && (slice < constants()->numTimeSlices()));
    return beads(slice,ptcl);
}
 
inline int Worm::beadOn(const beadLocator &beadIndex) const {
    return beads(beadIndex);
}
 
#endif