path.h

Go to the documentation of this file.

 
#ifndef PATH_H 
#define PATH_H
 
#include "common.h"
#include "constants.h"
#include "container.h"
#include "worm.h"
 
class LookupTable;
 
// ========================================================================  
// Path Class
// ========================================================================  
class Path {
 
    public:
        Path (const Container *, LookupTable &, int, const Array<dVec,1>&, int numberBroken = 0);
        ~Path();
 
        /* Path* clone() const{ return new Path(*this); } */
 
        const int numTimeSlices;        
        int breakSlice;                 
        vector<int> brokenWorldlinesL;   
        vector<int> brokenWorldlinesR;   
        vector<int> closedWorldlines;   
 
        const Container *boxPtr;        
        Worm worm;                      
 
        LookupTable &lookup;            
 
        Array <int,1> numBeadsAtSlice;  
 
        int getNumParticles() const {return beads.extent(secondDim);}
 
        int getTrueNumParticles() const {return ( worm.getNumBeadsOn() / numTimeSlices );}
 
        const dVec& operator() (int slice, int ptcl) const { 
            PIMC_ASSERT(slice>=0 && slice < numTimeSlices);
            return beads(slice,ptcl); }
        dVec& operator() (int slice, int ptcl) { 
            PIMC_ASSERT(slice>=0 && slice < numTimeSlices);
            return beads(slice,ptcl); }
        const dVec& operator() (const beadLocator &beadIndex) const { 
            PIMC_ASSERT(beadIndex[0]>=0 && beadIndex[0]<numTimeSlices);
            return beads(beadIndex); }
        dVec& operator() (const beadLocator &beadIndex) { 
            PIMC_ASSERT(beadIndex[0]>=0 && beadIndex[0]<numTimeSlices);
            return beads(beadIndex); }
 
        dVec getVelocity(const beadLocator&) const;
 
        dVec getSeparation(const beadLocator&, const beadLocator&) const;
 
        template<class Tstream> void printLinks(Tstream &);
 
        void outputConfig(int) const;
 
        beadLocator& next(int slice, int ptcl) {return nextLink(slice,ptcl);}
        const beadLocator& next(int slice, int ptcl) const {return nextLink(slice,ptcl);}
        beadLocator& next(const beadLocator &beadIndex) {return nextLink(beadIndex);}
        const beadLocator& next(const beadLocator &beadIndex) const {return nextLink(beadIndex);}
 
        beadLocator& prev(int slice, int ptcl) {return prevLink(slice,ptcl);}
        const beadLocator& prev(int slice, int ptcl) const {return prevLink(slice,ptcl);}
        beadLocator& prev(const beadLocator &beadIndex) {return prevLink(beadIndex);}
        const beadLocator& prev(const beadLocator &beadIndex) const {return prevLink(beadIndex);}
 
        beadLocator next(int,int,int) const;        
        beadLocator next(const beadLocator&,int) const; 
 
        beadLocator prev(int,int,int) const;        
        beadLocator prev(const beadLocator&,int) const; 
 
        beadLocator addBead(const int, const dVec &);
        beadLocator addNextBead(const beadLocator&, const dVec &);
        beadLocator addPrevBead(const beadLocator&, const dVec &);
 
        void delBead(const beadLocator&);
        beadLocator delBeadGetNext(const beadLocator&);
        beadLocator delBeadGetPrev(const beadLocator&);
    
        void breakLink(const beadLocator&);
        void makeLink(const beadLocator&,const beadLocator&);
        void removeCenterLink(const beadLocator&);
        void addCenterLink(const beadLocator&,const beadLocator&);
        bool isBroken(const beadLocator&) const;
        double breakFactor(const beadLocator&,const beadLocator&) const;
        bool inSubregionA(const beadLocator&) const;
        bool inSubregionB(const beadLocator&) const;
        bool checkSubregionLinks() const;
 
        void updateBead(const beadLocator&, const dVec&);
 
        void printWormConfig(Array <beadLocator,1> &);
 
        void leftPack();
    
        void resetBrokenClosedVecs();
 
    private:
        friend class PathIntegralMonteCarlo;        // Friends for I/O
 
        Array<dVec,2> beads;                        // The wordline array
        Array<beadLocator,2> prevLink, nextLink;    // Bead connection matrices
 
        beadLocator lastBeadIndex;                  // Holds the index of the last bead on a slice
};
 
/* inline Path* new_clone(Path const& other){ */
/*     return other.clone(); */
/* } */
 
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
// INLINE FUNCTION DEFINITIONS
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
inline dVec Path::getSeparation(const beadLocator &bead1, const beadLocator &bead2) const {
    dVec sep;
    sep = (*this)(bead1) - (*this)(bead2);
    boxPtr->putInBC(sep);
    return sep;
}
 
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
inline dVec Path::getVelocity (const beadLocator &beadIndex) const {
    dVec vel;
 
    if (all(beadIndex==XXX) || all(next(beadIndex)==XXX)) {
        vel = 0.0;
        return (vel);
    }
 
    /* Calculate the 'velocity' and implement periodic boundary conditions */
    vel = beads(next(beadIndex)) - beads(beadIndex);
    boxPtr->putInBC(vel);
 
    return (vel);
}
 
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
inline beadLocator Path::next(int slice, int ptcl, int numLinks) const {
    PIMC_ASSERT(slice>=0 && slice<numTimeSlices && ptcl>=0);
    beadLocator bI;
    bI = slice,ptcl;
    for (int m = 0; m < numLinks; m++)
        bI = next(bI);
    return bI;
}
 
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
inline beadLocator Path::next(const beadLocator &beadIndex, int numLinks) const {
    PIMC_ASSERT(beadIndex[0]>=0 && beadIndex[0]<numTimeSlices && beadIndex[1]>=0);
    beadLocator bI;
    bI = beadIndex;
    for (int m = 0; m < numLinks; m++)
        bI = next(bI);
    return bI;
}
 
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
inline beadLocator Path::prev(int slice, int ptcl, int numLinks) const {
    PIMC_ASSERT(slice>=0 && slice<numTimeSlices && ptcl>=0);
    beadLocator bI;
    bI = slice,ptcl;
    for (int m = 0; m < numLinks; m++)
        bI = prev(bI);
    return bI;
}
 
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
inline beadLocator Path::prev(const beadLocator &beadIndex, int numLinks) const {
    PIMC_ASSERT(beadIndex[0]>=0 && beadIndex[0]<numTimeSlices && beadIndex[1]>=0);
    beadLocator bI;
    bI = beadIndex;
    for (int m = 0; m < numLinks; m++)
        bI = prev(bI);
    return bI;
}
 
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
template<class Tstream>
void Path::printLinks(Tstream &outStream) {
    int numParticles = getNumParticles();
    for (int m = numTimeSlices-1; m >= 0; m--) {
        beadLocator beadIndex;
        for (int n = 0; n < numParticles; n++) {
            beadIndex = m,n;
            outStream << setw(2) << prevLink(beadIndex)[1] << " ";
        }
                        
        outStream << "\t";
        for (int n = 0; n < numParticles; n++) { 
            beadIndex = m,n;
            outStream << setw(2) << nextLink(beadIndex)[1] << " ";
        }
        outStream << endl;
    }
    outStream << endl;
}
 
#endif