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 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 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 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 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 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 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 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_parameter(model, name, value, unique=True):
"""Return parameter with given name, creating it if needed.
If unique is false and the parameter exists, the value is not changed; if
it does not exist, it will be created. If unique is true then upon conflict
a number is added to the end of the parameter name.
"""
parameter = model.parameters.get(name)
if not unique and parameter is not None:
return parameter
if unique:
pnum = 1
while True:
pname = name + '_%d' % pnum
if model.parameters.get(pname) is None:
break
pnum += 1
else:
pname = name
parameter = Parameter(pname, value)
model.add_component(parameter)
return parameter
def merge_parameters(model, new_name, parameters):
unique_values = {parameter.value for parameter in parameters}
if len(unique_values) > 1:
raise ValueError("Given parameters have different values: %s" %
(', '.join('%s=%g' % (p.name, p.value)
for p in parameters)))
value = parameters[0].value
rules = ComponentSet()
for parameter in parameters:
rules |= rules_using_parameter(model, parameter)
if not rules:
raise ValueError("Model has no rules using given parameters: %s" %
', '.join(p.name for p in parameters))
try:
new_parameter = model.parameters[new_name]
if new_parameter.value != value:
raise ValueError("Parameter %s is already present in the model "
"with the value %g, which differs from the "
"common value of the given parameters, %g" %
(new_parameter.name, new_parameter.value, value))
except KeyError:
new_parameter = Parameter(new_name, value)
model.add_component(new_parameter)
for rule in rules:
for attr in 'rate_forward', 'rate_reverse':
if getattr(rule, attr) in parameters:
setattr(rule, attr, new_parameter)
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 get_context(model):
# TODO: Here we will have to query the context
# for now it is hard coded
kras = model.monomers['KRAS']
try:
p = Parameter('kras_act_0', 100)
model.add_component(p)
model.initial(kras(act='active'), p)
except ComponentDuplicateNameError:
model.parameters['kras_act_0'].value = 100
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
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])
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 set_base_initial_condition(model, monomer, value):
# Build up monomer pattern dict
sites_dict = {}
for site in monomer.sites:
if site in monomer.site_states:
sites_dict[site] = monomer.site_states[site][0]
else:
sites_dict[site] = None
mp = monomer(**sites_dict)
pname = monomer.name + '_0'
try:
p = model.parameters[pname]
p.value = value
except KeyError:
p = Parameter(pname, value)
model.add_component(p)
model.initial(mp, p)
def test_hpp():
model = robertson.model
# Reset equations from any previous network generation
model.reset_equations()
A = robertson.model.monomers['A']
klump = Parameter('klump', 10000, _export=False)
model.add_component(klump)
population_maps = [PopulationMap(A(), klump)]
sim = BngSimulator(model, tspan=np.linspace(0, 1))
x = sim.run(n_runs=1,
method='nf',
population_maps=population_maps,
seed=_BNG_SEED)
observables = np.array(x.observables)
assert len(observables) == 50
def set_parameters(model):
if model.name.startswith('ATM'):
atm_atr = 'ATM'
else:
atm_atr = 'ATR'
# Set activation parameters to 1e-7
for param in model.parameters:
if param.name.startswith('kf') and param.name.find('act') != -1:
param.value = 1e-7
# Update Wip1 -| p53 parameter
model.parameters['kf_pt_act_1'].value = 5e-7
# Update the Wip1 -| ATM parameter in ATM models
if atm_atr == 'ATM':
if not (model.name.endswith('v4a') or model.name.endswith('v4b')):
model.parameters['kf_pa_act_1'].value = 1e-5
else:
model.parameters['kf_pa_dephosphorylation_1'].value = 1e-5
# Update ATR/ATM autoactivation parameter in v3/v4 models
if model.name.endswith('v3'):
model.parameters['kf_aa_act_1'].value = 5e-7
elif model.name.endswith('v4a'):
model.parameters['kf_a_autophos_1'].value = 5e-7
elif model.name.endswith('v4b'):
model.parameters['kf_aa_phosphorylation_1'].value = 5e-7
# Set some of the transcription/degradation parameters in v4 models:
if model.name.startswith('ATM_v4'):
model.parameters['MDM2_0'].value = 0
model.parameters['kf_m_deg_1'].value = 8e-2
model.parameters['kf_tm_synth_1'].value = 2e-2
# Start with some initial active/phosphorylated ATR/ATM
model.add_component(Parameter('%sa_0' % atm_atr, 1))
atm_atr_m = model.monomers[atm_atr]
if not model.name.startswith('ATM_v4'):
model.initial(atm_atr_m(activity='active'),
model.parameters['%sa_0' % atm_atr])
else:
model.initial(atm_atr_m(phospho='p'),
model.parameters['%sa_0' % atm_atr])
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
# https://github.com/RuleWorld/bionetgen/blob/master/bng2/Models2/localfunc.bngl
#
# This model demonstrates the use of MultiState and local functions in PySB
#
# Requires Python 3.x or greater (will give a SyntaxError on Python 2.7)
from pysb import Model, Monomer, Parameter, Expression, Rule, \
Observable, Initial, Tag, MultiState
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')
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
from pysb import ANY, WILD, Model, Monomer, Parameter, Expression, Initial, Observable, Rule
from pysb.macros import *
Model()
###################################################################################################
# DNA
Monomer('DNA_rpoA', ['type'], {'type': ['P1', 'RBS', 'CDS', 'T1']})
Initial(DNA_rpoA(type = 'P1'), Parameter('t0_DNA_rpoA_P1', 1))
Initial(DNA_rpoA(type = 'RBS'), Parameter('t0_DNA_rpoA_RBS', 1))
Initial(DNA_rpoA(type = 'CDS'), Parameter('t0_DNA_rpoA_CDS', 1))
Initial(DNA_rpoA(type = 'T1'), Parameter('t0_DNA_rpoA_T1', 1))
Monomer('DNA_rpoB', ['type'], {'type': ['P1', 'RBS', 'CDS', 'T1']})
Initial(DNA_rpoB(type = 'P1'), Parameter('t0_DNA_rpoB_P1', 1))
Initial(DNA_rpoB(type = 'RBS'), Parameter('t0_DNA_rpoB_RBS', 1))
Initial(DNA_rpoB(type = 'CDS'), Parameter('t0_DNA_rpoB_CDS', 1))
Monomer('DNA_rpoC', ['type'], {'type': ['RBS', 'CDS', 'T1']})
Initial(DNA_rpoC(type = 'RBS'), Parameter('t0_DNA_rpoC_RBS', 1))
Initial(DNA_rpoC(type = 'CDS'), Parameter('t0_DNA_rpoC_CDS', 1))
Initial(DNA_rpoC(type = 'T1'), Parameter('t0_DNA_rpoC_T1', 1))
Monomer('DNA_rpoD', ['type'], {'type': ['P1', 'RBS', 'CDS', 'T1']})
Initial(DNA_rpoD(type = 'P1'), Parameter('t0_DNA_rpoD_P1', 1))
Initial(DNA_rpoD(type = 'RBS'), Parameter('t0_DNA_rpoD_RBS', 1))
Initial(DNA_rpoD(type = 'CDS'), Parameter('t0_DNA_rpoD_CDS', 1))
Initial(DNA_rpoD(type = 'T1'), Parameter('t0_DNA_rpoD_T1', 1))
Monomer('DNA_rpoE', ['type'], {'type': ['P1', 'RBS', 'CDS', 'T1']})
Initial(DNA_rpoE(type = 'P1'), Parameter('t0_DNA_rpoE_P1', 1))
# Import of \IFN January 2018\Simplified SOCS model - alpha model from
# Rulebender to PySB. This is just a model file - must be run from a run file
from pysb import Model, Parameter, Expression, Initial, Monomer, Observable, Rule, WILD
# Begin Model
Model()
# =============================================================================
# # Parameters
# =============================================================================
Parameter('NA', 6.022E23) # Avogadro's number (molecues/mol)
Parameter('PI', 3.142) # no unit
Parameter('rad_cell', 30E-6) # radius of cell in m approx 30 micron
Parameter('cell_thickness', 8E-6) # height, m
Parameter('cell_dens', 1E5) # density of cells , /L
Parameter('width_PM', 1E-6) # effective width of membrane , m
Expression('volEC', 1 / cell_dens) # vol. extracellular space , L
Expression(
'volPM', 2 * rad_cell**2 +
rad_cell * cell_thickness * 4) # virtual vol. of plasma membrane , L
Expression('volCP', cell_thickness * rad_cell**2) # vol. of cytoplasm , L
Parameter('IFN', 1E-9) # initial concentration in Molar
Expression('I', IFN * volEC *
NA) # number of copies per cell (~ 6.022e8 copies per cell)
Expression('Ia', I)
#Expression('Ib', I)
#Parameter('r', 0) # Receptor assymmetry
#Parameter('R', 0) #
Parameter('R1', 2000) #(2000/7.2e-15)*volCP#(8000/2.76e-9)*volPM#R -r#
Parameter(
'S222': ['u', 'p']
})
Monomer('MAP2K2', ['S226', 'S222', 'inh'], {
'S226': ['u', 'p'],
'S222': ['u', 'p']
})
Monomer('MAPK1', ['Y187', 'T185', 'inh'], {
'Y187': ['u', 'p'],
'T185': ['u', 'p']
})
Monomer('MAPK3', ['T202', 'Y204', 'inh'], {
'T202': ['u', 'p'],
'Y204': ['u', 'p']
})
Parameter('EGF_eq', 100.0)
Parameter('EGF_0', 0.0)
Parameter('EGF_EGF_koff', 0.1)
Parameter('EGF_EGF_kd', 1.0)
Parameter('EGFR_eq', 100.0)
Parameter('EGFR_dephosphorylation_Y1173_base_kcat', 1.0)
Parameter('INPUT_EGFR_dephosphorylation_Y1173_base_kcat', 0.0)
Parameter('ERBB2_eq', 100.0)
Parameter('ERBB2_dephosphorylation_Y1248_base_kcat', 1.0)
Parameter('INPUT_ERBB2_dephosphorylation_Y1248_base_kcat', 0.0)
Parameter('EGFR_phosphorylation_Y1173_EGF_kcat', 1.0)
Parameter('INPUT_EGFR_phosphorylation_Y1173_EGF_kcat', 0.0)
Parameter('ERBB2_phosphorylation_Y1248_EGFR__Y1173_p_kcat', 1.0)
Parameter('INPUT_ERBB2_phosphorylation_Y1248_EGFR__Y1173_p_kcat', 0.0)
Parameter('RAF1_eq', 100.0)
Parameter('RAF1_dephosphorylation_S338_base_kcat', 1.0)
# Import of \IFN January 2018\Detailed IFN model - alpha model from
# Rulebender to PySB. This is just a model file - must be run from a run file
# Importantly, there cannot be any use of PySB Expressions in order to use
# the export functions from PySB.
# =============================================================================
# The major difference in usage for this file is that one cannot simply pass the
# concentration of IFN as a parameter for the simulation any more. Instead, pass
# the pre-calculated value of IFN*volEC*NA to the parameter I
# =============================================================================
from pysb import Model, Parameter, Rule, Monomer, Initial, Observable, WILD
Model()
# =============================================================================
# # Parameters
# =============================================================================
Parameter('NA', 6.022E23) # Avogadro's number (molecues/mol)
Parameter('PI', 3.142) # no unit
Parameter('rad_cell', 30E-6) # radius of cell in m approx 30 micron
Parameter('cell_thickness', 8E-6) # height, m
Parameter('cell_dens', 1E5) # density of cells , /L
Parameter('width_PM', 1E-6) # effective width of membrane , m
#vol. extracellular space , L
Parameter('volEC', 1E-5) # = 1/cell_dens
# virtual vol. of plasma membrane , L
Parameter('volPM', 2.76e-09) # = 2*rad_cell**2 + rad_cell*cell_thickness*4
# vol. of cytoplasm , L
Parameter('volCP', 7.2e-15) # = cell_thickness*rad_cell**2
"""
from pysb import Model, Monomer, Parameter, Initial, Rule, Observable
from pysb.macros import bind, bind_complex, catalyze
Model()
#Define individual species in model
Monomer('COX2', ['allo', 'cat']) #Cyclooxygenase-2 enzyme
Monomer('AG', ['b']) #2-arachidonoylglycerol, a substrate of COX2
Monomer('AA', ['b']) #arachidonic acid, a substrate of COX2
Monomer('PG') #Prostaglandin, product of COX2 turnover of AA
Monomer('PGG') #Prostaglandin glycerol, product of COX2 turnover of 2-AG
#Initial starting concentrations in micromolar
Parameter('COX2_0', 15e-3)
Parameter('AG_0', 16)
Parameter('AA_0', 16)
Parameter('PG_0', 0)
Parameter('PGG_0', 0)
Initial(COX2(allo=None, cat=None), COX2_0)
Initial(AG(b=None), AG_0)
Initial(AA(b=None), AA_0)
Initial(PG(), PG_0)
Initial(PGG(), PGG_0)
#All kf parameters are in units of inverse microM*s
#All kr parameters are in units of inverse s
#All kcat parameters are in units of inverse s
#the forward reaction is association; the reverse is disassociation
Monomer('Bcl2', ['bf', 'state'], {'state': ['C', 'M']})
Monomer('BclxL', ['bf', 'state'], {'state': ['C', 'M']})
Monomer('Mcl1', ['bf', 'state'], {'state': ['C', 'M']})
Monomer('Bad', ['bf', 'state'], {'state': ['C', 'M']})
Monomer('Noxa', ['bf', 'state'], {'state': ['C', 'M']})
Monomer('CytoC', ['bf', 'state'], {'state': ['M', 'C', 'A']})
Monomer('Smac', ['bf', 'state'], {'state': ['M', 'C', 'A']})
Monomer('Apaf', ['bf', 'state'], {'state': ['I', 'A']})
Monomer('Apop', ['bf'])
Monomer('C3', ['bf', 'state'], {'state': ['pro', 'A', 'ub']})
Monomer('C6', ['bf', 'state'], {'state': ['pro', 'A']})
Monomer('C9', ['bf'])
Monomer('PARP', ['bf', 'state'], {'state': ['U', 'C']})
Monomer('XIAP', ['bf'])
Parameter('L_0', 3000.0)
Parameter('R_0', 200.0)
Parameter('Flip_0', 100.0)
Parameter('C8_0', 20000.0)
Parameter('BAR_0', 1000.0)
Parameter('bind_L_R_to_LR_kf', 4e-07)
Parameter('bind_L_R_to_LR_kr', 0.001)
Parameter('convert_LR_to_DISC_kc', 1e-05)
Parameter('bind_DISC_C8pro_to_DISCC8pro_kf', 1e-06)
Parameter('bind_DISC_C8pro_to_DISCC8pro_kr', 0.001)
Parameter('catalyze_DISCC8pro_to_DISC_C8A_kc', 1.0)
Parameter('bind_C8A_BidU_to_C8ABidU_kf', 1e-06)
Parameter('bind_C8A_BidU_to_C8ABidU_kr', 0.001)
Parameter('catalyze_C8ABidU_to_C8A_BidT_kc', 1.0)
Parameter('bind_DISC_flip_kf', 1e-06)
Parameter('bind_DISC_flip_kr', 0.001)