def create_protein_decay(parameter_values=None): # Instantiate Model model = gillespy2.Model(name="Protein Decay") # Define Variables (GillesPy2.Species) protein = gillespy2.Species(name='protein', initial_value=50) # Add Variables to Model model.add_species(protein) # Define Parameters decayrate = gillespy2.Parameter(name='decayrate', expression=0.05) # Add Parameters to Model model.add_parameter(decayrate) # Define Reactions reaction = gillespy2.Reaction( name="decay", rate='decayrate', reactants={'protein': 1}, products={} ) # Add Reactions to Model model.add_reaction(reaction) # Define Timespan tspan = gillespy2.TimeSpan.linspace(t=100, num_points=101) # Set Model Timespan model.timespan(tspan) return model
def create_event_test_model(parameter_values=None): model = gillespy2.Model(name='Event Test Model') model.add_species([gillespy2.Species(name='S', initial_value=0)]) model.add_parameter( gillespy2.Parameter(name='event_tracker', expression=99)) model.add_parameter( gillespy2.Parameter(name='event_tracker2', expression=0)) model.add_reaction( gillespy2.Reaction( name='r1', products={'S': 1}, rate=model.listOfParameters['event_tracker2'])) eventTrig1 = gillespy2.EventTrigger(expression='t>=2') event1 = gillespy2.Event(name='event1', trigger=eventTrig1) event1.add_assignment( gillespy2.EventAssignment(variable='event_tracker', expression='t')) eventTrig2 = gillespy2.EventTrigger( expression='t >= event_tracker + 2') event2 = gillespy2.Event(name='event2', trigger=eventTrig2) event2.add_assignment( gillespy2.EventAssignment(variable='event_tracker2', expression='t')) model.add_event([event1, event2]) return model
def convert(filename, model_name=None, gillespy_model=None, report_silently_with_sbml_error=False): sbml_model, errors = __read_sbml_model(filename) if sbml_model is None: if report_silently_with_sbml_error: return None, errors errs = '\n\t'.join(errors) raise SBMLError(f"SBML model import failed. Reason Given: \n\t{errs}") if len(errors) > 0 and not report_silently_with_sbml_error: from gillespy2 import log errs = '\n\t'.join(errors) log.warning(f"Error were detected in the SBML model. Error: \n\t{errs}") if model_name is None: model_name = sbml_model.getName() if gillespy_model is None: gillespy_model = gillespy2.Model(name=model_name) gillespy_model.units = "concentration" __get_function_definitions(sbml_model, gillespy_model) __get_parameters(sbml_model, gillespy_model) __get_species(sbml_model, gillespy_model, errors) __get_compartments(sbml_model, gillespy_model) __get_reactions(sbml_model, gillespy_model, errors) __get_rules(sbml_model, gillespy_model, errors) __get_constraints(sbml_model, gillespy_model) __get_events(sbml_model, gillespy_model) __get_initial_assignments(sbml_model, gillespy_model) __resolve_evals(gillespy_model, init_state) return gillespy_model, errors
def create_boundary_condition_test_model(parameter_values=None): model = gillespy2.Model(name="BoundaryConditionTestModel") s1 = gillespy2.Species(name="S1", boundary_condition=True, initial_value=0.001, mode='continuous') s2 = gillespy2.Species(name="S2", boundary_condition=False, initial_value=0.002, mode='continuous') s3 = gillespy2.Species(name="S3", boundary_condition=False, initial_value=0.001, mode='continuous') s4 = gillespy2.Species(name="S4", boundary_condition=True, initial_value=0.002, mode='continuous') model.add_species([s1, s2, s3, s4]) k1 = gillespy2.Parameter(name="k1", expression="0.75") k2 = gillespy2.Parameter(name="k2", expression="0.25") model.add_parameter([k1, k2]) reaction1 = gillespy2.Reaction(name="reaction1", propensity_function="vol*k1*S1*S2", reactants={s1: 1, s2: 1}, products={s3: 1}) reaction2 = gillespy2.Reaction(name="reaction2", propensity_function="vol*k2*S3", reactants={s3: 1}, products={s1: 1, s2: 1}) reaction3 = gillespy2.Reaction(name="reaction3", propensity_function="vol*k2*S3", reactants={s1: 1, s2: 2, s3: 1}, products={s4: 1}) model.add_reaction([reaction1, reaction2, reaction3]) model.timespan(numpy.linspace(0, 20, 51)) return model
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 cbsa2gillespy(cbsa_model): import gillespy2 as glp gilles = glp.Model(name="Model") k = [glp.Parameter(name='k'+str(i), expression=cbsa_model.exp_k[i]) for i in range(1,cbsa_model.exp_n_reactions)] gilles.add_parameter(k) mols = [glp.Species(name='M'+str(i), initial_value=int(cbsa_model.exp_x0[i])) for i in range(1,cbsa_model.exp_n_molecules)] gilles.add_species(mols) reactions = [] for i in range(1,cbsa_model.exp_n_reactions): reactants = list(np.where(cbsa_model.expS[:,i] < 0)[0]) reactants_sto = list(cbsa_model.expS[:,i][reactants]*-1) modifiers = list(np.where(cbsa_model.expR[:,i] > 0)[0]) modifiers_sto = list(cbsa_model.expR[:,i][modifiers]) products = list(np.where(cbsa_model.expS[:,i] > 0)[0]) products_sto = list(cbsa_model.expS[:,i][products]) reactants += modifiers reactants_sto += modifiers_sto products += modifiers products_sto += modifiers_sto reactions.append(glp.Reaction(name="R"+str(i), rate=k[i-1], reactants={mols[reactants[j]-1]:reactants_sto[j] for j in range(len(reactants))}, products={mols[products[j]-1]:products_sto[j] for j in range(len(products))} ) ) gilles.add_reaction(reactions) return gilles
def test_compile_w_spaces(self): import gillespy2 self.solvers = [ gillespy2.ODECSolver, gillespy2.SSACSolver, gillespy2.TauLeapingCSolver, gillespy2.TauHybridCSolver ] # create a model model = gillespy2.Model(name="Michaelis_Menten") # parameters rate1 = gillespy2.Parameter(name='rate1', expression=0.0017) rate2 = gillespy2.Parameter(name='rate2', expression=0.5) rate3 = gillespy2.Parameter(name='rate3', expression=0.1) model.add_parameter([rate1, rate2, rate3]) # Species A = gillespy2.Species(name='A', initial_value=301) B = gillespy2.Species(name='B', initial_value=120) C = gillespy2.Species(name='C', initial_value=0) D = gillespy2.Species(name='D', initial_value=0) model.add_species([A, B, C, D]) # reactions r1 = gillespy2.Reaction(name="r1", reactants={ A: 1, B: 1 }, products={C: 1}, rate=rate1) r2 = gillespy2.Reaction(name="r2", reactants={C: 1}, products={ A: 1, B: 1 }, rate=rate2) r3 = gillespy2.Reaction(name="r3", reactants={C: 1}, products={ B: 1, D: 1 }, rate=rate3) model.add_reaction([r1, r2, r3]) model.timespan(gillespy2.TimeSpan.linspace(t=100, num_points=101)) # run the model for solver in self.solvers: with self.subTest(solver=solver.name): if platform.system() == "Windows": with self.assertRaises(gillespy2.SimulationError): model.run(solver=solver) else: result = model.run(solver=solver) self.assertTrue(gillespy2.__file__ == os.path.join( self.prefix_base_dir, 'A SPACE/gillespy2/__init__.py'))
def create_stoch_test_1(parameter_values=None): model = gillespy2.Model(name='StochTest1') A = gillespy2.Species(name='A', initial_value=10) B = gillespy2.Species(name='B', initial_value=0) model.add_species([A, B]) k = gillespy2.Parameter(name='k', expression=10) model.add_parameter([k]) r = gillespy2.Reaction(name='r', reactants={A: 2}, products={B: 1}, rate=k) model.add_reaction([r]) model.timespan(np.linspace(0, 100, 101)) return model
def create_stoch_test_1(parameter_values=None): model = gillespy2.Model(name='StochTest1') A = gillespy2.Species(name='A', initial_value=10) B = gillespy2.Species(name='B', initial_value=0) model.add_species([A, B]) k = gillespy2.Parameter(name='k', expression=10) model.add_parameter([k]) r = gillespy2.Reaction(name='r', reactants={A: 1}, products={B: 1}, propensity_function="k*A/vol" ) # testing if 'vol' is a pre-set variable model.add_reaction([r]) model.timespan(np.linspace(0, 100, 101)) return model
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_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 create_base_event_model(s1, s2, rate): model = gillespy2.Model(name="BasicEventModel") s1 = gillespy2.Species(name="S1", initial_value=s1, mode="continuous") s2 = gillespy2.Species(name="S2", initial_value=s2, mode="continuous") model.add_species([s1, s2]) rate = gillespy2.Parameter(name="k1", expression=rate) model.add_parameter(rate) r1 = gillespy2.Reaction( name="r1", reactants={s1: 1}, products={s2: 1}, rate=rate, ) model.add_reaction(r1) return model
def convert(filename, model_name=None, gillespy_model=None): sbml_model, errors = __read_sbml_model(filename) if model_name is None: model_name = sbml_model.getName() if gillespy_model is None: gillespy_model = gillespy2.Model(name=model_name) gillespy_model.units = "concentration" __get_function_definitions(sbml_model, gillespy_model) __get_parameters(sbml_model, gillespy_model) __get_species(sbml_model, gillespy_model, errors) __get_compartments(sbml_model, gillespy_model) __get_reactions(sbml_model, gillespy_model, errors) __get_rules(sbml_model, gillespy_model, errors) __get_constraints(sbml_model, gillespy_model) __get_events(sbml_model, gillespy_model) __get_initial_assignments(sbml_model, gillespy_model) __resolve_evals(gillespy_model, init_state) return gillespy_model, errors
def create_dimerization(parameter_values=None): # Initialize Model model = gillespy2.Model(name="Dimerization") # Define Variables (GillesPy2.Species) m = gillespy2.Species(name='monomer', initial_value=30) d = gillespy2.Species(name='dimer', initial_value=0) # Add Variables to Model model.add_species([m, d]) # Define Parameters k_c = gillespy2.Parameter(name='k_c', expression=0.005) k_d = gillespy2.Parameter(name='k_d', expression=0.08) # Add Parameters to Model model.add_parameter([k_c, k_d]) # Define Reactions r_creation = gillespy2.Reaction(name="r_creation", reactants={'monomer': 2}, products={'dimer': 1}, rate='k_c') r_dissociation = gillespy2.Reaction(name="r_dissociation", reactants={'dimer': 1}, products={'monomer': 2}, rate='k_d') # Add Reactions to Model model.add_reaction([r_creation, r_dissociation]) # Define Timespan tspan = gillespy2.TimeSpan.linspace(t=100, num_points=101) # Set Model Timespan model.timespan(tspan) return model
def create_vilar_oscillator(parameter_values=None): model = gillespy2.Model(name="VilarOscillator") # Set System Volume model.volume = 1 # Define Variables (GillesPy2.Species) Da = gillespy2.Species(name="Da", initial_value=1, mode="discrete") Da_prime = gillespy2.Species(name="Da_prime", initial_value=0, mode="discrete") Ma = gillespy2.Species(name="Ma", initial_value=0, mode="discrete") Dr = gillespy2.Species(name="Dr", initial_value=1, mode="discrete") Dr_prime = gillespy2.Species(name="Dr_prime", initial_value=0, mode="discrete") Mr = gillespy2.Species(name="Mr", initial_value=0, mode="discrete") C = gillespy2.Species(name="C", initial_value=0, mode="discrete") A = gillespy2.Species(name="A", initial_value=0, mode="discrete") R = gillespy2.Species(name="R", initial_value=0, mode="discrete") # Add Vairables to Model model.add_species([Da, Da_prime, Ma, Dr, Dr_prime, Mr, C, A, R]) # Define Parameters alphaA = gillespy2.Parameter(name="alphaA", expression=50) alphaA_prime = gillespy2.Parameter(name="alphaA_prime", expression=500) alphaR = gillespy2.Parameter(name="alphaR", expression=0.01) alphaR_prime = gillespy2.Parameter(name="alphaR_prime", expression=50) betaA = gillespy2.Parameter(name="betaA", expression=50) betaR = gillespy2.Parameter(name="betaR", expression=5) deltaMA = gillespy2.Parameter(name="deltaMA", expression=10) deltaMR = gillespy2.Parameter(name="deltaMR", expression=0.5) deltaA = gillespy2.Parameter(name="deltaA", expression=1) deltaR = gillespy2.Parameter(name="deltaR", expression=0.2) gammaA = gillespy2.Parameter(name="gammaA", expression=1) gammaR = gillespy2.Parameter(name="gammaR", expression=1) gammaC = gillespy2.Parameter(name="gammaC", expression=2) thetaA = gillespy2.Parameter(name="thetaA", expression=50) thetaR = gillespy2.Parameter(name="thetaR", expression=100) # Add Parameters to Model model.add_parameter([ alphaA, alphaA_prime, alphaR, alphaR_prime, betaA, betaR, deltaMA, deltaMR, deltaA, deltaR, gammaA, gammaR, gammaC, thetaA, thetaR ]) # Define Reactions r1 = gillespy2.Reaction(name="r1", reactants={ 'A': 1, 'R': 1 }, products={'C': 1}, rate="gammaC") r2 = gillespy2.Reaction(name="r2", reactants={'A': 1}, products={}, rate="deltaA") r3 = gillespy2.Reaction(name="r3", reactants={'C': 1}, products={'R': 1}, rate="deltaA") r4 = gillespy2.Reaction(name="r4", reactants={'R': 1}, products={}, rate="deltaR") r5 = gillespy2.Reaction(name="r5", reactants={ 'A': 1, 'Da': 1 }, products={'Da_prime': 1}, rate="gammaA") r6 = gillespy2.Reaction(name="r6", reactants={'Da_prime': 1}, products={ 'A': 1, 'Da': 1 }, rate="thetaA") r7 = gillespy2.Reaction(name="r7", reactants={'Da': 1}, products={ 'Da': 1, 'Ma': 1 }, rate="alphaA") r8 = gillespy2.Reaction(name="r8", reactants={'Da_prime': 1}, products={ 'Da_prime': 1, 'Ma': 1 }, rate="alphaA_prime") r9 = gillespy2.Reaction(name="r9", reactants={'Ma': 1}, products={}, rate="deltaMA") r10 = gillespy2.Reaction(name="r10", reactants={'Ma': 1}, products={ 'A': 1, 'Ma': 1 }, rate="betaA") r11 = gillespy2.Reaction(name="r11", reactants={ 'A': 1, 'Dr': 1 }, products={'Dr_prime': 1}, rate="gammaR") r12 = gillespy2.Reaction(name="r12", reactants={'Dr_prime': 1}, products={ 'A': 1, 'Dr': 1 }, rate="thetaR") r13 = gillespy2.Reaction(name="r13", reactants={'Dr': 1}, products={ 'Dr': 1, 'Mr': 1 }, rate="alphaR") r14 = gillespy2.Reaction(name="r14", reactants={'Dr_prime': 1}, products={ 'Dr_prime': 1, 'Mr': 1 }, rate="alphaR_prime") r15 = gillespy2.Reaction(name="r15", reactants={'Mr': 1}, products={}, rate="deltaMR") r16 = gillespy2.Reaction(name="r16", reactants={'Mr': 1}, products={ 'Mr': 1, 'R': 1 }, rate="betaR") # Add Reactions to Model model.add_reaction([ r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16 ]) # Define Timespan tspan = gillespy2.TimeSpan.linspace(t=200, num_points=201) # Set Model Timespan model.timespan(tspan) return model
def create_tyson_2_state(parameter_values=None): """ Here, as a test case, we run a simple two-state oscillator (Novak & Tyson 2008) as an example of a stochastic reaction system. """ system_volume = 300 #system volume model = gillespy2.Model(name="tyson-2-state", volume=system_volume) model.timespan(np.linspace(0, 100, 101)) # ============================================= # Define model species, initial values, parameters, and volume # ============================================= # Parameter values for this biochemical system are given in # concentration units. However, stochastic systems must use population # values. For example, a concentration unit of 0.5mol/(L*s) # is multiplied by a volume unit, to get a population/s rate # constant. Thus, for our non-mass action reactions, we include the # parameter "vol" in order to convert population units to concentration # units. Volume here = 300. P = gillespy2.Parameter(name='P', expression=2.0) kt = gillespy2.Parameter(name='kt', expression=20.0) kd = gillespy2.Parameter(name='kd', expression=1.0) a0 = gillespy2.Parameter(name='a0', expression=0.005) a1 = gillespy2.Parameter(name='a1', expression=0.05) a2 = gillespy2.Parameter(name='a2', expression=0.1) kdx = gillespy2.Parameter(name='kdx', expression=1.0) model.add_parameter([P, kt, kd, a0, a1, a2, kdx]) # Species # Initial values of each species (concentration converted to pop.) X = gillespy2.Species(name='X', initial_value=int(0.65609071 * system_volume)) Y = gillespy2.Species(name='Y', initial_value=int(0.85088331 * system_volume)) model.add_species([X, Y]) # ============================================= # Define the reactions within the model # ============================================= # creation of X: rxn1 = gillespy2.Reaction( name='X production', reactants={}, products={X: 1}, propensity_function='vol*1/(1+(Y*Y/((vol*vol))))') # degradadation of X: rxn2 = gillespy2.Reaction(name='X degradation', reactants={X: 1}, products={}, rate=kdx) # creation of Y: rxn3 = gillespy2.Reaction(name='Y production', reactants={X: 1}, products={ X: 1, Y: 1 }, rate=kt) # degradation of Y: rxn4 = gillespy2.Reaction(name='Y degradation', reactants={Y: 1}, products={}, rate=kd) # nonlinear Y term: rxn5 = gillespy2.Reaction( name='Y nonlin', reactants={Y: 1}, products={}, propensity_function='Y/(a0 + a1*(Y/vol)+a2*Y*Y/(vol*vol))') model.add_reaction([rxn1, rxn2, rxn3, rxn4, rxn5]) return model
def create_test_model(parameter_values=None): model = gillespy2.Model(name="TestModel") model.add_species(gillespy2.Species(name="S", initial_value=0)) model.timespan(np.linspace(0, 10, 11)) return model
def create_tyson_oscillator(parameter_values=None): # Initialize Model model = gillespy2.Model(name="tyson-2-state") # Set System Volume model.volume = 300 # Define Variables (GillesPy2.Species) # Initial values of each species (concentration converted to pop.) X = gillespy2.Species(name='X', initial_value=int(0.65609071 * model.volume)) Y = gillespy2.Species(name='Y', initial_value=int(0.85088331 * model.volume)) # Add Variables to Model model.add_species([X, Y]) # Define Parameters P = gillespy2.Parameter(name='P', expression=2.0) kt = gillespy2.Parameter(name='kt', expression=20.0) kd = gillespy2.Parameter(name='kd', expression=1.0) a0 = gillespy2.Parameter(name='a0', expression=0.005) a1 = gillespy2.Parameter(name='a1', expression=0.05) a2 = gillespy2.Parameter(name='a2', expression=0.1) kdx = gillespy2.Parameter(name='kdx', expression=1.0) # Add Parameters to Model model.add_parameter([P, kt, kd, a0, a1, a2, kdx]) # Define Reactions # creation of X: rxn1 = gillespy2.Reaction( name='X production', reactants={}, products={'X': 1}, propensity_function='vol*1/(1+(Y*Y/((vol*vol))))') # degradadation of X: rxn2 = gillespy2.Reaction(name='X degradation', reactants={'X': 1}, products={}, rate='kdx') # creation of Y: rxn3 = gillespy2.Reaction(name='Y production', reactants={'X': 1}, products={ 'X': 1, 'Y': 1 }, rate='kt') # degradation of Y: rxn4 = gillespy2.Reaction(name='Y degradation', reactants={'Y': 1}, products={}, rate='kd') # nonlinear Y term: rxn5 = gillespy2.Reaction( name='Y nonlin', reactants={'Y': 1}, products={}, propensity_function='Y/(a0 + a1*(Y/vol)+a2*Y*Y/(vol*vol))') # Add Reactions to Model model.add_reaction([rxn1, rxn2, rxn3, rxn4, rxn5]) # Define Timespan tspan = gillespy2.TimeSpan.linspace(t=20, num_points=21) # Set Model Timespan model.timespan(tspan) return model
def convert(filename, model_name=None, gillespy_model=None): try: import libsbml except ImportError: raise ImportError('libsbml is required to convert SBML files for GillesPy.') document = libsbml.readSBML(filename) errors = [] error_count = document.getNumErrors() if error_count > 0: for i in range(error_count): error = document.getError(i) converter_code = 0 converter_code = -10 errors.append(["SBML {0}, code {1}, line {2}: {3}".format(error.getSeverityAsString(), error.getErrorId(), error.getLine(), error.getMessage()), converter_code]) if min([code for error, code in errors] + [0]) < 0: return None, errors model = document.getModel() if model_name is None: model_name = model.getName() if gillespy_model is None: gillespy_model = gillespy2.Model(name=model_name) gillespy_model.units = "concentration" for i in range(model.getNumSpecies()): species = model.getSpecies(i) if species.getId() == 'EmptySet': errors.append([ "EmptySet species detected in model on line {0}. EmptySet is not an explicit species in " "gillespy".format( species.getLine()), 0]) continue name = species.getId() if species.isSetInitialAmount(): value = int(species.getInitialAmount()) mode = 'dynamic' elif species.isSetInitialConcentration(): value = species.getInitialConcentration() mode = 'continuous' else: rule = model.getRule(species.getId()) if rule: msg = "" if rule.isAssignment(): msg = "assignment " elif rule.isRate(): msg = "rate " elif rule.isAlgebraic(): msg = "algebraic " msg += "rule" errors.append([ "Species '{0}' does not have any initial conditions. Associated {1} '{2}' found, " "but {1}s are not supported in gillespy. Assuming initial condition 0".format( species.getId(), msg, rule.getId()), 0]) else: errors.append([ "Species '{0}' does not have any initial conditions or rules. Assuming initial " "condition 0".format( species.getId()), 0]) value = 0 is_negative = value < 0.0 gillespy_species = gillespy2.Species(name=name, initial_value=value, allow_negative_populations= is_negative, mode=mode) gillespy_model.add_species([gillespy_species]) for i in range(model.getNumParameters()): parameter = model.getParameter(i) name = parameter.getId() value = parameter.getValue() gillespy_parameter = gillespy2.Parameter(name=name, expression=value) gillespy_model.add_parameter([gillespy_parameter]) for i in range(model.getNumCompartments()): compartment = model.getCompartment(i) name = compartment.getId() value = compartment.getSize() gillespy_parameter = gillespy2.Parameter(name=name, expression=value) gillespy_model.add_parameter([gillespy_parameter]) # local parameters for i in range(model.getNumReactions()): reaction = model.getReaction(i) kinetic_law = reaction.getKineticLaw() for j in range(kinetic_law.getNumParameters()): parameter = kinetic_law.getParameter(j) name = parameter.getId() value = parameter.getValue() gillespy_parameter = gillespy2.Parameter(name=name, expression=value) gillespy_model.add_parameter([gillespy_parameter]) # reactions for i in range(model.getNumReactions()): reaction = model.getReaction(i) name = reaction.getId() reactants = {} products = {} for j in range(reaction.getNumReactants()): species = reaction.getReactant(j) if species.getSpecies() == "EmptySet": errors.append([ "EmptySet species detected as reactant in reaction '{0}' on line {1}. EmptySet is " "not an explicit species in gillespy".format( reaction.getId(), species.getLine()), 0]) else: reactants[species.getSpecies()] = species.getStoichiometry() # get products for j in range(reaction.getNumProducts()): species = reaction.getProduct(j) if species.getSpecies() == "EmptySet": errors.append([ "EmptySet species detected as product in reaction '{0}' on line {1}. EmptySet is " "not an explicit species in gillespy".format( reaction.getId(), species.getLine()), 0]) else: products[species.getSpecies()] = species.getStoichiometry() # propensity kinetic_law = reaction.getKineticLaw() propensity = kinetic_law.getFormula() gillespy_reaction = gillespy2.Reaction(name=name, reactants=reactants, products=products, propensity_function=propensity) gillespy_model.add_reaction([gillespy_reaction]) for i in range(model.getNumRules()): rule = model.getRule(i) t = [] if rule.isCompartmentVolume(): t.append('compartment') if rule.isParameter(): t.append('parameter') elif rule.isAssignment(): t.append('assignment') elif rule.isRate(): t.append('rate') elif 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 Rules".format( msg, rule.getId(), rule.getLine(), libsbml.formulaToString(rule.getMath())), -5]) for i in range(model.getNumCompartments()): compartment = model.getCompartment(i) errors.append([ "Compartment '{0}' found on line '{1}' with volume '{2}' and dimension '{3}'. gillespy " "assumes a single well-mixed, reaction volume".format( compartment.getId(), compartment.getLine(), compartment.getVolume(), compartment.getSpatialDimensions()), -5]) for i in range(model.getNumConstraints()): constraint = model.getConstraint(i) errors.append([ "Constraint '{0}' found on line '{1}' with equation '{2}'. gillespy does not support SBML " "Constraints".format( constraint.getId(), constraint.getLine(), libsbml.formulaToString(constraint.getMath())), -5]) for i in range(model.getNumEvents()): event = model.getEvent(i) errors.append([ "Event '{0}' found on line '{1}' with trigger equation '{2}'. gillespy does not support " "SBML Events".format( event.getId(), event.getLine(), libsbml.formulaToString(event.getTrigger().getMath())), -5]) for i in range(model.getNumFunctionDefinitions()): function = model.getFunctionDefinition(i) errors.append([ "Function '{0}' found on line '{1}' with equation '{2}'. gillespy does not support SBML " "Function Definitions".format( function.getId(), function.getLine(), libsbml.formulaToString(function.getMath())), -5]) return gillespy_model, errors