BisectionMove Class Reference

A derived class which performs a bisection move, which exactly samples the kinetic action. More...

#include <move.h>

Inheritance diagram for BisectionMove:

Collaboration diagram for BisectionMove:

Public Member Functions
	BisectionMove (Path &, ActionBase *, MTRand &, ensemble _operateOnConfig=ANY)
	Constructor. More...
	~BisectionMove ()
	Destructor.
bool	attemptMove ()
	Bisection Move : attempt Move. More...
string	getName ()
	return the move name
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 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 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 bisection move, which exactly samples the kinetic action.

Definition at line 296 of file move.h.

Constructor & Destructor Documentation

BisectionMove()

BisectionMove::BisectionMove	(	Path &	_path,
		ActionBase *	_actionPtr,
		MTRand &	_random,
		ensemble	_operateOnConfig = ANY
	)

Constructor.

Initialize the number of levels and all local data structures.

Definition at line 1440 of file move.cpp.

                                                    : 
    MoveBase(_path,_actionPtr,_random,_operateOnConfig) {
 
    /* Initialize private data to zera */
    numAccepted = numAttempted = numToMove = 0;
 
    /* Initialize the acceptance by level counters */
    /* These need to use the *actual* value of b */
    numAcceptedLevel.resize(constants()->b()+1);
    numAttemptedLevel.resize(constants()->b()+1);
    numAcceptedLevel  = 0;
    numAttemptedLevel = 0;
 
    /* The number of levels used in bisection */
    numLevels = constants()->b();
 
    /* We setup the original and new positions as well as the include array
     * which stores updates to the beads involved in the bisection */
    numActiveBeads = ipow(2,numLevels)-1;
    include.resize(numActiveBeads);
    originalPos.resize(numActiveBeads);
    newPos.resize(numActiveBeads);
}

Here is the call graph for this function:

Member Function Documentation

attemptMove()

bool BisectionMove::attemptMove ( )

virtual

Bisection Move : attempt Move.

Here we actually perform the bisection move, which attempts to make a single large move at the midpoint between two slices, then futher bisects until all particles have been moved. The only adjustable parameter for is the number of levels, which sets the number of particles that we will try to move. The move can be fully rejected at any level, and we then go back and restore the positions of all moved particles.

For a nice description of the algorithm see: C. Chakravarty et al. J. Chem. Phys. 109, 2123 (1998).

Implements MoveBase.

Definition at line 1486 of file move.cpp.

                                {
 
    success = false;
 
    /* Only perform a move if we have beads */
    if (path.worm.getNumBeadsOn() == 0) 
        return success;
 
    /* We cannot perform this move at present when using a pair product action */
    if (constants()->actionType() == "pair_product")
        return false;
 
    /* Do we perform varialble length bisection updates? */
    if (constants()->varUpdates()) {
        numLevels = 1+random.randInt(constants()->b()-1);
        numActiveBeads = ipow(2,numLevels)-1;
    }
 
    /* Only do bisections when we have at least one particle */
    if (path.getTrueNumParticles()==0)
        return false;
 
    /* Randomly select the start bead of the bisection */
    startBead[0] = random.randInt(path.numTimeSlices-1);
 
    /* We need to worry about the possibility of an empty slice for small
     * numbers of particles. */
    if (path.numBeadsAtSlice(startBead[0]) == 0)
        return false;
    startBead[1] = random.randInt(path.numBeadsAtSlice(startBead[0])-1);
 
    /* Now we have to make sure that we are moving an active trajectory, 
     * otherwise we exit immediatly */
    beadLocator beadIndex;
    beadIndex = startBead;
    for (int k = 0; k < (numActiveBeads+1); k++) {
        if (!path.worm.beadOn(beadIndex) || all(path.next(beadIndex)==XXX))
            return false;
        beadIndex = path.next(beadIndex);
    }
    endBead = beadIndex;
 
    checkMove(0,0.0);
 
    /* Increment the number of displacement moves and the total number
     * of moves */
    numAttempted++;
    totAttempted++;
    numAttemptedLevel(numLevels)++;
    include = true;
 
    /* Now we perform the actual bisection down to level 1 */
    oldDeltaAction = 0.0;
    for (level = numLevels; level > 0; level--) {
 
        /* Compute the distance between time slices and set the tau
         * shift for the action */
        shift = ipow(2,level-1);
        actionPtr->setShift(shift);
 
        /* Reset the actions for this level*/
        oldAction = newAction = 0.0;
 
        beadIndex = path.next(startBead,shift);
        int k = 1;
        do {
            int n = k*shift-1;
 
            if (include(n)) {
                originalPos(n) = path(beadIndex);
                oldAction += actionPtr->potentialAction(beadIndex);
 
                /* Generate the new position and compute the action */
                newPos(n) = newBisectionPosition(beadIndex,shift);
                path.updateBead(beadIndex,newPos(n));
                newAction += actionPtr->potentialAction(beadIndex);
 
                /* Set the include bit */
                include(n) = false;
            }
            /* At level 1 we need to compute the full action */
            else if (level==1) {
                newAction += actionPtr->potentialAction(beadIndex);
                path.updateBead(beadIndex,originalPos(n));
                oldAction += actionPtr->potentialAction(beadIndex);
                path.updateBead(beadIndex,newPos(n));
            }
 
            ++k;
            beadIndex = path.next(beadIndex,shift);
        } while (!all(beadIndex==endBead));
 
        /* Record the total action difference at this level */
        deltaAction = (newAction - oldAction);
 
        /* Now we do the metropolis step, if we accept the move, we 
         * keep going to the next level, however, if we reject it,
         * we return all slices that have already been moved back
         * to their original positions and break out of the level
         * loop. */
 
        /* The actual Metropolis test */
        if (random.rand() < exp(-deltaAction + oldDeltaAction)) {
            if (level == 1) {
                keepMove();
                checkMove(1,deltaAction);
            }
        }
        else {
            undoMove();
            checkMove(2,0.0);
            break;
        }
 
        oldDeltaAction = deltaAction;
 
    } // end over level
 
    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