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