def test_diffusion_field(config=get_gaussian_config(), time=10):
diffusion = DiffusionField(config)
settings = {
'return_raw_data': True,
'total_time': time,
'timestep': 1}
return simulate_process(diffusion, settings)
def run_template_process():
'''Run a simulation of the process.
Returns:
The simulation output.
'''
# initialize the process by passing in parameters
parameters = {}
template_process = Template(parameters)
# declare the initial state, mirroring the ports structure
initial_state = {
'internal': {
'A': 0.0
},
'external': {
'A': 1.0
},
}
# run the simulation
sim_settings = {'total_time': 10, 'initial_state': initial_state}
output = simulate_process(template_process, sim_settings)
return output
def test_output_port() -> None:
a_default = 1
b_default = 2
class InputOutput(Process):
def ports_schema(self) -> Schema:
return {
'input': {
'A': {
'_default': a_default,
'_emit': True,
}
},
'output': {
'_output': True,
'B': {
'_default': b_default,
'_emit': True,
}
}
}
def next_update(self, timestep: Union[float, int],
states: State) -> Update:
assert not states['output'], 'outputs should be masked'
return {}
total_time = 10
data = simulate_process(InputOutput(), {'total_time': total_time})
assert data['input']['A'] == [a_default for _ in range(total_time + 1)]
assert data['output']['B'] == [b_default for _ in range(total_time + 1)]
def test_toy_metabolism(total_time=15):
regulation_logic = {
'R4': 'if (external, O2) > 0.1 and not (external, F) < 0.1'
}
toy_config = get_toy_configuration()
toy_config['regulation'] = regulation_logic
toy_config['target_added_mass'] = None
toy_metabolism = COBRA_FBA(toy_config)
# simulate toy model
interval = int(total_time / 3)
timeline = [(interval, {
('external', 'A'): 1
}), (2 * interval, {
('external', 'F'): 0
}), (total_time, {})]
settings = {
'initial_state': toy_metabolism.initial_state(),
# 'total_time': total_time,
'timeline': {
'timeline': timeline,
'time_step': 10
}
}
return simulate_process(toy_metabolism, settings)
def run_injector():
parameters = {
'substrate_rate_map': {
'toy': 1.0
},
}
injector = Injector(parameters)
settings = {
'total_time': 10,
}
timeseries = simulate_process(injector, settings)
return timeseries
def test_diffusion_field(
config={},
initial_state={},
time=10,
):
diffusion = DiffusionField(config)
settings = {
'return_raw_data': True,
'initial_state': initial_state,
'total_time': time,
'timestep': 1}
return simulate_process(diffusion, settings)
def run_process():
parameters = {
'nodes': ['D', 'I'],
'edges': [(('D', 0), ('I', 0))],
'conditional_probabilities': {}
}
process = DynamicBayesianNetwork(parameters)
initial_state = {}
sim_settings = {'total_time': 10, 'initial_state': initial_state}
output = simulate_process(process, sim_settings)
return output
def run_bioscrape_process():
#Create a bioscrape process
initial_parameters = {'sbml_file': 'Notebooks/model1.xml'}
bioscrape_process = Bioscrape(initial_parameters)
# run the simulation
sim_settings = {
'total_time': 10,
'initial_state': bioscrape_process.initial_state()
}
output = simulate_process(bioscrape_process, sim_settings)
# Return the data from the simulation.
return output
def run_process():
parameters = {
'network': [('D', 'G'), ('I', 'G'), ('G', 'L'), ('I', 'S')],
'conditional_probabilities': {
'D': [[0.6], [0.4]],
'I': [[0.7], [0.3]],
'G': [[0.3, 0.05, 0.9, 0.5], [0.4, 0.25, 0.08, 0.3],
[0.3, 0.7, 0.02, 0.2]],
'L': [[0.1, 0.4, 0.99], [0.9, 0.6, 0.01]],
'S': [[0.95, 0.2], [0.05, 0.8]],
}
}
process = PGM(parameters)
initial_state = {}
sim_settings = {'total_time': 10, 'initial_state': initial_state}
output = simulate_process(process, sim_settings)
return output
def test_rna_degradation(end_time=10):
rna_degradation = RnaDegradation(TOY_CONFIG)
# initial state
proteins = {protein: 10 for protein in rna_degradation.protein_order}
molecules = {molecule: 10 for molecule in rna_degradation.molecule_order}
transcripts = {
transcript: 10
for transcript in rna_degradation.transcript_order
}
settings = {
'total_time': end_time,
'initial_state': {
'molecules': molecules,
'proteins': proteins,
'transcripts': transcripts
}
}
return simulate_process(rna_degradation, settings)
def run_dynamic_modeler():
epsilon = 10
initial_pmf = -140
recalculate = RecalculateFlagella(epsilon, initial_pmf)
parameters = {
'generate_source': FlagellaMotor,
'generate_target': DynamicBayesian,
'recalculate_condition': recalculate.recalculate,
'learn_structure': learn_dynamic_bayesian,
'transform_target': bayesian_flagella,
}
process = DynamicModeler(parameters)
initial_state = {}
sim_settings = {
'total_time': 10,
'initial_state': initial_state}
output = simulate_process(process, sim_settings)
return output
def run_inclusion_body(out_dir='out'):
# initialize the process by passing initial_parameters
initial_parameters = {'growth_rate': 1e-1}
inclusion_body_process = InclusionBody(initial_parameters)
# get initial state
initial_state = inclusion_body_process.initial_state({
'initial_mass': 1.0,
'molecules': {
'biomass': 1.0
}
})
# run the simulation
sim_settings = {'initial_state': initial_state, 'total_time': 100}
output = simulate_process(inclusion_body_process, sim_settings)
# plot the simulation output
plot_settings = {}
plot_simulation_output(output, plot_settings, out_dir)
def test_load_file():
parameters = {
'file': 'vivarium_smoldyn/examples/template.txt'
}
smoldyn = Smoldyn(parameters)
# declare the initial state
initial_state = {
'molecules': {
'E': 10,
'S': 1000}}
# run the simulation
sim_settings = {
'total_time': 100,
'initial_state': initial_state}
output = simulate_process(
smoldyn,
sim_settings)
import ipdb; ipdb.set_trace()
def test_smoldyn_process(
animate=False
):
# initialize the process by passing in parameters
parameters = {
'animate': animate,
'species': {
'X': {'difc': 0},
'A': {'difc': 1},
'B': {'difc': 1},
'A2': {'difc': 1},
'B2': {'difc': 1}},
'reactions': {
'express': {
'subs': ['X'],
'prds': [
'X', 'A', 'B'],
'rate': 1},
'Adimer': {
'subs': ['A', 'A'],
'prds': ['A2'],
'rate': 1},
'Adimer_reverse': {
'subs': ['A2'],
'prds': ['A', 'A'],
'rate': 1},
'Bdimer': {
'subs': ['B', 'B'],
'prds': ['B2'],
'rate': 1},
'Bdimer_reverse': {
'subs': ['B2'],
'prds': ['B', 'B'],
'rate': 1},
'AxB': {
'subs': ['A2', 'B'],
'prds': ['A2'],
'rate': 1},
'Adegrade': {
'subs': ['A'],
'prds': [],
'rate': 1},
'Bdegrade': {
'subs': ['B'],
'prds': [],
'rate': 1}}}
process = Smoldyn(parameters)
# declare the initial state
initial_state = {
'molecules': {
'X': 10}}
# run the simulation
sim_settings = {
'total_time': 100,
'initial_state': initial_state}
output = simulate_process(
process,
sim_settings)
return output
def run_CPM(cpm_config=get_cpm_minimum_config(), time=5):
# load process
CPM = CellularPotts(cpm_config)
settings = {'return_raw_data': True, 'total_time': 10, 'timestep': 1}
return simulate_process(CPM, settings)
'_emit': True,
}
},
'global': {},
}
def derivers(self):
return {
'my_deriver': {
'deriver': 'mass_deriver',
'port_mapping': {
'global': 'global',
},
'config': {},
},
}
if __name__ == '__main__':
parameters = {
'k_cat': 1.5,
}
my_process = GlucosePhosphorylation(parameters)
settings = {
'total_time': 10,
'timestep': 0.1,
}
timeseries = simulate_process(my_process, settings)
plot_simulation_output(timeseries, {}, './')
def test_toxin_antitoxin(time=10):
toxin_antitoxin = ToxinAntitoxin({})
settings = {'total_time': time}
return simulate_process(toxin_antitoxin, settings)
