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)
