def test_add_rate_rule_dict(self): species2 = gillespy2.Species('test_species2',initial_value=2, mode ='continuous') species3 = gillespy2.Species('test_species3',initial_value=3, mode='continuous') rule2 = gillespy2.RateRule(species2, 'cos(t)') rule3 = gillespy2.RateRule(species3, 'sin(t)') rate_rule_dict = {'rule2' :rule2, 'rule3':rule3} self.model.add_species([species2,species3]) with self.assertRaises(ParameterError): self.model.add_rate_rule(rate_rule_dict)
def test_model_add__multiple_components__in_order(self): import gillespy2 s1 = gillespy2.Species(name="s1", initial_value=29) k1 = gillespy2.Parameter(name="k1", expression=29) r1 = gillespy2.Reaction(name="r1", reactants={"s1": 1}, rate="k1") rr1 = gillespy2.RateRule(name="rr1", variable="k1", formula="29") ar1 = gillespy2.AssignmentRule(name="ar1", variable="s1", formula="29") ea = gillespy2.EventAssignment(name="ea", variable="k1", expression="29") et = gillespy2.EventTrigger(expression="t > 29") e1 = gillespy2.Event(name="e1", trigger=et, assignments=[ea]) divide = gillespy2.FunctionDefinition(name="divide", function="x / y", args=["x", "y"]) tspan = gillespy2.TimeSpan(range(100)) model = gillespy2.Model(name="Test Model") model.add([s1, k1, r1, rr1, ar1, e1, divide, tspan]) self.assertIn("ar1", model.listOfAssignmentRules) self.assertIn("e1", model.listOfEvents) self.assertIn("divide", model.listOfFunctionDefinitions) self.assertIn("k1", model.listOfParameters) self.assertIn("rr1", model.listOfRateRules) self.assertIn("r1", model.listOfReactions) self.assertIn("s1", model.listOfSpecies) self.assertEqual(tspan, model.tspan)
def test_add_rate_rule_dict(self): model = create_decay() species2 = gillespy2.Species('test_species2', initial_value=2, mode='continuous') species3 = gillespy2.Species('test_species3', initial_value=3, mode='continuous') rule2 = gillespy2.RateRule('rule2', species2, 'cos(t)') rule3 = gillespy2.RateRule(name='rule3', variable=species3, formula='sin(t)') rate_rule_dict = {'rule2': rule2, 'rule3': rule3} model.add_species([species2, species3]) with self.assertRaises(ModelError): model.add_rate_rule(rate_rule_dict)
def test_add_rate_rule(self): model = Example() species = gillespy2.Species('test_species', initial_value=1) rule = gillespy2.RateRule(name='rr1',formula='test_species+1',variable='test_species') model.add_species([species]) model.add_rate_rule([rule]) results = model.run() self.assertEqual(results[0].solver_name, 'TauHybridSolver')
def create_rate_rule_test_model(parameter_values=None): model = gillespy2.Model(name="RateRuleTestModel") s1 = gillespy2.Species(name="S1", initial_value=0.015, mode='continuous') s2 = gillespy2.Species(name="S2", initial_value=0.0, mode='continuous') s3 = gillespy2.Species(name="S3", initial_value=1.0, mode='continuous') model.add_species([s1, s2, s3]) k1 = gillespy2.Parameter(name="k1", expression="1.0") model.add_parameter([k1]) rule1 = gillespy2.RateRule(name="rule1", variable="S1", formula="-k1*S1") rule2 = gillespy2.RateRule(name="rule2", variable="S2", formula="k1*S1") rule3 = gillespy2.RateRule(name="rule3", variable="S3", formula="0.015-(S1+S2)") model.add_rate_rule([rule1, rule2, rule3]) model.timespan(numpy.linspace(0, 20, 51)) return model
def test_add_bad_expression_rate_rule_dict(self): model = create_decay() species2 = gillespy2.Species('test_species2', initial_value=2, mode='continuous') rule = gillespy2.RateRule(variable=species2, formula='') with self.assertRaises(ModelError): model.add_rate_rule(rule)
def test_add_rate_rule(self): species = gillespy2.Species('test_species', initial_value=1, mode='continuous') rule = gillespy2.RateRule(species, 'cos(t)') self.model.add_species([species]) self.model.add_rate_rule([rule]) self.model.run(solver=BasicTauHybridSolver)
def setUpClass(cls): cls.solvers = [ SSACSolver, ODESolver, NumPySSASolver, TauLeapingSolver, TauHybridSolver, ODECSolver, TauLeapingCSolver, TauHybridCSolver, ] cls.sbml_features = { "AssignmentRule": lambda model, variable: model.add_assignment_rule(gillespy2.AssignmentRule(variable=variable, formula="1/(t+1)")), "RateRule": lambda model, variable: model.add_rate_rule(gillespy2.RateRule(variable=variable, formula="2*t")), "Event": lambda model, variable: model.add_event(gillespy2.Event( trigger=gillespy2.EventTrigger(expression="t>1"), assignments=[gillespy2.EventAssignment(variable=variable, expression="100")] )), "FunctionDefinition": lambda model, variable: model.add_function_definition( gillespy2.FunctionDefinition(name="fn", function="variable", args=["variable"])), } # List of supported SBML features for each solver. # When a feature is implemented for a particular solver, add the feature to its list. cls.solver_supported_sbml_features = { NumPySSASolver: [], TauLeapingSolver: [], ODESolver: [], TauHybridSolver: [ "AssignmentRule", "RateRule", "Event", "FunctionDefinition", ], SSACSolver: [], ODECSolver: [], TauLeapingCSolver: [], TauHybridCSolver: [ "RateRule", "Event", ], } cls.model = create_decay() cls.results = {} cls.labeled_results = {} cls.labeled_results_more_trajectories = {}
def test_add_rate_rule(self): model = create_decay() species = gillespy2.Species('test_species', initial_value=1) rule = gillespy2.RateRule(name='rr1', formula='test_species+1', variable='test_species') model.add_species([species]) model.add_rate_rule([rule]) results = model.run() valid_solvers = ('TauHybridSolver', 'TauHybridCSolver') self.assertIn(results[0].solver_name, valid_solvers)
def __get_rules(sbml_model, gillespy_model, errors): for i in range(sbml_model.getNumRules()): rule = sbml_model.getRule(i) rule_name = rule.getId() rule_variable = rule.getVariable() rule_string = __get_math(rule.getMath()) if rule_variable in gillespy_model.listOfParameters: # Treat Non-Constant Parameters as Species value = gillespy_model.listOfParameters[rule_variable].expression species = gillespy2.Species(name=rule_variable, initial_value=value, allow_negative_populations=True, mode='continuous') gillespy_model.delete_parameter(rule_variable) gillespy_model.add_species([species]) t = [] if rule.isAssignment(): assign_value = eval(rule_string, {**eval_globals, **init_state}) postponed_evals[rule_variable] = rule_string gillespy_rule = gillespy2.AssignmentRule(name=rule_name, variable=rule_variable, formula=rule_string) gillespy_model.add_assignment_rule(gillespy_rule) init_state[gillespy_rule.variable] = eval(gillespy_rule.formula, { **init_state, **eval_globals }) if rule.isRate(): gillespy_rule = gillespy2.RateRule(name=rule_name, variable=rule_variable, formula=rule_string) gillespy_model.add_rate_rule(gillespy_rule) if rule.isAlgebraic(): t.append('algebraic') if len(t) > 0: t[0] = t[0].capitalize() msg = ", ".join(t) msg += " rule" else: msg = "Rule" errors.append([ "{0} '{1}' found on line '{2}' with equation '{3}'. gillespy does not support SBML Algebraic Rules" .format(msg, rule.getId(), rule.getLine(), libsbml.formulaToString(rule.getMath())), -5 ])
def __create_diff_eqs(self, comb, model, dependencies): ''' Helper method used to convert stochastic reaction descriptions into differential equations, used dynamically throught the simulation. ''' diff_eqs = OrderedDict() rate_rules = OrderedDict() #Initialize sample dict for spec in model.listOfSpecies: if spec in model.listOfRateRules: diff_eqs[spec] = model.listOfRateRules[spec].formula else: diff_eqs[spec] = '0' # loop through each det reaction and concatenate it's diff eq for each species for reaction in comb: factor = {dep: 0 for dep in dependencies[reaction]} for key, value in model.listOfReactions[reaction].reactants.items( ): if not key.constant and not key.boundary_condition: factor[key.name] -= value for key, value in model.listOfReactions[reaction].products.items(): if not key.constant and not key.boundary_condition: factor[key.name] += value for dep in dependencies[reaction]: if factor[dep] != 0: if model.listOfSpecies[dep].mode == 'continuous': diff_eqs[dep] += ' + {0}*({1})'.format( factor[dep], model.listOfReactions[reaction]. ode_propensity_function) else: diff_eqs[dep] += ' + {0}*({1})'.format( factor[dep], model.listOfReactions[reaction]. propensity_function) for spec in model.listOfSpecies: if diff_eqs[spec] == '0': del diff_eqs[spec] #create a dictionary of compiled gillespy2 rate rules for spec, rate in diff_eqs.items(): rate_rules[spec] = compile( gillespy2.RateRule(model.listOfSpecies[spec], rate).formula, '<string>', 'eval') return rate_rules
def create_truncated_state_model(parameter_values=None): model = gillespy2.Model(name="TruncatedStateModel") S1 = gillespy2.Species(name="S1", initial_value=0, mode="discrete") rate = gillespy2.Species(name="rate", initial_value=0.9999, mode="continuous") model.add_species([S1, rate]) model.add_rate_rule( gillespy2.RateRule(variable="rate", formula="-1/((t+0.9999)**2)")) model.add_reaction( # Because S1 is a "discrete" species, our reaction will be marked "stochastic." gillespy2.Reaction(products={S1: 1}, propensity_function="10.0*rate")) return model
def create_diff_eqs(self, comb, model, dependencies): diff_eqs = OrderedDict() reactions = OrderedDict() rate_rules = OrderedDict() #Initialize sample dict for reaction in comb: for dep in dependencies[reaction]: if dep not in diff_eqs: diff_eqs[dep] = '0' # loop through each det reaction and concatenate it's diff eq for each species for reaction in comb: factor = OrderedDict() for dep in dependencies[reaction]: if model.listOfSpecies[dep].mode != 'continuous': pure_continuous = False for dep in dependencies[reaction]: factor[dep] = 0 for key, value in model.listOfReactions[reaction].reactants.items( ): factor[key.name] -= value for key, value in model.listOfReactions[reaction].products.items(): factor[key.name] += value for dep in dependencies[reaction]: if factor[dep] != 0: if model.listOfSpecies[dep].mode == 'continuous': diff_eqs[dep] += ' + {0}*({1})'.format( factor[dep], model.listOfReactions[reaction]. ode_propensity_function) else: diff_eqs[dep] += ' + {0}*({1})'.format( factor[dep], model.listOfReactions[reaction]. propensity_function) #create a dictionary of compiled gillespy2 rate rules for spec, rate in diff_eqs.items(): rate_rules[spec] = compile( gillespy2.RateRule(model.listOfSpecies[spec], rate).expression, '<string>', 'eval') # be sure to include model rate rules for i, rr in enumerate(model.listOfRateRules): rate_rules[rr] = compile(model.listOfRateRules[rr].expression, '<string>', 'eval') return rate_rules
def test_add_bad_species_rate_rule_dict(self): model = Example() rule = gillespy2.RateRule(formula='sin(t)') with self.assertRaises(ModelError): model.add_rate_rule(rule)
def test_add_bad_expression_rate_rule_dict(self): species2 = gillespy2.Species('test_species2', initial_value=2, mode='continuous') rule = gillespy2.RateRule(species=species2, expression='') with self.assertRaises(ModelError): self.model.add_rate_rule(rule)
def test_add_bad_species_rate_rule_dict(self): species2 = gillespy2.Species('test_species2', initial_value=2, mode='continuous') rule = gillespy2.RateRule(formula='sin(t)') with self.assertRaises(ModelError): self.model.add_rate_rule(rule)