def make_movers(self, scheme):
(ensemble_weights, mover_weights) = self.get_weights(
scheme=scheme,
sorted_movers=scheme.movers,
sort_weights_override=self.ensemble_weights,
mover_weights_override=self.mover_weights)
scheme.choice_probability = self.choice_probability(
scheme, ensemble_weights, mover_weights)
self.ensemble_weights = ensemble_weights
self.mover_weights = mover_weights
root_info = self.chooser_root_weights(scheme, ensemble_weights,
mover_weights)
chooser_dict = {}
for ens in root_info.keys():
weight_dict = self.chooser_mover_weights(scheme, ens,
mover_weights)
choosername = ens.name + "Chooser"
chooser_dict[ens] = self.make_chooser(scheme, weight_dict,
choosername)
root_couples = [(root_info[g], chooser_dict[g])
for g in root_info.keys()]
(root_weights, choosers) = zip(*root_couples)
root_chooser = paths.RandomChoiceMover(movers=choosers,
weights=root_weights)
root_chooser.named("RootMover")
scheme.root_mover = root_chooser
return root_chooser
def make_movers(self, scheme):
(group_weights, mover_weights) = self.get_weights(
scheme=scheme,
sorted_movers=scheme.movers,
sort_weights_override=self.group_weights,
mover_weights_override=self.mover_weights)
scheme.choice_probability = self.choice_probability(
scheme, group_weights, mover_weights)
self.group_weights = group_weights
self.mover_weights = mover_weights
root_info = self.chooser_root_weights(scheme, group_weights,
mover_weights)
chooser_dict = {}
for group in root_info.keys():
# care to the order of weights
weight_dict = self.chooser_mover_weights(scheme, group,
mover_weights)
choosername = group.capitalize() + "Chooser"
chooser_dict[group] = self.make_chooser(scheme, weight_dict,
choosername)
root_couples = [(root_info[g], chooser_dict[g])
for g in root_info.keys()]
(root_weights, choosers) = zip(*root_couples)
root_chooser = paths.RandomChoiceMover(movers=choosers,
weights=root_weights)
root_chooser.named("RootMover")
scheme.root_mover = root_chooser
return root_chooser
def __init__(self, storage, engine, starting_volume, forward_ensemble,
backward_ensemble, randomizer, initial_snapshots):
super(ShootFromSnapshotsSimulation, self).__init__(storage)
self.engine = engine
# FIXME: this next line seems weird; but tests fail without it
paths.EngineMover.default_engine = engine
try:
initial_snapshots = list(initial_snapshots)
except TypeError:
initial_snapshots = [initial_snapshots]
self.initial_snapshots = initial_snapshots
self.randomizer = randomizer
self.starting_ensemble = (paths.AllInXEnsemble(starting_volume)
& paths.LengthEnsemble(1))
self.forward_ensemble = forward_ensemble
self.backward_ensemble = backward_ensemble
self.forward_mover = paths.ForwardExtendMover(
ensemble=self.starting_ensemble,
target_ensemble=self.forward_ensemble)
self.backward_mover = paths.BackwardExtendMover(
ensemble=self.starting_ensemble,
target_ensemble=self.backward_ensemble)
# subclasses will often override this
self.mover = paths.RandomChoiceMover(
[self.forward_mover, self.backward_mover])
def __init__(self, storage, engine=None, states=None, randomizer=None,
initial_snapshots=None, direction=None):
all_state_volume = paths.join_volumes(states)
no_state_volume = ~all_state_volume
# shoot forward until we hit a state
forward_ensemble = paths.SequentialEnsemble([
paths.AllOutXEnsemble(all_state_volume),
paths.AllInXEnsemble(all_state_volume) & paths.LengthEnsemble(1)
])
# or shoot backward until we hit a state
backward_ensemble = paths.SequentialEnsemble([
paths.AllInXEnsemble(all_state_volume) & paths.LengthEnsemble(1),
paths.AllOutXEnsemble(all_state_volume)
])
super(CommittorSimulation, self).__init__(
storage=storage,
engine=engine,
starting_volume=no_state_volume,
forward_ensemble=forward_ensemble,
backward_ensemble=backward_ensemble,
randomizer=randomizer,
initial_snapshots=initial_snapshots
)
self.states = states
self.direction = direction
# override the default self.mover given by the superclass
if self.direction is None:
self.mover = paths.RandomChoiceMover([self.forward_mover,
self.backward_mover])
elif self.direction > 0:
self.mover = self.forward_mover
elif self.direction < 0:
self.mover = self.backward_mover
def make_chooser(self, scheme, mover_weights, choosername):
"""
Make RandomChoiceMover based on the movers and weights in
mover_weights.
"""
chooser = paths.RandomChoiceMover(movers=list(mover_weights.keys()),
weights=list(mover_weights.values()))
chooser.named(choosername)
return chooser
def __init__(self,
storage,
engine=None,
states=None,
randomizer=None,
initial_snapshots=None,
direction=None):
super(CommittorSimulation, self).__init__(storage)
self.engine = engine
paths.EngineMover.default_engine = engine
self.states = states
self.randomizer = randomizer
try:
initial_snapshots = list(initial_snapshots)
except TypeError:
initial_snapshots = [initial_snapshots]
self.initial_snapshots = initial_snapshots
self.direction = direction
all_state_volume = paths.join_volumes(states)
# we should always start from a single frame not in any state
self.starting_ensemble = (paths.AllOutXEnsemble(all_state_volume)
& paths.LengthEnsemble(1))
# shoot forward until we hit a state
self.forward_ensemble = paths.SequentialEnsemble([
paths.AllOutXEnsemble(all_state_volume),
paths.AllInXEnsemble(all_state_volume) & paths.LengthEnsemble(1)
])
# or shoot backward until we hit a state
self.backward_ensemble = paths.SequentialEnsemble([
paths.AllInXEnsemble(all_state_volume) & paths.LengthEnsemble(1),
paths.AllOutXEnsemble(all_state_volume)
])
self.forward_mover = paths.ForwardExtendMover(
ensemble=self.starting_ensemble,
target_ensemble=self.forward_ensemble)
self.backward_mover = paths.BackwardExtendMover(
ensemble=self.starting_ensemble,
target_ensemble=self.backward_ensemble)
if self.direction is None:
self.mover = paths.RandomChoiceMover(
[self.forward_mover, self.backward_mover])
elif self.direction > 0:
self.mover = self.forward_mover
elif self.direction < 0:
self.mover = self.backward_mover
