# current that will start for channels in the n4 conformational state: OC_CaP = smodel.GHKcurr('OC_CaP', ssys, CaP_m3, Ca, virtual_oconc = Ca_oconc, computeflux = True) #Set single channel permeability OC_CaP.setP(CaP_P) diff_Ca_cyt = smodel.Diff('diff_Ca_cyt', vsys0, Ca, DCST) # name, where, what, how fast diff_Ca_ER = smodel.Diff('diff_Ca_ER', vsys1, Ca, DCST) # name, where, what, how fast # diff_Ca_sens = smodel.Diff('diff_Ca_sens', surfsys2, Ca_sens, DCST) # name, where, what, how fast # define compartments: cyto_comp = stetmesh.TmComp('cyto_comp', mesh, CS_tet_IDs) ER_comp = stetmesh.TmComp('ER_comp', mesh, ER_tet_IDs) # get surf tris in comps: CS_memb_tris = meshctrl.findSurfTrisInComp(mesh, cyto_comp) ER_memb_tris = meshctrl.findOverlapTris(mesh, CS_tet_IDs, ER_tet_IDs) # patches: ER_surf = stetmesh.TmPatch('ER_surf', mesh, ER_memb_tris, icomp=ER_comp, ocomp=cyto_comp) memb_surf = stetmesh.TmPatch('memb_surf', mesh, NotAzTris, icomp=cyto_comp, ocomp=None) # AZ_surf = stetmesh.TmPatch('AZ_surf', mesh, az_tris, icomp = cyto_comp) # $-----$-----$-----$-----$-----$-----$-----$-----$-----$-----$-----$----- # Create the patch and associate with surface system 'ssys' patch = stetmesh.TmPatch('patch', mesh, NotCaSensTris, icomp = cyto_comp)
# define model model = smodel.Model() A = smodel.Spec('A', model) surfsys = smodel.Surfsys('ssys', model) D_a = smodel.Diff('D_a', surfsys, A) DCST = 0.2e-9 D_a.setDcst(DCST) mesh = meshio.importAbaqus2("mesh_tet.inp", "mesh_tri.inp", 1e-6, "mesh_conf")[0] boundary_tris = mesh.getROIData("boundary") v1_tets = mesh.getROIData("v1_tets") comp1 = sgeom.TmComp("comp1", mesh, v1_tets) patch1 = sgeom.TmPatch("patch", mesh, boundary_tris, comp1) patch1.addSurfsys("ssys") neigh_tris = mesh.getROIData("neigh_tri") focus_tri = mesh.getROIData("focus_tri")[0] rng = srng.create('mt19937', 512) rng.initialize(int(time.time() % 4294967295)) solver = solv.Tetexact(model, mesh, rng) print "Set dcst from focus_tri to all neighbor tris to 0..." for tri in neigh_tris: solver.setTriDiffD(focus_tri, "D_a", 0, tri)
def gen_model(): mdl = smodel.Model() X = smodel.Spec('X', mdl) ssys = smodel.Surfsys('ssys', mdl) diff_X = smodel.Diff('diffX', ssys, X, DCST) return mdl ######################################################################## mesh = smeshio.loadMesh('meshes/coin_10r_1h_13861')[0] ntets = mesh.countTets() comp = stetmesh.TmComp('cyto', mesh, range(ntets)) tet_hosts = gd.linearPartition(mesh, [steps.mpi.nhosts, 1, 1]) alltris = mesh.getSurfTris() tri_hosts = gd.partitionTris(mesh, tet_hosts, alltris) # Sort patch triangles as those of positive z: A +ve x, B -ve x patchA_tris = [] patchB_tris = [] patchA_bars = set() patchB_bars = set() for t in alltris: vert0, vert1, vert2 = mesh.getTri(t) if (mesh.getVertex(vert0)[2] > 0.0 \ and mesh.getVertex(vert1)[2] > 0.0 \ and mesh.getVertex(vert2)[2] > 0.0):
def test_masteq_diff(): "Reaction-diffusion - Production and second order degradation (Parallel TetOpSplit)" ### NOW A+B-> B, 0->A (see Erban and Chapman, 2009) ######################################################################## SCALE = 1.0 KCST_f = 100e6 * SCALE # The reaction constant, degradation KCST_b = (20.0e-10 * SCALE) # The reaction constant, production DCST_A = 20e-12 DCST_B = 20e-12 B0 = 1 # The number of B moleucles DT = 0.1 # Sampling time-step INT = 50000.1 # Sim endtime filename = 'cube_1_1_1_73tets.inp' # A tolerance of 7.5% will fail <1% of the time tolerance = 7.5 / 100 ######################################################################## mdl = smod.Model() A = smod.Spec('A', mdl) B = smod.Spec('B', mdl) volsys = smod.Volsys('vsys', mdl) diffA = smod.Diff('diffA', volsys, A) diffA.setDcst(DCST_A) diffB = smod.Diff('diffB', volsys, B) diffB.setDcst(DCST_B) # Production R1 = smod.Reac('R1', volsys, lhs=[A, B], rhs=[B], kcst=KCST_f) R2 = smod.Reac('R2', volsys, lhs=[], rhs=[A], kcst=KCST_b) geom = meshio.loadMesh('validation_rd_mpi/meshes/' + filename)[0] comp1 = sgeom.TmComp('comp1', geom, range(geom.ntets)) comp1.addVolsys('vsys') rng = srng.create('r123', 512) rng.initialize(1000) tet_hosts = gd.binTetsByAxis(geom, steps.mpi.nhosts) sim = solvmod.TetOpSplit(mdl, geom, rng, False, tet_hosts) sim.reset() tpnts = numpy.arange(0.0, INT, DT) ntpnts = tpnts.shape[0] res = numpy.zeros([ntpnts]) res_std1 = numpy.zeros([ntpnts]) res_std2 = numpy.zeros([ntpnts]) sim.reset() sim.setCompCount('comp1', 'A', 0) sim.setCompCount('comp1', 'B', B0) b_time = time.time() 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 k1 = KCST_f / 6.022e23 k2 = KCST_b * 6.022e23 v = comp1.getVol() * 1.0e3 # litres for m in range(5, 11): analy = (1.0 / fact(m)) * math.pow( (k2 * v * v) / (B0 * k1), m) * math.exp(-((k2 * v * v) / (k1 * B0))) assert tol_funcs.tolerable(steps_n_res[m], analy, tolerance)
area=Rings_areas[i][j]) #For all patches, add the surface system for i in range(len(Length)): for j in range(int(Nannulis[i])): if j == 0: rings[i][j].addSurfsys('ssys_chans') else: rings[i][j].addSurfsys('ssys_diff') shells[i][j].addVolsys('vsys_buffs') ########## Create an intracellular compartment i.e. cytosolic compartment cyto_stoch = sgeom.TmComp('cyto_stoch', mesh_stoch, inner_tets) ########## Finding the triangles comprising the memberane memb_tris = list(mesh_stoch.getSurfTris()) Compborder_triIDs = [None] * len(Length) Compborder_tri_areas = [0.0] * len(Length) for i in range(len(Length)): Compborder_triIDs[i] = [] for j in range(len(Comp_tetIDs[i])): tritemp = mesh_stoch.getTetTriNeighb(Comp_tetIDs[i][j]) for tri in tritemp: if tri in memb_tris: Compborder_triIDs[i].append(tri)
# The points along (z) axis at which to record potential pot_pos = numpy.arange(mesh.getBoundMin()[2], mesh.getBoundMax()[2], 10e-6) pot_n = len(pot_pos) pot_tet = numpy.zeros(pot_n, dtype = 'uint') i=0 for p in pot_pos: # Axis is aligned with z-axis pot_tet[i] = mesh.findTetByPoint([0.0, 0.0, pot_pos[i]]) i=i+1 # # # # # # # # # # # # # # # GEOMETRY OBJECTS # # # # # # # # # # # # # # # # # # Create cytosol compartment cyto = sgeom.TmComp('cyto', mesh, range(mesh.ntets)) # Create the patch and associate with surface system 'ssys' patch = sgeom.TmPatch('patch', mesh, memb_tris, cyto) patch.addSurfsys('ssys') # Create the membrane across which the potential will be solved membrane = sgeom.Memb('membrane', mesh, [patch], opt_method = 1) # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # Create the random number generator r = srng.create('mt19937',512) r.initialize(int(time.time()%10000)) # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
def setUp(self): self.DCST = 0.08e-12 self.model = smodel.Model() A = smodel.Spec('A', self.model) X = smodel.Spec('X', self.model) self.ssys1 = smodel.Surfsys('ssys1', self.model) self.ssys2 = smodel.Surfsys('ssys2', self.model) self.sreac = smodel.SReac('sreac', self.ssys1, slhs=[A], srhs=[A], kcst=1e5) self.diff1 = smodel.Diff('diffX1', self.ssys1, X, self.DCST) self.diff2 = smodel.Diff('diffX2', self.ssys2, X, self.DCST) if __name__ == "__main__": self.mesh = meshio.loadMesh('meshes/coin_10r_1h_13861')[0] else: self.mesh = meshio.loadMesh( 'sdiff_bugfix_test/meshes/coin_10r_1h_13861')[0] ntets = self.mesh.countTets() self.comp = sgeom.TmComp('cyto', self.mesh, range(ntets)) alltris = self.mesh.getSurfTris() patchA_tris = [] patchB_tris = [] patchA_bars = set() patchB_bars = set() for t in alltris: vert0, vert1, vert2 = self.mesh.getTri(t) if (self.mesh.getVertex(vert0)[2] > 0.0 \ and self.mesh.getVertex(vert1)[2] > 0.0 \ and self.mesh.getVertex(vert2)[2] > 0.0): if self.mesh.getTriBarycenter(t)[0] > 0.0: patchA_tris.append(t) bar = self.mesh.getTriBars(t) patchA_bars.add(bar[0]) patchA_bars.add(bar[1]) patchA_bars.add(bar[2]) else: patchB_tris.append(t) bar = self.mesh.getTriBars(t) patchB_bars.add(bar[0]) patchB_bars.add(bar[1]) patchB_bars.add(bar[2]) self.patchA = sgeom.TmPatch('patchA', self.mesh, patchA_tris, icomp=self.comp) self.patchA.addSurfsys('ssys1') self.patchB = sgeom.TmPatch('patchB', self.mesh, patchB_tris, icomp=self.comp) self.patchB.addSurfsys('ssys2') # Find the set of bars that connect the two patches as the intersecting bars barsDB = patchA_bars.intersection(patchB_bars) barsDB = list(barsDB) # Create the surface diffusion boundary self.diffb = sgeom.SDiffBoundary('sdiffb', self.mesh, barsDB, [self.patchA, self.patchB]) ctetidx = self.mesh.findTetByPoint([0.0, 0.0, 0.5e-6]) ctet_trineighbs = self.mesh.getTetTriNeighb(ctetidx) self.ctri_idx = UNKNOWN_TRI for t in ctet_trineighbs: if t in patchA_tris + patchB_tris: self.ctri_idx = t self.rng = srng.create('r123', 512) self.rng.initialize(1000) self.solver = solv.Tetexact(self.model, self.mesh, self.rng)
DCST = 0.2e-9 model = smodel.Model() A = smodel.Spec('A', model) volsys = smodel.Volsys('vsys', model) D_a = smodel.Diff('D_a', volsys, A) D_a.setDcst(DCST) mesh = meshio.importAbaqus2("mesh_tet.inp", "mesh_tri.inp", 1e-6, "mesh_conf")[0] boundary_tris = mesh.getROIData("boundary") v1_tets = mesh.getROIData("v1_tets") v2_tets = mesh.getROIData("v2_tets") comp1 = sgeom.TmComp("comp1", mesh, v1_tets) comp2 = sgeom.TmComp("comp2", mesh, v2_tets) comp1.addVolsys("vsys") comp2.addVolsys("vsys") db = sgeom.DiffBoundary("boundary", mesh, boundary_tris) rng = srng.create('mt19937', 512) rng.initialize(int(time.time()%4294967295)) solver = solv.Tetexact(model, mesh, rng) print "Set directonal dcst from comp1 to comp2, and from comp2 to comp1 to 0..." solver.setCompCount("comp1", "A", 100) solver.setCompCount("comp2", "A", 20) solver.setDiffBoundaryDcst("boundary", "A", 0)
inner_tets = gettets.getcyl(mesh_stoch, 1e-6, -200e-6, 200e-6)[0] for i in inner_tets: outer_tets.remove(i) assert (outer_tets.__len__() + inner_tets.__len__() == mesh_stoch.ntets) print outer_tets.__len__(), " tets in outer compartment" print inner_tets.__len__(), " tets in inner compartment" # Record voltage from the central tetrahedron cent_tet = mesh_stoch.findTetByPoint([0.0, 0.0, 0.0]) ########## Create an intracellular compartment i.e. cytosolic compartment cyto_stoch = sgeom.TmComp('cyto_stoch', mesh_stoch, inner_tets) cyto_stoch.addVolsys('vsys_stoch') cyto_det = sgeom.TmComp('cyto_det', mesh_det, inner_tets) cyto_det.addVolsys('vsys_det') if cyl160: # Ensure that we use points a small distance inside the boundary: LENGTH = mesh_stoch.getBoundMax()[2] - mesh_stoch.getBoundMin()[2] boundminz = mesh_stoch.getBoundMin()[2] + LENGTH / mesh_stoch.ntets boundmaxz = mesh_stoch.getBoundMax()[2] - LENGTH / mesh_stoch.ntets memb_tris = list(mesh_stoch.getSurfTris()) minztris = [] maxztris = [] for tri in memb_tris:
def test_kisilevich(): "Reaction-diffusion - Degradation-diffusion (Tetexact)" NITER = 50 # The number of iterations DT = 0.1 # Sampling time-step INT = 0.3 # Sim endtime DCSTA = 400 * 1e-12 DCSTB = DCSTA RCST = 100000.0e6 #NA0 = 100000 # 1000000 # Initial number of A molecules NA0 = 1000 NB0 = NA0 # Initial number of B molecules SAMPLE = 1686 # <1% fail with a tolerance of 7.5% tolerance = 7.5 / 100 # create the array of tet indices to be found at random tetidxs = numpy.zeros(SAMPLE, dtype='int') # further create the array of tet barycentre distance to centre tetrads = numpy.zeros(SAMPLE) 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, B], rhs=[]) R1.setKcst(RCST) D_a = smod.Diff('D_a', volsys, A) D_a.setDcst(DCSTA) D_b = smod.Diff('D_b', volsys, B) D_b.setDcst(DCSTB) mesh = meshio.loadMesh('validation_rd/meshes/brick_40_4_4_1686tets')[0] VOLA = mesh.getMeshVolume() / 2.0 VOLB = VOLA ntets = mesh.countTets() acomptets = [] bcomptets = [] max = mesh.getBoundMax() min = mesh.getBoundMax() midz = 0.0 compatris = set() compbtris = set() for t in range(ntets): barycz = mesh.getTetBarycenter(t)[0] tris = mesh.getTetTriNeighb(t) if barycz < midz: acomptets.append(t) compatris.add(tris[0]) compatris.add(tris[1]) compatris.add(tris[2]) compatris.add(tris[3]) else: bcomptets.append(t) compbtris.add(tris[0]) compbtris.add(tris[1]) compbtris.add(tris[2]) compbtris.add(tris[3]) dbset = compatris.intersection(compbtris) dbtris = list(dbset) compa = sgeom.TmComp('compa', mesh, acomptets) compb = sgeom.TmComp('compb', mesh, bcomptets) compa.addVolsys('vsys') compb.addVolsys('vsys') diffb = sgeom.DiffBoundary('diffb', mesh, dbtris) # Now fill the array holding the tet indices to sample at random assert (SAMPLE <= ntets) numfilled = 0 while (numfilled < SAMPLE): tetidxs[numfilled] = numfilled numfilled += 1 # Now find the distance of the centre of the tets to the Z lower face for i in range(SAMPLE): baryc = mesh.getTetBarycenter(int(tetidxs[i])) r = baryc[0] tetrads[i] = r * 1.0e6 Atets = acomptets Btets = bcomptets rng = srng.create('r123', 512) rng.initialize(1000) sim = ssolv.Tetexact(mdl, mesh, rng) sim.reset() tpnts = numpy.arange(0.0, INT, DT) ntpnts = tpnts.shape[0] resA = numpy.zeros((NITER, ntpnts, SAMPLE)) resB = numpy.zeros((NITER, ntpnts, SAMPLE)) for i in range(0, NITER): sim.reset() sim.setDiffBoundaryDiffusionActive('diffb', 'A', True) sim.setDiffBoundaryDiffusionActive('diffb', 'B', True) sim.setCompCount('compa', 'A', NA0) sim.setCompCount('compb', 'B', NB0) for t in range(0, ntpnts): sim.run(tpnts[t]) for k in range(SAMPLE): resA[i, t, k] = sim.getTetCount(int(tetidxs[k]), 'A') resB[i, t, k] = sim.getTetCount(int(tetidxs[k]), 'B') itermeansA = numpy.mean(resA, axis=0) itermeansB = numpy.mean(resB, axis=0) def getdetc(t, x): N = 1000 # The number to represent infinity in the exponential calculation L = 20e-6 concA = 0.0 for n in range(N): concA += ((1.0 / (2 * n + 1)) * math.exp( (-(DCSTA / (20.0e-6)) * math.pow( (2 * n + 1), 2) * math.pow(math.pi, 2) * t) / (4 * L)) * math.sin(((2 * n + 1) * math.pi * x) / (2 * L))) concA *= ((4 * NA0 / math.pi) / (VOLA * 6.022e26)) * 1.0e6 return concA tpnt_compare = [1, 2] passed = True max_err = 0.0 for tidx in tpnt_compare: NBINS = 10 radmax = 0.0 radmin = 10.0 for r in tetrads: if (r > radmax): radmax = r if (r < radmin): radmin = r rsec = (radmax - radmin) / NBINS binmins = numpy.zeros(NBINS + 1) tetradsbinned = numpy.zeros(NBINS) r = radmin bin_vols = numpy.zeros(NBINS) for b in range(NBINS + 1): binmins[b] = r if (b != NBINS): tetradsbinned[b] = r + rsec / 2.0 r += rsec bin_countsA = [None] * NBINS bin_countsB = [None] * NBINS for i in range(NBINS): bin_countsA[i] = [] bin_countsB[i] = [] filled = 0 for i in range(itermeansA[tidx].size): irad = tetrads[i] for b in range(NBINS): if (irad >= binmins[b] and irad < binmins[b + 1]): bin_countsA[b].append(itermeansA[tidx][i]) bin_vols[b] += sim.getTetVol(int(tetidxs[i])) filled += 1.0 break filled = 0 for i in range(itermeansB[tidx].size): irad = tetrads[i] for b in range(NBINS): if (irad >= binmins[b] and irad < binmins[b + 1]): bin_countsB[b].append(itermeansB[tidx][i]) filled += 1.0 break bin_concsA = numpy.zeros(NBINS) bin_concsB = numpy.zeros(NBINS) for c in range(NBINS): for d in range(bin_countsA[c].__len__()): bin_concsA[c] += bin_countsA[c][d] for d in range(bin_countsB[c].__len__()): bin_concsB[c] += bin_countsB[c][d] bin_concsA[c] /= (bin_vols[c]) bin_concsA[c] *= (1.0e-3 / 6.022e23) * 1.0e6 bin_concsB[c] /= (bin_vols[c]) bin_concsB[c] *= (1.0e-3 / 6.022e23) * 1.0e6 for i in range(NBINS): rad = abs(tetradsbinned[i]) * 1.0e-6 if (tetradsbinned[i] < -5): # compare A det_conc = getdetc(tpnts[tidx], rad) steps_conc = bin_concsA[i] assert tol_funcs.tolerable(det_conc, steps_conc, tolerance) if (tetradsbinned[i] > 5): # compare B det_conc = getdetc(tpnts[tidx], rad) steps_conc = bin_concsB[i] assert tol_funcs.tolerable(det_conc, steps_conc, tolerance)