NonLocalAction Class Reference

A base class to be inherited by actions that are non-local in imaginary time. More...

#include <action.h>

Inheritance diagram for NonLocalAction:

Collaboration diagram for NonLocalAction:

Public Member Functions
	NonLocalAction (const Path &, LookupTable &, PotentialBase *, PotentialBase *, WaveFunctionBase *, bool _local=false, string _name="Non-local")
	Setup the path data members for non-local actions.
virtual	~NonLocalAction ()
	Empty constructor.
double	potentialAction ()
	Return the potential action for all time slices and all particles. More...
double	potentialAction (const beadLocator &)
	Return the potential action for a single bead indexed with beadIndex. More...
double	derivPotentialActionTau (int)
	The derivative of the potential action wrt tau on all links starting on slice. More...
double	derivPotentialActionLambda (int)
	The derivative of the potential action wrt lambda on all links starting on slice. More...
virtual TinyVector< double, 2 >	potential (int slice)
Public Member Functions inherited from ActionBase
	ActionBase (const Path &, LookupTable &, PotentialBase *, PotentialBase *, WaveFunctionBase *, bool _local=true, string _name="Base", double _endFactor=1.0, int _period=1)
	Setup the path data members and canonical re-weighting factors.
virtual	~ActionBase ()
	Empty base constructor.
string	getActionName ()
	Returns the action name.
double	kineticAction ()
	The full kinetic Action More...
double	kineticAction (const beadLocator &)
	The kinetic Action at a single slice More...
double	kineticAction (const beadLocator &, int wlLength)
	The kinetic Action for wlLength slices. More...
virtual double	potentialAction (const beadLocator &, const beadLocator &)
	Return the potential action for a path. More...
virtual double	barePotentialAction (const beadLocator &)
virtual double	potentialActionCorrection (const beadLocator &)
virtual double	potentialActionCorrection (const beadLocator &, const beadLocator &)
virtual double	secondderivPotentialActionTau (int)
virtual double	derivPotentialActionTau (int, double)
virtual double	derivPotentialActionLambda (int, double)
virtual dVec	gradPotentialAction (int)
virtual double	rDOTgradUterm1 (int)
virtual double	rDOTgradUterm2 (int)
virtual double	deltaDOTgradUterm1 (int)
virtual double	deltaDOTgradUterm2 (int)
virtual double	virKinCorr (int)
virtual double	potential (int, double)
void	setShift (int _shift)
	The public method that sets the tau scaling factor.
int	getShift ()
	Get the tau scaling factor.
double	rho0 (const dVec &, const dVec &, int)
	The free-particle density matrix. More...
double	rho0 (const beadLocator &, const beadLocator &, int)
	The free-particle density matrix for two beadLocators with imaginary time separation M.
double	rho0 (const dVec &, const int)
	The free-particle density matrix for a given spatial and temporal separation. More...
double	ensembleWeight (const int)
	The ensemble particle number weighting factor. More...

Protected Member Functions
TinyVector< double, 2 >	U (int)
	Return the potential action for all time slices and all particles. More...
Protected Member Functions inherited from ActionBase
double	tau ()
	The local shifted value of tau.
void	updateSepHist (const dVec &)
	Update the separation histogram. More...

Additional Inherited Members
Data Fields inherited from ActionBase
const bool	local
	Is the action local in imaginary time?
const int	period
PotentialBase *	externalPtr
	The external potential.
PotentialBase *	interactionPtr
	The interaction potential.
Array< int, 1 >	sepHist
	A histogram of separations.
Array< int, 1 >	cylSepHist
	A histogram of separations for a cylinder.
Protected Attributes inherited from ActionBase
string	name
	The name of the action.
LookupTable &	lookup
	We need a non-constant reference for updates.
const Path &	path
	A reference to the paths.
WaveFunctionBase *	waveFunctionPtr
	A pointer to a trial wave function object.
double	endFactor
	Mutiplictive factor of the potential action on ends.
int	shift
	The scaling factor for tau.
bool	canonical
	Are we in the canonical ensemble?
int	numBeads0
	The target number of beads.
bool	window
int	windowWidth
bool	gaussianEnsemble
double	gaussianEnsembleSD
beadLocator	bead2
beadLocator	bead3
dVec	sep
dVec	sep2
double	dSep

Detailed Description

A base class to be inherited by actions that are non-local in imaginary time.

