def plasticity(synchan, plas_params):
comp = synchan.parent
for child in comp.children:
if child.className == 'CaConc' or child.className == 'ZombieCaConc':
cal = child
CaMSG = 'concOut'
break
elif child.className == 'DifShell':
cal = child
CaMSG = 'concentrationOut'
break
else:
print('Could not find calcium objects')
return
shname = synchan.path + '/SH'
sh = moose.element(shname)
log.debug("{} {} {}", synchan.path, sh.synapse[0], cal.path)
plasname = comp.path + '/' + NAME_PLAS
plas = moose.Func(plasname)
#FIRST: calculate the amount of plasticity
#y is input plasticity trigger (e.g. Vm or Ca)
moose.connect(cal, CaMSG, plas, 'yIn')
#x is the high threshold, z is the low threshold
#This gives parabolic shape to plasticity between the low and high threshold
#highfac and lowfac scale the weight change (set in SynParams.py)
highfac = plas_params.highFactor
lowfac = plas_params.lowFactor
expression = highfac + "*(y>x)*(y-x)+(y>z)*(x>y)*(y-z)*(x-y)*" + lowfac
plas.expr = expression
#Must define plasticity expression first, else these next assignments do nothing
plas.x = plas_params.highThreshold
plas.z = plas_params.lowThreshold
#SECOND: accumulate all the changes, as percent increase or decrease
plasCum = moose.Func(plasname + NAME_CUM)
#need input from the plasticity thresholding function to y
moose.connect(plas, 'valueOut', plasCum, 'xIn')
moose.connect(plasCum, 'valueOut', plasCum, 'yIn')
plasCum.expr = "x+y*z"
plasCum.z = sh.synapse[0].weight
plasCum.y = 1.0
moose.connect(plasCum, 'valueOut', sh.synapse[0], 'setWeight')
return {'cum': plasCum, 'plas': plas, 'syn': synchan}
def makeReacs():
# Parameters
volume = 1e-15
CaInitConc = 60e-6
NA = 6.022e23
tauI = 1
tauG = 0.1
model = moose.Neutral('/cells')
compartment = moose.CubeMesh('/cells/compartment')
compartment.volume = volume
# Make pools
Ca = moose.BufPool('/cells/compartment/Ca')
tgtCa = moose.BufPool('/cells/compartment/tgtCa')
m = moose.Pool('/cells/compartment/m')
chan = moose.Pool('/cells/compartment/chan')
# Make Funcs
f1 = moose.Func('/cells/compartment/f1')
f2 = moose.Func('/cells/compartment/f2')
# connect up
moose.connect(f1, 'valueOut', m, 'increment')
moose.connect(f2, 'valueOut', chan, 'increment')
moose.connect(Ca, 'nOut', f1, 'xIn')
moose.connect(tgtCa, 'nOut', f1, 'yIn')
moose.connect(m, 'nOut', f2, 'xIn')
moose.connect(chan, 'nOut', f2, 'yIn')
# Set params
Ca.concInit = CaInitConc
tgtCa.concInit = tgtCaInitConc
m.concInit = 0.0
chan.concInit = 0.0
volscale = 1.0
f1.expr = str(volscale / tauI) + " * (x-y)"
f2.expr = str(volscale / tauG) + " * (x-y)"
#Plotting
channelPlot = makePlot('channelConc', chan, 'Conc', 18)
mPlot = makePlot('mConc', m, 'Conc', 18)
caPlot = makePlot('Ca', Ca, 'Conc', 18)
targetPlot = makePlot('tgtCa', tgtCa, 'Conc', 18)
return (channelPlot, mPlot, caPlot)
def chirp(gen_name="chirp",
amp=1,
f0=1,
f1=50,
T=0.8,
start=0.1,
end=0.5,
simdt=10E-5,
phase=0,
amp_offset=0):
chirper = moose.element('/chirpgen') if moose.exists(
'/chirpgen') else moose.Neutral('/chirpgen')
func_1 = moose.Func(chirper.path + '/' + gen_name)
func_1.mode = 3
func_1.expr = '{A}*cos(2*pi*({f1}-{f0})/{T}*x^2 + 2*pi*{f1}*x + {p})+{o}'.format(
f0=f0, f1=f1, T=T, A=amp, p=phase, o=amp_offset)
input = moose.StimulusTable(chirper.path + '/xtab')
xarr = np.arange(start, end, simdt)
input.vector = xarr
input.startTime = 0.0
input.stepPosition = xarr[0]
input.stopTime = xarr[-1] - xarr[0]
moose.connect(input, 'output', func_1, 'xIn')
moose.useClock(0, '%s/##[TYPE=StimulusTable]' % (chirper.path), 'process')
moose.useClock(0, '%s/##[TYPE=Func]' % (chirper.path), 'process')
return func_1
def desensitization(synchan, SynParams):
'''
Key equations to be implemented
dep.expression = "x = x*"+str(dep_constant)+"y*"+str(SynParams.dep_per_spike)
weight.expression = "weight*1/(1+x)/simdt"
facsynchan uses: (1+fac)/(1+dep)/simdt
x above is dep, and we didn't have fac, hence 1/(1+x)
weight is the current synaptic weight
'''
sh = moose.element(synchan).children[0]
deppath = synchan.path + '/dep'
weightpath = synchan.path + '/weight'
dep = moose.Func(deppath)
weight = moose.Func(weightpath)
help_dep = moose.Func(deppath + "/help")
activation = moose.Func(deppath + "/activation")
activation_help = moose.Func(deppath + "/activation/help")
y = moose.Func(deppath + "/y")
condition = moose.Func(deppath + "/condition")
help_dep.tick = synchan.tick
dep.tick = synchan.tick
weight.tick = synchan.tick
activation.tick = synchan.tick
activation_help.tick = synchan.tick
y.tick = synchan.tick
condition.tick = synchan.tick
#x*exp(dt/tau)+y*dep_per_spike, where x is output of self!
dep_const = np.exp(-synchan.dt / SynParams.dep_tau)
dep.expr = "x*" + str(dep_const) + "+y*" + str(SynParams.dep_per_spike)
help_dep.expr = "x"
weight.expr = "z*(1./(1+x))/" + str(synchan.dt)
activation.expr = "x+y"
activation_help.expr = "x"
y.expr = "x"
condition.expr = "x&&(x==y)"
moose.connect(dep, "valueOut", weight, "xIn")
moose.connect(condition, 'valueOut', dep, 'yIn')
moose.connect(condition, 'valueOut', weight, 'zIn')
moose.connect(condition, 'valueOut', activation, 'zIn')
moose.connect(sh, 'activationOut', activation, 'yIn')
moose.connect(sh, 'activationOut', y, 'xIn')
moose.connect(activation, "valueOut", condition, "xIn")
moose.connect(y, "valueOut", condition, "yIn")
moose.connect(condition, "valueOut", y, "zIn")
moose.connect(activation, "valueOut", activation_help, "xIn")
moose.connect(activation_help, "valueOut", activation, "xIn")
moose.connect(dep, 'valueOut', help_dep, 'xIn')
moose.connect(help_dep, 'valueOut', dep, 'xIn')
moose.connect(weight, "valueOut", synchan, 'activation')
moose.showmsg(synchan)
return condition, activation
def desensitization(synchan, SynParams):
sh = moose.element(synchan).children[0]
deppath = synchan.path + '/dep'
weightpath = synchan.path + '/weight'
dep = moose.Func(deppath)
weight = moose.Func(weightpath)
help_dep = moose.Func(deppath + "/help")
activation = moose.Func(deppath + "/activation")
activation_help = moose.Func(deppath + "/activation/help")
y = moose.Func(deppath + "/y")
condition = moose.Func(deppath + "/condition")
help_dep.tick = synchan.tick
dep.tick = synchan.tick
weight.tick = synchan.tick
activation.tick = synchan.tick
activation_help.tick = synchan.tick
y.tick = synchan.tick
condition.tick = synchan.tick
dep_const = np.exp(-synchan.dt / SynParams.dep_tau)
dep.expr = "x*" + str(dep_const) + "+y*" + str(SynParams.dep_per_spike)
help_dep.expr = "x"
weight.expr = "z*(1./(1+x))/" + str(synchan.dt)
activation.expr = "x+y"
activation_help.expr = "x"
y.expr = "x"
condition.expr = "x&&(x==y)"
moose.connect(dep, "valueOut", weight, "xIn")
moose.connect(condition, 'valueOut', dep, 'yIn')
moose.connect(condition, 'valueOut', weight, 'zIn')
moose.connect(condition, 'valueOut', activation, 'zIn')
moose.connect(sh, 'activationOut', activation, 'yIn')
moose.connect(sh, 'activationOut', y, 'xIn')
moose.connect(activation, "valueOut", condition, "xIn")
moose.connect(y, "valueOut", condition, "yIn")
moose.connect(condition, "valueOut", y, "zIn")
moose.connect(activation, "valueOut", activation_help, "xIn")
moose.connect(activation_help, "valueOut", activation, "xIn")
moose.connect(dep, 'valueOut', help_dep, 'xIn')
moose.connect(help_dep, 'valueOut', dep, 'xIn')
moose.connect(weight, "valueOut", synchan, 'activation')
moose.showmsg(synchan)
return condition, activation
def __init__(self, *args):
moose.Compartment.__init__(self, *args)
self.spikegen = moose.SpikeGen('%s/spike' % (self.path))
self.spikegen.edgeTriggered = 1 # This ensures that spike is generated only on leading edge.
self.dynamics = moose.Func('%s/dynamics' % (self.path))
self.initVm = 0.0
self.Rm = 10e6
self.Ra = 1e4
self.Cm = 100e-9
self.Em = 0 #-65e-3
self.initVm = 0 #self.Em
# Note that the result is dependent on exact order of
# execution of SpikeGen and Func. If Func gets executed first
# SpikeGen will never cross threshold.
self.dynamics.expr = 'x >= y? z: x'
moose.connect(self, 'VmOut', self.dynamics, 'xIn')
moose.connect(self.dynamics, 'valueOut', self, 'setVm')
moose.connect(self, 'VmOut', self.spikegen, 'Vm')
def test_func_nosim():
"""Create a Func object for computing function values without running
a simulations."""
# func_0 demonstrates multivariable function
lib = moose.Neutral('/library')
func_0 = moose.Func('%s/func_0' % (lib.path))
func_0.mode = 1
num = 5
expr = 'avg('
for ii in range(num - 1):
expr += 'x_%d, ' % (ii)
expr += 'x_%d)' % (num - 1)
print(('Expression:', expr))
func_0.expr = expr
for ii in range(num):
var = 'x_%d' % (ii)
print(('Setting:', var, '=', func_0.var[var]))
func_0.var[var] = float(ii)
print(('Expression:', func_0.expr))
print('Variables after assignment:')
for v in func_0.vars:
print((' %s = %g' % (v, func_0.var[v])))
print(('value %g\n' % (func_0.value)))
def test_func():
"""This function creates a Func object evaluating a function of a
single variable. It both shows direct evaluation without running a
simulation and a case where the x variable comes from another
source.
"""
model = moose.Neutral('/model')
data = moose.Neutral('/data')
func_1 = moose.Func('%s/func_1' % (model.path))
func_1.mode = 3 # mode = 1 : value, mode = 2 : derivative
# Expression is that for tau_m in Traub's NaF channel model
func_1.expr = 'x < -30e-3? 1.0e-3 * (0.025 + 0.14 * exp((x + 30.0e-3) / 10.0e-3)): 1.0e-3 * (0.02 + 0.145 * exp(( - x - 30.0e-3) / 10.0e-3))'
# First we display the use of Func as a standalone funculator
xarr = np.linspace(-120e-3, 40e-3, 1000)
values = []
deriv = []
for x in xarr:
func_1.var['x'] = x
values.append(func_1.value)
deriv.append(func_1.derivative)
pylab.plot(xarr, values, 'g-', label='f(no-sim)')
pylab.plot(xarr, np.array(deriv) / 1000, 'k-.', label="1e-3 * f'(no-sim)")
simdt = xarr[1] - xarr[0]
input = moose.StimulusTable('%s/xtab' % (model.path))
input.vector = xarr
input.startTime = 0.0
input.stepPosition = xarr[0]
input.stopTime = xarr[-1] - xarr[0]
print((input.startTime, input.stopTime))
moose.connect(input, 'output', func_1, 'xIn')
x_tab = moose.Table('/data/xtab')
moose.connect(x_tab, 'requestOut', input, 'getOutputValue')
y_tab = moose.Table('%s/y' % (data.path))
moose.connect(y_tab, 'requestOut', func_1, 'getValue')
yprime_tab = moose.Table('%s/yprime' % (data.path))
moose.connect(yprime_tab, 'requestOut', func_1, 'getDerivative')
func_1.mode = 3 # This forces both f ad f' to be computed and sent out
moose.setClock(0, simdt)
moose.setClock(1, simdt)
moose.setClock(2, simdt)
moose.setClock(3, simdt)
moose.useClock(0, '%s/##[TYPE=StimulusTable]' % (model.path), 'process')
moose.useClock(1, '%s/##[TYPE=Func]' % (model.path), 'process')
moose.useClock(2, '%s/##[TYPE=DiffAmp]' % (model.path), 'process')
moose.useClock(3, '%s/##' % (data.path), 'process')
moose.reinit()
t = xarr[-1] - xarr[0]
print(('Run for', t))
moose.start(t)
y = np.asarray(y_tab.vector)
yp = np.asarray(yprime_tab.vector)
pylab.plot(x_tab.vector, y, 'r-.', label='f(x)')
pylab.plot(x_tab.vector, yp / 1000, 'b--', label="1e-3 * f'(x)")
pylab.legend()
pylab.show()
def printRecursiveTree(elementid, level):
""" Recursive helper function for printCellTree,
specify depth/'level' to recurse and print subelements under MOOSE 'elementid'. """
spacefill = " " * level
element = moose.Neutral(elementid)
for childid in element.children:
childobj = moose.Neutral(childid)
classname = childobj.className
if classname in ["SynChan", "KinSynChan"]:
childobj = moose.SynChan(childid)
print(
spacefill + "|--",
childobj.name,
childobj.className,
"Gbar=",
childobj.Gbar,
"numSynapses=",
childobj.numSynapses,
)
return # Have yet to figure out the children of SynChan, currently not going deeper
elif classname in ["HHChannel", "HHChannel2D"]:
childobj = moose.HHChannel(childid)
print(
spacefill + "|--",
childobj.name,
childobj.className,
"Gbar=",
childobj.Gbar,
"Ek=",
childobj.Ek,
)
elif classname in ["CaConc"]:
childobj = moose.CaConc(childid)
print(
spacefill + "|--",
childobj.name,
childobj.className,
"thick=",
childobj.thick,
"B=",
childobj.B,
)
elif classname in ["Mg_block"]:
childobj = moose.Mg_block(childid)
print(
spacefill + "|--",
childobj.name,
childobj.className,
"CMg",
childobj.CMg,
"KMg_A",
childobj.KMg_A,
"KMg_B",
childobj.KMg_B,
)
elif classname in ["SpikeGen"]:
childobj = moose.SpikeGen(childid)
print(
spacefill + "|--",
childobj.name,
childobj.className,
"threshold",
childobj.threshold,
)
elif classname in ["Func"]:
childobj = moose.Func(childid)
print(
spacefill + "|--",
childobj.name,
childobj.className,
"expr",
childobj.expr,
)
elif classname in [
"Table"
]: # Table gives segfault if printRecursiveTree is called on it
return # so go no deeper
# for inmsg in childobj.inMessages():
# print spacefill+" |---", inmsg
# for outmsg in childobj.outMessages():
# print spacefill+" |---", outmsg
if len(childobj.children) > 0:
printRecursiveTree(childid, level + 1)
