def test(self):
rr = _gfrd.ReactionRule([self.s1], [self.s1, self.s2])
rr['k'] = '0.1'
self.m.network_rules.add_reaction_rule(rr)
rr = _gfrd.ReactionRule([self.s1, self.s2], [self.s1])
rr['k'] = '0.2'
self.m.network_rules.add_reaction_rule(rr)
rules = set(self.nr.query_reaction_rule(self.s1))
self.assertEqual(1, len(rules))
rules = set(self.nr.query_reaction_rule(self.s1, self.s2))
self.assertEqual(1, len(rules))
def set_all_repulsive(self):
"""Set all 'other' possible ReactionRules to be repulsive.
By default an EGFRDSimulator will assume:
- a repulsive bimolecular reaction rule (k=0) for each
possible combination of reactants for which no
bimolecular reaction rule is specified.
This method explicitly adds these ReactionRules to the
ParticleModel.
"""
nr = self.network_rules
# Maybe the user has defined a reaction rule for any 2 species since a
# previous call to this method, so remove *all* repulsive reaction
# rules first.
for species1 in self.species_types:
for species2 in self.species_types:
gen = nr.query_reaction_rule(species1, species2)
if gen is not None:
for reaction_rule in gen:
if float(reaction_rule['k']) == 0.0:
nr.remove_reaction_rule(reaction_rule)
for species1 in self.species_types:
for species2 in self.species_types:
gen = nr.query_reaction_rule(species1, species2)
if gen is None or len(set(gen)) == 0:
rr = _gfrd.ReactionRule([species1, species2], [])
rr['k'] = '0.0'
nr.add_reaction_rule(rr)
def create_binding_reaction_rule(reactant1, reactant2, product, ka):
"""Example: A + B -> C.
Arguments:
- reactant1
a Species.
- reactant2
a Species.
- product
a Species.
- ka
intrinsic reaction rate. Units: meters^3 per second. (Rough
order of magnitude: 1e-16 m^3/s to 1e-20 m^3/s)
The reactants and the product should be in/on the same
Region or Surface.
A binding reaction rule always has exactly one product.
ka should be an *intrinsic* reaction rate. You can convert an
overall reaction rate (kon) to an intrinsic reaction rate (ka) with
the function utils.k_a(kon, kD), but only for reaction rules in 3D.
By default an EGFRDSimulator will assume a repulsive
bimolecular reaction rule (ka=0) for each possible combination of
reactants for which no bimolecular reaction rule is specified.
You can explicitly add these reaction rules to the model with the
method model.ParticleModel.set_all_repulsive.
"""
rr = _gfrd.ReactionRule([reactant1, reactant2], [product])
rr['k'] = '%.16g' % ka
return rr
def create_unbinding_reaction_rule(reactant, product1, product2, kd):
"""Example: A -> B + C.
Arguments:
- reactant
a Species.
- product1
a Species.
- product2
a Species.
- kd
intrinsic reaction rate. Units: per second. (Rough order of
magnitude: 1e-2 /s to 1e2 /s).
The reactant and the products should be in/on the same
Region or Surface.
An unbinding reaction rule always has exactly two products.
kd should be an *intrinsic* reaction rate. You can convert an
overall reaction rate (koff) for this reaction rule to an intrinsic
reaction rate (kd) with the function utils.k_d(koff, kon, kD) or
utils.k_d_using_ka(koff, ka, kD).
An unbinding reaction rule defines a Poissonian process.
"""
rr = _gfrd.ReactionRule([reactant], [product1, product2])
rr['k'] = '%.16g' % kd
return rr
def test_get_attribute(self):
rr = _gfrd.ReactionRule([self.s1], [])
rr['k'] = '0.0'
self.assertEqual('0.0', rr['k'])
rr['k'] = '0.5'
self.assertEqual('0.5', rr['k'])
rr['name'] = 'R1'
self.assertEqual('R1', rr['name'])
def test_query_reaction_rule(self):
r1 = _gfrd.ReactionRule([self.s1], [self.s1, self.s2])
self.m.network_rules.add_reaction_rule(r1)
a = self.m.network_rules.query_reaction_rule(self.s1)
self.assertTrue(iter(a) != None)
a = list(a)
self.assertEqual(1, len(a))
self.assertTrue(r1 in a)
r2 = _gfrd.ReactionRule([self.s1], [self.s1])
self.m.network_rules.add_reaction_rule(r2)
a = self.m.network_rules.query_reaction_rule(self.s1)
self.assertTrue(iter(a) != None)
a = list(a)
self.assertEqual(2, len(a))
self.assertTrue(r1 in a)
self.assertTrue(r2 in a)
def add_reaction(self, reactants, products, k):
reactants = map(self.get_species_type, reactants)
products = map(self.get_species_type, products)
rr = _gfrd.ReactionRule(reactants, products)
rr['k'] = '%.16g' % k
self.network_rules.add_reaction_rule(rr)
return rr
def test_add_reaction_rule(self):
self.m.network_rules.add_reaction_rule(
_gfrd.ReactionRule([self.s1], [self.s1, self.s2]))
self.assertTrue(True)
self.m.network_rules.add_reaction_rule(
_gfrd.ReactionRule([self.s2], [self.s1, self.s2]))
self.assertTrue(True)
self.assertRaises(
_gfrd.AlreadyExists,
lambda: self.m.network_rules.add_reaction_rule(
_gfrd.ReactionRule([self.s1], [self.s1, self.s2])))
self.assertRaises(
_gfrd.AlreadyExists,
lambda: self.m.network_rules.add_reaction_rule(
_gfrd.ReactionRule([self.s2], [self.s1, self.s2])))
def test_remove_reaction_rule_1(self):
# Start with None.
assert self.m.network_rules.query_reaction_rule(self.s1) == None
# Add 1.
rr = _gfrd.ReactionRule([self.s1], [self.s1, self.s2])
rr['k'] = '0.1'
self.m.network_rules.add_reaction_rule(rr)
rules = set(self.m.network_rules.query_reaction_rule(self.s1))
self.assertEqual(1, len(rules))
# Remove 1 to get 0.
self.m.network_rules.remove_reaction_rule(rr)
gen = self.m.network_rules.query_reaction_rule(self.s1)
assert len(set(gen)) == 0
def test_get_reactants_and_get_products(self):
s1, s2 = self.s1, self.s2
for reactants in [
(s1, ),
(s2, ),
(s1, s2),
]:
for products in [
(),
(s1, ),
(s2, ),
(s1, s2),
]:
r = _gfrd.ReactionRule(reactants, products)
self.assertEqual(reactants, tuple(reactants))
self.assertEqual(products, tuple(products))
def create_decay_reaction_rule(reactant, k):
"""Example: A -> 0.
Arguments:
- reactant
a Species.
- k
reaction rate. Units: per second. (Rough order of magnitude:
1e-2 /s to 1e2 /s).
There is no distinction between an intrinsic and an overall reaction
rate for a decay ReactionRule.
A decay reaction rule defines a Poissonian process.
"""
rr = _gfrd.ReactionRule([reactant], [])
rr['k'] = '%.16g' % k
return rr
def set_all_repulsive(self):
nr = self.network_rules
# Maybe the user has defined a reaction rule for any 2 species since a
# previous call to this method, so remove *all* repulsive reaction
# rules first.
for species1 in self.species_types:
for species2 in self.species_types:
gen = nr.query_reaction_rule(species1, species2)
if gen is not None:
for reaction_rule in gen:
if float(reaction_rule['k']) == 0.0:
nr.remove_reaction_rule(reaction_rule)
for species1 in self.species_types:
for species2 in self.species_types:
gen = nr.query_reaction_rule(species1, species2)
if gen is None or len(set(gen)) == 0:
rr = _gfrd.ReactionRule([species1, species2], [])
rr['k'] = '0.0'
nr.add_reaction_rule(rr)
def create_unimolecular_reaction_rule(reactant, product, k):
"""Example: A -> B.
Arguments:
- reactant
a Species.
- product
a Species.
- k
reaction rate. Units: per second. (Rough order of magnitude:
1e-2 /s to 1e2 /s).
The reactant and the product should be in/on the same
Region or Surface.
There is no distinction between an intrinsic and an overall reaction
rate for a unimolecular ReactionRule.
A unimolecular reaction rule defines a Poissonian process.
"""
rr = _gfrd.ReactionRule([reactant], [product])
rr['k'] = '%.16g' % k
return rr
def create_unimolecular_reaction_rule(s1, p1, k):
rr = _gfrd.ReactionRule([s1, ], [p1, ])
rr['k'] = '%.16g' % k
return rr
S1 = m.new_species_type()
S1['D'] = '.01'
S1['radius'] = '.01'
S1['surface'] = 'default'
S2 = m.new_species_type()
S2['D'] = '.01'
S2['radius'] = '.01'
S2['surface'] = 'default'
colors = {
S0.id: (1., 0., 0.),
S1.id: (0., 1., 0.),
S2.id: (1., 1., 0.),
}
rr = _gfrd.ReactionRule((S0, S1), (S2, ))
rr['k'] = '.01'
m.network_rules.add_reaction_rule(rr)
nrw = _gfrd.NetworkRulesWrapper(m.network_rules)
class MyParticleContainer(_gfrd._ParticleContainer):
def __init__(self, world_size):
_gfrd._ParticleContainer.__init__(self)
self.particles = {}
self.surfaces = {}
self.species = {}
self.pidgen = _gfrd.ParticleIDGenerator(0)
self.world_size = world_size
def test_instantiation(self):
s1, s2 = self.s1, self.s2
self.assertTrue(
isinstance(_gfrd.ReactionRule([s1], []), _gfrd.ReactionRule))
self.assertTrue(
isinstance(_gfrd.ReactionRule([s1, s2], []), _gfrd.ReactionRule))
self.assertTrue(
isinstance(_gfrd.ReactionRule([s1], [s1]), _gfrd.ReactionRule))
self.assertTrue(
isinstance(_gfrd.ReactionRule([s1, s1], [s1]), _gfrd.ReactionRule))
self.assertTrue(
isinstance(_gfrd.ReactionRule([s1], [s2]), _gfrd.ReactionRule))
self.assertTrue(
isinstance(_gfrd.ReactionRule([s1, s1], [s2]), _gfrd.ReactionRule))
self.assertTrue(
isinstance(_gfrd.ReactionRule([s1, s1], [s1, s1]),
_gfrd.ReactionRule))
self.assertTrue(
isinstance(_gfrd.ReactionRule([s1, s1], [s2, s2]),
_gfrd.ReactionRule))
self.assertRaises(
TypeError, lambda: self.assertTrue(
isinstance(_gfrd.ReactionRule([], []), _gfrd.ReactionRule)))
self.assertRaises(
TypeError, lambda: self.assertTrue(
isinstance(_gfrd.ReactionRule([], [s1]), _gfrd.ReactionRule)))
self.assertRaises(
TypeError, lambda: self.assertTrue(
isinstance(_gfrd.ReactionRule([], [s1, s2]), _gfrd.ReactionRule
)))
def test_comparison(self):
s1, s2 = self.s1, self.s2
self.assertEqual(_gfrd.ReactionRule([s1], []),
_gfrd.ReactionRule([s1], []))
self.assertEqual(_gfrd.ReactionRule([s1], [s1]),
_gfrd.ReactionRule([s1], [s1]))
self.assertEqual(_gfrd.ReactionRule([s1], [s2]),
_gfrd.ReactionRule([s1], [s2]))
self.assertEqual(_gfrd.ReactionRule([s1], [s1, s2]),
_gfrd.ReactionRule([s1], [s1, s2]))
self.assertEqual(_gfrd.ReactionRule([s1], [s2, s1]),
_gfrd.ReactionRule([s1], [s2, s1]))
self.assertEqual(_gfrd.ReactionRule([s1], [s1, s2]),
_gfrd.ReactionRule([s1], [s2, s1]))
self.assertEqual(_gfrd.ReactionRule([s1], [s2, s1]),
_gfrd.ReactionRule([s1], [s1, s2]))
self.assertNotEqual(_gfrd.ReactionRule([s1], []),
_gfrd.ReactionRule([s2], []))
self.assertNotEqual(_gfrd.ReactionRule([s1], [s1]),
_gfrd.ReactionRule([s2], [s1]))
self.assertNotEqual(_gfrd.ReactionRule([s1], [s2]),
_gfrd.ReactionRule([s2], [s2]))
self.assertNotEqual(_gfrd.ReactionRule([s1], [s1, s2]),
_gfrd.ReactionRule([s2], [s1, s2]))
self.assertNotEqual(_gfrd.ReactionRule([s1], [s2, s1]),
_gfrd.ReactionRule([s2], [s2, s1]))
self.assertNotEqual(_gfrd.ReactionRule([s1], [s1, s2]),
_gfrd.ReactionRule([s2], [s2, s1]))
self.assertNotEqual(_gfrd.ReactionRule([s1], [s2, s1]),
_gfrd.ReactionRule([s2], [s1, s2]))
def create_unbinding_reaction_rule(s1, p1, p2, k):
rr = _gfrd.ReactionRule([s1, ], [p1, p2])
rr['k'] = '%.16g' % k
return rr
def create_binding_reaction_rule(s1, s2, p1, k):
rr = _gfrd.ReactionRule([s1, s2], [p1, ])
rr['k'] = '%.16g' % k
return rr
def create_decay_reaction_rule(s1, k):
rr = _gfrd.ReactionRule([s1, ], [])
rr['k'] = '%.16g' % k
return rr
