SwapMoveBase Class Reference

A derived class which forms the base of a swap head and swap tail move class. More...

#include <move.h>

Inheritance diagram for SwapMoveBase:

Collaboration diagram for SwapMoveBase:

Public Member Functions
	SwapMoveBase (Path &, ActionBase *, MTRand &, ensemble _operateOnConfig=OFFDIAGONAL)
	Constructor.
	~SwapMoveBase ()
	Destructor.
Public Member Functions inherited from MoveBase
	MoveBase (Path &, ActionBase *, MTRand &, ensemble _operateOnConfig=ANY, bool _varLength=false)
	Move naming conventions: More...
virtual	~MoveBase ()
	Destructor.
virtual string	getName ()
	return the move name
double	getAcceptanceRatio ()
	Get the acceptance ratio.
double	getTotAcceptanceRatio ()
	Get the total acceptance ratio.
double	getAcceptanceRatioLevel (int n)
	Get the acceptance ratio by level.
int	getNumAttempted ()
	Get the number of moves attempted.
int	getNumAccepted ()
	Get the number of moves accepted.
int	getNumAttemptedLevel (int n)
	Get the number of moves attempted by level.
int	getNumAcceptedLevel (int n)
	Get the number of moves accepted by level.
virtual bool	attemptMove ()=0
	Attempt the move (will be overloaded).
void	resetTotAccept ()
	Reset the total accepted counter.
void	resetAccept ()
	Reset the number accepted counter.

Protected Member Functions
double	getNorm (const beadLocator &, const int sign=1)
	Get the normalization constant for a swap move. More...
beadLocator	selectPivotBead ()
	Select the pivot bead for a swap move. More...
beadLocator	selectPivotBead (iVec &)
	‍*************************************************************************‍//‍** More...
Protected Member Functions inherited from MoveBase
virtual void	keepMove ()
	Keep the move. More...
virtual void	undoMove ()=0
	undo the move
dVec	newStagingPosition (const beadLocator &, const beadLocator &, const int, const int)
	Returns a new staging position which will exactly sample the kinetic action. More...
dVec	newStagingPosition (const beadLocator &, const beadLocator &, const int, const int, iVec &)
	Returns a new staging position which will exactly sample the kinetic action in different winding sectors. More...
iVec	sampleWindingSector (const beadLocator &, const beadLocator &, const int, double &)
	Obtain a winding sector for a stage-like move. More...
iVec	getWindingNumber (const beadLocator &, const beadLocator &)
	Find the winding number for a path between two beads. More...
dVec	newFreeParticlePosition (const beadLocator &)
	Generates a new position, which exactly samples the free particle density matrix. More...
dVec	newBisectionPosition (const beadLocator &, const int)
	Returns a new bisection position which will exactly sample the kinetic action. More...
void	printMoveState (string)
void	checkMove (int, double)

Protected Attributes
int	swapLength
	The length of worldLine to be moved.
int	numLevels
	The number of bisection levels.
unsigned int	sizeCDF
	The size of the cumulative distribution function.
vector< double >	cumulant
	The cumulant array used in selecting a pivot.
beadLocator	pivot
	The pivot bead.
beadLocator	swap
	The swap bead.
double	SigmaSwap
	Probability normalization factor.
Protected Attributes inherited from MoveBase
Path &	path
	A reference to the paths.
ActionBase *	actionPtr
	A base pointer to the action.
MTRand &	random
	A reference to the RNG.
bool	success
	Did we sucessfully perform a move?
uint32	numAccepted
	The number of accepted moves.
uint32	numAttempted
	The number of attempted moves.
int	numToMove
	The number of particles moved.
int	numLevels
Array< uint32, 1 >	numAcceptedLevel
	The number of moves accepted at each level.
Array< uint32, 1 >	numAttemptedLevel
	The number of moves attempted at each level.
Array< dVec, 1 >	originalPos
	The original particle positions.
Array< dVec, 1 >	newPos
	New particle positions.
vector< iVec >	winding
	The winding vectors
vector< int >	windingSector
	Used to index different winding sectors.
vector< double >	cumrho0
	Used for tower-sampling winding sectors.
int	maxWind
	The largest winding number.
int	numWind
	The total number of winding vectors.
double	oldAction
	The original potential action.
double	newAction
	The new potential action.
double	deltaAction
	The action difference.
double	sqrt2LambdaTau
	sqrt(2 * Lambda * tau)
double	sqrtLambdaTau
	sqrt(Lambda * tau)
beadLocator	nBeadIndex
	Neighbor bead index.
dVec	neighborPos
	Staging neighbor position.
dVec	newRanPos
	Staing random position.
double	newK
double	oldK
	The old and new kinetic action.
double	newV
double	oldV
	The old and new potential action.

Additional Inherited Members
Data Fields inherited from MoveBase
ensemble	operateOnConfig
	What configurations do we operate on?
bool	variableLength
	Does the move have a variable length?
