def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) rnaIds = [ "EG10367_RNA[c]", "EG11036_RNA[c]", "EG50002_RNA[c]", "EG10671_RNA[c]", "EG50003_RNA[c]", "EG10669_RNA[c]", "EG10873_RNA[c]", "EG12179_RNA[c]", "EG10321_RNA[c]", "EG10544_RNA[c]", ] names = [ "gapA - Glyceraldehyde 3-phosphate dehydrogenase", "tufA - Elongation factor Tu", "rpmA - 50S Ribosomal subunit protein L27", "ompF - Outer membrane protein F", "acpP - Apo-[acyl carrier protein]", "ompA - Outer membrane protein A", "rplL - 50S Ribosomal subunit protein L7/L12 dimer", "cspE - Transcription antiterminator and regulator of RNA stability", "fliC - Flagellin", "lpp - Murein lipoprotein", ] moleculeIds = bulkMolecules.readAttribute("objectNames") rnaIndexes = np.array([moleculeIds.index(x) for x in rnaIds], np.int) rnaCounts = bulkMolecules.readColumn("counts")[:, rnaIndexes] bulkMolecules.close() initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join( simOutDir, "Main")).readColumn("time") - initialTime plt.figure(figsize=(8.5, 11)) for subplotIdx in xrange(1, 10): plt.subplot(3, 3, subplotIdx) plt.plot(time / 60., rnaCounts[:, subplotIdx]) plt.xlabel("Time (min)") plt.ylabel("mRNA counts") plt.title(names[subplotIdx].split(" - ")[0]) plt.subplots_adjust(hspace=0.5, top=0.95, bottom=0.05) exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) rnaIds = [ "G7355_RNA[c]", "EG11783_RNA[c]", "G7742_RNA[c]", "G6253_RNA[c]", "EG10632_RNA[c]", "EG11484_RNA[c]", "G7889_RNA[c]", "EG10997_RNA[c]", "EG10780_RNA[c]", "EG11060_RNA[c]", ] names = [ "ypjD - Predicted inner membrane protein", "intA - CP4-57 prophage; integrase", "yrfG - Purine nucleotidase", "ylaC - Predicted inner membrane protein", "nagA - N-acetylglucosamine-6-phosphate deacetylase", "yigZ - Predicted elongation factor", "lptG - LptG (part of LPS transport system)", "mnmE - GTPase, involved in modification of U34 in tRNA", "pspE - Thiosulfate sulfurtransferase", "ushA - UDP-sugar hydrolase / 5'-ribonucleotidase / 5'-deoxyribonucleotidase", ] moleculeIds = bulkMolecules.readAttribute("objectNames") rnaIndexes = np.array([moleculeIds.index(x) for x in rnaIds], np.int) rnaCounts = bulkMolecules.readColumn("counts")[:, rnaIndexes] bulkMolecules.close() initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join( simOutDir, "Main")).readColumn("time") - initialTime plt.figure(figsize=(8.5, 11)) for subplotIdx in xrange(1, 10): plt.subplot(3, 3, subplotIdx) plt.plot(time / 60., rnaCounts[:, subplotIdx]) plt.xlabel("Time (min)") plt.ylabel("mRNA counts") plt.title(names[subplotIdx].split(" - ")[0]) plt.subplots_adjust(hspace=0.5, top=0.95, bottom=0.05) exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def mp_worker(sim_dir): sim_out_dir = os.path.join(sim_dir, 'simOut') ribosome_count_avg_cell = None try: (ribosome_30s_count, ribosome_50s_count) = read_bulk_molecule_counts( sim_out_dir, ( [ribosome_30s_id], [ribosome_50s_id])) unique_molecule_reader = TableReader(os.path.join(sim_out_dir, 'UniqueMoleculeCounts')) unique_molecule_ids = unique_molecule_reader.readAttribute('uniqueMoleculeIds') unique_molecule_counts = unique_molecule_reader.readColumn('uniqueMoleculeCounts') unique_molecule_reader.close() index_ribosome = unique_molecule_ids.index('activeRibosome') ribosome_active_count = unique_molecule_counts[:, index_ribosome] index_average_cell = int(len(ribosome_active_count) * CELL_CYCLE_FRACTION) ribosome_count_avg_cell = ribosome_active_count[index_average_cell] + min( ribosome_30s_count[index_average_cell], ribosome_50s_count[index_average_cell]) except Exception as e: print('Excluded from analysis due to broken files: {}'.format(sim_out_dir)) return ribosome_count_avg_cell
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) moleculeIds = bulkMolecules.readAttribute("objectNames") waterIndex = np.array(moleculeIds.index('WATER[c]'), np.int) waterCount = bulkMolecules.readColumn("counts")[:, waterIndex] initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join( simOutDir, "Main")).readColumn("time") - initialTime bulkMolecules.close() plt.figure(figsize=(8.5, 11)) plt.plot(time / 60., waterCount, linewidth=2) plt.xlabel("Time (min)") plt.ylabel("WATER[c] counts") plt.title("Counts of water") exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) ribosomeData = TableReader(os.path.join(simOutDir, "RibosomeData")) initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join( simOutDir, "Main")).readColumn("time") - initialTime fractionStalled = ribosomeData.readColumn("fractionStalled") ribosomeData.close() plt.figure(figsize=(8.5, 11)) plt.plot(time / 60, fractionStalled) plt.xlabel("Time (min)") plt.ylabel("Fraction of ribosomes stalled") plt.subplots_adjust(hspace=0.5, wspace=0.5) exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def mp_worker(sim_dir): sim_out_dir = os.path.join(sim_dir, 'simOut') rnap_count_avg_cell = None try: bulk_molecule_reader = TableReader( os.path.join(sim_out_dir, 'BulkMolecules')) index_rnap = bulk_molecule_reader.readAttribute('objectNames').index( rnap_id) rnap_count = bulk_molecule_reader.readColumn('counts', np.array([index_rnap])) unique_molecule_reader = TableReader( os.path.join(sim_out_dir, 'UniqueMoleculeCounts')) unique_molecule_ids = unique_molecule_reader.readAttribute( 'uniqueMoleculeIds') unique_molecule_counts = unique_molecule_reader.readColumn( 'uniqueMoleculeCounts') unique_molecule_reader.close() index_rnap = unique_molecule_ids.index('activeRnaPoly') rnap_active_count = unique_molecule_counts[:, index_rnap] index_average_cell = int(len(rnap_active_count) * CELL_CYCLE_FRACTION) rnap_count_avg_cell = rnap_count[ index_average_cell] + rnap_active_count[index_average_cell] except Exception as e: print('Excluded from analysis due to broken files: {}'.format( sim_out_dir)) return rnap_count_avg_cell
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) rnaIds = [ "EG10789_RNA[c]", "EG11556_RNA[c]", "EG12095_RNA[c]", "G1_RNA[c]", "G360_RNA[c]", "EG10944_RNA[c]", "EG12419_RNA[c]", "EG10372_RNA[c]", "EG10104_RNA[c]", "EG10539_RNA[c]", ] names = [ "ptsI - PTS enzyme I", "talB - Transaldolase", "secG - SecG", "thiS - ThiS protein", "flgD - Flagellar biosynthesis", "serA - (S)-2-hydroxyglutarate reductase", "gatY - GatY", "gdhA - Glutamate dehydrogenase", "atpG - ATP synthase F1 complex - gamma subunit", "livJ - Branched chain amino acid ABC transporter - periplasmic binding protein", ] moleculeIds = bulkMolecules.readAttribute("objectNames") rnaIndexes = np.array([moleculeIds.index(x) for x in rnaIds], np.int) rnaCounts = bulkMolecules.readColumn("counts")[:, rnaIndexes] bulkMolecules.close() initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join( simOutDir, "Main")).readColumn("time") - initialTime plt.figure(figsize=(8.5, 11)) for subplotIdx in xrange(1, 10): plt.subplot(3, 3, subplotIdx) plt.plot(time / 60., rnaCounts[:, subplotIdx]) plt.xlabel("Time (min)") plt.ylabel("mRNA counts") plt.title(names[subplotIdx].split(" - ")[0]) plt.subplots_adjust(hspace=0.5, top=0.95, bottom=0.05) exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) # Get time time = TableReader(os.path.join(simOutDir, "Main")).readColumn("time") # Get tRNA IDs and counts sim_data = cPickle.load(open(simDataFile, "rb")) isTRna = sim_data.process.transcription.rnaData["isTRna"] rnaIds = sim_data.process.transcription.rnaData["id"][isTRna] bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) moleculeIds = bulkMolecules.readAttribute("objectNames") rnaIndexes = np.array( [moleculeIds.index(moleculeId) for moleculeId in rnaIds], np.int) rnaCountsBulk = bulkMolecules.readColumn("counts")[:, rnaIndexes] bulkMolecules.close() # Plot fig = plt.figure(figsize=(8.5, 11)) ax = plt.subplot(1, 1, 1) ax.plot(time, rnaCountsBulk) ax.set_xlim([time[0], time[-1]]) ax.set_xlabel("Time (s)") ax.set_ylabel("Counts of tRNAs") ax.spines["right"].set_visible(False) ax.spines["top"].set_visible(False) ax.tick_params(right="off", top="off", which="both", direction="out") exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) sim_data = cPickle.load(open(simDataFile, "rb")) isMRna = sim_data.process.transcription.rnaData["isMRna"] isRRna = sim_data.process.transcription.rnaData["isRRna"] isTRna = sim_data.process.transcription.rnaData["isTRna"] rnaSynthProbListener = TableReader(os.path.join(simOutDir, "RnaSynthProb")) rnaIds = rnaSynthProbListener.readAttribute('rnaIds') rnaSynthProb = rnaSynthProbListener.readColumn('rnaSynthProb') time = rnaSynthProbListener.readColumn('time') rnaSynthProbListener.close() mRnaSynthProb = rnaSynthProb[:, isMRna].sum(axis = 1) rRnaSynthProb = rnaSynthProb[:, isRRna].sum(axis = 1) tRnaSynthProb = rnaSynthProb[:, isTRna].sum(axis = 1) # Plot rows = 3 cols = 1 fig = plt.figure(figsize = (11, 8.5)) plt.figtext(0.4, 0.96, "RNA synthesis probabilities over time", fontsize = 12) nMRnas = np.sum(isMRna) nRRnas = np.sum(isRRna) nTRnas = np.sum(isTRna) subplotOrder = [mRnaSynthProb, rRnaSynthProb, tRnaSynthProb] subplotTitles = ["mRNA\n(sum of %s mRNAs)" % nMRnas, "rRNA\n(sum of %s rRNAs)" % nRRnas, "tRNA\n(sum of %s tRNAs)" % nTRnas] for index, rnaSynthProb in enumerate(subplotOrder): ax = plt.subplot(rows, cols, index + 1) ax.plot(time, rnaSynthProb) ax.set_title(subplotTitles[index], fontsize = 10) ymin = np.min(rnaSynthProb) ymax = np.max(rnaSynthProb) yaxisBuffer = np.around(1.2*(ymax - ymin), 3) ax.set_ylim([ymin, yaxisBuffer]) ax.set_yticks([ymin, ymax, yaxisBuffer]) ax.set_yticklabels([ymin, np.around(ymax, 3), yaxisBuffer], fontsize = 10) ax.set_xlim([time[0], time[-1]]) ax.tick_params(axis = "x", labelsize = 10) ax.spines["left"].set_visible(False) ax.spines["right"].set_visible(False) plt.subplots_adjust(hspace = 0.5, ) exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) sim_data = cPickle.load(open(simDataFile)) # Get exchange flux data fbaResults = TableReader(os.path.join(simOutDir, "FBAResults")) initialTime = units.s * TableReader(os.path.join(simOutDir, "Main")).readAttribute("initialTime") time = units.s * TableReader(os.path.join(simOutDir, "Main")).readColumn("time") - initialTime externalExchangeFluxes = fbaResults.readColumn("externalExchangeFluxes") externalMoleculeIDs = np.array(fbaResults.readAttribute("externalMoleculeIDs")) fbaResults.close() massExchange = sim_data.getter.getMass(externalMoleculeIDs).asNumber(units.g / units.mmol) * externalExchangeFluxes # g / gDCW-hr # Get growth rate data growthRateData = TableReader(os.path.join(simOutDir, "Mass")) growthRate = ((1 / units.s) * growthRateData.readColumn("instantaniousGrowthRate")).asUnit(1 / units.h) # g / gDCW-hr doublingTime = (1 / growthRate) * np.log(2) # Plot stuff fig = plt.figure() fig.set_size_inches(8.5,11) ax1 = plt.subplot(3,1,1) ax1.plot(time.asNumber(units.min), doublingTime.asNumber(units.min)) ax1.plot(time.asNumber(units.min), sim_data.doubling_time.asNumber(units.min) * np.ones(time.asNumber().size), linestyle='--') medianDoublingTime = np.median(doublingTime.asNumber(units.min)[1:]) ax1.set_ylim([medianDoublingTime - 2*medianDoublingTime, medianDoublingTime + 2*medianDoublingTime]) ax1.set_ylabel("Doubling\ntime (min)") ax2 = plt.subplot(3,1,2) ax2.plot(time.asNumber(units.min), massExchange) maxMassExchange = massExchange[100:].max() minMassExchange = massExchange[100:].min() ax2.set_ylim([minMassExchange, maxMassExchange]) ax2.set_ylabel("Mass exchange\n(g / gDCW-hr)") ax3 = plt.subplot(3,1,3) water = massExchange[:, np.where(externalMoleculeIDs == "WATER[p]")[0][0]].copy() waterAll = massExchange[:, np.where(externalMoleculeIDs == "WATER[p]")[0][0]].copy() water[doublingTime.asNumber() > 0.] = np.nan ax3.plot(time.asNumber(units.min), waterAll, 'k.') ax3.plot(time.asNumber(units.min), water, 'b.') maxMassExchange = massExchange[100:].max() minMassExchange = massExchange[100:].min() ax3.set_ylim([minMassExchange, maxMassExchange]) ax3.set_ylabel("Water exchange\nwhen doubling time < 0") exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) # Get the names of rnas from the KB sim_data = cPickle.load(open(simDataFile, "rb")) rnaIds = sim_data.process.transcription.rnaData["id"][ sim_data.relation.rnaIndexToMonomerMapping] proteinIds = sim_data.process.translation.monomerData["id"] bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) bulkMoleculeCounts = bulkMolecules.readColumn("counts") moleculeIds = bulkMolecules.readAttribute("objectNames") rnaIndexes = np.array( [moleculeIds.index(moleculeId) for moleculeId in rnaIds], np.int) rnaCountsBulk = bulkMoleculeCounts[:, rnaIndexes] proteinIndexes = np.array( [moleculeIds.index(moleculeId) for moleculeId in proteinIds], np.int) proteinCountsBulk = bulkMoleculeCounts[:, proteinIndexes] bulkMolecules.close() relativeMRnaCounts = rnaCountsBulk[ -1, :] #/ rnaCountsBulk[-1, :].sum() relativeProteinCounts = proteinCountsBulk[ -1, :] #/ proteinCountsBulk[-1, :].sum() plt.figure(figsize=(8.5, 11)) plt.plot(relativeMRnaCounts, relativeProteinCounts, 'o', markeredgecolor='k', markerfacecolor='none') plt.xlabel("RNA count (at final time step)") plt.ylabel("Protein count (at final time step)") # plt.show() exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) sim_data = cPickle.load(open(simDataFile, "r")) trpIdx = sim_data.moleculeGroups.aaIDs.index("TRP[c]") growthLimits = TableReader(os.path.join(simOutDir, "GrowthLimits")) trpRequests = growthLimits.readColumn("aaRequestSize")[BURN_IN:, trpIdx] growthLimits.close() bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) moleculeIds = bulkMolecules.readAttribute("objectNames") trpSynIdx = moleculeIds.index("TRYPSYN[c]") trpSynCounts = bulkMolecules.readColumn("counts")[BURN_IN:, trpSynIdx] bulkMolecules.close() trpSynKcat = 2**( (37. - 25.) / 10.) * 4.1 # From PMID 6402362 (kcat of 4.1/s measured at 25 C) initialTime = TableReader(os.path.join(simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join(simOutDir, "Main")).readColumn("time")[BURN_IN:] - initialTime timeStep = TableReader(os.path.join(simOutDir, "Main")).readColumn("timeStepSec")[BURN_IN:] trpSynMaxCapacity = trpSynKcat * trpSynCounts * timeStep plt.figure(figsize = (8.5, 11)) plt.subplot(3, 1, 1) plt.plot(time / 60., trpSynMaxCapacity, linewidth = 2) plt.ylabel("Tryptophan Synthase Max Capacity") plt.subplot(3, 1, 2) plt.plot(time / 60., trpRequests, linewidth = 2) plt.ylabel("TRP requested by translation") plt.subplot(3, 1, 3) plt.plot(time / 60., trpSynMaxCapacity / trpRequests, linewidth = 2) plt.xlabel("Time (min)") plt.ylabel("(Max capacity) / (Request)") exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) bulkMoleculeCounts = bulkMolecules.readColumn("counts") moleculeIds = bulkMolecules.readAttribute("objectNames") rnapId = "APORNAP-CPLX[c]" rnapIndex = moleculeIds.index(rnapId) rnapCountsBulk = bulkMoleculeCounts[:, rnapIndex] RNAP_RNA_IDS = ["EG10893_RNA[c]", "EG10894_RNA[c]", "EG10895_RNA[c]", "EG10896_RNA[c]"] rnapRnaIndexes = np.array([moleculeIds.index(rnapRnaId) for rnapRnaId in RNAP_RNA_IDS], np.int) rnapRnaCounts = bulkMoleculeCounts[:, rnapRnaIndexes] bulkMolecules.close() uniqueMoleculeCounts = TableReader(os.path.join(simOutDir, "UniqueMoleculeCounts")) rnapIndex = uniqueMoleculeCounts.readAttribute("uniqueMoleculeIds").index("activeRnaPoly") initialTime = TableReader(os.path.join(simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join(simOutDir, "Main")).readColumn("time") - initialTime nActive = uniqueMoleculeCounts.readColumn("uniqueMoleculeCounts")[:, rnapIndex] uniqueMoleculeCounts.close() plt.figure(figsize = (8.5, 11)) plt.subplot(5, 1, 1) plt.plot(time / 60., nActive + rnapCountsBulk) plt.xlabel("Time (min)") plt.ylabel("Protein Counts") plt.title("RNA Polymerase") for subplotIdx in xrange(2, 6): rnapRnaCountsIdx = subplotIdx - 2 plt.subplot(5, 1, subplotIdx) plt.plot(time / 60., rnapRnaCounts[:, rnapRnaCountsIdx]) plt.xlabel("Time (min)") plt.ylabel("mRNA counts") plt.title(RNAP_RNA_IDS[rnapRnaCountsIdx]) plt.subplots_adjust(hspace = 0.5, top = 0.95, bottom = 0.05) exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) # Get the names of rnas from the KB sim_data = cPickle.load(open(simDataFile, "rb")) isTRna = sim_data.process.transcription.rnaData["isTRna"] rnaIds = sim_data.process.transcription.rnaData["id"][isTRna] bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) moleculeIds = bulkMolecules.readAttribute("objectNames") rnaIndexes = np.array([moleculeIds.index(moleculeId) for moleculeId in rnaIds], np.int) rnaCountsBulk = bulkMolecules.readColumn("counts")[:, rnaIndexes] bulkMolecules.close() # avgCounts = rnaCountsBulk.mean(0) # relativeCounts = avgCounts / avgCounts.sum() # relativeCounts = rnaCountsBulk[-1, :] / rnaCountsBulk[-1, :].sum() plt.figure(figsize = (8.5, 11)) counts = rnaCountsBulk[-1, :] expectedCountsArbitrary = sim_data.process.transcription.rnaExpression[sim_data.condition][isTRna] expectedCounts = expectedCountsArbitrary/expectedCountsArbitrary.sum() * counts.sum() maxLine = 1.1 * max(expectedCounts.max(), counts.max()) plt.plot([0, maxLine], [0, maxLine], '--r') plt.plot(expectedCounts, counts, 'o', markeredgecolor = 'k', markerfacecolor = 'none') plt.xlabel("Expected tRNA count (scaled to total)") plt.ylabel("Actual tRNA count (at final time step)") # plt.show() exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) processNames = bulkMolecules.readAttribute("processNames") atpAllocatedInitial = bulkMolecules.readColumn("atpAllocatedInitial") atpRequested = bulkMolecules.readColumn("atpRequested") initialTime = TableReader(os.path.join(simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join(simOutDir, "Main")).readColumn("time") - initialTime bulkMolecules.close() # Plot plt.figure(figsize = (8.5, 11)) rows = 7 cols = 2 for processIndex in np.arange(len(processNames)): ax = plt.subplot(rows, cols, processIndex + 1) ax.plot(time / 60., atpAllocatedInitial[:, processIndex]) ax.plot(time / 60., atpRequested[:, processIndex]) ax.set_title(str(processNames[processIndex]), fontsize = 8, y = 0.85) ymin = np.amin([atpAllocatedInitial[:, processIndex], atpRequested[:, processIndex]]) ymax = np.amax([atpAllocatedInitial[:, processIndex], atpRequested[:, processIndex]]) ax.set_ylim([ymin, ymax]) ax.set_yticks([ymin, ymax]) ax.set_yticklabels(["%0.2e" % ymin, "%0.2e" % ymax]) ax.spines['top'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.xaxis.set_ticks_position('bottom') ax.tick_params(which = 'both', direction = 'out', labelsize = 6) # ax.set_xticks([]) exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all") plt.subplots_adjust(hspace = 2.0, wspace = 2.0)
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) initialTime = TableReader(os.path.join(simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join(simOutDir, "Main")).readColumn("time") - initialTime timeStepSec = TableReader(os.path.join(simOutDir, "Main")).readColumn("timeStepSec") fba_results = TableReader(os.path.join(simOutDir, "FBAResults")) exFlux = fba_results.readColumn("externalExchangeFluxes") exMolec = fba_results.readAttribute("externalMoleculeIDs") fba_results.close() mass = TableReader(os.path.join(simOutDir, "Mass")) processMassDifferences = mass.readColumn("processMassDifferences") cellMass = mass.readColumn("dryMass") mass.close() exchangeMasses = {} # some duplicates in exMolec like CO2 and water so create dict to avoid double counting raw_data = KnowledgeBaseEcoli() for metabolite in raw_data.metabolites: for molecID in exMolec: if molecID.split("[")[0] == "WATER": exchangeMasses[molecID] = 18.015 * exFlux[:,exMolec.index(molecID)] * 10**-3 * cellMass * timeStepSec / 60 / 60 if molecID.split("[")[0] == metabolite["id"]: exchangeMasses[molecID] = metabolite["mw7.2"] * exFlux[:,exMolec.index(molecID)] * 10**-3 * cellMass * timeStepSec / 60 / 60 massInflux = 0 for molecID in exchangeMasses.keys(): massInflux += exchangeMasses[molecID] massProduced = processMassDifferences[:,0] # in metabolism massDiff = massInflux + massProduced plt.plot(time / 60. / 60., -massDiff) plt.tick_params(axis='both', which='major', labelsize=10) plt.ylabel("Mass Accumulation per time step (fg)") plt.title("Mass imported - mass created in metabolism process") exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) sim_data = cPickle.load(open(simDataFile, "rb")) fbaResults = TableReader(os.path.join(simOutDir, "FBAResults")) externalExchangeFluxes = fbaResults.readColumn("externalExchangeFluxes") initialTime = TableReader(os.path.join(simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join(simOutDir, "Main")).readColumn("time") - initialTime timeStepSec = TableReader(os.path.join(simOutDir, "Main")).readColumn("timeStepSec") externalMoleculeIDs = np.array(fbaResults.readAttribute("externalMoleculeIDs")) fbaResults.close() if GLUCOSE_ID not in externalMoleculeIDs: print "This plot only runs when glucose is the carbon source." return glucoseIdx = np.where(externalMoleculeIDs == GLUCOSE_ID)[0][0] glucoseFlux = FLUX_UNITS * externalExchangeFluxes[:, glucoseIdx] mass = TableReader(os.path.join(simOutDir, "Mass")) cellMass = MASS_UNITS * mass.readColumn("cellMass") cellDryMass = MASS_UNITS * mass.readColumn("dryMass") growth = GROWTH_UNITS * mass.readColumn("growth") / timeStepSec mass.close() glucoseMW = sim_data.getter.getMass([GLUCOSE_ID])[0] glucoseMassFlux = glucoseFlux * glucoseMW * cellDryMass glucoseMassYield = growth / -glucoseMassFlux fig = plt.figure(figsize = (8.5, 11)) plt.plot(time, glucoseMassYield) plt.xlabel("Time (s)") plt.ylabel("g cell / g glucose") exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) moleculeIds = bulkMolecules.readAttribute("objectNames") sim_data = cPickle.load(open(simDataFile)) aaIDs = sim_data.moleculeGroups.aaIDs aaIndexes = np.array([moleculeIds.index(aaId) for aaId in aaIDs], np.int) aaCounts = bulkMolecules.readColumn("counts")[:, aaIndexes] initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join( simOutDir, "Main")).readColumn("time") - initialTime bulkMolecules.close() plt.figure(figsize=(8.5, 11)) for idx in xrange(21): plt.subplot(6, 4, idx + 1) plt.plot(time / 60., aaCounts[:, idx], linewidth=2) plt.xlabel("Time (min)") plt.ylabel("Counts") plt.title(aaIDs[idx]) plt.subplots_adjust(hspace=0.5, wspace=0.5) exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) moleculeIds = bulkMolecules.readAttribute("objectNames") NTP_IDS = ['ATP[c]', 'CTP[c]', 'GTP[c]', 'UTP[c]'] ntpIndexes = np.array([moleculeIds.index(ntpId) for ntpId in NTP_IDS], np.int) ntpCounts = bulkMolecules.readColumn("counts")[:, ntpIndexes] initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join( simOutDir, "Main")).readColumn("time") - initialTime bulkMolecules.close() plt.figure(figsize=(8.5, 11)) for idx in xrange(4): plt.subplot(2, 2, idx + 1) plt.plot(time / 60., ntpCounts[:, idx], linewidth=2) plt.xlabel("Time (min)") plt.ylabel("Counts") plt.title(NTP_IDS[idx]) print "NTPs required for cell division (nt/cell-cycle) = %d" % sum( ntpCounts[0, :]) plt.subplots_adjust(hspace=0.5) exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) moleculeIds = bulkMolecules.readAttribute("objectNames") rnapId = "APORNAP-CPLX[c]" rnapIndex = moleculeIds.index(rnapId) rnapCountsBulk = bulkMolecules.readColumn("counts")[:, rnapIndex] bulkMolecules.close() uniqueMoleculeCounts = TableReader( os.path.join(simOutDir, "UniqueMoleculeCounts")) rnapIndex = uniqueMoleculeCounts.readAttribute( "uniqueMoleculeIds").index("activeRnaPoly") initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join( simOutDir, "Main")).readColumn("time") - initialTime nActive = uniqueMoleculeCounts.readColumn( "uniqueMoleculeCounts")[:, rnapIndex] uniqueMoleculeCounts.close() plt.figure(figsize=(8.5, 11)) plt.plot(time / 60., nActive * 100. / (nActive + rnapCountsBulk)) #plt.axis([0,60,0,25]) plt.xlabel("Time (min)") plt.ylabel("Percent of RNA Polymerase Molecules that are Active") plt.title("Active RNA Polymerase Percentage") exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) moleculeIds = bulkMolecules.readAttribute("objectNames") RIBOSOME_RNA_IDS = ["RRLA-RRNA[c]", "RRSA-RRNA[c]", "RRFA-RRNA[c]"] ribosomeRnaIndexes = np.array([moleculeIds.index(rRnaId) for rRnaId in RIBOSOME_RNA_IDS], np.int) ribosomeRnaCountsBulk = bulkMolecules.readColumn("counts")[:, ribosomeRnaIndexes] bulkMolecules.close() uniqueMoleculeCounts = TableReader(os.path.join(simOutDir, "UniqueMoleculeCounts")) ribosomeIndex = uniqueMoleculeCounts.readAttribute("uniqueMoleculeIds").index("activeRibosome") initialTime = TableReader(os.path.join(simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join(simOutDir, "Main")).readColumn("time") - initialTime nActive = uniqueMoleculeCounts.readColumn("uniqueMoleculeCounts")[:, ribosomeIndex] uniqueMoleculeCounts.close() plt.figure(figsize = (8.5, 11)) plt.plot(time / 60, nActive) plt.plot([time[0] / 60., time[-1] / 60.], [2 * nActive[0], 2 * nActive[0]], "r--") plt.xlabel("Time (min)") plt.ylabel("Counts") plt.title("Active Ribosomes Final:Initial = %0.2f" % (nActive[-1] / float(nActive[0]))) exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) validation_data = cPickle.load(open(validationDataFile, "rb")) sim_data = cPickle.load(open(simDataFile, "rb")) cellDensity = sim_data.constants.cellDensity initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join( simOutDir, "Main")).readColumn("time") - initialTime massListener = TableReader(os.path.join(simOutDir, "Mass")) cellMass = massListener.readColumn("cellMass") * units.fg dryMass = massListener.readColumn("dryMass") * units.fg massListener.close() fbaResults = TableReader(os.path.join(simOutDir, "FBAResults")) reactionIDs = np.array(fbaResults.readAttribute("reactionIDs")) reactionFluxes = (COUNTS_UNITS / VOLUME_UNITS / TIME_UNITS) * np.array( fbaResults.readColumn("reactionFluxes")) fbaResults.close() dryMassFracAverage = np.mean(dryMass / cellMass) toya_reactions = validation_data.reactionFlux.toya2010fluxes[ "reactionID"] toya_fluxes = FLUX_UNITS * np.array( [(dryMassFracAverage * cellDensity * x).asNumber(FLUX_UNITS) for x in validation_data.reactionFlux.toya2010fluxes["reactionFlux"]]) netFluxes = [] for toyaReactionID in toya_reactions: fluxTimeCourse = net_flux( toyaReactionID, reactionIDs, reactionFluxes).asNumber(FLUX_UNITS).squeeze() netFluxes.append(fluxTimeCourse) trimmedReactions = FLUX_UNITS * np.array(netFluxes) corrCoefTimecourse = [] for fluxes in trimmedReactions.asNumber(FLUX_UNITS).T: correlationCoefficient = np.corrcoef( fluxes, toya_fluxes.asNumber(FLUX_UNITS))[0, 1] corrCoefTimecourse.append(correlationCoefficient) meanCorr = np.mean( np.array(corrCoefTimecourse)[~np.isnan(corrCoefTimecourse)]) plt.figure() plt.plot(time / 60., corrCoefTimecourse) plt.axhline(y=meanCorr, color='r') plt.title("Measured vs. Simulated Central Carbon Fluxes") plt.text(.5 * np.max(time / 60.), .95 * meanCorr, "Mean = {:.2}".format(meanCorr), horizontalalignment="center") plt.xlabel("Time (min)") plt.ylabel("Pearson R") exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) # Load data from KB sim_data = cPickle.load(open(simDataFile, "rb")) endoRnaseIds = sim_data.process.rna_decay.endoRnaseIds exoRnaseIds = sim_data.moleculeGroups.exoRnaseIds RnaseIds = np.concatenate((endoRnaseIds, exoRnaseIds)) # Load count data for s30 proteins, rRNA, and final 30S complex bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) moleculeIds = bulkMolecules.readAttribute("objectNames") bulkMoleculeCounts = bulkMolecules.readColumn("counts") # Get indexes proteinIndexes = np.array( [moleculeIds.index(protein) for protein in RnaseIds], np.int) exoproteinIndexes = np.array( [moleculeIds.index(protein) for protein in exoRnaseIds], np.int) endoproteinIndexes = np.array( [moleculeIds.index(protein) for protein in endoRnaseIds], np.int) # Load data initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join( simOutDir, "Main")).readColumn("time") - initialTime RnaseCounts = bulkMoleculeCounts[:, proteinIndexes] exoRnaseCounts = bulkMoleculeCounts[:, exoproteinIndexes] endoRnaseCounts = bulkMoleculeCounts[:, endoproteinIndexes] bulkMolecules.close() rnaDegradationListenerFile = TableReader( os.path.join(simOutDir, "RnaDegradationListener")) countRnaDegraded = rnaDegradationListenerFile.readColumn( 'countRnaDegraded') nucleotidesFromDegradation = rnaDegradationListenerFile.readColumn( 'nucleotidesFromDegradation') FractionActiveEndoRNases = rnaDegradationListenerFile.readColumn( 'FractionActiveEndoRNases') DiffRelativeFirstOrderDecay = rnaDegradationListenerFile.readColumn( 'DiffRelativeFirstOrderDecay') FractEndoRRnaCounts = rnaDegradationListenerFile.readColumn( 'FractEndoRRnaCounts') fragmentBasesDigested = rnaDegradationListenerFile.readColumn( 'fragmentBasesDigested') rnaDegradationListenerFile.close() TranscriptElongationListenerFile = TableReader( os.path.join(simOutDir, "TranscriptElongationListener")) countNTPsUSed = TranscriptElongationListenerFile.readColumn( 'countNTPsUSed') countRnaSynthesized = TranscriptElongationListenerFile.readColumn( 'countRnaSynthesized') TranscriptElongationListenerFile.close() totalRnaseCounts = RnaseCounts.sum(axis=1) requiredRnaseTurnover = nucleotidesFromDegradation / RnaseCounts.sum( axis=1) totalexoRnaseCounts = exoRnaseCounts.sum(axis=1) totalendoRnaseCounts = endoRnaseCounts.sum(axis=1) # Load data growthLimitsDataFile = TableReader( os.path.join(simOutDir, "GrowthLimits")) # Translation gtpUsed = growthLimitsDataFile.readColumn("gtpAllocated") growthLimitsDataFile.close() # Load metabolism production fbaResults = TableReader(os.path.join(simOutDir, "FBAResults")) initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join( simOutDir, "Main")).readColumn("time") - initialTime deltaMetabolites = fbaResults.readColumn("deltaMetabolites") outputMoleculeIDs = np.array( fbaResults.readAttribute("metaboliteNames")) fbaResults.close() # Load ntps required for cell doubling bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) moleculeIds = bulkMolecules.readAttribute("objectNames") NTP_IDS = ['ATP[c]', 'CTP[c]', 'GTP[c]', 'UTP[c]'] ntpIndexes = np.array([moleculeIds.index(ntpId) for ntpId in NTP_IDS], np.int) ntpCounts = bulkMoleculeCounts[:, ntpIndexes] bulkMolecules.close() # Plotting plt.figure(figsize=(8.5, 11)) plt.rc('font', **FONT) max_yticks = 5 ax = plt.subplot(7, 2, 1) plt.plot(time / 60., countRnaSynthesized.sum(axis=1)) plt.ylabel("RNAs synthesized", fontsize=9) yloc = plt.MaxNLocator(max_yticks) ax.yaxis.set_major_locator(yloc) ax = plt.subplot(7, 2, 2) plt.plot(time / 60., gtpUsed / 1e6) plt.ylabel("Translation ($10^{%d}$nt)" % 6, fontsize=9) plt.title("GTPs needed (x$10^{%d}$) = %.2f" % (6, (gtpUsed.sum() / 1e6)), fontsize=9) yloc = plt.MaxNLocator(max_yticks) ax.yaxis.set_major_locator(yloc) ax = plt.subplot(7, 2, 3) plt.plot(time / 60., countRnaDegraded.sum(axis=1)) plt.ylabel("RNAs degraded", fontsize=9) yloc = plt.MaxNLocator(max_yticks) ax.yaxis.set_major_locator(yloc) ax = plt.subplot(7, 2, 5) plt.plot(time / 60., totalendoRnaseCounts) plt.ylabel("EndoRNase counts", fontsize=9) yloc = plt.MaxNLocator(max_yticks) ax.yaxis.set_major_locator(yloc) ax = plt.subplot(7, 2, 4) plt.plot(time / 60., countNTPsUSed / 1e6) plt.ylabel("Transcription ($10^{%d}$nt)" % 6, fontsize=9) plt.title("NTPs needed(x$10^{%d}$) = %.2f" % (6, (countNTPsUSed.sum() / 1e6)), fontsize=9) yloc = plt.MaxNLocator(max_yticks) ax.yaxis.set_major_locator(yloc) ax = plt.subplot(7, 2, 7) plt.plot(time / 60., totalexoRnaseCounts) plt.ylabel("ExoRNase counts", fontsize=9) yloc = plt.MaxNLocator(max_yticks) ax.yaxis.set_major_locator(yloc) IdxAtp = (np.where("ATP[c]" == outputMoleculeIDs))[0][0] ATP = np.sum(deltaMetabolites[:, IdxAtp]) IdxGtp = (np.where("GTP[c]" == outputMoleculeIDs))[0][0] GTP = np.sum(deltaMetabolites[:, IdxGtp]) IdxCtp = (np.where("CTP[c]" == outputMoleculeIDs))[0][0] CTP = np.sum(deltaMetabolites[:, IdxCtp]) IdxUtp = (np.where("UTP[c]" == outputMoleculeIDs))[0][0] UTP = np.sum(deltaMetabolites[:, IdxUtp]) NtpsProduced = ATP + GTP + CTP + UTP ax = plt.subplot(7, 2, 6) plt.plot(time / 60., (deltaMetabolites[:, IdxAtp] + deltaMetabolites[:, IdxGtp] + deltaMetabolites[:, IdxCtp] + deltaMetabolites[:, IdxUtp]) / 1e6) plt.ylabel("Metabolism ($10^{%d}$nt)" % 6, fontsize=9) plt.title( "NTPs produced (x$10^{%d}$) = %.2f" % (6, (sum(deltaMetabolites[:, IdxAtp] + deltaMetabolites[:, IdxGtp] + deltaMetabolites[:, IdxCtp] + deltaMetabolites[:, IdxUtp]) / 1e6)), fontsize=9) yloc = plt.MaxNLocator(max_yticks) ax.yaxis.set_major_locator(yloc) ax = plt.subplot(7, 2, 9) plt.plot(time / 60., FractionActiveEndoRNases * 100) plt.ylabel("EndoRN capacity (%)", fontsize=9) yloc = plt.MaxNLocator(max_yticks) ax.yaxis.set_major_locator(yloc) ax = plt.subplot(7, 2, 8) plt.plot(time / 60., fragmentBasesDigested / 1e6) plt.ylabel("Exo-digestion ($10^{%d}$nt)" % 6, fontsize=9) plt.title("NTPs recycled (x$10^{%d}$) = %.2f" % (6, (fragmentBasesDigested.sum() / 1e6)), fontsize=9) yloc = plt.MaxNLocator(max_yticks) ax.yaxis.set_major_locator(yloc) ax = plt.subplot(7, 2, 11) plt.plot(time / 60., DiffRelativeFirstOrderDecay) plt.ylabel("sum(Residuals)", fontsize=9) yloc = plt.MaxNLocator(max_yticks) ax.yaxis.set_major_locator(yloc) ax = plt.subplot(7, 2, 10) plt.plot(time / 60., (ntpCounts[:, 0] + ntpCounts[:, 1] + ntpCounts[:, 2] + ntpCounts[:, 3]) / 1e6) plt.ylabel("Net production ($10^{%d}$nt)" % 6, fontsize=9) plt.title("NTPs required for cell division (x$10^{%d}$) = %.2f" % (6, ((ntpCounts[0, 0] + ntpCounts[0, 1] + ntpCounts[0, 2] + ntpCounts[0, 3]) / 1e6)), fontsize=9) yloc = plt.MaxNLocator(max_yticks) ax.yaxis.set_major_locator(yloc) # compute active ExoRNase capacity (%) ActiveExoRNcapacity = fragmentBasesDigested.astype(float) / ( totalexoRnaseCounts * sim_data.constants.KcatExoRNase.asNumber()) * 100 ax = plt.subplot(7, 2, 13) plt.plot(time / 60., ActiveExoRNcapacity) plt.xlabel("Time (min)") plt.ylabel("ExoRN capacity (%)", fontsize=9) yloc = plt.MaxNLocator(max_yticks) ax.yaxis.set_major_locator(yloc) # compute instantaneous balance of nTPs InstantaneousNTPs = -gtpUsed - countNTPsUSed + ( deltaMetabolites[:, IdxAtp] + deltaMetabolites[:, IdxGtp] + deltaMetabolites[:, IdxCtp] + deltaMetabolites[:, IdxUtp]) + fragmentBasesDigested ax = plt.subplot(7, 2, 12) plt.plot(time / 60., InstantaneousNTPs / 1e6) plt.xlabel("Time (min)") plt.ylabel("Balance ($10^{%d}$nt)" % 6, fontsize=9) plt.title("Average instantaneous balance (x$10^{%d}$) = %.4f" % (6, (np.mean(InstantaneousNTPs) / 1e6)), fontsize=9) yloc = plt.MaxNLocator(max_yticks) ax.yaxis.set_major_locator(yloc) plt.subplots_adjust(hspace=0.6, wspace=0.35) exportFigure(plt, plotOutDir, plotOutFileName, metadata)
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) # Load data from KB sim_data = cPickle.load(open(simDataFile, "rb")) nAvogadro = sim_data.constants.nAvogadro cellDensity = sim_data.constants.cellDensity # Load time initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join( simOutDir, "Main")).readColumn("time") - initialTime # Load mass data # Total cell mass is needed to compute concentrations (since we have cell density) # Protein mass is needed to compute the mass fraction of the proteome that is tyrA massReader = TableReader(os.path.join(simOutDir, "Mass")) cellMass = units.fg * massReader.readColumn("cellMass") proteinMass = units.fg * massReader.readColumn("proteinMass") massReader.close() # Load data from bulk molecules bulkMoleculesReader = TableReader( os.path.join(simOutDir, "BulkMolecules")) bulkMoleculeIds = bulkMoleculesReader.readAttribute("objectNames") # Get the concentration of intracellular phe pheId = ["PHE[c]"] pheIndex = np.array([bulkMoleculeIds.index(x) for x in pheId]) pheCounts = bulkMoleculesReader.readColumn( "counts")[:, pheIndex].reshape(-1) pheMols = 1. / nAvogadro * pheCounts volume = cellMass / cellDensity pheConcentration = pheMols * 1. / volume # Get the amount of active tyrR (that isn't promoter bound) tyrRActiveId = ["MONOMER0-162[c]"] tyrRActiveIndex = np.array( [bulkMoleculeIds.index(x) for x in tyrRActiveId]) tyrRActiveCounts = bulkMoleculesReader.readColumn( "counts")[:, tyrRActiveIndex].reshape(-1) # Get the amount of inactive tyrR tyrRInactiveId = ["PD00413[c]"] tyrRInactiveIndex = np.array( [bulkMoleculeIds.index(x) for x in tyrRInactiveId]) tyrRInactiveCounts = bulkMoleculesReader.readColumn( "counts")[:, tyrRInactiveIndex].reshape(-1) # Get the promoter-bound status of the tyrA gene tyrATfBoundId = ["EG11039_RNA__MONOMER0-162"] tyrATfBoundIndex = np.array( [bulkMoleculeIds.index(x) for x in tyrATfBoundId]) tyrATfBoundCounts = bulkMoleculesReader.readColumn( "counts")[:, tyrATfBoundIndex].reshape(-1) # Get the amount of monomeric tyrA tyrAProteinId = ["CHORISMUTPREPHENDEHYDROG-MONOMER[c]"] tyrAProteinIndex = np.array( [bulkMoleculeIds.index(x) for x in tyrAProteinId]) tyrAProteinCounts = bulkMoleculesReader.readColumn( "counts")[:, tyrAProteinIndex].reshape(-1) tyrAComplexId = ["CHORISMUTPREPHENDEHYDROG-CPLX[c]"] tyrAComplexIndex = np.array( [bulkMoleculeIds.index(x) for x in tyrAComplexId]) tyrAComplexCounts = bulkMoleculesReader.readColumn( "counts")[:, tyrAComplexIndex].reshape(-1) bulkMoleculesReader.close() tyrAProteinTotalCounts = tyrAProteinCounts + 2 * tyrAComplexCounts # Compute the tyrA mass in the cell tyrAMw = sim_data.getter.getMass(tyrAProteinId) tyrAMass = 1. / nAvogadro * tyrAProteinTotalCounts * tyrAMw # Compute the proteome mass fraction proteomeMassFraction = tyrAMass.asNumber( units.fg) / proteinMass.asNumber(units.fg) # Get the tyrA synthesis probability rnaSynthProbReader = TableReader( os.path.join(simOutDir, "RnaSynthProb")) rnaIds = rnaSynthProbReader.readAttribute("rnaIds") tyrASynthProbId = ["EG11039_RNA[c]"] tyrASynthProbIndex = np.array( [rnaIds.index(x) for x in tyrASynthProbId]) tyrASynthProb = rnaSynthProbReader.readColumn( "rnaSynthProb")[:, tyrASynthProbIndex].reshape(-1) recruitmentColNames = sim_data.process.transcription_regulation.recruitmentColNames tfs = sorted( set([ x.split("__")[-1] for x in recruitmentColNames if x.split("__")[-1] != "alpha" ])) tyrRIndex = [i for i, tf in enumerate(tfs) if tf == "MONOMER0-162"][0] tyrRBound = rnaSynthProbReader.readColumn("nActualBound")[:, tyrRIndex] rnaSynthProbReader.close() # Calculate total tyrR - active, inactive and bound tyrRTotalCounts = tyrRActiveCounts + tyrRInactiveCounts + tyrRBound # Compute moving averages width = 100 tyrATfBoundCountsMA = np.convolve(tyrATfBoundCounts, np.ones(width) / width, mode="same") tyrASynthProbMA = np.convolve(tyrASynthProb, np.ones(width) / width, mode="same") plt.figure(figsize=(8.5, 11)) ############################################################## ax = plt.subplot(6, 1, 1) ax.plot(time, pheConcentration.asNumber(units.umol / units.L)) plt.ylabel("Internal phe Conc. [uM]", fontsize=6) ymin = np.amin(pheConcentration.asNumber(units.umol / units.L) * 0.9) ymax = np.amax(pheConcentration.asNumber(units.umol / units.L) * 1.1) if ymin != ymax: ax.set_ylim([ymin, ymax]) ax.set_yticks([ymin, ymax]) ax.set_yticklabels(["%0.0f" % ymin, "%0.0f" % ymax]) ax.spines['top'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.xaxis.set_ticks_position('none') ax.tick_params(which='both', direction='out', labelsize=6) ax.set_xticks([]) ############################################################## ############################################################## ax = plt.subplot(6, 1, 2) ax.plot(time, tyrRActiveCounts) ax.plot(time, tyrRInactiveCounts) ax.plot(time, tyrRTotalCounts) plt.ylabel("TyrR Counts", fontsize=6) plt.legend(["Active", "Inactive", "Total"], fontsize=6) ymin = min(np.amin(tyrRActiveCounts * 0.9), np.amin(tyrRInactiveCounts * 0.9)) ymax = np.amax(tyrRTotalCounts * 1.1) if ymin != ymax: ax.set_ylim([ymin, ymax]) ax.set_yticks([ymin, ymax]) ax.set_yticklabels(["%0.0f" % ymin, "%0.0f" % ymax]) ax.spines['top'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.xaxis.set_ticks_position('none') ax.tick_params(which='both', direction='out', labelsize=6) ax.set_xticks([]) ############################################################## ############################################################## ax = plt.subplot(6, 1, 3) ax.plot(time, tyrATfBoundCounts) ax.plot(time, tyrATfBoundCountsMA, color="g") plt.ylabel("TyrR Bound To tyrA Promoter", fontsize=6) ymin = np.amin(tyrATfBoundCounts * 1.) ymax = np.amax(tyrATfBoundCounts * 1.) if ymin != ymax: ax.set_ylim([ymin, ymax]) ax.set_yticks([ymin, ymax]) ax.set_yticklabels(["%0.0f" % ymin, "%0.0f" % ymax]) ax.spines['top'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.xaxis.set_ticks_position('none') ax.tick_params(which='both', direction='out', labelsize=6) ax.set_xticks([]) ############################################################## ############################################################## ax = plt.subplot(6, 1, 4) ax.plot(time, tyrASynthProb) ax.plot(time, tyrASynthProbMA, color="g") plt.ylabel("tyrA Synthesis Prob.", fontsize=6) ymin = np.amin(tyrASynthProb[1:] * 0.9) ymax = np.amax(tyrASynthProb[1:] * 1.1) if ymin != ymax: ax.set_ylim([ymin, ymax]) ax.set_yticks([ymin, ymax]) ax.set_yticklabels(["%0.2e" % ymin, "%0.2e" % ymax]) ax.spines['top'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.xaxis.set_ticks_position('none') ax.tick_params(which='both', direction='out', labelsize=6) ax.set_xticks([]) ############################################################## ############################################################## ax = plt.subplot(6, 1, 5) ax.plot(time, tyrAProteinTotalCounts) plt.ylabel("TyrA Counts", fontsize=6) ymin = np.amin(tyrAProteinTotalCounts * 0.9) ymax = np.amax(tyrAProteinTotalCounts * 1.1) if ymin != ymax: ax.set_ylim([ymin, ymax]) ax.set_yticks([ymin, ymax]) ax.set_yticklabels(["%0.0f" % ymin, "%0.0f" % ymax]) ax.spines['top'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.xaxis.set_ticks_position('none') ax.tick_params(which='both', direction='out', labelsize=6) ax.set_xticks([]) ############################################################## ############################################################## ax = plt.subplot(6, 1, 6) ax.plot(time, proteomeMassFraction) plt.ylabel("TyrA Mass Fraction of Proteome", fontsize=6) ymin = np.amin(proteomeMassFraction * 0.9) ymax = np.amax(proteomeMassFraction * 1.1) if ymin != ymax: ax.set_ylim([ymin, ymax]) ax.set_yticks([ymin, ymax]) ax.set_yticklabels(["%0.2e" % ymin, "%0.2e" % ymax]) ax.spines['top'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.xaxis.set_ticks_position('none') ax.tick_params(which='both', direction='out', labelsize=6) ax.set_xticks([]) ############################################################## exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) sim_data = cPickle.load(open(simDataFile)) constraintIsKcatOnly = sim_data.process.metabolism.constraintIsKcatOnly mainListener = TableReader(os.path.join(simOutDir, "Main")) initialTime = mainListener.readAttribute("initialTime") time = mainListener.readColumn("time") - initialTime mainListener.close() massListener = TableReader(os.path.join(simOutDir, "Mass")) cellMass = massListener.readColumn("cellMass") dryMass = massListener.readColumn("dryMass") massListener.close() coefficient = dryMass / cellMass * sim_data.constants.cellDensity.asNumber(MASS_UNITS / VOLUME_UNITS) # read constraint data enzymeKineticsReader = TableReader(os.path.join(simOutDir, "EnzymeKinetics")) targetFluxes = (COUNTS_UNITS / MASS_UNITS / TIME_UNITS) * (enzymeKineticsReader.readColumn("targetFluxes").T / coefficient).T actualFluxes = (COUNTS_UNITS / MASS_UNITS / TIME_UNITS) * (enzymeKineticsReader.readColumn("actualFluxes").T / coefficient).T reactionConstraint = enzymeKineticsReader.readColumn("reactionConstraint") constrainedReactions = np.array(enzymeKineticsReader.readAttribute("constrainedReactions")) enzymeKineticsReader.close() targetFluxes = targetFluxes.asNumber(units.mmol / units.g / units.h) actualFluxes = actualFluxes.asNumber(units.mmol / units.g / units.h) targetAve = np.mean(targetFluxes[BURN_IN_STEPS:, :], axis = 0) actualAve = np.mean(actualFluxes[BURN_IN_STEPS:, :], axis = 0) kcatOnlyReactions = np.all(constraintIsKcatOnly[reactionConstraint[BURN_IN_STEPS:,:]], axis = 0) kmAndKcatReactions = ~np.any(constraintIsKcatOnly[reactionConstraint[BURN_IN_STEPS:,:]], axis = 0) mixedReactions = ~(kcatOnlyReactions ^ kmAndKcatReactions) thresholds = [2, 10] categorization = np.zeros(reactionConstraint.shape[1]) categorization[actualAve == 0] = -2 categorization[actualAve == targetAve] = -1 for i, threshold in enumerate(thresholds): # categorization[targetAve / actualAve > threshold] = i + 1 categorization[actualAve / targetAve > threshold] = i + 1 # url for ecocyc to highlight fluxes that are 0 on metabolic network diagram siteStr = "https://ecocyc.org/overviewsWeb/celOv.shtml?zoomlevel=1&orgid=ECOLI" excluded = ['RXN0-2201', 'RXN-16000', 'RXN-12583', 'RXN-11496', 'DIMESULFREDUCT-RXN', '3.6.1.41-R[4/63051]5-NUCLEOTID-RXN'] # reactions not recognized by ecocyc rxns = [] for i, reaction in enumerate(constrainedReactions): if actualAve[i] == 0: rxn = re.findall(".+RXN", reaction) if len(rxn) == 0: rxn = re.findall("RXN[^-]*-[0-9]+", reaction) if rxn[0] not in excluded: siteStr += "&rnids=%s" % rxn[0] rxns.append(rxn[0]) # print siteStr csvFile = open(os.path.join(plotOutDir, plotOutFileName + ".tsv"), "wb") output = csv.writer(csvFile, delimiter = "\t") output.writerow(["ecocyc link:", siteStr]) output.writerow(["Km and kcat", "Target", "Actual", "Category"]) for reaction, target, flux, category in zip(constrainedReactions[kmAndKcatReactions], targetAve[kmAndKcatReactions], actualAve[kmAndKcatReactions], categorization[kmAndKcatReactions]): output.writerow([reaction, target, flux, category]) output.writerow(["kcat only"]) for reaction, target, flux, category in zip(constrainedReactions[kcatOnlyReactions], targetAve[kcatOnlyReactions], actualAve[kcatOnlyReactions], categorization[kcatOnlyReactions]): output.writerow([reaction, target, flux, category]) if np.sum(mixedReactions): output.writerow(["mixed constraints"]) for reaction, target, flux, category in zip(constrainedReactions[mixedReactions], targetAve[mixedReactions], actualAve[mixedReactions], categorization[mixedReactions]): output.writerow([reaction, target, flux, category]) csvFile.close() targetAve += 1e-6 actualAve += 1e-6 axes_limits = [1e-7, 1e4] plt.figure(figsize = (8, 8)) ax = plt.axes() plt.loglog(axes_limits, axes_limits, 'k') plt.loglog(targetAve, actualAve, "ob", markeredgewidth = 0.25, alpha = 0.25) plt.xlabel("Target Flux (mmol/g/hr)") plt.ylabel("Actual Flux (mmol/g/hr)") plt.minorticks_off() whitePadSparklineAxis(ax) ax.set_ylim(axes_limits) ax.set_xlim(axes_limits) ax.set_yticks(axes_limits) ax.set_xticks(axes_limits) exportFigure(plt, plotOutDir, plotOutFileName) plt.close("all") source = ColumnDataSource( data = dict( x = targetAve, y = actualAve, reactionName = constrainedReactions) ) hover = HoverTool( tooltips = [ ("Reaction", "@reactionName"), ] ) TOOLS = [hover, BoxZoomTool(), LassoSelectTool(), PanTool(), WheelZoomTool(), ResizeTool(), UndoTool(), RedoTool(), "reset", ] p1 = figure(x_axis_label = "Target", x_axis_type = "log", x_range = [min(targetAve[targetAve > 0]), max(targetAve)], y_axis_label = "Actual", y_axis_type = "log", y_range = [min(actualAve[actualAve > 0]), max(actualAve)], width = 800, height = 800, tools = TOOLS, ) p1.scatter(targetAve, actualAve, source = source, size = 8) p1.line([1e-15, 10], [1e-15, 10], line_color = "red", line_dash = "dashed") ## bar plot of error # sortedReactions = [constrainedReactions[x] for x in np.argsort(aveError)[::-1]] # aveError[np.log10(aveError) == -np.inf] = 0 # source = ColumnDataSource( # data = dict( # x = sorted(relError, reverse = True), # reactionName = sortedReactions # ) # ) # p2 = Bar(data, values = "x") # hover2 = p2.select(dict(type=HoverTool)) # hover2.tooltips = [("Reaction", "@reactionName")] ## flux for each reaction hover2 = HoverTool( tooltips = [ ("Reaction", "@reactionName"), ] ) TOOLS2 = [hover2, BoxZoomTool(), LassoSelectTool(), PanTool(), WheelZoomTool(), ResizeTool(), UndoTool(), RedoTool(), "reset", ] p2 = figure(x_axis_label = "Time(s)", y_axis_label = "Flux", y_axis_type = "log", y_range = [1e-8, 1], width = 800, height = 800, tools = TOOLS2, ) colors = COLORS_LARGE nTimesteps = len(time[BURN_IN_STEPS:]) x = time[BURN_IN_STEPS:] y = actualFluxes[BURN_IN_STEPS:, 0] reactionName = np.repeat(constrainedReactions[0], nTimesteps) source = ColumnDataSource( data = dict( x = x, y = y, reactionName = reactionName) ) p2.line(x, y, line_color = colors[0], source = source) # Plot remaining metabolites onto initialized figure for m in np.arange(1, actualFluxes.shape[1]): y = actualFluxes[BURN_IN_STEPS:, m] reactionName = np.repeat(constrainedReactions[m], nTimesteps) source = ColumnDataSource( data = dict( x = x, y = y, reactionName = reactionName) ) p2.line(x, y, line_color = colors[m % len(colors)], source = source) if not os.path.exists(os.path.join(plotOutDir, "html_plots")): os.makedirs(os.path.join(plotOutDir, "html_plots")) p = bokeh.io.vplot(p1, p2) bokeh.io.output_file(os.path.join(plotOutDir, "html_plots", plotOutFileName + ".html"), title=plotOutFileName, autosave=False) bokeh.io.save(p) bokeh.io.curstate().reset()
def do_plot(self, seedOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(seedOutDir): raise Exception, "seedOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) # Get all cells ap = AnalysisPaths(seedOutDir, multi_gen_plot=True) allDir = ap.get_cells() enzymeMonomerId = "GLUTCYSLIG-MONOMER[c]" enzymeRnaId = "EG10418_RNA[c]" reactionId = "GLUTCYSLIG-RXN" transcriptionFreq = 1.0 metaboliteId = "GLUTATHIONE[c]" # Get all cells ap = AnalysisPaths(seedOutDir, multi_gen_plot=True) allDir = ap.get_cells() sim_data = cPickle.load(open(simDataFile, "rb")) rnaIds = sim_data.process.transcription.rnaData["id"] isMRna = sim_data.process.transcription.rnaData["isMRna"] mRnaIndexes = np.where(isMRna)[0] mRnaIds = np.array([rnaIds[x] for x in mRnaIndexes]) simOutDir = os.path.join(allDir[0], "simOut") bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) moleculeIds = bulkMolecules.readAttribute("objectNames") enzymeMonomerIndex = moleculeIds.index(enzymeMonomerId) enzymeRnaIndex = moleculeIds.index(enzymeRnaId) metaboliteIndex = moleculeIds.index(metaboliteId) bulkMolecules.close() time = [] enzymeFluxes = [] enzymeMonomerCounts = [] enzymeRnaCounts = [] enzymeRnaInitEvent = [] metaboliteCounts = [] for gen, simDir in enumerate(allDir): simOutDir = os.path.join(simDir, "simOut") time += TableReader(os.path.join( simOutDir, "Main")).readColumn("time").tolist() bulkMolecules = TableReader( os.path.join(simOutDir, "BulkMolecules")) moleculeCounts = bulkMolecules.readColumn("counts") enzymeMonomerCounts += moleculeCounts[:, enzymeMonomerIndex].tolist() enzymeRnaCounts += moleculeCounts[:, enzymeRnaIndex].tolist() metaboliteCounts += moleculeCounts[:, metaboliteIndex].tolist() bulkMolecules.close() fbaResults = TableReader(os.path.join(simOutDir, "FBAResults")) reactionIDs = np.array(fbaResults.readAttribute("reactionIDs")) reactionFluxes = np.array(fbaResults.readColumn("reactionFluxes")) enzymeFluxes += reactionFluxes[:, np.where(reactionIDs == reactionId )[0][0]].tolist() fbaResults.close() rnapDataReader = TableReader(os.path.join(simOutDir, "RnapData")) enzymeRnaInitEvent += rnapDataReader.readColumn( "rnaInitEvent")[:, np.where( mRnaIds == enzymeRnaId)[0][0]].tolist() rnapDataReader.close() time = np.array(time) # Plot fig = plt.figure(figsize=(10, 10)) rnaInitAxis = plt.subplot(5, 1, 1) rnaAxis = plt.subplot(5, 1, 2, sharex=rnaInitAxis) monomerAxis = plt.subplot(5, 1, 3, sharex=rnaInitAxis) fluxAxis = plt.subplot(5, 1, 4, sharex=rnaInitAxis) metAxis = plt.subplot(5, 1, 5, sharex=rnaInitAxis) rnaInitAxis.plot(time / 3600., enzymeRnaInitEvent) rnaInitAxis.set_title("%s transcription initiation events" % enzymeRnaId, fontsize=10) rnaInitAxis.set_ylim([0, rnaInitAxis.get_ylim()[1] * 1.1]) rnaInitAxis.set_xlim([0, time[-1] / 3600.]) rnaAxis.plot(time / 3600., enzymeRnaCounts) rnaAxis.set_title("%s counts" % enzymeRnaId, fontsize=10) monomerAxis.plot(time / 3600., enzymeMonomerCounts) monomerAxis.set_title("%s counts" % enzymeMonomerId, fontsize=10) fluxAxis.plot(time / 3600., enzymeFluxes) fluxAxis.set_title( "%s flux (%s / %s / %s)" % (reactionId, COUNTS_UNITS, VOLUME_UNITS, TIME_UNITS), fontsize=10) metAxis.plot(time / 3600., metaboliteCounts) metAxis.set_title("%s counts" % metaboliteId, fontsize=10) metAxis.set_xlabel( "Time (hour)\n(%s frequency of at least 1 transcription per generation)" % transcriptionFreq, fontsize=10) plt.subplots_adjust( wspace=0.4, hspace=0.4 ) #, right = 0.83, bottom = 0.05, left = 0.07, top = 0.95) exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, seedOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(seedOutDir): raise Exception, "seedOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) # Get all cells ap = AnalysisPaths(seedOutDir, multi_gen_plot=True) allDir = ap.get_cells() validation_data = cPickle.load(open(validationDataFile, "rb")) essentialRnas = validation_data.essentialGenes.essentialRnas # Get mRNA data sim_data = cPickle.load(open(simDataFile, "rb")) rnaIds = sim_data.process.transcription.rnaData["id"] isMRna = sim_data.process.transcription.rnaData["isMRna"] synthProb = sim_data.process.transcription.rnaSynthProb["basal"] mRnaIndexes = np.where(isMRna)[0] mRnaSynthProb = np.array([synthProb[x] for x in mRnaIndexes]) mRnaIds = np.array([rnaIds[x] for x in mRnaIndexes]) if not USE_CACHE: # Get whether or not mRNAs were transcribed time = [] transcribedBool = [] simulatedSynthProbs = [] transcriptionEvents = [] for gen, simDir in enumerate(allDir): simOutDir = os.path.join(simDir, "simOut") time += TableReader(os.path.join( simOutDir, "Main")).readColumn("time").tolist() rnaSynthProb = TableReader( os.path.join(simOutDir, "RnaSynthProb")) simulatedSynthProb = np.mean( rnaSynthProb.readColumn("rnaSynthProb")[:, mRnaIndexes], axis=0) rnaSynthProb.close() simulatedSynthProbs.append(simulatedSynthProb) bulkMolecules = TableReader( os.path.join(simOutDir, "BulkMolecules")) moleculeIds = bulkMolecules.readAttribute("objectNames") mRnaIndexes_bulk = np.array( [moleculeIds.index(x) for x in mRnaIds]) moleculeCounts = bulkMolecules.readColumn( "counts")[:, mRnaIndexes_bulk] bulkMolecules.close() moleculeCountsSumOverTime = moleculeCounts.sum(axis=0) mRnasTranscribed = np.array( [x != 0 for x in moleculeCountsSumOverTime]) transcribedBool.append(mRnasTranscribed) rnapDataReader = TableReader( os.path.join(simOutDir, "RnapData")) rnaInitEvent = rnapDataReader.readColumn( "rnaInitEvent")[:, mRnaIndexes] rnapDataReader.close() if gen == 0: transcriptionEvents = (rnaInitEvent != 0) else: transcriptionEvents = np.vstack( (transcriptionEvents, (rnaInitEvent != 0))) time = np.array(time) transcribedBool = np.array(transcribedBool) simulatedSynthProbs = np.array(simulatedSynthProbs) indexingOrder = np.argsort(np.mean(simulatedSynthProbs, axis=0)) transcribedBoolOrdered = np.mean(transcribedBool, axis=0)[indexingOrder] simulatedSynthProbsOrdered = np.mean(simulatedSynthProbs, axis=0)[indexingOrder] transcriptionEventsOrdered = transcriptionEvents[:, indexingOrder] mRnaIdsOrdered = mRnaIds[indexingOrder] alwaysPresentIndexes = np.where(transcribedBoolOrdered == 1.)[0] neverPresentIndexes = np.where(transcribedBoolOrdered == 0.)[0] sometimesPresentIndexes = np.array([ x for x in np.arange(len(transcribedBoolOrdered)) if x not in alwaysPresentIndexes and x not in neverPresentIndexes ]) colors = np.repeat("g", len(transcribedBoolOrdered)) colors[alwaysPresentIndexes] = "b" colors[neverPresentIndexes] = "r" # Assemble data alwaysTranscriptionEvents_E = [] alwaysTranscriptionEvents_N = [] alwaysId_E = [] alwaysId_N = [] for i in alwaysPresentIndexes: v = (time[transcriptionEventsOrdered[:, i]] / 3600.).tolist() if transcriptionEventsOrdered[:, i].sum() == 0: v = [-1] if mRnaIdsOrdered[i] in essentialRnas: alwaysTranscriptionEvents_E.append(v) else: alwaysTranscriptionEvents_N.append(v) neverTranscriptionEvents_E = [] neverTranscriptionEvents_N = [] for i in neverPresentIndexes: v = (time[transcriptionEventsOrdered[:, i]] / 3600.).tolist() if transcriptionEventsOrdered[:, i].sum() == 0: v = [-1] if mRnaIdsOrdered[i] in essentialRnas: neverTranscriptionEvents_E.append(v) else: neverTranscriptionEvents_N.append(v) sometimesTranscriptionEvents_E = [] sometimesTranscriptionEvents_N = [] for i in sometimesPresentIndexes: v = (time[transcriptionEventsOrdered[:, i]] / 3600.).tolist() if transcriptionEventsOrdered[:, i].sum() == 0: v = [-1] if mRnaIdsOrdered[i] in essentialRnas: sometimesTranscriptionEvents_E.append(v) else: sometimesTranscriptionEvents_N.append(v) cPickle.dump( { "time": time, "always_E": alwaysTranscriptionEvents_E, "always_N": alwaysTranscriptionEvents_N, "never_E": neverTranscriptionEvents_E, "never_N": neverTranscriptionEvents_N, "sometimes_E": sometimesTranscriptionEvents_E, "sometimes_N": sometimesTranscriptionEvents_N, "transcriptionFrequency": transcribedBoolOrdered, "colors": colors, "id": mRnaIdsOrdered, }, open(os.path.join(plotOutDir, "transcriptionEvents.pickle"), "wb")) if USE_CACHE: D = cPickle.load( open(os.path.join(plotOutDir, "transcriptionEvents.pickle"), "r")) time = D["time"] alwaysTranscriptionEvents_E = D["always_E"] alwaysTranscriptionEvents_N = D["always_N"] neverTranscriptionEvents_E = D["never_E"] neverTranscriptionEvents_N = D["never_N"] sometimesTranscriptionEvents_E = D["sometimes_E"] sometimesTranscriptionEvents_N = D["sometimes_N"] transcribedBoolOrdered = D["transcriptionFrequency"] colors = D["colors"] mRnaIdsOrdered = D["id"] # Plot blue = [0, 0, 1] green = [0, 0.5, 0] red = [1, 0, 0] gray = [0, 0, 0] fig = plt.figure(figsize=(8, 10)) scatterAxis = plt.subplot2grid((5, 4), (0, 0), colspan=3, rowspan=2) histAxis = plt.subplot2grid((5, 4), (0, 3), colspan=1, rowspan=2, sharey=scatterAxis) alwaysAxis = plt.subplot2grid((5, 4), (2, 0), colspan=4, rowspan=1) sometimesAxis = plt.subplot2grid((5, 4), (3, 0), colspan=4, rowspan=1, sharex=alwaysAxis) neverAxis = plt.subplot2grid((5, 4), (4, 0), colspan=4, rowspan=1, sharex=alwaysAxis) scatterAxis.scatter(np.arange(len(transcribedBoolOrdered)), transcribedBoolOrdered, marker='o', facecolors=colors, edgecolors="none", s=5) scatterAxis.set_title( "Frequency of observing at least 1 transcript per generation\n(Genes ordered by simulated synthesis probability)", fontsize=10) scatterAxis.set_xlim([-1, len(transcribedBoolOrdered)]) scatterAxis.set_ylim([-0.1, 1.1]) scatterAxis.tick_params(top="off") scatterAxis.tick_params(right="off") scatterAxis.tick_params(which='both', direction='out', labelsize=8) histAxis.hist(transcribedBoolOrdered, bins=len(allDir) + 1, orientation='horizontal', color="k", alpha=0.5) histAxis.set_xscale("log") histAxis.spines["right"].set_visible(False) histAxis.tick_params(right="off") histAxis.tick_params(which='both', direction='out', labelsize=8) histAxis.text( histAxis.get_xlim()[1] * 1.5, 0, "%s genes\n(%0.1f%%)" % (len(neverTranscriptionEvents_N) + len(neverTranscriptionEvents_E), 100. * (len(neverTranscriptionEvents_N) + len(neverTranscriptionEvents_E)) / float(len(transcribedBoolOrdered))), fontsize=10, verticalalignment="top") histAxis.text(histAxis.get_xlim()[1] * 1.5, 1, "%s genes\n(%0.1f%%)" % (len(alwaysTranscriptionEvents_N) + len(alwaysTranscriptionEvents_E), 100. * (len(alwaysTranscriptionEvents_N) + len(alwaysTranscriptionEvents_E)) / float(len(transcribedBoolOrdered))), fontsize=10, verticalalignment="bottom") histAxis.text(histAxis.get_xlim()[1] * 1.5, 0.5, "%s genes\n(%0.1f%%)" % (len(sometimesTranscriptionEvents_N) + len(sometimesTranscriptionEvents_E), 100. * (len(sometimesTranscriptionEvents_N) + len(sometimesTranscriptionEvents_E)) / float(len(transcribedBoolOrdered))), fontsize=10, verticalalignment="center") histAxis.add_patch( patches.Rectangle( (histAxis.get_xlim()[1] * 0.7, 1. / (len(allDir) + 1)), 1e4, 1. - 2. / (len(allDir) + 1), facecolor=green, edgecolor="none")) alwaysAxis.eventplot(alwaysTranscriptionEvents_N + alwaysTranscriptionEvents_E, orientation="horizontal", linewidths=2., linelengths=1., colors=[blue] * len(alwaysTranscriptionEvents_N) + [gray] * len(alwaysTranscriptionEvents_E)) alwaysAxis.set_ylabel("Always present", fontsize=10) alwaysAxis.set_title("Transcription initiation events", fontsize=10) alwaysAxis.set_yticks([]) alwaysAxis.tick_params(top="off") alwaysAxis.tick_params(which='both', direction='out', labelsize=8) alwaysAxis.set_xlim([0, time[-1] / 3600.]) alwaysAxis.set_ylim([ -1, np.max([ N_GENES_TO_PLOT, len(alwaysTranscriptionEvents_E) + len(alwaysTranscriptionEvents_N) ]) ]) alwaysAxis.text(alwaysAxis.get_xlim()[1] * 1.02, len(alwaysTranscriptionEvents_N) * 0.5, "%s\nnon-essential\ngenes" % len(alwaysTranscriptionEvents_N), fontsize=10, verticalalignment="center") alwaysAxis.text(alwaysAxis.get_xlim()[1] * 1.02, len(alwaysTranscriptionEvents_N) + len(alwaysTranscriptionEvents_E) * 0.5, "%s essential\ngenes" % len(alwaysTranscriptionEvents_E), fontsize=10, verticalalignment="center") sometimesAxis.eventplot( sometimesTranscriptionEvents_N + sometimesTranscriptionEvents_E, orientation="horizontal", linewidths=2., linelengths=1., colors=[green] * len(sometimesTranscriptionEvents_N) + [gray] * len(sometimesTranscriptionEvents_E)) sometimesAxis.set_ylabel("Sub-generational", fontsize=10) sometimesAxis.set_yticks([]) sometimesAxis.tick_params(top="off") sometimesAxis.set_ylim([ -1, np.max([ N_GENES_TO_PLOT, len(sometimesTranscriptionEvents_E) + len(sometimesTranscriptionEvents_N) ]) ]) sometimesAxis.tick_params(which='both', direction='out', labelsize=8) sometimesAxis.text(sometimesAxis.get_xlim()[1] * 1.02, len(sometimesTranscriptionEvents_N) * 0.5, "%s\nnon-essential\ngenes" % len(alwaysTranscriptionEvents_N), fontsize=10, verticalalignment="center") sometimesAxis.text(sometimesAxis.get_xlim()[1] * 1.02, len(sometimesTranscriptionEvents_N) + len(sometimesTranscriptionEvents_E) * 0.5, "%s essential\ngenes" % len(sometimesTranscriptionEvents_E), fontsize=10, verticalalignment="center") neverAxis.eventplot(neverTranscriptionEvents_N + neverTranscriptionEvents_E, orientation="horizontal", linewidths=2., linelengths=1., colors=[red] * len(neverTranscriptionEvents_N) + [gray] * len(neverTranscriptionEvents_E)) neverAxis.set_ylabel("Never present", fontsize=10) neverAxis.set_xlabel("Time (hour)", fontsize=10) neverAxis.set_yticks([]) neverAxis.tick_params(top="off") neverAxis.set_ylim([ -1, np.max([ N_GENES_TO_PLOT, len(neverTranscriptionEvents_E) + len(neverTranscriptionEvents_N) ]) ]) neverAxis.tick_params(which='both', direction='out', labelsize=8) neverAxis.text(neverAxis.get_xlim()[1] * 1.02, len(neverTranscriptionEvents_N) * 0.5, "%s\nnon-essential\ngenes" % len(neverTranscriptionEvents_N), fontsize=10, verticalalignment="center") neverAxis.text(neverAxis.get_xlim()[1] * 1.02, len(neverTranscriptionEvents_N) + len(neverTranscriptionEvents_E) * 0.5, "%s essential\ngenes" % len(neverTranscriptionEvents_E), fontsize=10, verticalalignment="center") plt.subplots_adjust(wspace=0.4, hspace=0.4, right=0.83, bottom=0.05, left=0.07, top=0.95) exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, seedOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(seedOutDir): raise Exception, "seedOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) # Get all cells ap = AnalysisPaths(seedOutDir, multi_gen_plot=True) allDir = ap.get_cells() sim_data = cPickle.load(open(simDataFile, "rb")) metaboliteNames = np.array( sorted(sim_data.process.metabolism.concDict.keys())) nMetabolites = len(metaboliteNames) fig, axesList = plt.subplots(3) fig.set_size_inches(11, 11) histo = np.zeros(4) limitedCounts = np.zeros(len(metaboliteNames)) ax2 = axesList[2] for simDir in allDir: simOutDir = os.path.join(simDir, "simOut") enzymeKineticsData = TableReader( os.path.join(simOutDir, "EnzymeKinetics")) metaboliteCounts = enzymeKineticsData.readColumn( "metaboliteCountsFinal") normalizedCounts = metaboliteCounts / metaboliteCounts[1, :] enzymeKineticsData.close() # Read time info from the listener initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join(simOutDir, "Main")).readColumn("time") metaboliteLimited = np.zeros((len(time), nMetabolites)) diff = np.diff(normalizedCounts, axis=0) limited = [] for i in xrange(diff.shape[0] - WINDOW): currentStepLimited = np.where( np.any(diff[i:i + WINDOW] > 0, axis=0) == False)[0].astype(int) metaboliteLimited[i, currentStepLimited] = 1 limited = np.append(limited, currentStepLimited).astype(int) nLimited = len(np.unique(limited)) if nLimited >= len(histo): histo = np.append(histo, np.zeros(nLimited - len(histo) + 1)) histo[nLimited] += 1 limitedCounts[limited] += 1 ax2.plot(time / 60, metaboliteLimited * range(metaboliteLimited.shape[1])) ax2.axvline(initialTime / 60, color="r", linestyle="--") ax2.set_xlim([0, max(time) / 60]) ax2.set_xlabel("Time (min)") ax2.set_ylabel("Limited") ax0 = axesList[0] labels = np.arange(len(histo)) ax0.bar(labels - 0.5, histo, 1) ax0.set_xticks(labels) ax0.set_xlabel("Number of limited metabolites") ax0.set_ylabel("Number of generations") ax1 = axesList[1] ax1.bar( np.arange(len(np.where(limitedCounts > 0)[0])) - 0.4, limitedCounts[limitedCounts > 0]) ax1.set_xticks(np.arange(len(np.where(limitedCounts > 0)[0]))) ax1.set_xticklabels(metaboliteNames[limitedCounts > 0], fontsize=6) ax1.set_xlabel("Metabolite Limited") ax1.set_ylabel("Number of genreations") exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, seedOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(seedOutDir): raise Exception, "seedOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) # Get all cells ap = AnalysisPaths(seedOutDir, multi_gen_plot=True) allDir = ap.get_cells() # allDir = ap.get_cells(generation = [0, 1, 2]) sim_data = cPickle.load(open(simDataFile, "rb")) metaboliteNames = np.array( sorted(sim_data.process.metabolism.concDict.keys())) nMetabolites = len(metaboliteNames) validation_data = cPickle.load(open(validationDataFile, "rb")) toyaReactions = validation_data.reactionFlux.toya2010fluxes[ "reactionID"] toyaFluxes = validation_data.reactionFlux.toya2010fluxes[ "reactionFlux"] toyaStdev = validation_data.reactionFlux.toya2010fluxes[ "reactionFluxStdev"] toyaFluxesDict = dict(zip(toyaReactions, toyaFluxes)) toyaStdevDict = dict(zip(toyaReactions, toyaStdev)) sim_data = cPickle.load(open(simDataFile)) cellDensity = sim_data.constants.cellDensity modelFluxes = {} toyaOrder = [] for rxn in toyaReactions: modelFluxes[rxn] = [] toyaOrder.append(rxn) for simDir in allDir: simOutDir = os.path.join(simDir, "simOut") mainListener = TableReader(os.path.join(simOutDir, "Main")) timeStepSec = mainListener.readColumn("timeStepSec") mainListener.close() massListener = TableReader(os.path.join(simOutDir, "Mass")) cellMass = massListener.readColumn("cellMass") dryMass = massListener.readColumn("dryMass") massListener.close() coefficient = dryMass / cellMass * sim_data.constants.cellDensity.asNumber( MASS_UNITS / VOLUME_UNITS) fbaResults = TableReader(os.path.join(simOutDir, "FBAResults")) reactionIDs = np.array(fbaResults.readAttribute("reactionIDs")) reactionFluxes = (COUNTS_UNITS / MASS_UNITS / TIME_UNITS) * ( fbaResults.readColumn("reactionFluxes").T / coefficient).T fbaResults.close() for toyaReaction in toyaReactions: fluxTimeCourse = [] for rxn in reactionIDs: if re.findall(toyaReaction, rxn): reverse = 1 if re.findall("(reverse)", rxn): reverse = -1 if len(fluxTimeCourse): fluxTimeCourse += reverse * reactionFluxes[:, np. where( reactionIDs == rxn )] else: fluxTimeCourse = reverse * reactionFluxes[:, np.where( reactionIDs == rxn)] if len(fluxTimeCourse): modelFluxes[toyaReaction].append( np.mean(fluxTimeCourse).asNumber(units.mmol / units.g / units.h)) toyaVsReactionAve = [] for rxn, toyaFlux in toyaFluxesDict.iteritems(): if rxn in modelFluxes: toyaVsReactionAve.append( (np.mean(modelFluxes[rxn]), toyaFlux.asNumber(units.mmol / units.g / units.h), np.std(modelFluxes[rxn]), toyaStdevDict[rxn].asNumber( units.mmol / units.g / units.h))) toyaVsReactionAve = np.array(toyaVsReactionAve) correlationCoefficient = np.corrcoef(toyaVsReactionAve[:, 0], toyaVsReactionAve[:, 1])[0, 1] plt.figure(figsize=(8, 8)) plt.title("Central Carbon Metabolism Flux, Pearson R = {:.2}".format( correlationCoefficient)) plt.errorbar(toyaVsReactionAve[:, 1], toyaVsReactionAve[:, 0], xerr=toyaVsReactionAve[:, 3], yerr=toyaVsReactionAve[:, 2], fmt="o", ecolor="k") ylim = plt.ylim() plt.plot([ylim[0], ylim[1]], [ylim[0], ylim[1]], color="k") plt.xlabel("Toya 2010 Reaction Flux [mmol/g/hr]") plt.ylabel("Mean WCM Reaction Flux [mmol/g/hr]") ax = plt.axes() ax.set_ylim(plt.xlim()) whitePadSparklineAxis(plt.axes()) exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(simOutDir): raise Exception, "simOutDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) # Load data from KB sim_data = cPickle.load(open(simDataFile, "rb")) nAvogadro = sim_data.constants.nAvogadro cellDensity = sim_data.constants.cellDensity # Load time initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join( simOutDir, "Main")).readColumn("time") - initialTime # Load mass data # Total cell mass is needed to compute concentrations (since we have cell density) # Protein mass is needed to compute the mass fraction of the proteome that is trpA massReader = TableReader(os.path.join(simOutDir, "Mass")) cellMass = units.fg * massReader.readColumn("cellMass") proteinMass = units.fg * massReader.readColumn("proteinMass") massReader.close() # Load data from bulk molecules bulkMoleculesReader = TableReader( os.path.join(simOutDir, "BulkMolecules")) bulkMoleculeIds = bulkMoleculesReader.readAttribute("objectNames") bulkMoleculeCounts = bulkMoleculesReader.readColumn("counts") # Get the concentration of intracellular trp trpId = ["TRP[c]"] trpIndex = np.array([bulkMoleculeIds.index(x) for x in trpId]) trpCounts = bulkMoleculeCounts[:, trpIndex].reshape(-1) trpMols = 1. / nAvogadro * trpCounts volume = cellMass / cellDensity trpConcentration = trpMols * 1. / volume # Get the amount of active trpR (that isn't promoter bound) trpRActiveId = ["CPLX-125[c]"] trpRActiveIndex = np.array( [bulkMoleculeIds.index(x) for x in trpRActiveId]) trpRActiveCounts = bulkMoleculeCounts[:, trpRActiveIndex].reshape(-1) # Get the amount of inactive trpR trpRInactiveId = ["PC00007[c]"] trpRInactiveIndex = np.array( [bulkMoleculeIds.index(x) for x in trpRInactiveId]) trpRInactiveCounts = bulkMoleculeCounts[:, trpRInactiveIndex].reshape(-1) # Get the amount of monomeric trpR trpRMonomerId = ["PD00423[c]"] trpRMonomerIndex = np.array( [bulkMoleculeIds.index(x) for x in trpRMonomerId]) trpRMonomerCounts = bulkMoleculeCounts[:, trpRMonomerIndex].reshape(-1) # Get the promoter-bound status for all regulated genes tfBoundIds = [ target + "__CPLX-125" for target in sim_data.tfToFC["CPLX-125"].keys() ] tfBoundIndex = np.array([bulkMoleculeIds.index(x) for x in tfBoundIds]) tfBoundCounts = bulkMoleculeCounts[:, tfBoundIndex] # Get the amount of monomeric trpA trpAProteinId = ["TRYPSYN-APROTEIN[c]"] trpAProteinIndex = np.array( [bulkMoleculeIds.index(x) for x in trpAProteinId]) trpAProteinCounts = bulkMoleculeCounts[:, trpAProteinIndex].reshape(-1) # Get the amount of complexed trpA trpABComplexId = ["TRYPSYN[c]"] trpABComplexIndex = np.array( [bulkMoleculeIds.index(x) for x in trpABComplexId]) trpABComplexCounts = bulkMoleculeCounts[:, trpABComplexIndex].reshape(-1) bulkMoleculesReader.close() # Compute total counts of trpA in monomeric and complexed form # (we know the stoichiometry) trpAProteinTotalCounts = trpAProteinCounts + 2 * trpABComplexCounts # Compute the trpA mass in the cell trpAMw = sim_data.getter.getMass(trpAProteinId) trpAMass = 1. / nAvogadro * trpAProteinTotalCounts * trpAMw # Compute the proteome mass fraction proteomeMassFraction = trpAMass.asNumber( units.fg) / proteinMass.asNumber(units.fg) # Get the synthesis probability for all regulated genes rnaSynthProbReader = TableReader( os.path.join(simOutDir, "RnaSynthProb")) rnaIds = rnaSynthProbReader.readAttribute("rnaIds") synthProbIds = [ target + "[c]" for target in sim_data.tfToFC["CPLX-125"].keys() ] synthProbIndex = np.array([rnaIds.index(x) for x in synthProbIds]) synthProbs = rnaSynthProbReader.readColumn( "rnaSynthProb")[:, synthProbIndex] recruitmentColNames = sim_data.process.transcription_regulation.recruitmentColNames tfs = sorted( set([ x.split("__")[-1] for x in recruitmentColNames if x.split("__")[-1] != "alpha" ])) trpRIndex = [i for i, tf in enumerate(tfs) if tf == "CPLX-125"][0] trpRBound = rnaSynthProbReader.readColumn("nActualBound")[:, trpRIndex] rnaSynthProbReader.close() # Calculate total trpR - active, inactive, bound and monomeric trpRTotalCounts = 2 * (trpRActiveCounts + trpRInactiveCounts + trpRBound) + trpRMonomerCounts # Compute moving averages width = 100 tfBoundCountsMA = np.array([ np.convolve(tfBoundCounts[:, i], np.ones(width) / width, mode="same") for i in range(tfBoundCounts.shape[1]) ]).T synthProbsMA = np.array([ np.convolve(synthProbs[:, i], np.ones(width) / width, mode="same") for i in range(synthProbs.shape[1]) ]).T plt.figure(figsize=(8.5, 11)) ############################################################## ax = plt.subplot(6, 1, 1) ax.plot(time, trpConcentration.asNumber(units.umol / units.L)) plt.ylabel("Internal TRP Conc. [uM]", fontsize=6) ymin = np.amin(trpConcentration.asNumber(units.umol / units.L) * 0.9) ymax = np.amax(trpConcentration.asNumber(units.umol / units.L) * 1.1) if ymin != ymax: ax.set_ylim([ymin, ymax]) ax.set_yticks([ymin, ymax]) ax.set_yticklabels(["%0.0f" % ymin, "%0.0f" % ymax]) ax.spines['top'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.xaxis.set_ticks_position('none') ax.tick_params(which='both', direction='out', labelsize=6) ax.set_xticks([]) ############################################################## ############################################################## ax = plt.subplot(6, 1, 2) ax.plot(time, trpRActiveCounts) ax.plot(time, trpRInactiveCounts) ax.plot(time, trpRTotalCounts) plt.ylabel("TrpR Counts", fontsize=6) plt.legend(["Active (dimer)", "Inactive (dimer)", "Total (monomeric)"], fontsize=6) ymin = min(np.amin(trpRActiveCounts * 0.9), np.amin(trpRInactiveCounts * 0.9)) ymax = np.amax(trpRTotalCounts * 1.1) if ymin != ymax: ax.set_ylim([ymin, ymax]) ax.set_yticks([ymin, ymax]) ax.set_yticklabels(["%0.0f" % ymin, "%0.0f" % ymax]) ax.spines['top'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.xaxis.set_ticks_position('none') ax.tick_params(which='both', direction='out', labelsize=6) ax.set_xticks([]) ############################################################## ############################################################## ax = plt.subplot(6, 1, 3) ax.plot(time, tfBoundCountsMA) plt.ylabel("TrpR Bound To Promoters\n(Moving Average)", fontsize=6) ymin = np.amin(tfBoundCountsMA * 1.) ymax = np.amax(tfBoundCountsMA * 1.) if ymin != ymax: ax.set_ylim([ymin, ymax]) ax.set_yticks([ymin, ymax]) ax.set_yticklabels(["%0.0f" % ymin, "%0.0f" % ymax]) ax.spines['top'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.xaxis.set_ticks_position('none') ax.tick_params(which='both', direction='out', labelsize=6) ax.set_xticks([]) ############################################################## ############################################################## ax = plt.subplot(6, 1, 4) ax.plot(time, synthProbsMA) plt.ylabel("Regulated Gene Synthesis Prob.\n(Moving Average)", fontsize=6) ymin = np.amin(synthProbsMA[1:] * 0.9) ymax = np.amax(synthProbsMA[1:] * 1.1) if ymin != ymax: ax.set_ylim([ymin, ymax]) ax.set_yticks([ymin, ymax]) ax.set_yticklabels(["%0.2e" % ymin, "%0.2e" % ymax]) ax.spines['top'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.xaxis.set_ticks_position('none') ax.tick_params(which='both', direction='out', labelsize=6) ax.set_xticks([]) ############################################################## ############################################################## ax = plt.subplot(6, 1, 5) ax.plot(time, trpAProteinTotalCounts) plt.ylabel("TrpA Counts", fontsize=6) ymin = np.amin(trpAProteinTotalCounts * 0.9) ymax = np.amax(trpAProteinTotalCounts * 1.1) if ymin != ymax: ax.set_ylim([ymin, ymax]) ax.set_yticks([ymin, ymax]) ax.set_yticklabels(["%0.0f" % ymin, "%0.0f" % ymax]) ax.spines['top'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.xaxis.set_ticks_position('none') ax.tick_params(which='both', direction='out', labelsize=6) ax.set_xticks([]) ############################################################## ############################################################## ax = plt.subplot(6, 1, 6) ax.plot(time, proteomeMassFraction) plt.ylabel("TrpA Mass Fraction of Proteome", fontsize=6) ymin = np.amin(proteomeMassFraction * 0.9) ymax = np.amax(proteomeMassFraction * 1.1) if ymin != ymax: ax.set_ylim([ymin, ymax]) ax.set_yticks([ymin, ymax]) ax.set_yticklabels(["%0.2e" % ymin, "%0.2e" % ymax]) ax.spines['top'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.xaxis.set_ticks_position('none') ax.tick_params(which='both', direction='out', labelsize=6) ax.set_xticks([]) ############################################################## exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")