def makeAdaptors(): ################################################################## # set up adaptor for elec model Ca -> chem model Ca # Here it is easy because we don't have to deal with different # sizes of electrical and chemical compartments. adaptCa = moose.Adaptor( '/model/chem/kinetics/adaptCa' ) chemCa = moose.element( '/model/chem/kinetics/Ca' ) elecCa = moose.element( '/model/elec/soma/Ca_conc' ) moose.connect( elecCa, 'concOut', adaptCa, 'input' ) moose.connect( adaptCa, 'output', chemCa, 'setConc' ) adaptCa.inputOffset = 0.0 # adaptCa.outputOffset = 0.00008 # 80 nM offset in chem. adaptCa.scale = 0.0008 # set up adaptor for chem model chan -> elec model chan. adaptChan = moose.Adaptor( '/model/chem/kinetics/adaptChan' ) chemChan = moose.element( '/model/chem/kinetics/chan' ) elecChan = moose.element( '/model/elec/soma/K_A' ) # The Adaptor has to request the output conc of the chemical pool, # since there isn't an output message to deliver this value. moose.connect( adaptChan, 'requestOut', chemChan, 'getConc' ) moose.connect( adaptChan, 'output', elecChan, 'setGbar' ) adaptChan.inputOffset = 0.0 # adaptChan.outputOffset = 0.0 adaptChan.scale = 1e-5 #
def makeCubeMultiscale(): makeSpinyCompt() model = moose.Neutral('/model') elec = moose.element('/n') elec.name = 'elec' moose.move(elec, model) synInput = moose.element('/model/elec/compt/synInput') synInput.refractT = 47e-3 makeChemInCubeMesh() # set up a reaction to fake diffusion between compts. headCa = moose.element('/model/chem/spineMesh/Ca') dendCa = moose.element('/model/chem/neuroMesh/Ca') diffReac = moose.Reac('/model/chem/spineMesh/diff') moose.connect(diffReac, 'sub', headCa, 'reac') moose.connect(diffReac, 'prd', dendCa, 'reac') diffReac.Kf = 1 diffReac.Kb = headCa.volume / dendCa.volume # set up adaptors headCa = moose.element('/model/chem/spineMesh/Ca') dendCa = moose.element('/model/chem/neuroMesh/Ca') adaptCa = moose.Adaptor('/model/chem/adaptCa') elecCa = moose.element('/model/elec/head2/ca') # There are 5 spine heads in the electrical model. Average their input. for i in range(5): path = '/model/elec/head' + str(i) + '/ca' elecCa = moose.element(path) moose.connect(elecCa, 'concOut', adaptCa, 'input', 'Single') moose.connect(adaptCa, 'output', headCa, 'setConc') adaptCa.outputOffset = 0.0001 # 100 nM offset in chem. adaptCa.scale = 0.05 # 0.06 to 0.003 mM adaptGluR = moose.Adaptor('/model/chem/psdMesh/adaptGluR') chemR = moose.element('/model/chem/psdMesh/psdGluR') # Here we connect up the chem adaptors to only 3 of the spine # heads in the elec model, just to make it interesting. elec1R = moose.element('/model/elec/head1/gluR') elec2R = moose.element('/model/elec/head2/gluR') elec3R = moose.element('/model/elec/head3/gluR') moose.connect(adaptGluR, 'requestOut', chemR, 'getN', 'OneToAll') moose.connect(adaptGluR, 'output', elec1R, 'setGbar', 'OneToAll') moose.connect(adaptGluR, 'output', elec2R, 'setGbar', 'OneToAll') moose.connect(adaptGluR, 'output', elec3R, 'setGbar', 'OneToAll') adaptGluR.outputOffset = 1e-9 # pS adaptGluR.scale = 1e-8 / 100 # from n to pS adaptK = moose.Adaptor('/model/chem/neuroMesh/adaptK') chemK = moose.element('/model/chem/neuroMesh/kChan') elecK = moose.element('/model/elec/compt/K') moose.connect(adaptK, 'requestOut', chemK, 'getConc', 'OneToAll') moose.connect(adaptK, 'output', elecK, 'setGbar', 'OneToAll') adaptK.scale = 0.3 # from mM to Siemens
def makeModelInCubeMesh(): compt = createSquid() createSynapseOnCompartment(compt) chem = moose.Neutral('/n/chem') neuroMesh = moose.CubeMesh('/n/chem/neuroMesh') coords = [0] * 9 coords[3] = compt.length coords[4] = compt.diameter coords[5] = compt.diameter coords[6] = compt.length coords[7] = compt.diameter coords[8] = compt.diameter neuroMesh.coords = coords neuroMesh.preserveNumEntries = 1 createChemModel(neuroMesh) dendCa = moose.element('/n/chem/neuroMesh/Ca') assert dendCa.volume == compt.length * compt.diameter * compt.diameter dendKinaseEnzCplx = moose.element('/n/chem/neuroMesh/Ca.kinase/enz/cplx') assert dendKinaseEnzCplx.volume == dendCa.volume # Make adaptors # Note that we can do this two ways: We can use an existing output # msg from the object, which will come whenever the object processes, # or the adapator can request the object for the field, which happens # whenever the adaptor processes. Here we illustrate both alternatives. adaptK = moose.Adaptor('/n/chem/neuroMesh/adaptK') chemK = moose.element('/n/chem/neuroMesh/kChan') elecK = moose.element('/n/elec/compt/K') moose.connect(adaptK, 'requestOut', chemK, 'getConc', 'OneToAll') moose.connect(adaptK, 'output', elecK, 'setGbar', 'OneToAll') adaptK.scale = 0.3 # from mM to Siemens adaptCa = moose.Adaptor('/n/chem/neuroMesh/adaptCa') chemCa = moose.element('/n/chem/neuroMesh/Ca') elecCa = moose.element('/n/elec/compt/ca') moose.connect(elecCa, 'concOut', adaptCa, 'input', 'OneToAll') moose.connect(adaptCa, 'output', chemCa, 'setConc', 'OneToAll') adaptCa.outputOffset = 0.0001 # 100 nM offset in chem conc adaptCa.scale = 0.05 # Empirical: 0.06 max to 0.003 mM
def _buildAdaptor( self, meshName, elecRelPath, elecField, \ chemRelPath, isElecToChem, offset, scale ): mesh = moose.element( '/model/chem/' + meshName ) elecComptList = mesh.elecComptList if len( elecComptList ) == 0: raise BuildError( \ "buildAdaptor: no elec compts in elecComptList on: " + \ mesh.path ) startVoxelInCompt = mesh.startVoxelInCompt endVoxelInCompt = mesh.endVoxelInCompt capField = elecField[0].capitalize() + elecField[1:] chemPath = mesh.path + '/' + chemRelPath if not( moose.exists( chemPath ) ): raise BuildError( \ "Error: buildAdaptor: no chem obj in " + chemPath ) chemObj = moose.element( chemPath ) assert( chemObj.numData >= len( elecComptList ) ) adName = '/adapt' for i in range( 1, len( elecRelPath ) ): if ( elecRelPath[-i] == '/' ): adName += elecRelPath[1-i] break ad = moose.Adaptor( chemObj.path + adName, len( elecComptList ) ) print 'building ', len( elecComptList ), 'adaptors ', adName, \ ' for: ', mesh.name, elecRelPath, elecField, chemRelPath av = ad.vec chemVec = moose.element( mesh.path + '/' + chemRelPath ).vec for i in zip( elecComptList, startVoxelInCompt, endVoxelInCompt, av ): i[3].inputOffset = 0.0 i[3].outputOffset = offset i[3].scale = scale ePath = i[0].path + '/' + elecRelPath if not( moose.exists( ePath ) ): raise BuildError( \ "Error: buildAdaptor: no elec obj in " + ePath ) elObj = moose.element( i[0].path + '/' + elecRelPath ) if ( isElecToChem ): elecFieldSrc = 'get' + capField #print ePath, elecFieldSrc, scale moose.connect( i[3], 'requestOut', elObj, elecFieldSrc ) for j in range( i[1], i[2] ): moose.connect( i[3], 'output', chemVec[j], 'setConc') else: elecFieldDest = 'set' + capField for j in range( i[1], i[2] ): moose.connect( i[3], 'requestOut', chemVec[j], 'getConc') moose.connect( i[3], 'output', elObj, elecFieldDest )
def makeNeuroMeshModel(): diffLength = 10e-6 # Aim for 2 soma compartments. elec = loadElec() loadChem(diffLength) neuroCompt = moose.element('/model/chem/dend') neuroCompt.diffLength = diffLength neuroCompt.cellPortion(elec, '/model/elec/#') for x in moose.wildcardFind('/model/chem/##[ISA=PoolBase]'): if (x.diffConst > 0): x.diffConst = 1e-11 for x in moose.wildcardFind('/model/chem/##/Ca'): x.diffConst = 1e-10 # Put in dend solvers ns = neuroCompt.numSegments ndc = neuroCompt.numDiffCompts print 'ns = ', ns, ', ndc = ', ndc assert (neuroCompt.numDiffCompts == neuroCompt.mesh.num) assert (ns == 36) # assert (ndc == 278) # nmksolve = moose.Ksolve('/model/chem/dend/ksolve') nmdsolve = moose.Dsolve('/model/chem/dend/dsolve') nmstoich = moose.Stoich('/model/chem/dend/stoich') nmstoich.compartment = neuroCompt nmstoich.ksolve = nmksolve nmstoich.dsolve = nmdsolve nmstoich.path = "/model/chem/dend/##" print 'done setting path, numPools = ', nmdsolve.numPools assert (nmdsolve.numPools == 1) assert (nmdsolve.numAllVoxels == ndc) assert (nmstoich.numAllPools == 1) # oddly, numLocalFields does not work. ca = moose.element('/model/chem/dend/DEND/Ca') assert (ca.numData == ndc) # Put in spine solvers. Note that these get info from the neuroCompt spineCompt = moose.element('/model/chem/spine') sdc = spineCompt.mesh.num print 'sdc = ', sdc assert (sdc == 13) smksolve = moose.Ksolve('/model/chem/spine/ksolve') smdsolve = moose.Dsolve('/model/chem/spine/dsolve') smstoich = moose.Stoich('/model/chem/spine/stoich') smstoich.compartment = spineCompt smstoich.ksolve = smksolve smstoich.dsolve = smdsolve smstoich.path = "/model/chem/spine/##" print 'spine num Pools = ', smstoich.numAllPools, smdsolve.numPools assert (smstoich.numAllPools == 35) assert (smdsolve.numPools == 30) assert (smdsolve.numAllVoxels == sdc) # Put in PSD solvers. Note that these get info from the neuroCompt psdCompt = moose.element('/model/chem/psd') pdc = psdCompt.mesh.num assert (pdc == 13) pmksolve = moose.Ksolve('/model/chem/psd/ksolve') pmdsolve = moose.Dsolve('/model/chem/psd/dsolve') pmstoich = moose.Stoich('/model/chem/psd/stoich') pmstoich.compartment = psdCompt pmstoich.ksolve = pmksolve pmstoich.dsolve = pmdsolve pmstoich.path = "/model/chem/psd/##" print 'psd num Pools = ', pmstoich.numAllPools, pmdsolve.numPools assert (pmstoich.numAllPools == 55) assert (pmdsolve.numPools == 48) assert (pmdsolve.numAllVoxels == pdc) foo = moose.element('/model/chem/psd/Ca') print 'PSD: numfoo = ', foo.numData print 'PSD: numAllVoxels = ', pmksolve.numAllVoxels # Put in junctions between the diffusion solvers nmdsolve.buildNeuroMeshJunctions(smdsolve, pmdsolve) """ CaNpsd = moose.vec( '/model/chem/psdMesh/PSD/PP1_PSD/CaN' ) print 'numCaN in PSD = ', CaNpsd.nInit, ', vol = ', CaNpsd.volume CaNspine = moose.vec( '/model/chem/spine/SPINE/CaN_BULK/CaN' ) print 'numCaN in spine = ', CaNspine.nInit, ', vol = ', CaNspine.volume """ ################################################################## # set up adaptors aCa = moose.Adaptor('/model/chem/spine/adaptCa', sdc) adaptCa = moose.vec('/model/chem/spine/adaptCa') chemCa = moose.vec('/model/chem/spine/Ca') #print 'aCa = ', aCa, ' foo = ', foo, "len( ChemCa ) = ", len( chemCa ), ", numData = ", chemCa.numData, "len( adaptCa ) = ", len( adaptCa ) assert (len(adaptCa) == sdc) assert (len(chemCa) == sdc) for i in range(sdc): elecCa = moose.element('/model/elec/spine_head_14_' + str(i + 1) + '/NMDA_Ca_conc') #print elecCa moose.connect(elecCa, 'concOut', adaptCa[i], 'input', 'Single') moose.connect(adaptCa, 'output', chemCa, 'setConc', 'OneToOne') adaptCa.inputOffset = 0.0 # adaptCa.outputOffset = 0.00008 # 80 nM offset in chem. adaptCa.scale = 5e-3 # 520 to 0.0052 mM #print adaptCa.outputOffset moose.le('/model/chem/dend/DEND') compts = neuroCompt.elecComptList begin = neuroCompt.startVoxelInCompt end = neuroCompt.endVoxelInCompt aCa = moose.Adaptor('/model/chem/dend/DEND/adaptCa', len(compts)) adaptCa = moose.vec('/model/chem/dend/DEND/adaptCa') chemCa = moose.vec('/model/chem/dend/DEND/Ca') #print 'aCa = ', aCa, ' foo = ', foo, "len( ChemCa ) = ", len( chemCa ), ", numData = ", chemCa.numData, "len( adaptCa ) = ", len( adaptCa ) assert (len(chemCa) == ndc) for i in zip(compts, adaptCa, begin, end): name = i[0].path + '/Ca_conc' if (moose.exists(name)): elecCa = moose.element(name) #print i[2], i[3], ' ', elecCa #print i[1] moose.connect(elecCa, 'concOut', i[1], 'input', 'Single') for j in range(i[2], i[3]): moose.connect(i[1], 'output', chemCa[j], 'setConc', 'Single') adaptCa.inputOffset = 0.0 # adaptCa.outputOffset = 0.00008 # 80 nM offset in chem. adaptCa.scale = 20e-6 # 10 arb units to 2 uM.
def makeNeuroMeshModel(): makeSpinyCompt() diffLength = moose.element('/n/compt').length diffLength = diffLength / 10.0 elec = moose.element('/n') elec.name = 'elec' model = moose.Neutral('/model') moose.move(elec, model) synInput = moose.element('/model/elec/compt/synInput') synInput.refractT = 47e-3 chem = moose.Neutral('/model/chem') neuroCompt = moose.NeuroMesh('/model/chem/neuroMesh') neuroCompt.separateSpines = 1 neuroCompt.diffLength = diffLength neuroCompt.geometryPolicy = 'cylinder' spineCompt = moose.SpineMesh('/model/chem/spineMesh') moose.connect(neuroCompt, 'spineListOut', spineCompt, 'spineList', 'OneToOne') psdCompt = moose.PsdMesh('/model/chem/psdMesh') moose.connect(neuroCompt, 'psdListOut', psdCompt, 'psdList', 'OneToOne') createChemModel(neuroCompt, spineCompt, psdCompt) # Put in the solvers, see how they fare. nmksolve = moose.GslStoich('/model/chem/neuroMesh/ksolve') nmksolve.path = '/model/chem/neuroMesh/##' nmksolve.compartment = moose.element('/model/chem/neuroMesh') nmksolve.method = 'rk5' nm = moose.element('/model/chem/neuroMesh/mesh') moose.connect(nm, 'remesh', nmksolve, 'remesh') #print "neuron: nv=", nmksolve.numLocalVoxels, ", nav=", nmksolve.numAllVoxels, nmksolve.numVarPools, nmksolve.numAllPools #print 'setting up smksolve' smksolve = moose.GslStoich('/model/chem/spineMesh/ksolve') smksolve.path = '/model/chem/spineMesh/##' smksolve.compartment = moose.element('/model/chem/spineMesh') smksolve.method = 'rk5' sm = moose.element('/model/chem/spineMesh/mesh') moose.connect(sm, 'remesh', smksolve, 'remesh') #print "spine: nv=", smksolve.numLocalVoxels, ", nav=", smksolve.numAllVoxels, smksolve.numVarPools, smksolve.numAllPools # #print 'setting up pmksolve' pmksolve = moose.GslStoich('/model/chem/psdMesh/ksolve') pmksolve.path = '/model/chem/psdMesh/##' pmksolve.compartment = moose.element('/model/chem/psdMesh') pmksolve.method = 'rk5' pm = moose.element('/model/chem/psdMesh/mesh') moose.connect(pm, 'remesh', pmksolve, 'remesh') #print "psd: nv=", pmksolve.numLocalVoxels, ", nav=", pmksolve.numAllVoxels, pmksolve.numVarPools, pmksolve.numAllPools # #print 'Assigning the cell model' # Now to set up the model. neuroCompt.cell = elec ns = neuroCompt.numSegments #assert( ns == 11 ) # dend, 5x (shaft+head) ndc = neuroCompt.numDiffCompts assert (ndc == 10) ndc = neuroCompt.mesh.num assert (ndc == 10) sdc = spineCompt.mesh.num assert (sdc == 5) pdc = psdCompt.mesh.num assert (pdc == 5) # # We need to use the spine solver as the master for the purposes of # these calculations. This will handle the diffusion calculations # between head and dendrite, and between head and PSD. smksolve.addJunction(nmksolve) #print "spine: nv=", smksolve.numLocalVoxels, ", nav=", smksolve.numAllVoxels, smksolve.numVarPools, smksolve.numAllPools smksolve.addJunction(pmksolve) #print "psd: nv=", pmksolve.numLocalVoxels, ", nav=", pmksolve.numAllVoxels, pmksolve.numVarPools, pmksolve.numAllPools # Have to pass a message between the various solvers. foo = moose.vec('/model/chem/spineMesh/headGluR') # oddly, numLocalFields does not work. ca = moose.element('/model/chem/neuroMesh/Ca') assert (ca.lastDimension == ndc) moose.vec('/model/chem/spineMesh/headGluR').nInit = 100 moose.vec('/model/chem/psdMesh/psdGluR').nInit = 0 # set up adaptors aCa = moose.Adaptor('/model/chem/spineMesh/adaptCa', 5) adaptCa = moose.vec('/model/chem/spineMesh/adaptCa') chemCa = moose.vec('/model/chem/spineMesh/Ca') assert (len(adaptCa) == 5) for i in range(5): path = '/model/elec/head' + str(i) + '/ca' elecCa = moose.element(path) moose.connect(elecCa, 'concOut', adaptCa[i], 'input', 'Single') moose.connect(adaptCa, 'outputSrc', chemCa, 'setConc', 'OneToOne') adaptCa.outputOffset = 0.0001 # 100 nM offset in chem. adaptCa.scale = 0.05 # 0.06 to 0.003 mM aGluR = moose.Adaptor('/model/chem/psdMesh/adaptGluR', 5) adaptGluR = moose.vec('/model/chem/psdMesh/adaptGluR') chemR = moose.vec('/model/chem/psdMesh/psdGluR') assert (len(adaptGluR) == 5) for i in range(5): path = '/model/elec/head' + str(i) + '/gluR' elecR = moose.element(path) moose.connect(adaptGluR[i], 'outputSrc', elecR, 'setGbar', 'Single') #moose.connect( chemR, 'nOut', adaptGluR, 'input', 'OneToOne' ) # Ksolve isn't sending nOut. Not good. So have to use requestOut. moose.connect(adaptGluR, 'requestOut', chemR, 'getN', 'OneToOne') adaptGluR.outputOffset = 1e-7 # pS adaptGluR.scale = 1e-6 / 100 # from n to pS adaptK = moose.Adaptor('/model/chem/neuroMesh/adaptK') chemK = moose.element('/model/chem/neuroMesh/kChan') elecK = moose.element('/model/elec/compt/K') moose.connect(adaptK, 'requestOut', chemK, 'getConc', 'OneToAll') moose.connect(adaptK, 'outputSrc', elecK, 'setGbar', 'Single') adaptK.scale = 0.3 # from mM to Siemens """
def makeNeuroMeshModel(): diffLength = 20e-6 # Aim for just 3 compts. elec = loadElec() loadChem(diffLength) neuroCompt = moose.element('/model/chem/dend') neuroCompt.diffLength = diffLength neuroCompt.cellPortion(elec, '/model/elec/#') for x in moose.wildcardFind('/model/chem/##[ISA=PoolBase]'): if (x.diffConst > 0): x.diffConst = 1e-11 for x in moose.wildcardFind('/model/chem/##/Ca'): x.diffConst = 1e-10 # Put in dend solvers ns = neuroCompt.numSegments ndc = neuroCompt.numDiffCompts print 'ns = ', ns, ', ndc = ', ndc assert (neuroCompt.numDiffCompts == neuroCompt.mesh.num) assert (ns == 1) # dend, 5x (shaft+head) assert (ndc == 1) nmksolve = moose.Ksolve('/model/chem/dend/ksolve') nmdsolve = moose.Dsolve('/model/chem/dend/dsolve') nmstoich = moose.Stoich('/model/chem/dend/stoich') nmstoich.compartment = neuroCompt nmstoich.ksolve = nmksolve nmstoich.dsolve = nmdsolve nmstoich.path = "/model/chem/dend/##" print 'done setting path, numPools = ', nmdsolve.numPools assert (nmdsolve.numPools == 1) assert (nmdsolve.numAllVoxels == 1) assert (nmstoich.numAllPools == 1) # oddly, numLocalFields does not work. ca = moose.element('/model/chem/dend/DEND/Ca') assert (ca.numData == ndc) # Put in spine solvers. Note that these get info from the neuroCompt spineCompt = moose.element('/model/chem/spine') sdc = spineCompt.mesh.num print 'sdc = ', sdc assert (sdc == 1) smksolve = moose.Ksolve('/model/chem/spine/ksolve') smdsolve = moose.Dsolve('/model/chem/spine/dsolve') smstoich = moose.Stoich('/model/chem/spine/stoich') smstoich.compartment = spineCompt smstoich.ksolve = smksolve smstoich.dsolve = smdsolve smstoich.path = "/model/chem/spine/##" assert (smstoich.numAllPools == 3) assert (smdsolve.numPools == 3) assert (smdsolve.numAllVoxels == 1) # Put in PSD solvers. Note that these get info from the neuroCompt psdCompt = moose.element('/model/chem/psd') pdc = psdCompt.mesh.num assert (pdc == 1) pmksolve = moose.Ksolve('/model/chem/psd/ksolve') pmdsolve = moose.Dsolve('/model/chem/psd/dsolve') pmstoich = moose.Stoich('/model/chem/psd/stoich') pmstoich.compartment = psdCompt pmstoich.ksolve = pmksolve pmstoich.dsolve = pmdsolve pmstoich.path = "/model/chem/psd/##" assert (pmstoich.numAllPools == 3) assert (pmdsolve.numPools == 3) assert (pmdsolve.numAllVoxels == 1) foo = moose.element('/model/chem/psd/Ca') print 'PSD: numfoo = ', foo.numData print 'PSD: numAllVoxels = ', pmksolve.numAllVoxels """ CaNpsd = moose.vec( '/model/chem/psdMesh/PSD/PP1_PSD/CaN' ) print 'numCaN in PSD = ', CaNpsd.nInit, ', vol = ', CaNpsd.volume CaNspine = moose.vec( '/model/chem/spine/SPINE/CaN_BULK/CaN' ) print 'numCaN in spine = ', CaNspine.nInit, ', vol = ', CaNspine.volume """ # set up adaptors aCa = moose.Adaptor('/model/chem/psd/adaptCa', pdc) adaptCa = moose.vec('/model/chem/psd/adaptCa') chemCa = moose.vec('/model/chem/psd/Ca') print 'aCa = ', aCa, ' foo = ', foo, "len( ChemCa ) = ", len( chemCa), ", numData = ", chemCa.numData assert (len(adaptCa) == pdc) assert (len(chemCa) == pdc) path = '/model/elec/spine_head' elecCa = moose.element(path) moose.connect(elecCa, 'VmOut', adaptCa[0], 'input', 'Single') #moose.connect( adaptCa, 'outputSrc', chemCa, 'setConc', 'OneToOne' ) adaptCa.inputOffset = 0.0 # adaptCa.outputOffset = 0.00008 # 80 nM offset in chem. adaptCa.scale = 1e-5 # 520 to 0.0052 mM
def makeNeuroMeshModel(): diffLength = 20e-6 # But we only want diffusion over part of the model. numSyn = 13 elec = loadElec() synInput = moose.SpikeGen('/model/elec/synInput') synInput.refractT = 47e-3 synInput.threshold = -1.0 synInput.edgeTriggered = 0 synInput.Vm(0) synInput.refractT = 47e-3 for i in range(numSyn): name = '/model/elec/spine_head_14_' + str(i + 1) r = moose.element(name + '/glu') r.synapse.num = 1 syn = moose.element(r.path + '/synapse') moose.connect(synInput, 'spikeOut', syn, 'addSpike', 'Single') syn.weight = 0.2 * i * (numSyn - 1 - i) syn.delay = i * 1.0e-3 neuroCompt = moose.NeuroMesh('/model/neuroMesh') #print 'neuroMeshvolume = ', neuroCompt.mesh[0].volume neuroCompt.separateSpines = 1 neuroCompt.diffLength = diffLength neuroCompt.geometryPolicy = 'cylinder' spineCompt = moose.SpineMesh('/model/spineMesh') #print 'spineMeshvolume = ', spineCompt.mesh[0].volume moose.connect(neuroCompt, 'spineListOut', spineCompt, 'spineList', 'OneToOne') psdCompt = moose.PsdMesh('/model/psdMesh') #print 'psdMeshvolume = ', psdCompt.mesh[0].volume moose.connect(neuroCompt, 'psdListOut', psdCompt, 'psdList', 'OneToOne') loadChem(neuroCompt, spineCompt, psdCompt) # Put in the solvers, see how they fare. nmksolve = moose.GslStoich('/model/chem/neuroMesh/ksolve') nmksolve.path = '/model/chem/neuroMesh/##' nmksolve.compartment = moose.element('/model/chem/neuroMesh') nmksolve.method = 'rk5' nm = moose.element('/model/chem/neuroMesh/mesh') moose.connect(nm, 'remesh', nmksolve, 'remesh') #print "neuron: nv=", nmksolve.numLocalVoxels, ", nav=", nmksolve.numAllVoxels, nmksolve.numVarPools, nmksolve.numAllPools #print 'setting up smksolve' smksolve = moose.GslStoich('/model/chem/spineMesh/ksolve') smksolve.path = '/model/chem/spineMesh/##' smksolve.compartment = moose.element('/model/chem/spineMesh') smksolve.method = 'rk5' sm = moose.element('/model/chem/spineMesh/mesh') moose.connect(sm, 'remesh', smksolve, 'remesh') #print "spine: nv=", smksolve.numLocalVoxels, ", nav=", smksolve.numAllVoxels, smksolve.numVarPools, smksolve.numAllPools # #print 'setting up pmksolve' pmksolve = moose.GslStoich('/model/chem/psdMesh/ksolve') pmksolve.path = '/model/chem/psdMesh/##' pmksolve.compartment = moose.element('/model/chem/psdMesh') pmksolve.method = 'rk5' pm = moose.element('/model/chem/psdMesh/mesh') moose.connect(pm, 'remesh', pmksolve, 'remesh') #print "psd: nv=", pmksolve.numLocalVoxels, ", nav=", pmksolve.numAllVoxels, pmksolve.numVarPools, pmksolve.numAllPools # print('neuroMeshvolume = ', neuroCompt.mesh[0].volume) #print 'Assigning the cell model' # Now to set up the model. #neuroCompt.cell = elec neuroCompt.cellPortion( elec, '/model/elec/lat_14_#,/model/elec/spine_neck#,/model/elec/spine_head#') """ ns = neuroCompt.numSegments #assert( ns == 11 ) # dend, 5x (shaft+head) ndc = neuroCompt.numDiffCompts #print 'numDiffCompts = ', ndc assert( ndc == 145 ) ndc = neuroCompt.mesh.num #print 'NeuroMeshNum = ', ndc assert( ndc == 145 ) sdc = spineCompt.mesh.num #print 'SpineMeshNum = ', sdc assert( sdc == 13 ) pdc = psdCompt.mesh.num #print 'PsdMeshNum = ', pdc assert( pdc == 13 ) """ mesh = moose.vec('/model/chem/neuroMesh/mesh') #for i in range( ndc ): # print 's[', i, '] = ', mesh[i].volume mesh2 = moose.vec('/model/chem/spineMesh/mesh') # for i in range( sdc ): # print 's[', i, '] = ', mesh2[i].volume #print 'numPSD = ', moose.element( '/model/chem/psdMesh/mesh' ).localNumField mesh = moose.vec('/model/chem/psdMesh/mesh') #print 'psd mesh.volume = ', mesh.volume #for i in range( pdc ): # print 's[', i, '] = ', mesh[i].volume # # We need to use the spine solver as the master for the purposes of # these calculations. This will handle the diffusion calculations # between head and dendrite, and between head and PSD. smksolve.addJunction(nmksolve) #print "spine: nv=", smksolve.numLocalVoxels, ", nav=", smksolve.numAllVoxels, smksolve.numVarPools, smksolve.numAllPools smksolve.addJunction(pmksolve) #print "psd: nv=", pmksolve.numLocalVoxels, ", nav=", pmksolve.numAllVoxels, pmksolve.numVarPools, pmksolve.numAllPools ndc = neuroCompt.numDiffCompts #print 'numDiffCompts = ', ndc assert (ndc == 13) ndc = neuroCompt.mesh.num #print 'NeuroMeshNum = ', ndc assert (ndc == 13) sdc = spineCompt.mesh.num #print 'SpineMeshNum = ', sdc assert (sdc == 13) pdc = psdCompt.mesh.num #print 'PsdMeshNum = ', pdc assert (pdc == 13) """ print 'neuroCompt' for i in range( ndc ): print i, neuroCompt.stencilIndex[i] print i, neuroCompt.stencilRate[i] print 'spineCompt' for i in range( sdc * 3 ): print i, spineCompt.stencilIndex[i] print i, spineCompt.stencilRate[i] print 'psdCompt' for i in range( pdc ): print i, psdCompt.stencilIndex[i] print i, psdCompt.stencilRate[i] print 'Spine parents:' pavoxel = spineCompt.parentVoxel for i in range( sdc ): print i, pavoxel[i] """ # oddly, numLocalFields does not work. #moose.le( '/model/chem/neuroMesh' ) ca = moose.element('/model/chem/neuroMesh/DEND/Ca') assert (ca.lastDimension == ndc) """ CaNpsd = moose.vec( '/model/chem/psdMesh/PSD/PP1_PSD/CaN' ) print 'numCaN in PSD = ', CaNpsd.nInit, ', vol = ', CaNpsd.volume CaNspine = moose.vec( '/model/chem/spineMesh/SPINE/CaN_BULK/CaN' ) print 'numCaN in spine = ', CaNspine.nInit, ', vol = ', CaNspine.volume """ # set up adaptors aCa = moose.Adaptor('/model/chem/psdMesh/adaptCa', pdc) adaptCa = moose.vec('/model/chem/psdMesh/adaptCa') chemCa = moose.vec('/model/chem/psdMesh/PSD/Ca') assert (len(adaptCa) == pdc) assert (len(chemCa) == pdc) for i in range(pdc): path = '/model/elec/spine_head_14_' + str(i + 1) + '/NMDA_Ca_conc' elecCa = moose.element(path) moose.connect(elecCa, 'concOut', adaptCa[i], 'input', 'Single') moose.connect(adaptCa, 'outputSrc', chemCa, 'setConc', 'OneToOne') adaptCa.inputOffset = 0.0 # adaptCa.outputOffset = 80e-6 # 80 nM offset in chem. adaptCa.scale = 1e-5 # 520 to 0.0052 mM
def makeNeuroMeshModel(): diffLength = 10e-6 # But we only want diffusion over part of the model. numSyn = 13 elec = loadElec() synInput = moose.SpikeGen('/model/elec/synInput') synInput.threshold = -1.0 synInput.edgeTriggered = 0 synInput.Vm(0) synInput.refractT = 47e-3 for i in range(numSyn): name = '/model/elec/spine_head_14_' + str(i + 1) r = moose.element(name + '/glu') r.synapse.num = 1 syn = moose.element(r.path + '/synapse') moose.connect(synInput, 'spikeOut', syn, 'addSpike', 'Single') syn.weight = 0.2 * i * (numSyn - 1 - i) syn.delay = i * 1.0e-3 loadChem(diffLength) neuroCompt = moose.element('/model/chem/dend') neuroCompt.diffLength = diffLength neuroCompt.cellPortion(elec, '/model/elec/#') for x in moose.wildcardFind('/model/chem/##[ISA=PoolBase]'): if (x.diffConst > 0): x.diffConst = 1e-11 for x in moose.wildcardFind('/model/chem/##/Ca'): x.diffConst = 1e-10 # Put in dend solvers ns = neuroCompt.numSegments ndc = neuroCompt.numDiffCompts print('ns = ', ns, ', ndc = ', ndc) assert (neuroCompt.numDiffCompts == neuroCompt.mesh.num) assert (ns == 36) # dend, 5x (shaft+head) assert (ndc == 278) nmksolve = moose.Ksolve('/model/chem/dend/ksolve') nmdsolve = moose.Dsolve('/model/chem/dend/dsolve') nmstoich = moose.Stoich('/model/chem/dend/stoich') nmstoich.compartment = neuroCompt nmstoich.ksolve = nmksolve nmstoich.dsolve = nmdsolve nmstoich.path = "/model/chem/dend/##" print('done setting path, numPools = ', nmdsolve.numPools) assert (nmdsolve.numPools == 1) # oddly, numLocalFields does not work. ca = moose.element('/model/chem/dend/DEND/Ca') assert (ca.numData == ndc) # Put in spine solvers. Note that these get info from the neuroCompt spineCompt = moose.element('/model/chem/spine') sdc = spineCompt.mesh.num print('sdc = ', sdc) assert (sdc == 13) smksolve = moose.Ksolve('/model/chem/spine/ksolve') smdsolve = moose.Dsolve('/model/chem/spine/dsolve') smstoich = moose.Stoich('/model/chem/spine/stoich') smstoich.compartment = spineCompt smstoich.ksolve = smksolve smstoich.dsolve = smdsolve smstoich.path = "/model/chem/spine/##" assert (smstoich.numAllPools == 36) # Put in PSD solvers. Note that these get info from the neuroCompt psdCompt = moose.element('/model/chem/psd') pdc = psdCompt.mesh.num assert (pdc == 13) pmksolve = moose.Ksolve('/model/chem/psd/ksolve') pmdsolve = moose.Dsolve('/model/chem/psd/dsolve') pmstoich = moose.Stoich('/model/chem/psd/stoich') pmstoich.compartment = psdCompt pmstoich.ksolve = pmksolve pmstoich.dsolve = pmdsolve pmstoich.path = "/model/chem/psd/##" print('numAllPools = ', pmstoich.numAllPools) assert (pmstoich.numAllPools == 56) foo = moose.element('/model/chem/psd/Ca') bar = moose.element('/model/chem/psd/I1_p') print('PSD: numfoo = ', foo.numData, 'numbar = ', bar.numData) print('PSD: numAllVoxels = ', pmksolve.numAllVoxels) # Put in junctions between diffusion solvers nmdsolve.buildNeuroMeshJunctions(smdsolve, pmdsolve) """ CaNpsd = moose.vec( '/model/chem/psdMesh/PSD/PP1_PSD/CaN' ) print 'numCaN in PSD = ', CaNpsd.nInit, ', vol = ', CaNpsd.volume CaNspine = moose.vec( '/model/chem/spine/SPINE/CaN_BULK/CaN' ) print 'numCaN in spine = ', CaNspine.nInit, ', vol = ', CaNspine.volume """ # set up adaptors aCa = moose.Adaptor('/model/chem/psd/adaptCa', pdc) adaptCa = moose.vec('/model/chem/psd/adaptCa') chemCa = moose.vec('/model/chem/psd/Ca') print('aCa = ', aCa, ' foo = ', foo, "len( ChemCa ) = ", len(chemCa), ", numData = ", chemCa.numData) assert (len(adaptCa) == pdc) assert (len(chemCa) == pdc) for i in range(pdc): path = '/model/elec/spine_head_14_' + str(i + 1) + '/NMDA_Ca_conc' elecCa = moose.element(path) moose.connect(elecCa, 'concOut', adaptCa[i], 'input', 'Single') moose.connect(adaptCa, 'output', chemCa, 'setConc', 'OneToOne') adaptCa[i].inputOffset = 0.0 # adaptCa[i].outputOffset = 0.00008 # 80 nM offset in chem. adaptCa[i].scale = 1e-5 # 520 to 0.0052 mM #print adaptCa.outputOffset #print adaptCa.scale """ """ """
def _buildAdaptor( self, meshName, elecRelPath, elecField, \ chemRelPath, chemField, isElecToChem, offset, scale ): #print "offset = ", offset, ", scale = ", scale mesh = moose.element('/model/chem/' + meshName) #elecComptList = mesh.elecComptList if elecRelPath == 'spine': elecComptList = moose.vec(mesh.elecComptList[0].path + '/../spine') else: elecComptList = mesh.elecComptList ''' for i in elecComptList: print i.diameter print len( elecComptList[0] ) print elecComptList[0][0].parent.path print "--------------------------------------" spine = moose.vec( elecComptList[0].path + '/../spine' ) for i in spine: print i.headDiameter moose.le( elecComptList[0][0].parent ) ''' if len(elecComptList) == 0: raise BuildError( \ "buildAdaptor: no elec compts in elecComptList on: " + \ mesh.path ) startVoxelInCompt = mesh.startVoxelInCompt endVoxelInCompt = mesh.endVoxelInCompt capField = elecField[0].capitalize() + elecField[1:] capChemField = chemField[0].capitalize() + chemField[1:] chemPath = mesh.path + '/' + chemRelPath if not (moose.exists(chemPath)): raise BuildError( \ "Error: buildAdaptor: no chem obj in " + chemPath ) chemObj = moose.element(chemPath) assert (chemObj.numData >= len(elecComptList)) adName = '/adapt' for i in range(1, len(elecRelPath)): if (elecRelPath[-i] == '/'): adName += elecRelPath[1 - i] break ad = moose.Adaptor(chemObj.path + adName, len(elecComptList)) #print 'building ', len( elecComptList ), 'adaptors ', adName, ' for: ', mesh.name, elecRelPath, elecField, chemRelPath av = ad.vec chemVec = moose.element(mesh.path + '/' + chemRelPath).vec for i in zip(elecComptList, startVoxelInCompt, endVoxelInCompt, av): i[3].inputOffset = 0.0 i[3].outputOffset = offset i[3].scale = scale if elecRelPath == 'spine': elObj = i[0] else: ePath = i[0].path + '/' + elecRelPath if not (moose.exists(ePath)): raise BuildError( \ "Error: buildAdaptor: no elec obj in " + ePath ) elObj = moose.element(i[0].path + '/' + elecRelPath) if (isElecToChem): elecFieldSrc = 'get' + capField chemFieldDest = 'set' + capChemField #print ePath, elecFieldSrc, scale moose.connect(i[3], 'requestOut', elObj, elecFieldSrc) for j in range(i[1], i[2]): moose.connect(i[3], 'output', chemVec[j], chemFieldDest) else: chemFieldSrc = 'get' + capChemField elecFieldDest = 'set' + capField for j in range(i[1], i[2]): moose.connect(i[3], 'requestOut', chemVec[j], chemFieldSrc) msg = moose.connect(i[3], 'output', elObj, elecFieldDest)
def main(): p = moose.Pool('/ca') a = moose.Adaptor('/a') moose.connect(a, 'requestField', p, 'getConc')
def makeNeuroMeshModel(): diffLength = 6e-6 # Aim for 2 soma compartments. elec = loadElec() loadChem(diffLength) neuroCompt = moose.element('/model/chem/dend') neuroCompt.diffLength = diffLength neuroCompt.cellPortion(elec, '/model/elec/#') for x in moose.wildcardFind('/model/chem/##[ISA=PoolBase]'): if (x.diffConst > 0): x.diffConst = 1e-11 for x in moose.wildcardFind('/model/chem/##/Ca'): x.diffConst = 1e-10 # Put in dend solvers ns = neuroCompt.numSegments ndc = neuroCompt.numDiffCompts print(('ns = ', ns, ', ndc = ', ndc)) assert (neuroCompt.numDiffCompts == neuroCompt.mesh.num) assert (ns == 1) # soma/dend only assert (ndc == 2) # split into 2. nmksolve = moose.Ksolve('/model/chem/dend/ksolve') nmdsolve = moose.Dsolve('/model/chem/dend/dsolve') nmstoich = moose.Stoich('/model/chem/dend/stoich') nmstoich.compartment = neuroCompt nmstoich.ksolve = nmksolve nmstoich.dsolve = nmdsolve nmstoich.path = "/model/chem/dend/##" print(('done setting path, numPools = ', nmdsolve.numPools)) assert (nmdsolve.numPools == 1) assert (nmdsolve.numAllVoxels == 2) assert (nmstoich.numAllPools == 1) # oddly, numLocalFields does not work. ca = moose.element('/model/chem/dend/DEND/Ca') assert (ca.numData == ndc) # Put in spine solvers. Note that these get info from the neuroCompt spineCompt = moose.element('/model/chem/spine') sdc = spineCompt.mesh.num print(('sdc = ', sdc)) assert (sdc == 1) smksolve = moose.Ksolve('/model/chem/spine/ksolve') smdsolve = moose.Dsolve('/model/chem/spine/dsolve') smstoich = moose.Stoich('/model/chem/spine/stoich') smstoich.compartment = spineCompt smstoich.ksolve = smksolve smstoich.dsolve = smdsolve smstoich.path = "/model/chem/spine/##" assert (smstoich.numAllPools == 3) assert (smdsolve.numPools == 3) assert (smdsolve.numAllVoxels == 1) # Put in PSD solvers. Note that these get info from the neuroCompt psdCompt = moose.element('/model/chem/psd') pdc = psdCompt.mesh.num assert (pdc == 1) pmksolve = moose.Ksolve('/model/chem/psd/ksolve') pmdsolve = moose.Dsolve('/model/chem/psd/dsolve') pmstoich = moose.Stoich('/model/chem/psd/stoich') pmstoich.compartment = psdCompt pmstoich.ksolve = pmksolve pmstoich.dsolve = pmdsolve pmstoich.path = "/model/chem/psd/##" assert (pmstoich.numAllPools == 3) assert (pmdsolve.numPools == 3) assert (pmdsolve.numAllVoxels == 1) foo = moose.element('/model/chem/psd/Ca') print(('PSD: numfoo = ', foo.numData)) print(('PSD: numAllVoxels = ', pmksolve.numAllVoxels)) # Put in junctions between the diffusion solvers nmdsolve.buildNeuroMeshJunctions(smdsolve, pmdsolve) # set up adaptors aCa = moose.Adaptor('/model/chem/dend/DEND/adaptCa', ndc) adaptCa = moose.vec('/model/chem/dend/DEND/adaptCa') chemCa = moose.vec('/model/chem/dend/DEND/Ca') print(('aCa = ', aCa, ' foo = ', foo, "len( ChemCa ) = ", len(chemCa), ", numData = ", chemCa.numData, "len( adaptCa ) = ", len(adaptCa))) assert (len(adaptCa) == ndc) assert (len(chemCa) == ndc) path = '/model/elec/soma/Ca_conc' elecCa = moose.element(path) print("==========") print(elecCa) print(adaptCa) print(chemCa) moose.connect(elecCa, 'concOut', adaptCa[0], 'input', 'Single') moose.connect(adaptCa, 'output', chemCa, 'setConc', 'OneToOne') adaptCa.inputOffset = 0.0 # adaptCa.outputOffset = 0.00008 # 80 nM offset in chem. adaptCa.scale = 1e-3 # 520 to 0.0052 mM
def makeModel(): # create container for model model = moose.Neutral('model') compartment = moose.CubeMesh('/model/compartment') compartment.volume = 1e-15 # the mesh is created automatically by the compartment mesh = moose.element('/model/compartment/mesh') # create molecules and reactions a = moose.Pool('/model/compartment/a') b = moose.Pool('/model/compartment/b') c = moose.Pool('/model/compartment/c') enz1 = moose.Enz('/model/compartment/b/enz1') enz2 = moose.Enz('/model/compartment/c/enz2') cplx1 = moose.Pool('/model/compartment/b/enz1/cplx') cplx2 = moose.Pool('/model/compartment/c/enz2/cplx') reac = moose.Reac('/model/compartment/reac') # Connect them up throught adaptors. moose.Neutral('/model/adaptor') adapt1 = moose.Adaptor('/model/adaptor/a1') adapt1.setField('inputOffset', 0) adapt1.setField('scale', 1) moose.connect(adapt1, 'requestField', a, 'getConc') moose.connect(adapt1, 'output', b, 'setConc') # connect them up for reactions moose.connect(enz1, 'sub', a, 'reac') moose.connect(enz1, 'prd', b, 'reac') moose.connect(enz1, 'enz', b, 'reac') moose.connect(enz1, 'cplx', cplx1, 'reac') moose.connect(enz2, 'sub', b, 'reac') moose.connect(enz2, 'prd', a, 'reac') moose.connect(enz2, 'enz', c, 'reac') moose.connect(enz2, 'cplx', cplx2, 'reac') moose.connect(reac, 'sub', a, 'reac') moose.connect(reac, 'prd', b, 'reac') # connect them up to the compartment for volumes for x in (a, b, c, cplx1, cplx2): moose.connect(x, 'mesh', mesh, 'mesh') # Assign parameters a.concInit = 1 b.concInit = 0 c.concInit = 0.01 enz1.kcat = 0.4 enz1.Km = 4 enz2.kcat = 0.6 enz2.Km = 0.01 reac.Kf = 0.001 reac.Kb = 0.01 # Create the output tables graphs = moose.Neutral('/model/graphs') outputA = moose.Table('/model/graphs/concA') outputB = moose.Table('/model/graphs/concB') # connect up the tables moose.connect(outputA, 'requestData', a, 'get_conc') moose.connect(outputB, 'requestData', b, 'get_conc') # Schedule the whole lot moose.setClock(4, 0.001) # for the computational objects moose.setClock(8, 1.0) # for the plots moose.setClock(9, 10) # for the plots # The wildcard uses # for single level, and ## for recursive. moose.useClock(4, '/model/compartment/##', 'process') moose.useClock(8, '/model/graphs/#', 'process') moose.useClock(8, '/model/adaptor/#', 'process')