See also

Section IV.F in D. M. Ceperley, Rev. Mod. Phys. 67, 279–355 (1995).

Definition at line 257 of file action.h.

Member Function Documentation

derivPotentialActionLambda()

double NonLocalAction::derivPotentialActionLambda ( int  slice )

virtual

The derivative of the potential action wrt lambda on all links starting on slice.

It is essential to have these slice overloaded values as we need to be careful of the factor of 1/2 or i<j in the full potential action.

Parameters

slice

the imaginary timeslice of the first link

Reimplemented from ActionBase.

Definition at line 1709 of file action.cpp.

                                                            {
 
    double totU = 0.0;
 
    beadLocator bead1;
    bead1[0] = bead2[0] = slice;
 
    beadLocator nextBead1,nextBead2;
 
    int numParticles = path.numBeadsAtSlice(slice);
 
    /* Calculate the total potential, including external and interaction
     * effects*/
    for (bead1[1] = 0; bead1[1] < numParticles; bead1[1]++) {
 
        /* Get the advanced neightbor of bead1 */
        nextBead1 = path.next(bead1);
 
        for (bead2[1] = bead1[1]+1; bead2[1] < numParticles; bead2[1]++) {
            sep = path.getSeparation(bead1,bead2);
 
            /* Get the advanced neighbor of the second bead */
            nextBead2 = path.next(bead2);
 
            sep2 = path.getSeparation(nextBead1,nextBead2);
            totU += interactionPtr->dVdlambda(sep,sep2);
        } // bead2
 
    } // bead1
    return ( totU );
}

Here is the call graph for this function:

derivPotentialActionTau()

double NonLocalAction::derivPotentialActionTau ( int  slice )

virtual

The derivative of the potential action wrt tau on all links starting on slice.

It is essential to have these slice overloaded values as we need to be careful of the factor of 1/2 or i<j in the full potential action.

Parameters

slice

the imaginary timeslice of the first link

Reimplemented from ActionBase.

Definition at line 1664 of file action.cpp.

                                                         {
 
    double totU = 0.0;
 
    beadLocator bead1;
    bead1[0] = bead2[0] = slice;
 
    beadLocator nextBead1,nextBead2;
 
    int numParticles = path.numBeadsAtSlice(slice);
 
    /* Initialize the separation histogram */
    sepHist = 0;
 
    /* Calculate the total potential, including external and interaction
     * effects*/
    for (bead1[1] = 0; bead1[1] < numParticles; bead1[1]++) {
 
        /* Get the advanced neightbor of bead1 */
        nextBead1 = path.next(bead1);
 
        for (bead2[1] = bead1[1]+1; bead2[1] < numParticles; bead2[1]++) {
            sep = path.getSeparation(bead1,bead2);
            updateSepHist(sep);
 
            /* Get the advanced neighbor of the second bead */
            nextBead2 = path.next(bead2);
 
            sep2 = path.getSeparation(nextBead1,nextBead2);
            totU += interactionPtr->dVdtau(sep,sep2);
        } // bead2
 
    } // bead1
    return ( totU );
}

Here is the call graph for this function:

potentialAction() [1/2]

double NonLocalAction::potentialAction ( )

virtual

Return the potential action for all time slices and all particles.

Computes the total potential energy by summing over all particles and time slices. We must be very careful with the factor of 1/2 or the fact that the sum is over i<j for particles to avoid double counting.

Reimplemented from ActionBase.

Definition at line 1514 of file action.cpp.

                                        {
 
    double totU = 0.0;
    for (int slice = 0; slice < path.numTimeSlices; slice++) 
        totU += sum(U(slice));
 
    return ( totU );
}

Here is the call graph for this function:

potentialAction() [2/2]

double NonLocalAction::potentialAction ( const beadLocator &  bead1 )

virtual

Return the potential action for a single bead indexed with beadIndex.

Parameters

beadIndex

the bead to compute the advanced link action for.

Reimplemented from ActionBase.

