def test_masteq(): mdl = smod.Model() A = smod.Spec('A', mdl) volsys = smod.Volsys('vsys', mdl) # Production R1 = smod.Reac('R1', volsys, lhs=[], rhs=[A], kcst=KCST_f) R2 = smod.Reac('R2', volsys, lhs=[A], rhs=[], kcst=KCST_b) geom = sgeom.Geom() comp1 = sgeom.Comp('comp1', geom, VOL) comp1.addVolsys('vsys') rng = srng.create('mt19937', 1000) rng.initialize(int(time.time() % 4294967295)) sim = ssolv.Wmdirect(mdl, geom, rng) sim.reset() tpnts = numpy.arange(0.0, INT, DT) ntpnts = tpnts.shape[0] res = numpy.zeros([ntpnts]) sim.restore('./validation_cp/cp/masteq') for t in range(0, ntpnts): sim.run(tpnts[t]) res[t] = sim.getCompCount('comp1', 'A') def fact(x): return (1 if x == 0 else x * fact(x - 1)) # Do cumulative count, but not comparing them all. # Don't get over 50 (I hope) steps_n_res = numpy.zeros(50) for r in res: steps_n_res[int(r)] += 1 for s in range(50): steps_n_res[s] = steps_n_res[s] / ntpnts passed = True max_err = 0.0 k1 = KCST_b k2 = KCST_f * (6.022e23 * 1.0e-15) # Compare 5 to 15 for m in range(5, 16): analy = (1.0 / fact(m)) * math.pow((k2 / k1), m) * math.exp(-(k2 / k1)) assert (tol_funcs.tolerable(steps_n_res[m], analy, tolerance))
def test_forev(): mdl = smod.Model() A = smod.Spec('A', mdl) B = smod.Spec('B', mdl) volsys = smod.Volsys('vsys', mdl) R1 = smod.Reac('R1', volsys, lhs=[A], rhs=[B], kcst=KCST_f) R2 = smod.Reac('R2', volsys, lhs=[B], rhs=[A], kcst=KCST_b) geom = sgeom.Geom() comp1 = sgeom.Comp('comp1', geom, VOL) comp1.addVolsys('vsys') rng = srng.create('mt19937', 512) rng.initialize(int(time.time() % 4294967295)) sim = ssolv.Wmdirect(mdl, geom, rng) sim.reset() tpnts = numpy.arange(0.0, INT, DT) ntpnts = tpnts.shape[0] res_m = numpy.zeros([NITER, ntpnts, 2]) for i in range(0, NITER): sim.restore('./validation_cp/cp/first_order_rev') for t in range(0, ntpnts): sim.run(tpnts[t]) res_m[i, t, 0] = sim.getCompConc('comp1', 'A') * 1e6 res_m[i, t, 1] = sim.getCompConc('comp1', 'B') * 1e6 mean_res = numpy.mean(res_m, 0) Aeq = COUNT * (KCST_b / KCST_f) / (1 + (KCST_b / KCST_f)) / (VOL * 6.0221415e26) * 1e6 Beq = (COUNT / (VOL * 6.0221415e26)) * 1e6 - Aeq max_err = 0.0 passed = True for i in range(ntpnts): if i < 7: continue assert (tol_funcs.tolerable(mean_res[i, 0], Aeq, tolerance)) assert (tol_funcs.tolerable(mean_res[i, 1], Beq, tolerance))
def cbsa2steps(cbsa_model): import steps.geom as swm import steps.model as smodel import steps.rng as srng import steps.solver as ssolver mdl = smodel.Model() vsys = smodel.Volsys('vsys', mdl) mols = [smodel.Spec('M'+str(i), mdl) for i in range(1,cbsa_model.exp_n_molecules)] 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 reactants_objs = [[mols[reactants[j]-1] for k in range(reactants_sto[j])] for j in range(len(reactants))] reactants_objs = [item for sublist in reactants_objs for item in sublist] products_objs = [[mols[products[j]-1] for k in range(products_sto[j])] for j in range(len(products))] products_objs = [item for sublist in products_objs for item in sublist] reactions.append(smodel.Reac("R"+str(i), vsys, lhs=reactants_objs, rhs=products_objs, kcst=cbsa_model.exp_k[i])) wmgeom = swm.Geom() comp = swm.Comp('comp', wmgeom) comp.addVolsys('vsys') comp.setVol(1.6667e-21) r = srng.create('mt19937', 256) r.initialize(int(timer())) sim = ssolver.Wmdirect(mdl, wmgeom, r) sim.reset() for i in range(1,cbsa_model.exp_n_molecules): sim.setCompConc('comp', 'M'+str(i), cbsa_model.exp_x0[i]*1e-6) return sim
def get_solver(solver_type, mdl, geom): r = srng.create('r123', 1000) if solver_type == "Wmrk4": solver = ssolv.Wmrk4(mdl, geom) solver.setDT(1e-5) return solver elif solver_type == "Wmdirect": solver = ssolv.Wmdirect(mdl, geom, r) return solver if solver_type == "Wmrssa": solver = ssolv.Wmrssa(mdl, geom, r) return solver elif solver_type == "Tetexact": solver = ssolv.Tetexact(mdl, geom, r) return solver else: assert (False)
def test_foirev(): mdl = smod.Model() A = smod.Spec('A', mdl) volsys = smod.Volsys('vsys', mdl) R1 = smod.Reac('R1', volsys, lhs=[A], rhs=[], kcst=KCST) geom = sgeom.Geom() comp1 = sgeom.Comp('comp1', geom, VOL) comp1.addVolsys('vsys') rng = srng.create('mt19937', 1000) rng.initialize(int(time.time() % 4294967295)) sim = ssolv.Wmdirect(mdl, geom, rng) sim.reset() tpnts = np.arange(0.0, INT, DT) ntpnts = tpnts.shape[0] res_m = np.zeros([NITER, ntpnts, 1]) res_std1 = np.zeros([ntpnts, 1]) res_std2 = np.zeros([ntpnts, 1]) for i in range(0, NITER): sim.restore('./validation_cp/cp/first_order_irev') for t in range(0, ntpnts): sim.run(tpnts[t]) res_m[i, t, 0] = sim.getCompCount('comp1', 'A') mean_res = np.mean(res_m, 0) std_res = np.std(res_m, 0) m_tol = 0 s_tol = 0 passed = True for i in range(ntpnts): if i == 0: continue analy = N * np.exp(-KCST * tpnts[i]) std = np.power((N * (np.exp(-KCST * tpnts[i])) * (1 - (np.exp(-KCST * tpnts[i])))), 0.5) if not tol_funcs.tolerable(analy, mean_res[i], tolerance): passed = False assert (tol_funcs.tolerable(std, std_res[i], tolerance))
def run_sim(): # Set up and run the simulations once, before the tests # analyze the results. ##################### First order irreversible ######################### global KCST_foi, N_foi, tolerance_foi KCST_foi = 5 # The reaction constant N_foi = 50 # Can set count or conc NITER_foi = 100000 # The number of iterations # Tolerance for the comparison: # In test runs, with good code, < 1% will fail with a 1.5% tolerance tolerance_foi = 2.0 / 100 ####################### First order reversible ######################### global KCST_f_for, KCST_b_for, COUNT_for, tolerance_for KCST_f_for = 10.0 # The reaction constant KCST_b_for = 2.0 COUNT_for = 100000 # Can set count or conc NITER_for = 10 # The number of iterations # In test runs, with good code, <0.1% will fail with a tolerance of 1% tolerance_for = 1.0 / 100 ####################### Second order irreversible A2 ################### global KCST_soA2, CONCA_soA2, tolerance_soA2 KCST_soA2 = 10.0e6 # The reaction constant CONCA_soA2 = 10.0e-6 NITER_soA2 = 1000 # The number of iterations # In test runs, with good code, <0.1% will fail with a tolerance of 2% tolerance_soA2 = 1.0 / 100 ####################### Second order irreversible AA ################### global KCST_soAA, CONCA_soAA, CONCB_soAA, tolerance_soAA KCST_soAA = 50.0e6 # The reaction constant CONCA_soAA = 20.0e-6 CONCB_soAA = CONCA_soAA NITER_soAA = 1000 # The number of iterations # In test runs, with good code, <0.1% will fail with a tolerance of 1% tolerance_soAA = 1.0 / 100 ####################### Second order irreversible AB ################### global KCST_soAB, CONCA_soAB, CONCB_soAB, tolerance_soAB KCST_soAB = 5.0e6 # The reaction constant CONCA_soAB = 1.0e-6 n_soAB = 2 CONCB_soAB = CONCA_soAB / n_soAB NITER_soAB = 1000 # The number of iterations # In test runs, with good code, <0.1% will fail with a tolerance of 1% tolerance_soAB = 1.0 / 100 ####################### Third order irreversible A3 ################### global KCST_toA3, CONCA_toA3, tolerance_toA3 KCST_toA3 = 1.0e12 # The reaction constant CONCA_toA3 = 100.0e-6 NITER_toA3 = 1000 # The number of iterations # In test runs, with good code, <0.1% will fail with a tolerance of 1% tolerance_toA3 = 1.0 / 100 ####################### Third order irreversible A2B ################### global KCST_toA2B, CONCA_toA2B, CONCB_toA2B, tolerance_toA2B KCST_toA2B = 0.1e12 # The reaction constant CONCA_toA2B = 30.0e-6 CONCB_toA2B = 20.0e-6 NITER_toA2B = 1000 # The number of iterations # In test runs, with good code, <0.1% will fail with a tolerance of 1% tolerance_toA2B = 1.0 / 100 ####################### Second order irreversible 2D ################### global COUNTA_so2d, COUNTB_so2d, CCST_so2d, tolerance_so2d COUNTA_so2d = 100.0 n_so2d = 2.0 COUNTB_so2d = COUNTA_so2d / n_so2d KCST_so2d = 10.0e10 # The reaction constant AREA_so2d = 10.0e-12 CCST_so2d = KCST_so2d / (6.02214179e23 * AREA_so2d) NITER_so2d = 1000 # The number of iterations # In tests fewer than 0.1% fail with tolerance of 2% tolerance_so2d = 2.0 / 100 ############################ Common parameters ######################## global VOL DT = 0.1 # Sampling time-step INT = 1.1 # Sim endtime VOL = 9.0e-18 NITER_max = 100000 ######################################################################## mdl = smod.Model() volsys = smod.Volsys('vsys', mdl) surfsys = smod.Surfsys('ssys', mdl) # First order irreversible A_foi = smod.Spec('A_foi', mdl) R1_foi = smod.Reac('R1_foi', volsys, lhs=[A_foi], rhs=[], kcst=KCST_foi) # First order reversible A_for = smod.Spec('A_for', mdl) B_for = smod.Spec('B_for', mdl) R1_for = smod.Reac('R1_for', volsys, lhs=[A_for], rhs=[B_for], kcst=KCST_f_for) R2_for = smod.Reac('R2_for', volsys, lhs=[B_for], rhs=[A_for], kcst=KCST_b_for) # Second order irreversible A2 A_soA2 = smod.Spec('A_soA2', mdl) C_soA2 = smod.Spec('C_soA2', mdl) R1_soA2 = smod.Reac('R1_soA2', volsys, lhs=[A_soA2, A_soA2], rhs=[C_soA2], kcst=KCST_soA2) # Second order irreversible AA A_soAA = smod.Spec('A_soAA', mdl) B_soAA = smod.Spec('B_soAA', mdl) C_soAA = smod.Spec('C_soAA', mdl) R1_soAA = smod.Reac('R1_soAA', volsys, lhs=[A_soAA, B_soAA], rhs=[C_soAA], kcst=KCST_soAA) # Second order irreversible AB A_soAB = smod.Spec('A_soAB', mdl) B_soAB = smod.Spec('B_soAB', mdl) C_soAB = smod.Spec('C_soAB', mdl) R1_soAB = smod.Reac('R1_soAB', volsys, lhs=[A_soAB, B_soAB], rhs=[C_soAB], kcst=KCST_soAB) # Third order irreversible A3 A_toA3 = smod.Spec('A_toA3', mdl) C_toA3 = smod.Spec('C_toA3', mdl) R1_toA3 = smod.Reac('R1_toA3', volsys, lhs=[A_toA3, A_toA3, A_toA3], rhs=[C_toA3], kcst=KCST_toA3) # Third order irreversible A2B A_toA2B = smod.Spec('A_toA2B', mdl) B_toA2B = smod.Spec('B_toA2B', mdl) C_toA2B = smod.Spec('C_toA2B', mdl) R1_toA3 = smod.Reac('R1_toA2B', volsys, lhs=[A_toA2B, A_toA2B, B_toA2B], rhs=[C_toA2B], kcst=KCST_toA2B) # Second order irreversible 2D A_so2d = smod.Spec('A_so2d', mdl) B_so2d = smod.Spec('B_so2d', mdl) C_so2d = smod.Spec('C_so2d', mdl) SR1_so2d = smod.SReac('SR1_so2d', surfsys, slhs=[A_so2d, B_so2d], srhs=[C_so2d], kcst=KCST_so2d) geom = sgeom.Geom() comp1 = sgeom.Comp('comp1', geom, VOL) comp1.addVolsys('vsys') patch1 = sgeom.Patch('patch1', geom, comp1, area=AREA_so2d) patch1.addSurfsys('ssys') rng = srng.create('r123', 512) rng.initialize(1000) sim = ssolv.Wmdirect(mdl, geom, rng) sim.reset() global tpnts, ntpnts tpnts = numpy.arange(0.0, INT, DT) ntpnts = tpnts.shape[0] res_m_foi = numpy.zeros([NITER_foi, ntpnts, 1]) res_std1_foi = numpy.zeros([ntpnts, 1]) res_std2_foi = numpy.zeros([ntpnts, 1]) res_m_for = numpy.zeros([NITER_for, ntpnts, 2]) res_m_soA2 = numpy.zeros([NITER_soA2, ntpnts, 2]) res_m_soAA = numpy.zeros([NITER_soAA, ntpnts, 3]) res_m_soAB = numpy.zeros([NITER_soAB, ntpnts, 3]) res_m_toA3 = numpy.zeros([NITER_toA3, ntpnts, 2]) res_m_toA2B = numpy.zeros([NITER_toA2B, ntpnts, 3]) res_m_so2d = numpy.zeros([NITER_so2d, ntpnts, 3]) for i in range(0, NITER_max): sim.reset() if i < NITER_foi: sim.setCompCount('comp1', 'A_foi', N_foi) if i < NITER_for: sim.setCompCount('comp1', 'A_for', COUNT_for) sim.setCompCount('comp1', 'B_for', 0.0) if i < NITER_soA2: sim.setCompConc('comp1', 'A_soA2', CONCA_soA2) if i < NITER_soAA: sim.setCompConc('comp1', 'A_soAA', CONCA_soAA) sim.setCompConc('comp1', 'B_soAA', CONCB_soAA) if i < NITER_soAB: sim.setCompConc('comp1', 'A_soAB', CONCA_soAB) sim.setCompConc('comp1', 'B_soAB', CONCB_soAB) if i < NITER_toA3: sim.setCompConc('comp1', 'A_toA3', CONCA_toA3) if i < NITER_toA2B: sim.setCompConc('comp1', 'A_toA2B', CONCA_toA2B) sim.setCompConc('comp1', 'B_toA2B', CONCB_toA2B) if i < NITER_so2d: sim.setPatchCount('patch1', 'A_so2d', COUNTA_so2d) sim.setPatchCount('patch1', 'B_so2d', COUNTB_so2d) for t in range(0, ntpnts): sim.run(tpnts[t]) if i < NITER_foi: res_m_foi[i, t, 0] = sim.getCompCount('comp1', 'A_foi') if i < NITER_for: res_m_for[i, t, 0] = sim.getCompConc('comp1', 'A_for') * 1e6 res_m_for[i, t, 1] = sim.getCompConc('comp1', 'B_for') * 1e6 if i < NITER_soA2: res_m_soA2[i, t, 0] = sim.getCompConc('comp1', 'A_soA2') if i < NITER_soAA: res_m_soAA[i, t, 0] = sim.getCompConc('comp1', 'A_soAA') res_m_soAA[i, t, 1] = sim.getCompConc('comp1', 'B_soAA') if i < NITER_soAB: res_m_soAB[i, t, 0] = sim.getCompConc('comp1', 'A_soAB') res_m_soAB[i, t, 1] = sim.getCompConc('comp1', 'B_soAB') if i < NITER_toA3: res_m_toA3[i, t, 0] = sim.getCompConc('comp1', 'A_toA3') if i < NITER_toA2B: res_m_toA2B[i, t, 0] = sim.getCompConc('comp1', 'A_toA2B') res_m_toA2B[i, t, 1] = sim.getCompConc('comp1', 'B_toA2B') res_m_toA2B[i, t, 2] = sim.getCompConc('comp1', 'C_toA2B') if i < NITER_so2d: res_m_so2d[i, t, 0] = sim.getPatchCount('patch1', 'A_so2d') res_m_so2d[i, t, 1] = sim.getPatchCount('patch1', 'B_so2d') global mean_res_foi, std_res_foi mean_res_foi = numpy.mean(res_m_foi, 0) std_res_foi = numpy.std(res_m_foi, 0) global mean_res_for mean_res_for = numpy.mean(res_m_for, 0) global mean_res_soA2 mean_res_soA2 = numpy.mean(res_m_soA2, 0) global mean_res_soAA mean_res_soAA = numpy.mean(res_m_soAA, 0) global mean_res_soAB mean_res_soAB = numpy.mean(res_m_soAB, 0) global mean_res_toA3 mean_res_toA3 = numpy.mean(res_m_toA3, 0) global mean_res_toA2B mean_res_toA2B = numpy.mean(res_m_toA2B, 0) global mean_res_so2d mean_res_so2d = numpy.mean(res_m_so2d, 0) global ran_sim ran_sim = True
def testSetCompVolWmdirect(self): self.sim = ssolver.Wmdirect(self.mdl, self.geom, self.rng) self.sim.reset() self._testSetCompVol()
def test_masteq(): "Reaction - Production and degradation (Wmdirect)" ######################################################################## KCST_f = 100 / (6.022e23 * 1.0e-15) # The reaction constant, production KCST_b = 10 # The reaction constant, degradation VOL = 1.0e-18 DT = 0.1 # Sampling time-step INT = 200000.1 # Sim endtime # Tolerance for the comparison: # In tests with good code <1% fail with tolerance of 1.5% tolerance = 1.5 / 100 ######################################################################## mdl = smod.Model() A = smod.Spec('A', mdl) volsys = smod.Volsys('vsys', mdl) # Production R1 = smod.Reac('R1', volsys, lhs=[], rhs=[A], kcst=KCST_f) R2 = smod.Reac('R2', volsys, lhs=[A], rhs=[], kcst=KCST_b) geom = sgeom.Geom() comp1 = sgeom.Comp('comp1', geom, VOL) comp1.addVolsys('vsys') rng = srng.create('r123', 1000) rng.initialize(1000) sim = ssolv.Wmdirect(mdl, geom, rng) sim.reset() tpnts = numpy.arange(0.0, INT, DT) ntpnts = tpnts.shape[0] res = numpy.zeros([ntpnts]) sim.reset() sim.setCompCount('comp1', 'A', 0) for t in range(0, ntpnts): sim.run(tpnts[t]) res[t] = sim.getCompCount('comp1', 'A') def fact(x): return (1 if x == 0 else x * fact(x - 1)) # Do cumulative count, but not comparing them all. # Don't get over 50 (I hope) steps_n_res = numpy.zeros(50) for r in res: steps_n_res[int(r)] += 1 for s in range(50): steps_n_res[s] = steps_n_res[s] / ntpnts passed = True max_err = 0.0 k1 = KCST_b k2 = KCST_f * (6.022e23 * 1.0e-15) # Compare 5 to 15 for m in range(5, 16): analy = (1.0 / fact(m)) * math.pow((k2 / k1), m) * math.exp(-(k2 / k1)) assert tol_funcs.tolerable(steps_n_res[m], analy, tolerance)
tolerance = 2.0 / 100 ######################################################################## mdl = smod.Model() A = smod.Spec('A', mdl) volsys = smod.Volsys('vsys', mdl) R1 = smod.Reac('R1', volsys, lhs=[A], rhs=[], kcst=KCST) geom = sgeom.Geom() comp1 = sgeom.Comp('comp1', geom, VOL) comp1.addVolsys('vsys') rng = srng.create('mt19937', 1000) rng.initialize(int(time.time() % 4294967295)) sim = ssolv.Wmdirect(mdl, geom, rng) sim.reset() tpnts = numpy.arange(0.0, INT, DT) ntpnts = tpnts.shape[0] res_m = numpy.zeros([NITER, ntpnts, 1]) res_std1 = numpy.zeros([ntpnts, 1]) res_std2 = numpy.zeros([ntpnts, 1]) sim.reset() sim.setCompCount('comp1', 'A', N) sim.checkpoint('./validation_cp/cp/first_order_irev')
import steps.rng as srng #import package with alias srng. r = srng.create('mt19937', 256) #we actually generate a random number generator we want. #using the function steps.rng.create() #STEPS currently only implements one pseudo RNG algorithm, 'mt19937' r.initialize(23412) #initialize the random number generator with a seed value import steps.solver as ssolver #to create the actual solver object, first of all we import the #package in which all solvers have been implemented sim = ssolver.Wmdirect(mdl, wmgeom, r) sim.reset() #reset the function on the solver project #we can start manipulating the "state" of simulation sim.setCompConc('comp', 'molX1bar', 100) sim.setCompConc('comp', 'molY1', 20) #this means we're setting the concentration of molX1bar to 31.4 #micro m and molY1 to 22.3 micro m in our compartment comp. #we are setting these concentration value at simulation time t=0. import numpy #we use Numpy to generate some auxilialy numerical arrays that will #be used during simulation
def runSBMLmod(sbmlFile, time_end, time_dt, iter_n=1, solver='Wmdirect', specs_plot={}, vol_units=1.0e-3, vol_def=False): iSbml = ssbml.Interface(sbmlFile, volunits_def=vol_units, volume_def=vol_def) mdl = iSbml.getModel() mesh = iSbml.getGeom() comp_specs = {} if not specs_plot: got_sp = False else: got_sp = True for comp in mesh.getAllComps(): comp_specs[comp.getID()] = [] volsys_strings = comp.getVolsys() for vsys_str in volsys_strings: vsys = mdl.getVolsys(vsys_str) specs = vsys.getAllSpecs() for spec in specs: comp_specs[comp.getID()].append(spec.getID()) if (got_sp == False): specs_plot.update({spec.getID(): ''}) comp_specs_n = 0 for comp in comp_specs: comp_specs[comp].sort() comp_specs_n += len(comp_specs[comp]) time_pnts = numpy.arange(0.0, time_end, time_dt) points_n = int(round(time_end / time_dt)) if (len(time_pnts) == (points_n + 1)): time_pnts = numpy.delete(time_pnts, len(time_pnts) - 1) res = numpy.zeros([iter_n, points_n, comp_specs_n]) r = srng.create('mt19937', 256) r.initialize(7233) if (solver == 'Wmdirect'): sim = ssolver.Wmdirect(mdl, mesh, r) elif (solver == 'Wmrk4'): sim = ssolver.Wmrk4(mdl, mesh, r) sim.setDT(0.0001) else: raise NameError( "Unsupported solver. SBML importer accepts well-mixed solvers 'Wmrk4' and 'Wmdirect'" ) for it in range(0, iter_n): sim.reset() iSbml.reset() iSbml.setupSim(sim) for tp in range(0, points_n): sim.run(time_pnts[tp]) i = 0 for comp in comp_specs: for spec in comp_specs[comp]: res[it, tp, i] = sim.getCompConc(comp, spec) i += 1 iSbml.updateSim(sim, time_dt) mean_res = numpy.mean(res, 0) i = 0 for comp in comp_specs: for spec in comp_specs[comp]: if (spec in specs_plot): if (specs_plot[spec]): plot(time_pnts, mean_res[:, i], label=spec + ", " + comp, color=specs_plot[spec]) else: plot(time_pnts, mean_res[:, i], label=spec + ", " + comp) i += 1 legend(loc='best', numpoints=1) xlabel('Time (s)') ylabel('Conc (M)') show()
def testWmdirect(self): solver = solv.Wmdirect(self.model, self.geom, self.rng) self._runTest(solver)
def run(model_string, initial_condition_string, stop_time, event_string='', seed=23412, solver='wmdirect', dt=1, rk4dt=1e-5, realisations=1, file=False): """ Run a Matlab Simbiology model in STEPS using the Wmdriect or Wmrk4 solver. This is the entry point called by Matlab via the main code. Input parameters: - STEPS model as a string, - initial condition part of the STEPS model as a string, - stop time - pseudo random number generator seed, - solver: wmdirect or wmrk4, - dt: time increment betwen sampling points - realisations: number of times the simulation is to be run - file: flag to indicate if the generated model should be written to file. The file name carries a timestamp. """ if (not solver.upper() == 'WMDIRECT' and not solver.upper() == 'WMRK4'): logger.error('run unknown solver string: ' + solver) raise Exception('run unknown solver string: ' + solver) if (file): if (not os.path.exists(steps_path + '/.logs')): os.makedirs(steps_path + '/.logs') outfile = open( steps_path + '/.logs/matlab_steps_model_' + str(datetime.datetime.now()), 'w') outfile.write(model_string) outfile.write(initial_condition_string) outfile.close() exec(model_string.encode('ascii').decode('unicode-escape'), globals()) # setup the solver, only two solvers are supported, # so a simple if construct is sufficient. global sim if (solver.upper() == 'WMDIRECT'): r = srng.create('mt19937', 256) r.initialize(seed) sim = ssolver.Wmdirect(model, geometry, r) elif (solver.upper() == 'WMRK4'): sim = ssolver.Wmrk4(model, geometry) sim.setRk4DT(rk4dt) else: logger.error('run unknown solver string: ' + solver) raise Exception('run unknown solver string: ' + solver) # steup the return data structures nSpecies = len(model.getAllSpecs()) list_of_species = model.getAllSpecs() specie_names = [] for s in list_of_species: specie_names.append(s.getID()) tvector = numpy.arange(0, stop_time, dt) # get a list of the compartment names compartment_names = [] compartments = geometry.getAllComps() for comp in compartments: compartment_names.append(str(comp.getID())) res = numpy.zeros( [realisations, len(compartments), len(tvector), nSpecies]) # parse the events and # store them in a dictionary event_string = json.loads(event_string.replace('][', ', ')) logger.debug('run got events: ' + str(event_string)) # iterate the names of the reaction rates rate_names = event_string[1] # iterate the events event_string = event_string[0] # number of events, each event is a dict with trigger and event entry nevents = len(event_string) event_dict = {} # iterate all the dictionaries for i in range(nevents): # extract the trigger and event event_dict.update(event_string[i]) event_times = {} nevents = len(event_dict) if (nevents % 2 != 0): logger.error( 'run internal error, number of triggers and events do not match: ' + str(event_dict)) raise RuntimeError( 'run internal error, number of triggers and events do not match: ' + str(event_dict)) for i in range(nevents // 2): trigger = event_dict['trigger_' + str(i)] if (trigger.find('>=') >= 0): tmp = trigger.split('>=') elif (trigger.find('>') >= 0): tmp = trigger.split('>') else: logger.error('run invalid event trigger: ' + e) raise RuntimeError('run invalid event trigger: ' + e) #if(event_times.has_key(float(tmp[1]))): if (float(tmp[1]) in event_times): event_times[float(tmp[1])].append(event_dict['event_' + str(i)]) else: event_times[float(tmp[1])] = [event_dict['event_' + str(i)]] # build the event queue - sort the events event_queue = sorted(event_times.keys()) if (not event_queue): # run without event queue for i in range(realisations): # this is an index sim.reset() exec( initial_condition_string.encode('ascii').decode( 'unicode-escape'), globals()) for t in range(len(tvector)): # this is an index for c in range(len(compartment_names)): # this is an index for s in range(len(specie_names)): res[i, c, t, s] = sim.getCompCount(compartment_names[c], specie_names[s]) sim.run(tvector[t]) else: # run with event queue logger.debug('run event times: ' + str(event_times)) logger.debug('run event queue ' + str(event_queue)) logger.debug('run event dict: ' + str(event_dict)) for i in range(realisations): # copy the event queue for this realisation # FIXME: replace copying the queue with a counter eq = list(event_queue) t_event = float(eq.pop(0)) # initial conditions sim.reset() exec( initial_condition_string.encode('ascii').decode( 'unicode-escape'), globals()) for t in range(len(tvector)): if tvector[t] >= float(t_event): logger.debug('run time of next event: ' + str((float(t_event)))) sim.run(float(t_event)) # handle all events event queued for this t_event for e in event_times[t_event]: tmp = handleEvent(e, sim, model, spec_names, comp_names, rate_names, reac_to_comp, sreac_to_patch, kcst_si_factor) exec(tmp) # get next event if eq: t_event = eq.pop(0) else: t_event = float('inf') # end if sim.run(tvector[t]) # get molecule counts for c in range(len(compartment_names)): # this is an index #sim.run(tvector[t]) for s in range(len(specie_names)): res[i, c, t, s] = sim.getCompCount(compartment_names[c], specie_names[s]) # return the data json encoded data = { 'species': specie_names, 'compartments': compartment_names, 'data': res.tolist() } sys.stdout.write(json.dumps(data)) sys.stdout.flush() sys.exit(0)
print 'Inner compartment to memb is', memb.getIComp().getID() print 'Outer compartment to memb is', memb.getOComp().getID() #RNG setup import steps.rng as srng import pylab import numpy r = srng.create('mt19937', 1000) r.initialize(7233) #solver setup import steps.solver as ssolover if deterministic: sim = ssolover.Wmrk4(mdl, wmgeom, r) else: sim = ssolover.Wmdirect(mdl, wmgeom, r) tpnt = numpy.arange(0.0, 20.01, 0.01) res = numpy.zeros([NITER, 2001, 4]) res_std = numpy.zeros([2001, 4]) res_std1 = numpy.zeros([2001, 4]) res_std2 = numpy.zeros([2001, 4]) prob = [] ca = 0.1e-6 ip = 2e-6 for i in range(0, NITER): sim.reset() if deterministic: sim.setRk4DT(0.000001)
def test_soirevAA(): KCST = 50.0e6 # The reaction constant CONCA = 20.0e-6 CONCB = CONCA VOL = 9.0e-18 NITER = 1000 # The number of iterations DT = 0.1 # Sampling time-step INT = 1.1 # Sim endtime # In test runs, with good code, <0.1% will fail with a tolerance of 1% tolerance = 1.0 / 100 ######################################################################## mdl = smod.Model() A = smod.Spec('A', mdl) B = smod.Spec('B', mdl) C = smod.Spec('C', mdl) volsys = smod.Volsys('vsys', mdl) R1 = smod.Reac('R1', volsys, lhs=[A, B], rhs=[C], kcst=KCST) geom = sgeom.Geom() comp1 = sgeom.Comp('comp1', geom, VOL) comp1.addVolsys('vsys') rng = srng.create('mt19937', 512) rng.initialize(int(time.time() % 4294967295)) sim = ssolv.Wmdirect(mdl, geom, rng) sim.reset() tpnts = numpy.arange(0.0, INT, DT) ntpnts = tpnts.shape[0] res_m = numpy.zeros([NITER, ntpnts, 3]) for i in range(0, NITER): sim.restore('./validation_cp/cp/second_order_irev_AA') for t in range(0, ntpnts): sim.run(tpnts[t]) res_m[i, t, 0] = sim.getCompConc('comp1', 'A') res_m[i, t, 1] = sim.getCompConc('comp1', 'B') mean_res = numpy.mean(res_m, 0) invA = numpy.zeros(ntpnts) invB = numpy.zeros(ntpnts) lineA = numpy.zeros(ntpnts) lineB = numpy.zeros(ntpnts) max_err = 0.0 passed = True for i in range(ntpnts): invA[i] = (1.0 / mean_res[i][0]) invB[i] = (1.0 / mean_res[i][1]) lineA[i] = (1.0 / CONCA + ((tpnts[i] * KCST))) lineB[i] = (1.0 / CONCB + ((tpnts[i] * KCST))) assert (tol_funcs.tolerable(invA[i], lineA[i], tolerance)) assert (tol_funcs.tolerable(invB[i], lineB[i], tolerance))
import steps.rng as srng import steps.solver as ssolver import numpy #### #Concentrations for Ca in cytosol ca_concs = numpy.array([0.001e-6, 0.003e-6, 0.01e-6, 0.02e-6, 0.05e-6, 0.07e-6, 0.10e-6, 0.15e-6, 0.20e-6, 0.25e-6, \ 0.28e-6, 0.30e-6, 0.33e-6, 0.35e-6, 0.36e-6, 0.38e-6, 0.43e-6, 0.50e-6, 1.00e-6, 1.50e-6, 2.00e-6,\ 2.50e-6, 5.00e-6, 10.00e-6]) # mol/l # Solver settings r = srng.create('mt19937', 1000) r.initialize(2605) sim = ssolver.Wmdirect(model.mdl, model.cell, r) # Number of iterations (defines how many times the model is simulated) NITER = 1 #5000 tpnt = numpy.arange(0.0, 50.01, 0.01) # array for simulation results res = numpy.zeros([ca_concs.size, 2]) print 'Simulating the IP3R model of Dawson et al. 2003.' for i in xrange(ca_concs.size): print 'Round', i + 1, '/', ca_concs.size temp_res = numpy.zeros([NITER, tpnt.size])
print "Membrane created." # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # SIMULATION # # # # # # # # # # # # # # # # # # # # # # r = srng.create_mt19937(512) r.initialize(int(time.time()%1000)) # Random-number generator r_dummy = srng.create_mt19937(512) r_dummy.initialize(int(time.time()%1000)) print "Creating tetexact solver..." sim_stoch = ssolver.Tetexact(mdl_stoch, mesh_stoch, r, True) print "Creating WM solver" sim_WM = ssolver.Wmdirect(mdl_WM, wmgeom, r_dummy) print "Resetting simulation objects.." sim_stoch.reset() sim_WM.reset() print "Injecting molecules.." sim_stoch.setTemp(TEMPERATURE+273.15) for i in range(len(Length)): for j in range(int(Nannulis[i])): sim_WM.setCompConc('shells'+str(i)+str(j), 'Ca', Ca_iconc) sim_WM.setCompConc('shells'+str(i)+str(j), 'Mg', Mg_conc)
def solver(mdl, geom, tissue, sim_opt): """ run the simulation using sim_options and model and geometry (above) """ treated_tissue = copy.deepcopy(tissue) reactants = ['NP', 'NPi', 'NPR', 'R'] NT = int(sim_opt['general'].NT) t_final = int(sim_opt['general'].t_final) N_VC, unique_p = 0, [] for cell in treated_tissue: if cell.type == 'VC': N_VC += 1 [unique_p.append(p) for p in cell.prtcl_names if p not in unique_p] r = srng.create('mt19937', 512) seed = randint(1, 10000) r.initialize(seed) sim = ssolver.Wmdirect(mdl, geom, r) tpnt = np.linspace(0.0, t_final, NT) resi = np.zeros([NT, len(treated_tissue) * len(unique_p), len(reactants)]) for n, cell in enumerate(treated_tissue): for p in cell.prtcl_names: tag = str(n) + p prtcl = getattr(cell, p) if hasattr(cell, 'NR'): sim.setCompCount("cell_{}".format(tag), 'R', float(cell.NR)) if 'NP0' in prtcl: if prtcl['T'] == 1: sim.setCompCount("cell_{}".format(tag), 'N{}'.format(p), prtcl['NP0']) else: sim.setCompCount("cell_{}".format(tag), 'N{}'.format(p), prtcl['NP0']) sim.setCompClamped("cell_{}".format(tag), 'N{}'.format(p), True) printProgressBar(0, NT, prefix='Progress:', suffix='Complete', length=40) for t in range(NT): sim.run(tpnt[t]) printProgressBar(t, NT, prefix='Progress:', suffix='Complete', length=40) n = 0 for nc, cell in enumerate(treated_tissue): for p_idx, p in enumerate(cell.prtcl_names): tag = str(nc) + p prtcl = getattr(cell, p) if hasattr(cell, 'NR'): resi[t, n, 0] = sim.getCompCount("cell_{}".format(tag), 'N{}'.format(p)) resi[t, n, 1] = sim.getCompCount("cell_{}".format(tag), 'R') resi[t, n, 2] = sim.getCompCount("cell_{}".format(tag), 'NPR') resi[t, n, 3] = sim.getCompCount("cell_{}".format(tag), 'N{}i'.format(p)) else: resi[t, n, 0] = sim.getCompCount("cell_{}".format(tag), 'N{}'.format(p)) if 'T' in prtcl: if (tpnt[t] > prtcl['T']) or (prtcl['T'] == 1): sim.setCompClamped("cell_{}".format(tag), 'N{}'.format(p), False) if ('NP_max' in prtcl) and (resi[t, n, 3] > prtcl['NP_max']): cell.type = 'dead' n += 1 return treated_tissue, resi
def test_soirev2d(): VOL = 1.0e-18 COUNTA = 100.0 n=2.0 COUNTB = COUNTA/n KCST = 10.0e10 # The reaction constant AREA = 10.0e-12 CCST = KCST/(6.02214179e23*AREA) NITER = 1000 # The number of iterations DT = 0.05 # Sampling time-step INT = 1.05 # Sim endtime # In tests fewer than 0.1% fail with tolerance of 2% tolerance = 2.0/100 ######################################################################## mdl = smod.Model() A = smod.Spec('A', mdl) B = smod.Spec('B', mdl) C = smod.Spec('C', mdl) surfsys = smod.Surfsys('ssys',mdl) SR1 = smod.SReac('SR1', surfsys, slhs = [A, B], srhs = [C], kcst = KCST) geom = sgeom.Geom() comp1 = sgeom.Comp('comp1', geom, VOL) patch1 = sgeom.Patch('patch1', geom, comp1, area = AREA) patch1.addSurfsys('ssys') import random rng = srng.create('mt19937', 1000) rng.initialize(int(random.random()*4294967295)) sim = ssolv.Wmdirect(mdl, geom, rng) sim.reset() tpnts = numpy.arange(0.0, INT, DT) ntpnts = tpnts.shape[0] res_m = numpy.zeros([NITER, ntpnts, 3]) for i in range (0, NITER): sim.restore('./validation_cp/cp/second_order_irev_2D') for t in range(0, ntpnts): sim.run(tpnts[t]) res_m[i, t, 0] = sim.getPatchCount('patch1', 'A') res_m[i, t, 1] = sim.getPatchCount('patch1', 'B') mean_res = numpy.mean(res_m, 0) lnBA = numpy.zeros(ntpnts) lineAB = numpy.zeros(ntpnts) C = COUNTA-COUNTB passed =True max_err = 0.0 for i in range(ntpnts): A = mean_res[i][0] B = mean_res[i][1] lnBA[i] = math.log(B/A) lineAB[i] = math.log(COUNTB/COUNTA) -C*CCST*tpnts[i] assert(tol_funcs.tolerable(lnBA[i], lineAB[i], tolerance))