def test_minus_with_multiple_excursion(self):
minus = paths.MinusInterfaceEnsemble(self.stateA, self.stateA, n_l=4)
assert_equal(minus_sides_summary(self.traj_axaxaxaxa, minus), {
"in": [2, 3, 4],
"out": [1, 2, 3]
})
assert_equal(minus_sides_summary(self.traj_aixixiaixaxiaixia, minus), {
"in": [2, 1, 3],
"out": [7, 4, 3]
})
def test_minus_with_interstitial(self):
minus = paths.MinusInterfaceEnsemble(self.stateA, self.innermost)
assert_equal(minus_sides_summary(self.traj_axaxa, minus), {
"in": [5],
"out": [4]
})
assert_equal(minus_sides_summary(self.traj_aixiaixia, minus), {
"in": [6],
"out": [4]
})
assert_equal(minus_sides_summary(self.traj_aixixiaxia, minus), {
"in": [5],
"out": [8]
})
def __init__(self,
stateA,
stateB,
interfaces,
orderparameter=None,
name=None,
name_suffix=""):
super(TISTransition, self).__init__(stateA, stateB)
self.stateA = stateA
self.stateB = stateB
self.interfaces = interfaces
self.name_suffix = name_suffix
if name is not None:
self.name = name
# If we reload from a storage file, we want to use the
# ensembles from the file, not the automatically generated
# ones here
# build ensembles if we don't already have them
self.orderparameter = orderparameter
if not hasattr(self, "ensembles"):
self._build_ensembles(self.stateA, self.stateB, self.interfaces,
self.orderparameter)
self.default_orderparameter = self.orderparameter
self.total_crossing_probability_method = "wham"
self.histograms = {}
# caches for the results of our calculation
self._flux = None
self._rate = None
self.hist_args = {} # shortcut to ensemble_histogram_info[].hist_args
self.ensemble_histogram_info = {
'max_lambda':
Histogrammer(f=max_lambdas,
f_args={'orderparameter': self.orderparameter},
hist_args={}),
'pathlength':
Histogrammer(f=pathlength, f_args={}, hist_args={})
}
self.minus_ensemble = paths.MinusInterfaceEnsemble(
state_vol=stateA, innermost_vols=interfaces[0],
forbidden=stateB).named("Out " + stateA.name + " minus" +
self.name_suffix)
def test_minus_with_interstitial_and_multiple_excursion(self):
minus = paths.MinusInterfaceEnsemble(self.stateA,
self.innermost,
n_l=4)
assert_equal(minus_sides_summary(self.traj_axaxaxaxa, minus), {
"in": [2, 3, 4],
"out": [1, 2, 3]
})
assert_equal(minus_sides_summary(self.traj_aixixiaixaxiaixia, minus), {
"in": [4, 1, 5],
"out": [6, 2, 3]
})
assert_not_equal(
minus_sides_summary(self.traj_aixixiaixaxiaixia, minus), {
"in": [1, 4, 5],
"out": [6, 2, 3]
})
def _build_sampling_minus_ensembles(self):
# combining the minus interfaces
for initial in self.initial_states:
innermosts = []
# trans_from_initial: list of transition from initial
trans_from_initial = [
t for t in self.x_sampling_transitions if t.stateA == initial
]
for t1 in trans_from_initial:
innermosts.append(t1.interfaces[0])
minus = paths.MinusInterfaceEnsemble(
state_vol=initial,
innermost_vols=innermosts).named(initial.name + " MIS minus")
try:
self.special_ensembles['minus'][minus] = trans_from_initial
except KeyError:
self.special_ensembles['minus'] = {minus: trans_from_initial}
def test_normal_minus(self):
minus = paths.MinusInterfaceEnsemble(self.stateA, self.stateA)
assert_equal(minus_sides_summary(self.traj_axaxa, minus), {
"in": [5],
"out": [4]
})
assert_not_equal(minus_sides_summary(self.traj_axaxa, minus), {
"in": [5],
"out": [3]
})
assert_equal(minus_sides_summary(self.traj_aixiaixia, minus), {
"in": [5],
"out": [6]
})
assert_equal(minus_sides_summary(self.traj_aixixiaxia, minus), {
"in": [5],
"out": [10]
})
def build_sampling_transitions(self, transitions):
# identify transition pairs
transition_pair_set_dict = {}
for initial in self.initial_states:
for t1 in [t for t in transitions if t.stateA==initial]:
t_reverse = [
t for t in transitions
if t.stateA == t1.stateB and t.stateB == t1.stateA
]
if len(t_reverse) == 1:
key = frozenset([t1.stateA, t1.stateB])
new_v = [t1, t_reverse[0]]
if key not in transition_pair_set_dict.keys():
transition_pair_set_dict[key] = new_v
elif len(t_reverse) > 1: # pragma: no cover
raise RuntimeError("More than one reverse transition")
# if len(t_reverse) is 0, we just pass
self.transition_pairs = transition_pair_set_dict.values()
if len(self.transition_pairs) > 0:
all_in_pairs = reduce(list.__add__, map(lambda x: list(x),
self.transition_pairs))
else:
all_in_pairs = []
# build sampling transitions
all_states = paths.join_volumes(self.initial_states + self.final_states)
all_states_set = set(self.initial_states + self.final_states)
self.transition_to_sampling = {}
for transition in transitions:
stateA = transition.stateA
stateB = transition.stateB
if self.strict_sampling:
final_state = stateB
other_states = paths.join_volumes(all_states_set -
set([stateA, stateB]))
ensemble_to_intersect = paths.AllOutXEnsemble(other_states)
else:
final_state = all_states
ensemble_to_intersect = paths.FullEnsemble()
sample_trans = paths.TISTransition(
stateA=stateA,
stateB=final_state,
interfaces=transition.interfaces,
orderparameter=transition.orderparameter
)
new_ensembles = [e & ensemble_to_intersect
for e in sample_trans.ensembles]
if self.strict_sampling:
for (old, new) in zip(new_ensembles, sample_trans.ensembles):
old.name = new.name + " strict"
sample_trans.ensembles = new_ensembles
sample_trans.named("Sampling " + str(stateA) + "->" + str(stateB))
self.transition_to_sampling[transition] = sample_trans
self.x_sampling_transitions = self.transition_to_sampling.values()
# combining the minus interfaces
for initial in self.initial_states:
innermosts = []
trans_from_initial = [
t for t in self.x_sampling_transitions
if t.stateA==initial
]
for t1 in trans_from_initial:
innermosts.append(t1.interfaces[0])
minus = paths.MinusInterfaceEnsemble(
state_vol=initial,
innermost_vols=innermosts
)
try:
self.special_ensembles['minus'][minus] = trans_from_initial
except KeyError:
self.special_ensembles['minus'] = {minus : trans_from_initial}
def build_sampling_transitions(self, transitions):
# identify transition pairs
for initial in self.initial_states:
transition_pair_dict = {}
for t1 in [t for t in transitions if t.stateA == initial]:
reverse_trans = None
for t2 in transitions:
if t2.stateA == t1.stateB and t2.stateB == t1.stateA:
transition_pair_dict[t1] = t2
# TODO: speed this up with a set?
for key in transition_pair_dict.keys():
value = transition_pair_dict[key]
if value in transition_pair_dict.keys():
del transition_pair_dict[value]
self.transition_pairs = [(k, transition_pair_dict[k])
for k in transition_pair_dict.keys()]
all_in_pairs = reduce(list.__add__,
map(lambda x: list(x), self.transition_pairs))
# build sampling transitions
# TODO: really, I'd like to FORBID all other states (change the
# ensemble to intersection with AllOutXEnsemble(other_states)), but
# for now, let's accept all other states -- the key is to stop the
# trajectory. Forbidding all other states can be done once building
# the movers is better separated.
all_states = paths.join_volumes(self.initial_states +
self.final_states)
self.transition_to_sampling = {}
for transition in transitions:
stateA = transition.stateA
stateB = transition.stateB
if transition not in all_in_pairs:
sample_trans = paths.TISTransition(
stateA=stateA,
stateB=all_states,
interfaces=transition.interfaces,
orderparameter=transition.orderparameter)
else:
sample_trans = paths.TISTransition(
stateA=stateA,
stateB=all_states,
interfaces=transition.interfaces[:-1],
orderparameter=transition.orderparameter)
sample_trans.named("Sampling " + str(stateA) + "->" + str(stateB))
self.transition_to_sampling[transition] = sample_trans
self.x_sampling_transitions = self.transition_to_sampling.values()
# build non-transition interfaces
# combining the MS-outer interfaces
for pair in self.transition_pairs:
this_outer = paths.ensemble.join_ensembles(
[pair[0].ensembles[-1], pair[1].ensembles[-1]])
s_pair = [self.transition_to_sampling[p] for p in pair]
try:
self.special_ensembles['ms_outer'][this_outer] = list(s_pair)
except KeyError:
self.special_ensembles['ms_outer'] = {this_outer: list(s_pair)}
# combining the minus interfaces
for initial in self.initial_states:
innermosts = []
trans_from_initial = [
t for t in self.x_sampling_transitions if t.stateA == initial
]
for t1 in trans_from_initial:
innermosts.append(t1.interfaces[0])
minus = paths.MinusInterfaceEnsemble(state_vol=initial,
innermost_vols=innermosts)
try:
self.special_ensembles['minus'][minus] = trans_from_initial
except KeyError:
self.special_ensembles['minus'] = {minus: trans_from_initial}
