def do_plot(self, variantDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(variantDir): raise Exception, "variantDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) # Get all cells in each seed ap = AnalysisPaths(variantDir, cohort_plot=True) max_cells_in_gen = 0 for genIdx in range(ap.n_generation): n_cells = len(ap.get_cells(generation=[genIdx])) if n_cells > max_cells_in_gen: max_cells_in_gen = n_cells fig, axesList = plt.subplots(ap.n_generation, sharex=True) doubling_time = np.zeros((max_cells_in_gen, ap.n_generation)) for genIdx in range(ap.n_generation): gen_cells = ap.get_cells(generation=[genIdx]) for simDir in gen_cells: simOutDir = os.path.join(simDir, "simOut") time = TableReader(os.path.join(simOutDir, "Main")).readColumn("time") initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") doubling_time[np.where(simDir == gen_cells)[0], genIdx] = (time.max() - initialTime) / 60. # Plot initial vs final masses if ap.n_generation == 1: axesList = [axesList] for idx, axes in enumerate(axesList): if max_cells_in_gen > 1: axes.hist(doubling_time[:, idx].flatten(), int(np.ceil(np.sqrt(doubling_time[:, idx].size)))) else: axes.plot(doubling_time[:, idx], 1, 'x') axes.set_ylim([0, 2]) axes.axvline(doubling_time[:, idx].mean(), color='k', linestyle='dashed', linewidth=2) axes.text( doubling_time[:, idx].mean(), 1, "Mean: %.3f Var: %.3f" % (doubling_time[:, idx].mean(), doubling_time[:, idx].var())) axesList[-1].set_xlabel("Doubling time (min))") axesList[ap.n_generation / 2].set_ylabel("Frequency") plt.subplots_adjust(hspace=0.2, wspace=0.5) exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def getDivisionTime((variant, ap)): try: simDir = ap.get_cells(variant=[variant])[0] simOutDir = os.path.join(simDir, "simOut") time_column = TableReader(os.path.join(simOutDir, "Main")).readColumn("time") initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") return (time_column.max() - initialTime) / 60. except Exception as e: print e return np.nan
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) ap = AnalysisPaths(seedOutDir, multi_gen_plot=True) # TODO: Declutter Y-axis # Get all cells allDir = ap.get_cells().tolist() massNames = [ "dryMass", ] cleanNames = [ "Dry\nmass", ] for simDir in allDir: simOutDir = os.path.join(simDir, "simOut") initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join( simOutDir, "Main")).readColumn("time") - initialTime mass = TableReader(os.path.join(simOutDir, "Mass")) for idx, massType in enumerate(massNames): massToPlot = mass.readColumn(massNames[idx]) f = plt.figure(figsize=(1.25, 0.8), frameon=False) ax = f.add_axes([0, 0, 1, 1]) ax.axis("off") ax.plot(time, massToPlot, linewidth=2) ax.set_ylim([massToPlot.min(), massToPlot.max()]) ax.set_xlim([time.min(), time.max()]) exportFigure( plt, plotOutDir, "r01_{}_gen{}".format(massType, allDir.index(simDir))) 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 KB sim_data = cPickle.load(open(simDataFile, "rb")) oriC = sim_data.constants.oriCCenter.asNumber() terC = sim_data.constants.terCCenter.asNumber() genomeLength = len(sim_data.process.replication.genome_sequence) # Load time initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join( simOutDir, "Main")).readColumn("time") - initialTime # Load replication data dnaPolyFile = TableReader(os.path.join(simOutDir, "ReplicationData")) sequenceIdx = dnaPolyFile.readColumn("sequenceIdx") sequenceLength = dnaPolyFile.readColumn("sequenceLength") numberOfOric = dnaPolyFile.readColumn("numberOfOric") criticalMassPerOriC = dnaPolyFile.readColumn("criticalMassPerOriC") criticalInitiationMass = dnaPolyFile.readColumn( "criticalInitiationMass") dnaPolyFile.close() # Load dna mass data massFile = TableReader(os.path.join(simOutDir, "Mass")) totalMass = massFile.readColumn("cellMass") dnaMass = massFile.readColumn("dnaMass") massFile.close() # Setup elongation length data reverseIdx = 1 reverseCompIdx = 3 reverseSequences = np.logical_or(sequenceIdx == reverseIdx, sequenceIdx == reverseCompIdx) sequenceLength[ reverseSequences] = -1 * sequenceLength[reverseSequences] sequenceLength[sequenceLength == PLACE_HOLDER] = np.nan # Count pairs of forks, initation, and termination events pairsOfForks = (sequenceIdx != PLACE_HOLDER).sum(axis=1) / 4 # Count chromosome equivalents chromMass = (sim_data.getter.getMass(['CHROM_FULL[c]'])[0] / sim_data.constants.nAvogadro).asNumber(units.fg) chromEquivalents = dnaMass / chromMass # Count full chromosomes bulkMoleculesFile = TableReader( os.path.join(simOutDir, "BulkMolecules")) bulkIds = bulkMoleculesFile.readAttribute("objectNames") chromIdx = bulkIds.index("CHROM_FULL[c]") fullChromosomeCounts = bulkMoleculesFile.readColumn("counts")[:, chromIdx] # Count critical initiation mass equivalents # criticalInitiationMass[0] = criticalInitiationMass[1] criticalMassEquivalents = totalMass / criticalInitiationMass # Plot stuff plt.figure(figsize=(8.5, 11)) ax = plt.subplot(7, 1, 1) ax.plot(time / 60., sequenceLength, marker='.', markersize=1, linewidth=0) ax.set_xticks([0, time.max() / 60]) ax.set_yticks([-1 * genomeLength / 2, 0, genomeLength / 2]) ax.set_yticklabels(['-terC', 'oriC', '+terC']) ax.set_ylabel("DNA polymerase\nposition (nt)") ax = plt.subplot(7, 1, 2, sharex=ax) ax.plot(time / 60., chromEquivalents, linewidth=2) ax.set_xticks([0, time.max() / 60]) ax.set_yticks( np.arange(chromEquivalents.min(), chromEquivalents.max() + 0.5, 0.5)) ax.set_ylabel("Chromosome\nequivalents") ax = plt.subplot(7, 1, 3, sharex=ax) ax.plot(time / 60., pairsOfForks, linewidth=2) ax.set_xticks([0, time.max() / 60]) ax.set_yticks(np.arange(0, 7)) ax.set_ylim([0, 6]) ax.set_ylabel("Pairs of forks") ax = plt.subplot(7, 1, 4, sharex=ax) ax.plot(time / 60., criticalMassEquivalents, linewidth=2) ax.set_xticks([0, time.max() / 60]) ax.set_yticks(np.arange(1., 8., 0.5)) ax.set_ylim([ np.around(criticalMassEquivalents[1:].min(), decimals=1) - 0.1, np.around(criticalMassEquivalents[1:].max(), decimals=1) + 0.1 ]) ax.set_ylabel("Factors of critical\ninitiation mass") ax = plt.subplot(7, 1, 5, sharex=ax) ax.plot(time / 60., criticalMassPerOriC, linewidth=2) ax.set_xticks([0, time.max() / 60]) ax.set_yticks([0.5, 1.0]) # ax.set_ylim([0.4, 1.1]) ax.set_ylabel("Critical mass\nper oriC") ax = plt.subplot(7, 1, 6, sharex=ax) ax.plot(time / 60., numberOfOric, linewidth=2) ax.set_xticks([0, time.max() / 60]) ax.set_ylabel("Number of\noriC") ax.set_ylim([0, numberOfOric.max() + 1]) ax = plt.subplot(7, 1, 7, sharex=ax) ax.plot(time / 60., fullChromosomeCounts, linewidth=2) ax.set_xticks([0, time.max() / 60]) ax.set_ylabel("Full\nchromosomes") ax.set_ylim([0, fullChromosomeCounts.max() + 1]) ax.set_xlim([0, time.max() / 60]) ax.set_xlabel("Time (min)") exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all") plt.figure(figsize=(8.5, 11)) for idx in [0, 1, 2, 3]: ax = plt.subplot(4, 1, idx + 1) data = (sequenceIdx == idx).sum(axis=1) ax.plot(time / 60., data) ax.set_ylim([0, data.max() + 1]) exportFigure(plt, plotOutDir, 'replicationSequenceIdx') 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 moleculeIds = sim_data.moleculeGroups.aaIDs moleculeIds.append('GTP[c] (translation)') moleculeIds.extend(sim_data.moleculeGroups.ntpIds) # Load time initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join( simOutDir, "Main")).readColumn("time") - initialTime # Load data growthLimitsDataFile = TableReader( os.path.join(simOutDir, "GrowthLimits")) # Translation gtpPoolSize = growthLimitsDataFile.readColumn("gtpPoolSize") gtpRequestSize = growthLimitsDataFile.readColumn("gtpRequestSize") gtpAllocated = growthLimitsDataFile.readColumn("gtpAllocated") gtpUsed = growthLimitsDataFile.readColumn("gtpUsed") aaPoolSize = growthLimitsDataFile.readColumn("aaPoolSize") aaRequestSize = growthLimitsDataFile.readColumn("aaRequestSize") aaAllocated = growthLimitsDataFile.readColumn("aaAllocated") aasUsed = growthLimitsDataFile.readColumn("aasUsed") # Transcription ntpPoolSize = growthLimitsDataFile.readColumn("ntpPoolSize") ntpRequestSize = growthLimitsDataFile.readColumn("ntpRequestSize") ntpAllocated = growthLimitsDataFile.readColumn("ntpAllocated") ntpUsed = growthLimitsDataFile.readColumn("ntpUsed") # Create aggregate poolSize = np.hstack( (aaPoolSize, gtpPoolSize.reshape(gtpPoolSize.size, 1), ntpPoolSize)) requestSize = np.hstack( (aaRequestSize, gtpRequestSize.reshape(gtpPoolSize.size, 1), ntpRequestSize)) allocated = np.hstack( (aaAllocated, gtpAllocated.reshape(gtpPoolSize.size, 1), ntpAllocated)) used = np.hstack((aasUsed, gtpUsed.reshape(gtpPoolSize.size, 1), ntpUsed)) growthLimitsDataFile.close() # Load ATP usage # ATPusageListenerFile = TableReader(os.path.join(simOutDir, "ATPhydrolyzedUsageListener")) # atpsHydrolyzed = ATPusageListenerFile.readColumn('atpsHydrolyzed') # ATPusageListenerFile.close() # bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules")) # bulkMoleculeIds = bulkMolecules.readAttribute("objectNames") # bulkMolecules.close() # Plot fig = plt.figure(figsize=(11, 11)) # Plot GTP consumption # plt.rc('xtick', labelsize=5) # plt.rc('ytick', labelsize=5) # plt.plot(time / 60., gtpUsed) # plt.plot(time / 60., atpsHydrolyzed) # plt.xlabel("Time (min)", fontsize = 5) # plt.ylabel("GTP counts", fontsize = 5) print "GTP consumption by polypeptide elongation = %d" % np.sum( gtpUsed) # print "ATP hydrolyzed for non-growth associated maintenance = %d" % np.sum(atpsHydrolyzed) for idx in range(len(moleculeIds)): ax = plt.subplot(7, 4, idx + 1) ax.plot(time / 60., poolSize[:, idx], linewidth=2, label="pool size", color='k') ax.plot(time / 60., requestSize[:, idx], linewidth=2, label="request size", color='b') ax.plot(time / 60., allocated[:, idx], linewidth=2, label="allocated", color='r', linestyle='--') ax.plot(time / 60., used[:, idx], linewidth=2, label="used", color="c", linestyle=":") # Highlight title if request is greater than pool bbox = None if (poolSize < requestSize)[:, idx].any() or ( allocated < requestSize)[:, idx].any(): bbox = {'facecolor': 'red', 'alpha': 0.5, 'pad': 10} elif (used[:, idx] < allocated[:, idx]).any(): bbox = {'facecolor': 'orange', 'alpha': 0.5, 'pad': 10} ax.set_title(moleculeIds[idx], bbox=bbox) # Set ticks so this is all easy to read 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=10) ax.set_xticks([time.min() / 60., time.max() / 60.]) ax.set_yticks([ 0., np.max([ poolSize[:, idx].max(), requestSize[:, idx].max(), allocated[:, idx].max() ]) ]) # Create legend ax = plt.subplot(7, 4, len(moleculeIds) + 1) ax.plot(0, 0, linewidth=2, label="pool size", color='k') ax.plot(0, 0, linewidth=2, label="request size", color='b') ax.plot(0, 0, linewidth=2, label="allocated", color='r', linestyle='--') ax.plot(0, 0, linewidth=2, label="used", color="c", linestyle=':') ax.legend(loc=10, prop={'size': 10}) ax.spines['top'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.spines['left'].set_visible(False) ax.spines['right'].set_visible(False) ax.xaxis.set_ticks_position('none') ax.yaxis.set_ticks_position('none') ax.set_xticks([]) ax.set_yticks([]) ax.set_title("Highlights process under-usage", fontsize=12, bbox={ 'facecolor': 'orange', 'alpha': 0.5, 'pad': 10 }) ax.set_xlabel("Highlights pool/allocation limit", fontsize=12, bbox={ 'facecolor': 'red', 'alpha': 0.5, 'pad': 10 }) # Save plt.subplots_adjust(hspace=0.5, wspace=0.5) exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, inputDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if metadata is not None and SHUFFLE_VARIANT_TAG not in metadata[ "variant"]: print "This plot only runs for variants where parameters are shuffled." return if not os.path.isdir(inputDir): raise Exception, "variantDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) ap = AnalysisPaths(inputDir, variant_plot=True) control_sim = ap.get_cells(variant=[0]) variant_cells = ap.get_cells(variant=range(1, ap.n_variant)) doublingTimes = [] for simDir in variant_cells: try: simOutDir = os.path.join(simDir, "simOut") time = TableReader(os.path.join(simOutDir, "Main")).readColumn("time") initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") doublingTimes.append((time.max() - initialTime) / 60.) except Exception as e: print e continue doublingTimes = np.array(doublingTimes) controlDoublingTime = None for simDir in control_sim: simOutDir = os.path.join(simDir, "simOut") time = TableReader(os.path.join(simOutDir, "Main")).readColumn("time") initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") controlDoublingTime = (time.max() - initialTime) / 60. fig = plt.figure() fig.set_figwidth(5) fig.set_figheight(5) ax = plt.subplot(1, 1, 1) ax.hist(doublingTimes, np.sqrt(doublingTimes.size)) ax.axvline(controlDoublingTime, color="k", linestyle="dashed", linewidth=2) ax.set_xlabel("Cell Division Time (min)") ax.set_title( "Mean: %0.3g Std: %0.3g Control: %0.3g" % (doublingTimes.mean(), doublingTimes.std(), controlDoublingTime)) axes_list = [ax] for a in axes_list: for tick in a.yaxis.get_major_ticks(): tick.label.set_fontsize(FONT_SIZE) for tick in a.xaxis.get_major_ticks(): tick.label.set_fontsize(FONT_SIZE) whitePadSparklineAxis(ax) plt.subplots_adjust(bottom=0.2, wspace=0.3) exportFigure(plt, plotOutDir, plotOutFileName, metadata)
def do_plot(self, variantDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): if not os.path.isdir(variantDir): raise Exception, "variantDir does not currently exist as a directory" if not os.path.exists(plotOutDir): os.mkdir(plotOutDir) sim_data = cPickle.load(open(simDataFile, "rb")) oriC = sim_data.constants.oriCCenter.asNumber() terC = sim_data.constants.terCCenter.asNumber() genomeLength = len(sim_data.process.replication.genome_sequence) mult = 2.3 fig = plt.figure(figsize=(6, 6)) #fig.set_figwidth(mm2inch(97)*mult) #fig.set_figheight(mm2inch(58)*mult) ax0 = plt.subplot2grid((3, 4), (0, 0), colspan=4) ax1 = plt.subplot2grid((3, 4), (1, 0), colspan=4, sharex=ax0) ax2 = plt.subplot2grid((3, 4), (2, 0), colspan=4, sharex=ax0) ax0_xlim = ax0.get_xlim() #ax3 = plt.subplot2grid((5,7), (3,0), colspan = 4, sharex=ax0) #ax4 = plt.subplot2grid((5,7), (4,0), colspan = 4, sharex=ax0) # Get all cells in each seed ap = AnalysisPaths(variantDir, cohort_plot=True) #all_cells = ap.get_cells(seed=[0,1,2,3]) all_cells = ap.get_cells(seed=[4]) if not len(all_cells): return for idx, simDir in enumerate(all_cells): #color = "black" color = "#0d71b9" alpha = 1 if idx % 2: color = "#0d71b9" blue = 0.8 simOutDir = os.path.join(simDir, "simOut") time = TableReader(os.path.join(simOutDir, "Main")).readColumn("time") ## Cell mass mass = TableReader(os.path.join(simOutDir, "Mass")) cellMass = mass.readColumn("cellMass") massPerOric = TableReader( os.path.join( simOutDir, "ReplicationData")).readColumn("criticalMassPerOriC") idxInit = np.where(massPerOric >= 1)[0] ax0.plot(time / 60., cellMass, color=color, alpha=alpha, linewidth=2) ax0.plot(time[idxInit] / 60., cellMass[idxInit], markersize=6, linewidth=0, marker="o", color="#ed2224", markeredgewidth=0) ## Inst. growth rate growthRate = mass.readColumn("instantaniousGrowthRate") growthRate = (1 / units.s) * growthRate growthRate = growthRate.asNumber(1 / units.min) growthRate[abs(growthRate - np.median(growthRate)) > 1.25 * np.nanstd(growthRate)] = np.nan ax1.plot(time / 60., growthRate, color=color, alpha=alpha) ## Rna over protein # Get active ribosome counts uniqueMoleculeCounts = TableReader( os.path.join(simOutDir, "UniqueMoleculeCounts")) ribosomeIndex = uniqueMoleculeCounts.readAttribute( "uniqueMoleculeIds").index("activeRibosome") ribosomeCounts = uniqueMoleculeCounts.readColumn( "uniqueMoleculeCounts")[:, ribosomeIndex] uniqueMoleculeCounts.close() ribosomeConcentration = ( (1 / sim_data.constants.nAvogadro) * ribosomeCounts) / ( (1.0 / sim_data.constants.cellDensity) * (units.fg * cellMass)) ribosomeConcentration = ribosomeConcentration.asNumber(units.umol / units.L) ax2.plot(time / 60., ribosomeConcentration, color=color, alpha=alpha, linewidth=2) ax2.set_ylim([18., 28.]) # rnaMass = mass.readColumn("rnaMass") # proteinMass = mass.readColumn("proteinMass") # rnaOverProtein = rnaMass / proteinMass # ax2.plot(time / 60., rnaOverProtein, color = color, alpha = alpha, linewidth=2) ## Fork position sequenceIdx = TableReader( os.path.join(simOutDir, "ReplicationData")).readColumn("sequenceIdx") sequenceLength = TableReader( os.path.join(simOutDir, "ReplicationData")).readColumn("sequenceLength") reverseIdx = 1 reverseCompIdx = 3 reverseSequences = np.logical_or(sequenceIdx == reverseIdx, sequenceIdx == reverseCompIdx) sequenceLength[ reverseSequences] = -1 * sequenceLength[reverseSequences] sequenceLength[sequenceLength == PLACE_HOLDER] = np.nan # Down sample dna polymerase position, every position is only plotted once here # using numpy ninja-ness unique, index, value = np.unique(sequenceLength, return_index=True, return_inverse=True) m = np.zeros_like(value, dtype=bool) m[index] = True m = m.reshape(sequenceLength.shape) sequenceLength[~m] = np.nan # ax3.plot(time / 60., sequenceLength, marker=',', markersize=2, linewidth=0, color = color, alpha = alpha) # ax3.set_yticks([-1 * genomeLength / 2, 0, genomeLength / 2]) # ax3.set_yticklabels(['-terC', 'oriC', '+terC']) ## Pairs of forks # pairsOfForks = (sequenceIdx != PLACE_HOLDER).sum(axis = 1) / 4 # ax4.plot(time / 60., pairsOfForks, linewidth=2, color = color, alpha = alpha) # ax4.set_yticks(np.arange(0,7)) # ax4.set_ylim([0, 6]) y_ticks = ax0.get_yticks() new_y_ticks = y_ticks[0:-1:2] ax0.set_yticks(new_y_ticks) ax0.set_xlim([0., time.max() / 60.]) ax0.set_ylabel("Cell mass\n(fg)", fontsize=FONT_SIZE) ax0.xaxis.set_visible(False) #ax0.axvline(x=44*2+22., linewidth=3, color='gray', alpha = 0.5) nutrients_time_series_label = sim_data.external_state.environment.nutrients_time_series_label try: T_ADD_AA = sim_data.external_state.environment.nutrients_time_series[ nutrients_time_series_label][1][0] / 60. except Exception as e: print "nutrients_time_series does not have correct dimensions for this analysis. Exiting.", e return axes_list = [ax0, ax1, ax2] #, ax3, ax4] for a in axes_list: shift_time = T_ADD_AA width = a.get_xlim()[1] - shift_time height = a.get_ylim()[1] - a.get_ylim()[0] a.add_patch( patches.Rectangle( (shift_time, a.get_ylim()[0]), # (x,y) width, # width height, # height alpha=0.25, color="gray", linewidth=0.)) for a in axes_list: for tick in a.yaxis.get_major_ticks(): tick.label.set_fontsize(FONT_SIZE) ax1.set_ylabel(r"$\mu$ $(\frac{gDCW}{gDCW \cdot \, min})$", fontsize=FONT_SIZE) ax1.xaxis.set_visible(False) # ax1.axvline(x=44*2+22., linewidth=3, color='gray', alpha = 0.5) ax1.set_ylim([0, 0.032]) #ax2.set_ylabel("RNA/Protein\n(fg/fg)", fontsize=FONT_SIZE) ax2.set_ylabel("Active\nribosome\n(umol/L)", fontsize=FONT_SIZE) ax2.xaxis.set_visible(False) # ax2.axvline(x=44*2+22., linewidth=3, color='gray', alpha = 0.5) y_ticks = ax2.get_yticks() new_y_ticks = y_ticks[0:-1:2] ax2.set_yticks(new_y_ticks) # ax3.set_ylabel("DNA polymerase\nposition (nt)", fontsize=FONT_SIZE) # ax3.xaxis.set_visible(False) # # ax3.axvline(x=44*2+22., linewidth=3, color='gray', alpha = 0.5) # ax4.set_ylabel("Relative rate\nof dNTP\npolymerization", fontsize=FONT_SIZE) # ax4.set_xlabel("Time (min)", fontsize=FONT_SIZE) # # ax4.axvline(x=44*2+22., linewidth=3, color='gray', alpha = 0.5) whitePadSparklineAxis(ax0, False) whitePadSparklineAxis(ax1, False) whitePadSparklineAxis(ax2, False) # whitePadSparklineAxis(ax3, False) # whitePadSparklineAxis(ax4) exportFigure(plt, plotOutDir, plotOutFileName + "_b", metadata) for axes in axes_list: axes.tick_params( axis='x', # changes apply to the x-axis which='both', # both major and minor ticks are affected bottom='off', # ticks along the bottom edge are off top='off', # ticks along the top edge are off labelbottom='off') # labels along the bottom edge are off axes.tick_params( axis='y', # changes apply to the x-axis which='both', # both major and minor ticks are affected left='off', # ticks along the bottom edge are off right='off', # ticks along the top edge are off labelleft='off') # labels along the bottom edge are off axes.set_xlabel("") axes.set_ylabel("") plt.subplots_adjust(top=1, bottom=trim, left=trim, right=1) exportFigure(plt, plotOutDir, plotOutFileName + "_b_stripped", metadata, transparent=True) plt.close("all") ################ PART II ####################### mult = 2.3 fig = plt.figure() fig.set_figwidth(mm2inch(97) * mult) fig.set_figheight(mm2inch(38) * mult) # ax0 = plt.subplot2grid((3,4), (0,0), colspan = 4) # ax1 = plt.subplot2grid((3,4), (1,0), colspan = 4, sharex=ax0) # ax2 = plt.subplot2grid((3,4), (2,0), colspan = 4, sharex=ax0) ax3 = plt.subplot2grid((2, 4), (0, 0), colspan=4, sharex=ax0) ax4 = plt.subplot2grid((2, 4), (1, 0), colspan=4, sharex=ax0) # Get all cells in each seed ap = AnalysisPaths(variantDir, cohort_plot=True) all_cells = ap.get_cells(seed=[4]) if not len(all_cells): return for idx, simDir in enumerate(all_cells): #color = "black" color = "#0d71b9" alpha = 1 if idx % 2: color = "#0d71b9" blue = 0.8 simOutDir = os.path.join(simDir, "simOut") time = TableReader(os.path.join(simOutDir, "Main")).readColumn("time") ## Cell mass # mass = TableReader(os.path.join(simOutDir, "Mass")) # cellMass = mass.readColumn("cellMass") # ax0.plot(time / 60., cellMass, color = color, alpha = alpha, linewidth=2) ## Inst. growth rate # growthRate = mass.readColumn("instantaniousGrowthRate") # growthRate = (1 / units.s) * growthRate # growthRate = growthRate.asNumber(1 / units.min) # growthRate[abs(growthRate - np.median(growthRate)) > 1.25 * np.nanstd(growthRate)] = np.nan # ax1.plot(time / 60., growthRate, color = color, alpha = alpha) ## Rna over protein # Get active ribosome counts # uniqueMoleculeCounts = TableReader(os.path.join(simOutDir, "UniqueMoleculeCounts")) # ribosomeIndex = uniqueMoleculeCounts.readAttribute("uniqueMoleculeIds").index("activeRibosome") # ribosomeCounts = uniqueMoleculeCounts.readColumn("uniqueMoleculeCounts")[:, ribosomeIndex] # uniqueMoleculeCounts.close() # ribosomeConcentration = ((1 / sim_data.constants.nAvogadro) * ribosomeCounts) / ((1.0 / sim_data.constants.cellDensity) * (units.fg * cellMass)) # ribosomeConcentration = ribosomeConcentration.asNumber(units.umol / units.L) # ax2.plot(time / 60., ribosomeConcentration, color = color, alpha = alpha, linewidth=2) # ax2.set_ylim([20., 35.]) # rnaMass = mass.readColumn("rnaMass") # proteinMass = mass.readColumn("proteinMass") # rnaOverProtein = rnaMass / proteinMass # ax2.plot(time / 60., rnaOverProtein, color = color, alpha = alpha, linewidth=2) ## Fork position sequenceIdx = TableReader( os.path.join(simOutDir, "ReplicationData")).readColumn("sequenceIdx") sequenceLength = TableReader( os.path.join(simOutDir, "ReplicationData")).readColumn("sequenceLength") reverseIdx = 1 reverseCompIdx = 3 reverseSequences = np.logical_or(sequenceIdx == reverseIdx, sequenceIdx == reverseCompIdx) sequenceLength[ reverseSequences] = -1 * sequenceLength[reverseSequences] sequenceLength[sequenceLength == PLACE_HOLDER] = np.nan # Down sample dna polymerase position, every position is only plotted once here # using numpy ninja-ness unique, index, value = np.unique(sequenceLength, return_index=True, return_inverse=True) m = np.zeros_like(value, dtype=bool) m[index] = True m = m.reshape(sequenceLength.shape) sequenceLength[~m] = np.nan ax3.plot(time / 60., sequenceLength, marker='o', markersize=2, linewidth=0, color=color, alpha=alpha) #ax3.plot(time / 60., sequenceLength, linewidth=1, color = color, alpha = alpha) ax3.set_yticks([-1 * genomeLength / 2, 0, genomeLength / 2]) ax3.set_yticklabels(['-terC', 'oriC', '+terC']) # Pairs of forks pairsOfForks = (sequenceIdx != PLACE_HOLDER).sum(axis=1) / 4 ax4.plot(time / 60., pairsOfForks, linewidth=2, color=color, alpha=alpha) ax4.set_yticks(np.arange(0, 7)) ax4.set_ylim([0, 6.1]) ax4.set_yticks([0, 6.]) ax4.set_yticklabels(["0", "6"]) # y_ticks = ax0.get_yticks() # new_y_ticks = y_ticks[0:-1:2] # ax0.set_yticks(new_y_ticks) ax3.set_xlim([0., time.max() / 60.]) # ax0.set_ylabel("Cell mass\n(fg)", fontsize=FONT_SIZE) # ax0.xaxis.set_visible(False) #ax0.axvline(x=44*2+22., linewidth=3, color='gray', alpha = 0.5) nutrients_time_series_label = sim_data.external_state.environment.nutrients_time_series_label T_ADD_AA = sim_data.external_state.environment.nutrients_time_series[ nutrients_time_series_label][1][0] / 60. axes_list = [ax3, ax4] for a in axes_list: shift_time = T_ADD_AA width = a.get_xlim()[1] - shift_time height = a.get_ylim()[1] - a.get_ylim()[0] a.add_patch( patches.Rectangle( (shift_time, a.get_ylim()[0]), # (x,y) width, # width height, # height alpha=0.25, color="gray", linewidth=0.)) for a in axes_list: for tick in a.yaxis.get_major_ticks(): tick.label.set_fontsize(FONT_SIZE) # ax1.set_ylabel(r"$\mu$ $(\frac{gDCW}{gDCW-min})$", fontsize=FONT_SIZE) # ax1.xaxis.set_visible(False) # # ax1.axvline(x=44*2+22., linewidth=3, color='gray', alpha = 0.5) # ax1.set_ylim([0.012, 0.032]) # #ax2.set_ylabel("RNA/Protein\n(fg/fg)", fontsize=FONT_SIZE) # ax2.set_ylabel("Active\nribosome\n(umol/L)", fontsize=FONT_SIZE) # ax2.xaxis.set_visible(False) # # ax2.axvline(x=44*2+22., linewidth=3, color='gray', alpha = 0.5) # y_ticks = ax2.get_yticks() # new_y_ticks = y_ticks[0:-1:2] # ax2.set_yticks(new_y_ticks) ax3.set_ylabel("DNA polymerase\nposition (nt)", fontsize=FONT_SIZE) ax3.xaxis.set_visible(False) # ax3.axvline(x=44*2+22., linewidth=3, color='gray', alpha = 0.5) ax4.set_ylabel("Relative rate\nof dNTP\npolymerization", fontsize=FONT_SIZE) ax4.set_xlabel("Time (min)", fontsize=FONT_SIZE) # ax4.axvline(x=44*2+22., linewidth=3, color='gray', alpha = 0.5) # whitePadSparklineAxis(ax0, False) # whitePadSparklineAxis(ax1, False) # whitePadSparklineAxis(ax2, False) whitePadSparklineAxis(ax3, False) whitePadSparklineAxis(ax4) plt.subplots_adjust(bottom=0.15) exportFigure(plt, plotOutDir, plotOutFileName + "_e", metadata) for axes in axes_list: axes.tick_params( axis='x', # changes apply to the x-axis which='both', # both major and minor ticks are affected bottom='off', # ticks along the bottom edge are off top='off', # ticks along the top edge are off labelbottom='off') # labels along the bottom edge are off axes.tick_params( axis='y', # changes apply to the x-axis which='both', # both major and minor ticks are affected left='off', # ticks along the bottom edge are off right='off', # ticks along the top edge are off labelleft='off') # labels along the bottom edge are off axes.set_xlabel("") axes.set_ylabel("") plt.subplots_adjust(top=1, bottom=trim, left=trim, right=1) exportFigure(plt, plotOutDir, plotOutFileName + "_e_stripped", metadata, transparent=True) 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) sim_data = cPickle.load(open(simDataFile, "rb")) oriC = sim_data.constants.oriCCenter.asNumber() terC = sim_data.constants.terCCenter.asNumber() genomeLength = len(sim_data.process.replication.genome_sequence) ap = AnalysisPaths(seedOutDir, multi_gen_plot=True) # Get all cells allDir = ap.get_cells() fig, axesList = plt.subplots(6, sharex=True) fig.set_size_inches(11, 11) for simDir in allDir: simOutDir = os.path.join(simDir, "simOut") time = TableReader(os.path.join( simOutDir, "Main")).readColumn("time") / 60. / 60. mass = TableReader(os.path.join(simOutDir, "Mass")) division_time = time.max() # Plot dna polymerase position sequenceIdx = TableReader( os.path.join(simOutDir, "ReplicationData")).readColumn("sequenceIdx") sequenceLength = TableReader( os.path.join(simOutDir, "ReplicationData")).readColumn("sequenceLength") reverseIdx = 1 reverseCompIdx = 3 reverseSequences = np.logical_or(sequenceIdx == reverseIdx, sequenceIdx == reverseCompIdx) sequenceLength[ reverseSequences] = -1 * sequenceLength[reverseSequences] sequenceLength[sequenceLength == PLACE_HOLDER] = np.nan # Down sample dna polymerase position, every position is only plotted once here # using numpy ninja-ness unique, index, value = np.unique(sequenceLength, return_index=True, return_inverse=True) m = np.zeros_like(value, dtype=bool) m[index] = True m = m.reshape(sequenceLength.shape) sequenceLength[~m] = np.nan axesList[0].plot(time, sequenceLength, marker=',', markersize=1, linewidth=0) axesList[0].set_xlim([0, time.max()]) axesList[0].set_yticks( [-1 * genomeLength / 2, 0, genomeLength / 2]) axesList[0].set_yticklabels(['-terC', 'oriC', '+terC']) axesList[0].set_ylabel("DNA polymerase\nposition (nt)") # Plot dna polymerase counts pairsOfForks = (sequenceIdx != PLACE_HOLDER).sum(axis=1) / 4 axesList[1].plot(time, pairsOfForks, linewidth=2) axesList[1].set_yticks(np.arange(0, 7)) axesList[1].set_ylim([0, 6]) axesList[1].set_xlim([0, time.max()]) axesList[1].plot([time.max(), time.max()], axesList[1].get_ylim(), 'k') axesList[1].set_ylabel("Pairs of\nforks") # Factors of critical initiation mass totalMass = mass.readColumn("cellMass") criticalInitiationMass = TableReader( os.path.join( simOutDir, "ReplicationData")).readColumn("criticalInitiationMass") criticalMassEquivalents = totalMass / criticalInitiationMass axesList[2].plot(time, criticalMassEquivalents, linewidth=2) for N in CRITICAL_N: axesList[2].plot([0, time.max()], [N] * 2, 'k', linestyle='--') axesList[2].set_ylabel("Factors of critical\ninitiation mass") axesList[2].set_xlim([0, time.max()]) # Dry mass dryMass = mass.readColumn("dryMass") axesList[3].plot(time, dryMass, linewidth=2) axesList[3].set_ylabel("Dry mass (fg)") axesList[3].set_xlim([0, time.max()]) mass.close() # Number of oriC numberOfOric = TableReader( os.path.join(simOutDir, "ReplicationData")).readColumn("numberOfOric") axesList[4].plot(time, numberOfOric, linewidth=2) axesList[4].set_ylabel("Number of\noriC") axesList[4].set_xlim([0, time.max()]) # Mass per oriC criticalMassPerOriC = TableReader( os.path.join( simOutDir, "ReplicationData")).readColumn("criticalMassPerOriC") axesList[5].plot(time, criticalMassPerOriC, linewidth=2) axesList[5].set_ylabel("Critical mass\nper oriC") axesList[5].set_xlim([0, time.max()]) axesList[0].set_title("Replication plots") axesList[-1].set_xlabel("Time (hr)") plt.subplots_adjust(hspace=0.2, wspace=0.5) exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")
def do_plot(self, seedOutDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata): print "Disabled because it's slow" return 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) ap = AnalysisPaths(seedOutDir, multi_gen_plot=True) # Get first cell from each generation firstCellLineage = [] for gen_idx in range(ap.n_generation): firstCellLineage.append(ap.get_cells(generation=[gen_idx])[0]) sim_data = cPickle.load(open(simDataFile, "rb")) max_elongationRate = 21. # TODO: Fix this elongationRate = float( sim_data.growthRateParameters.ribosomeElongationRate.asNumber( units.aa / units.s)) fig = plt.figure() fig.set_size_inches(10, 12) ## Create composition plot massNames = [ "proteinMass", "rnaMass", ] cleanNames = [ "Protein", "RNA", ] colors = [ "red", "blue", ] # Composition plotting # Create plotting indexes with some offsets to make it look nice initFinalIdx = range(4 * len(firstCellLineage)) for idx, value in enumerate(initFinalIdx): if idx % 2: initFinalIdx[idx] = initFinalIdx[idx] - 0.1 else: initFinalIdx[idx] = initFinalIdx[idx] + 0.1 initFinalIdx = np.array(initFinalIdx) distanceInitFinalIdx = np.arange(start=0.5, stop=4 * len(firstCellLineage) + 0.5, step=2) tickLabels = tuple( ["$t=0$\nActual", "Expected", "$t=t_d$\nActual", "Expected"] * len(firstCellLineage)) barWidth = 0.75 gs = gridspec.GridSpec(6, 4) ax1 = plt.subplot(gs[:1, :-2]) ax8 = plt.subplot(gs[1, :-2]) ax2 = plt.subplot(gs[:2, 2:]) for gen, simDir in enumerate(firstCellLineage): simOutDir = os.path.join(simDir, "simOut") # Get simulation composition time, massData = getMassData(simDir, massNames) timeStep = TableReader(os.path.join( simOutDir, "Main")).readColumn("timeStepSec") _, dryMass = getMassData(simDir, ["dryMass"]) # massDataNorm = massData / massData.sum(axis = 0) massDataNorm = massData / dryMass initialComp = massDataNorm[:, 1:6 * 60 + 1].mean(axis=1) finalComp = massDataNorm[:, -5 * 60:].mean(axis=1) initialDryMass = dryMass[0] finalDryMass = dryMass[-1] # Get expected composition based on growth rates _, growthRate = getMassData(simDir, ["instantaniousGrowthRate"]) initialGrowthRate = np.mean(growthRate[1:6 * 60 + 1]) * 60 initialDoublingTime = np.log( 2 ) / initialGrowthRate * units.min # Five mintues skipping the first minute finalGrowthRate = (np.mean(growthRate[-5 * 60:]) * 60) finalDoublingTime = np.log( 2) / finalGrowthRate * units.min # Last five minutes expectedInitialComp, expectedInitialMass = getExpectedComposition( initialDoublingTime) #expectedInitialComp = expectedInitialComp / expectedInitialComp.sum() expectedInitialComp = expectedInitialComp / expectedInitialMass.asNumber( units.fg) expectedFinalComp, finalCompInitMass = getExpectedComposition( finalDoublingTime) #expectedFinalComp = expectedFinalComp / expectedFinalComp.sum() expectedFinalMass = finalCompInitMass * 2 expectedFinalComp = expectedFinalComp / expectedFinalMass.asNumber( units.fg) * 2 initialDistance = np.linalg.norm(expectedInitialComp - initialComp, 2) / np.linalg.norm( expectedInitialComp, 2) finalDistance = np.linalg.norm(expectedFinalComp - finalComp, 2) / np.linalg.norm( expectedFinalComp, 2) # Calculate ribosomal rna doubling times rrn16S_produced = TableReader( os.path.join(simOutDir, "RibosomeData")).readColumn("rrn16S_produced") rrn23S_produced = TableReader( os.path.join(simOutDir, "RibosomeData")).readColumn("rrn23S_produced") rrn5S_produced = TableReader( os.path.join(simOutDir, "RibosomeData")).readColumn("rrn5S_produced") ids_16s = [] ids_16s.extend(sim_data.moleculeGroups.s30_16sRRNA) ids_16s.append(sim_data.moleculeIds.s30_fullComplex) ids_23s = [] ids_23s.extend(sim_data.moleculeGroups.s50_23sRRNA) ids_23s.append(sim_data.moleculeIds.s50_fullComplex) ids_5s = [] ids_5s.extend(sim_data.moleculeGroups.s50_5sRRNA) ids_5s.append(sim_data.moleculeIds.s50_fullComplex) bulkMolecules = TableReader( os.path.join(simOutDir, "BulkMolecules")) moleculeIds = bulkMolecules.readAttribute("objectNames") idx_16s = np.array([moleculeIds.index(comp) for comp in ids_16s], np.int) idx_23s = np.array([moleculeIds.index(comp) for comp in ids_23s], np.int) idx_5s = np.array([moleculeIds.index(comp) for comp in ids_5s], np.int) rrn16s_count_bulk = bulkMolecules.readColumn( "counts")[:, idx_16s].sum(axis=1) rrn23s_count_bulk = bulkMolecules.readColumn( "counts")[:, idx_23s].sum(axis=1) rrn5s_count_bulk = bulkMolecules.readColumn("counts")[:, idx_5s].sum( axis=1) uniqueMoleculeCounts = TableReader( os.path.join(simOutDir, "UniqueMoleculeCounts")) ribosomeIndex = uniqueMoleculeCounts.readAttribute( "uniqueMoleculeIds").index("activeRibosome") ribosome_count_unique = uniqueMoleculeCounts.readColumn( "uniqueMoleculeCounts")[:, ribosomeIndex] rrn16s_count = rrn16s_count_bulk + ribosome_count_unique rrn23s_count = rrn23s_count_bulk + ribosome_count_unique rrn5s_count = rrn5s_count_bulk + ribosome_count_unique rrn16S_doubling_time = units.s * np.log(2) / ( rrn16S_produced / timeStep / rrn16s_count) rrn23S_doubling_time = units.s * np.log(2) / ( rrn23S_produced / timeStep / rrn23s_count) rrn5S_doubling_time = units.s * np.log(2) / ( rrn5S_produced / timeStep / rrn5s_count) rrn16S_doubling_time[rrn16S_doubling_time.asNumber() == np.inf] = np.nan * units.s rrn23S_doubling_time[rrn23S_doubling_time.asNumber() == np.inf] = np.nan * units.s rrn5S_doubling_time[rrn5S_doubling_time.asNumber() == np.inf] = np.nan * units.s # Plotting oldLayerData = np.zeros(4) indexesForGen = initFinalIdx[gen * 4:(gen + 1) * 4] ax1.axvline(x=indexesForGen[-1] + barWidth + 0.225, linewidth=2, color='k', linestyle='--') for idx, massType in enumerate(massNames): layerData = np.array([ initialComp[idx], expectedInitialComp[idx], finalComp[idx], expectedFinalComp[idx] ]) if gen == 0: ax1.bar(left=indexesForGen, height=layerData, width=barWidth, bottom=oldLayerData, label=cleanNames[idx], color=colors[idx]) else: ax1.bar(left=indexesForGen, height=layerData, width=barWidth, bottom=oldLayerData, color=colors[idx]) oldLayerData += layerData ax1.set_ylim([0, 1]) ax1.legend(prop={'size': 4}) ax1.set_title('Mass composition') # Plot Euclidian distance distanceIdxForGen = distanceInitFinalIdx[gen * 2:(gen + 1) * 2] ax8.bar(distanceIdxForGen, [initialDistance, finalDistance]) ax8.set_ylabel("Relative error") # Plot dry mass ax2.bar(indexesForGen, [ initialDryMass, expectedInitialMass.asNumber(units.fg), finalDryMass, expectedFinalMass.asNumber(units.fg) ], barWidth) ax2.set_title('Dry mass (fg)') ax2.axvline(x=indexesForGen[-1] + barWidth + 0.225, linewidth=2, color='k', linestyle='--') # Plot growth rate ax3 = plt.subplot(gs[2, :-1]) doublingTime = np.log(2) / growthRate / 60. # min avgDoublingTime = doublingTime[1:].mean() stdDoublingTime = doublingTime[1:].std() ax3.plot(time / 60., doublingTime) ax3.set_ylim([0, avgDoublingTime + 2 * stdDoublingTime]) ax3.set_ylabel("Doubling time (min)") ax3.axvline(x=time.max() / 60., linewidth=2, color='k', linestyle='--') # Plot ribosome data simOutDir = os.path.join(simDir, "simOut") ribosomeDataFile = TableReader( os.path.join(simOutDir, "RibosomeData")) effectiveElongationRate = ribosomeDataFile.readColumn( "effectiveElongationRate") initialTime = TableReader(os.path.join( simOutDir, "Main")).readAttribute("initialTime") time = TableReader(os.path.join(simOutDir, "Main")).readColumn("time") ribosomeDataFile.close() ax4 = plt.subplot(gs[3, :-1]) ax4.plot(time / 60., effectiveElongationRate, label="Effective elongation rate", linewidth=2) ax4.plot(time / 60., max_elongationRate * np.ones(time.size), 'r--') ax4.set_ylabel("Effective elongation\nrate (aa/s/ribosome)") ax4.axvline(x=time.max() / 60., linewidth=2, color='k', linestyle='--') # Plot rrn counts # bulkMoleculesFile = TableReader(os.path.join(simOutDir, "BulkMolecules")) # bulkMoleculeIds = bulkMoleculesFile.readAttribute("objectNames") # rrn_idx = bulkMoleculesFile.readAttribute("objectNames").index('rrn_operon') # rrn_counts = bulkMoleculesFile.readColumn("counts")[:, rrn_idx] # bulkMoleculesFile.close() # ax5 = plt.subplot(gs[4, :-1]) # ax5.plot(time / 60., rrn_counts, label="Rrn operon counts", linewidth=2) # ax5.set_ylim([rrn_counts.min() - 1, rrn_counts.max() + 1]) # ax5.set_ylabel("Rrn operons") # ax5.axvline(x = time.max() / 60., linewidth=2, color='k', linestyle='--') ax6 = plt.subplot(gs[5, :-1]) ax6.plot(time / 60., rrn16S_doubling_time.asNumber(units.min), linewidth=2) ax6.plot(time / 60., rrn23S_doubling_time.asNumber(units.min), linewidth=2) ax6.plot(time / 60., rrn5S_doubling_time.asNumber(units.min), linewidth=2) ax6.axvline(x=time.max() / 60., linewidth=2, color='k', linestyle='--') ax6.set_ylabel("rrn doubling time") ax6.set_xlabel("Time (min)") # Set axes labels for x-axis in plots 1 and 2 ax8.set_xticks(initFinalIdx + barWidth / 2.) ax8.set_xticklabels(tickLabels) plt.setp(ax8.xaxis.get_majorticklabels(), rotation=70, fontsize=8) ax2.set_xticks(initFinalIdx + barWidth / 2.) ax2.set_xticklabels(tickLabels) plt.setp(ax2.xaxis.get_majorticklabels(), rotation=70, fontsize=8) ## Create log growth plot massNames = [ "dryMass", "proteinMass", "rnaMass", "dnaMass", ] cleanNames = [ "Dry", "Protein", "RNA", "DNA", ] colors = [ "black", "red", "blue", "green", ] ax7 = plt.subplot(gs[2:, -1]) simDir = firstCellLineage[ 0] # Only considering the first generation for now time, massData = getMassData(simDir, massNames) for idx, massType in enumerate(massNames): ax7.plot(time / 60., np.log(massData[idx, :]), label=cleanNames[idx], color=colors[idx]) ax7.legend(prop={'size': 6}) ax7.set_xlabel('Time (min)') ax7.set_ylabel('log(mass in fg)') fig.subplots_adjust(hspace=.5, wspace=0.3) 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) ap = AnalysisPaths(seedOutDir, multi_gen_plot = True) allDirs = ap.get_cells() ################### #Initialize Figure: num_subplots = 9 nRows = 3 nCols = 3 fig =plt.figure(figsize=(7,4)) subplots_to_make = [] for i in range(1, num_subplots+1): subplots_to_make.append((nRows, nCols, i)) for nrows, ncols, plot_number in subplots_to_make: sub = fig.add_subplot(nrows, ncols, plot_number) sub.tick_params(which = 'both', direction = 'out', labelsize = 6) sub.spines['top'].set_visible(False) sub.spines['right'].set_visible(False) sub.spines['left'].set_position(('outward', 5)) if plot_number < (num_subplots + 1 - nCols): sub.xaxis.set_ticks_position('none') sub.spines['bottom'].set_visible(False) sub.set_xticks([]) else: sub.spines['bottom'].set_position(('outward', 5)) ################### # Load data from KB sim_data = cPickle.load(open(simDataFile, "rb")) nAvogadro = sim_data.constants.nAvogadro cellDensity = sim_data.constants.cellDensity oriC = sim_data.constants.oriCCenter.asNumber() terC = sim_data.constants.terCCenter.asNumber() genomeLength = len(sim_data.process.replication.genome_sequence) 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] tfBoundIds = [target + "__CPLX-125" for target in sim_data.tfToFC["CPLX-125"].keys()] synthProbIds = [target + "[c]" for target in sim_data.tfToFC["CPLX-125"].keys()] for simDir in allDirs: simOutDir = os.path.join(simDir, "simOut") # Load time initialTime = 0#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") cellMass_no_conv = massReader.readColumn("cellMass") proteinMass = units.fg * massReader.readColumn("proteinMass") # Get instantanous growth rate growth_rate = massReader.readColumn("instantaniousGrowthRate") massReader.close() # Load data from bulk molecules bulkMoleculesReader = TableReader(os.path.join(simOutDir, "BulkMolecules")) bulkMoleculeIds = bulkMoleculesReader.readAttribute("objectNames") # Get the concentration of intracellular trp trpId = ["TRP[c]"] trpIndex = np.array([bulkMoleculeIds.index(x) for x in trpId]) trpCounts = bulkMoleculesReader.readColumn("counts")[:, trpIndex].reshape(-1) trpMols = 1. / nAvogadro * trpCounts volume = cellMass / cellDensity trpConcentration = trpMols * 1. / volume # Get the promoter-bound status for all regulated genes tfBoundIndex = np.array([bulkMoleculeIds.index(x) for x in tfBoundIds]) tfBoundCounts = bulkMoleculesReader.readColumn("counts")[:, tfBoundIndex] # Get the amount of monomeric trpA trpAProteinId = ["TRYPSYN-APROTEIN[c]"] trpAProteinIndex = np.array([bulkMoleculeIds.index(x) for x in trpAProteinId]) trpAProteinCounts = bulkMoleculesReader.readColumn("counts")[:, trpAProteinIndex].reshape(-1) # Get the amount of complexed trpA trpABComplexId = ["TRYPSYN[c]"] trpABComplexIndex = np.array([bulkMoleculeIds.index(x) for x in trpABComplexId]) trpABComplexCounts = bulkMoleculesReader.readColumn("counts")[:, trpABComplexIndex].reshape(-1) # Get the amount of trpA mRNA trpARnaId = ["EG11024_RNA[c]"] trpARnaIndex = np.array([bulkMoleculeIds.index(x) for x in trpARnaId]) trpARnaCounts = bulkMoleculesReader.readColumn("counts")[:, trpARnaIndex].reshape(-1) #Get mass per Origin mass_per_oriC = TableReader(os.path.join(simOutDir, "ReplicationData")).readColumn("criticalMassPerOriC") #RNA over protein: #Get active ribosome counts uniqueMoleculeCounts = TableReader(os.path.join(simOutDir, "UniqueMoleculeCounts")) ribosomeIndex = uniqueMoleculeCounts.readAttribute("uniqueMoleculeIds").index("activeRibosome") ribosomeCounts = uniqueMoleculeCounts.readColumn("uniqueMoleculeCounts")[:, ribosomeIndex] uniqueMoleculeCounts.close() #Find the sequence index and length (to find the fork position later): sequenceIdx = TableReader(os.path.join(simOutDir, "ReplicationData")).readColumn("sequenceIdx") sequenceLength = TableReader(os.path.join(simOutDir, "ReplicationData")).readColumn("sequenceLength") sequenceLength[sequenceLength == -1] = np.nan bulkMoleculesReader.close() # Computations: # Compute total counts and concentration of trpA in monomeric and complexed form # (we know the stoichiometry) trpAProteinTotalCounts = trpAProteinCounts + 2 * trpABComplexCounts # 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 # Find the index of initialization: idxInit = np.where(mass_per_oriC >= 1)[0] # Calculate the growth rate: growth_rate = (1 / units.s) * growth_rate growth_rate = growth_rate.asNumber(1 / units.min) # Calculate Ribosome Concentration: ribosomeConcentration = ((1 / sim_data.constants.nAvogadro) * ribosomeCounts) / ((1.0 / sim_data.constants.cellDensity) * (cellMass)) ribosomeConcentration = ribosomeConcentration.asNumber(units.umol / units.L) # Fork Position: reverseIdx = 1 reverseCompIdx = 3 reverseSequences = np.logical_or(sequenceIdx == reverseIdx, sequenceIdx == reverseCompIdx) sequenceLength[reverseSequences] = -1 * sequenceLength[reverseSequences] # Down sample dna polymerase position, every position is only plotted once here unique, index, value = np.unique(sequenceLength, return_index=True, return_inverse=True) m = np.zeros_like(value, dtype=bool) m[index] = True m = m.reshape(sequenceLength.shape) sequenceLength[~m] = np.nan dnap_times = [] dnap_positions = [] for t, pos in zip(time, sequenceLength)[::10]: for p in pos[np.isfinite(pos)]: dnap_times += [t] dnap_positions += [p] dnap_times = np.array(dnap_times) dnap_positions = np.array(dnap_positions) # Relative Rate of dNTP polymerization relative_rate_dNTP_poly = (sequenceIdx != -1).sum(axis = 1) / 4 ''' Plots: Note: Some of the Y axis limits are hard coded. This was to make the plot have more rounded numbers for the paper. These limits may change simulation to simulation though, so make sure to change to be more dynamic if using on a different data set. ''' # Plot parameters: plot_line_color = '#0d71b9' plot_marker_color = '#ed2224' plot_font_size = 6 ############################################################## ax1 = plt.subplot(nRows, nCols, 1) ax1.plot(time, cellMass_no_conv, color = plot_line_color) ax1.plot(time[idxInit], cellMass_no_conv[idxInit], markersize=4, linewidth=0, marker="o", color = plot_marker_color, markeredgewidth=0) plt.ylabel("Cell Mass\n(fg)", fontsize = plot_font_size) y_min_1, y_max_1 = 1000, 4600 ax1.set_ylim([y_min_1, y_max_1]) ax1.set_yticks([y_min_1, y_max_1]) ax1.set_xlim([0, time.max()]) ############################################################## ax2 = plt.subplot(nRows, nCols, 2) ax2.plot(dnap_times, dnap_positions, marker='o', markersize=.5, linewidth=0, color = plot_line_color) plt.ylabel("DNA polymerase\nposition", fontsize = plot_font_size) ax2.set_yticks([-1 * genomeLength / 2, 0, genomeLength / 2]) ax2.set_yticklabels(['-terC', 'oriC', '+terC']) ax2.set_xlim([0, time.max()]) ############################################################## ax3 = plt.subplot(nRows, nCols, 3) ax3.plot(time, trpARnaCounts, color = plot_line_color) plt.ylabel("TrpA mRNA\nCounts", fontsize = plot_font_size) y_min_3, y_max_3 = ax3.get_ylim() ax3.set_ylim([0, y_max_3]) ax3.set_yticks([0, y_max_3]) ax3.set_yticklabels([0, "%0.0f" % y_max_3]) ax3.set_xlim([0, time.max()]) ############################################################## ax4 = plt.subplot(nRows, nCols, 4) ax4.plot(time, growth_rate, color = plot_line_color) plt.ylabel("Instantaneouse growth Rate", fontsize = plot_font_size) ax4.set_ylabel(r"$\mu$ $(\frac{gDCW}{gDCW \cdot \, min})$") y_min_4, y_max_4 = 0, 0.032 ax4.set_ylim([y_min_4, y_max_4]) ax4.set_yticks([y_min_4, y_max_4]) ax4.set_xlim([0, time.max()]) ############################################################## ax5 = plt.subplot(nRows, nCols, 5) ax5.plot(time, relative_rate_dNTP_poly, color = plot_line_color) plt.ylabel("Relative rate of\ndNTP polymerization", fontsize = plot_font_size) y_min_5, y_max_5 = 0, 6. ax5.set_ylim([y_min_5, y_max_5]) ax5.set_yticks([y_min_5, y_max_5]) ax5.set_xlim([0, time.max()]) ############################################################## ax6 = plt.subplot(nRows, nCols, 6) ax6.plot(time, trpAProteinTotalCounts, color = plot_line_color) plt.ylabel("TrpA Counts", fontsize = plot_font_size) y_min_6, y_max_6 = 800, 6000. ax6.set_ylim([y_min_6, y_max_6]) ax6.set_yticks([y_min_6,y_max_6]) ax6.set_xlim([0, time.max()]) ############################################################## ax7 = plt.subplot(nRows, nCols, 7) ax7.plot(time, ribosomeConcentration, color = plot_line_color) ax7.set_ylim([15., 25.]) plt.ylabel("Active Ribosome\n(umol/L)", fontsize = plot_font_size) y_min_7, y_max_7 = ax7.get_ylim() ax7.set_yticks([y_min_7, y_max_7]) ax7.set_yticklabels(["%0.0f" % y_min_7, "%0.0f" % y_max_7]) ax7.set_xlim([0, time.max()]) ax7.set_xticks([0, time.max()]) ax7.set_xticklabels([0., np.round(time.max() / 60., decimals = 0)]) ############################################################## ax8 = plt.subplot(nRows, nCols, 8) ax8.plot(time, tfBoundCountsMA, color = plot_line_color) #comment out color in order to see colors per generation plt.ylabel("TrpR Bound To Promoters\n(Moving Average)", fontsize = plot_font_size) y_min_8, y_max_8 = 0, 1 ax8.set_ylim([y_min_8, y_max_8]) ax8.set_yticks([y_min_8, y_max_8]) ax8.set_xlim([0, time.max()]) ax8.set_xticks([0, time.max()]) ax8.set_xticklabels([0., np.round(time.max() / 60., decimals = 0)]) ############################################################## ax9 = plt.subplot(nRows, nCols, 9) ax9.plot(time, trpConcentration.asNumber(units.umol / units.L), color = plot_line_color) plt.ylabel("Internal TRP Conc.\n(uM)", fontsize = plot_font_size) y_min_9, y_max_9 = 0, 400 ax9.set_ylim([y_min_9, y_max_9]) ax9.set_yticks([y_min_9, y_max_9]) ax9.set_yticklabels([y_min_9, y_max_9]) ax9.set_xlim([0, time.max()]) ax9.set_xticks([0, time.max()]) ax9.set_xticklabels([0., np.round(time.max() / 60., decimals = 0)]) ############################################################## plt.tight_layout() exportFigure(plt, plotOutDir, plotOutFileName, metadata) plt.close("all")