- class openpathsampling.pathmover.EngineMover(ensemble, target_ensemble, selector, engine=None, modifier=None)
Baseclass for Movers that use an engine
A few comments for developers working with subclasses of
EngineMover: This class is intended to do most of the grunt work for a wide range of possible engine-based needs. Remember that your
selectorcan select first or final points, e.g., to extend a move. In order to help you find your way through the
EngineMovercode, here is an overview of what various private methods do:
__call__: Creates the trial. Two steps: (1) make the trajectory; (2) assemble a sample to return
_build_sample: assembles the final sample
_make_backward_trajectory: creates the actual trajectory, using
SuffixTrajectoryEnsembleto ensure reasonable behavior (see below for further discussion)
._run: this is what is called by
__call__, and it in turn calls the functions to make the trajectories (depending on the nature of the mover). Frequently, this is the only thing to override (two-way shooting, shifting).
- __init__(ensemble, target_ensemble, selector, engine=None, modifier=None)
__init__(ensemble, target_ensemble, selector)
Return a list of args of the __init__ function of a class
Return the most parent class actually derived from StorableObject
Return number of objects subclassed from StorableObject still in memory
Traverse the tree in post-order applying a function with depth
depth_pre_order(fnc[, level, only_canonical])
Traverse the tree of node in pre-order applying a function
Return a list of all subclassed objects
Set the objects name to be immutable.
Reconstruct an object from a dictionary representaiton
Select samples to use as input to the move core.
Return the index which is used for the object in the given store.
Return a list of key : subtree tuples
legal_sample_set(sample_set[, ensembles, ...])
This returns all the samples from sample_set which are in both self.replicas and the parameter ensembles.
Traverse the tree in post-order applying a function
Traverse the tree in pre-order applying a function
Apply a function to each node and return a nested tree of results
Implements the Metropolis acceptance for a list of trial samples
Run the generation starting with the initial sample_set specified.
Core of the Monte Carlo move.
Name an unnamed object.
Returns a dictionary of all storable objects
select_sample(sample_set[, ensembles, replicas])
Returns one of the legal samples given self.replica and the ensemble set in ensembles.
(De-)Activate observing creation of storable objects
Return set of replica states that a submover might be called with
Convert object into a dictionary representation
Return the object as a tree structure of nested lists of nodes
Return the base class
Return the name of the base class
Return the class name as a string
Return the default name.
A unique identifier to build the unique key for a position in a tree
List the input -> output relation for ensembles
Return a list of possible used ensembles for this mover
True if this object has a custom name.
Return the current name of the object.
Return a list of possible returned ensembles for this mover
Returns a list of submovers