def main(fileName,outputfilename): molecules,rules,_ = parseXML(fileName) #print '---',rules #createBiPartite(rules,None,'simple', # reactionCenter=True, context=True, products=True) # createCollapsedContact(rules,molecules,[1],outputfilename)
def processBNGL(bngl,center,context,product): #xml = createXML(bngl) xml = bngl _,rules = parseXML(xml) createBiPartite(rules,None,bngl, reactionCenter=center, context=context, products=product)
def main2(): number = 19 species,rules,parameterDict,observableList= readBNGXML.parseXML('output{0}.xml'.format(number)) graph = nx.Graph() simpleGraph(graph,species,observableList,number) nx.write_gml(graph,'graph_{0}.gml'.format(number))
def main(fileName, outputfilename): molecules, rules, _ = parseXML(fileName) #print '---',rules #createBiPartite(rules,None,'simple', # reactionCenter=True, context=True, products=True) # createCollapsedContact(rules, molecules, [1], outputfilename)
def getGraph(fileName): molecules, rules, _ = parseXML(fileName) extendedInformation = getContext(fileName) return collapsedContactMap.createCollapsedContact(rules, molecules, [1], "", extendedInformation[0], True, True, False)
def main(): fileName = 'complex/output19.bngl' console.bngl2xml(fileName) species, rules, par = readBNGXML.parseXML('output19.xml') #print rules transformationCenter = [] transformationContext = [] #extract the context of such reactions for idx, rule in enumerate(rules): tatomicArray, ttransformationCenter, ttransformationContext, \ tproductElements,tactionNames,tlabelArray = extractAtomic.extractTransformations([rule]) #atomicArray.append(tatomicArray) transformationCenter.append(ttransformationCenter) transformationContext.append(ttransformationContext) redundantDict, patternDictList = extractRedundantContext( rules, transformationCenter, transformationContext) #print redundantDict #construct rule based patterns based on the reaction patterns they have to match and #the ones they have to discriminate for center in patternDictList: for rate in patternDictList[center]: match = patternDictList[center][rate] notContext = [] for cRate in [x for x in patternDictList[center] if x != rate]: notContext.append([ transformationContext[x] for x in redundantDict[center][cRate] ]) ruleSet = [rules[x] for x in redundantDict[center][rate]] createMetaRule(ruleSet, match) newRules = range(0, len(rules)) for center in redundantDict: for context in redundantDict[center]: for element in range(1, len(redundantDict[center][context])): newRules.remove(redundantDict[center][context][element]) #for element in newRules: # print str(rules[element][0]) newRulesArray = [] for element in newRules: newRulesArray.append('{0}\n'.format(str(rules[element][0]))) lines = readFile(fileName) startR = lines.index('begin reaction rules\n') endR = lines.index('end reaction rules\n') startP = lines.index('begin parameters\n') endP = lines.index('end parameters\n') newPar = findNewParameters(lines[startP + 1:endP], par) newLines = lines[0:endP] + newPar + lines[ endP:startR + 1] + newRulesArray + lines[endR:len(lines)] f = open(fileName + 'reduced.bngl', 'w') f.writelines(newLines) '''
def main2(): number = 48 species, rules, parameterDict, observableList = readBNGXML.parseXML( 'output{0}.xml'.format(number)) graph = nx.Graph() simpleGraph(graph, species, observableList, number) nx.write_gml(graph, 'graph_{0}.gml'.format(number))
def reactionBasedAtomizationFile(xml): ratomizationList = [] ratomizationDict = defaultdict(dict) ratomizationListm10 = [] ratomizationListl10 = [] largeUseless = [] syndelArray = [] syndel = 0 totalRatomizedProcesses = 0 totalReactions = 0 totalProcesses = 0 validFiles = 0 atomizedDistro = [] nonAtomizedDistro = [] interesting = [] try: # console.bngl2xml('complex/output{0}.bngl'.format(element),timeout=10) try: _, rules, _ = readBNGXML.parseXML(xml) except: print xml atomizedProcesses, weight = reactionBasedAtomization(rules) ato, nonato = stoichiometryAnalysis(rules) atomizedDistro.extend(ato) nonAtomizedDistro.extend(nonato) # if (2,1) in nonato: # interesting.append(element) score = atomizedProcesses * 1.0 / weight if weight != 0 else 0 totalRatomizedProcesses += atomizedProcesses totalReactions += len(rules) totalProcesses += weight ratomizationDict[xml]["score"] = score ratomizationDict[xml]["weight"] = weight ratomizationDict[xml]["length"] = len(rules) if len(rules) == 0: ruleslen0 += 1 syndelArray.append((len(rules) - weight) * 1.0 / len(rules)) if score == -1: syndel += 1 # ratomizationList.append([0,0,len(rules)]) ratomizationList.append([score, weight, len(rules)]) if len(rules) > 10: if weight * 1.0 / len(rules) >= 0.1 and score < 0.1: largeUseless.append(xml) ratomizationListm10.append([score, weight, len(rules)]) else: ratomizationListl10.append([score, weight, len(rules)]) # print xml,ratomizationList[-1] validFiles += 1 # except (IndexError,ZeroDivisionError): # syndel += 1 # print 'iz' # continue except IOError: print "io" return ratomizationDict
def main(): fileName = 'complex/output19.bngl' console.bngl2xml(fileName) species,rules,par= readBNGXML.parseXML('output19.xml') #print rules transformationCenter = [] transformationContext = [] #extract the context of such reactions for idx,rule in enumerate(rules): tatomicArray, ttransformationCenter, ttransformationContext, \ tproductElements,tactionNames,tlabelArray = extractAtomic.extractTransformations([rule]) #atomicArray.append(tatomicArray) transformationCenter.append(ttransformationCenter) transformationContext.append(ttransformationContext) print transformationCenter[6] redundantDict,patternDictList = extractRedundantContext(rules,transformationCenter,transformationContext) print redundantDict[(('Prot(iMod~U)',), ('Prot(egfr)', 'EGFR(prot)'))] #print redundantDict #construct rule based patterns based on the reaction patterns they have to match and #the ones they have to discriminate for center in patternDictList: for rate in patternDictList[center]: match = patternDictList[center][rate] notContext = [] for cRate in [x for x in patternDictList[center] if x != rate]: notContext.append([transformationContext[x] for x in redundantDict[center][cRate]]) ruleSet = [rules[x] for x in redundantDict[center][rate]] createMetaRule(ruleSet,match) newRules = range(0,len(rules)) for center in redundantDict: for context in redundantDict[center]: for element in range(1,len(redundantDict[center][context])): newRules.remove(redundantDict[center][context][element]) #for element in newRules: # print str(rules[element][0]) newRulesArray = [] for element in newRules: newRulesArray.append('{0}\n'.format(str(rules[element][0]))) lines = readFile(fileName) startR = lines.index('begin reaction rules\n') endR = lines.index('end reaction rules\n') startP = lines.index('begin parameters\n') endP = lines.index('end parameters\n') newPar = findNewParameters(lines[startP+1:endP],par) newLines = lines[0:endP] + newPar + lines[endP:startR+1] + newRulesArray + lines[endR:len(lines)] f = open(fileName + 'reduced.bngl','w') f.writelines(newLines) '''
def main(fileName, outputfilename, extendedInformation, contextOnlyFlag, nullContextFlag, separateGraphsFlag, motifFlag, bipartiteFlag): molecules, rules, _ = parseXML(fileName) graph, graphDictionary = createCollapsedContact(rules, molecules, [1], outputfilename, extendedInformation, contextOnlyFlag, nullContextFlag, separateGraphsFlag, motifFlag, bipartiteFlag) if separateGraphsFlag: for graphObject in graphDictionary: nx.write_gml(graphDictionary[graphObject], '{0}_{1}.gml'.format(fileName.split('.')[0], graphObject)) else: nx.write_gml(graph, outputfilename)
def processBNGL(bngl, center, context, product): #xml = createXML(bngl) xml = bngl _, rules = parseXML(xml) createBiPartite(rules, None, bngl, reactionCenter=center, context=context, products=product)
def getAtomizedRules(bngxml): ''' input an xml file, return atomized rules ''' _,rules = readBNGXML.parseXML(bngxml) print "\nChopping and atomizing rules..." atomizedrules = [] for idx, [reactants, products, actions, mappings, nameDict] in enumerate(rules): choppedrule = chopRule(reactants, products, actions, mappings, nameDict) atomizedrules.append(AtomizedRule(choppedrule,reactants,products)) print len(atomizedrules), "rules atomized." return atomizedrules
def main(fileName): _,rules = parseXML(fileName) #createBiPartite(rules,[x for x in range(1,25)],'simple', # reactionCenter=True, context=True, products=True) for element in range(1,20): print element try: createBiPartite(rules, [element], 'simple%i' % element, reactionCenter=True, context=True, products=True) except: print 'xxx' continue
def addAnnotations(fileName): bngl2xml('{0}.bngl'.format(fileName)) _,rules = parseXML('{0}.xml'.format(fileName)) totalAtomic = {} totalCenter = [] totalContext = [] totalProduct = [] for rule in rules: atomicArray, transformationCenter, transformationContext, \ productElements,actionNames,labelArray = extractTransformations([rule]) totalAtomic.update(atomicArray) totalCenter.append(transformationCenter) totalContext.append(transformationContext) totalProduct.append(productElements)
def addAnnotations(fileName): bngl2xml('{0}.bngl'.format(fileName)) _, rules = parseXML('{0}.xml'.format(fileName)) totalAtomic = {} totalCenter = [] totalContext = [] totalProduct = [] for rule in rules: atomicArray, transformationCenter, transformationContext, \ productElements,actionNames,labelArray = extractTransformations([rule]) totalAtomic.update(atomicArray) totalCenter.append(transformationCenter) totalContext.append(transformationContext) totalProduct.append(productElements)
def createDataStructures(bnglContent): """ create an atomized biomodels in a temporary file to obtain relevant bng information """ pointer = tempfile.mkstemp(suffix=".bngl", text=True) with open(pointer[1], "w") as f: f.write(bnglContent) retval = os.getcwd() os.chdir(tempfile.tempdir) consoleCommands.bngl2xml(pointer[1]) xmlfilename = ".".join(pointer[1].split(".")[0:-1]) + ".xml" os.chdir(retval) return readBNGXML.parseXML(xmlfilename)
def main(fileName, outputfilename, extendedInformation, contextOnlyFlag, nullContextFlag, separateGraphsFlag, motifFlag, bipartiteFlag): molecules, rules, _ = parseXML(fileName) graph, graphDictionary = createCollapsedContact( rules, molecules, [1], outputfilename, extendedInformation, contextOnlyFlag, nullContextFlag, separateGraphsFlag, motifFlag, bipartiteFlag) if separateGraphsFlag: for graphObject in graphDictionary: nx.write_gml( graphDictionary[graphObject], '{0}_{1}.gml'.format(fileName.split('.')[0], graphObject)) else: nx.write_gml(graph, outputfilename)
def createDataStructures(bnglContent): ''' create an atomized biomodels in a temporary file to obtain relevant bng information ''' pointer = tempfile.mkstemp(suffix='.bngl',text=True) with open(pointer[1],'w') as f: f.write(bnglContent) retval = os.getcwd() os.chdir(tempfile.tempdir) consoleCommands.bngl2xml(pointer[1]) xmlfilename = '.'.join(pointer[1].split('.')[0:-1]) + '.xml' os.chdir(retval) return readBNGXML.parseXML(xmlfilename)
def createDataStructures(bnglContent): ''' create an atomized biomodels in a temporary file to obtain relevant bng information ''' pointer = tempfile.mkstemp(suffix='.bngl', text=True) with open(pointer[1], 'w') as f: f.write(bnglContent) retval = os.getcwd() os.chdir(tempfile.tempdir) consoleCommands.bngl2xml(pointer[1]) xmlfilename = '.'.join(pointer[1].split('.')[0:-1]) + '.xml' os.chdir(retval) return readBNGXML.parseXML(xmlfilename)
def main(fileName): _,rules = parseXML(fileName) #print '---',rules #createBiPartite(rules,None,'simple', # reactionCenter=True, context=True, products=True) for element in [2]: print element createBiPartite(rules, [element], 'simple%i' % element, reactionCenter=True, context=True, products=True) try: createBiPartite(rules, [element], 'simple%i' % element, reactionCenter=True, context=True, products=True) except: print 'xxx' continue
def reactionBasedAtomizationFile(xmlFile, outputDataFrame, options): """ get atomization metrics from a bng-xml file """ ratomizationDict = {} try: # console.bngl2xml('complex/output{0}.bngl'.format(element),timeout=10) molecules, reactions, _ = readBNGXML.parseXML(xmlFile) atomizedProcesses = 0 trueProcessesCounter = 0 for reaction in reactions: if '0' in [str(x) for x in reaction[0].reactants] or '0' in \ [str(x) for x in reaction[0].products]: continue trueProcessesCounter += 1 # if len([x for x in action.action if x in ['Add','Delete']]) == 0: # atomizedProcesses +=1 for action in reaction[0].actions: if action.action in [ 'AddBond', 'DeleteBond', 'StateChange', 'ChangeCompartment' ]: atomizedProcesses += 1 break #ato, nonato = stoichiometryAnalysis(rules) #atomizedDistro.extend(ato) #nonAtomizedDistro.extend(nonato) score = atomizedProcesses * 1.0 / trueProcessesCounter if trueProcessesCounter != 0 else 0 #outputDataFrame = outputDataFrame.set_value(xmlFile,'score',score) #outputDataFrame = outputDataFrame.set_value(xmlFile,'lenght',len(rules)) ccompression = len(molecules) * 1.0 / readBNGXML.getNumObservablesXML( xmlFile) if readBNGXML.getNumObservablesXML(xmlFile) > 0 else 1 return xmlFile, score, len(reactions), ccompression #ratomizationDict['score'] = score #ratomizationDict['weight'] = weight #ratomizationDict['length'] = len(rules) except IOError: print 'io', xmlFile
def reactionBasedAtomizationFile(xmlFile,outputDataFrame,options): """ get atomization metrics from a bng-xml file """ ratomizationDict = {} try: # console.bngl2xml('complex/output{0}.bngl'.format(element),timeout=10) molecules, reactions, _ = readBNGXML.parseXML(xmlFile) atomizedProcesses = 0 trueProcessesCounter = 0 for reaction in reactions: if '0' in [str(x) for x in reaction[0].reactants] or '0' in \ [str(x) for x in reaction[0].products]: continue trueProcessesCounter += 1 # if len([x for x in action.action if x in ['Add','Delete']]) == 0: # atomizedProcesses +=1 for action in reaction[0].actions: if action.action in ['AddBond', 'DeleteBond', 'StateChange', 'ChangeCompartment']: atomizedProcesses += 1 break #ato, nonato = stoichiometryAnalysis(rules) #atomizedDistro.extend(ato) #nonAtomizedDistro.extend(nonato) score = atomizedProcesses * 1.0 / trueProcessesCounter if trueProcessesCounter != 0 else 0 #outputDataFrame = outputDataFrame.set_value(xmlFile,'score',score) #outputDataFrame = outputDataFrame.set_value(xmlFile,'lenght',len(rules)) ccompression = len(molecules)*1.0/readBNGXML.getNumObservablesXML(xmlFile) if readBNGXML.getNumObservablesXML(xmlFile) > 0 else 1 return xmlFile,score,len(reactions),ccompression #ratomizationDict['score'] = score #ratomizationDict['weight'] = weight #ratomizationDict['length'] = len(rules) except IOError: print 'io',xmlFile
def spaceCoveredCDF(): spaceCoveredArray = [] atomizationDict = {} with open("sortedD.dump", "rb") as f: atomizationStats = pickle.load(f) for element in atomizationStats: try: atomizationDict[element["index"]] = element["atomization"] except: continue for element in range(1, 491): try: if element in atomizationDict and atomizationDict[element] > 0: console.bngl2xml("complex/output{0}.bngl".format(element), timeout=10) species, _, _ = readBNGXML.parseXML("output{0}.xml".format(element)) observablesLen = readBNGXML.getNumObservablesXML("output{0}.xml".format(element)) try: spaceCoveredArray.append([atomizationDict[element], spaceCovered(species, observablesLen)]) print element, spaceCoveredArray[-1] except CycleError: spaceCoveredArray.append([atomizationDict[element], 0]) print element, -1 except (IOError, IndexError): print continue with open("spaceCovered.dump", "wb") as f: pickle.dump(spaceCoveredArray, f) atomization, space = zip(*spaceCoveredArray) heatmap, xedges, yedges = np.histogram2d(space, atomization, bins=8) extent = [xedges[0], xedges[-1], yedges[0], yedges[-1]] plt.clf() plt.imshow(heatmap, extent=extent) plt.xlabel("space") plt.ylabel("atomization") plt.show() plt.savefig("spaceCovered.png")
def main(fileName): _, rules = parseXML(fileName) #print '---',rules #createBiPartite(rules,None,'simple', # reactionCenter=True, context=True, products=True) for element in [2]: print element createBiPartite(rules, [element], 'simple%i' % element, reactionCenter=True, context=True, products=True) try: createBiPartite(rules, [element], 'simple%i' % element, reactionCenter=True, context=True, products=True) except: print 'xxx' continue
bpg1.add_argument('--omit-products',help='Omit product relationships on the bipartite graph',action='store_true',dest='no_p') bpg1.add_argument('--omit-contexts',help='Omit context relationships on the bipartite graph',action='store_true',dest='no_c') bpg_parser.add_argument('--use-annot',help='Use annotations instead of code',action='store_true',dest='use_annot') bpg_parser.add_argument('--filter',help='Textfile with list of patterns',required=False,dest='filter') bpg_parser.add_argument('--level',help='Depth to filter pattern list',required=False,dest='level',type=int) g1 = parser.add_argument_group('required arguments') g1.add_argument('-xml',dest='xml',required=True) args = parser.parse_args() if(os.path.isfile(args.xml)): # This generates all the pattern and transformation arrays and dictionaries _,rules = parseXML(args.xml) #rewrite required here: atomicArray = extractAtomicArray(rules) atomicArray, transformationCenter, transformationContext, productElements,actionName,label = extractTransformations(rules) patternDict,transformationDict = createDictionaries(atomicArray,transformationCenter,productElements) # This lets you create new empty annotation files
def getGraph(fileName): molecules, rules, _ = parseXML(fileName) extendedInformation = getContext(fileName) return collapsedContactMap.createCollapsedContact( rules, molecules, [1], "", extendedInformation[0], True, True, False )
def readXML(fileName): #consoleCommands.bngl2xml(fileName) fileName = '.'.join(fileName.split('.')[:-1]) + '.xml' return readBNGXML.parseXML(fileName)
def reactionBasedAtomizationDistro(directory): """ calculates a rection atomization based metric: ration of atomized reactions (non syndeg) in a model """ ratomizationList = [] ratomizationDict = defaultdict(dict) ratomizationListm10 = [] ratomizationListl10 = [] largeUseless = [] syndelArray = [] syndel = 0 totalRatomizedProcesses = 0 totalReactions = 0 totalProcesses = 0 validFiles = 0 atomizedDistro = [] nonAtomizedDistro = [] interesting = [] bnglFiles = getValidFiles(directory, "bngl") """ print 'converting bnglfiles' progress = progressbar.ProgressBar() for i in progress(range(len(bnglFiles))): console.bngl2xml(bnglFiles[i],timeout=10) """ print "moving xml files" files = glob.iglob(os.path.join(".", "*.xml")) for xmlfile in files: if os.path.isfile(xmlfile): shutil.move(xmlfile, directory) print "reading files" xmlFiles = getValidFiles(directory, "xml") print "analyzing {0} xml files".format(len(xmlFiles)) progress = progressbar.ProgressBar() ruleslen0 = 0 for i in progress(range(len(xmlFiles))): xml = xmlFiles[i] # for xml in xmlFiles: try: # console.bngl2xml('complex/output{0}.bngl'.format(element),timeout=10) try: _, rules, _ = readBNGXML.parseXML(xml) except: print xml continue atomizedProcesses, weight = reactionBasedAtomization(rules) ato, nonato = stoichiometryAnalysis(rules) atomizedDistro.extend(ato) nonAtomizedDistro.extend(nonato) # if (2,1) in nonato: # interesting.append(element) score = atomizedProcesses * 1.0 / weight if weight != 0 else 0 totalRatomizedProcesses += atomizedProcesses totalReactions += len(rules) totalProcesses += weight ratomizationDict[xml]["score"] = score ratomizationDict[xml]["weight"] = weight ratomizationDict[xml]["length"] = len(rules) if len(rules) == 0: ruleslen0 += 1 continue syndelArray.append((len(rules) - weight) * 1.0 / len(rules)) if score == -1: syndel += 1 # ratomizationList.append([0,0,len(rules)]) continue ratomizationList.append([score, weight, len(rules)]) if len(rules) > 10: if weight * 1.0 / len(rules) >= 0.1 and score < 0.1: largeUseless.append(xml) ratomizationListm10.append([score, weight, len(rules)]) else: ratomizationListl10.append([score, weight, len(rules)]) # print xml,ratomizationList[-1] validFiles += 1 # except (IndexError,ZeroDivisionError): # syndel += 1 # print 'iz' # continue except IOError: print "io" continue with open("ratomizationp2m.dump", "wb") as f: pickle.dump(ratomizationDict, f) print "{0} models with 0 rules".format(ruleslen0) print "generating figures for {0} models".format(len(ratomizationList)) print "-----" print "atomized", Counter(atomizedDistro) print "nonatomized", Counter(nonAtomizedDistro) print "models with 2->1 non atomized reactions", interesting with open("nonatomizedreactions.dump", "wb") as f: pickle.dump(generalSignature, f) ratomization, weights, length = zip(*ratomizationList) ratomizationm10, weightsm10, lengthm10 = zip(*ratomizationListm10) ratomizationl10, weightsl10, lengthl10 = zip(*ratomizationListl10) constructHistogram( syndelArray, "syndelHist", "Fraction of synthesis and degradation reactions", np.ones(len(syndelArray)), normed=False, ) constructHistogram( ratomization, "ratomizationHist", "Reaction atomization level ({0} models)".format(len(ratomization)), np.ones(len(ratomization)), normed=False, ) constructHistogram( ratomizationm10, "ratomizationwHist_m10", "Reaction atomization level ({0} models)".format(len(ratomizationm10)), lengthm10, normed=True, ) weights = np.array(weights) length = np.array(length) tmp = weights * 1.0 / length # ratomizationWP1 = [x for x,y in zip(ratomization,tmp) if y < 0.1] # ratomizationWP10 = [x for x,y,z in zip(ratomization,tmp,length) if y >= 0.1 and z<10] # ratomizationWP11 = [x for x,y,z in zip(ratomization,tmp,length) if y >= 0.1 and z>=10] # constructHistogram(ratomizationWP1,'ratomizationWP1','Reaction atomization level',np.ones(len(ratomizationWP1)),normed=False) # constructHistogram(ratomizationWP10,'ratomizationWP10','Reaction atomization level',np.ones(len(ratomizationWP10)),normed=False) # constructHistogram(ratomizationWP11,'ratomizationWP11','Reaction atomization level',np.ones(len(ratomizationWP11)),normed=False) print "process={0}, rprocess={1}, reactions = {2},syndel={3},valid={4}".format( totalProcesses, totalRatomizedProcesses, totalReactions, syndel, validFiles ) tmp2 = zip(ratomization, tmp) tmp2.sort(key=lambda x: x[0]) # heatmap showing histogram of atomization vs non syn-deg heatmap, xedges, yedges = np.histogram2d(tmp, ratomization, bins=6) heatmap = np.log2(heatmap) extent = [xedges[0], xedges[-1], yedges[0], yedges[-1]] heatmap[heatmap < 0] = 0 plt.clf() plt.imshow(heatmap, extent=extent, aspect="auto", origin="lower", interpolation="nearest") plt.xlabel("Atomization level") plt.ylabel("Percentage of non syn-del reactions") cb = plt.colorbar() cb.set_label("log2(Number of models)") plt.show() plt.savefig("atomizationHeatMap.png") plt.clf() plt.scatter(tmp, ratomization) plt.ylabel("Atomization level", fontsize=24) plt.xlabel("Percentage of non syn=del reactions", fontsize=24) plt.savefig("atomizationScatterplot.png") # heatmap showing average atomization of %syn-def vs model size ratomizationHeatmapCounter = defaultdict(lambda: defaultdict(list)) _, bin_edges = np.histogram(length, 4) digitizedLength = np.digitize(length, bin_edges) _, bin_edges2 = np.histogram(tmp, 4) digitizedSynDeg = np.digitize(tmp, bin_edges2) for rat, wei, leng in zip(ratomization, digitizedLength, digitizedSynDeg): ratomizationHeatmapCounter[wei][leng].append(rat) ratomizationHeatmap = np.zeros([5, 5]) for xelement in ratomizationHeatmapCounter: for yelement in ratomizationHeatmapCounter[xelement]: ratomizationHeatmap[xelement - 1][yelement - 1] = np.mean(ratomizationHeatmapCounter[xelement][yelement]) ratomizationHeatmapCounter[xelement][yelement] = np.mean(ratomizationHeatmapCounter[xelement][yelement]) heatmap, xedges, yedges = np.histogram2d(length, tmp, bins=5) heatmap = np.log2(heatmap) plt.clf() plt.hist(length, bins=10 ** np.linspace(np.log10(1), np.log10(1000), 40)) plt.xscale("log") plt.xlabel("Number of reactions ({0} models)".format(len(length)), fontsize=18) plt.savefig("numberOfReactionsHist.png") plt.clf() ax = plt.gca() ax.plot(length, 1 - tmp, "o", alpha=0.5) plt.xlabel("Number of reactions", fontsize=24) plt.ylabel("Fraction of syndel reactions", fontsize=24) ax.grid(True) ax.set_xscale("log") # ax.set_autoscale_on(False) plt.ylim([-0.1, 1.1]) # ax.set_yscale('log') plt.savefig("reactionsvsnsyndel.png") plt.clf() plt.scatter(length, 1 - tmp, s=40, c=[max(x, 0) for x in ratomization]) plt.xlabel("Number of reactions", fontsize=24) plt.ylabel("Fracion of syndel reactions", fontsize=24) ax = plt.gca() # ax.set_xscale('log') ax.grid(True) plt.xlim(xmin=0, xmax=100) plt.gray() cb = plt.colorbar() cb.set_label("Atomization level") plt.savefig("reactionsvssyndelwlinear.png") plt.clf() plt.imshow(ratomizationHeatmap, extent=extent, aspect="auto", origin="lower", interpolation="nearest") plt.xlabel("Fraction of non syn-del reactionsModel size") plt.ylabel("Model Size (reactions)") cb = plt.colorbar() cb.set_label("Atomization level") plt.show() plt.savefig("atomizationHeatMap2.png") heatmap[heatmap < 0] = 0 plt.clf() plt.imshow(heatmap, extent=extent, aspect="auto", origin="lower", interpolation="nearest") plt.ylabel("Model size (reactions)") plt.xlabel("Percentage of non syn-del reactions") cb = plt.colorbar() cb.set_label("log2(Number of models)") plt.show() plt.savefig("atomizationHeatMap3.png") plt.clf() plt.scatter(length, tmp) plt.xlabel("Number of reactions", fontsize=24) plt.xscale("log") plt.ylabel("Atomization level", fontsize=24) plt.savefig("scatterreactionsvslevel.png") ratomization = np.sort(ratomization) ratomizationm10 = np.sort(ratomizationm10) ratomizationl10 = np.sort(ratomizationl10) yvals = np.arange(len(ratomization)) / float(len(ratomization)) plotresults( ratomization, yvals, "ratomizationw", "Reaction atomization level ({0} models)".format(len(ratomizationList)) ) yvals = np.arange(len(ratomizationm10)) / float(len(ratomizationm10)) plotresults( ratomizationm10, yvals, "ratomization_m10w", "Reaction atomization level >10 reactions({0} models)".format(len(ratomizationListm10)), ) yvals = np.arange(len(ratomizationl10)) / float(len(ratomizationl10)) plotresults( ratomizationl10, yvals, "ratomization_l10w", "Reaction atomization level <=10 reactions({0} models)".format(len(ratomizationListl10)), ) print "syndel", syndel print ">10 with 0", largeUseless
getMapping(rule.mapping, action.site1), getMapping(rule.mapping, action.site2) ] atomic, rc, _ = extractMolecules(action.action, productSites[0], productSites[1], rule.products, differentiateDimers) productElements.append(rc) atomicArray.update(atomic) actionName.append('%i-%s' % (index, action.action)) r = '+'.join([str(x) for x in rule.reactants]) p = '+'.join([str(x) for x in rule.products]) label.append('->'.join([r, p, '%i-%s' % (index, action.action)])) solveWildcards(atomicArray) return (atomicArray, transformationCenter, transformationContext, productElements, actionName, label) if __name__ == "__main__": import readBNGXML _, rules, _ = readBNGXML.parseXML('output48.xml') for idx, rule in enumerate(rules): tatomicArray, ttransformationCenter, ttransformationContext, \ tproductElements, tactionNames, tlabelArray = extractTransformations( [rule], True) if rule[0].label == '_reverse_v7': print str(rule[0]) print ttransformationContext print tproductElements raise Exception
def extractRulesfromBNGL(fileName): # console.bngl2xml('complex/{0}.bngl'.format(fileName),timeout=10) species, rules, par = readBNGXML.parseXML(fileName) return species, rules, par
def main(fileName,outputfilename,extendedInformation): molecules,rules,_ = parseXML(fileName) createCollapsedContact(rules,molecules,[1],outputfilename,extendedInformation)
def extractStatistics(): number = 151 console.bngl2xml('complex/output{0}.bngl'.format(number)) species, rules, parameterDict = readBNGXML.parseXML( 'output{0}.xml'.format(number)) #print rules transformationCenter = [] transformationContext = [] k = [] actions = Counter() actionSet = Counter() for idx, rule in enumerate(rules): tatomicArray, ttransformationCenter, ttransformationContext, \ tproductElements,tactionNames,tlabelArray = extractAtomic.extractTransformations([rule]) #atomicArray.append(tatomicArray) transformationCenter.append(ttransformationCenter) transformationContext.append(ttransformationContext) k.append(len(rule[0].actions)) #if len(rule[0].actions) > 3: # print rule[0].reactants actions.update([x.action for x in rule[0].actions]) tmp = [x.action for x in rule[0].actions] tmp.sort() actionSet.update([tuple(tmp)]) #print actions #print actionSet print 'number of species', len(species) print 'avg number o actions', np.average(k), np.std(k) centerDict = groupByReactionCenter(transformationCenter) print 'singletons', len( {x: centerDict[x] for x in centerDict if len(centerDict[x]) == 1}) tmp = [[tuple(set(x)), len(centerDict[x])] for x in centerDict] #reactionCenterGraph(species,tmp) #tmp.sort(key=lambda x:x[1],reverse=True) print 'number of reaction centers', len(centerDict.keys()) print 'number of rules', len(rules) #print 'unique',[x for x in centerDict[element] if len(centerDict[element]) == 1] redundantDict = groupByReactionCenterAndRateAndActions(rules, centerDict) #print redundantDict tmp2 = [('$\\tt{{{0}}}$'.format(tuple(set(x))), tuple(set(y[:-1])), y[-1], len(redundantDict[x][y])) for x in redundantDict for y in redundantDict[x] if 'kr' not in y[-1]] tmp2 = set(tmp2) tmp2 = list(tmp2) tmp2.sort(key=lambda x: x[3], reverse=True) tmp2.sort(key=lambda x: x[0], reverse=True) tmp2 = [ '{0} & {1} & {2} & {3}\\\\\n'.format(element[0], element[1], element[2], element[3]) for element in tmp2 ] with open('table.tex', 'w') as f: f.write('\\begin{tabular}{|cccc|}\n') f.write('\\hline\n') f.write('Reaction Centers & Action & Score\\\\\\hline\n') for element in tmp2: f.write(element) f.write('\\hline\n') f.write('\\end{tabular}\n') #print redundantDict x = [len(centerDict[x]) for x in centerDict] #122,138 print 'average number of reactions with same rate and reaction cneter', np.average( x), np.std(x) print 'total number of clusters', len(x) print x
def extractStatistics(): number = 151 console.bngl2xml('complex/output{0}.bngl'.format(number)) species,rules,parameterDict= readBNGXML.parseXML('output{0}.xml'.format(number)) #print rules transformationCenter = [] transformationContext = [] k = [] actions = Counter() actionSet = Counter() for idx,rule in enumerate(rules): tatomicArray, ttransformationCenter, ttransformationContext, \ tproductElements,tactionNames,tlabelArray = extractAtomic.extractTransformations([rule]) #atomicArray.append(tatomicArray) transformationCenter.append(ttransformationCenter) transformationContext.append(ttransformationContext) k.append(len(rule[0].actions)) #if len(rule[0].actions) > 3: # print rule[0].reactants actions.update([x.action for x in rule[0].actions]) tmp = [x.action for x in rule[0].actions] tmp.sort() actionSet.update([tuple(tmp)]) #print actions #print actionSet print 'number of species',len(species) print 'avg number o actions',np.average(k),np.std(k) centerDict = groupByReactionCenter(transformationCenter) print 'singletons',len({x:centerDict[x] for x in centerDict if len(centerDict[x]) == 1}) tmp = [[tuple(set(x)),len(centerDict[x])] for x in centerDict] #reactionCenterGraph(species,tmp) #tmp.sort(key=lambda x:x[1],reverse=True) print 'number of reaction centers',len(centerDict.keys()) print 'number of rules',len(rules) #print 'unique',[x for x in centerDict[element] if len(centerDict[element]) == 1] redundantDict = groupByReactionCenterAndRateAndActions(rules,centerDict) #print redundantDict tmp2 = [('$\\tt{{{0}}}$'.format(tuple(set(x))),tuple(set(y[:-1])),y[-1],len (redundantDict[x][y])) for x in redundantDict for y in redundantDict[x] if 'kr' not in y[-1]] tmp2 = set(tmp2) tmp2 = list(tmp2) tmp2.sort(key=lambda x:x[3],reverse=True) tmp2.sort(key=lambda x:x[0],reverse=True) tmp2 = ['{0} & {1} & {2} & {3}\\\\\n'.format(element[0],element[1],element[2],element[3]) for element in tmp2] with open('table.tex','w') as f: f.write('\\begin{tabular}{|cccc|}\n') f.write('\\hline\n') f.write('Reaction Centers & Action & Score\\\\\\hline\n') for element in tmp2: f.write(element) f.write('\\hline\n') f.write('\\end{tabular}\n') #print redundantDict x = [len(centerDict[x]) for x in centerDict] #122,138 print 'average number of reactions with same rate and reaction cneter',np.average(x),np.std(x) print 'total number of clusters',len(x) print x
def main(): with open('linkArray.dump', 'rb') as f: linkArray = pickle.load(f) with open('xmlAnnotationsExtended.dump', 'rb') as f: annotations = pickle.load(f) speciesEquivalence = {} onlyDicts = [x for x in listdir('./complex')] onlyDicts = [x for x in onlyDicts if '.bngl.dict' in x] for x in onlyDicts: with open('complex/{0}'.format(x), 'rb') as f: speciesEquivalence[int(x.split('.')[0][6:])] = pickle.load(f) for cidx, cluster in enumerate(linkArray): #FIXME:only do the first cluster cidx = 0 cluster = linkArray[0] if len(cluster) == 1: continue annotationsDict = {idx: x for idx, x in enumerate(annotations)} annotationsIncidence = {} #get the model intersection points for element in annotationsDict: for species in annotationsDict[element]: key = annotationsDict[element][species][1] if key not in annotationsIncidence: annotationsIncidence[key] = set([]) annotationsIncidence[key].add(element) #number = 19 graph = nx.Graph() nodeDict = {} superNodeDict = {} for element in annotationsIncidence: if len(annotationsIncidence[element]) > 1: tmpEdgeList = [] names = [] for idx in annotationsIncidence[element]: for species in [ x for x in annotationsDict[idx] if annotationsDict[idx][x][1] == element ]: try: print speciesEquivalence[idx] if isinstance(speciesEquivalence[idx][species], str): tmpEdgeList.append('{0}_{1}'.format( idx, speciesEquivalence[idx][species][0:-2])) names.append( speciesEquivalence[idx][species][0:-2]) else: tmpEdgeList.append('{0}_{1}'.format( idx, speciesEquivalence[idx] [species].molecules[0].name)) names.append(speciesEquivalence[idx] [species].molecules[0].name) except: print '----', 'error', idx, species pass names = [x.lower() for x in names] name = Counter(names).most_common(5) name = [x for x in name if len(x[0]) > 1] if len(name) == 0: name = Counter(names).most_common(1) for edge in tmpEdgeList: superNodeDict[edge] = name[0][0] if len(name) > 0: superNodeDict[name[0][0]] = len(tmpEdgeList) #pairs = [(x,y,1) for x in tmpEdgeList for y in tmpEdgeList if x!= y] #graph.add_weighted_edges_from(pairs) print superNodeDict for x in cluster: number = x - 1 try: console.bngl2xml('complex/output{0}.bngl'.format(number)) species, rules, parameterDict, observableList = readBNGXML.parseXML( 'output{0}.xml'.format(number)) except: continue nodeDict[number] = simpleGraph(graph, species, observableList, number, superNodeDict) nx.write_gml(graph, 'cgraph_{0}.gml'.format(cidx)) break
transformationContext.append(context) atomicArray.update(atomic) productSites = [getMapping(rule.mapping, action.site1), getMapping(rule.mapping, action.site2)] atomic, rc, _ = extractMolecules( action.action, productSites[0], productSites[1], rule.products, differentiateDimers ) productElements.append(rc) atomicArray.update(atomic) actionName.append("%i-%s" % (index, action.action)) r = "+".join([str(x) for x in rule.reactants]) p = "+".join([str(x) for x in rule.products]) label.append("->".join([r, p, "%i-%s" % (index, action.action)])) solveWildcards(atomicArray) return (atomicArray, transformationCenter, transformationContext, productElements, actionName, label) if __name__ == "__main__": import readBNGXML _, rules, _ = readBNGXML.parseXML("output48.xml") for idx, rule in enumerate(rules): tatomicArray, ttransformationCenter, ttransformationContext, tproductElements, tactionNames, tlabelArray = extractTransformations( [rule], True ) if rule[0].label == "_reverse_v7": print str(rule[0]) print ttransformationContext print tproductElements raise Exception
def main(): with open('linkArray.dump', 'rb') as f: linkArray = pickle.load(f) with open('xmlAnnotationsExtended.dump','rb') as f: annotations = pickle.load(f) speciesEquivalence = {} onlyDicts = [ x for x in listdir('./complex')] onlyDicts = [x for x in onlyDicts if '.bngl.dict' in x] for x in onlyDicts: with open('complex/{0}'.format(x),'rb') as f: speciesEquivalence[int(x.split('.')[0][6:])] = pickle.load(f) for cidx,cluster in enumerate(linkArray): #FIXME:only do the first cluster cidx = 1 cluster = linkArray[1] if len(cluster) == 1: continue annotationsDict = {idx:x for idx,x in enumerate(annotations)} annotationsIncidence = {} #get the model intersection points for element in annotationsDict: for species in annotationsDict[element]: key = annotationsDict[element][species][1] if key not in annotationsIncidence: annotationsIncidence[key] = set([]) annotationsIncidence[key].add(element) #number = 19 graph = nx.Graph() nodeDict = {} superNodeDict = {} for element in annotationsIncidence: if len(annotationsIncidence[element]) > 1: tmpEdgeList = [] names= [] for idx in annotationsIncidence[element]: for species in [x for x in annotationsDict[idx] if annotationsDict[idx][x][1] == element]: try: if isinstance(speciesEquivalence[idx][species],str): tmpEdgeList.append('{0}_{1}'.format(idx,speciesEquivalence[idx][species][0:-2])) names.append(speciesEquivalence[idx][species][0:-2]) else: tmpEdgeList.append('{0}_{1}'.format(idx,speciesEquivalence[idx][species].molecules[0].name)) names.append(speciesEquivalence[idx][species].molecules[0].name) except: print 'error',idx,species names = [x.lower() for x in names] name = Counter(names).most_common(5) name = [x for x in name if len(x[0])> 1] if len(name) == 0: name = Counter(names).most_common(1) for edge in tmpEdgeList: superNodeDict[edge] = name[0][0] if len(name) > 0: superNodeDict[name[0][0]] = len(tmpEdgeList) #pairs = [(x,y,1) for x in tmpEdgeList for y in tmpEdgeList if x!= y] #graph.add_weighted_edges_from(pairs) print superNodeDict for x in cluster: number = x-1 try: console.bngl2xml('complex/output{0}.bngl'.format(number)) species,rules,parameterDict,observableList= readBNGXML.parseXML('output{0}.xml'.format(number)) except: continue nodeDict[number] = simpleGraph(graph,species,observableList,number,superNodeDict) nx.write_gml(graph,'cgraph_{0}.gml'.format(cidx)) break
solveWildcards(atomicArray) return ( atomicArray, transformationCenter, transformationContext, productElements, actionName, label, ) if __name__ == "__main__": import readBNGXML _, rules, _ = readBNGXML.parseXML("output48.xml") for idx, rule in enumerate(rules): ( tatomicArray, ttransformationCenter, ttransformationContext, tproductElements, tactionNames, tlabelArray, ) = extractTransformations([rule], True) if rule[0].label == "_reverse_v7": print(str(rule[0])) print(ttransformationContext) print(tproductElements) raise Exception
required=False, dest='filter') bpg_parser.add_argument('--level', help='Depth to filter pattern list', required=False, dest='level', type=int) g1 = parser.add_argument_group('required arguments') g1.add_argument('-xml', dest='xml', required=True) args = parser.parse_args() if (os.path.isfile(args.xml)): # This generates all the pattern and transformation arrays and dictionaries _, rules = parseXML(args.xml) #rewrite required here: atomicArray = extractAtomicArray(rules) atomicArray, transformationCenter, transformationContext, productElements, actionName, label = extractTransformations( rules) patternDict, transformationDict = createDictionaries( atomicArray, transformationCenter, productElements) # This lets you create new empty annotation files if args.mode == 'annotate': getStats(rules, patternDict, transformationDict) print "\n\nAnnotate mode." if args.verbose:
index += 1 for action in rule.actions: atomic, reactionCenter, context = extractMolecules(action.action, action.site1, action.site2, rule.reactants, differentiateDimers) transformationCenter.append(reactionCenter) transformationContext.append(context) atomicArray.update(atomic) productSites = [getMapping(rule.mapping, action.site1), getMapping(rule.mapping, action.site2)] atomic, rc, _ = extractMolecules(action.action, productSites[0], productSites[1], rule.products,differentiateDimers) productElements.append(rc) atomicArray.update(atomic) actionName.append('%i-%s' % (index, action.action)) r = '+'.join([str(x) for x in rule.reactants]) p = '+'.join([str(x) for x in rule.products]) label.append('->'.join([r, p, '%i-%s' % (index, action.action)])) solveWildcards(atomicArray) return (atomicArray, transformationCenter, transformationContext, productElements, actionName, label) if __name__ == "__main__": import readBNGXML _, rules, _ = readBNGXML.parseXML('output205_test.xml') for idx, rule in enumerate(rules): tatomicArray, ttransformationCenter, ttransformationContext, \ tproductElements, tactionNames, tlabelArray = extractTransformations( [rule], True) if rule[0].label == 'reaction_3': print ttransformationContext print tproductElements raise Exception