openpathsampling.pathsimulator.DirectSimulation¶

class openpathsampling.pathsimulator.DirectSimulation(storage=None, engine=None, states=None, flux_pairs=None, initial_snapshot=None)[source]¶

Direct simulation to calculate rates and fluxes.

In practice, this is primarily used to calculate the flux if you want to do so without saving the entire trajectory. However, it will also save the trajectory, if you want it to.

Parameters:

storage (Storage) – file to store the trajectory in. Default is None, meaning that the trajectory isn’t stored (also faster)
engine (DynamicsEngine) – the engine for the molecular dynamics
states (list of Volume) – states to look for transitions between
flux_pairs (list of 2-tuples of (state, interface)) – fluxes will calculate the flux out of state and through interface for each pair in this list
initial_snapshot (Snapshot) – initial snapshot for the MD

transitions¶: dict with keys 2-tuple of paths.Volume, values list of int – for each pair of states (from_state, to_state) as a key, gives the number of frames for each transition from the entry into from_state to entry into to_state

rate_matrix¶: pd.DataFrame – calculates the rate matrix, in units of per-frames

fluxes¶: dict with keys 2-tuple of paths.Volume, values float – flux out of state and through interface for each (state, interface) key pair

n_transitions¶: dict with keys 2-tuple of paths.Volume, values int – number of transition events for each pair of states

n_flux_events¶: dict with keys 2-tuple of paths.Volume, values int – number of flux events for each (state, interface) pair

__init__(storage=None, engine=None, states=None, flux_pairs=None, initial_snapshot=None)[source]¶: x.__init__(…) initializes x; see help(type(x)) for signature

Methods

`__init__`([storage, engine, states, …])	x.__init__(…) initializes x; see help(type(x)) for signature
`args`()	Return a list of args of the __init__ function of a class
`base`()	Return the most parent class actually derived from StorableObject
`count_weaks`()	Return number of objects subclassed from StorableObject still in memory
`descendants`()	Return a list of all subclassed objects
`fix_name`()	Set the objects name to be immutable.
`from_dict`(dct)	Reconstruct an object from a dictionary representaiton
`get_uuid`()
`idx`(store)	Return the index which is used for the object in the given store.
`load_results`(results)
`named`(name)	Name an unnamed object.
`objects`()	Returns a dictionary of all storable objects
`reverse_uuid`()
`run`(n_steps)	Run the simulator for a number of steps
`ruuid`(uid)
`save_initial_step`()	Save the initial state as an MCStep to the storage
`set_observer`(active)	(De-)Activate observing creation of storable objects
`sync_storage`()	Will sync all collective variables and the storage to disk
`to_dict`()	Convert object into a dictionary representation

Attributes

`ACTIVE_LONG`
`CREATION_COUNT`
`INSTANCE_UUID`
`base_cls`	Return the base class
`base_cls_name`	Return the name of the base class
`calc_name`
`cls`	Return the class name as a string
`default_name`	Return the default name.
`fluxes`
`is_named`	True if this object has a custom name.
`n_flux_events`
`n_transitions`
`name`	Return the current name of the object.
`observe_objects`
`rate_matrix`
`results`
`transitions`

__delattr__¶: x.__delattr__(‘name’) <==> del x.name

__format__()¶: default object formatter

__getattribute__¶: x.__getattribute__(‘name’) <==> x.name

__reduce__()¶: helper for pickle

__reduce_ex__()¶: helper for pickle

__repr__¶

__setattr__¶: x.__setattr__(‘name’, value) <==> x.name = value

__sizeof__() → int¶: size of object in memory, in bytes

__str__¶

classmethod args()¶

Return a list of args of the __init__ function of a class

Returns:	the list of argument names. No information about defaults is included.
Return type:	list of str

classmethod base()¶

Return the most parent class actually derived from StorableObject

Important to determine which store should be used for storage

Returns:	the base class
Return type:	type

base_cls¶

Return the base class

Returns:	the base class
Return type:	type

See also

base()

base_cls_name¶

Return the name of the base class

Returns:	the string representation of the base class
Return type:	str

cls¶

Return the class name as a string

Returns:	the class name
Return type:	str

static count_weaks()¶

Return number of objects subclassed from StorableObject still in memory

This includes objects not yet recycled by the garbage collector.

Returns:	dict of str – the dictionary which assigns the base class name of each references objects the integer number of objects still present
Return type:	int

default_name¶

Return the default name.

Usually derived from the objects class

Returns:	the default name
Return type:	str

classmethod descendants()¶

Return a list of all subclassed objects

Returns:	list of subclasses of a storable object
Return type:	list of type

fix_name()¶

Set the objects name to be immutable.

Usually called after load and save to fix the stored state.

classmethod from_dict(dct)¶

Reconstruct an object from a dictionary representaiton

Parameters:	dct (dict) – the dictionary containing a state representaion of the class.
Returns:	the reconstructed storable object
Return type:	`openpathsampling.netcdfplus.StorableObject`

idx(store)¶

Return the index which is used for the object in the given store.

Once you store a storable object in a store it gets assigned a unique number that can be used to retrieve the object back from the store. This function will ask the given store if the object is stored if so what the used index is.

Parameters:	store (`openpathsampling.netcdfplus.ObjectStore`) – the store in which to ask for the index
Returns:	the integer index for the object of it exists or None else
Return type:	int or None

is_named¶

True if this object has a custom name.

This distinguishes default algorithmic names from assigned names.

name¶

Return the current name of the object.

If no name has been set a default generated name is returned.

Returns:	the name of the object
Return type:	str

named(name)¶

Name an unnamed object.

This only renames the object if it does not yet have a name. It can be used to chain the naming onto the object creation. It should also be used when naming things algorithmically: directly setting the .name attribute could override a user-defined name.

Parameters:	name (str) – the name to be used for the object. Can only be set once

Examples

>>> import openpathsampling as p
>>> full = p.FullVolume().named('myFullVolume')

static objects()¶

Returns a dictionary of all storable objects

Returns:	dict of str – a dictionary of all subclassed objects from StorableObject. The name points to the class
Return type:	type

run(n_steps)[source]¶

Run the simulator for a number of steps

Parameters:	n_steps (int) – number of step to be run

save_initial_step()¶: Save the initial state as an MCStep to the storage

static set_observer(active)¶

(De-)Activate observing creation of storable objects

This can be used to track which storable objects are still alive and hence look for memory leaks and inspect caching. Use openpathsampling.netcdfplus.base.StorableObject.count_weaks() to get the current summary of created objects

Parameters:	active (bool) – if True then observing is enabled. False disables observing. Per default observing is disabled.