Definition at line 1528 of file action.cpp.

                                                                {
 
    /* We only need to calculate the potential action if the two neighboring
     * beads are on */
    if (!path.worm.beadOn(bead1))
        return 0.0;
   
    /* Since the non-local action lives on a link, both bead1 and nextBead1
     * must exist */
    beadLocator nextBead1,nextBead2;
    nextBead1 = path.next(bead1);
 
    double totU = 0.0;
 
#if PIGS
    /* We tack on a trial wave function and boundary piece if necessary */
    if ( (bead1[0] == 0) || (bead1[0] == (constants()->numTimeSlices()-1)) ) 
            totU -= log(waveFunctionPtr->PsiTrial(bead1));
#endif
 
    /* Make sure nextBead1 is a real bead and that it is active */
    if ( (all(nextBead1==XXX)) || (!path.worm.beadOn(nextBead1)) )
        return totU;
 
    /* Evaluate the external potential */
    double totVext = externalPtr->V(path(bead1))+externalPtr->V(path(nextBead1));
 
    /* Get the interaction list */
    lookup.updateInteractionList(path,bead1);
    for (int n = 0; n < lookup.numBeads; n++) {
        bead2 = lookup.beadList(n);
        if(!all(path.next(bead2)==XXX))
            NNbead[bead2[1]] = true;
    }
    
    /* Get the next interaction list */
    lookup.updateInteractionList(path,nextBead1);
    for (int n = 0; n < lookup.numBeads; n++) {
        bead2 = path.prev(lookup.beadList(n));
        if(!all(bead2==XXX))
           NNbead[bead2[1]] = true;
    }
    
    bead2[0] = bead1[0];
    for (bead2[1]= 0; bead2[1] < path.numBeadsAtSlice(bead1[0]); bead2[1]++) {
        if(NNbead[bead2[1]]){
            nextBead2 = path.next(bead2);
            sep = path.getSeparation(bead1,bead2);
            sep2 = path.getSeparation(nextBead1,nextBead2);
            totU += interactionPtr->V(sep,sep2);
            NNbead[bead2[1]] = false;
        }
    }
    
    double totUext = tau()*totVext/(2.0);
 
    /* bead2[0] = bead1[0]; */ 
    
    /* /1* Now calculate the total effective interation potential, neglecting self-interactions *1/ */
    /* for (bead2[1]= 0; bead2[1] < path.numBeadsAtSlice(bead1[0]); bead2[1]++) { */
        
    /*     /1* Skip self interactions *1/ */
    /*     if ( bead2[1] != bead1[1] ) { */
            
    /*         /1* get the separation between the two particles at the first time */
    /*          * slice *1/ */
    /*         sep = path.getSeparation(bead1,bead2); */
            
    /*         /1* Now we find the separation at the advanced time step *1/ */
    /*         nextBead2 = path.next(bead2); */
            
    /*         /1* If the imaginary time neighbor exists, compute the effective */
    /*          * potential *1/ */
    /*         if ( (!all(nextBead2==XXX)) && (path.worm.beadOn(nextBead2)) ) { */
    /*             sep2 = path.getSeparation(nextBead1,nextBead2); */
    /*             totU += interactionPtr->V(sep,sep2,constants()->lambda(),constants()->tau()); */
    /*         } */
    /*     } // bead2 != bead1 */
        
        
    /* } // for bead2 */
    
    return (totU + totUext);
}

Here is the call graph for this function:

U()

TinyVector< double, 2 > NonLocalAction::U ( int  slice )

protected

Return the potential action for all time slices and all particles.

Computes the total potential energy by summing over all particles and time slices.

Definition at line 1619 of file action.cpp.

                                                {
 
    double totUint = 0.0;
    double totUext = 0.0;
 
    beadLocator bead1;
    bead1[0] = bead2[0] = slice;
 
    beadLocator nextBead1,nextBead2;
 
    int numParticles = path.numBeadsAtSlice(slice);
 
    /* Initialize the separation histogram */
    sepHist = 0;
 
    /* Calculate the total potential, including external and interaction
     * effects*/
    for (bead1[1] = 0; bead1[1] < numParticles; bead1[1]++) {
 
        /* Get the advanced neightbor of bead1 */
        nextBead1 = path.next(bead1);
 
        for (bead2[1] = bead1[1]+1; bead2[1] < numParticles; bead2[1]++) {
            sep = path.getSeparation(bead1,bead2);
 
            /* Get the advanced neighbor of the second bead */
            nextBead2 = path.next(bead2);
 
            sep2 = path.getSeparation(nextBead1,nextBead2);
            totUint += interactionPtr->V(sep,sep2);
        } // bead2
 
    } // bead1
    return TinyVector<double,2>(totUext,totUint);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• include/action.h
• src/action.cpp