def _crn(compt):
nodes = {}
reacs = _moose.wildcardFind(compt.path + '/##[TYPE=Reac]')
reacs += _moose.wildcardFind(compt.path + '/##[TYPE=ZombieReac]')
dot = ['digraph %s {\n\t overlap=false' % compt.name]
for r in reacs:
rNode = _addNode(r, nodes, dot)
for s in r.neighbors['sub']:
sNode = _addNode(s, nodes, dot)
dot.append('\t%s -> %s' % (sNode, rNode))
for p in r.neighbors['prd']:
pNode = _addNode(p, nodes, dot)
dot.append('\t%s -> %s' % (rNode, pNode))
dot.append('}')
return '\n'.join(dot)
def removeEnzFromPool( pool ):
kids = _moose.wildcardFind( pool.path + "/#" )
for i in kids:
if i.isA[ 'EnzBase' ]:
_moose.delete( i )
elif i.isA[ 'Function' ]:
_moose.delete( i )
def removeEnzFromPool(pool):
kids = _moose.wildcardFind(pool.path + "/#")
for i in kids:
if i.isA['EnzBase']:
_moose.delete(i)
elif i.isA['Function']:
_moose.delete(i)
def loadGenCsp(target, filename, solver="gsl"):
target = target.replace(" ", "")
path = '/' + target
#Moving the model under /modelname/model and graphs under /model/graphs.
#This is passed while loading-time which will be easy for setting the stoich path
mpath = '/' + target + '/' + "model"
if moose.exists(mpath):
moose.delete(mpath)
modelpath1 = moose.Neutral('%s' % (target))
modelpath = moose.Neutral('%s/%s' % (modelpath1.path, "model"))
model = mutils.loadModel(filename, modelpath.path, solver)
if not moose.exists(modelpath1.path + '/data'):
graphspath = moose.Neutral('%s/%s' % (modelpath1.path, "data"))
dataPath = moose.element(modelpath1.path + '/data')
i = 0
nGraphs = moose.wildcardFind(modelpath.path + '/graphs/##[TYPE=Table2]')
for graphs in nGraphs:
if not moose.exists(dataPath.path + '/graph_' + str(i)):
graphspath = moose.Neutral('%s/%s' %
(dataPath.path, "graph_" + str(i)))
else:
graphspath = moose.element(dataPath.path + '/graph_' + str(i))
moose.move(graphs.path, graphspath)
if len(nGraphs) > 0:
i = i + 1
for moregraphs in moose.wildcardFind(modelpath.path +
'/moregraphs/##[TYPE=Table2]'):
if not moose.exists(dataPath.path + '/graph_' + str(i)):
graphspath = moose.Neutral('%s/%s' %
(dataPath.path, "graph_" + str(i)))
else:
graphspath = moose.element(dataPath.path + '/graph_' + str(i))
moose.move(moregraphs.path, graphspath)
if moose.exists(modelpath.path + '/info'):
AnnotatorOld = moose.element(modelpath.path + '/info')
AnnotatorNew = moose.Annotator(modelpath1.path + '/info')
AnnotatorNew.runtime = AnnotatorOld.runtime
AnnotatorNew.solver = AnnotatorOld.solver
moose.delete(AnnotatorOld)
moose.delete(modelpath.path + '/graphs')
moose.delete(modelpath.path + '/moregraphs')
return (modelpath1, modelpath1.path)
def morphologyToGraphviz(filename=None, pat='/##[TYPE=Compartment]'):
'''Write Electrical network to a dot graph.
Params:
:filename: Default None. Write graphviz file to this path. If None, write to
stdout.
:pat: Compartment path. By default, search for all moose.Compartment.
'''
def fix(path):
'''Fix a given path so it can be written to a graphviz file'''
# If no [0] is at end of the path then append it.
global pathPat_
if not pathPat_.match(path):
path = path + '[0]'
return path
compList = _moose.wildcardFind(pat)
if not compList:
logger_.warn("No compartment found")
dot = []
dot.append("digraph G {")
dot.append("\tconcentrate=true;")
for c in compList:
if c.neighbors['raxial']:
for n in c.neighbors['raxial']:
lhs = fix(c.path)
rhs = fix(n.path)
dot.append('\t"{}" -> "{}";'.format(lhs, rhs))
elif c.neighbors['axial']:
for n in c.neighbors['axial']:
lhs = fix(c.path)
rhs = fix(n.path)
dot.append('\t"{}" -> "{}" [dir=back];'.format(lhs, rhs))
else:
p = fix(c.path)
dot.append('\t"{}"'.format(p))
dot.append('}')
dot = '\n'.join(dot)
if not filename:
print(dot)
else:
with open(filename, 'w') as graphviz:
logger_.info(
"Writing compartment topology to file {}".format(filename))
graphviz.write(dot)
return True
def findXreacs( basepath, reacType ):
reacs = _moose.wildcardFind( basepath + '/##[ISA=' + reacType + 'Base]' )
ret = []
for i in reacs:
reacc = findCompt( i )
subs = i.neighbors['subOut']
prds = i.neighbors['prdOut']
subc = [findCompt(j) for j in subs]
prdc = [findCompt(j) for j in prds]
enzc = []
if reacType == 'Enz':
enzc = [reacc]
if not checkEqual( subc + prdc + enzc ):
ret.append( [i, reacc, subs, subc, prds, prdc ])
return ret
def findXreacs(basepath, reacType):
reacs = _moose.wildcardFind(basepath + '/##[ISA=' + reacType + ']')
ret = []
for i in reacs:
reacc = findCompt(i)
subs = i.neighbors['subOut']
prds = i.neighbors['prdOut']
subc = [findCompt(j) for j in subs]
prdc = [findCompt(j) for j in prds]
enzc = []
if reacType == 'EnzBase':
enzc = [reacc]
if not checkEqual(subc + prdc + enzc):
ret.append([i, reacc, subs, subc, prds, prdc])
return ret
def restoreXreacs( basepath ):
proxyInfo = _moose.wildcardFind( basepath + "/##/#_xfer_#/info" )
for i in proxyInfo:
msgs = i.notes.split( msgSeparator )
oldRates = getOldRates( msgs )
#print( "Deleting {}".format( i.parent.path ) )
#print msgs
_moose.delete( i.parent )
for j in msgs[1:]:
if len( j ) > 0:
args = j.split( ' ' )
assert( len( args ) == 4 )
#_moose.showfield( args[0] )
_moose.connect( args[0], args[1], args[2], args[3] )
#print( "Reconnecting {}".format( args ) )
#_moose.showfield( args[0] )
restoreOldRates( oldRates, msgs )
def restoreXreacs(basepath):
proxyInfo = _moose.wildcardFind(basepath + "/##/#_xfer_#/info")
for i in proxyInfo:
msgs = i.notes.split(msgSeparator)
oldRates = getOldRates(msgs)
#print( "Deleting {}".format( i.parent.path ) )
#print msgs
_moose.delete(i.parent)
for j in msgs[1:]:
if len(j) > 0:
args = j.split(' ')
assert (len(args) == 4)
#_moose.showfield( args[0] )
_moose.connect(args[0], args[1], args[2], args[3])
#print( "Reconnecting {}".format( args ) )
#_moose.showfield( args[0] )
restoreOldRates(oldRates, msgs)
def restoreXreacs(basepath):
proxyInfo = _moose.wildcardFind(basepath + "/##/#_xfer_#/info")
for i in proxyInfo:
msgs = i.notes.split(msgSeparator)
oldRates = getOldRates(msgs)
#print( "Deleting {}".format( i.parent.path ) )
_moose.delete(i.parent)
for j in msgs[1:]:
if len(j) > 0:
args = j.split(' ')
assert (len(args) == 4)
#_moose.showfield( args[0] )
#check to see if object exist before moose.connect, cases where object is deleted but
#_xref_ annotation info field still holds the reference
if (_moose.exists(args[0]) and _moose.exists(args[2])):
moose.connect(args[0], args[1], args[2], args[3])
#print( "Reconnecting {}".format( args ) )
#_moose.showfield( args[0] )
restoreOldRates(oldRates, msgs)
def wildcardFind(pattern):
"""Find objects using wildcard pattern
Parameters
----------
pattern: str
Wildcard (see note below)
.. note:: Wildcard
MOOSE allows wildcard expressions of the form
{PATH}/{WILDCARD}[{CONDITION}].
{PATH} is valid path in the element tree, {WILDCARD} can be
# or ##. # causes the search to be restricted to the children
of the element specified by {PATH}. ## makes the search to
recursively go through all the descendants of the {PATH} element.
{CONDITION} can be:
- TYPE={CLASSNAME}: an element satisfies this condition if it is of
class {CLASSNAME}.
- ISA={CLASSNAME}: alias for TYPE={CLASSNAME}
- CLASS={CLASSNAME}: alias for TYPE={CLASSNAME}
- FIELD({FIELDNAME}){OPERATOR}{VALUE} : compare field {FIELDNAME} with
{VALUE} by {OPERATOR} where {OPERATOR} is a comparison
operator (=, !=, >, <, >=, <=).
Returns
-------
list
A list of found MOOSE objects
Examples
--------
Following returns a list of all the objects under /mymodel whose Vm field
is >= -65.
>>> moose.wildcardFind("/mymodel/##[FIELD(Vm)>=-65]")
"""
return [__to_melement(x) for x in _moose.wildcardFind(pattern)]
super().setField(k, v)
else:
# Support for dead python2.
super(melement, self).__init__(obj)
for k, v in kwargs.items():
super(melement, self).setField(k, v)
def __to_melement(obj):
global __moose_classes__
mc = __moose_classes__[obj.type](obj)
return mc
# Create MOOSE classes from available Cinfos.
for p in _moose.wildcardFind("/##[TYPE=Cinfo]"):
if sys.version_info.major > 2:
cls = type(
p.name,
(melement, ),
{
"__type__": p.name,
"__doc__": _moose.__generatedoc__(p.name)
},
)
else:
# Python2.
cls = type(
str(p.name),
(melement, ),
{
def loadFile(filename, target, solver="gsl", merge=True):
"""Try to load a model from specified `filename` under the element
`target`.
if `merge` is True, the contents are just loaded at target. If
false, everything is deleted from the parent of target unless the
parent is root.
Returns
-------
a dict containing at least these three entries:
modeltype: type of the loaded model.
subtype: subtype of the loaded model, None if no specific subtype
modelroot: root element of the model, None if could not be located - as is the case with Python scripts
"""
loaderror = ""
num = 1
libsfound = True
model = '/'
newTarget = target
while moose.exists(newTarget):
newTarget = target + "-" + str(num)
num = num + 1
target = newTarget
istext = True
with open(filename, 'rb') as infile:
istext = mtypes.istextfile(infile)
if not istext:
print('Cannot handle any binary formats yet')
return None
# parent, child = posixpath.split(target)
# p = moose.Neutral(parent)
# if not merge and p.path != '/':
# for ch in p.children:
# moose.delete(ch)
try:
modeltype = mtypes.getType(filename)
subtype = mtypes.getSubtype(filename, modeltype)
except KeyError:
raise FileLoadError('Do not know how to handle this filetype: %s' %
(filename))
pwe = moose.getCwe()
#self.statusBar.showMessage('Loading model, please wait')
# app = QtGui.qApp
# app.setOverrideCursor(QtGui.QCursor(Qt.Qt.BusyCursor)) #shows a hourglass - or a busy/working arrow
if modeltype == 'genesis':
if subtype == 'kkit' or subtype == 'prototype':
model, modelpath = loadGenCsp(target, filename, solver)
xcord, ycord = [], []
if moose.exists(moose.element(modelpath).path):
process = True
compt = len(moose.wildcardFind(modelpath +
'/##[ISA=CubeMesh]'))
if not compt:
loaderror = "Model has no compartment, atleast one compartment should exist to display the widget"
process = False
else:
p = len(moose.wildcardFind(modelpath +
'/##[ISA=PoolBase]'))
if p < 2:
loaderror = "Model has no pool, atleast two pool should exist to display the widget"
process = False
if process:
if moose.exists(moose.element(modelpath).path):
mObj = moose.wildcardFind(
moose.element(modelpath).path + '/##[ISA=PoolBase]' +
',' + moose.element(modelpath).path +
'/##[ISA=ReacBase]' + ',' +
moose.element(modelpath).path + '/##[ISA=EnzBase]' +
',' + moose.element(modelpath).path +
'/##[ISA=StimulusTable]')
for p in mObj:
if not isinstance(moose.element(p.parent),
moose.CplxEnzBase):
xcord.append(moose.element(p.path + '/info').x)
ycord.append(moose.element(p.path + '/info').y)
recalculatecoordinatesforKkit(mObj, xcord, ycord)
for ememb in moose.wildcardFind(
moose.element(modelpath).path +
'/##[ISA=EnzBase]'):
objInfo = ememb.path + '/info'
#Enzyme's textcolor (from kkit) will be bgcolor (in moose)
if moose.exists(objInfo):
bgcolor = moose.element(objInfo).color
moose.element(objInfo).color = moose.element(
objInfo).textColor
moose.element(objInfo).textColor = bgcolor
moose.Annotator(moose.element(modelpath).path +
'/info').modeltype = "kkit"
else:
print(" path doesn't exists")
#moose.le(modelpath)
else:
print('Only kkit and prototype files can be loaded.')
elif modeltype == 'cspace':
model, modelpath = loadGenCsp(target, filename)
if moose.exists(modelpath):
moose.Annotator(
(moose.element(modelpath).path + '/info')).modeltype = "cspace"
addSolver(modelpath, 'gsl')
elif modeltype == 'xml':
if subtype == 'neuroml':
popdict, projdict = neuroml.loadNeuroML_L123(filename)
# Circus to get the container of populations from loaded neuroml
for popinfo in list(popdict.values()):
for cell in list(popinfo[1].values()):
solver = moose.HSolve(cell.path + "/hsolve")
solver.target = cell.path
# model = cell.parent
# break
# break
# Moving model to a new location under the model name
# model name is the filename without extension
model = moose.Neutral("/" + splitext(basename(filename))[0])
element = moose.Neutral(model.path + "/model")
if (moose.exists("/cells")): moose.move("/cells", element.path)
if (moose.exists("/elec")): moose.move("/elec", model.path)
if (moose.exists("/library")): moose.move("/library", model.path)
# moose.move("cells/", cell.path)
elif subtype == 'sbml':
foundLibSBML_ = False
try:
import libsbml
foundLibSBML_ = True
except ImportError:
pass
if foundLibSBML_:
if target != '/':
if moose.exists(target):
moose.delete(target)
model, loaderror = mooseReadSBML(filename, target)
if moose.exists(moose.element(model).path):
moose.Annotator(moose.element(model).path +
'/info').modeltype = "sbml"
addSolver(target, 'gsl')
libsfound = foundLibSBML_
else:
raise FileLoadError('Do not know how to handle this filetype: %s' %
(filename))
moose.setCwe(
pwe
) # The MOOSE loadModel changes the current working element to newly loaded model. We revert that behaviour
# TODO: check with Aditya how to specify the target for
# neuroml reader
# app.restoreOverrideCursor()
return {
'modeltype': modeltype,
'subtype': subtype,
'model': model,
'foundlib': libsfound,
'loaderror': loaderror
}
