def test_relevant_transitions(self):
extra_set = paths.VolumeInterfaceSet(self.cv_inc, 0.0, [0.2, 0.3])
extra = paths.TISTransition(self.stateA, self.stateB, extra_set,
self.cv_inc, "fake")
transitions = self.network.sampling_transitions + [extra]
# TODO: switch once network is working
relevant = self.post_network.relevant_transitions(transitions)
#relevant = self.ms_outer.relevant_transitions(transitions)
assert_equal(len(relevant), 2)
assert_equal(set(self.network.sampling_transitions), set(relevant))
def _build_sampling_transitions(self, transitions):
transitions = list(transitions) # input may be iterator
# TODO: I don't think transition pairs are used (see comment below;
# I think that was the previous use case -- as input to all_in_pairs
# However, existing files store this, so we won't actually remove it
# yet.
self.transition_pairs = self._build_transition_pairs(transitions)
# this seems to no longer be used; I think it was necessary when the
# MSOuter interface was done implicitly, instead of explicitly. Then
# we turn the outermost to MS if and only if it was paired with the
# reverse transition
# 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 = paths.join_volumes(all_states_set)
ensemble_to_intersect = paths.FullEnsemble()
sample_trans = paths.TISTransition(
stateA=stateA,
stateB=final_state,
interfaces=transition.interfaces,
name=stateA.name + "->" + stateB.name,
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 = \
list(self.transition_to_sampling.values())
self._build_sampling_minus_ensembles()
def build_fromstate_transitions(self, trans_info):
"""
Builds the sampling transitions (the self.from_state dictionary).
This also sets self.states (list of states volumes), self.outers
(list of interface volumes making the MS-outer interface), and
self.outer_ensembles (list of TISEnsembles associated with the
self.outers interfaces). Additionally, it gives default names
volumes, interfaces, and transitions.
Parameters
----------
trans_info : list of 2-tuples
See description in __init__.
"""
states, interfaces = zip(*trans_info)
orderparams = [iface_set.cv for iface_set in interfaces]
# NAMING STATES (give default names)
all_states = paths.volume.join_volumes(states).named("all states")
all_names = list(set([s.name for s in states]))
unnamed_states = [s for s in states if not s.is_named]
name_index = 0
for state in unnamed_states:
while index_to_string(name_index) in all_names:
name_index += 1
state.named(index_to_string(name_index))
name_index += 1
# BUILDING ENSEMBLES
self.states = states
for (state, ifaces) in trans_info:
op = ifaces.cv
state_index = states.index(state)
other_states = states[:state_index]+states[state_index+1:]
union_others = paths.volume.join_volumes(other_states)
union_others.named("all states except " + str(state.name))
this_trans = paths.TISTransition(
stateA=state,
stateB=union_others,
interfaces=ifaces,
name="Out " + state.name,
orderparameter=op
)
self.from_state[state] = this_trans
this_minus = self.from_state[state].minus_ensemble
this_inner = self.from_state[state].ensembles[0]
try:
self.special_ensembles['minus'][this_minus] = [this_trans]
except KeyError:
self.special_ensembles['minus'] = {this_minus : [this_trans]}
def build_one_state_sampling_transition(state, interfaces, all_states):
other_states = list(set(all_states) - set([state]))
union_others = paths.join_volumes(volume_list=other_states,
name="all states except " +
str(state.name))
this_trans = paths.TISTransition(stateA=state,
stateB=union_others,
interfaces=interfaces,
name="Out " + state.name,
orderparameter=interfaces.cv)
return this_trans
def __init__(self, trans_info, ms_outers=None, strict_sampling=False):
super(MISTISNetwork, self).__init__(trans_info, ms_outers)
self.strict_sampling = strict_sampling
states_A, interfaces, states_B = zip(*trans_info)
orderparams = [iface_set.cv for iface_set in interfaces]
self.initial_states = list(set(states_A))
self.final_states = list(set(states_B))
list_all_states = list(set(self.initial_states + self.final_states))
# name states
all_state_names = list(set([s.name for s in list_all_states]))
unnamed_states = [s for s in list_all_states if not s.is_named]
name_index = 0
for state in unnamed_states:
while index_to_string(name_index) in all_state_names:
name_index += 1
state.named(index_to_string(name_index))
name_index += 1
if not hasattr(self, "input_transitions"):
self.input_transitions = {
(stateA, stateB):
paths.TISTransition(stateA,
stateB,
interface,
interface.cv,
name=stateA.name + "->" + stateB.name,
name_suffix=" (input)")
for (stateA, interface, stateB) in self.trans_info
}
if not hasattr(self, 'x_sampling_transitions'):
self.special_ensembles = {}
self._build_sampling_transitions(self.input_transitions.values())
if self.ms_outer_objects is not None:
for ms_outer in self.ms_outer_objects:
all_transitions = self.x_sampling_transitions
if not self.strict_sampling:
self.add_ms_outer_interface(ms_outer, all_transitions)
else:
relevant = ms_outer.relevant_transitions(
all_transitions)
allowed = set(
sum([[t.stateA, t.stateB] for t in relevant], []))
forbidden = set(list_all_states) - allowed
self.add_ms_outer_interface(ms_outer, all_transitions,
forbidden)
self._sampling_transitions = self.x_sampling_transitions
# by default, we set assign these values to all ensembles
self.hist_args = {}
self._build_analysis_transitions()
def test_calculate_no_max_lambda(self):
mistis_AB = self.mistis.transitions[(self.state_A, self.state_B)]
modified_transition = paths.TISTransition(
stateA=mistis_AB.stateA,
stateB=mistis_AB.stateB,
interfaces=mistis_AB.interfaces.volumes,
orderparameter=mistis_AB.orderparameter
)
mistis_AB_histogrammer = FullHistogramMaxLambdas(
transition=modified_transition,
hist_parameters={'bin_width': 0.1, 'bin_range': (-0.1, 1.1)}
)
def build_analysis_transitions(self):
self.transitions = {}
for trans in self.input_transitions.values():
sample_trans = self.transition_to_sampling[trans]
stateA = trans.stateA
stateB = trans.stateB
analysis_trans = paths.TISTransition(
stateA=stateA,
stateB=stateB,
interfaces=sample_trans.interfaces,
orderparameter=sample_trans.orderparameter)
analysis_trans.ensembles = sample_trans.ensembles
analysis_trans.named(trans.name)
#analysis_trans.special_ensembles = sample_trans.special_ensembles
self.transitions[(stateA, stateB)] = analysis_trans
def ratcheter(self, interfaces, direction="out_in"):
if direction == "in_out":
stateA = self.DFG_in
stateB = self.DFG_out
elif direction == "out_in":
stateA = self.DFG_out
stateB = self.DFG_in
else:
raise RuntimeError("direction is " + str(direction) +
": must be 'in_out' or 'out_in'.")
transition = paths.TISTransition(stateA, stateB, interfaces, self.cv)
ratcheter = paths.FullBootstrapping(
transition=transition,
snapshot=self.engine.current_snapshot,
storage=self.storage,
engine=self.engine)
return ratcheter
def build_analysis_transitions(self):
# set up analysis transitions (not to be saved)
for stateA in self.from_state.keys():
state_index = self.states.index(stateA)
fromA = self.from_state[stateA]
other_states = self.states[:state_index] + self.states[
state_index + 1:]
for stateB in other_states:
trans = paths.TISTransition(
stateA=stateA,
stateB=stateB,
interfaces=fromA.interfaces,
name=str(stateA) + "->" + str(stateB),
orderparameter=fromA.orderparameter)
# override created stuff
trans.ensembles = fromA.ensembles
trans.minus_ensemble = fromA.minus_ensemble
self.transitions[(stateA, stateB)] = trans
def _build_analysis_transition_for_sampling(sampling_transition,
all_states):
local_transitions = {}
state_A = sampling_transition.stateA
other_states = set(all_states) - set([state_A])
str_A = _default_state_name(state_A)
for state_B in other_states:
str_B = _default_state_name(state_B)
trans = paths.TISTransition(
stateA=state_A,
stateB=state_B,
interfaces=sampling_transition.interfaces,
name=str_A + "->" + str_B,
orderparameter=sampling_transition.orderparameter)
# override created stuff
trans.ensembles = sampling_transition.ensembles
for i in range(len(trans.ensembles)):
trans.ensembles[i].named(trans.name + "[" + str(i) + "]")
trans.minus_ensemble = sampling_transition.minus_ensemble
local_transitions[(state_A, state_B)] = trans
return local_transitions
def __init__(self, trans_info):
super(MISTISNetwork, self).__init__()
self.trans_info = trans_info
states_A, interfaces, orderparams, states_B = zip(*trans_info)
self.initial_states = list(set(states_A))
self.final_states = list(set(states_B))
list_all_states = list(set(self.initial_states + self.final_states))
# name states
all_state_names = list(set([s.name for s in list_all_states]))
unnamed_states = [s for s in list_all_states if not s.is_named]
name_index = 0
for state in unnamed_states:
while index_to_string(name_index) in all_names:
name_index += 1
state.named(index_to_string(name_index))
name_index += 1
if not hasattr(self, "input_transitions"):
self.input_transitions = {
(stateA, stateB):
paths.TISTransition(stateA,
stateB,
interface,
orderparam,
name=stateA.name + "->" + stateB.name)
for (stateA, interface, orderparam, stateB) in self.trans_info
}
if not hasattr(self, 'x_sampling_transitions'):
self.special_ensembles = {}
self.build_sampling_transitions(self.input_transitions.values())
self._sampling_transitions = self.x_sampling_transitions
# by default, we set assign these values to all ensembles
self.hist_args = {}
self.build_analysis_transitions()
def build_analysis_transitions(self):
# set up analysis transitions (not to be saved)
for stateA in self.from_state.keys():
state_index = self.states.index(stateA)
fromA = self.from_state[stateA]
other_states = self.states[:state_index]+self.states[state_index+1:]
for stateB in other_states:
strA = stateA.name if stateA.is_named else str(stateA)
strB = stateB.name if stateB.is_named else str(stateB)
trans = paths.TISTransition(
stateA=stateA,
stateB=stateB,
interfaces=fromA.interfaces,
name=strA + "->" + strB,
orderparameter=fromA.orderparameter
)
# override created stuff
trans.ensembles = fromA.ensembles
for i in range(len(trans.ensembles)):
trans.ensembles[i].named(trans.name + "[" + str(i) + "]")
trans.minus_ensemble = fromA.minus_ensemble
self.transitions[(stateA, stateB)] = trans
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}
