ActionBase Class Reference

Holds a base class that all action classes will be derived from. More...

#include <action.h>

Inheritance diagram for ActionBase:

Collaboration diagram for ActionBase:

Public Member Functions
	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 ()
	The effective potential inter-ACTION for various pass conditions.
virtual double	potentialAction (const beadLocator &, const beadLocator &)
	Return the potential action for a path. More...
virtual double	potentialAction (const beadLocator &)
virtual double	barePotentialAction (const beadLocator &)
virtual double	potentialActionCorrection (const beadLocator &)
virtual double	potentialActionCorrection (const beadLocator &, const beadLocator &)
virtual double	derivPotentialActionTau (int)
virtual double	derivPotentialActionLambda (int)
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 TinyVector< double, 2 >	potential (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...

Data Fields
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 Member Functions
double	tau ()
	The local shifted value of tau.
void	updateSepHist (const dVec &)
	Update the separation histogram. More...

Protected Attributes
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

Holds a base class that all action classes will be derived from.

Implements the details of the action, including the potential and kinetic pieces. Two types of actions, local and non-local derive from this base class and the actually used actions then derive from these.

Definition at line 29 of file action.h.

Member Function Documentation

ensembleWeight()

double ActionBase::ensembleWeight

(

const int

deltaNumBeads

)

The ensemble particle number weighting factor.

The ensemble weighting factor.

For the grand canonical ensemble we return 1, for the canonical ensemble we return exp(-[(nb'-nb_0)^2 - (nb-nb_0)^2]/dN^2) where nb = number of beads

Definition at line 122 of file action.cpp.

                                                         {
    
    // ensembleWieght returns 1.0 unless window or ensemble weight is used
    if ( window || gaussianEnsemble ){
        int numBeads = path.worm.getNumBeadsOn();
        int numBeadsP = numBeads + deltaNumBeads;
        
        // Check if we are within bead window
        if (window){
            int beadWindowWidth = path.numTimeSlices*windowWidth;
            if ( ( numBeadsP > (numBeads0+beadWindowWidth) )||
                (numBeadsP < (numBeads0-beadWindowWidth)) )
                return 0.0;
        }
        // If we are within window check gaussian weight
        if (gaussianEnsemble){
            double sigmaBeads = path.numTimeSlices*gaussianEnsembleSD;
            double xp = 1.0*(numBeadsP-numBeads0)*(numBeadsP-numBeads0)/
                                (2.0*sigmaBeads*sigmaBeads);
            double x = 1.0*(numBeads-numBeads0)*(numBeads-numBeads0)/
                                (2.0*sigmaBeads*sigmaBeads);
            return exp(-xp+x);
        } 
        else
            return 1.0;
    } 
    else
        return 1.0; // Return 1.0 if no enembleWeight is used
    
}

Here is the call graph for this function:

Here is the caller graph for this function:

kineticAction() [1/3]

double ActionBase::kineticAction

(

)

The full kinetic Action

Return the total kinetic action.

The total kinetic action evaluated for all particles and all time slices.

Definition at line 205 of file action.cpp.

                                  {
 
    double totK = 0.0;
 
    /* Calculate the kinetic energy.  Even though there
     * may be multiple mixing and swaps, it doesn't matter as we always
     * just advance one time step at a time, as taken care of through the
     * linking arrays.  This has been checked! */
    beadLocator beadIndex;
    for (int slice = 0; slice < path.numTimeSlices; slice++) {
        for (int ptcl = 0; ptcl < path.numBeadsAtSlice(slice); ptcl++) {
            beadIndex = slice,ptcl;
            totK += kineticAction(beadIndex);
        }
    }
 
    return totK;
}

Here is the caller graph for this function:

kineticAction() [2/3]

double ActionBase::kineticAction

(

const beadLocator &

beadIndex

)

The kinetic Action at a single slice

Return the kinetic action for a single bead.

The kinetic action involves two contributions as each bead is linked to two other ones at the next and previous time slice.

Definition at line 159 of file action.cpp.

                                                              {
 
    double totK = 0.0;
    /* We get the Kinetic action for a single slice, which connects
     * to two other slices */
    dVec vel;
    vel = path.getVelocity(path.prev(beadIndex));
    totK += dot(vel,vel);
    vel = path.getVelocity(beadIndex);
    totK += dot(vel,vel);
 
    return totK / (4.0*constants()->lambda()*tau());
}

Here is the call graph for this function:

kineticAction() [3/3]

double ActionBase::kineticAction	(	const beadLocator &	beadIndex,
		int	wlLength
	)

The kinetic Action for wlLength slices.

Return the kinetic action for wlLength time slices starting at the bead given by beadIndex.

The total kinetic action for a string of connected beads all on the same worldline.

Definition at line 180 of file action.cpp.

                                                                            {
 
    double totK = 0.0;
 
    /* Make a local copy of beadIndex */
    beadLocator beadID;
    beadID = beadIndex;
 
    /* Starting from the initial bead, move wlLength slices in imaginary time
     * and accumulate the kinetic action */
    dVec vel;
    for (int n = 0; n < wlLength; n++) {
        vel = path.getVelocity(beadID);
        totK += dot(vel, vel);
        beadID = path.next(beadID);
    } 
 
    return totK / (4.0*constants()->lambda()*tau());
}

Here is the call graph for this function:

potentialAction()

double ActionBase::potentialAction ( const beadLocator &  startBead, const beadLocator &  endBead  )

virtual

Return the potential action for a path.

Given a starting and ending bead, compute the potential action for the path.

NOTE: if startBead == endBead this returns potentialAction(startBead) I'm not sure if this is the desired behavior yet.

Parameters

startBead	the starting bead
endBead	the end bead on the path

Returns

the total potential action for a given path

Definition at line 237 of file action.cpp.

                                    {
 
    double totU = 0.0;
    beadLocator beadIndex;
    beadIndex = startBead;
    do {
        totU += potentialAction(beadIndex);
        beadIndex = path.next(beadIndex);
    } while (!all(beadIndex==path.next(endBead)));
    return totU;
}

Here is the call graph for this function:

rho0() [1/2]

double ActionBase::rho0	(	const dVec &	r1,
		const dVec &	r2,
		int	M
	)

The free-particle density matrix.

The free-particle density matrix for two particles with imaginary time separation M.

Definition at line 83 of file action.cpp.

                                                             {
    dVec vel;
    vel = r2 - r1;
    path.boxPtr->putInBC(vel);
    double rho0Norm = pow(4.0*M_PI*constants()->lambda()*M*constants()->tau(),-0.5*NDIM);
    return ( rho0Norm * exp(-dot(vel,vel) / (4.0*constants()->lambda()*M*constants()->tau()) ) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

rho0() [2/2]

double ActionBase::rho0	(	const dVec &	vel,
		const int	M
	)

The free-particle density matrix for a given spatial and temporal separation.

Parameters

vel	The spatial separtion R - R'
M	The imaginary time separation

Returns

The free density matrix

Definition at line 110 of file action.cpp.

                                                    {
    double rho0Norm = pow(4.0*M_PI*constants()->lambda()*M*constants()->tau(),-0.5*NDIM);
    return ( rho0Norm * exp(-dot(vel,vel) / (4.0*constants()->lambda()*M*constants()->tau()) ) );
}

Here is the call graph for this function:

updateSepHist()

void ActionBase::updateSepHist ( const dVec &  _sep )

inlineprotected

Update the separation histogram.

We multiply by the periodic array, as we will only measure separations along spatial dimensions with periodic boundary conditions.

Definition at line 71 of file action.cpp.

                                                      {
    dVec psep;
    psep = path.boxPtr->periodic*_sep;
    int nR = int(sqrt(dot(psep,psep))/dSep);
    if (nR < NPCFSEP)
        ++sepHist(nR);
}

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