def parse_bngl_strings_to_complex_representations(counts_df):
# returns a list of pairs (mcell.Complex, int), the second item is count
res = []
for index, row in counts_df.iterrows():
# constructor m.Complex parses the BNGL representaion into
# a MCell4 API representation
# (see https://cnl.salk.edu/~ahusar/mcell4_documentation/generated/subsystem.html#complex
cplx = m.Complex(row['species'])
res.append((cplx, row['count']))
return res
def read_species_file(file_name):
# load the .species file as a list of pairs (mcell.Complex, int), the second item is count
res = []
with open(file_name, 'r') as f:
for line in f:
if not line.strip():
continue
items = line.split()
assert len(items) == 2, "Invalid input file contents " + line
# constructor m.Complex parses the BNGL representaion into
# a MCell4 API representation
# (see https://cnl.salk.edu/~ahusar/mcell4_documentation/generated/subsystem.html#complex
cplx = m.Complex(items[0])
res.append((cplx, str(items[1])))
return res
import mcell as m
# numerical attribute
c = m.Color(red=1, green=0, blue=0, alpha=1)
c2 = copy.deepcopy(c)
c2.red = 0.5
# check that the original object is correct
assert c.red == 1
assert c2.red == 0.5
# object - first level copy
rs = m.ReleaseSite(name='test',
complex=m.Complex('A'),
shape=m.Shape.SPHERICAL,
location=(1, 2, 3),
number_to_release=1000)
rs2 = copy.deepcopy(rs)
rs2.complex.name = 'B'
assert rs.complex.name == 'A'
assert rs2.complex.name == 'B'
# object in vector
cplx = m.Complex('X(a~0!1).Y(b~Q!1)')
ct = m.ComponentType('z', ['E', 'R'])
import mcell as m
from parameters import *
from subsystem import *
from geometry import *
# ---- instantiation ----
# ---- release sites ----
rel_a = m.ReleaseSite(
name = 'rel_a',
complex = m.Complex('a'),
region = Cell - (Organelle_1 + Organelle_2),
number_to_release = 2000
)
rel_b = m.ReleaseSite(
name = 'rel_b',
complex = m.Complex('b'),
region = Organelle_1,
number_to_release = 1000
)
rel_t1 = m.ReleaseSite(
name = 'rel_t1',
complex = m.Complex('t1', orientation = m.Orientation.UP),
region = Organelle_1_top,
number_to_release = 700
)
model.notifications.rxn_and_species_report = False
model.config.partition_dimension = 2
model.config.subpartition_dimension = 0.2
model.initialize()
model.run_iterations(1)
num_VS = params['num_VS']
num_VCP = params['num_VCP']
num_VEC = params['num_VEC']
ids_VSCP = model.get_molecule_ids(pattern = m.Complex('@CP:V(s!1).S(v!1)'))
ids_VSPM = model.get_molecule_ids(pattern = m.Complex('@PM:V(s!1).S(v!1)'))
ids_VSEC = model.get_molecule_ids(pattern = m.Complex('@EC:V(s!1).S(v!1)'))
ids_VCP = model.get_molecule_ids(pattern = m.Complex('@CP:V'))
ids_VPM = model.get_molecule_ids(pattern = m.Complex('@PM:V'))
ids_VEC = model.get_molecule_ids(pattern = m.Complex('@EC:V'))
assert len(ids_VSCP) == 0
assert len(ids_VSPM) == num_VS
assert len(ids_VSEC) == 0
assert len(ids_VCP) == num_VCP
assert len(ids_VPM) == num_VS
assert len(ids_VEC) == num_VEC
import sys
import os
MCELL_PATH = os.environ.get('MCELL_PATH', '')
if MCELL_PATH:
sys.path.append(os.path.join(MCELL_PATH, 'lib'))
else:
print("Error: variable MCELL_PATH that is used to find the mcell library was not set.")
sys.exit(1)
import mcell as m
cplx = m.Complex('A(x~0)')
assert str(cplx) == 'A(x~0)'
assert "elementary_molecule_type=(ElementaryMoleculeType 'A'" in cplx.__str__(all_details=True)
# species
spec = m.Species('A', diffusion_constant_3d = 1e-6)
assert str(spec) == 'A'
assert "diffusion_constant_3d=1e-06" in spec.__str__(True)
# geometry object
box = m.geometry_utils.create_box('box', 1)
#print(len(str(box)))
assert len(str(box)) < 150
import os
MCELL_PATH = os.environ.get('MCELL_PATH', '')
if MCELL_PATH:
sys.path.append(os.path.join(MCELL_PATH, 'lib'))
else:
print(
"Error: variable MCELL_PATH that is used to find the mcell library was not set."
)
sys.exit(1)
import mcell as m
# single property
rs1 = m.ReleaseSite('rel1',
complex=m.Complex('X(y!1).Y(x!1)'),
shape=m.Shape.SPHERICAL,
location=(1, 1, 1),
number_to_release=10)
rs2 = m.ReleaseSite('rel1',
complex=m.Complex('X(y!1).Y(x!1)'),
shape=m.Shape.SPHERICAL,
location=(0.1, 0.1, 0.1),
number_to_release=10)
assert rs1 != rs2
rs3 = m.ReleaseSite('rel1',
complex=m.Complex('Y(x!1).X(y!1)'),
shape=m.Shape.SPHERICAL,
# WARNING: This is an automatically generated file and will be overwritten
# by CellBlender on the next model export.
import os
import shared
import mcell as m
from parameters import *
from subsystem import *
from geometry import *
MODEL_PATH = os.path.dirname(os.path.abspath(__file__))
instantiation = m.Instantiation()
for mol in ['A', 'B']:
cplx = m.Complex(mol)
box1_sr1_rel = m.ReleaseSite(name='box1_sr1_rel_' + mol,
complex=cplx,
region=box1_sr1,
number_to_release=40)
box1_sr2_rel = m.ReleaseSite(name='box1_sr2_rel' + mol,
complex=cplx,
region=box1_sr2,
number_to_release=60)
box2_rel = m.ReleaseSite(name='box2_rel' + mol,
complex=cplx,
region=box2,
number_to_release=30)
sys.path.append(os.path.join(MCELL_PATH, 'lib'))
else:
print(
"Error: variable MCELL_PATH that is used to find the mcell library was not set."
)
sys.exit(1)
import mcell as m
params = m.bngl_utils.load_bngl_parameters('test.bngl')
box1 = m.geometry_utils.create_box('box1', 0.5)
box2 = m.geometry_utils.create_box('box2', 1)
box3 = m.geometry_utils.create_box('box3', 1.5)
ct_box2 = m.CountTerm(species_pattern=m.Complex('A'), region=box2)
ct_box1 = m.CountTerm(species_pattern=m.Complex('A'), region=box1)
ct_box2_minus_ct_box1 = ct_box2 - ct_box1
# setting region that will be ignored
ct_box2_minus_ct_box1.region = box3
count = m.Count(name='z', expression=ct_box2_minus_ct_box1, file_name='x.dat')
# ---- load bngl file ----
# must be checked during initialization
model = m.Model()
model.load_bngl('test.bngl')
model.add_geometry_object(Sphere1)
model.add_geometry_object(Sphere2)
# load information on species and on our reaction
model.load_bngl('model.bngl')
# define reflective surface classes for our regions - same as in the lipid raft example so that
# our molecules don't diffuse away for the regions where the 'cells' touch
# when using the surface class, the molecules weirdly agreggate at its boundary,
# this is probably something to be checked.
# however in reality the whole object won't more so quickly so
# this might not be an issue
lipid_raft_A = m.SurfaceClass(name='lipid_raft_A',
type=m.SurfacePropertyType.REFLECTIVE,
affected_complex_pattern=m.Complex('A'))
lipid_raft_B = m.SurfaceClass(name='lipid_raft_B',
type=m.SurfacePropertyType.REFLECTIVE,
affected_complex_pattern=m.Complex('B'))
model.add_surface_class(lipid_raft_A)
model.add_surface_class(lipid_raft_B)
Sphere1_right.surface_class = lipid_raft_A
Sphere2_left.surface_class = lipid_raft_B
# release molecules in specified regions
rel_A = m.ReleaseSite(name='rel_A',
complex=m.Complex('A', orientation=m.Orientation.UP),
region=Sphere1_right,
number_to_release=350)
import mcell as m
# numerical attribute
c = m.Color(red=1, green=0, blue=0, alpha=1)
c2 = copy.copy(c)
c2.red = 0.5
# check that the original object is correct
assert c.red == 1
assert c2.red == 0.5
# object
rs = m.ReleaseSite(name='test',
complex=m.Complex('A'),
shape=m.Shape.SPHERICAL,
location=(1, 2, 3),
number_to_release=1000)
rs2 = copy.copy(rs)
rs2.complex = m.Complex('B')
assert rs.complex.to_bngl_str() == 'A'
assert rs2.complex.to_bngl_str() == 'B'
# vector
ct = m.ComponentType('u', states=['0'])
ct2 = copy.copy(ct)
ct2.states = ['X', 'Y']
from subsystem import *
from geometry import *
MODEL_PATH = os.path.dirname(os.path.abspath(__file__))
# ---- instantiation ----
# ---- release sites ----
# ---- surface classes assignment ----
box_bottom.surface_class = reflect_edge
# ---- compartments assignment ----
rel_m = m.ReleaseSite(
name = 'rel_m',
complex = m.Complex('M'),
region = box_bottom,
number_to_release = 3755
)
# ---- create instantiation object and add components ----
instantiation = m.Instantiation()
instantiation.add_geometry_object(box)
instantiation.add_release_site(rel_m)
# load seed species information from bngl file
instantiation.load_bngl_compartments_and_seed_species(os.path.join(MODEL_PATH, 'model.bngl'), None, shared.parameter_overrides)
from geometry import *
MODEL_PATH = os.path.dirname(os.path.abspath(__file__))
# ---- instantiation ----
# ---- release sites ----
# ---- surface classes assignment ----
Plane.surface_class = empty
# ---- compartments assignment ----
vol1_rel = m.ReleaseSite(
name = 'vol1_rel',
complex = m.Complex('vol1'),
region = Cube,
number_to_release = 2000
)
# ---- create instantiation object and add components ----
instantiation = m.Instantiation()
instantiation.add_geometry_object(Plane)
instantiation.add_geometry_object(Cube)
instantiation.add_release_site(vol1_rel)
# load seed species information from bngl file
instantiation.load_bngl_compartments_and_seed_species(os.path.join(MODEL_PATH, 'model.bngl'), None, shared.parameter_overrides)
output_files_prefix='./viz_data/seed_' +
str(SEED).zfill(5) + '/Scene',
every_n_timesteps=5000)
model.add_viz_output(viz_output)
gdat_file = ''
if 'GDAT' in params and params['GDAT'] == 1:
gdat_file = os.path.splitext(bngl_file)[0] + '.gdat'
model.load_bngl(bngl_file,
'./react_data/seed_' + str(SEED).zfill(5) + '/' + gdat_file,
default_compartment)
rel_site = m.ReleaseSite(
name='x',
complex=m.Complex('A@PM'),
#shape = model.find_geometry_object('CP'),
number_to_release=12345678900)
model.add_release_site(rel_site)
# ---- configuration ----
model.config.time_step = TIME_STEP
model.config.seed = SEED
model.config.total_iterations = ITERATIONS
model.config.partition_dimension = MCELL_DEFAULT_COMPARTMENT_EDGE_LENGTH
model.config.subpartition_dimension = MCELL_DEFAULT_COMPARTMENT_EDGE_LENGTH
model.initialize()
# ---- add components ----
model.add_geometry_object(Cube)
model.load_bngl('model.bngl', '', Cube)
surf = m.SurfaceClass(
name = 'surf',
type = m.SurfacePropertyType.REACTIVE
)
rxn = m.ReactionRule(
name = 'rxn',
reactants = [ m.Complex('v', orientation = m.Orientation.DOWN), m.Complex('surf', orientation = m.Orientation.UP) ],
products = [ m.Complex('s', orientation = m.Orientation.UP) ],
fwd_rate = 1e+07
)
Cube_membrane.surface_class = surf
model.add_surface_class(surf)
model.add_reaction_rule(rxn)
# ---- initialization and execution ----
model.initialize()
if DUMP:
assert C.to_bngl_str() == 'C~0~1~Z'
assert N.to_bngl_str() == 'N'
C_inst = C.inst('1', 2)
C_inst2 = C.inst(1)
assert C_inst.to_bngl_str() == 'C~1!2'
assert C_inst2.to_bngl_str() == 'C~1'
CaM = m.ElementaryMoleculeType('CaM', [C, N], diffusion_constant_3d=1e-6)
assert CaM.to_bngl_str() == 'CaM(C~0~1~Z,N)'
CaM_inst = CaM.inst([C.inst(0), N.inst(1)])
assert CaM_inst.to_bngl_str() == 'CaM(C~0,N~1)'
cplx_inst = m.Complex(elementary_molecules=[
CaM.inst([C.inst(2, 1), N.inst(bond=2)]),
CaM.inst([C.inst('Z', 1), N.inst(bond=2)])
])
assert cplx_inst.to_bngl_str() == 'CaM(C~2!1,N!2).CaM(C~Z!1,N!2)'
cplx2 = m.Complex('Ca', compartment_name='CP')
assert cplx2.to_bngl_str() == 'Ca@CP'
cplx3 = m.Complex('A(a!1).B(b!1)', compartment_name='CP')
assert cplx3.to_bngl_str() == '@CP:A(a!1).B(b!1)'
cplx4 = m.Complex('A(a!1)@IN.B(b!1)')
assert cplx4.to_bngl_str() == 'A(a!1)@IN.B(b!1)'
CaMC0N1_species = m.Species(
elementary_molecules=[CaM.inst([C.inst(0), N.inst(1)])])
assert CaMC0N1_species.to_bngl_str() == 'CaM(C~0,N~1)'
# test to check that the Complex constructor correctly initializes internal
# representation
import sys
import os
MCELL_PATH = os.environ.get('MCELL_PATH', '')
if MCELL_PATH:
sys.path.append(os.path.join(MCELL_PATH, 'lib'))
else:
print("Error: variable MCELL_PATH that is used to find the mcell library was not set.")
sys.exit(1)
import mcell as m
c = m.Complex('@C1:A(b~X!1).B(a!1)')
#print(c)
assert len(c.elementary_molecules) == 2
em0 = c.elementary_molecules[0]
em1 = c.elementary_molecules[1]
assert len(em0.components) == 1
assert len(em1.components) == 1
assert em0.elementary_molecule_type.name == 'A'
comp0 = em0.components[0]
assert comp0.bond == 1
assert comp0.state == 'X'
import mcell as m
from parameters import *
from subsystem import *
from geometry import *
# ---- instantiation ----
# ---- release sites ----
rel_a = m.ReleaseSite(name='rel_a',
complex=m.Complex('a'),
shape=m.Shape.SPHERICAL,
location=(0, 0, 0),
site_diameter=0,
number_to_release=1000)
# ---- surface classes assignment ----
# ---- compartments assignment ----
# ---- instantiation data ----
instantiation = m.Instantiation()
instantiation.add_geometry_object(Cube)
instantiation.add_release_site(rel_a)
# WARNING: This is an automatically generated file and will be overwritten
# by CellBlender on the next model export.
import os
import mcell as m
MODEL_PATH = os.path.dirname(os.path.abspath(__file__))
from parameters import *
from subsystem import *
from geometry import *
# ---- observables ----
viz_output = m.VizOutput(mode=m.VizMode.ASCII,
output_files_prefix='./viz_data/seed_' +
str(SEED).zfill(5) + '/Scene',
every_n_timesteps=1)
count_a = m.Count(expression=m.CountTerm(species_pattern=m.Complex('a')),
file_name='./react_data/seed_' + str(SEED).zfill(5) +
'/a.dat')
# ---- create observables object and add components ----
observables = m.Observables()
observables.add_count(count_a)
observables.add_viz_output(viz_output)
import os
import shared
import mcell as m
from parameters import *
# ---- subsystem ----
MODEL_PATH = os.path.dirname(os.path.abspath(__file__))
empty = m.SurfaceClass(name='empty', type=m.SurfacePropertyType.REACTIVE)
unnamed_reaction_rule_0 = m.ReactionRule(
name='unnamed_reaction_rule_0',
reactants=[
m.Complex('vol1', orientation=m.Orientation.DOWN),
m.Complex('empty', orientation=m.Orientation.UP)
],
products=[m.Complex('vol2', orientation=m.Orientation.UP)],
fwd_rate=1e7)
# ---- create subsystem object and add components ----
subsystem = m.Subsystem()
subsystem.add_surface_class(empty)
subsystem.add_reaction_rule(unnamed_reaction_rule_0)
# load subsystem information from bngl file
subsystem.load_bngl_molecule_types_and_reaction_rules(
os.path.join(MODEL_PATH, 'model.bngl'), shared.parameter_overrides)
MCELL_PATH = os.environ.get('MCELL_PATH', '')
if MCELL_PATH:
sys.path.append(os.path.join(MCELL_PATH, 'lib'))
else:
print(
"Error: variable MCELL_PATH that is used to find the mcell library was not set."
)
sys.exit(1)
import mcell as m
# single property
sc1 = m.SurfaceClass('sc',
type=m.SurfacePropertyType.REFLECTIVE,
affected_complex_pattern=m.Complex('X(y!1).Y(x!1)'))
sc2 = m.SurfaceClass('sc',
type=m.SurfacePropertyType.TRANSPARENT,
affected_complex_pattern=m.Complex('X(y!1).Y(x!1)'))
assert sc1 != sc2
sc3 = m.SurfaceClass('sc',
type=m.SurfacePropertyType.TRANSPARENT,
affected_complex_pattern=m.Complex('Y(x!1).X(y!1)'))
assert sc3 == sc2
# multiple properties
p1_1 = m.SurfaceProperty(type=m.SurfacePropertyType.REFLECTIVE,
# WARNING: This is an automatically generated file and will be overwritten
# by CellBlender on the next model export.
import os
import shared
import mcell as m
from parameters import *
# ---- subsystem ----
MODEL_PATH = os.path.dirname(os.path.abspath(__file__))
react_a_plus_b = m.ReactionRule(name='react_a_plus_b',
reactants=[m.Complex('a'),
m.Complex('b')],
products=[m.Complex('c')],
variable_rate=var_rate_react_a_plus_b_0)
# ---- create subsystem object and add components ----
subsystem = m.Subsystem()
subsystem.add_reaction_rule(react_a_plus_b)
# load subsystem information from bngl file
subsystem.load_bngl_molecule_types_and_reaction_rules(
os.path.join(MODEL_PATH, 'model.bngl'), shared.parameter_overrides)
# set additional information about species and molecule types that cannot be stored in BNGL,
# elementary molecule types are already in the subsystem after they were loaded from BNGL
# ---- default configuration overrides ----
if customization and 'custom_config' in dir(customization):
# user-defined model configuration
customization.custom_config(model)
# ---- add components ----
viz_output = m.VizOutput(mode=m.VizMode.ASCII,
output_files_prefix='./viz_data/seed_' +
str(parameters.SEED).zfill(5) + '/Scene',
every_n_timesteps=1)
model.add_viz_output(viz_output)
count_Syk_CP = m.Count(
expression=m.CountTerm(molecules_pattern=m.Complex('Syk@CP')),
file_name='./react_data/seed_' + str(parameters.SEED).zfill(5) +
'/Syk.dat',
every_n_timesteps=1)
model.add_count(count_Syk_CP)
model.add_subsystem(subsystem.subsystem)
model.add_instantiation(instantiation.instantiation)
# ---- initialization and execution ----
if customization and 'custom_init_and_run' in dir(customization):
customization.custom_init_and_run(model)
else:
model.initialize()
import mcell as m
from parameters import *
from subsystem import *
from geometry import *
# ---- instantiation ----
# ---- release sites ----
rel_a = m.ReleaseSite(name='rel_a',
complex=m.Complex('a'),
shape=m.Shape.SPHERICAL,
location=(0, 0, 0),
site_diameter=0,
number_to_release=1000)
rel_b = m.ReleaseSite(name='rel_b',
complex=m.Complex('b'),
shape=m.Shape.SPHERICAL,
location=(5.0000000000000001e-03, 0, 0),
site_diameter=0,
number_to_release=1000)
# ---- surface classes assignment ----
# ---- compartments assignment ----
# ---- instantiation data ----
instantiation = m.Instantiation()
import mcell as m
from parameters import *
from bngl_molecule_types_info import *
# ---- subsystem ----
cclamp_left = m.SurfaceClass(
name='cclamp_left',
type=m.SurfacePropertyType.CONCENTRATION_CLAMP,
affected_complex_pattern=m.Complex(
'a', orientation=m.Orientation.DOWN
), # DOWN means towards the center of the object
concentration=1e-5)
cclamp_right = m.SurfaceClass(name='cclamp_right',
type=m.SurfacePropertyType.CONCENTRATION_CLAMP,
affected_complex_pattern=m.Complex(
'a', orientation=m.Orientation.DOWN),
concentration=1e-7)
subsystem = m.Subsystem()
subsystem.add_surface_class(cclamp_left)
subsystem.add_surface_class(cclamp_right)
# load subsystem information from bngl file
subsystem.load_bngl_molecule_types_and_reaction_rules('model.bngl')
# set additional information such as diffusion constants for loaded elementary molecule types
set_bngl_molecule_types_info(subsystem)
sys.path.append(os.path.join(MCELL_PATH, 'lib'))
else:
print(
"Error: variable MCELL_PATH that is used to find the mcell library was not set."
)
sys.exit(1)
import mcell as m
# checking that .append and other modifications works
ct_u = m.ComponentType('u', states=['0'])
#print(type(ct_u.states))
assert len(ct_u.states) == 1
ct_u.states.append('1')
assert len(ct_u.states) == 2
ct_u.states[1] = '2'
assert ct_u.states[1] == '2'
rs = m.ReleaseSite(name='test',
complex=m.Complex('A'),
shape=m.Shape.SPHERICAL,
location=(1, 2, 3),
number_to_release=1000)
#print(type(rs.location))
#print(rs.location)
rs.location[0] = 2
#print(rs.location)
assert rs.location[0] == 2
# WARNING: This is an automatically generated file and will be overwritten
# by CellBlender on the next model export.
import mcell as m
from parameters import *
from subsystem import *
from geometry import *
# ---- instantiation ----
# ---- release sites ----
rel_A = m.ReleaseSite(name='rel_A',
complex=m.Complex('A', orientation=m.Orientation.UP),
region=up,
number_to_release=100)
rel_B = m.ReleaseSite(name='rel_B',
complex=m.Complex('B', orientation=m.Orientation.UP),
region=bottom,
number_to_release=100)
# ---- surface classes assignment ----
# ---- compartments assignment ----
# ---- create instantiation object and add components ----
instantiation = m.Instantiation()
instantiation.add_geometry_object(up)
# WARNING: This is an automatically generated file and will be overwritten
# by CellBlender on the next model export.
import mcell as m
from parameters import *
from subsystem import *
from geometry import *
# ---- instantiation ----
# ---- release sites ----
Release_of_Syk_ps_a_Y_l_Y_tSH2_pe_CP_at_CP = m.ReleaseSite(
name='Release_of_Syk_ps_a_Y_l_Y_tSH2_pe_CP_at_CP',
complex=m.Complex('Syk(a~Y,l~Y,tSH2)'),
region=CP,
number_to_release=20)
# ---- surface classes assignment ----
# ---- compartments assignment ----
default_compartment.is_bngl_compartment = True
EC.is_bngl_compartment = True
CP.is_bngl_compartment = True
CP.surface_compartment_name = 'PM'
# ---- create instantiation object and add components ----
model.config.partition_dimension = 2
model.config.subpartition_dimension = 0.2
model.initialize()
model.run_iterations(1)
num_AR = params['num_AR']
num_AS = params['num_AS']
num_BT = params['num_BT']
num_BU = params['num_BU']
num_ASBT = params['num_ASBT']
num_ARBU = params['num_ARBU']
ids_A = model.get_molecule_ids(pattern = m.Complex('A'))
ids_B = model.get_molecule_ids(pattern = m.Complex('B'))
ids_AR = model.get_molecule_ids(pattern = m.Complex('A(a~R)'))
ids_AS = model.get_molecule_ids(pattern = m.Complex('A(a~S)'))
ids_BT = model.get_molecule_ids(pattern = m.Complex('B(b~T)'))
ids_BU = model.get_molecule_ids(pattern = m.Complex('B(b~U)'))
ids_ASBT = model.get_molecule_ids(pattern = m.Complex('A(a~S,b!1).B(b~T,a!1)'))
ids_ARBU = model.get_molecule_ids(pattern = m.Complex('A(a~R,b!1).B(b~U,a!1)'))
ids_AB = model.get_molecule_ids(pattern = m.Complex('A(b!1).B(a!1)'))
assert len(ids_A) == num_AR + num_AS + num_ASBT + num_ARBU
assert len(ids_B) == num_BT + num_BU + num_ASBT + num_ARBU
assert len(ids_AR) == num_AR + num_ARBU
assert len(ids_AS) == num_AS + num_ASBT
# ---- observables ----
viz_output = m.VizOutput(mode=m.VizMode.ASCII,
output_files_prefix='./viz_data/seed_' +
str(get_seed()).zfill(5) + '/Scene',
every_n_timesteps=1)
# declaration of rxn rules defined in BNGL and used in counts
react_a_plus_b = subsystem.find_reaction_rule('react_a_plus_b')
assert react_a_plus_b, "Reaction rule 'react_a_plus_b' was not found"
react_b_plus_c = subsystem.find_reaction_rule('react_b_plus_c')
assert react_b_plus_c, "Reaction rule 'react_b_plus_c' was not found"
count_a_Cube1 = m.Count(
expression=m.CountTerm(molecules_pattern=m.Complex('a'), region=Cube1),
file_name='./react_data/seed_' + str(get_seed()).zfill(5) + '/a.Cube1.dat',
every_n_timesteps=0 # used only manually
)
count_a_Cube2 = m.Count(
expression=m.CountTerm(molecules_pattern=m.Complex('a'), region=Cube2),
file_name='./react_data/seed_' + str(get_seed()).zfill(5) + '/a.Cube2.dat',
every_n_timesteps=0 # used only manually
)
count_a_Cube3 = m.Count(
expression=m.CountTerm(molecules_pattern=m.Complex('a'), region=Cube3),
file_name='./react_data/seed_' + str(get_seed()).zfill(5) + '/a.Cube3.dat',
every_n_timesteps=0 # used only manually
)
