def copy(src, dest, name="", n=1, toGlobal=False, copyExtMsg=False): """Make copies of a moose object. Parameters ---------- src : vec, element or str source object. dest : vec, element or str Destination object to copy into. name : str Name of the new object. If omitted, name of the original will be used. n : int Number of copies to make (default=1). toGlobal : bool Relevant for parallel environments only. If false, the copies will reside on local node, otherwise all nodes get the copies. copyExtMsg : bool If true, messages to/from external objects are also copied. Returns ------- vec newly copied vec """ if isinstance(src, str): src = _moose.element(src) if isinstance(dest, str): dest = _moose.element(dest) if not name: name = src.name return _moose.copy(src.id, dest, name, n, toGlobal, copyExtMsg)
def connect(src, srcfield, dest, destfield, msgtype="Single"): """Create a message between `srcfield` on `src` object to `destfield` on `dest` object. This function is used mainly, to say, connect two entities, and to denote what kind of give-and-take relationship they share. It enables the 'destfield' (of the 'destobj') to acquire the data, from 'srcfield'(of the 'src'). Parameters ---------- src : element/vec/string the source object (or its path) the one that provides information. srcfield : str source field on self (type of the information). destobj : element Destination object to connect to (The one that need to get information). destfield : str field to connect to on `destobj` msgtype : str type of the message. It ca be one of the following (default Single). - Single - OneToAll - AllToOne - OneToOne - Reduce - Sparse Returns ------- msgmanager: melement message-manager for the newly created message. Note ----- Alternatively, one can also use the following form:: >>> src.connect(srcfield, dest, destfield, msgtype) Examples -------- Connect the output of a pulse generator to the input of a spike generator:: >>> pulsegen = moose.PulseGen('pulsegen') >>> spikegen = moose.SpikeGen('spikegen') >>> moose.connect(pulsegen, 'output', spikegen, 'Vm') Or, >>> pulsegen.connect('output', spikegen, 'Vm') """ src = _moose.element(src) dest = _moose.element(dest) return src.connect(srcfield, dest, destfield, msgtype)
def append_finfodocs(classname, docstring, indent): """Append list of finfos in class name to docstring""" try: class_element = _moose.element('/classes/%s' % (classname)) except ValueError: raise NameError('class \'%s\' not defined.' % (classname)) for ftype, rname in finfotypes: docstring.write(toUnicode('\n*%s*\n' % (rname.capitalize()))) try: finfo = _moose.element('%s/%s' % (class_element.path, ftype)) for field in finfo.vec: docstring.write(toUnicode( '%s%s: %s\n' % (indent, field.fieldName, field.type))) except ValueError: docstring.write(toUnicode('%sNone\n' % (indent)))
def _appendFinfoDocs(classname, docstring, indent): """Append list of finfos in class name to docstring""" try: classElem = _moose.element('/classes/%s' % (classname)) except ValueError: raise NameError('class \'%s\' not defined.' % (classname)) for ftype, rname in finfotypes: docstring.write(u'\n*%s*\n' % (rname.capitalize())) try: finfo = _moose.element('%s/%s' % (classElem.path, ftype)) for field in finfo.vec: docstring.write(u'%s%s: %s\n' % (indent, field.fieldName, field.type)) except ValueError: docstring.write(u'%sNone\n' % (indent))
def disconnectReactant( reacOrEnz, reactant, duppool ): outMsgs = reacOrEnz.msgOut infoPath = duppool.path + '/info' if _moose.exists( infoPath ): info = _moose.element( infoPath ) else: info = _moose.Annotator( infoPath ) #_moose.le( reactant ) notes = "" #_moose.showmsg( reacOrEnz ) for i in outMsgs: #print "killing msg from {} to {}\nfor {} and {}".format( reacOrEnz.path, reactant.path, i.srcFieldsOnE1[0], i.srcFieldsOnE2[0] ) if i.e1 == reactant: msgStr = identifyMsg( i.e2, i.e2.srcFieldsOnE2[0], i.e1 ) if len( msgStr ) > 0: notes += msgStr _moose.delete( i ) elif i.e2 == reactant: msgStr = identifyMsg( i.e1[0], i.srcFieldsOnE1[0], i.e2[0] ) if len( msgStr ) > 0: notes += msgStr _moose.delete( i ) #print "MSGS to rebuild:", notes info.notes += notes
def proxify( reac, reacc, direction, pool, poolc ): reacc_elm = _moose.element( reacc ) reac_elm = _moose.element( reac ) # Preserve the rates which were set up for the x-compt reacn #_moose.showfield( reac ) dupname = pool.name + '_xfer_' + _moose.element(poolc).name #print "#############", pool, dupname, poolc if _moose.exists( reacc + '/' + dupname ): duppool = _moose.element( reacc + '/' + dupname ) else: # This also deals with cases where the duppool is buffered. duppool = _moose.copy(pool, reacc_elm, dupname ) duppool.diffConst = 0 # diffusion only happens in original compt removeEnzFromPool( duppool ) disconnectReactant( reac, pool, duppool ) _moose.connect( reac, direction, duppool, 'reac' )
def showmsg(el): """Print the incoming and outgoing messages of `el`. Parameters ---------- el : melement/vec/str Object whose messages are to be displayed. Returns ------- None """ obj = _moose.element(el) print('INCOMING:') for msg in obj.msgIn: print( msg.e2.path, msg.destFieldsOnE2, '<---', msg.e1.path, msg.srcFieldsOnE1) print('OUTGOING:') for msg in obj.msgOut: print( msg.e1.path, msg.srcFieldsOnE1, '--->', msg.e2.path, msg.destFieldsOnE2)
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 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 _getMooseDoc(tokens, inherited=False): """Return MOOSE builtin documentation. """ indent = ' ' docstring = io.StringIO() with closing(docstring): if not tokens: return "" try: classElem = _moose.element('/classes/%s' % (tokens[0])) except ValueError: raise NameError("Name '%s' not defined." % (tokens[0])) if len(tokens) > 1: docstring.write(getFieldDoc(tokens)) return docstring.getvalue() docstring.write(u'%s\n' % (classElem.docs)) _appendFinfoDocs(tokens[0], docstring, indent) if not inherited: return docstring.getvalue() mro = eval('_moose.%s' % (tokens[0])).mro() for class_ in mro[1:]: if class_ == _moose.melement: break docstring.write(u"\n# Inherited from '%s'\n" % (class_.__name__)) _appendFinfoDocs(class_.__name__, docstring, indent) if class_ == _moose.Neutral: break return docstring.getvalue()
def enzProxify( enz, enzc, direction, pool, poolc ): if enzc == poolc: return enze = _moose.element( enz ) # kcat and k2 are indept of volume, just time^-1 km = enze.numKm proxify( enz, enzc, direction, pool, poolc ) enze.numKm = km
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 reacProxify( reac, reacc, direction, pool, poolc ): if reacc == poolc: return reac_elm = _moose.element( reac ) kf = reac_elm.numKf kb = reac_elm.numKb proxify( reac, reacc, direction, pool, poolc ) reac_elm.numKf = kf reac_elm.numKb = kb
def findCompt( elm ): elm = _moose.element( elm ) pa = elm.parent while pa.path != '/': if _moose.Neutral(pa).isA[ 'ChemCompt' ]: return pa.path pa = pa.parent print( 'Error: No compartment parent found for ' + elm.path ) return '/'
def restoreOldRates( oldRates, msgs ): #print oldRates, msgs if len( msgs ) > 1 : m1 = msgs[1].split( msgSeparator )[0] elm = _moose.element( m1.split( ' ' )[0] ) if elm.isA[ 'ReacBase' ]: elm.numKf = oldRates[0] elm.numKb = oldRates[1] elif elm.isA[ 'enzBase' ]: elm.numKm = oldRates[0]
def getOldRates( msgs ): if len( msgs ) > 1 : m1 = msgs[1].split( msgSeparator )[0] elm = _moose.element( m1.split( ' ' )[0] ) if elm.isA[ 'ReacBase' ]: return [elm.numKf, elm.numKb] elif elm.isA[ 'EnzBase' ]: return [elm.numKm,] print( "Warning: getOldRates did not have any messages" ) return [0,]
def getmoosedoc(tokens, inherited=False): """Return MOOSE builtin documentation. Parameters ---------- tokens : (className, [fieldName]) tuple containing one or two strings specifying class name and field name (optional) to get documentation for. inherited: bool (default: False) include inherited fields. Returns ------- docstring : str Documentation string for class `className`.`fieldName` if both are specified, for the class `className` if fieldName is not specified. In the latter case, the fields and their data types and finfo types are listed. Raises ------ NameError If class or field does not exist. """ indent = ' ' docstring = StringIO() with closing(docstring): if not tokens: return "" try: class_element = _moose.element('/classes/%s' % (tokens[0])) except ValueError as e: raise NameError('name \'%s\' not defined.' % (tokens[0])) if len(tokens) > 1: docstring.write(toUnicode(getfielddoc(tokens))) else: docstring.write(toUnicode('%s\n' % (class_element.docs))) append_finfodocs(tokens[0], docstring, indent) if inherited: mro = eval('_moose.%s' % (tokens[0])).mro() for class_ in mro[1:]: if class_ == _moose.melement: break docstring.write( toUnicode('\n\n#Inherited from %s#\n' % (class_.__name__))) append_finfodocs(class_.__name__, docstring, indent) if class_ == _moose.Neutral: # Neutral is the toplevel moose class break return docstring.getvalue()
def showfields(el, field="*", showtype=False): """Show the fields of the element `el`, their data types and values in human readable format. Convenience function for GENESIS users. Parameters ---------- el : melement/str Element or path of an existing element. field : str Field to be displayed. If '*' (default), all fields are displayed. showtype : bool If True show the data type of each field. False by default. Returns ------- string """ if isinstance(el, str): if not _moose.exists(el): raise ValueError("no such element: %s" % el) el = _moose.element(el) result = [] if field == "*": value_field_dict = _moose.getFieldDict(el.className, "valueFinfo") max_type_len = max(len(dtype) for dtype in value_field_dict.values()) max_field_len = max(len(dtype) for dtype in value_field_dict.keys()) result.append("\n[" + el.path + "]\n") for key, dtype in sorted(value_field_dict.items()): if (dtype == "bad" or key == "this" or key == "dummy" or key == "me" or dtype.startswith("vector") or "ObjId" in dtype): continue value = el.getField(key) if showtype: typestr = dtype.ljust(max_type_len + 4) ## The following hack is for handling both Python 2 and ## 3. Directly putting the print command in the if/else ## clause causes syntax error in both systems. result.append(typestr + " ") result.append( key.ljust(max_field_len + 4) + "=" + str(value) + "\n") else: try: result.append(field + "=" + el.getField(field)) except AttributeError: pass # Genesis silently ignores non existent fields print("".join(result)) return "".join(result)
def showfield(el, field='*', showtype=False): """Show the fields of the element `el`, their data types and values in human readable format. Convenience function for GENESIS users. Parameters ---------- el : melement/str Element or path of an existing element. field : str Field to be displayed. If '*' (default), all fields are displayed. showtype : bool If True show the data type of each field. False by default. Returns ------- string """ if isinstance(el, str): if not _moose.exists(el): raise ValueError('no such element: %s' % el) el = _moose.element(el) result = [] if field == '*': value_field_dict = _moose.getFieldDict(el.className, 'valueFinfo') max_type_len = max(len(dtype) for dtype in value_field_dict.values()) max_field_len = max(len(dtype) for dtype in value_field_dict.keys()) result.append('\n[' + el.path + ']\n') for key, dtype in sorted(value_field_dict.items()): if dtype == 'bad' or key == 'this' or key == 'dummy' \ or key == 'me' or dtype.startswith('vector') \ or 'ObjId' in dtype: continue value = el.getField(key) if showtype: typestr = dtype.ljust(max_type_len + 4) # The following hack is for handling both Python 2 and # 3. Directly putting the print command in the if/else # clause causes syntax error in both systems. result.append(typestr + ' ') result.append( key.ljust(max_field_len + 4) + '=' + str(value) + '\n') else: try: result.append(field + '=' + el.getField(field)) except AttributeError: pass # Genesis silently ignores non existent fields print(''.join(result)) return ''.join(result)
def getmoosedoc(tokens, inherited=False): """Return MOOSE builtin documentation. Parameters ---------- tokens : (className, [fieldName]) tuple containing one or two strings specifying class name and field name (optional) to get documentation for. inherited: bool (default: False) include inherited fields. Returns ------- docstring : str Documentation string for class `className`.`fieldName` if both are specified, for the class `className` if fieldName is not specified. In the latter case, the fields and their data types and finfo types are listed. Raises ------ NameError If class or field does not exist. """ indent = ' ' docstring = StringIO() with closing(docstring): if not tokens: return "" try: class_element = _moose.element('/classes/%s' % (tokens[0])) except ValueError as e: raise NameError('name \'%s\' not defined.' % (tokens[0])) if len(tokens) > 1: docstring.write(toUnicode(getfielddoc(tokens))) else: docstring.write(toUnicode('%s\n' % (class_element.docs))) append_finfodocs(tokens[0], docstring, indent) if inherited: mro = eval('_moose.%s' % (tokens[0])).mro() for class_ in mro[1:]: if class_ == _moose.melement: break docstring.write(toUnicode( '\n\n#Inherited from %s#\n' % (class_.__name__))) append_finfodocs(class_.__name__, docstring, indent) if class_ == _moose.Neutral: # Neutral is the toplevel moose class break return docstring.getvalue()
def getFieldDoc(tokens, indent=''): """Return the documentation for field specified by `tokens`. Parameters ---------- tokens : (className, fieldName) str A sequence whose first element is a MOOSE class name and second is the field name. indent : str indentation (default: empty string) prepended to builtin documentation string. Returns ------- docstring : str string of the form `{indent}{className}.{fieldName}: {datatype} - {finfoType}\n{Description}\n` Raises ------ NameError If the specified fieldName is not present in the specified class. """ assert (len(tokens) > 1) classname = tokens[0] fieldname = tokens[1] while True: try: classelement = _moose.element('/classes/' + classname) for finfo in classelement.children: for fieldelement in finfo: baseinfo = '' if classname != tokens[0]: baseinfo = ' (inherited from {})'.format(classname) if fieldelement.fieldName == fieldname: # The field elements are # /classes/{ParentClass}[0]/{fieldElementType}[N]. finfotype = fieldelement.name return u'{indent}{classname}.{fieldname}: type={type}, finfotype={finfotype}{baseinfo}\n\t{docs}\n'.format( indent=indent, classname=tokens[0], fieldname=fieldname, type=fieldelement.type, finfotype=finfotype, baseinfo=baseinfo, docs=fieldelement.docs) classname = classelement.baseClass except ValueError: raise NameError('`%s` has no field called `%s`' % (tokens[0], tokens[1]))
def getfielddoc(tokens, indent=''): """Return the documentation for field specified by `tokens`. Parameters ---------- tokens : (className, fieldName) str A sequence whose first element is a MOOSE class name and second is the field name. indent : str indentation (default: empty string) prepended to builtin documentation string. Returns ------- docstring : str string of the form `{indent}{className}.{fieldName}: {datatype} - {finfoType}\n{Description}\n` Raises ------ NameError If the specified fieldName is not present in the specified class. """ assert(len(tokens) > 1) classname = tokens[0] fieldname = tokens[1] while True: try: classelement = _moose.element('/classes/' + classname) for finfo in classelement.children: for fieldelement in finfo: baseinfo = '' if classname != tokens[0]: baseinfo = ' (inherited from {})'.format(classname) if fieldelement.fieldName == fieldname: # The field elements are # /classes/{ParentClass}[0]/{fieldElementType}[N]. finfotype = fieldelement.name return '{indent}{classname}.{fieldname}: type={type}, finfotype={finfotype}{baseinfo}\n\t{docs}\n'.format( indent=indent, classname=tokens[0], fieldname=fieldname, type=fieldelement.type, finfotype=finfotype, baseinfo=baseinfo, docs=fieldelement.docs) classname = classelement.baseClass except ValueError: raise NameError('`%s` has no field called `%s`' % (tokens[0], tokens[1]))
def showmsg(el): """Print the incoming and outgoing messages of `el`. Parameters ---------- el : melement/vec/str Object whose messages are to be displayed. Returns ------- None """ print(_moose.showmsg(_moose.element(el)))
def element(arg): """Convert a path or an object to the appropriate builtin moose class instance Parameters ---------- arg : str/vec/moose object path of the moose element to be converted or another element (possibly available as a superclass instance). Returns ------- melement MOOSE element (object) corresponding to the `arg` converted to write subclass. """ return _moose.element(arg)
def showfield(el, field='*', showtype=False): """Show the fields of the element `el`, their data types and values in human readable format. Convenience function for GENESIS users. Parameters ---------- el : melement/str Element or path of an existing element. field : str Field to be displayed. If '*' (default), all fields are displayed. showtype : bool If True show the data type of each field. False by default. Returns ------- None """ if isinstance(el, str): if not _moose.exists(el): raise ValueError('no such element') el = _moose.element(el) if field == '*': value_field_dict = _moose.getFieldDict(el.className, 'valueFinfo') max_type_len = max(len(dtype) for dtype in value_field_dict.values()) max_field_len = max(len(dtype) for dtype in value_field_dict.keys()) print('\n[', el.path, ']') for key, dtype in sorted(value_field_dict.items()): if dtype == 'bad' or key == 'this' or key == 'dummy' or key == 'me' or dtype.startswith( 'vector') or 'ObjId' in dtype: continue value = el.getField(key) if showtype: typestr = dtype.ljust(max_type_len + 4) # The following hack is for handling both Python 2 and # 3. Directly putting the print command in the if/else # clause causes syntax error in both systems. print(typestr, end=' ') print(key.ljust(max_field_len + 4), '=', value) else: try: print(field, '=', el.getField(field)) except AttributeError: pass # Genesis silently ignores non existent fields
def listmsg(arg): """Return a list containing the incoming and outgoing messages of `el`. Parameters ---------- arg : melement/vec/str MOOSE object or path of the object to look into. Returns ------- msg : list List of Msg objects corresponding to incoming and outgoing connections of `arg`. """ obj = _moose.element(arg) assert obj return _moose.listmsg(obj)
def showmsg(el): """Print the incoming and outgoing messages of `el`. Parameters ---------- el : melement/vec/str Object whose messages are to be displayed. Returns ------- None """ obj = _moose.element(el) print('INCOMING:') for msg in obj.msgIn: print(msg.e2.path, msg.destFieldsOnE2, '<---', msg.e1.path, msg.srcFieldsOnE1) print('OUTGOING:') for msg in obj.msgOut: print(msg.e1.path, msg.srcFieldsOnE1, '--->', msg.e2.path, msg.destFieldsOnE2)
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 listmsg(el): """Return a list containing the incoming and outgoing messages of `el`. Parameters ---------- el : melement/vec/str MOOSE object or path of the object to look into. Returns ------- msg : list List of Msg objects corresponding to incoming and outgoing connections of `el`. """ obj = _moose.element(el) ret = [] for msg in obj.inMsg: ret.append(msg) for msg in obj.outMsg: ret.append(msg) return ret
def listmsg(el): """Return a list containing the incoming and outgoing messages of `el`. Parameters ---------- el : melement/vec/str MOOSE object or path of the object to look into. Returns ------- msg : list List of Msg objects corresponding to incoming and outgoing connections of `el`. """ obj = _moose.element(el) ret = [] for msg in obj.msgIn: ret.append(msg) for msg in obj.msgOut: ret.append(msg) return ret
def record(obj, field=None, label=None): """""" global _counter # Checking if object is an iterable like list or a tuple, but not a string. if hasattr(obj, "__iter__"): return [record(o, field, label) for o in obj] if isinstance(obj, str): obj = _moose.element(obj) if field is None: field = _defaultField(obj) path = _path.format(_counter) _counter += 1 p = _Plot(path, obj, field, label) _plots.append(p) _moose.connect(p, "requestData", obj, "get_" + field) _moose.useClock(_tick, path, "process") return p
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 }