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')
