SwapTailMove Class Reference

A derived class which performs a swap tail move, which mixes up worldlines by reconnecting the worm tail and is essential for systems with permutation symmetry (such as our bosons). More...

#include <move.h>

Inheritance diagram for SwapTailMove:

Collaboration diagram for SwapTailMove:

Public Member Functions
	SwapTailMove (Path &, ActionBase *, MTRand &, ensemble _operateOnConfig=OFFDIAGONAL)
	Constructor.
	~SwapTailMove ()
	Destructor.
bool	attemptMove ()
	Perform a swap tail move. More...
string	getName ()
	return the move name
Public Member Functions inherited from SwapMoveBase
	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.
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.
void	resetTotAccept ()
	Reset the total accepted counter.
void	resetAccept ()
	Reset the number accepted counter.

Static Public Attributes
static const string	name

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
Protected Member Functions inherited from SwapMoveBase
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
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 inherited from SwapMoveBase
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.
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 performs a swap tail move, which mixes up worldlines by reconnecting the worm tail and is essential for systems with permutation symmetry (such as our bosons).

Definition at line 619 of file move.h.

Member Function Documentation

attemptMove()

bool SwapTailMove::attemptMove ( )

virtual

Perform a swap tail move.

Try to perform a swap tail move that samples particle permuations due to the indistinguishability of bosons by reattaching the tail to a worldline.

Implements MoveBase.

Definition at line 3554 of file move.cpp.

                               {
 
    success = false;
 
    /* Only perform a move if we have beads */
    if (path.worm.getNumBeadsOn() == 0) 
        return success;
 
    /* We first make sure we are in an off-diagonal configuration */
    if (!path.worm.isConfigDiagonal) {
 
        /* Initialize */
        pivot = XXX;
        swap = XXX;
 
        /* Now we figure out how many beads will be involved with the swap bisection. */
        swapLength = constants()->Mbar();
        numLevels = int (ceil(log(1.0*swapLength) / log(2.0)-EPS));
 
        /* Now form the list of beads which are in the neighbourhood of
         * the tail, but at the regressed time slice */
        int pivotSlice = path.worm.tail[0] - swapLength;
        if (pivotSlice < 0)
            pivotSlice += constants()->numTimeSlices();
 
        path.lookup.updateFullInteractionList(path.worm.tail,pivotSlice);
 
        /* We can only try to make a move if we have at least one bead to swap with */
        if (path.lookup.fullNumBeads > 0) {
 
            /* We compute the normalization factors using the tail bead */
            /* We have a factor of -1 here due to the tail */
            SigmaTail = getNorm(path.worm.tail,-1);
 
            /* Get the pivot bead and winding sector */
            iVec wind;
            wind = 0;
            pivot = selectPivotBead(wind);
 
            /* Now we try to find the swap bead.  If we find the worm head, we immediatly
             * exit the move */
            beadLocator beadIndex;
            beadIndex = pivot;
            for (int k = 0; k < swapLength; k++) {
                if (all(beadIndex==path.worm.head))
                    return false;
                beadIndex = path.next(beadIndex);
            }
            swap = beadIndex;
 
            /* We only continue if we don't find the head, and the pivot and swap grid
             * boxes coincide, otherwise we reject the move. */
            if ( !all(path.worm.head==swap) && path.lookup.gridNeighbors(pivot,swap) ) {
 
                checkMove(0,0.0);
 
                /* Increment the number of swap moves and the total number of moves */
                numAttempted++;
                totAttempted++;
                numAttemptedLevel(numLevels)++;
 
                /* Now we create a new list of beads (using the same beadList)
                 * which contains all beads in neighborhood of the swap bead
                 * grid box, but at a time slice advanced by Mbar. We only 
                 * do this if tail and swap are in different grid boxes. */ 
                if (!path.lookup.gridShare(path.worm.tail,swap))
                    path.lookup.updateFullInteractionList(swap,pivotSlice);
 
                /* Get the normalization factor for the new list */
                SigmaSwap = getNorm(swap);
 
                /* We now perform a pre-metropolis step on the selected bead. If this 
                 * is not accepted, it is extremely unlikely that the potential change
                 * will have any effect, so we don't bother with it. */
                double PNorm = min(SigmaTail/SigmaSwap,1.0);
                if (random.rand() < PNorm) {
 
                    /* Mark the swap and pivot as special */
                    path.worm.special1 = swap;
                    path.worm.special2 = pivot;
 
                    int k = 0;
                    oldAction = newAction = 0.0;
 
                    /* Store the old trajectory and compute its action */
                    beadIndex = pivot;
                    do {
                        if (!all(beadIndex==swap) && !all(beadIndex==pivot)) {
                            originalPos(k) = path(beadIndex);
                            ++k;
                        }
                        beadIndex = path.next(beadIndex);
                    } while (!all(beadIndex==path.next(swap)));
 
                    oldAction = actionPtr->potentialAction(pivot,swap);
 
                    /* Because the staging algorithm requires that we move foward
                     * and backward in imaginary time (for periodic boundary conditions)
                     * we perform the relinking now, and change back to the original 
                     * linking only if we reject the move */
 
                    /* Store temporary bead locators for all the linkages that
                     * will be changed */
                    prevSwap = path.prev(swap);
 
                    /* Update the links.  Here we exploit the non-constant return reference 
                     * semantics of the next/prev methods */
                    path.prev(path.worm.tail) = prevSwap;
                    path.prev(swap)           = XXX;
                    path.next(prevSwap)       = path.worm.tail;
 
                    /* Change the former tail to a special bead, and assign the new tail */
                    path.worm.special1 = path.worm.tail;
                    path.worm.tail = swap;
 
                    /* Propose a new path trajectory and compute its action */
                    k = 0;
                    beadIndex = pivot;
                    do {
                        if (!all(beadIndex==path.worm.special1) && !all(beadIndex==pivot)) {
                            path.updateBead(beadIndex,
                                    newStagingPosition(path.prev(beadIndex),path.worm.special1,swapLength,k,wind));
                            ++k;
                        }
                        beadIndex = path.next(beadIndex);
                    } while (!all(beadIndex==path.next(path.worm.special1)));
 
                    newAction = actionPtr->potentialAction(pivot,path.worm.special1);
 
                    /* Perform the Metropolis test */
                    if ( random.rand() < exp(-(newAction - oldAction))) {
                        keepMove();
                        checkMove(1,newAction-oldAction);
                    }
                    else {
                        undoMove();
                        checkMove(2,0.0);
                    }
 
                } // PNorm 
 
            } // if we didn't find the tail and the grid boxes coincide
 
        } // numListBeads = 0
 
    } // isConfigDiagonal
 
    return success;
}

Here is the call graph for this function:

---

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

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