def __get_kinetic_law(sbml_model, gillespy_model, reaction): kinetic_law = reaction.getKineticLaw() if kinetic_law is None: raise gillespyError.InvalidModelError( f"Failed to load SBML model: Reaction '{reaction}' is missing its propensity function." ) tree = kinetic_law.getMath() params = kinetic_law.getListOfParameters() local_params = kinetic_law.getListOfLocalParameters() for i in range(kinetic_law.getNumLocalParameters()): lp = local_params.get(i) old_id = lp.getId() new_id = ('{}_{}'.format(reaction.getId(), lp.getId())) traverse_math(tree, old_id, new_id) lp.setId(new_id) gillespy_parameter = gillespy2.Parameter(name=new_id, expression=lp.getValue()) gillespy_model.add_parameter([gillespy_parameter]) for i in range(kinetic_law.getNumParameters()): p = params.get(i) if not p.getId() in gillespy_model.listOfParameters: gillespy_parameter = gillespy2.Parameter(name=p.getId(), expression=p.getValue()) gillespy_model.add_parameter([gillespy_parameter]) return tree
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_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 __init__(self, parameter_values=None): # Initialize the model. gillespy2.Model.__init__(self, name="toggle_switch") # Parameters alpha1 = gillespy2.Parameter(name='alpha1', expression=1) alpha2 = gillespy2.Parameter(name='alpha2', expression=1) beta = gillespy2.Parameter(name='beta', expression="2.0") gamma = gillespy2.Parameter(name='gamma', expression="2.0") mu = gillespy2.Parameter(name='mu', expression=1.0) self.add_parameter([alpha1, alpha2, beta, gamma, mu]) # Species U = gillespy2.Species(name='U', initial_value=10) V = gillespy2.Species(name='V', initial_value=10) self.add_species([U, V]) # Reactions cu = gillespy2.Reaction(name="r1", reactants={}, products={U: 1}, propensity_function="alpha1/(1+pow(V,beta))") cv = gillespy2.Reaction(name="r2", reactants={}, products={V: 1}, propensity_function="alpha2/(1+pow(U,gamma))") du = gillespy2.Reaction(name="r3", reactants={U: 1}, products={}, rate=mu) dv = gillespy2.Reaction(name="r4", reactants={V: 1}, products={}, rate=mu) self.add_reaction([cu, cv, du, dv]) self.timespan(np.linspace(0, 50, 101))
def __init__(self, parameter_values=None): # First call the gillespy2.Model initializer. super().__init__(self) # Define parameters for the rates of creation and dissociation. k_c = gillespy2.Parameter(name='k_c', expression=0.005) k_d = gillespy2.Parameter(name='k_d', expression=0.08) self.add_parameter([k_c, k_d]) # Define variables for the molecular species representing M and D. m = gillespy2.Species(name='monomer', initial_value=30) d = gillespy2.Species(name='dimer', initial_value=0) self.add_species([m, d]) # Define the reactions representing the process. In GillesPy2, # the list of reactants and products for a Reaction object are each a # Python dictionary in which the dictionary keys are Species objects # and the values are stoichiometries of the species in the reaction. r_creation = gillespy2.Reaction(name="r_creation", rate=k_c, reactants={m: 2}, products={d: 1}) r_dissociation = gillespy2.Reaction(name="r_dissociation", rate=k_d, reactants={d: 1}, products={m: 2}) self.add_reaction([r_creation, r_dissociation]) # Set the timespan for the simulation. self.timespan(numpy.linspace(0, 100, 101))
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 __init__(self, t, s0, i0, r0, beta, gamma): # First call the gillespy2.Model initializer. gillespy2.Model.__init__(self, name='StochasticSIR') # Define parameters for the rates of creation and dissociation. k_i = gillespy2.Parameter(name='k_i', expression=beta / N) k_r = gillespy2.Parameter(name='k_r', expression=gamma) self.add_parameter([k_i, k_r]) # Define variables for the molecular species representing M and D. s = gillespy2.Species(name='S', initial_value=s0) i = gillespy2.Species(name='I', initial_value=i0) r = gillespy2.Species(name='R', initial_value=r0) self.add_species([s, i, r]) # The list of reactants and products for a Reaction object are each a # Python dictionary in which the dictionary keys are Species objects # and the values are stoichiometries of the species in the reaction. r_i = gillespy2.Reaction(name="infection", rate=k_i, reactants={ s: 1, i: 1 }, products={i: 2}) r_r = gillespy2.Reaction(name="recovery", rate=k_r, reactants={i: 1}, products={r: 1}) self.add_reaction([r_i, r_r]) # Set the timespan for the simulation. self.timespan(t)
def __init__(self, parameter_values=None, init_v=1): #initialize Model gillespy2.Model.__init__(self, name="Simple_Hybrid_Model") #Species A = gillespy2.Species(name='A', initial_value=init_v) V = gillespy2.Species(name='V', initial_value=init_v) self.add_species([A, V]) #parameters rate1 = gillespy2.Parameter(name='rate1', expression=20.0) rate2 = gillespy2.Parameter(name='rate2', expression=10.0) # rate_rule1 = gillespy2.RateRule(V, "cos(t)") self.add_parameter([rate1, rate2]) # self.add_rate_rule(rate_rule1) #reactions r1 = gillespy2.Reaction(name="r1", reactants={}, products={A: 1}, propensity_function="rate1 * V") r2 = gillespy2.Reaction(name="r2", reactants={A: 1}, products={}, rate=rate2) self.add_reaction([r1, r2]) self.timespan(numpy.linspace(0, 100, 101))
def __init__(self, parameter_values=None): # Initialize the model. gillespy2.Model.__init__(self, name="simple1") # Parameters k1 = gillespy2.Parameter(name='k1', expression=parameter_values[0]) k2 = gillespy2.Parameter(name='k2', expression=parameter_values[1]) k3 = gillespy2.Parameter(name='k3', expression=parameter_values[2]) self.add_parameter([k1, k2, k3]) # Species S1 = gillespy2.Species(name='S1', initial_value=100) S2 = gillespy2.Species(name='S2', initial_value=0) self.add_species([S1, S2]) # Reactions rxn1 = gillespy2.Reaction(name='S1 production', reactants={}, products={S1: 1}, rate=k1) rxn2 = gillespy2.Reaction(name='dimer formation', reactants={S1: 2}, products={S2: 1}, rate=k2) rxn3 = gillespy2.Reaction(name='dimer degradation', reactants={S2: 1}, products={}, rate=k3) self.add_reaction([rxn1, rxn2, rxn3]) self.timespan(np.linspace(0, 100, 101))
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 __init__(self, parameter_values=None, volume=1.0): # Initialize the model. gillespy2.Model.__init__(self, name="simple1", volume=volume) # Parameters k1 = gillespy2.Parameter(name='k1', expression=0.03) self.add_parameter(k1) # Species r1 = gillespy2.Species(name='r1', initial_value=100) self.add_species(r1) r2 = gillespy2.Species(name='r2', initial_value=100) self.add_species(r2) # Reactions rxn1 = gillespy2.Reaction(name='r1d', reactants={r1: 2}, products={}, rate=k1) self.add_reaction(rxn1) rxn2 = gillespy2.Reaction(name='r2d', reactants={r2: 2}, products={}, propensity_function='k1/2 * r2*(r2-1)/vol') self.add_reaction(rxn2)
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 __init__(self, parameter_values=None): # First call the gillespy2.Model initializer. super().__init__(self) # Define a parameter that represents the rate of decay. decayrate = gillespy2.Parameter(name='decayrate', expression=0.05) self.add_parameter([decayrate]) # Define a molecular species representing the protein; "initial_value" # sets the number of molecules initial present of simulation. protein = gillespy2.Species(name='protein', initial_value=50) self.add_species([protein]) # Define the reaction representing the decay process. In GillesPy2, # the list of reactants and products for a Reaction object are each a # Python dictionary in which the dictionary keys are Species objects # and the values are stoichiometries of the species in the reaction. # (In this example, we have only one reactant, and no products.) The # "rate" for the Reaction object is a Parameter representing the # propensity of this reaction firing.) reaction = gillespy2.Reaction(name="decay", rate=decayrate, reactants={protein: 1}, products={}) self.add_reaction([reaction]) # Set the timespan for the simulation. self.timespan(numpy.linspace(0, 100, 101))
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 test_math_name_overlap(self): gamma = gillespy2.Species('gamma',initial_value=2, mode='continuous') self.model.add_species([gamma]) k2 = gillespy2.Parameter(name='k2', expression=1) self.model.add_parameter([k2]) gamma_react = gillespy2.Reaction(name='gamma_react', reactants={'gamma':1}, products={}, rate=k2) self.model.add_reaction([gamma_react]) self.model.run(solver=BasicTauHybridSolver)
def __init__(self, endtime, timestep): """ Initialize the model. Parameters ---------- endtime : endtime of simulations timestep : time-step of simulations """ super().__init__( endtime=endtime, timestep=timestep, model_name="SIR", ) beta = gillespy.Parameter(name='beta', expression=self.params['beta']) gamma = gillespy.Parameter(name='gamma', expression=self.params['gamma']) self.add_parameter([beta, gamma]) # Species S = gillespy.Species(name='S', initial_value=100) I = gillespy.Species(name='I', initial_value=100) R = gillespy.Species(name='R', initial_value=100) self.add_species([S, I, R]) # Reactions infection = gillespy.Reaction( name='infection', reactants={ S: 1, I: 1 }, products={I: 2}, propensity_function='beta*S*I/(S+I+R)', ) recover = gillespy.Reaction( name='recover', reactants={I: 1}, products={R: 1}, rate=gamma, ) self.add_reaction([infection, recover]) nb_of_steps = int(math.ceil((endtime / timestep))) + 1 self.timespan(np.linspace(0, endtime, nb_of_steps))
def __init__(self): gillespy2.Model.__init__(self, name='Event Test Model') self.add_species([gillespy2.Species(name='S', initial_value=0)]) self.add_parameter(gillespy2.Parameter(name='event_tracker', expression=99)) self.add_parameter(gillespy2.Parameter(name='event_tracker2', expression=0)) self.add_reaction(gillespy2.Reaction(name='r1', products={'S':1}, rate=self.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')) self.add_event([event1, event2])
def __init__(self, parameter_values=None): gillespy2.Model.__init__(self, name='StochTest1') A = gillespy2.Species(name='A', initial_value=10) B = gillespy2.Species(name='B', initial_value=0) self.add_species([A, B]) k = gillespy2.Parameter(name='k', expression=10) self.add_parameter([k]) r = gillespy2.Reaction(name='r', reactants={A: 2}, products={B:1}, rate=k) self.add_reaction([r]) self.timespan(np.linspace(0, 100, 101))
def __get_compartments(sbml_model, gillespy_model): for i in range(sbml_model.getNumCompartments()): compartment = sbml_model.getCompartment(i) name = compartment.getId() value = compartment.getSize() gillespy_parameter = gillespy2.Parameter(name=name, expression=value) init_state[name] = value gillespy_model.add_parameter([gillespy_parameter]) '''
def __get_kinetic_law(sbml_model, gillespy_model, reaction): kinetic_law = reaction.getKineticLaw() tree = kinetic_law.getMath() params = kinetic_law.getListOfParameters() local_params = kinetic_law.getListOfLocalParameters() for i in range(kinetic_law.getNumLocalParameters()): lp = local_params.get(i) old_id = lp.getId() new_id = ('{}_{}'.format(reaction.getId(), lp.getId())) traverse_math(tree, old_id, new_id) lp.setId(new_id) gillespy_parameter = gillespy2.Parameter(name=new_id, expression=lp.getValue()) gillespy_model.add_parameter([gillespy_parameter]) for i in range(kinetic_law.getNumParameters()): p = params.get(i) if not p.getId() in gillespy_model.listOfParameters: gillespy_parameter = gillespy2.Parameter(name=p.getId(), expression=p.getValue()) gillespy_model.add_parameter([gillespy_parameter]) return tree
def __init__(self, parameter_values=None): # First call the gillespy2.Model initializer. gillespy2.Model.__init__(self, name='Repressilator') # Define parameters for the rates of creation and dissociation. alpha=gillespy2.Parameter(name="alpha", expression=216) alpha_0=gillespy2.Parameter(name="alpha_0",expression=0.216) beta=gillespy2.Parameter(name="beta",expression=0.8) self.add_parameter([alpha, alpha_0, beta]) # Define variables for the molecular species representing M and D. m_lacI= gillespy2.Species(name='m_lacI', initial_value=30) p_lacI= gillespy2.Species(name='p_lacI', initial_value=0) m_tetR= gillespy2.Species(name='m_tetR', initial_value=0) p_tetR= gillespy2.Species(name='p_tetR', initial_value=0) m_cI= gillespy2.Species(name='m_cI', initial_value=0) p_cI= gillespy2.Species(name='p_cI', initial_value=0) self.add_species([m_lacI, p_lacI, p_tetR, m_tetR, m_cI, p_cI]) # The list of reactants and products for a Reaction object are each a # Python dictionary in which the dictionary keys are Species objects # and the values are stoichiometries of the species in the reaction. m_1 = gillespy2.Reaction(name="m_1", rate=alpha/(1 + p_cI), reactants={m_lacI:1}, products={m_lacI:2+alpha_0}) m_2 = gillespy2.Reaction(name="m_2", rate=1, reactants={m_lacI:1}, products={m_lacI:0}) p_1 = gillespy2.Reaction(name="p_1", rate=beta, reactants={p_lacI:1}, products={p_lacI:2+m_lacI}) p_2 = gillespy2.Reaction(name="p_2", rate=beta, reactants={p_lacI:1}, products={p_lacI:0}) m_3 = gillespy2.Reaction(name="m_3", rate=alpha/(1+p_lacI), reactants={m_tetR:1}, products={m_tetR:2+alpha_0}) m_4 = gillespy2.Reaction(name="m_4", rate=1, reactants={m_tetR:1}, products={m_tetR:0}) p_3 = gillespy2.Reaction(name="p_3", rate=beta, reactants={p_tetR:1}, products={p_tetR:2+m_tetR}) p_4 = gillespy2.Reaction(name="p_4", rate=beta, reactants={p_tetR:1}, products={p_tetR:0}) m_5 = gillespy2.Reaction(name="m_5", rate=alpha/(1+p_tetR), reactants={m_cI:1}, products={m_cI:2+alpha_0}) m_6 = gillespy2.Reaction(name="m_6", rate=1, reactants={m_cI:1}, products={m_cI:0}) p_5 = gillespy2.Reaction(name="p_5", rate=beta, reactants={p_cI:1}, products={p_cI:2+m_cI}) p_6 = gillespy2.Reaction(name="p_6", rate=beta, reactants={p_cI:1}, products={p_cI:0}) self.add_reaction([m_1,m_2,m_3,m_4,m_5,m_6,p_1,p_2,p_3,p_4,p_5,p_6]) # Set the timespan for the simulation. self.timespan(numpy.linspace(0, 100, 101))
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_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_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 __get_parameters(sbml_model, gillespy_model): for i in range(sbml_model.getNumParameters()): parameter = sbml_model.getParameter(i) name = parameter.getId() value = parameter.getValue() init_state[name] = value # GillesPy2 represents non-constant parameters as species if parameter.isSetConstant(): gillespy_parameter = gillespy2.Parameter(name=name, expression=value) gillespy_model.add_parameter([gillespy_parameter]) else: gillespy_species = gillespy2.Species(name=name,initial_value=value) gillespy_model.add_species([gillespy_species])
def convert_rates(self): ''' Method to convert rate constants from non-gillespy2 Random DNA Chemistry to the gillespy2 Random DNA Chemistry ''' gillespy2_rates = [] for index_bind, (r_bind, rate_bind) in enumerate( self.randomDNAChem.rateConst_lookup['rate_BIND'].items()): name_bind = 'bind{}'.format(index_bind) gillespy2_kbind = gillespy2.Parameter(name=name_bind, expression=rate_bind[0]) gillespy2_rates.append(gillespy2_kbind) for index_displace, (r_displace, rate_displace) in enumerate( self.randomDNAChem.rateConst_lookup['rate_DISPLACE'].items()): name_displace = 'displace{}'.format(index_displace) gillespy2_kdisplace = gillespy2.Parameter( name=name_displace, expression=rate_displace[0]) gillespy2_rates.append(gillespy2_kdisplace) for index_in, (r_in, rate_in) in enumerate( self.randomDNAChem.rateConst_lookup['rate_IN'].items()): name_in = 'influx{}'.format(index_in) gillespy2_kin = gillespy2.Parameter( name=name_in, expression=rate_in[self.rate_in_timeIndex]) gillespy2_rates.append(gillespy2_kin) for index_out, (r_out, rate_out) in enumerate( self.randomDNAChem.rateConst_lookup['rate_OUT'].items()): name_out = 'efflux{}'.format(index_out) gillespy2_kout = gillespy2.Parameter(name=name_out, expression=rate_out[0]) gillespy2_rates.append(gillespy2_kout) self.add_parameter(gillespy2_rates)
def __get_compartments(sbml_model, gillespy_model): for i in range(sbml_model.getNumCompartments()): compartment = sbml_model.getCompartment(i) name = compartment.getId() if compartment.isSetSize(): value = compartment.getSize() else: value = 1 if name == "vol": gillespy_model.volume = value else: gillespy_parameter = gillespy2.Parameter(name=name, expression=value) init_state[name] = value gillespy_model.add_parameter([gillespy_parameter]) '''
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 test_random_seed_unnamed_reactions(self): model = self.model k2 = gillespy2.Parameter(name='k2', expression=1.0) model.add_parameter([k2]) unnamed_rxn = gillespy2.Reaction(reactants={}, products={'Sp':1}, rate=k2) model.add_reaction(unnamed_rxn) for solver in self.solvers: with self.subTest(solver=solver.name): solver = solver(model=self.model) if "ODE" in solver.name: same_results = self.model.run(solver=solver) compare_results = self.model.run(solver=solver) else: same_results = self.model.run(solver=solver, seed=1) compare_results = self.model.run(solver=solver,seed=1) self.assertTrue(np.array_equal(same_results.to_array(), compare_results.to_array())) if solver.name in ["ODESolver", "ODECSolver"]: continue diff_results = self.model.run(solver=solver, seed=2) self.assertFalse(np.array_equal(diff_results.to_array(), same_results.to_array()))