string	name1
Static Protected Attributes inherited from MoveBase
static uint32	totAccepted = 0
	The total number of moves accepted.
static uint32	totAttempted = 0
	The total number of moves attempted.

Detailed Description

A derived class which forms the base of a swap head and swap tail move class.

Definition at line 554 of file move.h.

Member Function Documentation

getNorm()

double SwapMoveBase::getNorm ( const beadLocator &  beadIndex, const int  sign = 1  )

protected

Get the normalization constant for a swap move.

We compute the normalization constant used in both the pivot selection probability as well as the overall acceptance probabilty.

See also

Eq. (2.23) of PRE 74, 036701 (2006).

Parameters

sign	corrects for always measuring distances forward in imaginary time

Definition at line 3141 of file move.cpp.

                                                                         {
 
    double Sigma = 0.0;
    double crho0;
    dVec sep;
    int index = 0;
 
    sizeCDF = path.lookup.fullNumBeads*numWind;
 
    /* Check if we need to resisize our cumulative distribution funciton */
     if (cumulant.size() < sizeCDF)
         cumulant.assign(sizeCDF,0.0);
 
    /* For each particle, we find the free particle weight for all winding
     * sectors.  We start with W = 0. */
 
    /* We sum up the free particle density matrices for each bead
     * in the list */
    sep = path(path.lookup.fullBeadList(0)) - path(beadIndex);
    Sigma = actionPtr->rho0(sep,swapLength);
    cumulant.at(index) = Sigma;
    ++index;
    for (int n = 1; n < path.lookup.fullNumBeads; n++) {
        sep = path(path.lookup.fullBeadList(n)) - path(beadIndex);
        crho0 = actionPtr->rho0(sep,swapLength);
        Sigma += crho0;
        cumulant.at(index) = cumulant.at(index-1) + crho0;
        ++index;
    }
 
    /* Now we repeat for all winding sectors */
    for (int w = 1; w < numWind; w++) {
 
        /* Go through every particle in the lookup table. */
        for (int n = 0; n < path.lookup.fullNumBeads; n++) {
            sep = path(path.lookup.fullBeadList(n)) - path(beadIndex) 
                + sign*winding.at(w)*path.boxPtr->side;
            crho0 = actionPtr->rho0(sep,swapLength);
            Sigma += crho0;
            cumulant.at(index) = cumulant.at(index-1) + crho0;
            ++index;
        }
    }
 
    /* Normalize the cumulant */
    for (unsigned int n = 0; n < sizeCDF; n++) 
        cumulant.at(n) /= Sigma;
 
    return Sigma;
}

Here is the call graph for this function:

Here is the caller graph for this function:

selectPivotBead() [1/2]

beadLocator SwapMoveBase::selectPivotBead ( )

protected

Select the pivot bead for a swap move.

Here we select a pivot bead from a list with the probability given by Eq. (2.22) of PRE 74, 036701 (2006). We use the trick in Ceperly's lecture notes where we evaluate the cumulative distribution function then generate a uniform random variable and find where it lies in the ordered CDF list.

Definition at line 3269 of file move.cpp.

                                          {
    
    /* Generate a uniform deviate, and figure out where it fits in our cumulant
     * array using a binary search.  This is basic tower sampling */
    int index = std::lower_bound(cumulant.begin(),cumulant.end(),random.rand()) 
        - cumulant.begin();
 
    /* Copy over the pivot bead and return it */
    beadLocator pivotBead;
    pivotBead = path.lookup.fullBeadList(index);
    
    return pivotBead;
}

Here is the caller graph for this function:

selectPivotBead() [2/2]

beadLocator SwapMoveBase::selectPivotBead ( iVec &  wind )

protected

‍*************************************************************************‍//‍**

Select the pivot bead for a swap move.

Here we select a pivot bead from a list with the probability given by Eq. (2.22) of PRE 74, 036701 (2006). We use the trick in Ceperly's lecture notes where we evaluate the cumulative distribution function then generate a uniform random variable and find where it lies in the ordered CDF list.

Parameters

wind	the chosen winding number sector.

Definition at line 3233 of file move.cpp.

                                                    {
    
    /* Generate a uniform deviate, and figure out where it fits in our cumulant
     * array using a binary search.  This is basic tower sampling */
 
    double x = random.rand();
 
    int index = std::lower_bound(cumulant.begin(),cumulant.begin()+sizeCDF, x) - cumulant.begin();
    /* We need to determine the pivot index and winding sector */
 
    /* row index */
    int w = (index/path.lookup.fullNumBeads) % numWind; 
 
    /* column index */
    int p = index % path.lookup.fullNumBeads;
 
    /* Copy over the pivot bead and return it */
    beadLocator pivotBead;
    pivotBead = path.lookup.fullBeadList(p);
 
    /* Get the winding number */
    wind = winding.at(w);
 
 
    return pivotBead;
}

---

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

• include/move.h
• src/move.cpp