def __init__(
self,
storage,
move_scheme=None,
sample_set=None,
initialize=True
):
"""
Parameters
----------
storage : :class:`openpathsampling.storage.Storage`
the storage where all results should be stored in
move_scheme : :class:`openpathsampling.MoveScheme`
the move scheme used for the pathsampling cycle
sample_set : :class:`openpathsampling.SampleSet`
the initial SampleSet for the Simulator
initialize : bool
if `False` the new PathSimulator will continue at the step and
not create a new SampleSet object to cut the connection to previous
steps
"""
super(PathSampling, self).__init__(storage)
self.move_scheme = move_scheme
if move_scheme is not None:
self.root_mover = move_scheme.move_decision_tree()
self._mover = paths.PathSimulatorMover(self.root_mover, self)
else:
self.root_mover = None
self._mover = None
initialization_logging(init_log, self,
['move_scheme', 'sample_set'])
self.live_visualizer = None
self.status_update_frequency = 1
if initialize:
samples = []
if sample_set is not None:
for sample in sample_set:
samples.append(sample.copy_reset())
self.sample_set = paths.SampleSet(samples)
mcstep = MCStep(
simulation=self,
mccycle=self.step,
active=self.sample_set,
change=paths.AcceptedSampleMoveChange(self.sample_set.samples)
)
self._current_step = mcstep
else:
self.sample_set = sample_set
self._current_step = None
self.root = self.sample_set
if self.storage is not None:
self.save_current_step()
def __init__(
self,
storage,
move_scheme=None,
sample_set=None,
initialize=True
):
"""
Parameters
----------
storage : :class:`openpathsampling.storage.Storage`
the storage where all results should be stored in
move_scheme : :class:`openpathsampling.MoveScheme`
the move scheme used for the pathsampling cycle
sample_set : :class:`openpathsampling.SampleSet`
the initial SampleSet for the Simulator
initialize : bool
if `False` the new PathSimulator will continue at the step and
not create a new SampleSet object to cut the connection to previous
steps
"""
super(PathSampling, self).__init__(storage)
self.move_scheme = move_scheme
if move_scheme is not None:
self.root_mover = move_scheme.move_decision_tree()
self._mover = paths.PathSimulatorMover(self.root_mover, self)
else:
self.root_mover = None
self._mover = None
initialization_logging(init_log, self,
['move_scheme', 'sample_set'])
self.live_visualizer = None
self.status_update_frequency = 1
if initialize:
samples = []
if sample_set is not None:
for sample in sample_set:
samples.append(sample.copy_reset())
self.sample_set = paths.SampleSet(samples)
mcstep = MCStep(
simulation=self,
mccycle=self.step,
active=self.sample_set,
change=paths.AcceptedSampleMoveChange(self.sample_set.samples)
)
self._current_step = mcstep
else:
self.sample_set = sample_set
self._current_step = None
self.root = self.sample_set
if self.storage is not None:
self.save_current_step()
def __init__(self, storage):
super(PathSimulator, self).__init__()
self.storage = storage
# self.engine = engine
self.save_frequency = 1
self.step = 0
initialization_logging(
logger=init_log, obj=self,
entries=['storage']#, 'engine']
)
self.sample_set = None
self.output_stream = sys.stdout # user can change to file handler
def __init__(self, storage, engine=None):
super(PathSimulator, self).__init__()
self.storage = storage
self.engine = engine
self.save_frequency = 1
self.step = 0
initialization_logging(
logger=init_log, obj=self,
entries=['storage', 'engine']
)
self.globalstate = None
def __init__(self, storage, engine=None):
super(PathSimulator, self).__init__()
self.storage = storage
self.engine = engine
self.save_frequency = 1
self.step = 0
initialization_logging(
logger=init_log, obj=self,
entries=['storage', 'engine']
)
self.globalstate = None
def __init__(self, storage):
super(PathSimulator, self).__init__()
self.storage = storage
# self.engine = engine
self.save_frequency = 1
self.step = 0
initialization_logging(
logger=init_log, obj=self,
entries=['storage']#, 'engine']
)
self.sample_set = None
self.output_stream = sys.stdout # user can change to file handler
self.allow_refresh = True
def __init__(
self,
storage,
engine=None,
movers=None,
trajectory=None,
ensembles=None
):
"""
Parameters
----------
storage : openpathsampling.storage.Storage
the storage all results should be stored in
engine : openpathsampling.DynamicsEngine
the dynamics engine to be used
movers : list of openpathsampling.PathMover
list of shooters to be used in the BootstrapPromotionMove
trajectory : openpathsampling.Trajectory
an initial trajectory to be started from
ensembles : nested list of openpathsampling.Ensemble
the ensembles this move should act on
"""
# TODO: Change input from trajectory to sample
super(Bootstrapping, self).__init__(storage)
self.engine = engine
paths.EngineMover.default_engine = engine # set the default
self.ensembles = ensembles
self.trajectory = trajectory
sample = paths.Sample(
replica=0,
trajectory=trajectory,
ensemble=self.ensembles[0]
)
self.sample_set = paths.SampleSet([sample])
if movers is None:
pass # TODO: implement defaults: one per ensemble, uniform sel
else:
self.movers = movers
initialization_logging(init_log, self,
['movers', 'ensembles'])
init_log.info("Parameter: %s : %s", 'trajectory', str(trajectory))
self._bootstrapmove = BootstrapPromotionMove(
bias=None,
shooters=self.movers,
ensembles=self.ensembles
)
def __init__(
self,
storage,
engine=None,
movers=None,
trajectory=None,
ensembles=None
):
"""
Parameters
----------
storage : openpathsampling.storage.Storage
the storage all results should be stored in
engine : openpathsampling.DynamicsEngine
the dynamics engine to be used
movers : list of openpathsampling.PathMover
list of shooters to be used in the BootstrapPromotionMove
trajectory : openpathsampling.Trajectory
an initial trajectory to be started from
ensembles : nested list of openpathsampling.Ensemble
the ensembles this move should act on
"""
# TODO: Change input from trajectory to sample
super(Bootstrapping, self).__init__(storage)
self.engine = engine
paths.EngineMover.default_engine = engine # set the default
self.ensembles = ensembles
self.trajectory = trajectory
sample = paths.Sample(
replica=0,
trajectory=trajectory,
ensemble=self.ensembles[0]
)
self.sample_set = paths.SampleSet([sample])
if movers is None:
pass # TODO: implement defaults: one per ensemble, uniform sel
else:
self.movers = movers
initialization_logging(init_log, self,
['movers', 'ensembles'])
init_log.info("Parameter: %s : %s", 'trajectory', str(trajectory))
self._bootstrapmove = BootstrapPromotionMove(
bias=None,
shooters=self.movers,
ensembles=self.ensembles
)
def __init__(self, bias=None, shooters=None,
ensembles=None):
"""
Parameters
----------
bias : None
not used yet, only for API consistency and later implementation
shooters : list of ShootingMovers
list of ShootingMovers for each ensemble
ensembles : list of Ensembles
list of ensembles the move should act on
Notes
-----
The bootstrapping will use the ensembles sequentially so it requires
that all ensembles have a reasonable overlab using shooting moves.
"""
self.shooters = shooters
self.bias = bias
self.ensembles = ensembles
initialization_logging(logger=init_log, obj=self,
entries=['bias', 'shooters', 'ensembles'])
ens_pairs = [[self.ensembles[i], self.ensembles[i+1]]
for i in range(len(self.ensembles)-1)]
# Bootstrapping sets numeric replica IDs. If the user wants it done
# differently, the user can change it.
self._ensemble_dict = {ens : rep for rep, ens in enumerate(ensembles) }
# Create all possible hoppers so we do not have to recreate these
# every time which will result in more efficient storage
mover = paths.LastAllowedMover([
# writing an algorithm this convoluted can get you shot in Texas
paths.PartialAcceptanceSequentialMover(
movers=[
shoot,
paths.EnsembleHopMover(
ensemble=enss[0],
target_ensemble=enss[1],
change_replica=self._ensemble_dict[enss[1]]
)
]
) for (enss, shoot) in zip(ens_pairs, shooters)
])
super(BootstrapPromotionMove, self).__init__(mover)
def __init__(self, bias=None, shooters=None,
ensembles=None):
"""
Parameters
----------
bias : None
not used yet, only for API consistency and later implementation
shooters : list of ShootingMovers
list of ShootingMovers for each ensemble
ensembles : list of Ensembles
list of ensembles the move should act on
Notes
-----
The bootstrapping will use the ensembles sequentially so it requires
that all ensembles have a reasonable overlab using shooting moves.
"""
self.shooters = shooters
self.bias = bias
self.ensembles = ensembles
initialization_logging(logger=init_log, obj=self,
entries=['bias', 'shooters', 'ensembles'])
ens_pairs = [[self.ensembles[i], self.ensembles[i+1]]
for i in range(len(self.ensembles)-1)]
# Bootstrapping sets numeric replica IDs. If the user wants it done
# differently, the user can change it.
self._ensemble_dict = {ens : rep for rep, ens in enumerate(ensembles) }
# Create all possible hoppers so we do not have to recreate these
# every time which will result in more efficient storage
mover = paths.LastAllowedMover([
# writing an algorithm this convoluted can get you shot in Texas
paths.PartialAcceptanceSequentialMover(
movers=[
shoot,
paths.EnsembleHopMover(
ensemble=enss[0],
target_ensemble=enss[1],
change_replica=self._ensemble_dict[enss[1]]
)
]
) for (enss, shoot) in zip(ens_pairs, shooters)
])
super(BootstrapPromotionMove, self).__init__(mover)
def __init__(
self,
storage,
engine=None,
move_scheme=None,
globalstate=None
):
"""
Parameters
----------
storage : openpathsampling.storage.Storage
the storage where all results should be stored in
engine : openpathsampling.DynamicsEngine
the engine to be used with shooting moves
move_scheme : openpathsampling.MoveScheme
the move scheme used for the pathsampling cycle
globalstate : openpathsampling.SampleSet
the initial SampleSet for the Simulator
"""
super(PathSampling, self).__init__(storage, engine)
self.move_scheme = move_scheme
self.root_mover = move_scheme.move_decision_tree()
# self.move_scheme.name = "PathSamplingRoot"
samples = []
if globalstate is not None:
for sample in globalstate:
samples.append(sample.copy_reset())
self.globalstate = paths.SampleSet(samples)
self.root = self.globalstate
initialization_logging(init_log, self,
['move_scheme', 'globalstate'])
self.live_visualization = None
self.visualize_frequency = 1
self._mover = paths.PathSimulatorMover(self.root_mover, self)
def __init__(
self,
storage,
engine=None,
move_scheme=None,
globalstate=None
):
"""
Parameters
----------
storage : openpathsampling.storage.Storage
the storage where all results should be stored in
engine : openpathsampling.DynamicsEngine
the engine to be used with shooting moves
move_scheme : openpathsampling.PathMover
the mover used for the pathsampling cycle
globalstate : openpathsampling.SampleSet
the initial SampleSet for the Simulator
"""
super(PathSampling, self).__init__(storage, engine)
self.move_scheme = move_scheme
# self.move_scheme.name = "PathSamplingRoot"
samples = []
if globalstate is not None:
for sample in globalstate:
samples.append(sample.copy_reset())
self.globalstate = paths.SampleSet(samples)
self.root = self.globalstate
initialization_logging(init_log, self,
['move_scheme', 'globalstate'])
self.live_visualization = None
self.visualize_frequency = 1
self._mover = paths.PathSimulatorMover(self.move_scheme, self)
