def setCompartmentSolver(modelRoot,solver): compts = moose.wildcardFind(modelRoot+'/##[ISA=ChemCompt]') for compt in compts: if ( solver == 'gsl' ) or (solver == 'Runge Kutta'): ksolve = moose.Ksolve( compt.path+'/ksolve' ) if ( solver == 'gssa' ) or (solver == 'Gillespie'): ksolve = moose.Gsolve( compt.path+'/gsolve' ) if ( solver != 'ee' ): stoich = moose.Stoich( compt.path+'/stoich' ) stoich.compartment = compt stoich.ksolve = ksolve if moose.exists(compt.path): stoich.path = compt.path+"/##" stoichList = moose.wildcardFind(modelRoot+'/##[ISA=Stoich]') if len( stoichList ) == 2: stoichList[1].buildXreacs( stoichList[0] ) if len( stoichList ) == 3: stoichList[1].buildXreacs (stoichList [0]) stoichList[1].buildXreacs (stoichList [2]) for i in stoichList: i.filterXreacs() for x in moose.wildcardFind( modelRoot+'/data/graph#/#' ): x.tick = 18
def read_prototype(celltype, cdict):
"""Read the cell prototype file for the specified class. The
channel properties are updated using values in cdict."""
filename = '%s/%s.p' % (config.modelSettings.protodir, celltype)
logger.debug('Reading prototype file %s' % (filename))
adjust_chanlib(cdict)
cellpath = '%s/%s' % (config.modelSettings.libpath, celltype)
if moose.exists(cellpath):
return moose.element(cellpath)
for handler in logger.handlers:
handler.flush()
proto = moose.loadModel(filename, cellpath)
# If prototype files do not have absolute compartment positions,
# set the compartment postions to origin. This will avoid
# incorrect assignemnt of position when the x/y/z values in
# prototype file is just to for setting the compartment length.
if not config.modelSettings.morph_has_postion:
for comp in moose.wildcardFind('%s/#[TYPE=Compartment]' % (proto.path)):
comp.x = 0.0
comp.y = 0.0
comp.z = 0.0
leveldict = read_keyvals('%s/%s.levels' % (config.modelSettings.protodir, celltype))
depths = read_keyvals('%s/%s.depths' % (config.modelSettings.protodir, celltype))
depthdict = {}
for level, depthset in list(depths.items()):
if len(depthset) != 1:
raise Exception('Depth set must have only one entry.')
depthdict[level] = depthset.pop()
assign_depths(proto, depthdict, leveldict)
config.logger.debug('Read %s with %d compartments' % (celltype, len(moose.wildcardFind('%s/#[TYPE=Compartment]' % (proto.path)))))
return proto
def spinetabs(model,neuron,comps='all'):
if not moose.exists(DATA_NAME):
moose.Neutral(DATA_NAME)
#creates tables of calcium and vm for spines
spcatab = defaultdict(list)
spvmtab = defaultdict(list)
for typenum,neurtype in enumerate(neuron.keys()):
if type(comps)==str and comps in {'*', 'all'}:
spineHeads=[moose.wildcardFind(neurtype+'/##/#head#[ISA=CompartmentBase]')]
else:
spineHeads=[moose.wildcardFind(neurtype+'/'+c+'/#head#[ISA=CompartmentBase]') for c in comps]
for spinelist in spineHeads:
for spinenum,spine in enumerate(spinelist):
compname = spine.parent.name
sp_num=spine.name.split(NAME_HEAD)[0]
spvmtab[typenum].append(moose.Table(vm_table_path(neurtype, spine=sp_num, comp=compname)))
log.debug('{} {} {}',spinenum, spine.path, spvmtab[typenum][-1].path)
moose.connect(spvmtab[typenum][-1], 'requestOut', spine, 'getVm')
if model.calYN:
for child in spine.children:
if child.className == "CaConc" or child.className == "ZombieCaConc" :
spcatab[typenum].append(moose.Table(DATA_NAME+'/%s_%s%s'% (neurtype,sp_num,compname)+child.name))
spcal = moose.element(spine.path+'/'+child.name)
moose.connect(spcatab[typenum][-1], 'requestOut', spcal, 'getCa')
elif child.className == 'DifShell':
spcatab[typenum].append(moose.Table(DATA_NAME+'/%s_%s%s'% (neurtype,sp_num,compname)+child.name))
spcal = moose.element(spine.path+'/'+child.name)
moose.connect(spcatab[typenum][-1], 'requestOut', spcal, 'getC')
return spcatab,spvmtab
def loadModel(filename, chanProto, chanDistrib, passiveDistrib):
"""Load the model and insert channels """
global modelName
global nchans, ncompts
# Load in the swc file.
modelName = "elec"
cellProto = [ ( filename, modelName ) ]
rdes = rd.rdesigneur( cellProto = cellProto
, combineSegments = True
, passiveDistrib = passiveDistrib
, chanProto = chanProto
, chanDistrib = chanDistrib
)
rdes.buildModel('/model')
compts = moose.wildcardFind( "/model/%s/#[ISA=CompartmentBase]"%modelName )
setupStimuls( compts[0] )
for compt in compts:
vtab = moose.Table( '%s/vm' % compt.path )
moose.connect( vtab, 'requestOut', compt, 'getVm' )
_records[compt.path] = vtab
nchans = len(set([x.path for x in
moose.wildcardFind('/model/elec/##[TYPE=ZombieHHChannel]')])
)
_logger.info("Total channels: %s" % nchans)
return _records
def _loadElec( self, efile, elecname ):
if ( efile[ len( efile ) - 2:] == ".p" ):
self.elecid = moose.loadModel( efile, '/library/' + elecname)[0]
print self.elecid
elif ( efile[ len( efile ) - 4:] == ".swc" ):
self.elecid = moose.loadModel( efile, '/library/' + elecname)[0]
else:
nm = NeuroML()
print "in _loadElec, combineSegments = ", self.combineSegments
nm.readNeuroMLFromFile( efile, \
params = {'combineSegments': self.combineSegments, \
'createPotentialSynapses': True } )
if moose.exists( '/cells' ):
kids = moose.wildcardFind( '/cells/#' )
else:
kids = moose.wildcardFind( '/library/#[ISA=Neuron],/library/#[TYPE=Neutral]' )
if ( kids[0].name == 'spine' ):
kids = kids[1:]
assert( len( kids ) > 0 )
self.elecid = kids[0]
temp = moose.wildcardFind( self.elecid.path + '/#[ISA=CompartmentBase]' )
transformNMDAR( self.elecid.path )
kids = moose.wildcardFind( '/library/##[0]' )
for i in kids:
i.tick = -1
def main():
simdt = 0.1
plotdt = 0.1
runtime = 100.0
makeModel()
# Schedule the whole lot
moose.setClock( 4, simdt ) # for the computational objects
moose.setClock( 5, simdt ) # for the computational objects
moose.setClock( 8, plotdt ) # for the plots
moose.useClock( 4, '/model/compt#/ksolve#', 'init' )
moose.useClock( 5, '/model/compt#/ksolve#', 'process' )
moose.useClock( 8, '/model/graphs/#', 'process' )
moose.reinit()
moose.start( runtime ) # Run the model for 100 seconds.
for x in moose.wildcardFind( '/model/compt#/#[ISA=PoolBase]' ):
print x.name, x.conc
# Iterate through all plots, dump their contents to data.plot.
for x in moose.wildcardFind( '/model/graphs/conc#' ):
#x.xplot( 'scriptKineticModel.plot', x.name )
t = numpy.linspace( 0, runtime, x.vector.size ) # sec
pylab.plot( t, x.vector, label=x.name )
pylab.legend()
pylab.show()
quit()
def dumpPlots( fname ):
if ( os.path.exists( fname ) ):
os.remove( fname )
for x in moose.wildcardFind( '/graphs/#[ISA=Table]' ):
moose.element( x[0] ).xplot( fname, x[0].name )
for x in moose.wildcardFind( '/graphs/elec/#[ISA=Table]' ):
moose.element( x[0] ).xplot( fname, x[0].name + '_e' )
def add_synchans(model, container):
synchans=[]
#2D array to store all the synapses. Rows=num synapse types, columns=num comps
#at the end they are concatenated into a dictionary
for key in model.SYNAPSE_TYPES:
synchans.append([])
allkeys = sorted(model.SYNAPSE_TYPES)
comp_list = moose.wildcardFind(container + '/#[TYPE=Compartment]')
for comp in comp_list:
#create each type of synchan in each compartment. Add to 2D array
for key in DendSynChans(model):
keynum = allkeys.index(key)
Gbar = model.SYNAPSE_TYPES[key].Gbar
Gbarvar=model.SYNAPSE_TYPES[key].var
synchans[keynum].append(addoneSynChan(key,comp,Gbar, model.calYN, Gbarvar))
for key in SpineSynChans(model):
keynum = allkeys.index(key)
Gbar = model.SYNAPSE_TYPES[key].Gbar
Gbarvar=model.SYNAPSE_TYPES[key].var
for spcomp in moose.wildcardFind(comp.path + '/#[ISA=Compartment]'):
if NAME_HEAD in spcomp.path:
synchans[keynum].append(addoneSynChan(key,spcomp,Gbar, model.calYN, Gbarvar))
allsynchans={key:synchans[keynum]
for keynum, key in enumerate(sorted(model.SYNAPSE_TYPES))}
return allsynchans
def installCellFromProtos( self ):
if self.stealCellFromLibrary:
moose.move( self.elecid, self.model )
if self.elecid.name != 'elec':
self.elecid.name = 'elec'
else:
moose.copy( self.elecid, self.model, 'elec' )
self.elecid = moose.element( self.model.path + '/elec' )
self.elecid.buildSegmentTree() # rebuild: copy has happened.
if hasattr( self, 'chemid' ):
self.validateChem()
if self.stealCellFromLibrary:
moose.move( self.chemid, self.model )
if self.chemid.name != 'chem':
self.chemid.name = 'chem'
else:
moose.copy( self.chemid, self.model, 'chem' )
self.chemid = moose.element( self.model.path + '/chem' )
ep = self.elecid.path
somaList = moose.wildcardFind( ep + '/#oma#[ISA=CompartmentBase]' )
if len( somaList ) == 0:
somaList = moose.wildcardFind( ep + '/#[ISA=CompartmentBase]' )
if len( somaList ) == 0:
raise BuildError( "installCellFromProto: No soma found" )
maxdia = 0.0
for i in somaList:
if ( i.diameter > maxdia ):
self.soma = i
def main():
global synSpineList
global synDendList
numpy.random.seed( 1234 )
rdes = buildRdesigneur( )
for i in elecFileNames:
print(i)
rdes.cellProtoList = [ ['./cells/' + i, 'elec'] ]
rdes.buildModel( )
assert( moose.exists( '/model' ) )
synSpineList = moose.wildcardFind( "/model/elec/#head#/glu,/model/elec/#head#/NMDA" )
temp = set( moose.wildcardFind( "/model/elec/#/glu,/model/elec/#/NMDA" ) )
synDendList = list( temp - set( synSpineList ) )
moose.reinit()
buildPlots( rdes )
# Run for baseline, tetanus, and post-tetanic settling time
t1 = time.time()
probeStimulus( baselineTime )
tetanicStimulus( tetTime )
probeStimulus( postTetTime )
print(('real time = ', time.time() - t1))
printPsd( i + ".fig5" )
saveAndClearPlots( i + ".fig5" )
moose.delete( '/model' )
rdes.elecid = moose.element( '/' )
def deliverStim(currTime):
global injectionCurrent
global spineVm
global somaVm
if numpy.fabs( currTime - baselineTime ) < frameRunTime/2.0 :
#start
eList = moose.wildcardFind( '/model/elec/#soma#' )
assert( len(eList) > 0 )
eList[0].inject = injectionCurrent
#print "1. injected current = ", injectionCurrent
injectionCurrent += deltaCurrent
#print "del stim first ", moose.element('/clock').currentTime
if numpy.fabs( currTime - baselineTime - currPulseTime) < frameRunTime/2.0 :
#end
eList = moose.wildcardFind( '/model/elec/#soma#' )
assert( len(eList) > 0 )
eList[0].inject = 0.0
#print "2. injected current = ", injectionCurrent
#print "del stim second ", moose.element('/clock').currentTime
if runtime - currTime < frameRunTime * 2.0 :
#print "3. reinit-ing"
somaVm.append( moose.element( '/graphs/VmTab' ).vector )
spineVm.append( moose.element( '/graphs/eSpineVmTab' ).vector )
iList.append(injectionCurrent)
if injectionCurrent < maxCurrent :
moose.reinit()
def main():
global synSpineList
global synDendList
numpy.random.seed( 1234 )
rdes = buildRdesigneur()
for i in elecFileNames:
print(i)
rdes.cellProtoList = [ ['./cells/' + i, 'elec'] ]
rdes.buildModel( '/model' )
rdes.soma.inject = inject
assert( moose.exists( '/model' ) )
synSpineList = moose.wildcardFind( "/model/elec/#head#/glu,/model/elec/#head#/NMDA" )
temp = set( moose.wildcardFind( "/model/elec/#/glu,/model/elec/#/NMDA" ) )
synDendList = list( temp - set( synSpineList ) )
print("[INFO] reinitialzing")
moose.reinit()
buildPlots( rdes )
# Run for baseline, tetanus, and post-tetanic settling time
t1 = time.time()
moose.start( runtime )
print('runtime = ', runtime, '; real time = ', time.time() - t1)
saveAndClearPlots( "bigElec" )
moose.delete( '/model' )
rdes.elecid = moose.element( '/' )
def transformNMDAR( path ):
for i in moose.wildcardFind( path + "/##/#NMDA#[ISA!=NMDAChan]" ):
chanpath = i.path
pa = i.parent
i.name = '_temp'
if ( chanpath[-3:] == "[0]" ):
chanpath = chanpath[:-3]
nmdar = moose.NMDAChan( chanpath )
sh = moose.SimpleSynHandler( chanpath + '/sh' )
moose.connect( sh, 'activationOut', nmdar, 'activation' )
sh.numSynapses = 1
sh.synapse[0].weight = 1
nmdar.Ek = i.Ek
nmdar.tau1 = i.tau1
nmdar.tau2 = i.tau2
nmdar.Gbar = i.Gbar
nmdar.CMg = 12
nmdar.KMg_A = 1.0 / 0.28
nmdar.KMg_B = 1.0 / 62
nmdar.temperature = 300
nmdar.extCa = 1.5
nmdar.intCa = 0.00008
nmdar.intCaScale = 1
nmdar.intCaOffset = 0.00008
nmdar.condFraction = 0.02
moose.delete( i )
moose.connect( pa, 'channel', nmdar, 'channel' )
caconc = moose.wildcardFind( pa.path + '/#[ISA=CaConcBase]' )
if ( len( caconc ) < 1 ):
print('no caconcs found on ', pa.path)
else:
moose.connect( nmdar, 'ICaOut', caconc[0], 'current' )
moose.connect( caconc[0], 'concOut', nmdar, 'assignIntCa' )
def updateDisplay():
makeYmodel()
tabvec = moose.wildcardFind( '/model/graphs/plot#' )
moose.element( '/model/elec/' ).name = 'Y'
vecYdend = moose.wildcardFind( '/model/Y/soma,/model/Y/dend#' )
vecYbranch1 = moose.wildcardFind( '/model/Y/branch1#' )
vecYbranch2 = moose.wildcardFind( '/model/Y/branch2#' )
moose.reinit()
dt = interval1
currtime = 0.0
for i in lines:
moose.start( dt )
currtime += dt
#print "############## NumDendData = ", len( vecYdend )
i.YdendLines.set_ydata( [v.Vm*1000 for v in vecYdend] )
i.Ybranch1Lines.set_ydata( [v.Vm*1000 for v in vecYbranch1] )
i.Ybranch2Lines.set_ydata( [v.Vm*1000 for v in vecYbranch2] )
dt = interval2
moose.start( runtime - currtime )
#print "############## len (tabvec) = ", len( tabvec[0].vector )
for i, tab in zip( tplot, tabvec ):
i.set_ydata( tab.vector * 1000 )
moose.delete( '/model' )
moose.delete( '/library' )
def _loadElec( self, efile, elecname, combineSegments ):
library = moose.Neutral( '/library' )
if ( efile[ len( efile ) - 2:] == ".p" ):
self.elecid = moose.loadModel( efile, self.model.path + '/' + elecname )
else:
nm = NeuroML()
nm.readNeuroMLFromFile( efile, \
params = {'combineSegments': combineSegments, \
'createPotentialSynapses': True } )
if moose.exists( '/cells' ):
kids = moose.wildcardFind( '/cells/#' )
else:
kids = moose.wildcardFind( '/library/#[ISA=Neuron],/library/#[TYPE=Neutral]' )
if ( kids[0].name == 'spine' ):
kids = kids[1:]
assert( len( kids ) > 0 )
self.elecid = kids[0]
temp = moose.wildcardFind( self.elecid.path + '/#[ISA=CompartmentBase]' )
moose.move( self.elecid, self.model )
self.elecid.name = elecname
self._transformNMDAR( self.elecid.path )
kids = moose.wildcardFind( '/library/##[0]' )
for i in kids:
i.tick = -1
def main():
#solver = "gsl" # Pick any of gsl, gssa, ee..
solver = "gssa" # Pick any of gsl, gssa, ee..
mfile = '../../Genesis_files/Repressillator.g'
runtime = 6000.0
if ( len( sys.argv ) >= 2 ):
solver = sys.argv[1]
modelId = moose.loadModel( mfile, 'model', solver )
# Increase volume so that the stochastic solver gssa
# gives an interesting output
compt = moose.element( '/model/kinetics' )
compt.volume = 1e-19
dt = moose.element( '/clock' ).dt
moose.reinit()
moose.start( runtime )
# Display all plots.
img = mpimg.imread( 'repressillatorOsc.png' )
fig = plt.figure( figsize=(12, 10 ) )
png = fig.add_subplot( 211 )
imgplot = plt.imshow( img )
ax = fig.add_subplot( 212 )
x = moose.wildcardFind( '/model/#graphs/conc#/#' )
plt.ylabel( 'Conc (mM)' )
plt.xlabel( 'Time (seconds)' )
for x in moose.wildcardFind( '/model/#graphs/conc#/#' ):
t = numpy.arange( 0, x.vector.size, 1 ) * dt
pylab.plot( t, x.vector, label=x.name )
pylab.legend()
pylab.show()
def writeCompt(modelpath, cremodel_):
# getting all the compartments
compts = moose.wildcardFind(modelpath + '/##[ISA=ChemCompt]')
groupInfo = {}
for compt in compts:
comptName = convertSpecialChar(compt.name)
# converting m3 to litre
size = compt.volume * pow(10, 3)
ndim = compt.numDimensions
c1 = cremodel_.createCompartment()
c1.setId(str(idBeginWith(comptName +
"_" +
str(compt.getId().value) +
"_" +
str(compt.getDataIndex()) +
"_")))
c1.setName(comptName)
c1.setConstant(True)
c1.setSize(size)
c1.setSpatialDimensions(ndim)
c1.setUnits('volume')
#For each compartment get groups information along
for grp in moose.wildcardFind(compt.path+'/##[TYPE=Neutral]'):
grp_cmpt = findGroup_compt(grp.parent)
try:
value = groupInfo[moose.element(grp)]
except KeyError:
# Grp is not present
groupInfo[moose.element(grp)] = []
if compts:
return True,groupInfo
else:
return False,groupInfo
def transformNMDAR(path):
for i in moose.wildcardFind(path + "/##/#NMDA#[ISA!=NMDAChan]"):
chanpath = i.path
pa = i.parent
i.name = "_temp"
if chanpath[-3:] == "[0]":
chanpath = chanpath[:-3]
nmdar = moose.NMDAChan(chanpath)
sh = moose.SimpleSynHandler(chanpath + "/sh")
moose.connect(sh, "activationOut", nmdar, "activation")
sh.numSynapses = 1
sh.synapse[0].weight = 1
nmdar.Ek = i.Ek
nmdar.tau1 = i.tau1
nmdar.tau2 = i.tau2
nmdar.Gbar = i.Gbar
nmdar.CMg = 12
nmdar.KMg_A = 1.0 / 0.28
nmdar.KMg_B = 1.0 / 62
nmdar.temperature = 300
nmdar.extCa = 1.5
nmdar.intCa = 0.00008
nmdar.intCaScale = 1
nmdar.intCaOffset = 0.00008
nmdar.condFraction = 0.02
moose.delete(i)
moose.connect(pa, "channel", nmdar, "channel")
caconc = moose.wildcardFind(pa.path + "/#[ISA=CaConcBase]")
if len(caconc) < 1:
print("no caconcs found on ", pa.path)
else:
moose.connect(nmdar, "ICaOut", caconc[0], "current")
moose.connect(caconc[0], "concOut", nmdar, "assignIntCa")
def showVisualization():
makeModel()
elec = moose.element( '/model/elec' )
elec.setSpineAndPsdMesh( moose.element('/model/chem/spine'), moose.element('/model/chem/psd') )
eHead = moose.wildcardFind( '/model/elec/#head#' )
oldDia = [ i.diameter for i in eHead ]
graphs = moose.Neutral( '/graphs' )
#makePlot( 'psd_x', moose.vec( '/model/chem/psd/x' ), 'getN' )
#makePlot( 'head_x', moose.vec( '/model/chem/spine/x' ), 'getN' )
makePlot( 'dend_x', moose.vec( '/model/chem/dend/x' ), 'getN' )
dendZ = makePlot( 'dend_z', moose.vec( '/model/chem/dend/z' ), 'getN' )
makePlot( 'head_z', moose.vec( '/model/chem/spine/z' ), 'getN' )
psdZ = makePlot( 'psd_z', moose.vec( '/model/chem/psd/z' ), 'getN' )
diaTab = makePlot( 'headDia', eHead, 'getDiameter' )
# print diaTab[0].vector[-1]
# return
dendrite = moose.element("/model/elec/dend")
dendrites = [dendrite.path + "/" + str(i) for i in range(len(dendZ))]
# print dendrites
moose.reinit()
spineHeads = moose.wildcardFind( '/model/elec/#head#')
# print moose.wildcardFind( '/model/elec/##')
# print "dendZ", readValues(dendZ)
# print dendrite
app = QtGui.QApplication(sys.argv)
viewer = create_viewer("/model/elec", dendrite, dendZ, diaTab, psdZ)
viewer.showMaximized()
viewer.start()
return app.exec_()
def poolMerge(comptA,comptB,poolNotcopiedyet):
aCmptGrp = moose.wildcardFind(comptA.path+'/#[TYPE=Neutral]')
aCmptGrp = aCmptGrp +(moose.element(comptA.path),)
bCmptGrp = moose.wildcardFind(comptB.path+'/#[TYPE=Neutral]')
bCmptGrp = bCmptGrp +(moose.element(comptB.path),)
objA = moose.element(comptA.path).parent.name
objB = moose.element(comptB.path).parent.name
for bpath in bCmptGrp:
grp_cmpt = ((bpath.path).replace(objB,objA)).replace('[0]','')
if moose.exists(grp_cmpt) :
if moose.element(grp_cmpt).className != bpath.className:
grp_cmpt = grp_cmpt+'_grp'
bpath.name = bpath.name+"_grp"
l = moose.Neutral(grp_cmpt)
else:
#moose.Neutral(grp_cmpt)
src = bpath
srcpath = (bpath.parent).path
des = srcpath.replace(objB,objA)
moose.copy(bpath,moose.element(des))
apath = moose.element(bpath.path.replace(objB,objA))
bpoollist = moose.wildcardFind(bpath.path+'/#[ISA=PoolBase]')
apoollist = moose.wildcardFind(apath.path+'/#[ISA=PoolBase]')
for bpool in bpoollist:
if bpool.name not in [apool.name for apool in apoollist]:
copied = copy_deleteUnlyingPoolObj(bpool,apath)
if copied == False:
#hold it for later, this pool may be under enzyme, as cplx
poolNotcopiedyet.append(bpool)
def displayPlots():
pylab.figure(1, figsize = (8,10 ) )
pylab.subplot( 1,1,1)
for i in moose.wildcardFind( "/graphs/#VmTab" ):
t = numpy.arange( 0, i.vector.size, 1 ) * i.dt
pylab.plot( t, i.vector, label = i.name )
pylab.xlabel( "Time (s)" )
pylab.legend()
pylab.title( 'Vm' )
pylab.figure(2, figsize= (8,10))
ax = pylab.subplot( 1,1,1 )
neuron = moose.element( '/model/elec' )
comptDistance = dict( zip( neuron.compartments, neuron.pathDistanceFromSoma ) )
for i in moose.wildcardFind( '/library/#[ISA=ChanBase]' ):
chans = moose.wildcardFind( '/model/elec/#/' + i.name )
print i.name, len( chans )
p = [ 1e6*comptDistance.get( j.parent, 0) for j in chans ]
Gbar = [ j.Gbar/(j.parent.length * j.parent.diameter * PI) for j in chans ]
if len( p ) > 2:
pylab.plot( p, Gbar, linestyle = 'None', marker = ".", label = i.name )
sortedGbar = sorted(zip(p, Gbar), key=lambda x: x[0])
ax.set_yscale( 'log' )
pylab.xlabel( "Distance from soma (microns)" )
pylab.ylabel( "Channel density (Seimens/sq mtr)" )
pylab.legend()
pylab.title( 'Channel distribution' )
pylab.show()
def makeGraphics( cPlotDt, ePlotDt ):
plt.ion()
fig = plt.figure( figsize=(10,16) )
chem = fig.add_subplot( 411 )
chem.set_ylim( 0, 0.006 )
plt.ylabel( 'Conc (mM)' )
plt.xlabel( 'time (seconds)' )
for x in moose.wildcardFind( '/graphs/chem/#[ISA=Table]' ):
pos = numpy.arange( 0, x.vector.size, 1 ) * cPlotDt
line1, = chem.plot( pos, x.vector, label=x.name )
plt.legend()
elec = fig.add_subplot( 412 )
plt.ylabel( 'Vm (V)' )
plt.xlabel( 'time (seconds)' )
for x in moose.wildcardFind( '/graphs/elec/#[ISA=Table]' ):
pos = numpy.arange( 0, x.vector.size, 1 ) * ePlotDt
line1, = elec.plot( pos, x.vector, label=x.name )
plt.legend()
ca = fig.add_subplot( 413 )
plt.ylabel( '[Ca] (mM)' )
plt.xlabel( 'time (seconds)' )
for x in moose.wildcardFind( '/graphs/ca/#[ISA=Table]' ):
pos = numpy.arange( 0, x.vector.size, 1 ) * ePlotDt
line1, = ca.plot( pos, x.vector, label=x.name )
plt.legend()
lenplot = fig.add_subplot( 414 )
plt.ylabel( 'Ca (mM )' )
plt.xlabel( 'Voxel#)' )
spineCa = moose.vec( '/model/chem/spine/Ca' )
dendCa = moose.vec( '/model/chem/dend/DEND/Ca' )
line1, = lenplot.plot( range( len( spineCa ) ), spineCa.conc, label='spine' )
line2, = lenplot.plot( range( len( dendCa ) ), dendCa.conc, label='dend' )
ca = [ x.Ca * 0.0001 for x in moose.wildcardFind( '/model/elec/##[ISA=CaConcBase]') ]
line3, = lenplot.plot( range( len( ca ) ), ca, label='elec' )
spineCaM = moose.vec( '/model/chem/spine/CaM_dash_Ca4' )
line4, = lenplot.plot( range( len( spineCaM ) ), spineCaM.conc, label='spineCaM' )
psdCaM = moose.vec( '/model/chem/psd/CaM_dash_Ca4' )
line5, = lenplot.plot( range( len( psdCaM ) ), psdCaM.conc, label='psdCaM' )
plt.legend()
fig.canvas.draw()
raw_input()
'''
for x in moose.wildcardFind( '/graphs/##[ISA=Table]' ):
t = numpy.arange( 0, x.vector.size, 1 )
pylab.plot( t, x.vector, label=x.name )
pylab.legend()
pylab.show()
'''
print 'All done'
def dumpPlots( fname ): t = numpy.arange( 0, 100.2, 0.2 ) # msec plots = moose.wildcardFind( '/graphs/##[ISA=Table]' ) for x in moose.wildcardFind( '/graphs/##[ISA=Table]' ): pylab.plot( t, x.vector, label=x.name) pylab.legend() pylab.show()
def dumpPlots(): plots = moose.wildcardFind( '/graphs/##[ISA=Table]' ) for x in moose.wildcardFind( '/graphs/##[ISA=Table]' ): t = numpy.arange( 0, x.size ) * x.dt # msec pylab.plot( t, x.vector, label=x.name) pylab.legend() pylab.show()
def dump_plots():
for x in moose.wildcardFind('/graphs/cpu/##[ISA=Table]'):
t = numpy.arange(0, len(x.vector), 1)
pylab.plot(t, x.vector, label=("CPU:%s" % x.name))
for x in moose.wildcardFind('/graphs/gpu/##[ISA=Table]'):
# print x.vector
t = numpy.arange(0, len(x.vector), 1)
pylab.plot(t, x.vector, label=("GPU:%s" % x.name))
def main():
"""
funcRateHarmonicOsc illustrates the use of function objects to
directly define the rates of change of pool concentration. This
example shows how to set up a simple harmonic oscillator system
of differential equations using the script. In normal use one would
prefer to use SBML.
The equations are ::
p' = v - offset1
v' = -k(p - offset2)
where the rates for Pools p and v are computed using Functions.
Note the use of offsets. This is because MOOSE chemical
systems cannot have negative concentrations.
The model is set up to run using default Exponential Euler
integration, and then using the GSL deterministic solver.
"""
makeModel()
for i in range( 11, 18 ):
moose.setClock( i, 0.01 )
moose.setClock( 18, 0.1 )
moose.reinit()
moose.start( runtime ) # Run the model
# Iterate through all plots, dump their contents to data.plot.
for x in moose.wildcardFind( '/model/graphs/#' ):
#x.xplot( 'scriptKineticModel.plot', x.name )
t = numpy.arange( 0, x.vector.size, 1 ) * x.dt # sec
pylab.plot( t, x.vector, label=x.name )
pylab.suptitle( "Integration using ee" )
pylab.legend()
pylab.figure()
compt = moose.element( '/model/harmonic' )
ksolve = moose.Ksolve( '/model/harmonic/ksolve' )
stoich = moose.Stoich( '/model/harmonic/stoich' )
stoich.compartment = compt
stoich.ksolve = ksolve
stoich.path = '/model/harmonic/##'
for i in range( 11, 18 ):
moose.setClock( i, 0.1 )
moose.reinit()
moose.start( runtime ) # Run the model
for x in moose.wildcardFind( '/model/graphs/#' ):
t = numpy.arange( 0, x.vector.size, 1 ) * x.dt # sec
pylab.plot( t, x.vector, label=x.name )
pylab.suptitle( "Integration using gsl" )
pylab.legend()
pylab.show()
quit()
def run_model_fig6():
"""Do a simulation for fig6 and plot data."""
for ch in moose.wildcardFind('/model/##[ISA=ChanBase]'):
ch.Gk = 1.0/Rm
print('Starting for', inject_time)
moose.start(inject_time)
for ch in moose.wildcardFind('/model/##[ISA=ChanBase]'):
ch.Gk = 0.0
moose.start(simtime - inject_time)
def deleteSolver(modelRoot):
if moose.wildcardFind(modelRoot+'/##[ISA=ChemCompt]'):
compt = moose.wildcardFind(modelRoot+'/##[ISA=ChemCompt]')
if ( moose.exists( compt[0].path+'/stoich' ) ):
st = moose.element(compt[0].path+'/stoich')
if moose.exists((st.ksolve).path):
moose.delete(st.ksolve)
moose.delete( compt[0].path+'/stoich' )
for x in moose.wildcardFind( modelRoot+'/data/graph#/#' ):
x.tick = -1
def main():
"""
This example illustrates a simple cross compartment reaction::
a <===> b <===> c
Here each molecule is in a different compartment.
The initial conditions are such that the end conc on all compartments
should be 2.0.
The time course depends on which compartment the Reac object is
embedded in.
The cleanest thing numerically and also conceptually is to have both
reactions in the same compartment, in this case the middle one
(**compt1**).
The initial conditions have a lot of **B**. The equilibrium with
**C** is fast and so **C** shoots up and passes **B**, peaking at
about (2.5,9). This is also just
about the crossover point.
**A** starts low and slowly climbs up to equilibrate.
If we put **reac0** in **compt0** and **reac1** in **compt1**,
it behaves the same
qualitiatively but now the peak is at around (1, 5.2)
This configuration of reactions makes sense from the viewpoint of
having the
reactions always in the compartment with the smaller volume, which is
important if we need to have junctions where many small voxels talk to
one big voxel in another compartment.
Note that putting the reacs in other compartments doesn't work and in
some combinations (e.g., **reac0** in **compt0** and **reac1** in
**compt2**) give
numerical instability.
"""
simdt = 0.1
plotdt = 0.1
runtime = 100.0
makeModel()
# MOOSE autoschedules everything.
moose.reinit()
moose.start( runtime ) # Run the model for 100 seconds.
print("All concs should converge to 2.0 even though vols differ:")
for x in moose.wildcardFind( '/model/compt#/#[ISA=PoolBase]' ):
print((x.name, x.conc))
# Iterate through all plots, dump their contents to data.plot.
for x in moose.wildcardFind( '/model/graphs/conc#' ):
t = numpy.linspace( 0, runtime, x.vector.size ) # sec
pylab.plot( t, x.vector, label=x.name )
pylab.legend()
pylab.show()
quit()
def _scaleSpineCompt( self, compt, size ):
chans = moose.wildcardFind( compt.path + '/##[ISA=ChanBase]' )
a = size * size
for i in chans:
i.Gbar *= a
concs = moose.wildcardFind( compt.path + '/##[ISA=CaConcBase]' )
for i in concs:
i.B *= size * size * size
compt.Rm /= a
compt.Cm *= a
compt.Ra /= size
def displayPlots():
pylab.figure(1, figsize=(8, 10))
pylab.subplot(4, 1, 1)
for i in moose.wildcardFind("/graphs/psdRtab[]"):
t = numpy.arange(0, i.vector.size, 1) * i.dt
pylab.plot(t, i.vector)
pylab.title('# receptor in PSD')
pylab.subplot(4, 1, 2)
for i in moose.wildcardFind("/graphs/caDendTab[]"):
t = numpy.arange(0, i.vector.size, 1) * i.dt
pylab.plot(t, i.vector)
pylab.title('[Ca] in dend')
pylab.subplot(4, 1, 3)
for i in moose.wildcardFind("/graphs/caHeadTab[]"):
t = numpy.arange(0, i.vector.size, 1) * i.dt
pylab.plot(t, i.vector)
pylab.title('[Ca] in spine head')
pylab.subplot(4, 1, 4)
for i in moose.wildcardFind("/graphs/#VmTab"):
t = numpy.arange(0, i.vector.size, 1) * i.dt
pylab.plot(t, i.vector, label=i.name)
pylab.xlabel("Time (s)")
pylab.legend()
pylab.title('Vm')
pylab.figure(2, figsize=(8, 10))
ax = pylab.subplot(1, 1, 1)
neuron = moose.element('/model/elec')
comptDistance = dict(zip(neuron.compartments, neuron.pathDistanceFromSoma))
for i in moose.wildcardFind('/library/#[ISA=ChanBase]'):
chans = moose.wildcardFind('/model/elec/#/' + i.name)
print i.name, len(chans)
p = [1e6 * comptDistance.get(j.parent, 0) for j in chans]
Gbar = [
j.Gbar / (j.parent.length * j.parent.diameter * PI) for j in chans
]
if len(p) > 2:
pylab.plot(p, Gbar, linestyle='None', marker=".", label=i.name)
ax.set_yscale('log')
pylab.xlabel("Distance from soma (microns)")
pylab.ylabel("Channel density (Seimens/sq mtr)")
pylab.legend()
pylab.title('Channel distribution')
pylab.show()
def create_neuron(model, ntype, ghkYN):
p_file = find_morph_file(model, ntype)
try:
cellproto = moose.loadModel(p_file, ntype)
except IOError:
print('could not load model from {!r}'.format(p_file))
raise
#######channels
Cond = model.Condset[ntype]
for comp in moose.wildcardFind('{}/#[TYPE=Compartment]'.format(ntype)):
xloc = moose.Compartment(comp).x
yloc = moose.Compartment(comp).y
#Possibly this should be replaced by pathlength
dist = np.sqrt(xloc * xloc + yloc * yloc)
log.debug('comp {.path} dist {}', comp, dist)
#
#If we are using GHK, just create one GHK per compartment, connect it to comp
#calcium concentration is connected in a different function
if ghkYN:
ghkproto = moose.element('/library/ghk')
ghk = moose.copy(ghkproto, comp, 'ghk')[0]
moose.connect(ghk, 'channel', comp, 'channel')
else:
ghk = []
for channame, chanparams in model.Channels.items():
c = _util.distance_mapping(Cond[channame], comp)
if c > 0:
log.debug('Testing Cond If {} {}', channame, c)
calciumPermeable = chanparams.calciumPermeable
add_channel.addOneChan(channame,
c,
comp,
ghkYN,
ghk,
calciumPermeable=calciumPermeable)
return cellproto
def writeFunc(modelpath, cremodel_):
funcs = moose.wildcardFind(modelpath + '/##[ISA=Function]')
# if func:
foundFunc = False
for func in funcs:
if func:
if func.parent.className == "CubeMesh" or func.parent.className == "CyclMesh":
if len(moose.element(func).neighbors["valueOut"]) > 0:
funcEle = moose.element(
moose.element(func).neighbors["valueOut"][0])
funcEle1 = moose.element(funcEle)
fName = idBeginWith(convertSpecialChar(
funcEle.name + "_" + str(funcEle.getId().value) + "_" + str(funcEle.getDataIndex()) + "_"))
expr = " "
expr = str(moose.element(func).expr)
if not expr:
foundFunc = True
else:
foundFunc = True
fName = idBeginWith(convertSpecialChar(func.parent.name +
"_" + str(func.parent.getId().value) +
"_" + str(func.parent.getDataIndex()) +
"_"))
item = func.path + '/x[0]'
sumtot = moose.element(item).neighbors["input"]
expr = moose.element(func).expr
for i in range(0, len(sumtot)):
v = "x" + str(i)
if v in expr:
z = str(idBeginWith(str(convertSpecialChar(sumtot[i].name + "_" + str(moose.element(
sumtot[i]).getId().value) + "_" + str(moose.element(sumtot[i]).getDataIndex())) + "_")))
expr = expr.replace(v, z)
if foundFunc:
rule = cremodel_.createAssignmentRule()
rule.setVariable(fName)
rule.setFormula(expr)
def writeCompt(modelpath, cremodel_):
# getting all the compartments
compts = moose.wildcardFind(modelpath + '/##[ISA=ChemCompt]')
for compt in compts:
comptName = convertSpecialChar(compt.name)
# converting m3 to litre
size = compt.volume * pow(10, 3)
ndim = compt.numDimensions
c1 = cremodel_.createCompartment()
c1.setId(str(idBeginWith(comptName +
"_" +
str(compt.getId().value) +
"_" +
str(compt.getDataIndex()) +
"_")))
c1.setName(comptName)
c1.setConstant(True)
c1.setSize(size)
c1.setSpatialDimensions(ndim)
c1.setUnits('volume')
if compts:
return True
else:
return False
def addSolver(modelRoot, solver):
compt = moose.wildcardFind(modelRoot + '/##[ISA=ChemCompt]')
comptinfo = moose.Annotator(moose.element(compt[0]).path + '/info')
previousSolver = comptinfo.solver
currentSolver = previousSolver
if solver == "Gillespie":
currentSolver = "gssa"
elif solver == "Runge Kutta":
currentSolver = "gsl"
elif solver == "Exponential Euler":
currentSolver = "ee"
if previousSolver != currentSolver:
# if previousSolver != currentSolver
comptinfo.solver = currentSolver
if (moose.exists(compt[0].path + '/stoich')):
# "A: and stoich exists then delete the stoich add solver"
deleteSolver(modelRoot)
setCompartmentSolver(modelRoot, currentSolver)
return True
else:
# " B: stoich doesn't exists then addSolver, this is when object is deleted which delete's the solver "
# " and solver is also changed, then add addsolver "
setCompartmentSolver(modelRoot, currentSolver)
return True
else:
# " solver is same "
if moose.exists(compt[0].path + '/stoich'):
# " stoich exist, doing nothing"
return False
else:
# "but stoich doesn't exist,this is when object is deleted which deletes the solver
# " but solver are not changed, then also call addSolver"
setCompartmentSolver(modelRoot, currentSolver)
return True
return False
def main():
solver = "old_gsl" # Pick any of gsl, gssa, ee..
mfile = '../Genesis_files/kkit_objects_example.g'
runtime = 20.0
if (len(sys.argv) >= 3):
mfile = '../Genesis_files/' + sys.argv[1]
runtime = float(sys.argv[2])
if (len(sys.argv) == 4):
solver = sys.argv[3]
modelId = moose.loadModel(mfile, 'model', solver)
# Increase volume so that the stochastic solver gssa
# gives an interesting output
#compt = moose.element( '/model/kinetics' )
#compt.volume = 1e-19
moose.reinit()
moose.start(runtime)
# Report parameters
'''
for x in moose.wildcardFind( '/model/kinetics/##[ISA=PoolBase]' ):
print x.name, x.nInit, x.concInit
for x in moose.wildcardFind( '/model/kinetics/##[ISA=ReacBase]' ):
print x.name, 'num: (', x.numKf, ', ', x.numKb, '), conc: (', x.Kf, ', ', x.Kb, ')'
for x in moose.wildcardFind('/model/kinetics/##[ISA=EnzBase]'):
print x.name, '(', x.Km, ', ', x.numKm, ', ', x.kcat, ')'
'''
# Display all plots.
for x in moose.wildcardFind('/model/#graphs/conc#/#'):
t = numpy.arange(0, x.vector.size, 1) * x.dt
pylab.plot(t, x.vector, label=x.name)
pylab.legend()
pylab.show()
quit()
def updateCoords(self):
''' Obtains coords from the associated cell'''
self.compts_ = moose.wildcardFind(self.neuronId.path +
"/#[ISA=CompartmentBase]")
# Matplotlib3d isn't able to do full rotations about an y axis,
# which is what the NeuroMorpho models use, so
# here we shuffle the axes around. Should be an option.
#coords = np.array([[[i.x0,i.y0,i.z0],[i.x,i.y,i.z]]
#for i in self.compts_])
coords = np.array([[[i.z0, i.x0, i.y0], [i.z, i.x, i.y]]
for i in self.compts_])
dia = np.array([i.diameter for i in self.compts_])
if self.relativeObj == '.':
self.activeCoords = coords
self.activeDia = dia
self.activeObjs = self.compts_
else:
self.activeObjs = []
self.activeCoords = []
self.activeDia = []
for i, j, k in zip(self.compts_, coords, dia):
if moose.exists(i.path + '/' + self.relativeObj):
elm = moose.element(i.path + '/' + self.relativeObj)
self.activeObjs.append(elm)
self.activeCoords.append(j)
self.activeDia.append(k)
self.activeCoords = np.array(self.activeCoords) * self.lenScale
self.coordMax = np.amax(self.activeCoords)
self.coordMin = np.amin(self.activeCoords)
self.linewidth = np.array([
min(self.maxLineWidth, 1 + int(i * self.diaScale))
for i in self.activeDia
])
return
def create_comp_model(container_name,
file_name,
comp_RM=None,
comp_CM=None,
comp_RA=None,
comp_ELEAK=None,
comp_initVm=None):
'Create compartmental model from *.p file or a *.swc file.'
if file_name.endswith('.p'):
root_comp = moose.loadModel(file_name, container_name)
elif file_name.endswith('swc'):
assert comp_RM is not None, "comp_RM needs valid value."
assert comp_CM is not None, "comp_CM needs valid value."
assert comp_RA is not None, "comp_RA needs valid value."
assert comp_ELEAK is not None, "comp_ELEAK needs valid value."
assert comp_initVm is not None, "comp_initVm needs valid value."
root_comp = moose.loadModel(file_name, container_name)
for comp in moose.wildcardFind(root_comp.path +
'/#[TYPE=Compartment]'):
set_comp_values(comp, comp_RM, comp_CM, comp_RA, comp_initVm,
comp_ELEAK)
else:
raise "Invalid cell model file type."
return root_comp
def __init__(self, modelRoot, *args, **kwargs):
super(PlotWidgetContainer, self).__init__(*args)
self.modelRoot = modelRoot
if len(moose.wildcardFind(modelRoot + "/##[ISA=ChemCompt]")) == 0:
self.modelType = ELECTRICAL
else:
self.modelType = CHEMICAL
self.model = moose.element(self.modelRoot)
if self.modelRoot != "/":
self.modelRoot = self.findModelPath(self.modelRoot)
if moose.exists(modelRoot + "/data"):
self.data = moose.element(self.modelRoot + "/data")
else:
self.data = moose.Neutral(self.modelRoot + "/data")
else:
self.data = moose.element("/data")
self._layout = QVBoxLayout()
self.graphs = QSplitter()
self.graphs.setOrientation(QtCore.Qt.Vertical)
self.graphsArea = QScrollArea()
self.rowIndex = 0
self.graphs.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.setAcceptDrops(True)
self.graphsArea.setWidget(self.graphs)
self.graphsArea.setWidgetResizable(True)
self.graphWidgets = []
self._layout.addWidget(self.graphsArea)
self.setLayout(self._layout)
for graph in self.data.children:
self.addPlotWidget(graph=graph)
if len(self.data.children) == 0:
self.addPlotWidget()
def test_travelling_osc():
"""Test travelling wave.
"""
rdes = rd.rdesigneur(
turnOffElec = True,
diffusionLength = 2e-6,
chemProto = [['makeChemOscillator()', 'osc']],
chemDistrib = [['osc', 'soma', 'install', '1' ]],
plotList = [
['soma', '1', 'dend/a', 'conc', 'Concentration of a'],
['soma', '1', 'dend/b', 'conc', 'Concentration of b'],
['soma', '1', 'dend/a', 'conc', 'Concentration of a', 'wave'],
],
moogList = [['soma', '1', 'dend/a', 'conc', 'a Conc', 0, 360 ]]
)
a = moose.element( '/library/osc/kinetics/a' )
b = moose.element( '/library/osc/kinetics/b' )
s = moose.element( '/library/osc/kinetics/s' )
a.diffConst = 0
b.diffConst = 0
a.motorConst = 1e-6
rdes.buildModel()
moose.reinit()
# rdes.displayMoogli( 1, 400, rotation = 0, azim = -np.pi/2, elev = 0.0 )
moose.start(400)
data = []
for t in moose.wildcardFind('/##[TYPE=Table2]'):
data.append(t.vector[::10])
m = np.mean(data, axis=0)
u = np.std(data, axis=0)
# The expected values are computed with GSL solver. These values will vary
# a little with BOOST solver. Give some leeway for these tests.
assert np.allclose(expected[0], m, rtol=1e-2), "Error is %s " % (expected[0]-m)
A, B = expected[1], u
assert np.allclose(B, A, rtol=1e-1), "Error is %s, base=%s" % ((A-B), B)
print('done')
def test_axon_propagation():
""" Test squid axon propagation.
"""
moose.Neutral( '/library' )
makeAxonProto()
rdes = rd.rdesigneur(
chanProto = [['make_HH_Na()', 'Na'], ['make_HH_K()', 'K']],
cellProto = [['elec','axon']],
chanDistrib = [
['Na', '#', 'Gbar', '1200' ],
['K', '#', 'Gbar', '360' ]],
stimList = [['soma', '1', '.', 'inject', '(t>0.005 && t<0.2) * 2e-11' ]],
plotList = [['soma', '1', '.', 'Vm', 'Membrane potential']],
moogList = [['#', '1', '.', 'Vm', 'Vm (mV)']]
)
rdes.buildModel()
moose.reinit()
moose.start(0.04)
data = moose.wildcardFind('/##[TYPE=Table]')[0].vector[::10]
assert np.allclose(data, expected), "Error is %s" % (data-expected)
print('Add done')
return data
def test_rdes():
rdes = rd.rdesigneur(
cellProto=[['somaProto', 'soma', 20e-6, 200e-6]],
chanProto=[['make_glu()', 'glu']],
chanDistrib=[['glu', 'soma', 'Gbar', '1']],
stimList=[['soma', '0.5', 'glu', 'randsyn', '50']],
# Deliver stimulus to glu synapse on soma, at mean 50 Hz Poisson.
plotList=[['soma', '1', '.', 'Vm', 'Soma membrane potential']])
rdes.buildModel()
print('[INFO] built rdesigneur')
moose.reinit()
moose.start(0.3)
tables = moose.wildcardFind('/##[TYPE=Table]')
res = []
for t in tables:
y = t.vector
u, s = np.mean(y), np.std(y)
res.append((u, s))
# Got these values from version compiled on Sep 20, 2018 with moose.seed
# set to 100.
expected = [(-0.051218660048699974, 0.01028490481294165)]
assert np.isclose(expected, res,
atol=1e-5).all(), "Expected %s, got %s" % (expected, res)
def writeNotes(modelpath, f):
notes = ""
#items = moose.wildcardFind(modelpath+"/##[ISA=ChemCompt],/##[ISA=ReacBase],/##[ISA=PoolBase],/##[ISA=EnzBase],/##[ISA=Function],/##[ISA=StimulusTable]")
items = []
items = moose.wildcardFind(modelpath+"/##[0][ISA=ChemCompt]") +\
moose.wildcardFind(modelpath+"/##[0][ISA=PoolBase]") +\
moose.wildcardFind(modelpath+"/##[0][ISA=ReacBase]") +\
moose.wildcardFind(modelpath+"/##[0][ISA=EnzBase]") +\
moose.wildcardFind(modelpath+"/##[0][ISA=Function]") +\
moose.wildcardFind(modelpath+"/##[0][ISA=StimulusTable]")
for item in items:
if not re.search(r"xfer", item.name):
if not moose.exists(item.path + '/info'):
continue
info = item.path + '/info'
notes = moose.Annotator(info).getField('notes')
if not notes:
continue
m = r'call /kinetics/{0}/notes LOAD \ \n"{1}"\n'.format(
trimPath(item),
moose.Annotator(info).getField('notes'))
f.write(m)
try:
import matplotlib
except Exception as e:
print("[INFO ] matplotlib is not found. This test wont run.")
quit()
import rdesigneur as rd
rdes = rd.rdesigneur(
cellProto=[['somaProto', 'soma', 20e-6, 200e-6]],
chanProto=[['make_glu()', 'glu']],
chanDistrib=[['glu', 'soma', 'Gbar', '1']],
stimList=[['soma', '0.5', 'glu', 'randsyn', '50']],
# Deliver stimulus to glu synapse on soma, at mean 50 Hz Poisson.
plotList=[['soma', '1', '.', 'Vm', 'Soma membrane potential']])
rdes.buildModel()
moose.reinit()
moose.start(0.3)
tables = moose.wildcardFind('/##[TYPE=Table]')
res = []
for t in tables:
y = t.vector
u, s = np.mean(y), np.std(y)
res.append((u, s))
# Got these values from version compiled on Sep 20, 2018 with moose.seed set to
# 100.
expected = [(-0.051218660048699974, 0.01028490481294165)]
assert np.isclose(expected, res,
atol=1e-5).all(), "Expected %s, got %s" % (expected, res)
popdict, projdict = moose.neuroml.loadNeuroML_L123(filename)
# setting up hsolve object for each neuron
for popinfo in popdict.values():
for cell in popinfo[1].values():
solver = moose.HSolve(cell.path + "/hsolve")
solver.target = cell.path
# reinit moose to bring to a reliable initial state.
moose.reinit()
SIMULATION_DELTA = 0.001
SIMULATION_TIME = 0.03
ALL_COMPARTMENTS = map( lambda x : x.path
, moose.wildcardFind("/cells[0]/##[ISA=CompartmentBase]")
)
BASE_RM_VALUE = min( map( lambda x : moose.element(x).Rm
, ALL_COMPARTMENTS
)
)
PEAK_RM_VALUE = max( map( lambda x : moose.element(x).Rm
, ALL_COMPARTMENTS
)
)
BASE_RM_COLOR = [0.0, 1.0, 0.0, 0.1]
PEAK_RM_COLOR = [1.0, 0.0, 0.0, 1.0]
BASE_VM_VALUE = -0.065
PEAK_VM_VALUE = -0.060
def convert_morphology(root, positions='auto'):
"""Convert moose neuron morphology contained under `root` into a
NeuroML object. The id of the return object is
{root.name}_morphology. Each segment object gets the numeric value
of the moose id of the object. The name of the segments are same
as the corresponding moose compartment.
Parameters
----------
root : a moose element containing a single cell model.
positions : string
flag to indicate if the positions of the end points of the
compartments are explicitly available in the compartments or
should be automatically generated. Possible values:
`auto` - automatically generate z coordinates using length of the
compartments.
`explicit` - model has explicit coordinates for all compartments.
Return
------
a neuroml.Morphology instance.
"""
if positions == 'auto':
queue = deque([autoposition(root)])
elif positions == 'explicit':
compartments = moose.wildcardFind('%s/##[TYPE=Compartment]' % (root.path))
queue = deque([compartment for compartment in map(moose.element, compartments)
if len(compartment.neighbours['axial']) == 0])
if len(queue) != 1:
raise Exception('There must be one and only one top level compartment. Found %d' % (len(topcomp_list)))
else:
raise Exception('allowed values for keyword argument positions=`auto` or `explicit`')
comp_seg = {}
parent = None
while len(queue) > 0:
compartment = queue.popleft()
proximal = neuroml.Point3DWithDiam(x=compartment.x0,
y=compartment.y0,
z=compartment.z0,
diameter=compartment.diameter)
distal = neuroml.Point3DWithDiam(x=compartment.x,
y=compartment.y,
z=compartment.z,
diameter=compartment.diameter)
plist = list(map(moose.element, compartment.neighbours['axial']))
try:
parent = neuroml.SegmentParent(segments=comp_seg[moose.element(plist[0])].id)
except (KeyError, IndexError) as e:
parent = None
segment = neuroml.Segment(id=compartment.id_.value,
proximal=proximal,
distal=distal,
parent=parent)
# TODO: For the time being using numerical value of the moose
# id for neuroml id.This needs to be updated for handling
# array elements
segment.name = compartment.name
comp_seg[compartment] = segment
queue.extend([comp for comp in map(moose.element, compartment.neighbours['raxial'])])
morph = neuroml.Morphology(id='%s_morphology' % (root.name))
morph.segments.extend(comp_seg.values())
return morph
def setupItem(modelPath, cntDict):
'''This function collects information of what is connected to what. \
eg. substrate and product connectivity to reaction's and enzyme's \
sumtotal connectivity to its pool are collected '''
#print " setupItem"
sublist = []
prdlist = []
zombieType = ['ReacBase', 'EnzBase', 'Function', 'StimulusTable']
for baseObj in zombieType:
path = '/##[ISA=' + baseObj + ']'
if modelPath != '/':
path = modelPath + path
if ((baseObj == 'ReacBase') or (baseObj == 'EnzBase')):
for items in moose.wildcardFind(path):
sublist = []
prdlist = []
uniqItem, countuniqItem = countitems(items, 'subOut')
subNo = uniqItem
for sub in uniqItem:
sublist.append(
(moose.element(sub), 's', countuniqItem[sub]))
uniqItem, countuniqItem = countitems(items, 'prd')
prdNo = uniqItem
if (len(subNo) == 0 or len(prdNo) == 0):
print("\nSubstrate Product is empty for " + items.path)
for prd in uniqItem:
prdlist.append(
(moose.element(prd), 'p', countuniqItem[prd]))
if (baseObj == 'CplxEnzBase'):
uniqItem, countuniqItem = countitems(items, 'toEnz')
for enzpar in uniqItem:
sublist.append((moose.element(enzpar), 't',
countuniqItem[enzpar]))
uniqItem, countuniqItem = countitems(items, 'cplxDest')
for cplx in uniqItem:
prdlist.append(
(moose.element(cplx), 'cplx', countuniqItem[cplx]))
if (baseObj == 'EnzBase'):
uniqItem, countuniqItem = countitems(items, 'enzDest')
for enzpar in uniqItem:
sublist.append((moose.element(enzpar), 't',
countuniqItem[enzpar]))
cntDict[items] = sublist, prdlist
elif baseObj == 'Function':
for items in moose.wildcardFind(path):
sublist = []
prdlist = []
item = items.path + '/x[0]'
uniqItem, countuniqItem = countitems(item, 'input')
for funcpar in uniqItem:
sublist.append((moose.element(funcpar), 'sts',
countuniqItem[funcpar]))
uniqItem, countuniqItem = countitems(items, 'valueOut')
for funcpar in uniqItem:
prdlist.append((moose.element(funcpar), 'stp',
countuniqItem[funcpar]))
cntDict[items] = sublist, prdlist
# elif baseObj == 'Function':
# #ZombieSumFunc adding inputs
# inputlist = []
# outputlist = []
# funplist = []
# nfunplist = []
# for items in moose.wildcardFind(path):
# for funplist in moose.element(items).neighbors['valueOut']:
# for func in funplist:
# funcx = moose.element(items.path+'/x[0]')
# uniqItem,countuniqItem = countitems(funcx,'input')
# for inPut in uniqItem:
# inputlist.append((inPut,'st',countuniqItem[inPut]))
# cntDict[func] = inputlist
else:
for tab in moose.wildcardFind(path):
tablist = []
uniqItem, countuniqItem = countitems(tab, 'output')
for tabconnect in uniqItem:
tablist.append((moose.element(tabconnect), 'tab',
countuniqItem[tabconnect]))
cntDict[tab] = tablist
def moose_main(corticalinput):
import numpy as np
import matplotlib.pyplot as plt
# plt.ion()
import moose
from moose_nerp.prototypes import (create_model_sim,
clocks,
inject_func,
create_network,
tables,
net_output)
from moose_nerp import d1opt as model
from moose_nerp import str_net as net
# additional, optional parameter overrides specified from with python terminal
# model.Condset.D1.NaF[model.param_cond.prox] /= 3
# model.Condset.D1.KaS[model.param_cond.prox] *= 3
net.connect_dict['D1']['ampa']['extern1'].dend_loc.postsyn_fraction = 0.8
net.param_net.tt_Ctx_SPN.filename = corticalinput
print('cortical_fraction = {}'.format(net.connect_dict['D1']['ampa']['extern1'].dend_loc.postsyn_fraction))
model.synYN = True
model.plasYN = True
model.calYN = True
model.spineYN = True
net.single = True
create_model_sim.setupOptions(model)
param_sim = model.param_sim
param_sim.useStreamer = True
param_sim.plotdt = .1e-3
param_sim.stim_loc = model.NAME_SOMA
param_sim.stim_paradigm = 'inject'
param_sim.injection_current = [0] # [-0.2e-9, 0.26e-9]
param_sim.injection_delay = 0.2
param_sim.injection_width = 0.4
param_sim.simtime = 21
net.num_inject = 0
net.confile = 'str_connect_plas_simd1opt_{}_corticalfraction_{}'.format(net.param_net.tt_Ctx_SPN.filename, 0.8)
if net.num_inject == 0:
param_sim.injection_current = [0]
#################################-----------create the model: neurons, and synaptic inputs
model = create_model_sim.setupNeurons(model, network=not net.single)
all_neur_types = model.neurons
# FSIsyn,neuron = cell_proto.neuronclasses(FSI)
# all_neur_types.update(neuron)
population, connections, plas = create_network.create_network(model, net, all_neur_types)
###### Set up stimulation - could be current injection or plasticity protocol
# set num_inject=0 to avoid current injection
if net.num_inject < np.inf:
inject_pop = inject_func.inject_pop(population['pop'], net.num_inject)
else:
inject_pop = population['pop']
# Does setupStim work for network?
# create_model_sim.setupStim(model)
pg = inject_func.setupinj(model, param_sim.injection_delay, param_sim.injection_width, inject_pop)
moose.showmsg(pg)
##############--------------output elements
if net.single:
# fname=model.param_stim.Stimulation.Paradigm.name+'_'+model.param_stim.location.stim_dendrites[0]+'.npz'
# simpath used to set-up simulation dt and hsolver
simpath = ['/' + neurotype for neurotype in all_neur_types]
create_model_sim.setupOutput(model)
else: # population of neurons
spiketab, vmtab, plastab, catab = net_output.SpikeTables(model, population['pop'], net.plot_netvm, plas,
net.plots_per_neur)
# simpath used to set-up simulation dt and hsolver
simpath = [net.netname]
clocks.assign_clocks(simpath, param_sim.simdt, param_sim.plotdt, param_sim.hsolve, model.param_cond.NAME_SOMA)
if model.synYN and (param_sim.plot_synapse or net.single):
# overwrite plastab above, since it is empty
syntab, plastab, stp_tab = tables.syn_plastabs(connections, model)
nonstim_plastab = tables.nonstimplastabs(plas)
# Streamer to prevent Tables filling up memory on disk
# This is a hack, should be better implemented
if param_sim.useStreamer == True:
allTables = moose.wildcardFind('/##[ISA=Table]')
streamer = moose.Streamer('/streamer')
streamer.outfile = 'plas_simd1opt_{}_corticalfraction_{}.npy'.format(net.param_net.tt_Ctx_SPN.filename, 0.8)
moose.setClock(streamer.tick, 0.1)
for t in allTables:
if any(s in t.path for s in ['plas', 'VmD1_0', 'extern', 'Shell_0']):
streamer.addTable(t)
else:
t.tick = -2
################### Actually run the simulation
def run_simulation(injection_current, simtime):
print(u'◢◤◢◤◢◤◢◤ injection_current = {} ◢◤◢◤◢◤◢◤'.format(injection_current))
pg.firstLevel = injection_current
moose.reinit()
moose.start(simtime, True)
traces, names = [], []
for inj in param_sim.injection_current:
run_simulation(injection_current=inj, simtime=param_sim.simtime)
weights = [w.value for w in moose.wildcardFind('/##/plas##[TYPE=Function]')]
plt.figure()
plt.hist(weights, bins=100)
plt.title('plas_sim_{}_corticalfraction_{}'.format(net.param_net.tt_Ctx_SPN.filename, cortical_fraction))
plt.savefig('plas_simd1opt_{}_corticalfraction_{}.png'.format(net.param_net.tt_Ctx_SPN.filename, 0.8))
if param_sim.useStreamer == True:
import atexit
atexit.register(moose.quit)
return weights
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 writePool(modelpath,f,volIndex,sceneitems):
error = ""
color = ""
textcolor = ""
for p in moose.wildcardFind(modelpath+'/##[0][ISA=PoolBase]'):
if findCompartment(p) == moose.element('/'):
error = error + " \n "+p.path+ " doesn't have compartment ignored to write to genesis"
else:
slave_enable = 0
if (p.className == "BufPool" or p.className == "ZombieBufPool"):
pool_children = p.children
if pool_children== 0:
slave_enable = 4
else:
for pchild in pool_children:
if not(pchild.className == "ZombieFunction") and not(pchild.className == "Function"):
slave_enable = 4
else:
slave_enable = 0
break
if (p.parent.className != "Enz" and p.parent.className !='ZombieEnz'):
#Assuming "p.parent.className !=Enzyme is cplx which is not written to genesis"
# x = sceneitems[p]['x']
# y = sceneitems[p]['y']
# if sceneitems != None:
# value = sceneitems[p]
# x = calPrime(value['x'])
# y = calPrime(value['y'])
pinfo = p.path+'/info'
if moose.exists(pinfo):
x = sceneitems[p]['x']
y = sceneitems[p]['y']
else:
x = 0
y = 0
error = error + " \n x and y co-ordinates are not specified for `" + p.name+ "` zero will be assigned"+ " \n "
if moose.exists(pinfo):
color = moose.Annotator(pinfo).getField('color')
color = getColorCheck(color,GENESIS_COLOR_SEQUENCE)
textcolor = moose.Annotator(pinfo).getField('textColor')
textcolor = getColorCheck(textcolor,GENESIS_COLOR_SEQUENCE)
poolsCmpt = findCompartment(p)
geometryName = volIndex[float(poolsCmpt.volume)]
volume = p.volume * NA * 1e-3
if color == "" or color == " ":
color = getRandomColor()
if textcolor == "" or textcolor == " ":
textcolor = getRandomColor()
f.write("simundump kpool /kinetics/" + trimPath(p) + " 0 " +
str(p.diffConst) + " " +
str(0) + " " +
str(0) + " " +
str(0) + " " +
str(p.nInit) + " " +
str(0) + " " + str(0) + " " +
str(volume)+ " " +
str(slave_enable) +
" /kinetics"+ geometryName + " " +
str(color) +" " + str(textcolor) + " " + str(int(x)) + " " + str(int(y)) + " "+ str(0)+"\n")
return error
def writeStimulus(modelpath,f):
error = ""
if len(moose.wildcardFind(modelpath+'/##[0][ISA=StimulusTable]')):
error = error +'\n StimulusTable is not written into genesis. This is in Todo List'
return error
def writeEnz( modelpath,f,sceneitems):
error = ""
enzList = moose.wildcardFind(modelpath+'/##[0][ISA=EnzBase]')
for enz in enzList:
if findCompartment(enz) == moose.element('/'):
error = error + " \n "+enz.path+ " doesn't have compartment ignored to write to genesis"
else:
x = random.randrange(0,10)
y = random.randrange(0,10)
textcolor = ""
color = ""
k1 = 0;
k2 = 0;
k3 = 0;
nInit = 0;
concInit = 0;
n = 0;
conc = 0;
if len(moose.element(enz).neighbors['enzDest']) == 1:
enzParent = moose.element(moose.element(enz).neighbors['enzDest'][0])
if not (isinstance(enzParent,moose.PoolBase)):
print(" raise exception enz doesn't have pool as parent %s",moose.element(enz).path)
return False
else:
vol = enzParent.volume * NA * 1e-3;
isMichaelisMenten = 0;
enzClass = enz.className
if (enzClass == "ZombieMMenz" or enzClass == "MMenz"):
k1 = enz.numKm
k3 = enz.kcat
k2 = 4.0*k3;
k1 = (k2 + k3) / k1;
isMichaelisMenten = 1;
elif (enzClass == "ZombieEnz" or enzClass == "Enz"):
k1 = enz.k1
k2 = enz.k2
k3 = enz.k3
if enz.neighbors['cplx']:
cplx = enz.neighbors['cplx'][0]
nInit = cplx.nInit[0];
else:
cplx = moose.Pool(enz.path+"/cplx")
moose.Annotator(cplx.path+'/info')
moose.connect( enz, 'cplx', cplx, 'reac' )
nInit = cplx.nInit
einfo = enz.path+'/info'
if moose.exists(einfo):
x = sceneitems[enz]['x']
y = sceneitems[enz]['y']
color = moose.Annotator(einfo).getField('color')
color = getColorCheck(color,GENESIS_COLOR_SEQUENCE)
textcolor = moose.Annotator(einfo).getField('textColor')
textcolor = getColorCheck(textcolor,GENESIS_COLOR_SEQUENCE)
else:
error = error + "\n x and y co-ordinates are not specified for `" + enz.name+ "` zero will be assigned \n "
if color == "" or color == " ":
color = getRandomColor()
if textcolor == "" or textcolor == " ":
textcolor = getRandomColor()
f.write("simundump kenz /kinetics/" + trimPath(enz) + " " + str(int(0))+ " " +
str(concInit) + " " +
str(conc) + " " +
str(nInit) + " " +
str(n) + " " +
str(vol) + " " +
str(k1) + " " +
str(k2) + " " +
str(k3) + " " +
str(0) + " " +
str(isMichaelisMenten) + " " +
"\"\"" + " " +
str(textcolor) + " " + str(color) + " \"\"" +
" " + str(int(x)) + " " + str(int(y)) + " "+str(int(0))+"\n")
return enzList,error
def main():
# Simulation information.
simtime = 0.1
simdt = 0.25e-5
plotdt = 0.25e-3
# Cell Compartment infromation
diameter = 30e-6
length = 50e-6
Em = EREST_ACT + 10.613e-3
CM = 1e-6 * 1e4
RM = 1 / (0.3E-3 * 1e4)
RA = 4
# Stimulus information
inj_delay = 20E-3
inj_amp = 1E-9
inj_width = 40E-3
# Create cell
chicken_model = create_swc_model(
root_name='E19',
file_name='E19-cell_filling-caudal.CNG.swc',
RM=RM,
CM=CM,
RA=RA,
ELEAK=Em,
initVM=Em)
soma = moose.element('/E19[0]/soma')
# Create channels
channels_set = create_set_of_channels(channel_settings, VDIVS, VMIN, VMAX)
# Fetch all compartment paths.
moose_paths = []
for comp in moose.wildcardFind(chicken_model.path +
'/#[TYPE=Compartment]'):
moose_paths.append(comp.path)
# Copy all channels to compartments.
for channel_name, channel_obj in channels_set.items():
copy_connect_channel_moose_paths(channel_obj, channel_name,
moose_paths)
# connect pulse gen
pulse_inject = create_pulse_generator(soma,
inj_width,
inj_amp,
delay=inj_delay)
# Output table
soma_v_table = create_output_table(table_element='/output',
table_name='somaVm')
soma_i_table = create_output_table(table_element='/output',
table_name='somaIm')
chicken_dend_table = create_output_table(table_element='/output',
table_name='chkdend')
# Connect output tables
moose.connect(soma_v_table, 'requestOut', soma, 'getVm')
moose.connect(soma_i_table, 'requestOut', pulse_inject, 'getOutputValue')
moose.connect(chicken_dend_table, 'requestOut',
moose.element('/E19[0]/dend_36_0'), 'getVm')
# Set moose simulation clocks
for lable in range(7):
moose.setClock(lable, simdt)
moose.setClock(8, plotdt)
# Run simulation
moose.reinit()
moose.start(simtime)
# Plot output tables.
v_plot = plot_vm_table(simtime,
soma_v_table,
soma_i_table,
chicken_dend_table,
title="soma vs dend new k1 chan g_bar = 0.05")
v_plot.legend(['soma_v', 'i', 'dend_v'])
plt.grid(True)
plt.show()
def displayPlots():
for x in moose.wildcardFind('/graphs/##[ISA=Table]'):
t = numpy.arange(0, x.vector.size, 1) * x.dt
pylab.plot(t, x.vector, label=x.name)
pylab.legend()
pylab.show()
def main():
"""
This example illustrates loading, and running a kinetic model
for a delayed -ve feedback oscillator, defined in kkit format.
The model is one by Boris N. Kholodenko from
Eur J Biochem. (2000) 267(6):1583-8
This model has a high-gain MAPK stage,
whose effects are visible whem one looks at the traces from
successive stages in the plots. The upstream pools have small
early peaks, and the downstream pools have large delayed ones.
The negative feedback step is mediated by a simple binding reaction
of the end-product of oscillation with an upstream activator.
We use the gsl solver here. The model already
defines some plots and sets the runtime to 4000 seconds.
The model does not really play nicely with the GSSA solver, since it
involves some really tiny amounts of the MAPKKK.
Things to do with the model:
- Look at model once it is loaded in::
moose.le( '/model' )
moose.showfields( '/model/kinetics/MAPK/MAPK' )
- Behold the amplification properties of the cascade.
Could do this by blocking the feedback step and giving a
small pulse input.
- Suggest which parameters you would alter to change
the period of the oscillator:
- Concs of various molecules, for example::
ras_MAPKKKK = moose.element( '/model/kinetics/MAPK/Ras_dash_MKKKK' )
moose.showfields( ras_MAPKKKK )
ras_MAPKKKK.concInit = 1e-5
- Feedback reaction rates
- Rates of all the enzymes::
for i in moose.wildcardFind( '/##[ISA=EnzBase]'):
i.kcat *= 10.0
"""
solver = "gsl"
mfile = '../../Genesis_files/Kholodenko.g'
runtime = 5000.0
if (len(sys.argv) >= 2):
solver = sys.argv[1]
modelId = moose.loadModel(mfile, 'model', solver)
dt = moose.element('/clock').tickDt[18]
moose.reinit()
moose.start(runtime)
# Display all plots.
img = mpimg.imread('Kholodenko_tut.png')
fig = plt.figure(figsize=(12, 10))
png = fig.add_subplot(211)
imgplot = plt.imshow(img)
ax = fig.add_subplot(212)
x = moose.wildcardFind('/model/#graphs/conc#/#')
t = numpy.arange(0, x[0].vector.size, 1) * dt
ax.plot(t, x[0].vector * 100, 'b-', label='Ras-MKKK * 100')
ax.plot(t, x[1].vector, 'y-', label='MKKK-P')
ax.plot(t, x[2].vector, 'm-', label='MKK-PP')
ax.plot(t, x[3].vector, 'r-', label='MAPK-PP')
plt.ylabel('Conc (mM)')
plt.xlabel('Time (seconds)')
pylab.legend()
pylab.show()
def mooseWriteKkit( modelpath, filename, sceneitems={}):
global foundmatplotlib_
if not foundmatplotlib_:
print('No maplotlib found.'
'\nThis module can be installed by following command in terminal:'
'\n\t sudo apt install python-maplotlib', "")
return False
else:
error = ""
if filename.rfind('.') != -1:
filename = filename[:filename.rfind('.')]
else:
filename = filename[:len(filename)]
filename = filename+'.g'
global NA
NA = 6.0221415e23
global cmin,cmax,xmin,xmax,ymin,ymax
cmin, xmin, ymin = 0, 0, 0
cmax, xmax, ymax = 1, 1, 1
moose.fixXreacs.restoreXreacs(modelpath)
compt = moose.wildcardFind(modelpath+'/##[0][ISA=ChemCompt]')
maxVol = estimateDefaultVol(compt)
positionInfoExist = True
if compt:
if bool(sceneitems):
cmin,cmax,xmin1,xmax1,ymin1,ymax1 = findMinMax(sceneitems)
elif not bool(sceneitems):
srcdesConnection = {}
setupItem(modelpath,srcdesConnection)
meshEntry,xmin,xmax,ymin,ymax,positionInfoExist,sceneitems = setupMeshObj(modelpath)
if not positionInfoExist:
#cmin,cmax,sceneitems = autoCoordinates(meshEntry,srcdesConnection)
sceneitems = autoCoordinates(meshEntry,srcdesConnection)
if not positionInfoExist:
# if position are not from kkit, then zoom factor is applied while
# writing to genesis. Like if position is from pyqtSceneItem or auto-coordinates
cmin,cmax,xmin1,xmax1,ymin1,ymax1 = findMinMax(sceneitems)
for k,v in list(sceneitems.items()):
anno = moose.element(k.path+'/info')
#x1 = calPrime(v['x'])
#y1 = calPrime(v['y'])
#sceneitems[k]['x'] = x1
#sceneitems[k]['y'] = y1
f = open(filename, 'w')
writeHeader (f,maxVol)
gtId_vol = writeCompartment(modelpath,compt,f)
errors = ""
error = writePool(modelpath,f,gtId_vol,sceneitems)
errors = errors+error
reacList,error= writeReac(modelpath,f,sceneitems)
errors = errors+error
enzList,error = writeEnz(modelpath,f,sceneitems)
errors = errors+error
chanList, error = writeConcChan(modelpath,f,sceneitems)
errors = errors+error
error = writeStimulus(modelpath,f)
errors = errors+error
error = writeSumtotal(modelpath,f)
errors = errors+error
#writeSumtotal(modelpath,f)
f.write("simundump xgraph /graphs/conc1 0 0 99 0.001 0.999 0\n"
"simundump xgraph /graphs/conc2 0 0 100 0 1 0\n")
tgraphs = moose.wildcardFind(modelpath+'/##[0][ISA=Table2]')
first, second = " ", " "
if tgraphs:
first,second = writeplot(tgraphs,f)
if first:
f.write(first)
f.write("simundump xgraph /moregraphs/conc3 0 0 100 0 1 0\n"
"simundump xgraph /moregraphs/conc4 0 0 100 0 1 0\n")
if second:
f.write(second)
f.write("simundump xcoredraw /edit/draw 0 -6 4 -2 6\n"
"simundump xtree /edit/draw/tree 0 \\\n"
" /kinetics/#[],/kinetics/#[]/#[],/kinetics/#[]/#[]/#[][TYPE!=proto],/kinetics/#[]/#[]/#[][TYPE!=linkinfo]/##[] \"edit_elm.D <v>; drag_from_edit.w <d> <S> <x> <y> <z>\" auto 0.6\n"
"simundump xtext /file/notes 0 1\n")
storeReacMsg(reacList,f)
storeEnzMsg(enzList,f)
storeChanMsg(chanList,f)
if tgraphs:
storePlotMsgs(tgraphs,f)
writeFooter1(f)
writeNotes(modelpath,f)
writeFooter2(f)
print('Written to file '+filename)
return errors, True
else:
print("Warning: writeKkit:: No model found on " , modelpath)
return False
def makeGraphics(cPlotDt, ePlotDt):
plt.ion()
fig = plt.figure(figsize=(10, 16))
chem = fig.add_subplot(411)
chem.set_ylim(0, 0.006)
plt.ylabel('Conc (mM)')
plt.xlabel('time (seconds)')
for x in moose.wildcardFind('/graphs/chem/#[ISA=Table]'):
pos = numpy.arange(0, x.vector.size, 1) * cPlotDt
line1, = chem.plot(pos, x.vector, label=x.name)
plt.legend()
elec = fig.add_subplot(412)
plt.ylabel('Vm (V)')
plt.xlabel('time (seconds)')
for x in moose.wildcardFind('/graphs/elec/#[ISA=Table]'):
pos = numpy.arange(0, x.vector.size, 1) * ePlotDt
line1, = elec.plot(pos, x.vector, label=x.name)
plt.legend()
ca = fig.add_subplot(413)
plt.ylabel('[Ca] (mM)')
plt.xlabel('time (seconds)')
for x in moose.wildcardFind('/graphs/ca/#[ISA=Table]'):
pos = numpy.arange(0, x.vector.size, 1) * ePlotDt
line1, = ca.plot(pos, x.vector, label=x.name)
plt.legend()
lenplot = fig.add_subplot(414)
plt.ylabel('Ca (mM )')
plt.xlabel('Voxel#)')
spineCa = moose.vec('/model/chem/spine/Ca')
dendCa = moose.vec('/model/chem/dend/DEND/Ca')
line1, = lenplot.plot(range(len(spineCa)), spineCa.conc, label='spine')
line2, = lenplot.plot(range(len(dendCa)), dendCa.conc, label='dend')
ca = [
x.Ca * 0.0001
for x in moose.wildcardFind('/model/elec/##[ISA=CaConcBase]')
]
line3, = lenplot.plot(range(len(ca)), ca, label='elec')
spineCaM = moose.vec('/model/chem/spine/CaM_dash_Ca4')
line4, = lenplot.plot(range(len(spineCaM)),
spineCaM.conc,
label='spineCaM')
psdCaM = moose.vec('/model/chem/psd/CaM_dash_Ca4')
line5, = lenplot.plot(range(len(psdCaM)), psdCaM.conc, label='psdCaM')
plt.legend()
fig.canvas.draw()
raw_input()
'''
for x in moose.wildcardFind( '/graphs/##[ISA=Table]' ):
t = numpy.arange( 0, x.vector.size, 1 )
pylab.plot( t, x.vector, label=x.name )
pylab.legend()
pylab.show()
'''
print 'All done'
def setupMeshObj(modelRoot):
''' Setup compartment and its members pool,reaction,enz cplx under self.meshEntry dictionaries \
self.meshEntry with "key" as compartment,
value is key2:list where key2 represents moose object type,list of objects of a perticular type
e.g self.meshEntry[meshEnt] = { 'reaction': reaction_list,'enzyme':enzyme_list,'pool':poollist,'cplx': cplxlist }
'''
xmin = 0.0
xmax = 1.0
ymin = 0.0
ymax = 1.0
listOfitems = {}
positionInfoExist = True
meshEntry = {}
if meshEntry:
meshEntry.clear()
else:
meshEntry = {}
xcord = []
ycord = []
meshEntryWildcard = '/##[ISA=ChemCompt]'
if modelRoot != '/':
meshEntryWildcard = modelRoot + meshEntryWildcard
for meshEnt in moose.wildcardFind(meshEntryWildcard):
mollist = []
realist = []
enzlist = []
cplxlist = []
tablist = []
funclist = []
mol_cpl = moose.wildcardFind(meshEnt.path + '/##[ISA=PoolBase]')
funclist = moose.wildcardFind(meshEnt.path + '/##[ISA=Function]')
enzlist = moose.wildcardFind(meshEnt.path + '/##[ISA=EnzBase]')
realist = moose.wildcardFind(meshEnt.path + '/##[ISA=ReacBase]')
tablist = moose.wildcardFind(meshEnt.path + '/##[ISA=StimulusTable]')
if mol_cpl or funclist or enzlist or realist or tablist:
for m in mol_cpl:
objInfo = None
# if m.parent.isA['CplxEnzBase']: # New bindings
if moose.element(m.parent).isA['CplxEnzBase']:
cplxlist.append(m)
objInfo = m.parent.path + '/info'
elif m.isA['PoolBase']:
mollist.append(m)
objInfo = m.path + '/info'
if objInfo is not None and moose.exists(objInfo):
listOfitems[moose.element(
moose.element(objInfo).parent)] = {
'x': xyPosition(objInfo, 'x'),
'y': xyPosition(objInfo, 'y')
}
xcord.append(xyPosition(objInfo, 'x'))
ycord.append(xyPosition(objInfo, 'y'))
getxyCord(xcord, ycord, funclist, listOfitems)
getxyCord(xcord, ycord, enzlist, listOfitems)
getxyCord(xcord, ycord, realist, listOfitems)
getxyCord(xcord, ycord, tablist, listOfitems)
meshEntry[meshEnt] = {
'enzyme': enzlist,
'reaction': realist,
'pool': mollist,
'cplx': cplxlist,
'table': tablist,
'function': funclist
}
positionInfoExist = not(len(np.nonzero(xcord)[0]) == 0 \
and len(np.nonzero(ycord)[0]) == 0)
if positionInfoExist:
xmin = min(xcord)
xmax = max(xcord)
ymin = min(ycord)
ymax = max(ycord)
return meshEntry, xmin, xmax, ymin, ymax, positionInfoExist, listOfitems
def displayPlots():
for x in moose.wildcardFind('/model/graphs/conc#'):
t = numpy.arange(0, x.vector.size, 1) #sec
pylab.plot(t, x.vector, label=x.name)
def createObj(scene, view, modelpath, string, pos, layoutPt):
event_pos = pos
num = 0
ret_string = " "
pos = view.mapToScene(event_pos)
itemAt = view.sceneContainerPt.itemAt(pos)
chemMesh = moose.wildcardFind(modelpath + '/##[ISA=ChemCompt]')
deleteSolver(modelpath)
mobj = ""
if itemAt != None:
itemAtView = view.sceneContainerPt.itemAt(view.mapToScene(event_pos))
itemClass = type(itemAtView).__name__
if (itemClass == 'QGraphicsRectItem'):
mobj = itemAtView.parentItem().mobj
elif (itemClass == 'QGraphicsSvgItem'):
mobj = itemAtView.parent().mobj
else:
mobj = itemAtView.mobj
if string == "CubeMesh" or string == "CylMesh":
ret_string, num = findUniqId(moose.element(modelpath), "Compartment",
0)
comptexist = moose.wildcardFind(modelpath + '/##[ISA=ChemCompt]')
if not len(comptexist):
if itemAt != None:
QtGui.QMessageBox.information(
None, 'Drop Not possible',
'\'{newString}\' currently single compartment model building is allowed'
.format(newString=string), QtGui.QMessageBox.Ok)
return
else:
mobj = moose.element(modelpath)
else:
QtGui.QMessageBox.information(
None, 'Drop Not possible',
'\'{newString}\' currently single compartment model building is allowed'
.format(newString=string), QtGui.QMessageBox.Ok)
return
elif string == "Pool" or string == "BufPool" or string == "Reac" or string == "StimulusTable":
if itemAt == None:
QtGui.QMessageBox.information(
None, 'Drop Not possible',
'\'{newString}\' has to have compartment as its parent'.format(
newString=string), QtGui.QMessageBox.Ok)
return
else:
mobj = findCompartment(mobj)
ret_string, num = findUniqId(mobj, string, num)
elif string == "Function":
mobj = findCompartment(mobj)
ret_string, num = findUniqId(mobj, string, num)
'''
if itemAt != None:
if ((mobj).className != "BufPool"):
QtGui.QMessageBox.information(None,'Drop Not possible','\'{newString}\' has to have BufPool as its parent'.format(newString =string),QtGui.QMessageBox.Ok)
return
else:
ret_string,num = findUniqId(mobj,string,num)
else:
QtGui.QMessageBox.information(None,'Drop Not possible','\'{newString}\' has to have BufPool as its parent'.format(newString =string),QtGui.QMessageBox.Ok)
return
'''
elif string == "Enz" or string == "MMenz":
if itemAt != None:
if ((mobj).className != "Pool" and (mobj).className != "BufPool"):
QtGui.QMessageBox.information(
None, 'Drop Not possible',
'\'{newString}\' has to have Pool as its parent'.format(
newString=string), QtGui.QMessageBox.Ok)
return
else:
ret_string, num = findUniqId(mobj, string, num)
else:
QtGui.QMessageBox.information(
None, 'Drop Not possible',
'\'{newString}\' has to have Pool as its parent'.format(
newString=string), QtGui.QMessageBox.Ok)
return
if ret_string != " ":
checkCreate(scene, view, modelpath, mobj, string, ret_string, num,
event_pos, layoutPt)
