def le(el=None):
"""List elements under `el` or current element if no argument
specified.
Parameters
----------
el : str/melement/vec/None
The element or the path under which to look. If `None`, children
of current working element are displayed.
Returns
-------
List of path of child elements
"""
if el is None:
el = _moose.getCwe()
elif isinstance(el, str):
if not _moose.exists(el):
raise ValueError('no such element')
el = _moose.element(el)
elif isinstance(el, _moose.vec):
el = el[0]
print("Elements under '%s'" % el.path)
for ch in el.children:
print(" %s" % ch.path)
return [child.path for child in el.children]
def le(el=None):
"""List elements under `el` or current element if no argument
specified.
Parameters
----------
el : str/melement/vec/None
The element or the path under which to look. If `None`, children
of current working element are displayed.
Returns
-------
List of path of child elements
"""
if el is None:
el = _moose.getCwe()
elif isinstance(el, str):
if not _moose.exists(el):
raise ValueError('no such element')
el = _moose.element(el)
elif isinstance(el, _moose.vec):
el = el[0]
print('Elements under', el.path)
for ch in el.children:
print(ch.path)
return [child.path for child in el.children]
def getCwe():
"""Return current working elemement.
See also
--------
moose.setCwe
"""
return _moose.getCwe()
def pwe():
"""Print present working element. Convenience function for GENESIS
users. If you want to retrieve the element in stead of printing
the path, use moose.getCwe()
"""
pwe_ = _moose.getCwe()
print(pwe_.getPath())
return pwe_
def pwe():
"""Print present working element. Convenience function for GENESIS
users. If you want to retrieve the element in stead of printing
the path, use moose.getCwe()
"""
pwe_ = _moose.getCwe()
print(pwe_.getPath())
return pwe_
def pwe():
"""Print present working element's path.
Convenience function for GENESIS users. If you want to retrieve the element
in stead of printing the path, use moose.getCwe().
Returns
------
melement
current MOOSE element
Example
-------
>>> pwe()
'/'
"""
pwe_ = _moose.getCwe()
print(pwe_.path)
return pwe_
def le(el=None):
"""List elements under `el` or current element if no argument
specified.
Parameters
----------
el : str/melement/vec/None
The element or the path under which to look. If `None`, children of
current working element are displayed.
Returns
-------
List[str]
path of all children
"""
el = _moose.getCwe() if el is None else el
if isinstance(el, str):
el = _moose.element(el)
elif isinstance(el, _moose.vec):
el = el[0]
return _moose.le(el)
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
}
