def test_integrate_with_expression():
"""Ensure a model with Expressions simulates."""
Monomer('s1')
Monomer('s9')
Monomer('s16')
Monomer('s20')
# Parameters should be able to contain s(\d+) without error
Parameter('ks0', 2e-5)
Parameter('ka20', 1e5)
Initial(s9(), Parameter('s9_0', 10000))
Observable('s1_obs', s1())
Observable('s9_obs', s9())
Observable('s16_obs', s16())
Observable('s20_obs', s20())
Expression('keff', (ks0 * ka20) / (ka20 + s9_obs))
Rule('R1', None >> s16(), ks0)
Rule('R2', None >> s20(), ks0)
Rule('R3', s16() + s20() >> s16() + s1(), keff)
time = np.linspace(0, 40)
solver = Solver(model, time)
solver.run()
assert solver.yexpr_view.shape == (len(time),
len(model.expressions_dynamic()))
assert solver.yobs_view.shape == (len(time), len(model.observables))
def setUp(self):
Monomer('A', ['a'])
Monomer('B', ['b'])
Parameter('ksynthA', 100)
Parameter('ksynthB', 100)
Parameter('kbindAB', 100)
Parameter('A_init', 0)
Parameter('B_init', 0)
Initial(A(a=None), A_init)
Initial(B(b=None), B_init)
Observable("A_free", A(a=None))
Observable("B_free", B(b=None))
Observable("AB_complex", A(a=1) % B(b=1))
Rule('A_synth', None >> A(a=None), ksynthA)
Rule('B_synth', None >> B(b=None), ksynthB)
Rule('AB_bind', A(a=None) + B(b=None) >> A(a=1) % B(b=1), kbindAB)
self.model = model
# Convenience shortcut for accessing model monomer objects
self.mon = lambda m: self.model.monomers[m]
# This timespan is chosen to be enough to trigger a Jacobian evaluation
# on the various solvers.
self.time = np.linspace(0, 1)
self.sim = ScipyOdeSimulator(self.model,
tspan=self.time,
integrator='vode')
def setUp(self):
Monomer('A', ['a'])
Monomer('B', ['b'])
Parameter('ksynthA', 100)
Parameter('ksynthB', 100)
Parameter('kbindAB', 100)
Parameter('A_init', 0)
Parameter('B_init', 0)
Initial(A(a=None), A_init)
Initial(B(b=None), B_init)
Observable("A_free", A(a=None))
Observable("B_free", B(b=None))
Observable("AB_complex", A(a=1) % B(b=1))
Rule('A_synth', None >> A(a=None), ksynthA)
Rule('B_synth', None >> B(b=None), ksynthB)
Rule('AB_bind', A(a=None) + B(b=None) >> A(a=1) % B(b=1), kbindAB)
self.model = model
# This timespan is chosen to be enough to trigger a Jacobian evaluation
# on the various solvers.
self.time = np.linspace(0, 1)
self.solver = Solver(self.model, self.time, integrator='vode')
def activityactivity_assemble_one_step(stmt, model, agent_set):
subj_pattern = get_complex_pattern(
model,
stmt.subj,
agent_set,
extra_fields={stmt.subj_activity: 'active'})
obj_inactive = get_complex_pattern(
model,
stmt.obj,
agent_set,
extra_fields={stmt.obj_activity: 'inactive'})
obj_active = get_complex_pattern(
model, stmt.obj, agent_set, extra_fields={stmt.obj_activity: 'active'})
param_name = 'kf_' + stmt.subj.name[0].lower() + \
stmt.obj.name[0].lower() + '_act'
kf_one_step_activate = \
get_create_parameter(model, param_name, 1e-6)
rule_name = '%s_%s_activates_%s_%s' % \
(stmt.subj.name, stmt.subj_activity, stmt.obj.name,
stmt.obj_activity)
if stmt.relationship == 'increases':
r = Rule(rule_name,
subj_pattern + obj_inactive >> subj_pattern + obj_active,
kf_one_step_activate)
else:
r = Rule(rule_name,
subj_pattern + obj_active >> subj_pattern + obj_inactive,
kf_one_step_activate)
add_rule_to_model(model, r)
def test_integrate_with_expression():
"""Ensure a model with Expressions simulates."""
Monomer('s1')
Monomer('s9')
Monomer('s16')
Monomer('s20')
# Parameters should be able to contain s(\d+) without error
Parameter('ks0', 2e-5)
Parameter('ka20', 1e5)
Initial(s9(), Parameter('s9_0', 10000))
Observable('s1_obs', s1())
Observable('s9_obs', s9())
Observable('s16_obs', s16())
Observable('s20_obs', s20())
Expression('keff', (ks0 * ka20) / (ka20 + s9_obs))
Rule('R1', None >> s16(), ks0)
Rule('R2', None >> s20(), ks0)
Rule('R3', s16() + s20() >> s16() + s1(), keff)
time = np.linspace(0, 40)
sim = ScipyOdeSimulator(model, tspan=time)
simres = sim.run()
keff_vals = simres.expressions['keff']
assert len(keff_vals) == len(time)
assert np.allclose(keff_vals, 1.8181818181818182e-05)
def test_integrate_with_expression():
"""Ensure a model with Expressions simulates."""
Monomer('s1')
Monomer('s9')
Monomer('s16')
Monomer('s20')
# Parameters should be able to contain s(\d+) without error
Parameter('ks0', 2e-5)
Parameter('ka20', 1e5)
Initial(s9(), Parameter('s9_0', 10000))
Observable('s1_obs', s1())
Observable('s9_obs', s9())
Observable('s16_obs', s16())
Observable('s20_obs', s20())
Expression('keff', (ks0 * ka20) / (ka20 + s9_obs))
Rule('R1', None >> s16(), ks0)
Rule('R2', None >> s20(), ks0)
Rule('R3', s16() + s20() >> s16() + s1(), keff)
time = np.linspace(0, 40)
x = odesolve(model, time)
def non_specific_step_8(self, i):
if i == "Ls":
if self.p_flag:
Parameter('k_grb_on', self.parameters['k_8_1'])
Parameter('k_grb_product', self.parameters['k_8_2'])
else:
Parameter('k_grb_on', 0.00005)
Parameter('k_grb_product', 0.01)
previous_product = self.step_8(i)
intermediate_product = "LATP_Grb"
product = "final_product"
if i == "Ls":
self.add_new_monomer(intermediate_product)
Rule(
"{0}_convert".format(intermediate_product),
eval('{0}()'.format(previous_product)) + Grb()
| eval('{0}()'.format(intermediate_product)), k_grb_on,
k_p_off_R_pmhc)
self.add_new_monomer(product)
Rule(
"{0}_cat".format(product),
eval('{0}()'.format(intermediate_product)) >>
LATP() + eval('{0}()'.format(product)), k_grb_product)
Rule("{0}_uncat".format(product),
eval('{0}()'.format(product)) >> Grb(), k_p_off_R_pmhc)
add_observable(product)
return product
def add_step_9(self, i):
previous_product = self.add_step_8_sos(i)
product_rd = previous_product + "_Ras_GDP"
if i == "Ls":
Parameter('k_sos_on_rgdp', 0.0024)
Parameter('k_sos_off_rgdp', 3.0)
self.add_new_monomer(product_rd)
Rule(
'{0}_bind'.format(product_rd),
eval('{0}()'.format(previous_product)) + Ras_GDP()
| eval('{0}()'.format(product_rd)), k_sos_on_rgdp, k_sos_off_rgdp)
product_rt = previous_product + "_Ras_GTP"
if i == "Ls":
Parameter('k_sos_on_rgtp', 0.0022)
Parameter('k_sos_off_rgtp', 0.4)
self.add_new_monomer(product_rt)
Rule(
'{0}_bind'.format(product_rt),
eval('{0}()'.format(previous_product)) + Ras_GTP()
| eval('{0}()'.format(product_rt)), k_sos_on_rgtp, k_sos_off_rgtp)
return product_rd, product_rt
def dephosphorylation_assemble_two_step(stmt, model, agent_set):
sub_bs = get_binding_site_name(stmt.sub.name)
phos_bs = get_binding_site_name(stmt.phos.name)
phos_bound = get_complex_pattern(model,
stmt.phos,
agent_set,
extra_fields={sub_bs: 1})
phos_unbound = get_complex_pattern(model,
stmt.phos,
agent_set,
extra_fields={sub_bs: None})
sub_pattern = get_complex_pattern(model, stmt.sub, agent_set)
param_name = 'kf_' + stmt.phos.name[0].lower() + \
stmt.sub.name[0].lower() + '_bind'
kf_bind = get_create_parameter(model, param_name, 1e-6)
param_name = 'kr_' + stmt.phos.name[0].lower() + \
stmt.sub.name[0].lower() + '_bind'
kr_bind = get_create_parameter(model, param_name, 1e-3)
param_name = 'kc_' + stmt.phos.name[0].lower() + \
stmt.sub.name[0].lower() + '_dephos'
kf_phospho = get_create_parameter(model, param_name, 1e-3)
site = site_name(stmt)[0]
phos_act_mods = get_activating_mods(stmt.phos, agent_set)
for i, am in enumerate(phos_act_mods):
rule_name = '%s_dephos_bind_%s_%s_%d' % \
(stmt.phos.name, stmt.sub.name, site, i + 1)
r = Rule(rule_name,
phos_unbound(am) + \
sub_pattern(**{site: 'p', phos_bs: None}) >>
phos_bound(am) % \
sub_pattern(**{site: 'p', phos_bs: 1}),
kf_bind, kr_bind)
add_rule_to_model(model, r)
rule_name = '%s_dephos_%s_%s_%d' % \
(stmt.phos.name, stmt.sub.name, site, i + 1)
r = Rule(rule_name,
phos_bound(am) % \
sub_pattern(**{site: 'p', phos_bs: 1}) >>
phos_unbound(am) + \
sub_pattern(**{site: 'u', phos_bs: None}),
kf_phospho)
add_rule_to_model(model, r)
rule_name = '%s_dissoc_%s' % (stmt.phos.name, stmt.sub.name)
r = Rule(rule_name, model.monomers[stmt.phos.name](**{sub_bs: 1}) % \
model.monomers[stmt.sub.name](**{phos_bs: 1}) >>
model.monomers[stmt.phos.name](**{sub_bs: None}) + \
model.monomers[stmt.sub.name](**{phos_bs: None}), kr_bind)
add_rule_to_model(model, r)
def phosphorylation_assemble_one_step(stmt, model, agent_set):
param_name = 'kf_' + stmt.enz.name[0].lower() + \
stmt.sub.name[0].lower() + '_phos'
kf_phospho = get_create_parameter(model, param_name, 1e-6)
# See NOTE in monomers_one_step
site = site_name(stmt)[0]
enz_pattern = get_complex_pattern(model, stmt.enz, agent_set)
sub_unphos = get_complex_pattern(model,
stmt.sub,
agent_set,
extra_fields={site: 'u'})
sub_phos = get_complex_pattern(model,
stmt.sub,
agent_set,
extra_fields={site: 'p'})
enz_act_mods = get_activating_mods(stmt.enz, agent_set)
for i, am in enumerate(enz_act_mods):
rule_name = '%s_phospho_%s_%s_%d' % \
(stmt.enz.name, stmt.sub.name, site, i + 1)
r = Rule(rule_name,
enz_pattern(am) + sub_unphos >> enz_pattern(am) + sub_phos,
kf_phospho)
add_rule_to_model(model, r)
def cycle_4(self, i):
if i == "Ls":
Parameter('k_p_on_zap_species',
self.rate_constants.k_p_on_zap_species)
Parameter('k_p_off_zap_species',
self.rate_constants.k_p_off_zap_species)
previous_product = self.cycle_3(i)
product = "RP{0}_Lck_Zap_P".format(i)
self.add_new_monomer(product)
Rule(
'{0}_cat'.format(product),
eval('{0}()'.format(previous_product))
| eval('{0}()'.format(product)), k_p_on_zap_species,
k_p_off_zap_species)
add_observable(product)
no_ligand = self.unbind_ligand(i, product)
if i == "Ls":
no_lck = self.lck_off(no_ligand, k_off="k_lck_off_zap_R")
self.dephosphorylate_zap(no_lck)
return product
def complex_assemble_one_step(stmt, model, agent_set):
pairs = itertools.combinations(stmt.members, 2)
for pair in pairs:
agent1 = pair[0]
agent2 = pair[1]
param_name = agent1.name[0].lower() + \
agent2.name[0].lower() + '_bind'
kf_bind = get_create_parameter(model, 'kf_' + param_name, 1e-6)
kr_bind = get_create_parameter(model, 'kr_' + param_name, 1e-6)
# Make a rule name
name_components = []
for m in pair:
for bc in m.bound_conditions:
if bc.is_bound:
name_components.append(m.name + '_' + bc.agent.name)
else:
name_components.append(m.name + '_n' + bc.agent.name)
else:
name_components.append(m.name)
# Construct full patterns of each agent with conditions
rule_name = '_'.join(name_components) + '_bind'
agent1_pattern = get_complex_pattern(model, agent1, agent_set)
agent2_pattern = get_complex_pattern(model, agent2, agent_set)
agent1_bs = get_binding_site_name(agent2.name)
agent2_bs = get_binding_site_name(agent1.name)
r = Rule(rule_name, agent1_pattern(**{agent1_bs: None}) + \
agent2_pattern(**{agent2_bs: None}) >>
agent1_pattern(**{agent1_bs: 1}) % \
agent2_pattern(**{agent2_bs: 1}),
kf_bind)
add_rule_to_model(model, r)
# In reverse reaction, assume that dissocition is unconditional
rule_name = '_'.join(name_components) + '_dissociate'
agent1_uncond = get_complex_pattern(model, ist.Agent(agent1.name),
agent_set)
agent2_uncond = get_complex_pattern(model, ist.Agent(agent2.name),
agent_set)
r = Rule(rule_name, agent1_uncond(**{agent1_bs: 1}) % \
agent2_uncond(**{agent2_bs: 1}) >>
agent1_uncond(**{agent1_bs: None}) + \
agent2_uncond(**{agent2_bs: None}),
kr_bind)
add_rule_to_model(model, r)
def rasgap_assemble_interactions_only(stmt, model, agent_set):
kf_bind = get_create_parameter(model, 'kf_bind', 1.0, unique=False)
gap = model.monomers[stmt.gap.name]
ras = model.monomers[stmt.ras.name]
r = Rule(
'%s_inactivates_%s' % (stmt.gap.name, stmt.ras.name),
gap(**{'gap_site': None}) + ras(**{'gtp_site': None}) >>
gap(**{'gap_site': 1}) + ras(**{'gtp_site': 1}), kf_bind)
add_rule_to_model(model, r)
def add_gf_bolus(model, name: str, created_monomers: List[str]):
bolus = Monomer(f'{name}_ext')
Initial(bolus(), Parameter(f'{name}_0', 0.0), fixed=True)
for created_monomer in created_monomers:
koff = Parameter(f'{name}_{created_monomer}_koff', 0.1)
kd = Parameter(f'{name}_{created_monomer}_kd', 1.0)
kon = Expression(f'{name}_{created_monomer}_kon', kd * koff)
Rule(f'{name}_ext_to_{created_monomer}',
bolus() | model.monomers[created_monomer](inh=None), kon, koff)
def activityactivity_assemble_interactions_only(stmt, model):
kf_bind = get_create_parameter(model, 'kf_bind', 1.0, unique=False)
subj = model.monomers[stmt.subj.name]
obj = model.monomers[stmt.obj.name]
subj_active_site = active_site_names[stmt.subj_activity]
obj_mod_site = default_mod_site_names[stmt.subj_activity]
r = Rule(
'%s_%s_activates_%s_%s' %
(stmt.subj.name, stmt.subj_activity, stmt.obj.name, stmt.obj_activity),
subj(**{subj_active_site: None}) + obj(**{obj_mod_site: None}) >>
subj(**{subj_active_site: 1}) % obj(**{obj_mod_site: 1}), kf_bind)
add_rule_to_model(model, r)
def dephosphorylation_assemble_interactions_only(stmt, model, agent_set):
kf_bind = get_create_parameter(model, 'kf_bind', 1.0, unique=False)
phos = model.monomers[stmt.phos.name]
sub = model.monomers[stmt.sub.name]
phos_site = active_site_names['Phosphatase']
# See NOTE in Phosphorylation.monomers_one_step
site = site_name(stmt)[0]
r = Rule(
'%s_dephospho_%s_%s' % (stmt.phos.name, stmt.sub.name, site),
phos(**{phos_site: None}) + sub(**{site: None}) >>
phos(**{phos_site: 1}) + sub(**{site: 1}), kf_bind)
add_rule_to_model(model, r)
def add_positive_feedback_nonspecific(self, i):
if i == "Ls":
if self.p_flag:
Parameter('k_latp_product', self.parameters['k_9_1'])
Parameter('k_latp_product_grb', self.parameters['k_9_2'])
Parameter('k_positive_fb', self.parameters['k_9_3'])
else:
Parameter('k_latp_product', 0.0003)
Parameter('k_latp_product_grb', 0.0004)
Parameter('k_positive_fb', 5.0)
previous_product = self.non_specific_step_8(i)
intermediate_product = "LATP_" + previous_product
intermediate_product_2 = "LATP_" + previous_product + "_Grb"
if i == "Ls":
self.add_new_monomer(intermediate_product)
Rule(
"{0}_bind".format(intermediate_product),
LATP() + eval('{0}()'.format(previous_product))
| eval('{0}()'.format(intermediate_product)), k_latp_product,
k_p_off_R_pmhc)
# self.add_observable(intermediate_product)
self.add_new_monomer(intermediate_product_2)
Rule(
"{0}_bind".format(intermediate_product_2),
eval('{0}()'.format(intermediate_product)) + Grb()
| eval('{0}()'.format(intermediate_product_2)),
k_latp_product_grb, k_p_off_R_pmhc)
Rule(
"{0}_cat".format(intermediate_product_2),
eval('{0}()'.format(intermediate_product_2)) >>
eval('{0}()'.format(intermediate_product)) +
eval('{0}()'.format(previous_product)), k_positive_fb)
return previous_product
def test_stop_if():
Model()
Monomer('A')
Rule('A_synth', None >> A(), Parameter('k', 1))
Observable('Atot', A())
Expression('exp_const', k + 1)
Expression('exp_dyn', Atot + 1)
sim = BngSimulator(model, verbose=5)
tspan = np.linspace(0, 100, 101)
x = sim.run(tspan, stop_if='Atot>9', seed=_BNG_SEED)
# All except the last Atot value should be <=9
assert all(x.observables['Atot'][:-1] <= 9)
assert x.observables['Atot'][-1] > 9
# Starting with Atot > 9 should terminate simulation immediately
y = sim.run(tspan, initials=x.species[-1], stop_if='Atot>9')
assert len(y.observables) == 1
def autophosphorylation_assemble_one_step(stmt, model, agent_set):
param_name = 'kf_' + stmt.enz.name[0].lower() + '_autophos'
kf_autophospho = get_create_parameter(model, param_name, 1e-3)
# See NOTE in monomers_one_step
site = site_name(stmt)[0]
pattern_unphos = get_complex_pattern(model,
stmt.enz,
agent_set,
extra_fields={site: 'u'})
pattern_phos = get_complex_pattern(model,
stmt.enz,
agent_set,
extra_fields={site: 'p'})
rule_name = '%s_autophospho_%s_%s' % (stmt.enz.name, stmt.enz.name, site)
r = Rule(rule_name, pattern_unphos >> pattern_phos, kf_autophospho)
add_rule_to_model(model, r)
def add_step_8_sos(self, i):
if i == "Ls":
self.model.parameters['Sos_0'].value = 2000
Parameter('k_sos_on', 0.0002 / 4)
Parameter('k_sos_off', 0.005)
previous_product = self.cycle_4(i)
product = previous_product + "_Sos"
self.add_new_monomer(product)
Rule(
"{0}_bind".format(product),
eval('{0}()'.format(previous_product)) + Sos()
| eval('{0}()'.format(product)), k_sos_on, k_sos_off)
add_observable(product)
return product
def rasgap_assemble_one_step(stmt, model, agent_set):
gap_pattern = get_complex_pattern(
model, stmt.gap, agent_set, extra_fields={stmt.gap_activity: 'active'})
ras_inactive = get_complex_pattern(model,
stmt.ras,
agent_set,
extra_fields={'GtpBound': 'inactive'})
ras_active = get_complex_pattern(model,
stmt.ras,
agent_set,
extra_fields={'GtpBound': 'active'})
param_name = 'kf_' + stmt.gap.name[0].lower() + \
stmt.ras.name[0].lower() + '_gap'
kf_gap = get_create_parameter(model, param_name, 1e-6)
r = Rule('%s_deactivates_%s' % (stmt.gap.name, stmt.ras.name),
gap_pattern + ras_active >> gap_pattern + ras_inactive, kf_gap)
add_rule_to_model(model, r)
def phosphorylation_assemble_interactions_only(stmt, model, agent_set):
kf_bind = get_create_parameter(model, 'kf_bind', 1.0, unique=False)
kr_bind = get_create_parameter(model, 'kr_bind', 1.0, unique=False)
enz = model.monomers[stmt.enz.name]
sub = model.monomers[stmt.sub.name]
# See NOTE in monomers_one_step
site = site_name(stmt)[0]
rule_name = '%s_phospho_%s_%s' % (stmt.enz.name, stmt.sub.name, site)
active_site = active_site_names['Kinase']
# Create a rule specifying that the substrate binds to the kinase at
# its active site
r = Rule(
rule_name,
enz(**{active_site: None}) + sub(**{site: None}) <>
enz(**{active_site: 1}) + sub(**{site: 1}), kf_bind, kr_bind)
add_rule_to_model(model, r)
def dephosphorylation_assemble_one_step(stmt, model, agent_set):
param_name = 'kf_' + stmt.phos.name[0].lower() + \
stmt.sub.name[0].lower() + '_dephos'
kf_dephospho = get_create_parameter(model, param_name, 1e-6)
site = site_name(stmt)[0]
phos_pattern = get_complex_pattern(model, stmt.phos, agent_set)
sub_phos = get_complex_pattern(model,
stmt.sub,
agent_set,
extra_fields={site: 'p'})
sub_unphos = get_complex_pattern(model,
stmt.sub,
agent_set,
extra_fields={site: 'u'})
r = Rule('%s_dephospho_%s_%s' % (stmt.phos.name, stmt.sub.name, site),
phos_pattern + sub_phos >> phos_pattern + sub_unphos,
kf_dephospho)
add_rule_to_model(model, r)
def transphosphorylation_assemble_one_step(stmt, model, agent_set):
param_name = ('kf_' + stmt.enz.name[0].lower() +
stmt.enz.bound_conditions[0].agent.name[0].lower() +
'_transphos')
kf = get_create_parameter(model, param_name, 1e-3)
site = site_name(stmt)[0]
enz_pattern = get_complex_pattern(model, stmt.enz, agent_set)
bound_agent = stmt.enz.bound_conditions[0].agent
sub_unphos = get_complex_pattern(model,
bound_agent,
agent_set,
extra_fields={site: 'u'})
sub_phos = get_complex_pattern(model,
bound_agent,
agent_set,
extra_fields={site: 'p'})
rule_name = '%s_transphospho_%s_%s' % (stmt.enz.name, bound_agent.name,
site)
r = Rule(rule_name, enz_pattern % sub_unphos >> \
enz_pattern % sub_phos, kf)
add_rule_to_model(model, r)
def _get_gk_model():
SelfExporter.do_export = True
Model()
Monomer('DUSP6', ['mapk1'])
Monomer('MAP2K1', ['mapk1'])
Monomer('MAPK1', ['phospho', 'map2k1', 'dusp6'], {'phospho': ['u', 'p']})
Parameter('kf_mm_bind_1', 1e-06)
Parameter('kr_mm_bind_1', 0.001)
Parameter('kc_mm_phos_1', 0.001)
Parameter('kf_dm_bind_1', 1e-06)
Parameter('kr_dm_bind_1', 0.001)
Parameter('kc_dm_dephos_1', 0.001)
Parameter('DUSP6_0', 100.0)
Parameter('MAP2K1_0', 100.0)
Parameter('MAPK1_0', 100.0)
Rule('MAP2K1_phospho_bind_MAPK1_phospho_1', MAP2K1(mapk1=None) + \
MAPK1(phospho='u', map2k1=None) >>
MAP2K1(mapk1=1) % MAPK1(phospho='u', map2k1=1), kf_mm_bind_1)
Rule('MAP2K1_phospho_MAPK1_phospho_1', MAP2K1(mapk1=1) % \
MAPK1(phospho='u', map2k1=1) >>
MAP2K1(mapk1=None) + MAPK1(phospho='p', map2k1=None), kc_mm_phos_1)
Rule(
'MAP2K1_dissoc_MAPK1',
MAP2K1(mapk1=1) % MAPK1(map2k1=1) >>
MAP2K1(mapk1=None) + MAPK1(map2k1=None), kr_mm_bind_1)
Rule(
'DUSP6_dephos_bind_MAPK1_phospho_1',
DUSP6(mapk1=None) + MAPK1(phospho='p', dusp6=None) >>
DUSP6(mapk1=1) % MAPK1(phospho='p', dusp6=1), kf_dm_bind_1)
Rule(
'DUSP6_dephos_MAPK1_phospho_1',
DUSP6(mapk1=1) % MAPK1(phospho='p', dusp6=1) >>
DUSP6(mapk1=None) + MAPK1(phospho='u', dusp6=None), kc_dm_dephos_1)
Rule(
'DUSP6_dissoc_MAPK1',
DUSP6(mapk1=1) % MAPK1(dusp6=1) >>
DUSP6(mapk1=None) + MAPK1(dusp6=None), kr_dm_bind_1)
Initial(DUSP6(mapk1=None), DUSP6_0)
Initial(MAP2K1(mapk1=None), MAP2K1_0)
Initial(MAPK1(phospho='u', map2k1=None, dusp6=None), MAPK1_0)
SelfExporter.do_export = False
return model
Parameter('kf_AG_allo2', 1000.0)
Parameter('kr_AG_allo2', 400.0)
#2-AG binding at allosteric site with 2-AG in the catalytic site
Parameter('kf_AG_allo3', 1000.0)
Parameter('kr_AG_allo3', 63000.0)
#Defining allowed reaction rules
catalyze(COX2(allo=None), 'cat', AA(), 'b', PG(),
[kf_AA_cat1, kr_AA_cat1, kcat_AA1])
bind_complex(
COX2(allo=1) % AG(b=1), 'cat', AA(), 'b', [kf_AA_cat2, kr_AA_cat2])
Rule(
'kcat_AA_2',
COX2(allo=1, cat=2) % AG(b=1) % AA(b=2) >>
COX2(allo=1, cat=None) % AG(b=1) + PG(), kcat_AA2)
bind_complex(
COX2(allo=1) % AA(b=1), 'cat', AA(), 'b', [kf_AA_cat3, kr_AA_cat3])
Rule(
'kcat_AA_3',
COX2(allo=1, cat=2) % AA(b=1) % AA(b=2) >>
COX2(allo=1, cat=None) % AA(b=1) + PG(), kcat_AA3)
catalyze(COX2(allo=None), 'cat', AG(), 'b', PGG(),
[kf_AG_cat1, kr_AG_cat1, kcat_AG1])
bind_complex(
COX2(allo=1) % AG(b=1), 'cat', AG(), 'b', [kf_AG_cat2, kr_AG_cat2])
Observable('SOCSmRNACyt', SOCSmRNA(loc='Cyt'))
Observable(
'BoundSOCS',
IFNAR1(re=1, ri=None, loc='out') % IFN_alpha2(r1=1, r2=2) %
IFNAR2(re=2, ri=3, rs=None, loc='out') % SOCS(site=3))
Observable(
'TSOCS',
IFNAR1(re=1, ri=None, loc='out') % IFN_alpha2(r1=1, r2=2) %
IFNAR2(re=2, ri=3, loc='out') % SOCS(site=3))
# =============================================================================
# # Reaction rules
# =============================================================================
# Alpha block
Rule(
'IFN_bind_R1',
IFNAR1(re=None, ri=None, loc='out') + IFN_alpha2(r1=None, r2=None)
| IFNAR1(re=1, ri=None, loc='out') % IFN_alpha2(r1=1, r2=None), ka1, kd1)
Rule(
'IFN_bind_R2',
IFNAR2(re=None, ri=None, rs=None, loc='out') + IFN_alpha2(r1=None, r2=None)
| IFNAR2(re=1, ri=None, rs=None, loc='out') % IFN_alpha2(r1=1, r2=None),
ka2, kd2)
Rule(
'IR1_bind_R2',
IFNAR1(re=1, ri=None, loc='out') % IFN_alpha2(r1=1, r2=None) +
IFNAR2(re=None, ri=None, loc='out') | IFNAR1(re=1, ri=None, loc='out') %
IFN_alpha2(r1=1, r2=2) % IFNAR2(re=2, ri=None, loc='out'), ka3, kd3)
Rule(
'IR2_bind_R1',
IFNAR2(re=1, ri=None, rs=None, loc='out') % IFN_alpha2(r1=1, r2=None) +
###################################################################################################
#RNA Pol Assembly (Ishihama81, Sequential Assembly: Two RpoA; Then RpoB; Then RpoC; Then a Sigma Factor)
cplx_rpoa_rpoa = Prot_rpoA(PBD_01 = 1, PBD_02 = None) % Prot_rpoA(PBD_01 = None, PBD_02 = 1)
cplx_rpoa_rpoa_rpob = Prot_rpoA(PBD_01 = 1, PBD_02 = 2) % Prot_rpoA(PBD_01 = None, PBD_02 = 1) % Prot_rpoB(PBD_01 = 2, PBD_02 = None)
cplx_rpoa_rpoa_rpob_rpoc = Prot_rpoA(PBD_01 = 1, PBD_02 = 2) % Prot_rpoA(PBD_01 = 3, PBD_02 = 1) % Prot_rpoB(PBD_01 = 2, PBD_02 = 4) % Prot_rpoC(PBD_01 = 3, PBD_02 = 4)
cplx_rnap70 = RNAP(DBD_01 = None, PBD_01 = 2, RBD_01 = None) % Prot_rpoD(PBD_01 = 2)
cplx_rnap24 = RNAP(DBD_01 = None, PBD_01 = 2, RBD_01 = None) % Prot_rpoE(PBD_01 = 2)
cplx_rnap32 = RNAP(DBD_01 = None, PBD_01 = 2, RBD_01 = None) % Prot_rpoH(PBD_01 = 2)
cplx_rnap28 = RNAP(DBD_01 = None, PBD_01 = 2, RBD_01 = None) % Prot_fliA(PBD_01 = 2)
cplx_rnap54 = RNAP(DBD_01 = None, PBD_01 = 2, RBD_01 = None) % Prot_rpoN(PBD_01 = 2)
cplx_rnap38 = RNAP(DBD_01 = None, PBD_01 = 2, RBD_01 = None) % Prot_rpoS(PBD_01 = 2)
cplx_rnap19 = RNAP(DBD_01 = None, PBD_01 = 2, RBD_01 = None) % Prot_fecI(PBD_01 = 2)
Rule('rpoa_rpoa', free_rpoa + free_rpoa != cplx_rpoa_rpoa,
Parameter('rpoa_rpoa_fwd', 1),
Parameter('rpoa_rpoa_rvs', 1))
Rule('rpoa_rpoa_rpob', free_rpob + cplx_rpoa_rpoa != cplx_rpoa_rpoa_rpob,
Parameter('rpoa_rpoa_rpob_fwd', 1),
Parameter('rpoa_rpoa_rpob_rvs', 1))
Rule('rpoa_rpoa_rpob_rpoc', free_rpoc + cplx_rpoa_rpoa_rpob != cplx_rpoa_rpoa_rpob_rpoc + cplx_rnap,
Parameter('rpoa_rpoa_rpob_rpoc_fwd', 1),
Parameter('rpoa_rpoa_rpob_rpoc_rvs', 1))
Rule('rpoa_rpoa_rpob_rpoc_rpod', cplx_rnap + free_rpod != cplx_rnap70,
Parameter('rpoa_rpoa_rpob_rpoc_rpod_fwd', 1),
Parameter('rpoa_rpoa_rpob_rpoc_rpod_rvs', 1))
Rule('rpoa_rpoa_rpob_rpoc_rpoe', cplx_rnap + free_rpoe != cplx_rnap24,
Observable('Atot', A())
Observable('Btot', B())
Observable('Ctot', C())
Observable('AB0', A(b=MultiState(None, None, None)), match='species')
Observable('AB1', A(b=MultiState(1, None, None)) % B(a=1), match='species')
Observable('AB2',
A(b=MultiState(1, 2, None)) % B(a=1) % B(a=2),
match='species')
Observable('AB3',
A(b=MultiState(1, 2, 3)) % B(a=1) % B(a=2) % B(a=3),
match='species')
Observable('AB_motif', A(b=1) % B(a=1))
Tag('x')
Expression('f_synth', k_synthC * AB_motif(x)**2)
# A synthesizes C with rate dependent on bound B
Rule('_R1', A() @ x >> A() @ x + C(), f_synth)
# A binds B
Rule('_R2', A(b=None) + B(a=None) | A(b=1) % B(a=1), kp, km)
# degradation of C
Rule('_R3', C() >> None, k_degrC)
Initial(A(b=MultiState(None, None, None)), Ab_b_b_0)
Initial(B(a=None), Ba_0)
Initial(C(), C_0)
def add_step_10(self, i):
previous_product_rd, previous_product_rt = self.add_step_9(i)
product_rt_rd = previous_product_rt + "_Ras_GDP"
if i == "Ls":
Parameter('k_rgdp_on_sos_rgtp', 0.001)
Parameter('k_rgdp_off_sos_rgtp', 0.1)
Parameter('k_cat_3', 0.038 * 1.7)
self.add_new_monomer(product_rt_rd)
Rule(
'{0}_bind'.format(product_rt_rd),
eval('{0}()'.format(previous_product_rt)) + Ras_GDP()
| eval('{0}()'.format(product_rt_rd)), k_rgdp_on_sos_rgtp,
k_rgdp_off_sos_rgtp)
Rule(
'{0}_cat'.format(product_rt_rd),
eval('{0}()'.format(product_rt_rd)) >>
eval('{0}()'.format(previous_product_rt)) + Ras_GTP(), k_cat_3)
product_rd_rd = previous_product_rd + "_Ras_GDP"
if i == "Ls":
Parameter('k_rgdp_on_sos_rgdp', 0.0014)
Parameter('k_rgdp_off_sos_rgdp', 1.0)
Parameter('k_cat_4', 0.003)
self.add_new_monomer(product_rd_rd)
Rule(
'{0}_bind'.format(product_rd_rd),
eval('{0}()'.format(previous_product_rd)) + Ras_GDP()
| eval('{0}()'.format(product_rd_rd)), k_rgdp_on_sos_rgdp,
k_rgdp_off_sos_rgdp)
Rule(
'{0}_cat'.format(product_rd_rd),
eval('{0}()'.format(product_rd_rd)) >>
eval('{0}()'.format(previous_product_rd)) + Ras_GTP(), k_cat_4)
# Deactivate - convert Ras_GTP to Ras_GDP
product = "Ras_GAP_Ras_GTP"
new_product = "Ras_GTP"
if i == "Ls":
Parameter('k_rgap_on_rgtp', 0.0348)
Parameter('k_rgap_off_rgtp', 0.2)
Parameter('k_cat_5', 0.1)
self.add_new_monomer(product)
Rule('{0}_bind'.format(product),
Ras_GAP() + Ras_GTP() | eval('{0}()'.format(product)),
k_rgap_on_rgtp, k_rgap_off_rgtp)
add_observable(product)
Rule('{0}_cat'.format(product),
eval('{0}()'.format(product)) >> Ras_GAP() + Ras_GDP(),
k_cat_5)
add_observable(new_product)
return new_product