def createSpecies(basePath, model, comptSbmlidMooseIdMap, specInfoMap, modelAnnotaInfo): # ToDo: # - Need to add group name if exist in pool # - Notes # print "species " if not (model.getNumSpecies()): return (False, "number of species is zero") else: for sindex in range(0, model.getNumSpecies()): spe = model.getSpecies(sindex) group = "" specAnnoInfo = {} specAnnoInfo = getObjAnnotation(spe, modelAnnotaInfo) if "Group" in specAnnoInfo: group = specAnnoInfo["Group"] sName = None sId = spe.getId() if spe.isSetName(): sName = spe.getName() sName = sName.replace(" ", "_space_") if spe.isSetCompartment(): comptId = spe.getCompartment() if not (sName): sName = sId constant = spe.getConstant() boundaryCondition = spe.getBoundaryCondition() comptEl = comptSbmlidMooseIdMap[comptId]["MooseId"].path hasonlySubUnit = spe.getHasOnlySubstanceUnits() # "false": is {unit of amount}/{unit of size} (i.e., concentration or density). # "true": then the value is interpreted as having a unit of amount only. if group: if moose.exists(comptEl + '/' + group): comptEl = comptEl + '/' + group else: comptEl = (moose.Neutral(comptEl + '/' + group)).path if (boundaryCondition): poolId = moose.BufPool(comptEl + '/' + sName) else: poolId = moose.Pool(comptEl + '/' + sName) if (spe.isSetNotes): pullnotes(spe, poolId) if specAnnoInfo: if not moose.exists(poolId.path + '/info'): poolInfo = moose.Annotator(poolId.path + '/info') else: poolInfo = moose.element(poolId.path + '/info') for k, v in list(specAnnoInfo.items()): if k == 'xCord': poolInfo.x = float(v) elif k == 'yCord': poolInfo.y = float(v) elif k == 'bgColor': poolInfo.color = v else: poolInfo.textColor = v specInfoMap[sId] = { "Mpath": poolId, "const": constant, "bcondition": boundaryCondition, "hassubunit": hasonlySubUnit, "comptId": comptSbmlidMooseIdMap[comptId]["MooseId"] } initvalue = 0.0 unitfactor, unitset, unittype = transformUnit(spe, hasonlySubUnit) if hasonlySubUnit == True: if spe.isSetInitialAmount(): initvalue = spe.getInitialAmount() # populating nInit, will automatically calculate the # concInit. if not (unitset): # if unit is not set, # default unit is assumed as Mole in SBML unitfactor = pow(6.0221409e23, 1) unittype = "Mole" initvalue = initvalue * unitfactor elif spe.isSetInitialConcentration(): initvalue = spe.getInitialConcentration() print( " Since hasonlySubUnit is true and concentration is set units are not checked" ) poolId.nInit = initvalue elif hasonlySubUnit == False: # ToDo : check 00976 if spe.isSetInitialAmount(): initvalue = spe.getInitialAmount() # initAmount is set we need to convert to concentration initvalue = initvalue / comptSbmlidMooseIdMap[comptId][ "size"] elif spe.isSetInitialConcentration(): initvalue = spe.getInitialConcentration() if not unitset: # print " unit is not set" unitfactor = pow(10, -3) initvalue = initvalue * unitfactor poolId.concInit = initvalue else: nr = model.getNumRules() found = False for nrItem in range(0, nr): rule = model.getRule(nrItem) assignRule = rule.isAssignment() if (assignRule): rule_variable = rule.getVariable() if (rule_variable == sId): found = True break if not (found): print( "Invalid SBML: Either initialConcentration or initialAmount must be set or it should be found in assignmentRule but non happening for ", sName) return ( False, "Invalid SBML: Either initialConcentration or initialAmount must be set or it should be found in assignmentRule but non happening for ", sName) return (True, " ")
def setData(self, index, value, role=QtCore.Qt.EditRole): if not index.isValid() or index.row() >= len( self.fields) or index.column() != 1: return False field = self.fields[index.row()] if (role == QtCore.Qt.CheckStateRole): if (index.column() == 1): self.checkState_ = value return True else: value = str( value.strip()) # convert Qt datastructure to Python string if len(value) == 0: return False if field == "Notes": field = "notes" ann = moose.Annotator(self.mooseObject.path + '/info') oldValue = ann.getField(field) value = type(oldValue)(value) ann.setField(field, value) self.undoStack.append((index, oldValue)) elif field == "vector": for ch in ['[', ']']: if ch in value: value = value.replace(ch, " ") value = value.replace(",", " ") valuelist = [] if value.find(',') != -1: valuelist = value.split(",") elif value.find(' ') != -1: valuelist = value.split(" ") else: valuelist = value vectorlist = [] for d in valuelist: try: float(d) vectorlist.append(float(d)) except: pass from numpy import array a = array(vectorlist) self.mooseObject.setField(field, a) else: oldValue = self.mooseObject.getField(field) if field != "isBuffered": value = type(oldValue)(value) self.mooseObject.setField(field, value) else: if self.mooseObject.className == "ZombiePool" or self.mooseObject.className == "ZombieBufPool": QMessageBox.warning( None, 'Solver is set, Could not set the value', '\n Unset the solver by clicking \n run widget -> Preferences -> Exponential Euler->Apply' ) else: if value.lower() in ("yes", "true", "t", "1"): self.mooseObject.setField(field, True) else: self.mooseObject.setField(field, False) self.undoStack.append((index, oldValue)) if field == 'name': self.emit(QtCore.SIGNAL('objectNameChanged(PyQt_PyObject)'), self.mooseObject) return True #self.dataChanged.emit(index, index) return True
def checkCreate(scene, view, modelpath, mobj, string, ret_string, num, event_pos, layoutPt): # The variable 'compt' will be empty when dropping cubeMesh,cyclMesh, but rest it shd be # compartment # if modelpath.find('/',1) > -1: # modelRoot = modelpath[0:modelpath.find('/',1)] # else: # modelRoot = modelpath if moose.exists(modelpath + '/info'): mType = moose.Annotator((moose.element(modelpath + '/info'))).modeltype itemAtView = view.sceneContainerPt.itemAt(view.mapToScene(event_pos)) pos = view.mapToScene(event_pos) modelpath = moose.element(modelpath) if num: string_num = ret_string + str(num) else: string_num = ret_string if string == "CubeMesh" or string == "CylMesh": if string == "CylMesh": mobj = moose.CylMesh(modelpath.path + '/' + string_num) else: mobj = moose.CubeMesh(modelpath.path + '/' + string_num) mobj.volume = 1e-15 mesh = moose.element(mobj.path + '/mesh') qGItem = ComptItem(scene, pos.toPoint().x(), pos.toPoint().y(), 100, 100, mobj) qGItem.setPen( QtGui.QPen(Qt.QColor(66, 66, 66, 100), 1, Qt.Qt.SolidLine, Qt.Qt.RoundCap, Qt.Qt.RoundJoin)) view.sceneContainerPt.addItem(qGItem) qGItem.cmptEmitter.connect( qGItem.cmptEmitter, QtCore.SIGNAL("qgtextPositionChange(PyQt_PyObject)"), layoutPt.positionChange1) qGItem.cmptEmitter.connect( qGItem.cmptEmitter, QtCore.SIGNAL("qgtextItemSelectedChange(PyQt_PyObject)"), layoutPt.objectEditSlot) compartment = qGItem layoutPt.qGraCompt[mobj] = qGItem view.emit(QtCore.SIGNAL("dropped"), mobj) elif string == "Pool" or string == "BufPool": #getting pos with respect to compartment otherwise if compartment is moved then pos would be wrong posWrtComp = (itemAtView.mapFromScene(pos)).toPoint() if string == "Pool": poolObj = moose.Pool(mobj.path + '/' + string_num) else: poolObj = moose.BufPool(mobj.path + '/' + string_num) poolinfo = moose.Annotator(poolObj.path + '/info') #Compartment's one Pool object is picked to get the font size qGItem = PoolItem(poolObj, itemAtView) layoutPt.mooseId_GObj[poolObj] = qGItem posWrtComp = (itemAtView.mapFromScene(pos)).toPoint() bgcolor = getRandColor() qGItem.setDisplayProperties(posWrtComp.x(), posWrtComp.y(), QtGui.QColor('green'), bgcolor) poolinfo.color = str(bgcolor.getRgb()) view.emit(QtCore.SIGNAL("dropped"), poolObj) setupItem(modelpath.path, layoutPt.srcdesConnection) layoutPt.drawLine_arrow(False) x, y = roundoff(qGItem.scenePos(), layoutPt) poolinfo.x = x poolinfo.y = y #Dropping is on compartment then update Compart size if isinstance(mobj, moose.ChemCompt): compt = layoutPt.qGraCompt[moose.element(mobj)] updateCompartmentSize(compt) elif string == "Reac": posWrtComp = (itemAtView.mapFromScene(pos)).toPoint() reacObj = moose.Reac(mobj.path + '/' + string_num) reacinfo = moose.Annotator(reacObj.path + '/info') qGItem = ReacItem(reacObj, itemAtView) qGItem.setDisplayProperties(posWrtComp.x(), posWrtComp.y(), "white", "white") #if mType == "new_kkit": # reacinfo.x = posWrtComp.x() # reacinfo.y = posWrtComp.y() layoutPt.mooseId_GObj[reacObj] = qGItem view.emit(QtCore.SIGNAL("dropped"), reacObj) setupItem(modelpath.path, layoutPt.srcdesConnection) layoutPt.drawLine_arrow(False) #Dropping is on compartment then update Compart size if isinstance(mobj, moose.ChemCompt): compt = layoutPt.qGraCompt[moose.element(mobj)] updateCompartmentSize(compt) x, y = roundoff(qGItem.scenePos(), layoutPt) reacinfo.x = x reacinfo.y = y elif string == "StimulusTable": posWrtComp = (itemAtView.mapFromScene(pos)).toPoint() tabObj = moose.StimulusTable(mobj.path + '/' + string_num) tabinfo = moose.Annotator(tabObj.path + '/info') qGItem = TableItem(tabObj, itemAtView) qGItem.setDisplayProperties(posWrtComp.x(), posWrtComp.y(), QtGui.QColor('white'), QtGui.QColor('white')) #if mType == "new_kkit": #tabinfo.x = posWrtComp.x() #tabinfo.y = posWrtComp.y() layoutPt.mooseId_GObj[tabObj] = qGItem view.emit(QtCore.SIGNAL("dropped"), tabObj) setupItem(modelpath.path, layoutPt.srcdesConnection) layoutPt.drawLine_arrow(False) #Dropping is on compartment then update Compart size if isinstance(mobj, moose.ChemCompt): compt = layoutPt.qGraCompt[moose.element(mobj)] updateCompartmentSize(compt) x, y = roundoff(qGItem.scenePos(), layoutPt) tabinfo.x = x tabinfo.y = y elif string == "Function": posWrtComp = (itemAtView.mapFromScene(pos)).toPoint() funcObj = moose.Function(mobj.path + '/' + string_num) funcinfo = moose.Annotator(funcObj.path + '/info') #moose.connect( funcObj, 'valueOut', mobj ,'setN' ) poolclass = ["ZombieBufPool", "BufPool"] comptclass = ["CubeMesh", "cyclMesh"] if mobj.className in poolclass: funcParent = layoutPt.mooseId_GObj[element(mobj.path)] elif mobj.className in comptclass: funcParent = layoutPt.qGraCompt[moose.element(mobj)] posWrtComp = funcParent.mapFromScene(pos).toPoint() #posWrtComp = (itemAtView.mapFromScene(pos)).toPoint() qGItem = FuncItem(funcObj, funcParent) #print " function ", posWrtComp.x(),posWrtComp.y() qGItem.setDisplayProperties(posWrtComp.x(), posWrtComp.y(), QtGui.QColor('red'), QtGui.QColor('green')) layoutPt.mooseId_GObj[funcObj] = qGItem #if mType == "new_kkit": #funcinfo.x = posWrtComp.x() #funcinfo.y = posWrtComp.y() view.emit(QtCore.SIGNAL("dropped"), funcObj) setupItem(modelpath.path, layoutPt.srcdesConnection) layoutPt.drawLine_arrow(False) #Dropping is on compartment then update Compart size mooseCmpt = findCompartment(mobj) if isinstance(mooseCmpt, moose.ChemCompt): compt = layoutPt.qGraCompt[moose.element(mooseCmpt)] updateCompartmentSize(compt) x, y = roundoff(qGItem.scenePos(), layoutPt) funcinfo.x = x funcinfo.y = y elif string == "Enz" or string == "MMenz": #If 2 enz has same pool parent, then pos of the 2nd enz shd be displaced by some position, need to check how to deal with it posWrtComp = pos enzPool = layoutPt.mooseId_GObj[mobj] if ((mobj.parent).className == "Enz"): QtGui.QMessageBox.information( None, 'Drop Not possible', '\'{newString}\' has to have Pool as its parent and not Enzyme Complex' .format(newString=string), QtGui.QMessageBox.Ok) return else: enzparent = findCompartment(mobj) parentcompt = layoutPt.qGraCompt[enzparent] if string == "Enz": enzObj = moose.Enz(moose.element(mobj).path + '/' + string_num) enzinfo = moose.Annotator(enzObj.path + '/info') moose.connect(enzObj, 'enz', mobj, 'reac') qGItem = EnzItem(enzObj, parentcompt) layoutPt.mooseId_GObj[enzObj] = qGItem posWrtComp = pos bgcolor = getRandColor() qGItem.setDisplayProperties(posWrtComp.x(), posWrtComp.y() - 40, QtGui.QColor('green'), bgcolor) x, y = roundoff(qGItem.scenePos(), layoutPt) enzinfo.x = x enzinfo.y = y enzinfo.color = str(bgcolor.name()) enzinfo.textColor = str(QtGui.QColor('green').name()) #if mType == "new_kkit": #enzinfo.x = posWrtComp.x() #enzinfo.y = posWrtComp.y() #enzinfo.color = str(bgcolor.name()) e = moose.Annotator(enzinfo) #e.x = posWrtComp.x() #e.y = posWrtComp.y() Enz_cplx = enzObj.path + '/' + string_num + '_cplx' cplxItem = moose.Pool(Enz_cplx) cplxinfo = moose.Annotator(cplxItem.path + '/info') qGEnz = layoutPt.mooseId_GObj[enzObj] qGItem = CplxItem(cplxItem, qGEnz) layoutPt.mooseId_GObj[cplxItem] = qGItem enzboundingRect = qGEnz.boundingRect() moose.connect(enzObj, 'cplx', cplxItem, 'reac') qGItem.setDisplayProperties(enzboundingRect.height() / 2, enzboundingRect.height() - 40, QtGui.QColor('white'), QtGui.QColor('white')) #cplxinfo.x = enzboundingRect.height()/2 #cplxinfo.y = enzboundingRect.height()-60 view.emit(QtCore.SIGNAL("dropped"), enzObj) else: enzObj = moose.MMenz(mobj.path + '/' + string_num) enzinfo = moose.Annotator(enzObj.path + '/info') moose.connect(mobj, "nOut", enzObj, "enzDest") qGItem = MMEnzItem(enzObj, parentcompt) posWrtComp = pos bgcolor = getRandColor() qGItem.setDisplayProperties(posWrtComp.x(), posWrtComp.y() - 30, QtGui.QColor('green'), bgcolor) #enzinfo.x = posWrtComp.x() #enzinfo.y = posWrtComp.y() enzinfo.color = str(bgcolor.name()) layoutPt.mooseId_GObj[enzObj] = qGItem view.emit(QtCore.SIGNAL("dropped"), enzObj) x, y = roundoff(qGItem.scenePos(), layoutPt) enzinfo.x = x enzinfo.y = y setupItem(modelpath.path, layoutPt.srcdesConnection) layoutPt.drawLine_arrow(False) #Dropping is on compartment then update Compart size if isinstance(enzparent, moose.ChemCompt): updateCompartmentSize(parentcompt) if view.iconScale != 1: view.updateScale(view.iconScale)
def createReaction(model, specInfoMap, modelAnnotaInfo, globparameterIdValue): # print " reaction " # Things done for reaction # --Reaction is not created, if substrate and product is missing # --Reaction is created under first substrate's compartment if substrate not found then product # --Reaction is created if substrate or product is missing, but while run time in GUI atleast I have stopped # ToDo # -- I need to check here if any substance/product is if ( constant == true && bcondition == false) # cout <<"The species "<< name << " should not appear in reactant or product as per sbml Rules"<< endl; errorFlag = True reactSBMLIdMooseId = {} msg = "" rName = "" reaction_ = None for ritem in range(0, model.getNumReactions()): reactionCreated = False groupName = "" reac = model.getReaction(ritem) group = "" reacAnnoInfo = {} reacAnnoInfo = getObjAnnotation(reac, modelAnnotaInfo) if "Group" in reacAnnoInfo: group = reacAnnoInfo["Group"] if (reac.isSetId()): rId = reac.getId() if (reac.isSetName()): rName = reac.getName() rName = rName.replace(" ", "_space_") if not (rName): rName = rId rev = reac.getReversible() fast = reac.getFast() if (fast): print(" warning: for now fast attribute is not handled \"", rName, "\"") if (reac.getAnnotation() is not None): groupName = getEnzAnnotation(reac, modelAnnotaInfo, rev, globparameterIdValue, specInfoMap) if (groupName != "" and list(modelAnnotaInfo[groupName]["stage"])[0] == 3): reaction_, reactionCreated = setupEnzymaticReaction( reac, groupName, rName, specInfoMap, modelAnnotaInfo) reaction_.k3 = modelAnnotaInfo[groupName]['k3'] reaction_.k2 = modelAnnotaInfo[groupName]['k2'] reaction_.concK1 = modelAnnotaInfo[groupName]['k1'] if reactionCreated: if (reac.isSetNotes): pullnotes(reac, reaction_) reacAnnoInfo = {} reacAnnoInfo = getObjAnnotation(reac, modelAnnotaInfo) if reacAnnoInfo: if not moose.exists(reaction_.path + '/info'): reacInfo = moose.Annotator(reaction_.path + '/info') else: reacInfo = moose.element(reaction_.path + '/info') for k, v in list(reacAnnoInfo.items()): if k == 'xCord': reacInfo.x = float(v) elif k == 'yCord': reacInfo.y = float(v) elif k == 'bgColor': reacInfo.color = v else: reacInfo.textColor = v elif (groupName == ""): numRcts = reac.getNumReactants() numPdts = reac.getNumProducts() nummodifiers = reac.getNumModifiers() if not (numRcts and numPdts): print( "Warning: %s" % (rName), " : Substrate or Product is missing, we will be skiping creating this reaction in MOOSE" ) reactionCreated = False elif (reac.getNumModifiers() > 0): reactionCreated, reaction_ = setupMMEnzymeReaction( reac, rName, specInfoMap, reactSBMLIdMooseId, modelAnnotaInfo, model, globparameterIdValue) # elif (reac.getNumModifiers() > 0): # reactionCreated = setupMMEnzymeReaction(reac,rName,specInfoMap,reactSBMLIdMooseId,modelAnnotaInfo,model,globparameterIdValue) # reaction_ = reactSBMLIdMooseId['classical']['MooseId'] # reactionType = "MMEnz" elif (numRcts): # In moose, reactions compartment are decided from first Substrate compartment info # substrate is missing then check for product if (reac.getNumReactants()): react = reac.getReactant(reac.getNumReactants() - 1) # react = reac.getReactant(0) sp = react.getSpecies() sp = str(idBeginWith(sp)) speCompt = specInfoMap[sp]["comptId"].path if group: if moose.exists(speCompt + '/' + group): speCompt = speCompt + '/' + group else: speCompt = (moose.Neutral(speCompt + '/' + group)).path reaction_ = moose.Reac(speCompt + '/' + rName) reactionCreated = True reactSBMLIdMooseId[rName] = { "MooseId": reaction_, "className ": "reaction" } elif (numPdts): # In moose, reactions compartment are decided from first Substrate compartment info # substrate is missing then check for product if (reac.getNumProducts()): react = reac.getProducts(0) sp = react.getSpecies() sp = str(idBeginWith(sp)) speCompt = specInfoMap[sp]["comptId"].path reaction_ = moose.Reac(speCompt + '/' + rName) reactionCreated = True reactSBMLIdMooseId[rId] = { "MooseId": reaction_, "className": "reaction" } if reactionCreated: if (reac.isSetNotes): pullnotes(reac, reaction_) reacAnnoInfo = {} reacAnnoInfo = getObjAnnotation(reac, modelAnnotaInfo) if reacAnnoInfo: if not moose.exists(reaction_.path + '/info'): reacInfo = moose.Annotator(reaction_.path + '/info') else: reacInfo = moose.element(reaction_.path + '/info') for k, v in list(reacAnnoInfo.items()): if k == 'xCord': reacInfo.x = float(v) elif k == 'yCord': reacInfo.y = float(v) elif k == 'bgColor': reacInfo.color = v else: reacInfo.textColor = v addSubPrd(reac, rName, "sub", reactSBMLIdMooseId, specInfoMap) addSubPrd(reac, rName, "prd", reactSBMLIdMooseId, specInfoMap) if reac.isSetKineticLaw(): klaw = reac.getKineticLaw() mmsg = "" errorFlag, mmsg, kfvalue, kbvalue = getKLaw( model, klaw, rev, globparameterIdValue, specInfoMap) if not errorFlag: msg = "Error while importing reaction \"" + \ rName + "\"\n Error in kinetics law " if mmsg != "": msg = msg + mmsg return (errorFlag, msg) else: # print " reactSBMLIdMooseId # ",reactSBMLIdMooseId[rName]["nSub"], " prd # ",reactSBMLIdMooseId[rName]["nPrd"] if reaction_.className == "Reac": subn = reactSBMLIdMooseId[rName]["nSub"] prdn = reactSBMLIdMooseId[rName]["nPrd"] reaction_.Kf = kfvalue # * pow(1e-3,subn-1) reaction_.Kb = kbvalue # * pow(1e-3,prdn-1) elif reaction_.className == "MMenz": reaction_.kcat = kfvalue reaction_.Km = kbvalue return (errorFlag, msg)
def autoCoordinates(meshEntry, srcdesConnection): G = nx.Graph() for cmpt, memb in meshEntry.items(): if memb in ["enzyme"]: for enzObj in find_index(memb, 'enzyme'): #G.add_node(enzObj.path) G.add_node(enzObj.path, label='', shape='ellipse', color='', style='filled', fontname='Helvetica', fontsize=12, fontcolor='blue') for cmpt, memb in meshEntry.items(): #if memb.has_key if memb in ["pool", "cplx", "reaction"]: for poolObj in find_index(memb, 'pool'): #G.add_node(poolObj.path) G.add_node(poolObj.path, label=poolObj.name, shape='box', color='', style='filled', fontname='Helvetica', fontsize=9, fontcolor='blue') for cplxObj in find_index(memb, 'cplx'): G.add_node(cplxObj.path) G.add_node(cplxObj.path, label=cplxObj.name, shape='box', color='', style='filled', fontname='Helvetica', fontsize=12, fontcolor='blue') #G.add_edge((cplxObj.parent).path,cplxObj.path) for reaObj in find_index(memb, 'reaction'): #G.add_node(reaObj.path) G.add_node(reaObj.path, label='', shape='circle', color='') for inn, out in list(srcdesConnection.items()): if isinstance(out, tuple): if len(out[0]) == 0: print(inn.className + ':' + inn.name + " doesn't have input message") else: for items in (items for items in out[0]): G.add_edge(moose.element(items[0]).path, inn.path) if len(out[1]) == 0: print(inn.className + ':' + inn.name + "doesn't have output mssg") else: for items in (items for items in out[1]): G.add_edge(inn.path, moose.element(items[0]).path) elif isinstance(out, list): if len(out) == 0: print("Func pool doesn't have sumtotal") else: for items in (items for items in out): G.add_edge(moose.element(items[0]).path, inn.path) position = graphviz_layout(G) xcord, ycord = [], [] for item in position.items(): xy = item[1] xroundoff = round(xy[0], 0) yroundoff = round(xy[1], 0) xcord.append(xroundoff) ycord.append(yroundoff) for item in position.items(): xy = item[1] anno = moose.Annotator(item[0] + '/info') anno.x = xy[0] anno.y = xy[1]
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 popdict.values(): for cell in 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 }
def writeEnz(modelpath, f, sceneitems): enzList = moose.wildcardFind(modelpath + '/##[ISA=EnzBase]') for enz in enzList: 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 enzParent = enz.parent if (isinstance(enzParent.className, moose.Pool)) or (isinstance( enzParent.className, moose.ZombiePool)): print(" raise exception enz doesn't have pool as parent") 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 cplx = enz.neighbors['cplx'][0] nInit = cplx.nInit[0] if sceneitems != None: # value = sceneitems[enz] # x = calPrime(value['x']) # y = calPrime(value['y']) x = sceneitems[enz]['x'] y = sceneitems[enz]['y'] einfo = enz.path + '/info' if moose.exists(einfo): color = moose.Annotator(einfo).getField('color') color = getColorCheck(color, GENESIS_COLOR_SEQUENCE) textcolor = moose.Annotator(einfo).getField('textColor') textcolor = getColorCheck(textcolor, GENESIS_COLOR_SEQUENCE) if color == "" or color == " ": color = getRandColor() if textcolor == "" or textcolor == " ": textcolor = getRandColor() f.write("simundump kenz /kinetics/" + trimPath(enz) + " " + str(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(0) + "\n") return enzList
def writeReac(modelpath, cremodel_, sceneitems): for reac in moose.wildcardFind(modelpath + '/##[ISA=ReacBase]'): reacSub = reac.neighbors["sub"] reacPrd = reac.neighbors["prd"] if (len(reacSub) != 0 and len(reacPrd) != 0): reaction = cremodel_.createReaction() reacannoexist = False reacGpname = " " cleanReacname = convertSpecialChar(reac.name) reaction.setId(str(idBeginWith(cleanReacname + "_" + str(reac.getId().value) + "_" + str(reac.getDataIndex()) + "_"))) reaction.setName(cleanReacname) #Kf = reac.numKf #Kb = reac.numKb Kf = reac.Kf Kb = reac.Kb if Kb == 0.0: reaction.setReversible(False) else: reaction.setReversible(True) reaction.setFast(False) if moose.exists(reac.path + '/info'): Anno = moose.Annotator(reac.path + '/info') if Anno.notes != "": cleanNotesR = convertNotesSpecialChar(Anno.notes) notesStringR = "<body xmlns=\"http://www.w3.org/1999/xhtml\">\n \t \t" + \ cleanNotesR + "\n\t </body>" reaction.setNotes(notesStringR) element = moose.element(reac) ele = getGroupinfo(element) if element.className == "Neutral" or sceneitems or Anno.x or Anno.y: reacannoexist = True if reacannoexist: reacAnno = "<moose:ModelAnnotation>\n" if ele.className == "Neutral": reacAnno = reacAnno + "<moose:Group>" + ele.name + "</moose:Group>\n" if sceneitems: #Saved from GUI, then scene co-ordinates are passed reacAnno = reacAnno + "<moose:xCord>" + \ str(sceneitems[reac]['x']) + "</moose:xCord>\n" + \ "<moose:yCord>" + \ str(sceneitems[reac]['y'])+ "</moose:yCord>\n" else: #Saved from cmdline,genesis coordinates are kept as its # SBML, cspace, python, then auto-coordinates are done #and coordinates are updated in moose Annotation field reacAnno = reacAnno + "<moose:xCord>" + \ str(Anno.x) + "</moose:xCord>\n" + \ "<moose:yCord>" + \ str(Anno.y)+ "</moose:yCord>\n" if Anno.color: reacAnno = reacAnno + "<moose:bgColor>" + Anno.color + "</moose:bgColor>\n" if Anno.textColor: reacAnno = reacAnno + "<moose:textColor>" + \ Anno.textColor + "</moose:textColor>\n" reacAnno = reacAnno + "</moose:ModelAnnotation>" reaction.setAnnotation(reacAnno) kl_s, sRL, pRL, compt = "", "", "", "" if not reacSub and not reacPrd: print(" Reaction ", reac.name, "missing substrate and product") else: kfl = reaction.createKineticLaw() if reacSub: noofSub, sRateLaw = getSubprd( cremodel_, False, "sub", reacSub) if noofSub: comptVec = findCompartment(moose.element(reacSub[0])) if not isinstance(moose.element( comptVec), moose.ChemCompt): return -2 else: compt = comptVec.name + "_" + \ str(comptVec.getId().value) + "_" + \ str(comptVec.getDataIndex()) + "_" cleanReacname = cleanReacname + "_" + \ str(reac.getId().value) + "_" + \ str(reac.getDataIndex()) + "_" kfparm = idBeginWith(cleanReacname) + "_" + "Kf" sRL = compt + " * " + \ idBeginWith(cleanReacname) + "_Kf * " + sRateLaw unit = parmUnit(noofSub - 1, cremodel_) printParameters(kfl, kfparm, Kf, unit) #kl_s = compt+"(" +sRL kl_s = sRL else: print(reac.name + " has no substrate") return -2 else: print(" Substrate missing for reaction ", reac.name) if reacPrd: noofPrd, pRateLaw = getSubprd( cremodel_, False, "prd", reacPrd) if noofPrd: if Kb: kbparm = idBeginWith(cleanReacname) + "_" + "Kb" pRL = compt + " * " + \ idBeginWith(cleanReacname) + \ "_Kb * " + pRateLaw unit = parmUnit(noofPrd - 1, cremodel_) printParameters(kfl, kbparm, Kb, unit) #kl_s = kl_s+ "- "+pRL+")" kl_s = kl_s + "-" + pRL else: print(reac.name + " has no product") return -2 else: print(" Product missing for reaction ", reac.name) kfl.setFormula(kl_s) kfl.setNotes( "<body xmlns=\"http://www.w3.org/1999/xhtml\">\n\t\t" + kl_s + "\n \t </body>") kfl.setFormula(kl_s) else: print(" Reaction ", reac.name, "missing substrate and product")
def writePool(modelpath, f, volIndex, sceneitems): error = "" color = "" textcolor = "" for p in moose.wildcardFind(modelpath + '/##[0][ISA=PoolBase]'): if findCompartment(p) == moose.element('/'): error += "\n%s doesn't have compartment ignored to write to genesis" % p else: slave_enable = 0 if p.isA["BufPool"] or p.isA["ZombieBufPool"]: pool_children = p.children if pool_children == 0: slave_enable = 4 else: for pchild in pool_children: if (not pchild.isA["ZombieFunction"]) and ( not pchild.isA["Function"]): slave_enable = 4 else: slave_enable = 0 break pp = moose.element(p.parent) if (not pp.isA['Enz']) and (not pp.isA['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 enzymeMerge(comptD, comptS, key, poolListind): war_msg = "" RE_Duplicated, RE_Notcopiedyet, RE_Daggling = [], [], [] comptDpath = moose.element(comptD[key]).path comptSpath = moose.element(comptS[key]).path objD = moose.element(comptDpath).parent.name objS = moose.element(comptSpath).parent.name #nzyListina => enzyListind enzyListind = moose.wildcardFind(comptDpath + '/##[ISA=EnzBase]') enzyListins = moose.wildcardFind(comptSpath + '/##[ISA=EnzBase]') for es in enzyListins: eSsubname, eSprdname = [], [] eSsubname = subprdList(es, "sub") eSprdname = subprdList(es, "prd") allexists, allexistp = False, False allclean = False poolinDlist = poolListind[findCompartment(es).name] for pD in poolinDlist: if es.parent.name == pD.name: edpath = es.parent.path.replace(objS, objD) if not moose.exists(edpath + '/' + es.name): #This will take care # -- If same enzparent name but different enzyme name # -- or different parent/enzyme name if eSsubname and eSprdname: allexists = checkexist(eSsubname, objS, objD) allexistp = checkexist(eSprdname, objS, objD) if allexists and allexistp: enzPool = moose.element(pD.path) edpath = es.parent.path.replace(objS, objD) enz = moose.element( moose.copy(es, moose.element(edpath))) enzPool = enz.parent if es.className in ["ZombieEnz", "Enz"]: moose.connect(moose.element(enz), "enz", enzPool, "reac") if es.className in ["ZombieMMenz", "MMenz"]: moose.connect(enzPool, "nOut", enz, "enzDest") connectObj(enz, eSsubname, "sub", comptD, war_msg) connectObj(enz, eSprdname, "prd", comptD, war_msg) allclean = True else: # didn't find sub or prd for this Enzyme RE_Notcopiedyet.append(es) else: # -- it is dagging reaction RE_Daggling.append(es) else: #Same Enzyme name # -- Same substrate and product including same volume then don't copy # -- different substrate/product or if sub/prd's volume is different then DUPLICATE the Enzyme allclean = False ed = moose.element(es.path.replace(objS, objD)) eDsubname = subprdList(ed, "sub") eSsubname = subprdList(es, "sub") hasSamenoofsublen, hasSameS, hasSamevols = same_len_name_vol( eDsubname, eSsubname) eDprdname = subprdList(ed, "prd") eSprdname = subprdList(es, "prd") hasSamenoofprdlen, hasSameP, hasSamevolp = same_len_name_vol( eDprdname, eSprdname) if not all((hasSamenoofsublen, hasSameS, hasSamevols, hasSamenoofprdlen, hasSameP, hasSamevolp)): # May be different substrate or product or volume of Sub/prd may be different, # Duplicating the enzyme if eSsubname and eSprdname: allexists, allexistp = False, False allexists = checkexist(eSsubname, objS, objD) allexistp = checkexist(eSprdname, objS, objD) if allexists and allexistp: es.name = es.name + "_duplicated" if es.className in ["ZombieEnz", "Enz"]: edpath = es.parent.path.replace(objS, objD) enz = moose.copy(es, moose.element(edpath)) moose.connect(enz, 'enz', edpath, 'reac') if es.className in ["ZombieMMenz", "MMenz"]: edpath = es.parent.path.replace(objS, objD) enz = moose.copy(es, moose.element(edpath)) enzinfo = moose.Annotator(enz.path + '/info') moose.connect( moose.element(enz).parent, "nOut", moose.element(enz), "enzDest") #moose.connect(moose.element(enz),"enz",moose.element(enz).parent,"reac") connectObj(enz, eSsubname, "sub", comptD, war_msg) connectObj(enz, eSprdname, "prd", comptD, war_msg) RE_Duplicated.append(enz) allclean = True else: allclean = False else: allclean = True if not allclean: # didn't find sub or prd for this enzyme # -- it may be connected Enzyme cplx if eSsubname and eSprdname: RE_Notcopiedyet.append(es) else: RE_Daggling.append(es) return RE_Duplicated, RE_Notcopiedyet, RE_Daggling
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 enzParent.isA['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 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 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 """ num = 1 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) if moose.exists(moose.element(modelpath).path): 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 popdict.values(): for cell in 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': if target != '/': if moose.exists(target): moose.delete(target) model = mooseReadSBML(filename, target) if moose.exists(moose.element(model).path): moose.Annotator(moose.element(model).path + '/info').modeltype = "sbml" addSolver(target, 'gsl') 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}
def autoCoordinates(meshEntry, srcdesConnection): global pygraphvizFound_ positionInfo = {} if not pygraphvizFound_: print('[warn] python-pygraphviz could not be found.') print('\tMOOSE Install pygraphviz to use this feature') return positionInfo if meshEntry: #G = nx.Graph() G = pgv.AGraph() for cmpt, memb in list(meshEntry.items()): for enzObj in find_index(memb, 'enzyme'): #G.add_node(enzObj.path) G.add_node(enzObj.path, label='', shape='ellipse', color='', style='filled', fontname='Helvetica', fontsize=12, fontcolor='blue') for cmpt, memb in list(meshEntry.items()): for poolObj in find_index(memb, 'pool'): #G.add_node(poolObj.path) G.add_node(poolObj.path, label=poolObj.name, shape='box', color='', style='filled', fontname='Helvetica', fontsize=12, fontcolor='blue') for cplxObj in find_index(memb, 'cplx'): G.add_node(cplxObj.path) G.add_node(cplxObj.path, label=cplxObj.name, shape='box', color='', style='filled', fontname='Helvetica', fontsize=12, fontcolor='blue') #G.add_edge((cplxObj.parent).path,cplxObj.path) for reaObj in find_index(memb, 'reaction'): #G.add_node(reaObj.path) G.add_node(reaObj.path, label='', shape='circle', color='') for inn, out in list(srcdesConnection.items()): if (inn.className == 'ZombieReac'): arrowcolor = 'green' elif (inn.className == 'ZombieEnz'): arrowcolor = 'red' else: arrowcolor = 'blue' if isinstance(out, tuple): if len(out[0]) == 0: print(inn.className + ':' + inn.name + " doesn't have input message") else: for items in (items for items in out[0]): G.add_edge(moose.element(items[0]).path, inn.path) if len(out[1]) == 0: print(inn.className + ':' + inn.name + "doesn't have output mssg") else: for items in (items for items in out[1]): G.add_edge(inn.path, moose.element(items[0]).path) elif isinstance(out, list): if len(out) == 0: print("Func pool doesn't have sumtotal") else: for items in (items for items in out): G.add_edge(moose.element(items[0]).path, inn.path) # if int( nx.__version__.split( '.' )[-1] ) >= 11: # position = nx.spring_layout( G ) # else: # position = nx.graphviz_layout(G, prog = 'dot') # for item in position.items(): # xy = item[1] # ann = moose.Annotator(item[0]+'/info') # ann.x = xy[0] # ann.y = xy[1] # positioninfo[(moose.element(item[0]))] ={'x':float(xy[0]),'y':float(xy[1])} G.layout() for n in G.nodes(): value = str(n.attr['pos']) valuelist = (value.split(',')) positionInfo[(moose.element(n))] = { 'x': float(valuelist[0]), 'y': float(valuelist[1]) } ann = moose.Annotator(moose.element(n).path + '/info') ann.x = float(valuelist[0]) ann.y = float(valuelist[1]) return positionInfo
def enzymeMerge(comptA, comptB, key, poolListina): war_msg = "" RE_Duplicated, RE_Notcopiedyet, RE_Daggling = [], [], [] comptApath = moose.element(comptA[key]).path comptBpath = moose.element(comptB[key]).path objA = moose.element(comptApath).parent.name objB = moose.element(comptBpath).parent.name enzyListina = moose.wildcardFind(comptApath + '/##[ISA=EnzBase]') enzyListinb = moose.wildcardFind(comptBpath + '/##[ISA=EnzBase]') for eb in enzyListinb: eBsubname, eBprdname = [], [] eBsubname = subprdList(eb, "sub") eBprdname = subprdList(eb, "prd") allexists, allexistp = False, False allclean = False poolinAlist = poolListina[findCompartment(eb).name] for pA in poolinAlist: if eb.parent.name == pA.name: eapath = eb.parent.path.replace(objB, objA) if not moose.exists(eapath + '/' + eb.name): #This will take care # -- If same enzparent name but different enzyme name # -- or different parent/enzyme name if eBsubname and eBprdname: allexists = checkexist(eBsubname, objB, objA) allexistp = checkexist(eBprdname, objB, objA) if allexists and allexistp: enzPool = moose.element(pA.path) eapath = eb.parent.path.replace(objB, objA) enz = moose.element( moose.copy(eb, moose.element(eapath))) enzPool = enz.parent if eb.className in ["ZombieEnz", "Enz"]: moose.connect(moose.element(enz), "enz", enzPool, "reac") if eb.className in ["ZombieMMenz", "MMenz"]: moose.connect(enzPool, "nOut", enz, "enzDest") connectObj(enz, eBsubname, "sub", comptA, war_msg) connectObj(enz, eBprdname, "prd", comptA, war_msg) allclean = True else: # didn't find sub or prd for this Enzyme #print ("didn't find sub or prd for this reaction" ) RE_Notcopiedyet.append(eb) else: # -- it is dagging reaction RE_Daggling.append(eb) #print ("This reaction \""+eb.path+"\" has no substrate/product daggling reaction are not copied") #war_msg = war_msg+"\nThis reaction \""+eb.path+"\" has no substrate/product daggling reaction are not copied" else: #Same Enzyme name # -- Same substrate and product including same volume then don't copy # -- different substrate/product or if sub/prd's volume is different then DUPLICATE the Enzyme allclean = False #ea = moose.element('/'+obj+'/'+enzcompartment.name+'/'+enzparent.name+'/'+eb.name) #ea = moose.element(pA.path+'/'+eb.name) ea = moose.element(eb.path.replace(objB, objA)) eAsubname = subprdList(ea, "sub") eBsubname = subprdList(eb, "sub") hasSamenoofsublen, hasSameS, hasSamevols = same_len_name_vol( eAsubname, eBsubname) eAprdname = subprdList(ea, "prd") eBprdname = subprdList(eb, "prd") hasSamenoofprdlen, hasSameP, hasSamevolp = same_len_name_vol( eAprdname, eBprdname) if not all((hasSamenoofsublen, hasSameS, hasSamevols, hasSamenoofprdlen, hasSameP, hasSamevolp)): # May be different substrate or product or volume of Sub/prd may be different, # Duplicating the enzyme if eBsubname and eBprdname: allexists, allexistp = False, False allexists = checkexist(eBsubname, objB, objA) allexistp = checkexist(eBprdname, objB, objA) if allexists and allexistp: eb.name = eb.name + "_duplicated" if eb.className in ["ZombieEnz", "Enz"]: eapath = eb.parent.path.replace(objB, objA) enz = moose.copy(eb, moose.element(eapath)) moose.connect(enz, 'enz', eapath, 'reac') if eb.className in ["ZombieMMenz", "MMenz"]: eapath = eb.parent.path.replace(objB, objA) enz = moose.copy(eb.name, moose.element(eapath)) enzinfo = moose.Annotator(enz.path + '/info') moose.connect( moose.element(enz).parent, "nOut", moose.element(enz), "enzDest") #moose.connect(moose.element(enz),"enz",moose.element(enz).parent,"reac") #moose.connect( cplxItem, 'reac', enz, 'cplx' ) connectObj(enz, eBsubname, "sub", comptA, war_msg) connectObj(enz, eBprdname, "prd", comptA, war_msg) RE_Duplicated.append(enz) allclean = True else: allclean = False else: allclean = True if not allclean: # didn't find sub or prd for this enzyme # -- it may be connected Enzyme cplx if eBsubname and eBprdname: RE_Notcopiedyet.append(eb) #print ("This Enzyme \""+eb.path+"\" has no substrate/product must be connect to cplx") #war_msg = war_msg+ "\nThis Enzyme \""+rb.path+"\" has no substrate/product must be connect to cplx" else: RE_Daggling.append(eb) #print ("This enzyme \""+eb.path+"\" has no substrate/product daggling reaction are not copied") #war_msg = war_msg+"\nThis reaction \""+eb.path+"\" has no substrate/product daggling reaction are not copied" return RE_Duplicated, RE_Notcopiedyet, RE_Daggling
def writeEnz(modelpath, cremodel_, sceneitems,groupInfo): for enz in moose.wildcardFind(modelpath + '/##[ISA=EnzBase]'): enzannoexist = False enzGpnCorCol = " " cleanEnzname = convertSpecialChar(enz.name) enzSubt = () compt = "" notesE = "" groupName = moose.element("/") if moose.exists(enz.path + '/info'): groupName = moose.element("/") Anno = moose.Annotator(enz.path + '/info') notesE = Anno.notes element = moose.element(enz) ele = getGroupinfo(element) ele = findGroup_compt(element) if ele.className == "Neutral" or sceneitems or Anno.x or Anno.y: enzannoexist = True if enzannoexist: enzAnno = "<moose:ModelAnnotation>\n" if ele.className == "Neutral": groupName = ele #enzGpnCorCol = "<moose:Group>" + ele.name + "</moose:Group>\n" # if ele.name not in groupInfo: # groupInfo[ele.name]=[setId] # else: # groupInfo[ele.name].append(setId) if sceneitems: #Saved from GUI, then scene co-ordinates are passed enzGpnCorCol = enzGpnCorCol + "<moose:xCord>" + \ str(sceneitems[enz]['x']) + "</moose:xCord>\n" + \ "<moose:yCord>" + \ str(sceneitems[enz]['y'])+ "</moose:yCord>\n" else: #Saved from cmdline,genesis coordinates are kept as its # SBML, cspace, python, then auto-coordinates are done #and coordinates are updated in moose Annotation field enzGpnCorCol = enzGpnCorCol + "<moose:xCord>" + \ str(Anno.x) + "</moose:xCord>\n" + \ "<moose:yCord>" + \ str(Anno.y)+ "</moose:yCord>\n" if Anno.color: enzGpnCorCol = enzGpnCorCol + "<moose:bgColor>" + Anno.color + "</moose:bgColor>\n" if Anno.textColor: enzGpnCorCol = enzGpnCorCol + "<moose:textColor>" + \ Anno.textColor + "</moose:textColor>\n" if (enz.className == "Enz" or enz.className == "ZombieEnz"): # Enz cplx is written into 2 reaction S+E-> SE*, SE* -> E+P foundEnzymeComplex = False comptVec = findCompartment(moose.element(enz)) if not isinstance(moose.element(comptVec), moose.ChemCompt): return -2 else: compt = comptVec.name + "_" + \ str(comptVec.getId().value) + "_" + \ str(comptVec.getDataIndex()) + "_" #Writting out S+E -> SE* enzsetId = str(idBeginWith(cleanEnzname + "_" + str(enz.getId().value) + "_" + str(enz.getDataIndex()) + "_" + "Complex_formation_")) #Finding Enzyme parent (E), each enzyme should just have one parent, multiple parent not right! secplxerror = "" enzSubt = () enzOut = enz.neighbors["enzOut"] if not enzOut: secplxerror = "enzyme parent missing " else: enzAnno = "<moose:EnzymaticReaction>\n" listofname(enzOut, True) enzSubt = enzOut if len(nameList_) != 1: secplxerror = secplxerror +" multiple enzyme parent present" else: for i in range(0, len(nameList_)): enzAnno = enzAnno + "<moose:enzyme>" + \ (str(idBeginWith(convertSpecialChar( nameList_[i])))) + "</moose:enzyme>\n" #Finding Substrate, (S) enzSub = enz.neighbors["sub"] if not enzSub: secplxerror = secplxerror + " substrate missing" else: listofname(enzSub, True) enzSubt += enzSub for i in range(0, len(nameList_)): enzAnno = enzAnno + "<moose:substrates>" + \ nameList_[i] + "</moose:substrates>\n" #Finding product, which in this case the cplx (SE*) enzPrd = enz.neighbors["cplxDest"] noofPrd = len(enzPrd) if not enzPrd: secplxerror = secplxerror + " enzymecplx missing which act as product " else: listofname(enzPrd, True) for i in range(0, len(nameList_)): enzAnno = enzAnno + "<moose:product>" + \ nameList_[i] + "</moose:product>\n" foundEnzymeComplex = True if foundEnzymeComplex: # Only if S+E->SE* found, reaction is created enzyme = cremodel_.createReaction() if notesE != "": cleanNotesE = convertNotesSpecialChar(notesE) notesStringE = "<body xmlns=\"http://www.w3.org/1999/xhtml\">\n \t \t" + \ cleanNotesE + "\n\t </body>" enzyme.setNotes(notesStringE) enzyme.setId(enzsetId) enzyme.setName(str(idBeginWith(convertSpecialCharshot(enz.name)))) enzyme.setFast(False) enzyme.setReversible(True) k1 = enz.concK1 k2 = enz.k2 k3 = enz.k3 enzAnno = enzAnno + "<moose:groupName>" + cleanEnzname + "_" + \ str(enz.getId().value) + "_" + \ str(enz.getDataIndex()) + "_" + "</moose:groupName>\n" enzAnno = enzAnno + "<moose:stage>1</moose:stage>\n" if enzannoexist: enzAnno = enzAnno + enzGpnCorCol enzAnno = enzAnno + "</moose:EnzymaticReaction>" enzyme.setAnnotation(enzAnno) if enzSubt: rate_law = "k1" noofSub, sRateLaw = getSubprd(cremodel_, True, "sub", enzSubt) rate_law = compt + " * ( " + rate_law + " * " + sRateLaw if enzPrd: noofPrd, sRateLaw = getSubprd(cremodel_, True, "prd", enzPrd) rate_law = rate_law + " - " + " k2 " + ' * ' + sRateLaw +" )" kl = enzyme.createKineticLaw() kl.setFormula(rate_law) kl.setNotes("<body xmlns=\"http://www.w3.org/1999/xhtml\">\n\t\t" + \ rate_law + "\n \t </body>") unit = parmUnit(noofSub - 1, cremodel_) printParameters(kl, "k1", k1, unit) punit = parmUnit(noofPrd - 1, cremodel_) printParameters(kl, "k2", k2, punit) if groupName != moose.element('/'): if groupName not in groupInfo: groupInfo[groupName]=[enzsetId] else: groupInfo[groupName].append(enzsetId) else: if secplxerror: print ("\'"+enz.name+"\' this enzyme is not written to file because,"+ secplxerror) #Here SE* -> E+ P foundEnzymeEP = False enzsetIdP = str(idBeginWith(cleanEnzname + "_" + str(enz.getId().value) + "_" + str(enz.getDataIndex()) + "_" + "Product_formation_")) cplxeperror = "" #enzSubt = "" enzOut = enz.neighbors["enzOut"] if not enzOut: cplxepeerror = "enzyme parent missing " else: enzAnno2 = "<moose:EnzymaticReaction>\n" listofname(enzOut, True) #enzSubt = enzOut if len(nameList_) != 1: cplxeperror = cplxeperror +" multiple enzyme parent present" else: # for i in range(0, len(nameList_)): # enzEnz = "<moose:enzyme>" + \ # (str(idBeginWith(convertSpecialChar( # nameList_[i])))) + "</moose:enzyme>\n" #Finding Substrate, which is (SE*) enzSub = enz.neighbors["cplxDest"] noofSub = len(enzSub) listofname(enzSub, True) if not enzSub: cplxeperror = cplxeperror +"complex missing which act as substrate " else: for i in range(0, len(nameList_)): enzAnno2 =enzAnno2 +"<moose:complex>" + \ nameList_[i] + "</moose:complex>\n" listofname(enzOut, True) for i in range(0, len(nameList_)): enzAnno2 = enzAnno2 +"<moose:enzyme>" + \ (str(idBeginWith(convertSpecialChar( nameList_[i])))) + "</moose:enzyme>\n" enzPrd = enz.neighbors["prd"] noofPrd = len(enzPrd) if not enzPrd: cplxeperror = cplxeperror + "product missing " else: listofname(enzPrd,True) for i in range(0, len(nameList_)): enzAnno2 = enzAnno2 + "<moose:product>" + \ nameList_[i] + "</moose:product>\n" enzAnno2 += "<moose:groupName>" + cleanEnzname + "_" + \ str(enz.getId().value) + "_" + \ str(enz.getDataIndex()) + "_" + "</moose:groupName>\n" enzAnno2 += "<moose:stage>2</moose:stage> \n" if enzannoexist: enzAnno2 = enzAnno2 + enzGpnCorCol enzAnno2 += "</moose:EnzymaticReaction>" foundEnzymeEP = True if foundEnzymeEP: enzyme = cremodel_.createReaction() enzyme.setId(enzsetIdP) enzyme.setName(str(idBeginWith(convertSpecialCharshot(enz.name)))) enzyme.setFast(False) enzyme.setReversible(False) enzyme.setAnnotation(enzAnno2) noofSub, sRateLaw = getSubprd(cremodel_, True, "sub", enzSub) enzprdt = () enzPrdt = enzPrd+enzOut noofprd, sRateLaw2 = getSubprd(cremodel_, True, "prd", enzPrdt) enzrate_law = compt + " * k3" + '*' + sRateLaw kl = enzyme.createKineticLaw() kl.setFormula(enzrate_law) kl.setNotes( "<body xmlns=\"http://www.w3.org/1999/xhtml\">\n\t\t" + enzrate_law + "\n \t </body>") unit = parmUnit(noofSub - 1, cremodel_) printParameters(kl, "k3", k3, unit) if groupName != moose.element('/'): if groupName not in groupInfo: groupInfo[groupName]=[enzsetIdP] else: groupInfo[groupName].append(enzsetIdP) else: print (cplxeperror) elif(enz.className == "MMenz" or enz.className == "ZombieMMenz"): enzSub = enz.neighbors["sub"] enzPrd = enz.neighbors["prd"] if (len(enzSub) != 0 and len(enzPrd) != 0): enzCompt = findCompartment(enz) if not isinstance(moose.element(enzCompt), moose.ChemCompt): return -2 else: compt = enzCompt.name + "_" + \ str(enzCompt.getId().value) + "_" + \ str(enzCompt.getDataIndex()) + "_" enzyme = cremodel_.createReaction() enzAnno = " " if notesE != "": cleanNotesE = convertNotesSpecialChar(notesE) notesStringE = "<body xmlns=\"http://www.w3.org/1999/xhtml\">\n \t \t" + \ cleanNotesE + "\n\t </body>" enzyme.setNotes(notesStringE) mmenzsetId = str(idBeginWith(cleanEnzname + "_" + str(enz.getId().value) + "_" + str(enz.getDataIndex()) + "_")) enzyme.setId(mmenzsetId) if groupName != moose.element('/'): if groupName not in groupInfo: groupInfo[groupName]=[mmenzsetId] else: groupInfo[groupName].append(mmenzsetId) enzyme.setName(str(idBeginWith(convertSpecialCharshot(enz.name)))) #enzyme.setName(cleanEnzname) enzyme.setFast(False) enzyme.setReversible(True) if enzannoexist: enzAnno = enzAnno + enzGpnCorCol enzAnno = "<moose:EnzymaticReaction>\n" + \ enzGpnCorCol + "</moose:EnzymaticReaction>" enzyme.setAnnotation(enzAnno) Km = enz.Km kcat = enz.kcat enzSub = enz.neighbors["sub"] noofSub, sRateLawS = getSubprd(cremodel_, False, "sub", enzSub) #sRate_law << rate_law.str(); # Modifier enzMod = enz.neighbors["enzDest"] noofMod, sRateLawM = getSubprd(cremodel_, False, "enz", enzMod) enzPrd = enz.neighbors["prd"] noofPrd, sRateLawP = getSubprd(cremodel_, False, "prd", enzPrd) kl = enzyme.createKineticLaw() fRate_law = compt + " * ( kcat * " + sRateLawS + " * " + sRateLawM + \ " / ( Km" + " + " + sRateLawS + "))" kl.setFormula(fRate_law) kl.setNotes( "<body xmlns=\"http://www.w3.org/1999/xhtml\">\n\t\t" + fRate_law + "\n \t </body>") KmUnit(cremodel_) printParameters(kl, "Km", Km, "mmole_per_litre") kcatUnit = parmUnit(0, cremodel_) printParameters(kl, "kcat", kcat, kcatUnit)
def writeEnz(modelpath, cremodel_, sceneitems): for enz in moose.wildcardFind(modelpath + '/##[ISA=EnzBase]'): enzannoexist = False enzGpnCorCol = " " cleanEnzname = convertSpecialChar(enz.name) enzSubt = () compt = "" notesE = "" if moose.exists(enz.path + '/info'): Anno = moose.Annotator(enz.path + '/info') notesE = Anno.notes element = moose.element(enz) ele = getGroupinfo(element) if element.className == "Neutral" or sceneitems or Anno.x or Anno.y: enzannoexist = True if enzannoexist: enzAnno = "<moose:ModelAnnotation>\n" if ele.className == "Neutral": enzGpnCorCol = "<moose:Group>" + ele.name + "</moose:Group>\n" if sceneitems: #Saved from GUI, then scene co-ordinates are passed enzGpnCorCol = enzGpnCorCol + "<moose:xCord>" + \ str(sceneitems[enz]['x']) + "</moose:xCord>\n" + \ "<moose:yCord>" + \ str(sceneitems[enz]['y'])+ "</moose:yCord>\n" else: #Saved from cmdline,genesis coordinates are kept as its # SBML, cspace, python, then auto-coordinates are done #and coordinates are updated in moose Annotation field enzGpnCorCol = enzGpnCorCol + "<moose:xCord>" + \ str(Anno.x) + "</moose:xCord>\n" + \ "<moose:yCord>" + \ str(Anno.y)+ "</moose:yCord>\n" if Anno.color: enzGpnCorCol = enzGpnCorCol + "<moose:bgColor>" + Anno.color + "</moose:bgColor>\n" if Anno.textColor: enzGpnCorCol = enzGpnCorCol + "<moose:textColor>" + \ Anno.textColor + "</moose:textColor>\n" if (enz.className == "Enz" or enz.className == "ZombieEnz"): enzyme = cremodel_.createReaction() if notesE != "": cleanNotesE = convertNotesSpecialChar(notesE) notesStringE = "<body xmlns=\"http://www.w3.org/1999/xhtml\">\n \t \t" + \ cleanNotesE + "\n\t </body>" enzyme.setNotes(notesStringE) comptVec = findCompartment(moose.element(enz)) if not isinstance(moose.element(comptVec), moose.ChemCompt): return -2 else: compt = comptVec.name + "_" + \ str(comptVec.getId().value) + "_" + \ str(comptVec.getDataIndex()) + "_" enzyme.setId(str(idBeginWith(cleanEnzname + "_" + str(enz.getId().value) + "_" + str(enz.getDataIndex()) + "_" + "Complex_formation_"))) enzyme.setName(cleanEnzname) enzyme.setFast(False) enzyme.setReversible(True) k1 = enz.concK1 k2 = enz.k2 k3 = enz.k3 enzAnno = " " enzAnno = "<moose:EnzymaticReaction>\n" enzOut = enz.neighbors["enzOut"] if not enzOut: print(" Enzyme parent missing for ", enz.name) else: listofname(enzOut, True) enzSubt = enzOut for i in range(0, len(nameList_)): enzAnno = enzAnno + "<moose:enzyme>" + \ (str(idBeginWith(convertSpecialChar( nameList_[i])))) + "</moose:enzyme>\n" #noofSub,sRateLaw = getSubprd(cremodel_,True,"sub",enzSub) # for i in range(0,len(nameList_)): # enzAnno=enzAnno+"<moose:enzyme>"+nameList_[i]+"</moose:enzyme>\n" #rec_order = noofSub #rate_law = "k1"+"*"+sRateLaw enzSub = enz.neighbors["sub"] if not enzSub: print("Enzyme \"", enz.name, "\" substrate missing") else: listofname(enzSub, True) enzSubt += enzSub for i in range(0, len(nameList_)): enzAnno = enzAnno + "<moose:substrates>" + \ nameList_[i] + "</moose:substrates>\n" if enzSubt: rate_law = "k1" noofSub, sRateLaw = getSubprd(cremodel_, True, "sub", enzSubt) #rec_order = rec_order + noofSub rec_order = noofSub rate_law = compt + " * " + rate_law + "*" + sRateLaw enzPrd = enz.neighbors["cplxDest"] if not enzPrd: print("Enzyme \"", enz.name, "\"product missing") else: noofPrd, sRateLaw = getSubprd(cremodel_, True, "prd", enzPrd) for i in range(0, len(nameList_)): enzAnno = enzAnno + "<moose:product>" + \ nameList_[i] + "</moose:product>\n" rate_law = rate_law + " - " + compt + "* k2" + '*' + sRateLaw prd_order = noofPrd enzAnno = enzAnno + "<moose:groupName>" + cleanEnzname + "_" + \ str(enz.getId().value) + "_" + \ str(enz.getDataIndex()) + "_" + "</moose:groupName>\n" enzAnno = enzAnno + "<moose:stage>1</moose:stage>\n" if enzannoexist: enzAnno = enzAnno + enzGpnCorCol enzAnno = enzAnno + "</moose:EnzymaticReaction>" enzyme.setAnnotation(enzAnno) kl = enzyme.createKineticLaw() kl.setFormula(rate_law) kl.setNotes( "<body xmlns=\"http://www.w3.org/1999/xhtml\">\n\t\t" + rate_law + "\n \t </body>") punit = parmUnit(prd_order - 1, cremodel_) printParameters(kl, "k2", k2, punit) unit = parmUnit(rec_order - 1, cremodel_) printParameters(kl, "k1", k1, unit) enzyme = cremodel_.createReaction() enzyme.setId(str(idBeginWith(cleanEnzname + "_" + str(enz.getId().value) + "_" + str(enz.getDataIndex()) + "_" + "Product_formation_"))) enzyme.setName(cleanEnzname) enzyme.setFast(False) enzyme.setReversible(False) enzAnno2 = "<moose:EnzymaticReaction>" enzSub = enz.neighbors["cplxDest"] if not enzSub: print(" complex missing from ", enz.name) else: noofSub, sRateLaw = getSubprd(cremodel_, True, "sub", enzSub) for i in range(0, len(nameList_)): enzAnno2 = enzAnno2 + "<moose:complex>" + \ nameList_[i] + "</moose:complex>\n" enzEnz = enz.neighbors["enzOut"] if not enzEnz: print("Enzyme parent missing for ", enz.name) else: noofEnz, sRateLaw1 = getSubprd(cremodel_, True, "prd", enzEnz) for i in range(0, len(nameList_)): enzAnno2 = enzAnno2 + "<moose:enzyme>" + \ nameList_[i] + "</moose:enzyme>\n" enzPrd = enz.neighbors["prd"] if enzPrd: noofprd, sRateLaw2 = getSubprd(cremodel_, True, "prd", enzPrd) else: print("Enzyme \"", enz.name, "\" product missing") for i in range(0, len(nameList_)): enzAnno2 = enzAnno2 + "<moose:product>" + \ nameList_[i] + "</moose:product>\n" enzAnno2 += "<moose:groupName>" + cleanEnzname + "_" + \ str(enz.getId().value) + "_" + \ str(enz.getDataIndex()) + "_" + "</moose:groupName>\n" enzAnno2 += "<moose:stage>2</moose:stage> \n" if enzannoexist: enzAnno2 = enzAnno2 + enzGpnCorCol enzAnno2 += "</moose:EnzymaticReaction>" enzyme.setAnnotation(enzAnno2) enzrate_law = compt + " * k3" + '*' + sRateLaw kl = enzyme.createKineticLaw() kl.setFormula(enzrate_law) kl.setNotes( "<body xmlns=\"http://www.w3.org/1999/xhtml\">\n\t\t" + enzrate_law + "\n \t </body>") unit = parmUnit(noofPrd - 1, cremodel_) printParameters(kl, "k3", k3, unit) elif(enz.className == "MMenz" or enz.className == "ZombieMMenz"): enzSub = enz.neighbors["sub"] enzPrd = enz.neighbors["prd"] if (len(enzSub) != 0 and len(enzPrd) != 0): enzCompt = findCompartment(enz) if not isinstance(moose.element(enzCompt), moose.ChemCompt): return -2 else: compt = enzCompt.name + "_" + \ str(enzCompt.getId().value) + "_" + \ str(enzCompt.getDataIndex()) + "_" enzyme = cremodel_.createReaction() enzAnno = " " if notesE != "": cleanNotesE = convertNotesSpecialChar(notesE) notesStringE = "<body xmlns=\"http://www.w3.org/1999/xhtml\">\n \t \t" + \ cleanNotesE + "\n\t </body>" enzyme.setNotes(notesStringE) enzyme.setId(str(idBeginWith(cleanEnzname + "_" + str(enz.getId().value) + "_" + str(enz.getDataIndex()) + "_"))) enzyme.setName(cleanEnzname) enzyme.setFast(False) enzyme.setReversible(True) if enzannoexist: enzAnno = enzAnno + enzGpnCorCol enzAnno = "<moose:EnzymaticReaction>\n" + \ enzGpnCorCol + "</moose:EnzymaticReaction>" enzyme.setAnnotation(enzAnno) Km = enz.Km kcat = enz.kcat enzSub = enz.neighbors["sub"] noofSub, sRateLawS = getSubprd(cremodel_, False, "sub", enzSub) #sRate_law << rate_law.str(); # Modifier enzMod = enz.neighbors["enzDest"] noofMod, sRateLawM = getSubprd(cremodel_, False, "enz", enzMod) enzPrd = enz.neighbors["prd"] noofPrd, sRateLawP = getSubprd(cremodel_, False, "prd", enzPrd) kl = enzyme.createKineticLaw() fRate_law = "kcat *" + sRateLawS + "*" + sRateLawM + \ "/(" + compt + " * (" + "Km" + "+" + sRateLawS + "))" kl.setFormula(fRate_law) kl.setNotes( "<body xmlns=\"http://www.w3.org/1999/xhtml\">\n\t\t" + fRate_law + "\n \t </body>") printParameters(kl, "Km", Km, "substance") kcatUnit = parmUnit(0, cremodel_) printParameters(kl, "kcat", kcat, kcatUnit)
def mooseWriteSBML(modelpath, filename, sceneitems={}): global foundLibSBML_ msg = " " if not foundLibSBML_: print('No python-libsbml found.' '\nThis module can be installed by following command in terminal:' '\n\t easy_install python-libsbml or' '\n\t apt-get install python-libsbml' ) return -2, "Could not save the model in to SBML file. \nThis module can be installed by following command in terminal: \n\t easy_install python-libsbml or \n\t apt-get install python-libsbml",'' #sbmlDoc = SBMLDocument(3, 1) filepath, filenameExt = os.path.split(filename) if filenameExt.find('.') != -1: filename = filenameExt[:filenameExt.find('.')] else: filename = filenameExt # validatemodel sbmlOk = False global spe_constTrue spe_constTrue = [] global nameList_ nameList_ = [] xcord,ycord = [],[] if not moose.exists(modelpath): return False, "Path doesn't exist" elif moose.exists(modelpath): 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): if moose.exists(p.path+'/info'): xcord.append(moose.element(p.path+'/info').x) ycord.append(moose.element(p.path+'/info').y) recalculatecoordinates(modelpath,mObj,xcord,ycord) positionInfoexist = False xmlns = SBMLNamespaces(3, 1) xmlns.addNamespace("http://www.w3.org/1999/xhtml", "xhtml") xmlns.addNamespace("http://www.moose.ncbs.res.in", "moose") xmlns.addNamespace("http://www.sbml.org/sbml/level3/version1/groups/version1", "groups") sbmlDoc = SBMLDocument(xmlns) sbmlDoc.setPackageRequired("groups",bool(0)) cremodel_ = sbmlDoc.createModel() cremodel_.setId(filename) cremodel_.setTimeUnits("time") cremodel_.setExtentUnits("substance") cremodel_.setSubstanceUnits("substance") cremodel_.setVolumeUnits("volume") cremodel_.setAreaUnits("area") cremodel_.setLengthUnits("length") neutralNotes = "" specieslist = moose.wildcardFind(modelpath + '/##[ISA=PoolBase]') if specieslist: neutralPath = getGroupinfo(specieslist[0]) if moose.exists(neutralPath.path + '/info'): neutralInfo = moose.element(neutralPath.path + '/info') neutralNotes = neutralInfo.notes if neutralNotes != "": cleanNotes = convertNotesSpecialChar(neutralNotes) notesString = "<body xmlns=\"http://www.w3.org/1999/xhtml\">\n \t \t" + \ neutralNotes + "\n\t </body>" cremodel_.setNotes(notesString) srcdesConnection = {} writeUnits(cremodel_) modelAnno = writeSimulationAnnotation(modelpath) if modelAnno: cremodel_.setAnnotation(modelAnno) groupInfo = {} compartexist, groupInfo = writeCompt(modelpath, cremodel_) if compartexist == True: species = writeSpecies( modelpath,cremodel_,sbmlDoc,sceneitems,groupInfo) if species: writeFunc(modelpath, cremodel_) reacGroup = {} writeReac(modelpath, cremodel_, sceneitems,groupInfo) writeEnz(modelpath, cremodel_, sceneitems,groupInfo) if groupInfo: for key,value in groupInfo.items(): mplugin = cremodel_.getPlugin("groups") group = mplugin.createGroup() name = str(idBeginWith(moose.element(key).name)) group.setId(name) group.setKind("collection") if moose.exists(key.path+'/info'): ginfo = moose.element(key.path+'/info') else: moose.Annotator(key.path+'/info') groupCompartment = findCompartment(key) if ginfo.color != '': grpAnno = "<moose:GroupAnnotation>" grpAnno = grpAnno + "<moose:Compartment>" + groupCompartment.name + "</moose:Compartment>\n" if ginfo.color: grpAnno = grpAnno + "<moose:bgColor>" + ginfo.color + "</moose:bgColor>\n" grpAnno = grpAnno + "</moose:GroupAnnotation>" group.setAnnotation(grpAnno) for values in value: member = group.createMember() member.setIdRef(values) consistencyMessages = "" SBMLok = validateModel(sbmlDoc) if (SBMLok): writeTofile = filepath + "/" + filename + '.xml' writeSBMLToFile(sbmlDoc, writeTofile) return True, consistencyMessages, writeTofile if (not SBMLok): #cerr << "Errors encountered " << endl consistencyMessages = "Errors encountered" return -1, consistencyMessages else: return False, "Atleast one compartment should exist to write SBML"
def writeSpecies(modelpath, cremodel_, sbmlDoc, sceneitems): # getting all the species for spe in moose.wildcardFind(modelpath + '/##[ISA=PoolBase]'): sName = convertSpecialChar(spe.name) comptVec = findCompartment(spe) speciannoexist = False speciGpname = "" if not isinstance(moose.element(comptVec), moose.ChemCompt): return -2 else: compt = comptVec.name + "_" + \ str(comptVec.getId().value) + "_" + \ str(comptVec.getDataIndex()) + "_" s1 = cremodel_.createSpecies() spename = sName + "_" + \ str(spe.getId().value) + "_" + str(spe.getDataIndex()) + "_" spename = str(idBeginWith(spename)) s1.setId(spename) if spename.find( "cplx") != -1 and isinstance(moose.element(spe.parent), moose.EnzBase): enz = spe.parent if (moose.element(enz.parent), moose.PoolBase): # print " found a cplx name ",spe.parent, # moose.element(spe.parent).parent enzname = enz.name enzPool = (enz.parent).name sName = convertSpecialChar( enzPool + "_" + enzname + "_" + sName) s1.setName(sName) # s1.setInitialAmount(spe.nInit) s1.setInitialConcentration(spe.concInit) s1.setCompartment(compt) # Setting BoundaryCondition and constant as per this rule for BufPool # -constanst -boundaryCondition -has assignment/rate Rule -can be part of sub/prd # false true yes yes # true true no yes if spe.className == "BufPool" or spe.className == "ZombieBufPool": # BoundaryCondition is made for buff pool s1.setBoundaryCondition(True) if moose.exists(spe.path + '/func'): bpf = moose.element(spe.path) for fp in bpf.children: if fp.className == "Function" or fp.className == "ZombieFunction": if len(moose.element( fp.path + '/x').neighbors["input"]) > 0: s1.setConstant(False) else: # if function exist but sumtotal object doesn't # exist spe_constTrue.append(spename) s1.setConstant(True) else: spe_constTrue.append(spename) s1.setConstant(True) else: # if not bufpool then Pool, then s1.setBoundaryCondition(False) s1.setConstant(False) s1.setUnits("substance") s1.setHasOnlySubstanceUnits(False) if moose.exists(spe.path + '/info'): Anno = moose.Annotator(spe.path + '/info') if Anno.notes != "": cleanNotesS = convertNotesSpecialChar(Anno.notes) notesStringS = "<body xmlns=\"http://www.w3.org/1999/xhtml\">\n \t \t" + \ cleanNotesS + "\n\t </body>" s1.setNotes(notesStringS) element = moose.element(spe) ele = getGroupinfo(element) if element.className == "Neutral" or Anno.color or Anno.textColor or sceneitems or Anno.x or Anno.y: speciannoexist = True if speciannoexist: speciAnno = "<moose:ModelAnnotation>\n" if ele.className == "Neutral": speciAnno = speciAnno + "<moose:Group>" + ele.name + "</moose:Group>\n" if sceneitems: #Saved from GUI, then scene co-ordinates are passed speciAnno = speciAnno + "<moose:xCord>" + \ str(sceneitems[spe]['x']) + "</moose:xCord>\n" + \ "<moose:yCord>" + \ str(sceneitems[spe]['y'])+ "</moose:yCord>\n" else: #Saved from cmdline,genesis coordinates are kept as its # SBML, cspace, python, then auto-coordinates are done #and coordinates are updated in moose Annotation field speciAnno = speciAnno + "<moose:xCord>" + \ str(Anno.x) + "</moose:xCord>\n" + \ "<moose:yCord>" + \ str(Anno.y)+ "</moose:yCord>\n" if Anno.color: speciAnno = speciAnno + "<moose:bgColor>" + Anno.color + "</moose:bgColor>\n" if Anno.textColor: speciAnno = speciAnno + "<moose:textColor>" + \ Anno.textColor + "</moose:textColor>\n" speciAnno = speciAnno + "</moose:ModelAnnotation>" s1.setAnnotation(speciAnno) return True
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 positionInfoExist = True meshEntry = {} if meshEntry: meshEntry.clear() else: meshEntry = {} xcord = [] ycord = [] objPar = collections.OrderedDict() for compt in moose.wildcardFind(modelRoot + '/##[ISA=ChemCompt]'): groupColor = [] try: meshEntry[moose.element(compt)] except KeyError: # Compt is not present meshEntry[moose.element(compt)] = {} objPar[moose.element(compt)] = moose.element('/') for grp in moose.wildcardFind(compt.path + '/##[TYPE=Neutral]'): grpinfo = moose.Annotator(moose.element(grp).path + '/info') validatecolor = colorCheck(grpinfo.color, "bg") validatedgrpcolor = str(QColor(validatecolor).name()) groupColor.append(validatedgrpcolor) grp_cmpt = findGroup_compt(grp.parent) try: meshEntry[moose.element(grp)] except KeyError: # Grp is not present meshEntry[moose.element(grp)] = {} objPar[moose.element(grp)] = moose.element(grp_cmpt) for compt in moose.wildcardFind(modelRoot + '/##[ISA=ChemCompt]'): for m in moose.wildcardFind(compt.path + '/##[ISA=PoolBase]'): if not re.search("xfer", m.name): grp_cmpt = findGroup_compt(m) xcord.append(xyPosition(m.path + '/info', 'x')) ycord.append(xyPosition(m.path + '/info', 'y')) if isinstance(moose.element(grp_cmpt), moose.Neutral): if isinstance(moose.element(m.parent), moose.EnzBase): populateMeshEntry(meshEntry, grp_cmpt, "cplx", m) else: populateMeshEntry(meshEntry, grp_cmpt, "pool", m) else: if isinstance(moose.element(m.parent), moose.EnzBase): populateMeshEntry(meshEntry, compt, "cplx", m) else: populateMeshEntry(meshEntry, compt, "pool", m) for r in moose.wildcardFind(compt.path + '/##[ISA=ReacBase]'): rgrp_cmpt = findGroup_compt(r) xcord.append(xyPosition(r.path + '/info', 'x')) ycord.append(xyPosition(r.path + '/info', 'y')) if isinstance(moose.element(rgrp_cmpt), moose.Neutral): populateMeshEntry(meshEntry, rgrp_cmpt, "reaction", r) else: populateMeshEntry(meshEntry, compt, "reaction", r) for e in moose.wildcardFind(compt.path + '/##[ISA=EnzBase]'): egrp_cmpt = findGroup_compt(e) xcord.append(xyPosition(e.path + '/info', 'x')) ycord.append(xyPosition(e.path + '/info', 'y')) if isinstance(moose.element(egrp_cmpt), moose.Neutral): populateMeshEntry(meshEntry, egrp_cmpt, "enzyme", e) else: populateMeshEntry(meshEntry, compt, "enzyme", e) for f in moose.wildcardFind(compt.path + '/##[ISA=Function]'): fgrp_cmpt = findGroup_compt(f) if isinstance(moose.element(fgrp_cmpt), moose.Neutral): populateMeshEntry(meshEntry, fgrp_cmpt, "function", f) else: populateMeshEntry(meshEntry, compt, "function", f) for t in moose.wildcardFind(compt.path + '/##[ISA=StimulusTable]'): tgrp_cmpt = findGroup_compt(t) xcord.append(xyPosition(t.path + '/info', 'x')) ycord.append(xyPosition(t.path + '/info', 'y')) if isinstance(moose.element(tgrp_cmpt), moose.Neutral): populateMeshEntry(meshEntry, tgrp_cmpt, "stimTab", t) else: populateMeshEntry(meshEntry, compt, "stimTab", t) xmin = min(xcord) xmax = max(xcord) ymin = min(ycord) ymax = max(ycord) positionInfoExist = not (len(np.nonzero(xcord)[0]) == 0 and len(np.nonzero(ycord)[0]) == 0) return (objPar, meshEntry, xmin, xmax, ymin, ymax, positionInfoExist)