from __future__ import print_function, division
import os
import numpy as np
import moose
from moose_nerp.prototypes import constants, logutil
from moose_nerp.prototypes.util import distance_mapping, NamedList
from moose_nerp.prototypes.spines import NAME_NECK, NAME_HEAD
CalciumConfig = NamedList('CalciumConfig','''
shellMode
increase_mode
outershell_thickness
thickness_increase
min_thickness''')
SingleBufferParams = NamedList('SingleBufferParams','''
Name
kf
kb
D''')
SinglePumpParams = NamedList('SinglePumpParams','''
Name
Kd
''')
CellCalcium = NamedList('CellCalcium','''
CaName
Ceq
DCa
tau
''')
ShapeParams = NamedList('ShapeParams','''
OutershellThickness
ThicknessIncreaseFactor
ThicknessIncreaseMode
MinThickness
''')
log = logutil.Logger()
def shell_surface(dShell,head=False,prevd=0):
if dShell.shapeMode:
if not dShell.length:
cos_alpha = (dShell.diameter/2-prevd)/(dShell.diameter/2)
cos_alpha_beta = (dShell.diameter/2-prevd-dShell.thickness)/(dShell.diameter/2)
surfaceArea = np.pi*(dShell.diameter)*(cos_alpha-cos_alpha_beta)
else:
surfaceArea = np.pi*dShell.diameter*dShell.thickness
else:
surfaceArea = dShell.outerArea
if head and dShell.shapeMode:
if dShell.length:
surfaceArea += dShell.outerArea
return surfaceArea
def shell_volume(dShell):
if dShell.shapeMode: #SLAB
return np.pi*(dShell.diameter/2)**2*dShell.thickness
else:
if dShell.length: #ONION Cylinder
return np.pi*dShell.length*((dShell.diameter/2)**2-(dShell.diameter/2-dShell.thickness)**2)
else:
return 4./3.*np.pi*((dShell.diameter/2)**3-(dShell.diameter/2-dShell.thickness)**3)
def get_path(s):
l = len(s.split('/')[-1])
return s[:-l]
def difshell_geometry(comp, shell_params):
res = []
if shell_params.shellMode == 0:
multiplier = 2.
new_rad = comp.diameter/2.
else:
multiplier = 1.
if comp.length:
new_rad = comp.length
else:
new_rad = comp.diameter
i = 1
new_thick = shell_params.outershell_thickness
if shell_params.increase_mode:
while new_rad > shell_params.min_thickness + new_thick:
res.append([new_rad*multiplier,new_thick])
new_rad = new_rad - new_thick
new_thick = shell_params.outershell_thickness*shell_params.thickness_increase**i
i = i+1
res.append([new_rad*multiplier,new_rad])
return res
while new_rad >shell_params.min_thickness+ new_thick:
res.append([new_rad*multiplier,new_thick])
new_rad = new_rad - new_thick
new_thick = shell_params.outershell_thickness + i*shell_params.thickness_increase*shell_params.outershell_thickness
i = i+1
res.append([new_rad*multiplier,new_rad])
return res
def strip_brackets(comp):
shellName = ''
for s in comp.path.split('[0]'):
shellName += s
return shellName
def addCaDifShell(comp,shellMode,shellDiameter,shellThickness,name,capar):
name = strip_brackets(comp)+'/'+capar.CaName+'_'+name
dif = moose.DifShell(name)
dif.Ceq = capar.Ceq
dif.D = capar.DCa
dif.valence = 2
dif.leak = 0
dif.shapeMode = shellMode
dif.thickness = shellThickness
if shellMode:
dif.diameter = comp.diameter
dif.length = shellThickness
else:
dif.length = comp.length
dif.diameter = shellDiameter
return dif
def addDifBuffer(comp,dShell,bufparams,bTotal):
name = strip_brackets(dShell)+ '_' + bufparams.Name
dbuf = moose.DifBuffer(name)
dbuf.bTot = bTotal
dbuf.kf = bufparams.kf
dbuf.kb = bufparams.kb
dbuf.D = bufparams.D
dbuf.shapeMode = dShell.shapeMode
dbuf.length = dShell.length
dbuf.diameter = dShell.diameter
dbuf.thickness = dShell.thickness
moose.connect(dShell,"concentrationOut",dbuf,"concentration")
moose.connect(dbuf,"reactionOut",dShell,"reaction")
return dbuf
def addMMPump(dShell,pumpparams,Vmax,surface):
shellName = ''
for s in dShell.path.split('[0]'):
shellName += s
pump = moose.MMPump(shellName+'_'+pumpparams.Name)
pump.Vmax = Vmax*surface
pump.Kd = pumpparams.Kd
moose.connect(pump,"PumpOut",dShell,"mmPump")
return pump
def CaProto(model):
if not model.calYN:
return
capar = model.CaPlasticityParams.CalciumParams
if not moose.exists('/library'):
lib = moose.Neutral('/library')
if not moose.exists('/library/'+capar.CaName):
concproto = moose.CaConc('/library/'+capar.CaName)
concproto.tau = capar.tau
concproto.CaBasal = capar.Ceq
concproto.ceiling = 1.
concproto.floor = 0.0
concproto.tick=-1
return moose.element('/library/'+capar.CaName)
def connectVDCC_KCa(model,comp,capool,CurrentMessage,CaOutMessage,check_list=[]):
if model.ghkYN:
ghk = moose.element(comp.path + '/ghk')
moose.connect(capool,CaOutMessage,ghk,'set_Cin')
moose.connect(ghk,'IkOut',capool,CurrentMessage)
log.debug('CONNECT GHK {.path} to Ca {.path}', ghk, capool)
#connect them to the channels
chan_list = [c for c in comp.neighbors['VmOut'] if c.className == 'HHChannel' or c.className == 'HHChannel2D']
if not check_list:
check_list=chan_list
for chan in chan_list:
if model.Channels[chan.name].calciumPermeable:
if not model.ghkYN:
# do nothing if ghkYesNo==1, since already connected the single GHK object
if chan in check_list or chan.name in check_list:
m = moose.connect(chan, 'IkOut', capool, CurrentMessage)
log.debug('channel {.path} to Ca {.path}',chan, capool)
if model.Channels[chan.name].calciumDependent:
if chan in check_list or chan.name in check_list:
m = moose.connect(capool,CaOutMessage, chan, 'concen')
log.debug('channel message {} {} {}', chan.path, comp.path, m)
def connectNMDA(comp,capool,CurrentMessage,CaOutMessage):
#nmdachans!!!
for chan in moose.element(comp).neighbors['VmOut']:
if chan.className == 'NMDAChan':
moose.connect(chan, 'ICaOut', capool, CurrentMessage)
moose.connect(capool,CaOutMessage,chan,'assignIntCa')
def addDifMachineryToComp(model,comp,Buffers,Pumps,sgh,spine):
diam_thick = difshell_geometry(comp, sgh)
BufferParams = model.CaPlasticityParams.BufferParams
PumpParams = model.CaPlasticityParams.PumpParams
difshell = []
buffers = []
prevd = 0 #important only for spherical compartments with SLABS, we might have them one day, right!?
#print('Adding DifShells to '+comp.path)
for i,(diameter,thickness) in enumerate(diam_thick): #adding shells
dShell = addCaDifShell(comp,sgh.shellMode,diameter,thickness,str(i),model.CaPlasticityParams.CalciumParams)
difshell.append(dShell)
b = []
for j,buf in enumerate(Buffers): #add buffers to shell
b.append(addDifBuffer(comp,dShell,BufferParams[buf],Buffers[buf]))
buffers.append(b)
if i: #diffusion between neighboring shells
#connect shells
moose.connect(difshell[i-1],"outerDifSourceOut",difshell[i],"fluxFromOut")
moose.connect(difshell[i],"innerDifSourceOut",difshell[i-1],"fluxFromIn")
#connect buffers
for j,b in enumerate(buffers[i]): #diffusion between buffers
moose.connect(buffers[i-1][j],"outerDifSourceOut",buffers[i][j],"fluxFromOut")
moose.connect(buffers[i][j],"innerDifSourceOut",buffers[i-1][j],"fluxFromIn")
#pumps
#There is a surface correction for the pumps for the PSD
if not i:
connectNMDA(comp,dShell,'influx','concentrationOut')
if comp.name.endswith(NAME_HEAD) and i == 0:
head = True
else:
head = False
surface = shell_surface(dShell,head=head,prevd=prevd)
if spine and comp.name.endswith(NAME_HEAD):
try:
check_list = list(model.SpineParams.spineChanList[i])
connectVDCC_KCa(model,comp,dShell,'influx','concentrationOut',check_list)
except IndexError:
pass
else:
if not i:
connectVDCC_KCa(model,comp,dShell,'influx','concentrationOut')
if dShell.shapeMode == 1:
addPumps(dShell,PumpParams,Pumps,surface)
else:
if i == 0:
addPumps(dShell,PumpParams,Pumps,surface)
prevd += dShell.thickness
return difshell
def addPumps(dShell,PumpParams,Pumps,surface):
leak = 0
for pump in Pumps:
Km = PumpParams[pump]
p = addMMPump(dShell,PumpParams[pump],Pumps[pump],surface)
leak += p.Vmax*dShell.Ceq/shell_volume(dShell)/(dShell.Ceq+p.Kd)
dShell.leak = leak
def addCaPool(model,OutershellThickness,BufCapacity,comp,caproto,tau=None,tauScale=None):
#create the calcium pools in each compartment
capool = moose.copy(caproto, comp, caproto.name)[0]
capool.thick = OutershellThickness
capool.diameter = comp.diameter
capool.length = comp.length
radius = comp.diameter/2.
if capool.thick > radius:
capool.thick = radius
if capool.length:
vol = np.pi * comp.length * (radius**2 - (radius-capool.thick)**2)
else:
vol = 4./3.*np.pi*(radius**3-(radius-capool.thick)**3)
if tau is not None:
capool.tau = tau#*np.pi*comp.diameter*comp.length *0.125e10 #/(np.pi*comp.length*(comp.diameter/2)**2) #
if tauScale is not None:
if tauScale == 'SurfaceArea':
capool.tau = tau * (np.pi * comp.diameter * comp.length) / 8.478e-11 # normalize to primdend surface area
elif tauScale == 'Volume':
capool.tau = tau / vol
elif tauScale == 'SVR': #surface to volume ratio
capool.tau = tau / (np.pi * comp.diameter * comp.length)/vol
capool.B = 1. / (constants.Faraday*vol*2) / BufCapacity #volume correction
connectVDCC_KCa(model,comp,capool,'current','concOut')
connectNMDA(comp,capool,'current','concOut')
#print('Adding CaConc to '+capool.path)
return capool
def extract_and_add_capool(model,comp,pools):
params = model.CaPlasticityParams
shape = distance_mapping(params.ShapeConfig,comp)
OuterShellThick = shape.OutershellThickness
BufCapacity = distance_mapping(params.BufferCapacityDensity,comp)
if hasattr(params,'Taus'):
tau = distance_mapping(params.Taus,comp)
tauScale = params.tauScale
else:
tau = params.CalciumParams.tau
tauScale = None
pool = addCaPool(model,OuterShellThick,BufCapacity,comp, pools,tau=tau,tauScale=tauScale)
return pool
def extract_and_add_difshell(model, shellMode, comp,spine):
params = model.CaPlasticityParams
Pumps = {}
for pump in params.PumpVmaxDensities.keys():
Pumps[pump] = distance_mapping(params.PumpVmaxDensities[pump], comp)
Buffers = distance_mapping(params.BufferDensity,comp)
shape = distance_mapping(params.ShapeConfig,comp)
shellsparams = CalciumConfig(shellMode=shellMode,increase_mode=shape.ThicknessIncreaseMode,outershell_thickness=shape.OutershellThickness,thickness_increase=shape.ThicknessIncreaseFactor, min_thickness=shape.MinThickness)
dshells_dend = addDifMachineryToComp(model,comp,Buffers,Pumps,shellsparams,spine)
return dshells_dend
def add_calcium_to_compartment(model, shellMode, comp, pools,capool,spine):
if shellMode == -1:
capool.append(extract_and_add_capool(model,comp,pools))
dshells_dend = None
return dshells_dend
if shellMode == 0 or shellMode == 1 or shellMode == 3:
dshells_dend = extract_and_add_difshell(model, shellMode, comp,spine)
capool.extend(dshells_dend)
return dshells_dend
print('Unknown shellMode. Leaving')
return -1
def addCalcium(model,ntype):
pools = CaProto(model)
capool = []
params = model.CaPlasticityParams
for comp in moose.wildcardFind(ntype + '/#[TYPE=Compartment]'):
if NAME_NECK not in comp.name and NAME_HEAD not in comp.name: #Look for spines connected to the dendrite
shellMode = distance_mapping(params.CaShellModeDensity,comp)
dshells_dend = add_calcium_to_compartment(model, shellMode, comp, pools,capool,spine=False)
if dshells_dend == -1:
return
if model.spineYN:
spines = []
neighbors = list(comp.neighbors['raxial'])
neighbors.extend(list(comp.neighbors['axial']))
for neighbor in neighbors:
if NAME_NECK in neighbor.name:
spines.append(neighbor)
else:
'Could not find spines!!!'
for sp in spines:
shellMode = distance_mapping(params.CaShellModeDensity,moose.element(sp))
dshells_neck = add_calcium_to_compartment(model,shellMode,moose.element(sp),pools,capool,spine=True)
if dshells_neck == -1:
return
if dshells_dend and dshells_neck: #diffusion between neck and dendrite
moose.connect(dshells_neck[-1],"outerDifSourceOut",dshells_dend[0],"fluxFromOut")
moose.connect(dshells_dend[0],"innerDifSourceOut",dshells_neck[-1],"fluxFromIn")
heads = []
neighbors = list(moose.element(sp).neighbors['raxial'])
neighbors.extend(list(moose.element(sp).neighbors['axial']))
for neighbor in neighbors:
if NAME_HEAD in neighbor.name:
heads.append(neighbor)
if not heads:
'Could not find heads!!!'
for head in heads:
shellMode = distance_mapping(params.CaShellModeDensity,moose.element(head))
dshells_head = add_calcium_to_compartment(model,shellMode,moose.element(head),pools,capool,spine=True)
if dshells_head == -1:
return
if dshells_head and dshells_neck: #diffusion between neck and dendrite
moose.connect(dshells_head[-1],"outerDifSourceOut",dshells_neck[0],"fluxFromOut")
moose.connect(dshells_neck[0],"innerDifSourceOut",dshells_head[-1],"fluxFromIn")
return capool
def fix_calcium(neurontypes, model):
"""kluge to fix buffer capacity in CaPool
Initiating hsolve calculates CaConc.B from thickness, length,
diameter; ignores buffer capacity.
"""
comptype = 'ZombieCompartment'
cacomptype = 'ZombieCaConc'
ca_elem_suffix = model.CaPlasticityParams.CalciumParams.CaName
buffer_capacity_density = model.CaPlasticityParams.BufferCapacityDensity
log.info('Fixing calcium buffer capacity for {} elements'.format(comptype))
for ntype in neurontypes:
for comp in moose.wildcardFind('{}/#[TYPE={}]'.format(ntype, comptype)):
cacomps = [m for m in moose.element(comp).children if m.className==cacomptype]
for cacomp in cacomps:
buf_capacity = distance_mapping(buffer_capacity_density, comp)
radius = cacomp.diameter/2.
if cacomp.thick > radius:
cacomp.thick = radius
if cacomp.length:
vol = np.pi * cacomp.length * (radius**2 - (radius-cacomp.thick)**2)
else:
vol = 4. / 3. * np.pi * ((cacomp.diameter / 2) ** 3 - (cacomp.diameter / 2 - cacomp.thick) ** 3)
cacomp.B = 1. / (constants.Faraday * vol * 2) / buf_capacity # volume correction
# print(cacomp.path, cacomp.B, cacomp.className)