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