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) 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 # 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 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 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 get_create_observable(model, agent): site_pattern = pa.get_site_pattern(agent) obs_name = pa.get_agent_rule_str(agent) + '_obs' monomer = model.monomers[pa._n(agent.name)] obs = Observable(obs_name.encode('utf-8'), monomer(site_pattern)) model.add_component(obs) return obs
def add_or_get_modulator_obs(model: Model, modulator: str): """ Adds an observable to the model that tracks the specified modulator :param model: model to which the observable will be added :param modulator: string definition of an observable in format `{monomer_name}__{site}_{site_condition}` """ mod_name = f'{modulator}_obs' if mod_name in model.observables.keys(): modulator_obs = model.observables[f'{modulator}_obs'] else: desc = modulator.split('__') mono_name = desc[0] if len(desc) > 1: site_conditions = desc[1:] else: site_conditions = [] try: site_conditions = { cond.split('_')[0]: cond.split('_')[1] for cond in site_conditions } except IndexError: raise ValueError(f'Malformed site condition {site_conditions}') modulator_obs = Observable( mod_name, model.components[mono_name](**site_conditions)) return modulator_obs
def _check_regulate_activity(self, stmt): """Check a RegulateActivity statement.""" logger.info('Checking stmt: %s' % stmt) # FIXME Currently this will match rules with the corresponding monomer # pattern from the Activation/Inhibition statement, which will nearly # always have no state conditions on it. In future, this statement foo # should also match rules in which 1) the agent is in its active form, # or 2) the agent is tagged as the enzyme in a rule of the appropriate # activity (e.g., a phosphorylation rule) FIXME subj_mp = pa.get_monomer_pattern(self.model, stmt.subj) target_polarity = 1 if stmt.is_activation else -1 # This may fail, since there may be no rule in the model activating the # object, and the object may not have an "active" site of the # appropriate type obj_obs_name = pa.get_agent_rule_str(stmt.obj) + '_obs' try: obj_site_pattern = pa.get_site_pattern(stmt.obj) obj_site_pattern.update({stmt.obj_activity: 'active'}) obj_monomer = self.model.monomers[stmt.obj.name] obj_mp = obj_monomer(**obj_site_pattern) except Exception as e: logger.info("Could not create obj monomer pattern: %s" % e) return False obj_obs = Observable(obj_obs_name, obj_mp, _export=False) return self._find_im_paths(subj_mp, obj_obs, target_polarity)
def add_obs_for_agents(main_agent, ref_agents=None): if ref_agents: all_agents = [main_agent] + ref_agents else: all_agents = [main_agent] ag_to_obj_mps = self.get_all_mps(all_agents, mapping=True) if all([not v for v in ag_to_obj_mps.values()]): logger.debug('No monomer patterns found in model for agents %s' ', skipping' % all_agents) return obs_nodes = NodesContainer(main_agent, ref_agents) main_obs_set = set() ref_obs_set = set() for agent in ag_to_obj_mps: for obj_mp in ag_to_obj_mps[agent]: obs_name = _monomer_pattern_label(obj_mp) + '_obs' self.obs_to_agents[obs_name] = agent # Add the observable obj_obs = Observable(obs_name, obj_mp, _export=False) if agent.matches(main_agent): main_obs_set.add(obs_name) else: ref_obs_set.add(obs_name) try: self.model.add_component(obj_obs) self.model.add_annotation( Annotation(obs_name, agent.name, 'from_indra_agent')) except ComponentDuplicateNameError as e: pass obs_nodes.main_interm = main_obs_set obs_nodes.ref_interm = ref_obs_set return obs_nodes
def add_observables(model): data = process_data.read_data() ab_map = process_data.get_antibody_map(data) for ab_name, agents in ab_map.items(): patterns = [] for agent in agents: try: monomer = model.monomers[agent.name] except KeyError: continue if agent.mods: mc = agent.mods[0] site_names = ['phospho', mc.residue] if mc.position is not None: site_names.append(mc.residue + mc.position) for site_name in site_names: try: pattern = monomer(**{site_name: 'p'}) patterns.append(ComplexPattern([pattern], None)) except Exception: pass else: patterns.append(ComplexPattern([monomer()], None)) if patterns: if model.monomers.get(ab_name) is not None: obs_name = ab_name + '_obs' else: obs_name = ab_name if not re.match(r'[_a-z][_a-z0-9]*\Z', obs_name, re.IGNORECASE): obs_name = obs_name.replace('-', '_') if not re.match(r'[_a-z][_a-z0-9]*\Z', obs_name, re.IGNORECASE): obs_name = 'p' + obs_name o = Observable(obs_name, ReactionPattern(patterns)) model.add_component(o) '''
def add_observables(model: Model): """ Adds a observable that tracks the normalized absolute abundance of all phosphorylated site combinations for all monomers """ for monomer in model.monomers: Observable(f't{monomer.name}', monomer()) psites = [ site for site in monomer.site_states.keys() if re.match(r'[YTS][0-9]+$', site) ] for nsites in range(1, len(psites) + 1): for sites in itt.combinations(psites, nsites): sites = sorted(sites) Observable(f'p{monomer.name}_{"_".join(sites)}', monomer(**{site: 'p' for site in sites}))
def add_abundance_observables(model): """ Adds an observable that tracks the normalized absolute abundance of a protein """ for monomer in model.monomers: obs = Observable(f'total_{monomer.name}', monomer()) scale = Parameter(f't{monomer.name}_scale', 1.0) offset = Parameter(f't{monomer.name}_offset', 1.0) Expression(f't{monomer.name}_obs', sp.log(scale * (obs + offset)))
def add_phospho_observables(model): """ Adds an observable that tracks the normalized absolute abundance of a phosphorylated site """ for monomer in model.monomers: for site in monomer.site_states: if re.match(r'[YTS][0-9]+$', site): obs = Observable(f'p{monomer.name}_{site}', monomer(**{site: 'p'})) scale = Parameter(f'p{monomer.name}_{site}_scale', 1.0) offset = Parameter(f'p{monomer.name}_{site}_offset', 1.0) Expression(f'p{monomer.name}_{site}_obs', sp.log(scale * (obs + offset)))
def get_create_observable(model, agent): site_pattern = pa.get_site_pattern(agent) obs_name = pa.get_agent_rule_str(agent) + '_obs' try: monomer = model.monomers[pa._n(agent.name)] except KeyError: raise MissingMonomerError('%s is not in the model ' % agent.name) try: monomer_state = monomer(site_pattern) except Exception as e: msg = 'Site pattern %s invalid for monomer %s' % \ (site_pattern, monomer.name) raise MissingMonomerSiteError(msg) obs = Observable(obs_name, monomer(site_pattern)) model.add_component(obs) return obs
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 add_obs_for_agent(agent): obj_mps = list(pa.grounded_monomer_patterns(self.model, agent)) if not obj_mps: logger.debug('No monomer patterns found in model for agent %s, ' 'skipping' % agent) return obs_list = [] for obj_mp in obj_mps: obs_name = _monomer_pattern_label(obj_mp) + '_obs' # Add the observable obj_obs = Observable(obs_name, obj_mp, _export=False) obs_list.append(obs_name) try: self.model.add_component(obj_obs) except ComponentDuplicateNameError as e: pass return obs_list
def set_model_observables(model): print('Setting model observables') s6 = model.monomers['RPS6'] site_patterns = [{ 'S235': 'p', 'S236': 'u' }, { 'S235': 'u', 'S236': 'p' }, { 'S235': 'p', 'S236': 'p' }] pattern_terms = [ ComplexPattern([s6(**pat)], None) for pat in site_patterns ] obs_pattern = ReactionPattern(pattern_terms) obs = Observable('pS6', obs_pattern, _export=False) model.add_component(obs)
def _check_modification(self, stmt): """Check a Modification statement.""" # Identify the observable we're looking for in the model, which # may not exist! # The observable is the modified form of the substrate logger.info('Checking stmt: %s' % stmt) # Look for an agent with the appropriate grounding in the model if stmt.enz is not None: enz_mps = list(pa.grounded_monomer_patterns(self.model, stmt.enz)) if not enz_mps: logger.info('No monomers found corresponding to agent %s' % stmt.enz) return False else: enz_mps = [None] # Get target polarity demodify_list = (Dephosphorylation, Dehydroxylation, Desumoylation, Deacetylation, Deglycosylation, Deribosylation, Deubiquitination, Defarnesylation) target_polarity = -1 if type(stmt) in demodify_list else 1 # Add modification to substrate agent # TODO TODO TODO: Should be updated to get a valid mod condition name mod_condition_name = stmt.__class__.__name__.lower() if mod_condition_name.startswith('de'): mod_condition_name = mod_condition_name[2:] # TODO TODO TODO modified_sub = _add_modification_to_agent(stmt.sub, mod_condition_name, stmt.residue, stmt.position) obs_name = pa.get_agent_rule_str(modified_sub) + '_obs' obj_mps = list(pa.grounded_monomer_patterns(self.model, modified_sub)) if not obj_mps: logger.info('Failed to create observable; returning False') return False # Try to find paths between pairs of matching subj and object monomer # patterns for enz_mp, obj_mp in itertools.product(enz_mps, obj_mps): obj_obs = Observable(obs_name, obj_mp, _export=False) # Return True for the first valid path we find if self._find_im_paths(enz_mp, obj_obs, target_polarity): return True # If we got here, then there was no path for any observable return False
def add_or_get_modulator_obs(model: Model, modulator: str): """ Adds an observable to the model that tracks the specified modulator :param model: model to which the observable will be added :param modulator: string definition of an observable in format `{monomer_name}__{site}_{site_condition}` """ mod_name = f'{modulator}_obs' if mod_name in model.observables.keys(): modulator_obs = model.observables[f'{modulator}_obs'] else: mono_name, site_conditions = site_states_from_string(modulator) # uninhibited site_conditions['inh'] = None modulator_obs = Observable( mod_name, model.components[mono_name](**site_conditions)) return modulator_obs
def add_inhibitor(model: Model, name: str, targets: List[str]): inh = Parameter(f'{name}_0', 0.0) kd = Parameter(f'{name}_kd', 0.0) affinities = { target: Expression(f'inh_{target}', Observable(f'target_{target}', model.monomers[target]) / kd) for target in targets } for expr in model.expressions: if expr.name.startswith('inh_'): continue target = next( (next(mp.monomer.name for cp in s.reaction_pattern.complex_patterns for mp in cp.monomer_patterns if mp.monomer.name in targets) for s in expr.expr.free_symbols if isinstance(s, Observable) and any( mp.monomer.name in targets for cp in s.reaction_pattern.complex_patterns for mp in cp.monomer_patterns)), None) if target is None: continue expr.expr *= 1 / (1 + inh * affinities[target])
lopez_modules.lopez_pore_formation() apoptosis_modules.apoptosis_sensitizer_translocation() apoptosis_modules.apoptosis_bim_and_puma_bind_anti_apoptotics() apoptosis_modules.apoptosis_bim_activate_bax() albeck_modules.pore_to_parp() ## Crosstalk between MAPK and AKT pathways crosstalk_modules.crosstalk_mapk_akt_monomers() crosstalk_modules.crosstalk_mapk_akt_initial() crosstalk_modules.crosstalk_mapk_akt_events() # ## Crosstalk between ErbB signaling and apoptotic signaling crosstalk_modules.crosstalk_erbb_apoptosis_monomers() crosstalk_modules.crosstalk_erbb_apoptosis_initial() crosstalk_modules.crosstalk_erbb_apoptosis_events() # ## Observables #Observable('obsAKTPP', AKT(bpip3=None, bpdk1=None, S='PP')) #Observable('obsErbB1_P_CE', erbb(ty='1', st='P')) #Observable('obsERKPP', ERK(st='PP')) #Observable('active_mTORC1', mTOR(S2448='P')) #Observable('S6K_PP', S6K(T252='P', T412='P')) Observable('mBid', Bid(state='M')) Observable('aSmac', Smac(state='A')) Observable('cPARP', PARP(state='C')) Observable('obsPARP', PARP(state='U')) #Observable('nuclear_FOXO', FOXO(loc='N')) #Observable('mito_Puma', Puma(state='M')) #Observable('mito_Bad', Bad(state='M')) #Observable('mito_Bim', Bim(state='M'))
Initial(DNA_rpoS(type = 'RBS'), Parameter('t0_DNA_rpoS_RBS', 1)) Initial(DNA_rpoS(type = 'CDS'), Parameter('t0_DNA_rpoS_CDS', 1)) Initial(DNA_rpoS(type = 'T1'), Parameter('t0_DNA_rpoS_T1', 1)) Monomer('DNA_fecI', ['type'], {'type': ['P1', 'RBS', 'CDS', 'T1']}) Initial(DNA_fecI(type = 'P1'), Parameter('t0_DNA_fecI_P1', 1)) Initial(DNA_fecI(type = 'RBS'), Parameter('t0_DNA_fecI_RBS', 1)) Initial(DNA_fecI(type = 'CDS'), Parameter('t0_DNA_fecI_CDS', 1)) Initial(DNA_fecI(type = 'T1'), Parameter('t0_DNA_fecI_T1', 1)) ################################################################################################### # RNA Monomer('RNA_rpoA', ['type', 'up', 'dw'], {'type': ['RBS', 'CDS']}) Initial(RNA_rpoA(type = 'RBS', up = None, dw = None), Parameter('t0_RNA_rpoA_RBS', 186)) # Recuerda dividir todo por 10 Initial(RNA_rpoA(type = 'CDS', up = None, dw = None), Parameter('t0_RNA_rpoA_CDS', 186)) Observable('rpoA_RNA', RNA_rpoA(type = 'CDS', up = WILD, dw = WILD)) Monomer('RNA_rpoB', ['type', 'up', 'dw'], {'type': ['RBS', 'CDS']}) Initial(RNA_rpoB(type = 'RBS', up = None, dw = None), Parameter('t0_RNA_rpoB_RBS', 60)) Initial(RNA_rpoB(type = 'CDS', up = None, dw = None), Parameter('t0_RNA_rpoB_CDS', 60)) Observable('rpoB_RNA', RNA_rpoB(type = 'CDS', up = WILD, dw = WILD)) Monomer('RNA_rpoC', ['type', 'up', 'dw'], {'type': ['RBS', 'CDS']}) Initial(RNA_rpoC(type = 'RBS', up = None, dw = None), Parameter('t0_RNA_rpoC_RBS', 72)) Initial(RNA_rpoC(type = 'CDS', up = None, dw = None), Parameter('t0_RNA_rpoC_CDS', 72)) Observable('rpoC_RNA', RNA_rpoC(type = 'CDS', up = WILD, dw = WILD)) Monomer('RNA_rpoD', ['type', 'up', 'dw'], {'type': ['RBS', 'CDS']}) Initial(RNA_rpoD(type = 'RBS', up = None, dw = None), Parameter('t0_RNA_rpoD_RBS', 68)) Initial(RNA_rpoD(type = 'CDS', up = None, dw = None), Parameter('t0_RNA_rpoD_CDS', 68)) Observable('rpoD_RNA', RNA_rpoD(type = 'CDS', up = WILD, dw = WILD))
INPUT_MAPK1_dephosphorylation_Y187_base_kcat * MAPK1_dephosphorylation_Y187_base_kcat) Expression( 'MAPK1_dephosphorylation_T185_base_rate', INPUT_MAPK1_dephosphorylation_T185_base_kcat * MAPK1_dephosphorylation_T185_base_kcat) Expression( 'MAPK3_dephosphorylation_T202_base_rate', INPUT_MAPK3_dephosphorylation_T202_base_kcat * MAPK3_dephosphorylation_T202_base_kcat) Expression( 'MAPK3_dephosphorylation_Y204_base_rate', INPUT_MAPK3_dephosphorylation_Y204_base_kcat * MAPK3_dephosphorylation_Y204_base_kcat) Observable('EGF_obs', EGF(inh=None)) Observable('EGFR__Y1173_p_obs', EGFR(Y1173='p', inh=None)) Observable('ERBB2__Y1248_p_obs', ERBB2(Y1248='p', inh=None)) Observable('RAF1__S338_p_obs', RAF1(S338='p', inh=None)) Observable('BRAF__S445_p_obs', BRAF(S445='p', inh=None)) Observable('MAP2K1__S218_p__S222_p_obs', MAP2K1(S218='p', S222='p', inh=None)) Observable('MAP2K2__S222_p__S226_p_obs', MAP2K2(S226='p', S222='p', inh=None)) Observable('ERK_T202_Y204', MAPK1(Y187='p', T185='p') + MAPK3(T202='p', Y204='p')) Observable('MEK_S221', MAP2K1(S222='p') + MAP2K2(S226='p')) Observable('target_EGFR', EGFR()) Observable('target_MAP2K1', MAP2K1()) Observable('target_MAP2K2', MAP2K2()) Observable('tEGF', EGF()) Observable('tEGF_ext', EGF_ext()) Observable('tEGFR', EGFR())
Ea0_RR, energy=True) #RAF and RAFi binding EnergyPattern('ep_RI', R(i=1) % I(r=1), Gf_RI) EnergyPattern('ep_RRI', R(r=1, i=None) % R(r=1, i=2) % I(r=2), f_Gf) EnergyPattern('ep_IRRI', I(r=3) % R(r=1, i=3) % R(r=1, i=2) % I(r=2), Expression('fg_G', f_Gf + g_Gf)) Rule('RAF_binds_RAFi', R(i=None) + I(r=None) | R(i=1) % I(r=1), phi, Ea0_RI, energy=True) #Initial concentrations, mol/L Parameter('R_0', 0.01) Parameter('I_0', 0) #Set initial concentrations Initial(R(r=None, i=None), R_0) Initial(I(r=None), I_0) #Observables (all possible R and I combination independent of A) Observable('R_obs', R(r=None, i=None)) Observable('I_obs', I(r=None)) Observable('RR_obs', R(r=1, i=None) % R(r=1, i=None)) Observable('RI_obs', R(r=None, i=1) % I(r=1)) Observable('RRI_obs', R(r=1, i=None) % R(r=1, i=2) % I(r=2)) Observable('IRRI_obs', I(r=2) % R(r=1, i=2) % R(r=1, i=3) % I(r=3))
# ============================================================================= # # Seed Species # ============================================================================= Initial(IFN_alpha2(r1=None, r2=None), I) Initial(IFNAR1(re=None, ri=None, loc='out'), R1) Initial(IFNAR2(re=None, ri=None, rs=None, loc='out'), R2) Initial(STAT(j='U', loc='Cyt', fdbk=None), S) # ============================================================================= # # Observables # Use 'WILD' for ?, use 'ANY' for + # ============================================================================= Observable('Free_Ia', IFN_alpha2(r1=None, r2=None)) Observable('Free_R1', IFNAR1(re=None, ri=None, loc='out')) Observable('Free_R2', IFNAR2(re=None, ri=None, rs=None, loc='out')) Observable('R1Ia', IFNAR1(re=1, ri=None, loc='out') % IFN_alpha2(r1=1, r2=None)) Observable( 'R2Ia', IFNAR2(re=1, ri=None, rs=None, loc='out') % IFN_alpha2(r1=1, r2=None)) Observable('IntR1', IFNAR1(re=WILD, ri=WILD, loc='in')) Observable('IntR2', IFNAR2(re=WILD, ri=WILD, rs=WILD, loc='in')) Observable('R1surface', IFNAR1(re=WILD, ri=WILD, loc='out')) Observable('R2surface', IFNAR2(re=WILD, ri=WILD, rs=WILD, loc='out')) Observable( 'T',
# exported from PySB model 'model' from pysb import Model, Monomer, Parameter, Expression, Compartment, Rule, Observable, Initial, MatchOnce, Annotation, ANY, WILD Model() Monomer('A', ['B']) Monomer('B', ['A']) Parameter('inhibition_0_A_inhibitor_B_inh_target_2kf_0', 1.5e-05) Parameter('inhibition_0_A_inhibitor_B_inh_target_1kr_0', 0.00012) Parameter('A_0', 200000.0) Parameter('B_0', 50000.0) Observable('A_obs', A()) Observable('B_obs', B()) Rule('inhibition_0_A_inhibitor_B_inh_target', A(B=None) + B(A=None) | A(B=1) % B(A=1), inhibition_0_A_inhibitor_B_inh_target_2kf_0, inhibition_0_A_inhibitor_B_inh_target_1kr_0) Initial(A(B=None), A_0) Initial(B(A=None), B_0) Observable('AB_complex', A(B=1) % B(A=1))
Model() Monomer('A', ['b', 'b', 'b']) Monomer('B', ['a']) Monomer('C') Parameter('kp', 0.5) Parameter('km', 0.1) Parameter('k_synthC', 1e3) Parameter('k_degrC', 0.5) Parameter('Ab_b_b_0', 1.0) Parameter('Ba_0', 3.0) Parameter('C_0', 0.0) 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)
Expression('FLT3_dephosphorylation_Y843_base_rate', FLT3_dephosphorylation_Y843_base_kcat*INPUT_FLT3_dephosphorylation_Y843_base_kcat) Expression('HRAS_gdp_exchange_N_base_rate', HRAS_gdp_exchange_N_base_kcat*INPUT_HRAS_gdp_exchange_N_base_kcat) Expression('KRAS_gdp_exchange_N_base_rate', INPUT_KRAS_gdp_exchange_N_base_kcat*KRAS_gdp_exchange_N_base_kcat) Expression('NRAS_gdp_exchange_N_base_rate', INPUT_NRAS_gdp_exchange_N_base_kcat*NRAS_gdp_exchange_N_base_kcat) Expression('RAF1_dephosphorylation_S338_base_rate', INPUT_RAF1_dephosphorylation_S338_base_kcat*RAF1_dephosphorylation_S338_base_kcat) Expression('BRAF_dephosphorylation_S447_base_rate', BRAF_dephosphorylation_S447_base_kcat*INPUT_BRAF_dephosphorylation_S447_base_kcat) Expression('MAP2K1_dephosphorylation_S222_base_rate', INPUT_MAP2K1_dephosphorylation_S222_base_kcat*MAP2K1_dephosphorylation_S222_base_kcat) Expression('MAP2K1_dephosphorylation_S218_base_rate', INPUT_MAP2K1_dephosphorylation_S218_base_kcat*MAP2K1_dephosphorylation_S218_base_kcat) Expression('MAP2K2_dephosphorylation_S222_base_rate', INPUT_MAP2K2_dephosphorylation_S222_base_kcat*MAP2K2_dephosphorylation_S222_base_kcat) Expression('MAP2K2_dephosphorylation_S226_base_rate', INPUT_MAP2K2_dephosphorylation_S226_base_kcat*MAP2K2_dephosphorylation_S226_base_kcat) Expression('MAPK1_dephosphorylation_T185_base_rate', INPUT_MAPK1_dephosphorylation_T185_base_kcat*MAPK1_dephosphorylation_T185_base_kcat) Expression('MAPK1_dephosphorylation_Y187_base_rate', INPUT_MAPK1_dephosphorylation_Y187_base_kcat*MAPK1_dephosphorylation_Y187_base_kcat) Expression('MAPK3_dephosphorylation_Y204_base_rate', INPUT_MAPK3_dephosphorylation_Y204_base_kcat*MAPK3_dephosphorylation_Y204_base_kcat) Expression('MAPK3_dephosphorylation_T202_base_rate', INPUT_MAPK3_dephosphorylation_T202_base_kcat*MAPK3_dephosphorylation_T202_base_kcat) Observable('FL_obs', FL(inh=None)) Observable('FLT3__Y843_p_obs', FLT3(Y843='p', inh=None)) Observable('KRAS__N_gtp_obs', KRAS(N='gtp', inh=None)) Observable('HRAS__N_gtp_obs', HRAS(N='gtp', inh=None)) Observable('NRAS__N_gtp_obs', NRAS(N='gtp', inh=None)) Observable('RAF1__S338_p_obs', RAF1(S338='p', inh=None)) Observable('BRAF__S447_p_obs', BRAF(S447='p', inh=None)) Observable('MAP2K1__S218_p__S222_p_obs', MAP2K1(S222='p', S218='p', inh=None)) Observable('MAP2K2__S222_p__S226_p_obs', MAP2K2(S222='p', S226='p', inh=None)) Observable('tFL', FL()) Observable('tFLT3', FLT3()) Observable('pFLT3_Y843', FLT3(Y843='p')) Observable('tHRAS', HRAS()) Observable('tKRAS', KRAS()) Observable('tNRAS', NRAS()) Observable('tRAF1', RAF1())
Rule( 'bind_COX2AG_AA_allo', COX2(cat=1, allo=None) % AG(b=1) + AA(b=None) | COX2(cat=1, allo=2) % AG(b=1) % AA(b=2), kf_AA_allo3, kr_AA_allo3) bind(COX2(cat=None), 'allo', AG(), 'b', [kf_AG_allo1, kr_AG_allo1]) Rule( 'bind_COX2AA_AG_allo', COX2(cat=1, allo=None) % AA(b=1) + AG(b=None) | COX2(cat=1, allo=2) % AA(b=1) % AG(b=2), kf_AG_allo2, kr_AG_allo2) Rule( 'bind_COX2AG_AG_allo', COX2(cat=1, allo=None) % AG(b=1) + AG(b=None) | COX2(cat=1, allo=2) % AG(b=1) % AG(b=2), kf_AG_allo3, kr_AG_allo3) Observable('obsPG', PG()) Observable('obsPGG', PGG()) Observable('obsAA', AA()) Observable('obsAG', AG()) Observable('obsAAallo', COX2(allo=1, cat=None) % AA(b=1)) Observable('obsAAcat', COX2(cat=1, allo=None) % AA(b=1)) Observable('obsAAboth', COX2(cat=1, allo=2) % AA(b=1) % AA(b=2)) Observable('obsAGallo', COX2(allo=1, cat=None) % AG(b=1)) Observable('obsAGcat', COX2(cat=1, allo=None) % AG(b=1)) Observable('obsAGboth', COX2(cat=1, allo=2) % AG(b=1) % AG(b=2)) Observable('obsAAcatAGallo', COX2(cat=1, allo=2) % AA(b=1) % AG(b=2)) Observable('obsAGcatAAallo', COX2(cat=1, allo=2) % AG(b=1) % AA(b=2))
model.add_component(Parameter('RAF_0', 40000)) model.add_component(Parameter('MAP2K1_0', 3020000)) model.add_component(Parameter('MAPK1_0', 695000)) model.add_component(Parameter('AKT_0', 905000)) add_initial(model, m['EGF'](), p['EGF_0']) add_initial(model, get_base_state(m['EGFR']), p['EGFR_0']) add_initial(model, get_base_state(m['SOS1']), p['SOS_0']) add_initial(model, get_base_state(m['HRAS']), p['RAS_0']) add_initial(model, get_base_state(m['NRAS']), p['RAS_0']) add_initial(model, get_base_state(m['KRAS']), p['RAS_0']) add_initial(model, get_base_state(m['ARAF']), p['RAF_0']) add_initial(model, get_base_state(m['BRAF']), p['RAF_0']) add_initial(model, get_base_state(m['RAF1']), p['RAF_0']) add_initial(model, get_base_state(m['MAP2K1']), p['MAP2K1_0']) add_initial(model, get_base_state(m['MAPK1']), p['MAPK1_0']) add_initial(model, m['RASA2'](Catalytic='active'), p['init_default']) add_initial(model, m['RASA3'](Catalytic='active'), p['init_default']) # Add observables model.add_component(Observable("ERKact", m['MAPK1'](Kinase='active'))) model.add_component(Observable("MEKact", m['MAP2K1'](Kinase='active'))) # Import solver and generate model equations t = np.linspace(0, 25, 11) solver = Solver(model, t) # Pickle the model with open('RAS_combined_model.pkl', 'wb') as fh: pickle.dump(model, fh)