def test_dependency_graphing(self):
from example_models import create_toggle_switch, create_michaelis_menten
model = create_toggle_switch()
dependencies = dependency_grapher(model,
list(model.listOfReactions.keys()))
correct_graph = {
'cu': {
'dependencies': ['cv', 'dv']
},
'cv': {
'dependencies': ['cu', 'du']
},
'du': {
'dependencies': ['cu']
},
'dv': {
'dependencies': ['cv']
}
}
self.assertEqual(correct_graph, dependencies)
model = create_michaelis_menten()
dependencies = dependency_grapher(model,
list(model.listOfReactions.keys()))
correct_graph = {
'r1': {
'dependencies': ['r2', 'r3']
},
'r2': {
'dependencies': ['r1', 'r3']
},
'r3': {
'dependencies': ['r1', 'r2']
}
}
self.assertEqual(correct_graph, dependencies)
def __run(self,
model,
curr_state,
total_time,
timeline,
trajectory_base,
live_grapher,
t=20,
number_of_trajectories=1,
increment=0.05,
seed=None,
debug=False,
show_labels=True,
resume=None,
timeout=None):
# for use with resume, determines how much excess data to cut off due to
# how species and time are initialized to 0
timeStopped = 0
if resume is not None:
if resume[0].model != model:
raise gillespyError.ModelError(
'When resuming, one must not alter the model being resumed.'
)
if t < resume['time'][-1]:
raise gillespyError.ExecutionError(
"'t' must be greater than previous simulations end time, or set in the run() method as the "
"simulations next end time")
random.seed(seed)
species_mappings, species, parameter_mappings, number_species = nputils.numpy_initialization(
model)
# create dictionary of all constant parameters for propensity evaluation
parameters = {'V': model.volume}
for paramName, param in model.listOfParameters.items():
parameters[parameter_mappings[paramName]] = param.value
# create mapping of reaction dictionary to array indices
reactions = list(model.listOfReactions.keys())
# create mapping of reactions, and which reactions depend on their reactants/products
dependent_rxns = nputils.dependency_grapher(model, reactions)
number_reactions = len(reactions)
propensity_functions = {}
# create an array mapping reactions to species modified
species_changes = np.zeros((number_reactions, number_species))
# pre-evaluate propensity equations from strings:
for i, reaction in enumerate(reactions):
# replace all references to species with array indices
for j, spec in enumerate(species):
species_changes[i][j] = model.listOfReactions[reaction].products.get(model.listOfSpecies[spec], 0) \
- model.listOfReactions[reaction].reactants.get(model.listOfSpecies[spec], 0)
if debug:
print('species_changes: {0},i={1}, j={2}... {3}'.format(
species, i, j, species_changes[i][j]))
propensity_functions[reaction] = [
eval(
'lambda S:' + model.
listOfReactions[reaction].sanitized_propensity_function(
species_mappings, parameter_mappings), parameters), i
]
if debug:
print('propensity_functions', propensity_functions)
# begin simulating each trajectory
simulation_data = []
for trajectory_num in range(number_of_trajectories):
total_time[0] = 0
if self.stop_event.is_set():
self.rc = 33
break
elif self.pause_event.is_set():
timeStopped = timeline[entry_count]
break
# For multi trajectories, live_grapher needs to be informed of trajectory increment
if live_grapher[0] is not None:
live_grapher[0].increment_trajectory(trajectory_num)
# copy initial state data
trajectory = trajectory_base[trajectory_num]
entry_count = 1
curr_state[0] = {}
# curr_time and curr_state are list of len 1 so that __run receives reference
if resume is not None:
curr_time = [resume['time'][-1]]
else:
curr_time = [0]
for spec in model.listOfSpecies:
if resume is not None:
curr_state[0][spec] = resume[spec][-1]
else:
curr_state[0][spec] = model.listOfSpecies[
spec].initial_value
propensity_sums = np.zeros(number_reactions)
# calculate initial propensity sums
while entry_count < timeline.size:
if self.stop_event.is_set():
self.rc = 33
break
elif self.pause_event.is_set():
timeStopped = timeline[entry_count]
break
# determine next reaction
species_states = list(curr_state[0].values())
for i in range(number_reactions):
propensity_sums[i] = propensity_functions[reactions[i]][0](
species_states)
if debug:
print('propensity: ', propensity_sums[i])
propensity_sum = np.sum(propensity_sums)
if debug:
print('propensity_sum: ', propensity_sum)
# if no more reactions, quit
if propensity_sum <= 0:
trajectory[entry_count:, 1:] = list(species_states)
break
cumulative_sum = random.uniform(0, propensity_sum)
curr_time[0] += -math.log(random.random()) / propensity_sum
total_time[0] += -math.log(random.random()) / propensity_sum
if debug:
print('cumulative sum: ', cumulative_sum)
print('entry count: ', entry_count)
print('timeline.size: ', timeline.size)
print('curr_time: ', curr_time[0])
# determine time passed in this reaction
while entry_count < timeline.size and timeline[
entry_count] <= curr_time[0]:
if self.stop_event.is_set():
self.rc = 33
break
elif self.pause_event.is_set():
timeStopped = timeline[entry_count]
break
trajectory[entry_count, 1:] = species_states
entry_count += 1
for potential_reaction in range(number_reactions):
cumulative_sum -= propensity_sums[potential_reaction]
if debug:
print('if <=0, fire: ', cumulative_sum)
if cumulative_sum <= 0:
for i, spec in enumerate(model.listOfSpecies):
curr_state[0][spec] += species_changes[
potential_reaction][i]
reacName = reactions[potential_reaction]
if debug:
print('current state: ', curr_state[0])
print('species_changes: ', species_changes)
print('updating: ', potential_reaction)
species_states = list(curr_state[0].values())
for i in dependent_rxns[reacName]['dependencies']:
propensity_sums[propensity_functions[i]
[1]] = propensity_functions[i][0](
species_states)
if debug:
print('new propensity sum: ',
propensity_sums[i])
break
data = {'time': timeline}
for i in range(number_species):
data[species[i]] = trajectory[:, i + 1]
simulation_data.append(data)
# If simulation has been paused, or tstopped !=0
if timeStopped != 0 or resume is not None:
simulation_data = nputils.numpy_resume(timeStopped,
simulation_data,
resume=resume)
self.result = simulation_data
return self.result, self.rc