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)
validation_data = cPickle.load(open(validationDataFile, "rb"))
schmidtCounts = validation_data.protein.schmidt2015Data[
"glucoseCounts"]
ap = AnalysisPaths(inputDir, variant_plot=True)
pool = Pool(processes=parallelization.plotter_cpus())
args = zip(
range(ap.n_variant), [ap] * ap.n_variant,
[validation_data.protein.schmidt2015Data["monomerId"].tolist()] *
ap.n_variant, [schmidtCounts] * ap.n_variant)
result = pool.map(getPCC, args)
# cPickle.dump(result, open("pcc_results.cPickle", "w"), cPickle.HIGHEST_PROTOCOL)
pool.close()
pool.join()
# result = cPickle.load(open("pcc_results.cPickle", "r"))
controlPcc, controlPvalue = result[0]
pccs, pvals = zip(*result[1:])
pccs = np.array(pccs)
pvals = np.array(pvals)
fig = plt.figure()
fig.set_figwidth(5)
fig.set_figheight(5)
ax = plt.subplot(1, 1, 1)
pccs = np.array([x for x in pccs if not np.isnan(x)])
ax.hist(pccs, np.sqrt(pccs.size))
ax.axvline(controlPcc, color="k", linestyle="dashed", linewidth=2)
ax.set_xlabel("Proteome correlation (Pearson r)")
ax.set_title("Mean: %0.3g Std: %0.3g Control: %0.3g" %
(pccs.mean(), pccs.std(), controlPcc))
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 plot_threshold(ax, data, threshold, reactions):
"""
Plots the largest negative change for each reaction the changes the flux
more than the threshold. Prints the full reaction names for these reactions.
Args:
ax (matplotlib.axes): axes to plot on
data (ndarray[float]): 2D array (n time steps x m reactions) of fluxes
with the last column being the reference flux
threshold (float): threshold to plot and use as cutoff
reactions (ndarray[str]): names for each reaction in data
"""
sorted_idx = np.argsort(data)
below_idx = np.where(data[sorted_idx] < threshold)[0]
# Plot data
ax.set_yscale('symlog', threshold=0.01)
ax.bar(below_idx, data[sorted_idx[below_idx]], color='b')
ax.axhline(threshold, color='k', linestyle='--', linewidth=0.5)
# Format axes
y_ticks = np.hstack((ax.get_yticks(), threshold))
sparkline.whitePadSparklineAxis(ax)
ax.spines["bottom"].set_visible(False)
ax.tick_params(bottom=False)
ax.set_xticks(below_idx)
ax.set_xticklabels([r[:10] for r in reactions[sorted_idx[below_idx]]],
rotation=90)
ax.set_yticks(y_ticks)
ax.tick_params(labelsize=6)
ax.yaxis.set_major_formatter(FormatStrFormatter('%.1f'))
print(reactions[sorted_idx[below_idx]])
def plot_lows(ax, data, threshold, label):
"""
Plots the largest negative change for each reaction.
Args:
ax (matplotlib.axes): axes to plot on
data (ndarray[float]): 2D array (n time steps x m reactions) of fluxes
with the last column being the reference flux
threshold (float): threshold to plot
label (str): reaction label for y axis
"""
# Plot data
ax.set_yscale('symlog', threshold=0.01)
ax.fill_between(range(len(data)), sorted(data), color='b')
ax.axhline(threshold, color='k', linestyle='--', linewidth=0.5)
# Format axes
y_ticks = np.hstack((ax.get_yticks(), threshold))
sparkline.whitePadSparklineAxis(ax, xAxis=False)
ax.set_xticks([])
ax.set_yticks(y_ticks)
ax.tick_params(labelsize=6)
ax.yaxis.set_major_formatter(FormatStrFormatter('%.1f'))
ax.set_ylabel('Maximum change in\n{} flux'.format(label), fontsize=6)
def plot(proteinIds, zeroAtLeastOnce, essential, ax, axEssential, xloc, width,
functionalUnitIds):
if not len(functionalUnitIds):
notAlwaysPresent = zeroAtLeastOnce.sum()
alwaysPresent = len(proteinIds) - notAlwaysPresent
# Count number of essential genes
notAlwaysPresentEssential = np.logical_and(zeroAtLeastOnce,
essential).sum()
alwaysPresentEssential = np.logical_and(
np.logical_not(zeroAtLeastOnce), essential).sum()
else:
functionalUnitIndices = [
proteinIds.index(x) for x in functionalUnitIds
]
notAlwaysPresent = zeroAtLeastOnce[functionalUnitIndices].sum()
alwaysPresent = len(functionalUnitIds) - notAlwaysPresent
# Count number of essential genes
notAlwaysPresentEssential = np.logical_and(
zeroAtLeastOnce[functionalUnitIndices],
essential[functionalUnitIndices]).sum()
alwaysPresentEssential = np.logical_and(
np.logical_not(zeroAtLeastOnce[functionalUnitIndices]),
essential[functionalUnitIndices]).sum()
# Plot
bar = ax.bar(xloc + width, [alwaysPresent, notAlwaysPresent],
width,
color="lightgray")
axEssential.bar(xloc + width, [alwaysPresent, notAlwaysPresent],
width,
color="lightgray")
barEssential = axEssential.bar(
xloc + width, [alwaysPresentEssential, notAlwaysPresentEssential],
width,
color="b")
# Format
for axis in [ax, axEssential]:
whitePadSparklineAxis(axis)
axis.set_xticklabels(["Always\npresent", "0 at\nleast once"])
axis.set_xticks(xloc + width)
ax.set_yticks([x.get_height() for x in bar])
axRight = axEssential.twinx()
axRight.set_yticks([x[1].get_height() for x in [bar, barEssential]])
axEssential.set_yticks([x[0].get_height() for x in [bar, barEssential]])
axRight.set_ylim(ax.get_ylim())
axRight.spines["left"].set_visible(False)
axRight.spines["top"].set_visible(False)
return
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, variantDir, plotOutDir, plotOutFileName, simDataFile,
validationDataFile, metadata):
if not os.path.isdir(variantDir):
raise Exception, 'variantDir does not currently exist as a directory'
filepath.makedirs(plotOutDir)
ap = AnalysisPaths(variantDir, cohort_plot=True)
limited_metabolites = []
for sim_dir in ap.get_cells():
sim_out_dir = os.path.join(sim_dir, 'simOut')
# Listeners used
kinetics_reader = TableReader(
os.path.join(sim_out_dir, "EnzymeKinetics"))
# Load data
try:
metabolite_indices = {
m: i
for i, m in enumerate(
kinetics_reader.readAttribute('metaboliteNames'))
}
metabolite_counts = kinetics_reader.readColumn(
"metaboliteCountsFinal")[1:, :]
counts_to_molar = kinetics_reader.readColumn(
'countsToMolar')[1:].reshape(-1, 1)
except:
print('Error reading data from {}'.format(sim_out_dir))
continue
# Calculate concentrations
met_idx = np.array(
[metabolite_indices[m] for m in LIMITED_METABOLITES])
metabolite_conc = counts_to_molar * metabolite_counts[:, met_idx]
limited_metabolites += [metabolite_conc]
limited_metabolites = np.vstack(limited_metabolites)
# Values to calculate significance between different cohorts
print('Metabolites: {}'.format(LIMITED_METABOLITES))
print('Means: {}'.format(limited_metabolites.mean(axis=0)))
print('Stds: {}'.format(limited_metabolites.std(axis=0)))
print('N: {}'.format(limited_metabolites.shape[0]))
plt.figure(figsize=(4, 4))
xticks = [0, 1]
# Plot data
plt.violinplot(limited_metabolites, xticks, showmeans=True)
# Format axes
plt.ylim([0, 50])
whitePadSparklineAxis(plt.gca())
plt.xticks(xticks, LIMITED_METABOLITES)
plt.ylabel('Concentration (uM)')
plt.tight_layout()
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
plt.close('all')
def do_plot(self, inputDir, plotOutDir, plotOutFileName, simDataFile,
validationDataFile, metadata):
if metadata["variant"] != "condition":
print('This analysis only runs for the "condition" variant.')
return
if not os.path.isdir(inputDir):
raise Exception, 'inputDir does not currently exist as a directory'
filepath.makedirs(plotOutDir)
ap = AnalysisPaths(inputDir, variant_plot=True)
n_gens = ap.n_generation
variants = ap.get_variants()
if n_gens - 1 < FIRST_GENERATION:
print('Not enough generations to plot.')
return
all_growth_rates = []
all_rna_to_protein_ratios = []
for variant in variants:
doubling_times = np.zeros(0)
variant_rna_to_protein_ratios = np.zeros(0)
all_cells = ap.get_cells(variant=[variant],
generation=range(FIRST_GENERATION,
n_gens))
if len(all_cells) == 0:
continue
for simDir in all_cells:
try:
simOutDir = os.path.join(simDir, "simOut")
mass = TableReader(os.path.join(simOutDir, "Mass"))
rna_mass = mass.readColumn("rnaMass")
protein_mass = mass.readColumn("proteinMass")
time = TableReader(os.path.join(simOutDir,
"Main")).readColumn("time")
doubling_times = np.hstack(
(doubling_times, (time[-1] - time[0]) / 3600.))
variant_rna_to_protein_ratios = np.hstack(
(variant_rna_to_protein_ratios,
rna_mass.mean() / protein_mass.mean()))
except:
continue
variant_growth_rates = np.log(2) / doubling_times
all_growth_rates.append(variant_growth_rates)
all_rna_to_protein_ratios.append(variant_rna_to_protein_ratios)
# Get errorbar plot
plt.figure(figsize=FIGSIZE)
plt.style.use('seaborn-deep')
color_cycle = plt.rcParams['axes.prop_cycle'].by_key()['color']
marker_styles = ['o', '^', 'x']
labels = ['basal', 'anaerobic', '+AA']
ax = plt.subplot2grid((1, 1), (0, 0))
for i in range(3):
ax.errorbar(all_growth_rates[i].mean(),
all_rna_to_protein_ratios[i].mean(),
yerr=all_rna_to_protein_ratios[i].std(),
color=color_cycle[0],
mec=color_cycle[0],
marker=marker_styles[i],
markersize=8,
mfc='white',
linewidth=1,
capsize=2,
label=labels[i])
# Add linear plot proposed in Scott et al. (2010)
x_linear = np.linspace(0.05, 1.95, 100)
y_linear = x_linear / 4.5 + 0.087
ax.plot(x_linear, y_linear, linewidth=2, color=color_cycle[2])
ax.set_xlim([0, 2])
ax.set_ylim([0, 0.7])
ax.get_yaxis().get_major_formatter().set_useOffset(False)
ax.get_xaxis().get_major_formatter().set_useOffset(False)
whitePadSparklineAxis(ax)
ax.tick_params(which='both',
bottom=True,
left=True,
top=False,
right=False,
labelbottom=True,
labelleft=True)
ax.set_xlabel("Growth rate $\lambda$ (hour$^{-1}$)")
ax.set_ylabel("RNA/protein mass ratio")
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
# Get clean version of errorbar plot
ax.set_xlabel("")
ax.set_ylabel("")
ax.set_yticklabels([])
ax.set_xticklabels([])
exportFigure(plt, plotOutDir, plotOutFileName + "_clean", metadata)
plt.close("all")
# Get scatter version of plot
plt.figure(figsize=FIGSIZE)
ax = plt.subplot2grid((1, 1), (0, 0))
options = {"edgecolors": color_cycle[0], "alpha": 0.25, "s": 20}
ax.scatter(all_growth_rates[0],
all_rna_to_protein_ratios[0],
facecolors="none",
marker="o",
label=labels[0],
**options)
ax.scatter(all_growth_rates[1],
all_rna_to_protein_ratios[1],
facecolors="none",
marker="^",
label=labels[1],
**options)
ax.scatter(all_growth_rates[2],
all_rna_to_protein_ratios[2],
marker="x",
label=labels[2],
**options)
x_linear = np.linspace(0.05, 2.45, 100)
y_linear = x_linear / 4.5 + 0.087
ax.plot(x_linear, y_linear, linewidth=2, color=color_cycle[2])
ax.set_xlim([0, 2.5])
ax.set_ylim([0, 0.8])
ax.get_yaxis().get_major_formatter().set_useOffset(False)
ax.get_xaxis().get_major_formatter().set_useOffset(False)
whitePadSparklineAxis(ax)
ax.tick_params(which='both',
bottom=True,
left=True,
top=False,
right=False,
labelbottom=True,
labelleft=True)
ax.set_xlabel("Growth rate $\lambda$ (hour$^{-1}$)")
ax.set_ylabel("RNA/protein mass ratio")
exportFigure(plt, plotOutDir, plotOutFileName + "_scatter", metadata)
def do_plot(self, inputDir, plotOutDir, plotOutFileName, simDataFile,
validationDataFile, metadata):
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)
fig = plt.figure()
fig.set_figwidth(5)
fig.set_figheight(5)
bremer_tau = [40, 100, 24]
bremer_origins_per_cell_at_initiation = [2, 1, 4]
bremer_rrn_init_rate = [20 * 23, 4 * 12.4, 58 * 35.9]
bremer_rna_mass_per_cell = [77, 20, 211]
bremer_elng_rate = [18, 12, 21]
sim_doubling_time = np.zeros(ap.n_variant)
sim_doubling_time_std = np.zeros(ap.n_variant)
sim_origins_per_cell_at_initiation = np.zeros(ap.n_variant)
sim_rna_mass_per_cell = np.zeros(ap.n_variant)
sim_elng_rate = np.zeros(ap.n_variant)
sim_rrn_init_rate = np.zeros(ap.n_variant)
sim_origins_per_cell_at_initiation_std = np.zeros(ap.n_variant)
sim_elng_rate_std = np.zeros(ap.n_variant)
sim_rna_mass_per_cell_std = np.zeros(ap.n_variant)
sim_rrn_init_rate_std = np.zeros(ap.n_variant)
variants = ap.get_variants()
for varIdx in range(ap.n_variant):
variant = variants[varIdx]
print("variant {}".format(variant))
all_cells = ap.get_cells(variant=[variant])
print("Total cells: {}".format(len(all_cells)))
try:
sim_data = cPickle.load(open(ap.get_variant_kb(variant)))
except Exception as e:
print "Couldn't load sim_data object. Exiting.", e
return
num_origin_at_init = np.zeros(len(all_cells))
doubling_time = np.zeros(len(all_cells))
meanRnaMass = np.zeros(len(all_cells))
meanElngRate = np.zeros(len(all_cells))
meanRrnInitRate = np.zeros(len(all_cells))
for idx, simDir in enumerate(all_cells):
print "cell {} of {}".format(idx, len(all_cells))
simOutDir = os.path.join(simDir, "simOut")
try:
time = TableReader(os.path.join(simOutDir,
"Main")).readColumn("time")
doubling_time[idx] = time[-1] - time[0]
except Exception as e:
print 'Error with data for %s: %s' % (simDir, e)
continue
timeStepSec = TableReader(os.path.join(
simOutDir, "Main")).readColumn("timeStepSec")
meanRnaMass[idx] = TableReader(os.path.join(
simOutDir, "Mass")).readColumn("rnaMass").mean()
meanElngRate[idx] = TableReader(
os.path.join(simOutDir, "RibosomeData")).readColumn(
"effectiveElongationRate").mean()
numOrigin = TableReader(
os.path.join(simOutDir,
"ReplicationData")).readColumn("numberOfOric")
massPerOric = TableReader(
os.path.join(
simOutDir,
"ReplicationData")).readColumn("criticalMassPerOriC")
idxInit = np.where(massPerOric >= 1)[0]
numOriginAtInit = numOrigin[idxInit - 1]
if numOriginAtInit.size:
num_origin_at_init[idx] = numOriginAtInit.mean()
else:
num_origin_at_init[idx] = np.nan
transcriptDataFile = TableReader(
os.path.join(simOutDir, "TranscriptElongationListener"))
rnaSynth = transcriptDataFile.readColumn("countRnaSynthesized")
isRRna = sim_data.process.transcription.rnaData["isRRna"]
meanRrnInitRate[idx] = (rnaSynth[:, isRRna].sum(axis=1) /
timeStepSec).mean() * 60. / 3
sim_rna_mass_per_cell[varIdx] = meanRnaMass.mean()
sim_elng_rate[varIdx] = meanElngRate.mean()
sim_origins_per_cell_at_initiation[varIdx] = np.nanmean(
num_origin_at_init)
sim_doubling_time[varIdx] = np.nanmean(doubling_time) / 60.
sim_rrn_init_rate[varIdx] = np.nanmean(meanRrnInitRate)
sim_rna_mass_per_cell_std[varIdx] = meanRnaMass.std()
sim_elng_rate_std[varIdx] = meanElngRate.std()
sim_origins_per_cell_at_initiation_std[varIdx] = np.nanstd(
num_origin_at_init)
sim_doubling_time_std[varIdx] = np.nanstd(doubling_time) / 60.
sim_rrn_init_rate_std[varIdx] = np.nanstd(meanRrnInitRate)
bremer_tau = np.array(bremer_tau)
ax0 = plt.subplot2grid((2, 2), (0, 0))
ax1 = plt.subplot2grid((2, 2), (1, 0), sharex=ax0)
ax2 = plt.subplot2grid((2, 2), (0, 1), sharex=ax0)
ax3 = plt.subplot2grid((2, 2), (1, 1), sharex=ax0)
lines = {'linestyle': 'dashed'}
plt.rc('lines', **lines)
plt.style.use('seaborn-deep')
color_cycle = plt.rcParams['axes.prop_cycle'].by_key()['color']
ax0.errorbar(
sim_doubling_time[np.argsort(sim_doubling_time)[::-1]],
sim_rna_mass_per_cell[np.argsort(sim_doubling_time)[::-1]],
yerr=sim_rna_mass_per_cell_std[np.argsort(sim_doubling_time)
[::-1]],
color=color_cycle[0],
**SIM_PLOT_STYLE)
ax0.errorbar(
bremer_tau[np.argsort(bremer_tau)[::-1]],
np.array(bremer_rna_mass_per_cell)[np.argsort(bremer_tau)[::-1]],
color=color_cycle[2],
**EXP_PLOT_STYLE)
ax0.set_title("RNA mass per cell (fg)", fontsize=FONT_SIZE)
ax0.set_xlim([0, 135])
ax0.set_ylim([0, 250])
ax0.legend(loc=1, fontsize='xx-small', markerscale=0.5, frameon=False)
ax1.errorbar(
sim_doubling_time[np.argsort(sim_doubling_time)[::-1]],
sim_elng_rate[np.argsort(sim_doubling_time)[::-1]],
yerr=sim_elng_rate_std[np.argsort(sim_doubling_time)[::-1]],
color=color_cycle[0],
**SIM_PLOT_STYLE)
ax1.errorbar(bremer_tau[np.argsort(bremer_tau)[::-1]],
np.array(bremer_elng_rate)[np.argsort(bremer_tau)[::-1]],
color=color_cycle[2],
**EXP_PLOT_STYLE)
ax1.set_title("Ribosome elongation\nrate (aa/s/ribosome)",
fontsize=FONT_SIZE)
ax1.set_xlabel("Doubling time (min)", fontsize=FONT_SIZE)
ax1.set_ylim([0, 24])
ax2.errorbar(sim_doubling_time[np.argsort(sim_doubling_time)[::-1]],
sim_origins_per_cell_at_initiation[np.argsort(
sim_doubling_time)[::-1]],
yerr=sim_origins_per_cell_at_initiation_std[np.argsort(
sim_doubling_time)[::-1]],
color=color_cycle[0],
**SIM_PLOT_STYLE)
ax2.errorbar(bremer_tau[np.argsort(bremer_tau)[::-1]],
np.array(bremer_origins_per_cell_at_initiation)[
np.argsort(bremer_tau)[::-1]],
color=color_cycle[2],
**EXP_PLOT_STYLE)
ax2.set_title("Average origins at chrom. init.", fontsize=FONT_SIZE)
ax2.set_ylim([0.5, 4.5])
ax3.errorbar(
sim_doubling_time[np.argsort(sim_doubling_time)[::-1]],
sim_rrn_init_rate[np.argsort(sim_doubling_time)[::-1]],
yerr=sim_rrn_init_rate_std[np.argsort(sim_doubling_time)[::-1]],
color=color_cycle[0],
**SIM_PLOT_STYLE)
ax3.errorbar(
bremer_tau[np.argsort(bremer_tau)[::-1]],
np.array(bremer_rrn_init_rate)[np.argsort(bremer_tau)[::-1]],
color=color_cycle[2],
**EXP_PLOT_STYLE)
ax3.set_title("Rate of rrn initiation (1/min)", fontsize=FONT_SIZE)
ax3.set_ylim([0, 2500])
# ax3.legend(loc=1, frameon=True, fontsize=7)
ax3.set_xlabel("Doubling time (min)", fontsize=FONT_SIZE)
axes_list = [ax0, ax1, ax2, ax3]
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(ax0, False)
whitePadSparklineAxis(ax1)
whitePadSparklineAxis(ax2, False)
whitePadSparklineAxis(ax3)
plt.subplots_adjust(bottom=0.2, wspace=0.3)
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
def do_plot(self, inputDir, plotOutDir, plotOutFileName, simDataFile,
validationDataFile, metadata):
if not os.path.isdir(inputDir):
raise Exception, "inputDir does not currently exist as a directory"
if not os.path.exists(plotOutDir):
os.mkdir(plotOutDir)
if not os.path.exists(
os.path.join(
plotOutDir,
"distribution_division_fluxome_proteome_data_matrix.xls")):
print "%s must exist as an .xls file for this plot." % "distribution_division_fluxome_proteome_data_matrix.xls"
return
# Load data
wb = open_workbook(
os.path.join(
plotOutDir,
"distribution_division_fluxome_proteome_data_matrix.xls"))
data_raw = wb.sheet_by_index(0)
heading = data_raw.row_values(0)
col_divisionTime = heading.index("division time")
col_proteome = heading.index("proteome pearson r")
col_fluxome = heading.index("fluxome pearson r")
col_finalMass = heading.index("final dry mass (fg)")
dataIndices = [col_divisionTime, col_proteome, col_fluxome]
wt = np.array(data_raw.row_values(1), dtype=float)[dataIndices]
# Load failures
failures = cPickle.load(
open(os.path.join(plotOutDir, "failed_variants.cPickle"), "rb"))
flag1 = 0 # failure
flag2 = 0 # 3-hour upper limit
flag3 = 0 # final dry mass < 750
data = []
for varId, row in enumerate(xrange(2, data_raw.nrows)):
row_values = data_raw.row_values(row)
if (varId + 1) in failures:
flag1 += 1
elif row_values[col_divisionTime] == 180:
flag2 += 1
elif row_values[col_finalMass] < 750.:
flag3 += 1
else:
data.append(np.array(row_values, dtype=float)[dataIndices])
data = np.array(data)
# Plot
nrows = 6
ncols = 9
factor = 1.5
fig = plt.figure(figsize=(ncols * factor, nrows * factor))
diviAx = plt.subplot2grid((nrows, ncols), (0, 0 + 1),
rowspan=2,
colspan=2)
protAx = plt.subplot2grid((nrows, ncols), (0, 3 + 1),
rowspan=2,
colspan=2)
fluxAx = plt.subplot2grid((nrows, ncols), (0, 6 + 1),
rowspan=2,
colspan=2)
dpAx = plt.subplot2grid((nrows, ncols), (4, 0 + 1),
rowspan=2,
colspan=2)
pfAx = plt.subplot2grid((nrows, ncols), (4, 3 + 1),
rowspan=2,
colspan=2)
fdAx = plt.subplot2grid((nrows, ncols), (4, 6 + 1),
rowspan=2,
colspan=2)
dp_dAx = plt.subplot2grid((nrows, ncols), (3, 1), rowspan=1, colspan=2)
pf_pAx = plt.subplot2grid((nrows, ncols), (3, 4), rowspan=1, colspan=2)
dp_pAx = plt.subplot2grid((nrows, ncols), (4, 0), rowspan=2, colspan=1)
fd_fAx = plt.subplot2grid((nrows, ncols), (3, 7), rowspan=1, colspan=2)
pf_fAx = plt.subplot2grid((nrows, ncols), (4, 3), rowspan=2, colspan=1)
fd_dAx = plt.subplot2grid((nrows, ncols), (4, 6), rowspan=2, colspan=1)
histAxes = [diviAx, protAx, fluxAx]
axesList = [
diviAx, protAx, fluxAx, dpAx, pfAx, fdAx, dp_dAx, dp_pAx, pf_pAx,
fd_fAx, pf_fAx, fd_dAx
]
# Plot histograms
nBins = 50
histTitles = [
"Division Time", "Proteome Comparison", "Fluxome Comparison"
]
histXlabels = ["Time (min)", "PCC", "PCC"]
for i, ax in enumerate(histAxes):
if i == 2:
fluxAx.set_ylim([fluxAx.get_ylim()[0], 55])
ax.hist(data[:, i],
bins=nBins,
edgecolor="none",
facecolor="k",
alpha=0.5)
ax.plot([wt[i], wt[i]], [0, ax.get_ylim()[1]],
"r",
linewidth=LINEWIDTH)
ax.set_title("%s\nwt = %0.2f" % (histTitles[i], wt[i]),
fontsize=TITLE_FONTSIZE)
ax.set_ylabel("Frequency", fontsize=TITLE_FONTSIZE)
ax.set_xlabel(histXlabels[i], fontsize=TITLE_FONTSIZE)
diviAx.set_xlim([30, diviAx.get_xlim()[1]])
diviAx.text(wt[0] - 5,
50,
"%0.0f %%" %
((data[:, 0] < wt[0]).sum() / data.shape[0] * 100.),
size=LABEL_FONTSIZE,
horizontalalignment="right")
diviAx.text(wt[0] + 5,
50,
"%0.0f %%" %
((data[:, 0] > wt[0]).sum() / data.shape[0] * 100.),
size=LABEL_FONTSIZE,
horizontalalignment="left")
protAx.text(wt[1] - 0.005,
40,
"%0.0f %%" %
((data[:, 1] < wt[1]).sum() / data.shape[0] * 100.),
size=LABEL_FONTSIZE,
horizontalalignment="right")
protAx.text(wt[1] + 0.005,
40,
"%0.0f %%" %
((data[:, 1] > wt[1]).sum() / data.shape[0] * 100.),
size=LABEL_FONTSIZE,
horizontalalignment="left")
fluxAx.text(wt[2] - 0.1,
50,
"%0.1f %%" % (float(
(data[:, 2] < wt[2]).sum()) / data.shape[0] * 100.),
size=LABEL_FONTSIZE,
horizontalalignment="right")
fluxAx.text(wt[2] + 0.1,
50,
"%0.1f %%" % (float(
(data[:, 2] > wt[2]).sum()) / data.shape[0] * 100.),
size=LABEL_FONTSIZE,
horizontalalignment="left")
for ax in histAxes:
whitePadSparklineAxis(ax)
# Plot scatter plots
axesList = [dpAx, pfAx, fdAx]
xIndices = [0, 1, 2]
yIndices = [1, 2, 0]
for i, ax in enumerate(axesList):
ax.scatter(data[:, xIndices[i]],
data[:, yIndices[i]],
s=2,
edgecolor="none",
facecolor="k")
ax.plot(wt[xIndices[i]],
wt[yIndices[i]],
"r.",
markersize=MARKERSIZE)
ax.set_xlim(histAxes[xIndices[i]].get_xlim())
ax.set_ylim(histAxes[yIndices[i]].get_xlim())
whitePadSparklineAxis(ax)
ax.axvline(x=wt[xIndices[i]], linestyle="--", color="r")
ax.axhline(y=wt[yIndices[i]], linestyle="--", color="r")
# Plot small histograms
fd_fAx.set_ylim([fluxAx.get_ylim()[0], 55])
titles = [
"Division Time (min)", "Proteome Comparison (PCC)",
"Fluxome Comparison (PCC)"
]
for i, ax in enumerate([dp_dAx, pf_pAx, fd_fAx]):
ax.hist(data[:, i],
bins=nBins,
edgecolor="none",
facecolor="k",
alpha=0.5)
ax.axvline(wt[i], color="r", linewidth=LINEWIDTH)
removeXAxis(ax)
whitePadSparklineAxis(ax)
ax.set_title(titles[i], fontsize=TITLE_FONTSIZE)
pf_fAx.set_xlim([fluxAx.get_ylim()[0], 55])
for i, ax in enumerate([fd_dAx, dp_pAx, pf_fAx]):
ax.hist(data[:, i],
bins=nBins,
edgecolor="none",
facecolor="k",
alpha=0.5,
orientation="horizontal")
ax.axhline(wt[i], color="r", linewidth=LINEWIDTH)
removeYAxis(ax)
whitePadSparklineAxis(ax)
ax.set_ylabel(titles[i], fontsize=TITLE_FONTSIZE)
ax.invert_xaxis()
for ax in axesList:
ax.tick_params(labelsize=LABEL_FONTSIZE)
plt.subplots_adjust(wspace=2, hspace=2, left=0.075, right=0.95)
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
if GENERATE_CLEAN_SUBPLOTS:
# Histograms
fig, ax = plt.subplots(1, 1, figsize=(5, 5))
filenames = ["Division", "Proteome", "Fluxome"]
axesList = [diviAx, protAx, fluxAx]
for i, filename in enumerate(filenames):
ax.set_xlim(axesList[i].get_xlim())
ax.set_ylim(axesList[i].get_ylim())
ax.plot([wt[i], wt[i]], [0, ax.get_ylim()[1]],
"r",
linewidth=LINEWIDTH)
ax.hist(data[:, i],
bins=nBins,
edgecolor="none",
facecolor="k",
alpha=0.5)
whitePadSparklineAxis(ax)
removeXAxis(ax)
cleanAxis(ax)
exportFigure(plt, plotOutDir,
plotOutFileName + "_%s" % filename, metadata)
plt.cla()
# Scatter plots
fig, ax = plt.subplots(1, 1, figsize=(5, 5))
filenames = ["DP", "PF", "FD"]
axesList = [dpAx, pfAx, fdAx]
xIndices = [0, 1, 2]
yIndices = [1, 2, 0]
for i, filename in enumerate(filenames):
ax.scatter(data[:, xIndices[i]],
data[:, yIndices[i]],
s=SCATTER_MSIZE,
edgecolor="none",
facecolor="k")
ax.plot(wt[xIndices[i]],
wt[yIndices[i]],
"r.",
markersize=MARKERSIZE)
ax.set_xlim(axesList[i].get_xlim())
ax.set_ylim(axesList[i].get_ylim())
removeYAxis(ax)
whitePadSparklineAxis(ax)
ax.axvline(x=wt[xIndices[i]], linestyle="--", color="r")
ax.axhline(y=wt[yIndices[i]], linestyle="--", color="r")
cleanAxis(ax)
exportFigure(plt, plotOutDir,
plotOutFileName + "_%s" % filename, metadata)
plt.cla()
plt.close("all")
# Small histograms for splom (only generates side histograms)
filenames = ["Division", "Proteome", "Fluxome"]
axesList = [diviAx, protAx, fluxAx]
for i, filename in enumerate(filenames):
fig, ax = plt.subplots(1, 1, figsize=(2, 5))
ax.set_ylim(axesList[i].get_xlim())
ax.set_xlim(axesList[i].get_ylim())
ax.hist(data[:, i],
bins=nBins,
edgecolor="none",
facecolor="k",
alpha=0.5,
orientation="horizontal")
ax.axhline(wt[i], color="r", linewidth=LINEWIDTH)
ax.invert_xaxis()
whitePadSparklineAxis(ax)
cleanAxis(ax)
exportFigure(plt, plotOutDir,
plotOutFileName + "_%s_%s" % (filename, "small"),
metadata)
plt.close("all")
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)
# Check if basal sim
sim_data = cPickle.load(open(simDataFile, "rb"))
if sim_data.condition != "basal":
print "Skipping - plot only runs for basal sim."
return
# Get all cells
ap = AnalysisPaths(seedOutDir, cohort_plot=True)
allDir = ap.get_cells(seed=[0], generation=GENS)
n_gens = GENS.size
if len(allDir) < n_gens:
print "Skipping - particular seed and/or gens were not simulated."
return
# Get all ids reqiured
ids_complexation = sim_data.process.complexation.moleculeNames # Complexes of proteins, and protein monomers
ids_complexation_complexes = sim_data.process.complexation.ids_complexes # Only complexes
ids_equilibrium = sim_data.process.equilibrium.moleculeNames # Complexes of proteins + small molecules, small molecules, protein monomers
ids_equilibrium_complexes = sim_data.process.equilibrium.ids_complexes # Only complexes
ids_translation = sim_data.process.translation.monomerData[
"id"].tolist() # Only protein monomers
ids_transcription = sim_data.process.transcription.rnaData[
"id"].tolist()
data_50s = sim_data.process.complexation.getMonomers(
sim_data.moleculeIds.s50_fullComplex)
data_30s = sim_data.process.complexation.getMonomers(
sim_data.moleculeIds.s30_fullComplex)
ribosome_subunit_ids = data_50s["subunitIds"].tolist(
) + data_30s["subunitIds"].tolist()
ribosome_subunit_stoich = np.hstack(
(data_50s["subunitStoich"], data_30s["subunitStoich"]))
data_rnap = sim_data.process.complexation.getMonomers(
sim_data.moleculeIds.rnapFull)
rnap_subunit_ids = data_rnap["subunitIds"].tolist()
rnap_subunit_stoich = data_rnap["subunitStoich"]
# Stoich matrices
complexStoich = sim_data.process.complexation.stoichMatrixMonomers()
equilibriumStoich = sim_data.process.equilibrium.stoichMatrixMonomers()
first_build = True
# Pre-allocate variables. Rows = Generations, Cols = Monomers
n_monomers = sim_data.process.translation.monomerData['id'].size
ratioFinalToInitialCountMultigen = np.zeros((n_gens, n_monomers),
dtype=np.float)
if not FROM_CACHE:
print "Re-running - not using cache"
for gen_idx, simDir in enumerate(allDir):
simOutDir = os.path.join(simDir, "simOut")
time = TableReader(os.path.join(simOutDir,
"Main")).readColumn("time")
## READ DATA ##
# Read in bulk ids and counts
bulkMolecules = TableReader(
os.path.join(simOutDir, "BulkMolecules"))
if first_build:
print "Running first build code"
moleculeIds = bulkMolecules.readAttribute("objectNames")
complexationIdx = np.array([
moleculeIds.index(x) for x in ids_complexation
]) # Complexes of proteins, and protein monomers
complexation_complexesIdx = np.array([
moleculeIds.index(x)
for x in ids_complexation_complexes
]) # Only complexes
equilibriumIdx = np.array(
[moleculeIds.index(x) for x in ids_equilibrium]
) # Complexes of proteins + small molecules, small molecules, protein monomers
equilibrium_complexesIdx = np.array([
moleculeIds.index(x) for x in ids_equilibrium_complexes
]) # Only complexes
translationIdx = np.array([
moleculeIds.index(x) for x in ids_translation
]) # Only protein monomers
transcriptionIdx = np.array([
moleculeIds.index(x) for x in ids_transcription
]) # Only protein rnas
ribosomeIdx = np.array(
[moleculeIds.index(x) for x in ribosome_subunit_ids])
rnapIdx = np.array(
[moleculeIds.index(x) for x in rnap_subunit_ids])
cPickle.dump(
complexationIdx,
open(
os.path.join(plotOutDir, "complexationIdx.pickle"),
"wb"))
cPickle.dump(
complexation_complexesIdx,
open(
os.path.join(plotOutDir,
"complexation_complexesIdx.pickle"),
"wb"))
cPickle.dump(
equilibriumIdx,
open(os.path.join(plotOutDir, "equilibriumIdx.pickle"),
"wb"))
cPickle.dump(
equilibrium_complexesIdx,
open(
os.path.join(plotOutDir,
"equilibrium_complexesIdx.pickle"),
"wb"))
cPickle.dump(
translationIdx,
open(os.path.join(plotOutDir, "translationIdx.pickle"),
"wb"))
cPickle.dump(
transcriptionIdx,
open(
os.path.join(plotOutDir,
"transcriptionIdx.pickle"), "wb"))
cPickle.dump(
ribosomeIdx,
open(os.path.join(plotOutDir, "ribosomeIdx.pickle"),
"wb"))
cPickle.dump(
rnapIdx,
open(os.path.join(plotOutDir, "rnapIdx.pickle"), "wb"))
first_build = False
bulkCounts = bulkMolecules.readColumn("counts")
bulkMolecules.close()
# Dissociate protein-protein complexes
bulkCounts[:, complexationIdx] += np.dot(
complexStoich,
bulkCounts[:, complexation_complexesIdx].transpose() *
-1).transpose().astype(np.int)
# Dissociate protein-small molecule complexes
bulkCounts[:, equilibriumIdx] += np.dot(
equilibriumStoich,
bulkCounts[:, equilibrium_complexesIdx].transpose() *
-1).transpose().astype(np.int)
# Load unique molecule data for RNAP and ribosomes
uniqueMoleculeCounts = TableReader(
os.path.join(simOutDir, "UniqueMoleculeCounts"))
ribosomeIndex = uniqueMoleculeCounts.readAttribute(
"uniqueMoleculeIds").index("activeRibosome")
rnaPolyIndex = uniqueMoleculeCounts.readAttribute(
"uniqueMoleculeIds").index("activeRnaPoly")
nActiveRibosome = uniqueMoleculeCounts.readColumn(
"uniqueMoleculeCounts")[:, ribosomeIndex]
nActiveRnaPoly = uniqueMoleculeCounts.readColumn(
"uniqueMoleculeCounts")[:, rnaPolyIndex]
uniqueMoleculeCounts.close()
# Add subunits from RNAP and ribosomes
ribosomeSubunitCounts = (
nActiveRibosome.reshape((nActiveRibosome.size, 1)) *
ribosome_subunit_stoich.reshape(
(1, ribosome_subunit_stoich.size)))
rnapSubunitCounts = (nActiveRnaPoly.reshape(
(nActiveRnaPoly.size, 1)) * rnap_subunit_stoich.reshape(
(1, rnap_subunit_stoich.size)))
bulkCounts[:, ribosomeIdx] += ribosomeSubunitCounts.astype(
np.int64)
bulkCounts[:, rnapIdx] += rnapSubunitCounts.astype(np.int64)
# Get protein monomer counts for calculations now that all complexes are dissociated
proteinMonomerCounts = bulkCounts[:, translationIdx]
ratioFinalToInitialCount = (
proteinMonomerCounts[-1, :] +
1) / (proteinMonomerCounts[0, :].astype(np.float) + 1)
ratioFinalToInitialCountMultigen[
gen_idx, :] = ratioFinalToInitialCount
cPickle.dump(
ratioFinalToInitialCountMultigen,
open(
os.path.join(plotOutDir,
"ratioFinalToInitialCountMultigen.pickle"),
"wb"))
ratioFinalToInitialCountMultigen = cPickle.load(
open(
os.path.join(plotOutDir,
"ratioFinalToInitialCountMultigen.pickle"), "rb"))
complexationIdx = cPickle.load(
open(os.path.join(plotOutDir, "complexationIdx.pickle"), "rb"))
complexation_complexesIdx = cPickle.load(
open(os.path.join(plotOutDir, "complexation_complexesIdx.pickle"),
"rb"))
equilibriumIdx = cPickle.load(
open(os.path.join(plotOutDir, "equilibriumIdx.pickle"), "rb"))
equilibrium_complexesIdx = cPickle.load(
open(os.path.join(plotOutDir, "equilibrium_complexesIdx.pickle"),
"rb"))
translationIdx = cPickle.load(
open(os.path.join(plotOutDir, "translationIdx.pickle"), "rb"))
transcriptionIdx = cPickle.load(
open(os.path.join(plotOutDir, "transcriptionIdx.pickle"), "rb"))
ribosomeIdx = cPickle.load(
open(os.path.join(plotOutDir, "ribosomeIdx.pickle"), "rb"))
rnapIdx = cPickle.load(
open(os.path.join(plotOutDir, "rnapIdx.pickle"), "rb"))
protein_index_of_interest = np.where(
np.logical_and(
ratioFinalToInitialCountMultigen > 1.6,
ratioFinalToInitialCountMultigen < 2.4).all(axis=0))[0]
first_gen_flat = ratioFinalToInitialCountMultigen[0, :] < 1.1
second_gen_burst = ratioFinalToInitialCountMultigen[1, :] > 10
rest_of_gens_decline = (ratioFinalToInitialCountMultigen[2:, :] <
1.1).all(axis=0)
logic_filter = np.logical_and.reduce(
(first_gen_flat, second_gen_burst, rest_of_gens_decline))
protein_index_of_interest_burst = np.where(logic_filter)[0]
try: # try block expects particular proteins to plot
protein_idx = protein_index_of_interest[0]
protein_idx_burst = protein_index_of_interest_burst[7]
except Exception as exc:
print "Error: %s" % exc
return
fig, axesList = plt.subplots(ncols=2, nrows=2, sharex=True)
expProtein_axis = axesList[0, 0]
expRna_axis = axesList[1, 0]
burstProtein_axis = axesList[0, 1]
burstRna_axis = axesList[1, 1]
mult = 3
fig_width = mm2inch(80) * mult
fig_height = mm2inch(50) * mult
fig.set_figwidth(fig_width)
fig.set_figheight(fig_height)
firstLine = True
plt.style.use('seaborn-deep')
color_cycle = plt.rcParams['axes.prop_cycle'].by_key()['color']
exponential_color = color_cycle[2]
subgen_color = color_cycle[0]
time_eachGen = []
y_min = np.full(4, np.inf)
y_max = np.zeros(4)
for gen_idx, simDir in enumerate(allDir):
simOutDir = os.path.join(simDir, "simOut")
time = TableReader(os.path.join(simOutDir,
"Main")).readColumn("time")
time_eachGen.append(time[0])
if gen_idx == 0:
startTime = time[0]
## READ DATA ##
# Read in bulk ids and counts
bulkMolecules = TableReader(
os.path.join(simOutDir, "BulkMolecules"))
bulkCounts = bulkMolecules.readColumn("counts")
bulkMolecules.close(
) # NOTE (John): .close() doesn't currently do anything
# Dissociate protein-protein complexes
bulkCounts[:, complexationIdx] += np.dot(
complexStoich,
bulkCounts[:, complexation_complexesIdx].transpose() *
-1).transpose().astype(np.int)
# Dissociate protein-small molecule complexes
bulkCounts[:, equilibriumIdx] += np.dot(
equilibriumStoich,
bulkCounts[:, equilibrium_complexesIdx].transpose() *
-1).transpose().astype(np.int)
# Load unique molecule data for RNAP and ribosomes
uniqueMoleculeCounts = TableReader(
os.path.join(simOutDir, "UniqueMoleculeCounts"))
ribosomeIndex = uniqueMoleculeCounts.readAttribute(
"uniqueMoleculeIds").index("activeRibosome")
rnaPolyIndex = uniqueMoleculeCounts.readAttribute(
"uniqueMoleculeIds").index("activeRnaPoly")
nActiveRibosome = uniqueMoleculeCounts.readColumn(
"uniqueMoleculeCounts")[:, ribosomeIndex]
nActiveRnaPoly = uniqueMoleculeCounts.readColumn(
"uniqueMoleculeCounts")[:, rnaPolyIndex]
uniqueMoleculeCounts.close()
# Add subunits from RNAP and ribosomes
ribosomeSubunitCounts = (nActiveRibosome.reshape(
(nActiveRibosome.size, 1)) * ribosome_subunit_stoich.reshape(
(1, ribosome_subunit_stoich.size)))
rnapSubunitCounts = (nActiveRnaPoly.reshape(
(nActiveRnaPoly.size, 1)) * rnap_subunit_stoich.reshape(
(1, rnap_subunit_stoich.size)))
bulkCounts[:,
ribosomeIdx] += ribosomeSubunitCounts.astype(np.int64)
bulkCounts[:, rnapIdx] += rnapSubunitCounts.astype(np.int64)
# Get protein monomer counts for calculations now that all complexes are dissociated
proteinMonomerCounts = bulkCounts[:, translationIdx]
rnaMonomerCounts = bulkCounts[:, transcriptionIdx]
if firstLine:
firstLine = False
LINEWIDTH = 1
time_minutes = time / 60.
axes = (expProtein_axis, burstProtein_axis, expRna_axis,
burstRna_axis)
counts = (
proteinMonomerCounts[:, protein_idx],
proteinMonomerCounts[:, protein_idx_burst],
rnaMonomerCounts[:, sim_data.relation.rnaIndexToMonomerMapping]
[:, protein_idx],
rnaMonomerCounts[:, sim_data.relation.rnaIndexToMonomerMapping]
[:, protein_idx_burst])
line_color = (
exponential_color,
subgen_color,
exponential_color,
subgen_color,
)
count_min = ( # better to acquire programatically, but would require loading data twice
600, 0, 0, 0)
count_scale = ( # same as above
2200 - 600, 30 - 0, 7 - 0, 1 - 0)
# These are *approximate* estimates of the axes sizes, using the
# size of the figure plus the fact that the subplots are 2x2.
# This is good enough since we primarily need the aspect ratio;
# however there is probably a programmatic way to get this info
# from the axes objects themselves.
axes_width = fig_width / 2
axes_height = fig_height / 2
# No easy way to know how long the total set of simulations
# will be without rewriting a lot of code, so assume that
# the total time is roughly the time of the current generation
# multiplied by the total number of generations.
rescaled_time = (time_minutes - time_minutes.min()) / (
(time_minutes.max() - time_minutes.min()) * n_gens)
for i, (ax, c, lc, cm, cs) in enumerate(
izip(axes, counts, line_color, count_min, count_scale)):
rescaled_counts = (c.astype(np.float64) - cm) / cs
# Roughly rescale the data into the plotted dimensions for
# better point downsampling
points = np.column_stack([
rescaled_time * axes_width, rescaled_counts * axes_height
])
RDP_THRESHOLD = 1e-5
keep = rdp(points, RDP_THRESHOLD)
x = time_minutes[keep]
y = c[keep]
if y.min() < y_min[i]:
y_min[i] = y.min()
if y.max() > y_max[i]:
y_max[i] = y.max()
ax.plot(x, y, color=lc, linewidth=LINEWIDTH)
expProtein_axis.set_ylim([y_min[0], y_max[0]])
burstProtein_axis.set_ylim([y_min[1], y_max[1]])
expRna_axis.set_ylim([y_min[2], y_max[2]])
burstRna_axis.set_ylim([y_min[3], y_max[3]])
expProtein_axis.set_title("Exponential dynamics: {}".format(
sim_data.process.translation.monomerData['id'][protein_idx][:-3]),
fontsize=9)
burstProtein_axis.set_title("Sub-generational dynamics: {}".format(
sim_data.process.translation.monomerData['id'][protein_idx_burst]
[:-3]),
fontsize=9)
expProtein_axis.set_ylabel("Protein\ncount", rotation=0, fontsize=9)
expRna_axis.set_ylabel("mRNA\ncount", rotation=0, fontsize=9)
time_eachGen.append(time[-1])
time_eachGen = np.array(time_eachGen)
expProtein_axis.set_xlim([startTime / 60., time[-1] / 60.])
burstProtein_axis.set_xlim([startTime / 60., time[-1] / 60.])
expRna_axis.set_xlim([startTime / 60., time[-1] / 60.])
burstRna_axis.set_xlim([startTime / 60., time[-1] / 60.])
whitePadSparklineAxis(expProtein_axis, False)
whitePadSparklineAxis(burstProtein_axis, False)
whitePadSparklineAxis(expRna_axis)
whitePadSparklineAxis(burstRna_axis)
expRna_axis.set_xticks(time_eachGen / 60.)
burstRna_axis.set_xticks(time_eachGen / 60.)
xlabel = GENS.tolist()
xlabel.append(GENS[-1] + 1)
expRna_axis.set_xticklabels(xlabel)
burstRna_axis.set_xticklabels(xlabel)
burstRna_axis.set_xlabel("Time (gens)", fontsize=9)
expRna_axis.set_xlabel("Time (gens)", fontsize=9)
axesList = axesList.flatten().tolist()
for axes in axesList:
for tick in axes.xaxis.get_major_ticks():
tick.label.set_fontsize(9)
for tick in axes.yaxis.get_major_ticks():
tick.label.set_fontsize(9)
plt.subplots_adjust(wspace=0.2, hspace=0.15)
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
for axes in axesList:
axes.set_xlabel("")
axes.set_ylabel("")
axes.set_title("")
axes.set_xticklabels([])
axes.set_yticklabels([])
exportFigure(plt, plotOutDir, plotOutFileName + "_stripped", 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)
## Identify sub-genenerationally transcribed genes
# Get all cells
ap = AnalysisPaths(seedOutDir, multi_gen_plot=True)
allDir = ap.get_cells()
# Load sim data
sim_data = cPickle.load(open(simDataFile, "rb"))
rnaIds = sim_data.process.transcription.rnaData["id"]
geneIds = sim_data.process.transcription.rnaData["geneId"]
# For each generation
nonzeroSumRnaCounts_allGens = []
for i, simDir in enumerate(allDir):
simOutDir = os.path.join(simDir, "simOut")
# Read counts of transcripts
bulkMolecules = TableReader(
os.path.join(simOutDir, "BulkMolecules"))
if i == 0:
moleculeIds = bulkMolecules.readAttribute("objectNames")
rnaIndices = np.array([moleculeIds.index(x) for x in rnaIds])
rnaCounts = bulkMolecules.readColumn("counts")[:, rnaIndices]
bulkMolecules.close()
# Sum counts over timesteps
sumRnaCounts = rnaCounts.sum(axis=0)
# Flag where the sum is nonzero (True if nonzero, False if zero)
nonzeroSumRnaCounts = sumRnaCounts != 0
nonzeroSumRnaCounts_allGens.append(nonzeroSumRnaCounts)
# Average (mean) over generations
nonzeroSumRnaCounts_allGens = np.array(nonzeroSumRnaCounts_allGens)
avgRnaCounts = nonzeroSumRnaCounts_allGens.mean(axis=0)
# Identify subgenerationally transcribed genes
subgenRnaIndices = np.where(
np.logical_and(avgRnaCounts != 0., avgRnaCounts != 1.))[0]
subgenRnaIds = rnaIds[subgenRnaIndices]
subgenMonomerIndices = [
np.where(
sim_data.process.translation.monomerData["rnaId"] == x)[0][0]
for x in subgenRnaIds
]
subgenMonomerIds = sim_data.process.translation.monomerData["id"][
subgenMonomerIndices]
# Identify subgenerationally transcribed genes that function as monomers
complexationMoleculeNames = sim_data.process.complexation.moleculeNames
subgenMonomerOnlyIds = [
x for x in subgenMonomerIds if x not in complexationMoleculeNames
]
subgenMonomersInComplexesIds = [
x for x in subgenMonomerIds if x in complexationMoleculeNames
]
## Identify complexes that subgenerationally transcribed genes participate in
subgenComplexIds = []
for complexId in sim_data.process.complexation.complexNames:
subunitIds = sim_data.process.complexation.getMonomers(
complexId)["subunitIds"]
if np.any([x in subgenMonomerIds for x in subunitIds]):
subgenComplexIds.append(complexId)
subgenComplexIds = list(set(subgenComplexIds))
## Identify functional units that have a 0 count for at least one timestep
proteinIds = list(set(subgenMonomerOnlyIds + subgenComplexIds))
if not len(proteinIds):
print "Returned -- No subgenerational functional units were found."
return
zeroAtLeastOnce = np.zeros(len(proteinIds), dtype=bool)
for i, simDir in enumerate(allDir):
simOutDir = os.path.join(simDir, "simOut")
# Read counts of proteins
bulkMolecules = TableReader(
os.path.join(simOutDir, "BulkMolecules"))
if i == 0:
moleculeIds = bulkMolecules.readAttribute("objectNames")
proteinIndices = np.array(
[moleculeIds.index(x) for x in proteinIds])
proteinCounts = bulkMolecules.readColumn("counts")[
SKIP_TIMESTEPS:, proteinIndices]
else:
proteinCounts = bulkMolecules.readColumn(
"counts")[:, proteinIndices]
bulkMolecules.close()
# Flag proteins with a minimum count of 0
minProteinCounts = np.min(proteinCounts, axis=0)
zeroAtLeastOnce[minProteinCounts == 0] = True
## Identify essential functional units
# Load validation data
validation_data = cPickle.load(open(validationDataFile, "rb"))
essentialGenes_genes = validation_data.essentialGenes.essentialGenes
essentialGenes_monomers = validation_data.essentialGenes.essentialProteins
# Flag essential monomers
essential = np.zeros(len(proteinIds), dtype=bool)
essential[[x in essentialGenes_monomers for x in proteinIds]] = True
# Flag essential complexes
subgenMonomerIdToComplexIds = {}
for complexId in subgenComplexIds:
subunitIds = sim_data.process.complexation.getMonomers(
complexId)["subunitIds"]
isEssential = np.any(
[x in essentialGenes_monomers for x in subunitIds])
if isEssential:
complexIndex = proteinIds.index(complexId)
essential[complexIndex] = True
# Add unadded complexes to subgenMonomerIdToComplexIds
for monomerId in subunitIds:
if monomerId not in subgenMonomerIdToComplexIds.keys():
subgenMonomerIdToComplexIds[monomerId] = []
subgenMonomerIdToComplexIds[monomerId].append(complexId)
## Plot
nrows = 2
ncols = 3
fig, axesList = plt.subplots(nrows, ncols, figsize=(11, 8.5))
[[axMonomers, axComplexes, axTotal],
[axMonomersEssential, axComplexesEssential,
axTotalEssential]] = axesList
xloc = np.arange(2)
width = 0.75
# Plot subgenerational genes that don't form complexes
args = {
"proteinIds": proteinIds,
"zeroAtLeastOnce": zeroAtLeastOnce,
"essential": essential,
"ax": axMonomers,
"axEssential": axMonomersEssential,
"xloc": xloc,
"width": width,
"functionalUnitIds": subgenMonomerOnlyIds,
}
plot(**args)
axMonomers.set_title("{0} monomeric\nfunctional units".format(
len(subgenMonomerOnlyIds)))
axMonomers.set_ylabel("# functional units")
axMonomersEssential.set_ylabel(
"# functional units\n(essential genes in blue)")
# Plot subgenerational genes that form complexes
args["ax"] = axComplexes
args["axEssential"] = axComplexesEssential
args["functionalUnitIds"] = subgenComplexIds
plot(**args)
axComplexes.set_title("{0} complexed\nfunctional units".format(
len(subgenComplexIds)))
# Plot subgenenerational functional units
args["ax"] = axTotal
args["axEssential"] = axTotalEssential
args["functionalUnitIds"] = []
plot(**args)
axTotal.set_title("{0} + {1} = {2}\nfunctional units".format(
len(subgenMonomerOnlyIds), len(subgenComplexIds), len(proteinIds)))
plt.subplots_adjust(wspace=0.3)
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
plt.close("all")
# Plot unlabeled version of final panel for Fig. 4E
fig, ax = plt.subplots(1, 1, figsize=(8.5, 11))
notAlwaysPresent = zeroAtLeastOnce.sum()
alwaysPresent = len(proteinIds) - notAlwaysPresent
notAlwaysPresentEssential = np.logical_and(zeroAtLeastOnce,
essential).sum()
alwaysPresentEssential = np.logical_and(
np.logical_not(zeroAtLeastOnce), essential).sum()
barAll = ax.bar(xloc + width, [alwaysPresent, notAlwaysPresent],
width,
color="lightgray")
barEssential = ax.bar(
xloc + width, [alwaysPresentEssential, notAlwaysPresentEssential],
width,
color="blue")
# Format
whitePadSparklineAxis(ax)
ax.set_xticks(xloc + width)
ax.set_xticklabels([])
ax.set_yticks([0] +
[x[0].get_height() for x in [barAll, barEssential]])
axRight = ax.twinx()
axRight.set_ylim(ax.get_ylim())
axRight.set_yticks([x[1].get_height() for x in [barAll, barEssential]])
axRight.spines["left"].set_visible(False)
axRight.spines["top"].set_visible(False)
axRight.spines["right"].set_position(("outward", 10))
axRight.spines["bottom"].set_position(("outward", 10))
for axis in [ax, axRight]:
axis.set_yticklabels([])
axis.tick_params(length=10.0)
plt.subplots_adjust(bottom=0.3, top=0.7, left=0.2, right=0.8)
exportFigure(plt, plotOutDir, "{0}_clean".format(plotOutFileName),
metadata)
plt.close("all")
if WRITE_TO_FILE:
with open(os.path.join(plotOutDir, "%s.tsv" % plotOutFileName),
"wb") as f:
f.write(
"gene\trna\tmonomer\tcomplex(es)\tzero_at_least_once\tessential\n"
)
for rnaId, monomerId in zip(subgenRnaIds, subgenMonomerIds):
# Get gene Id
rnaIndex = np.where(rnaIds == rnaId)[0][0]
geneId = geneIds[rnaIndex]
# Get IDs of complex(es)
if monomerId in subgenMonomerIdToComplexIds:
complexIds = subgenMonomerIdToComplexIds[monomerId]
functionalUnitIds = complexIds
else:
complexIds = None
functionalUnitIds = [monomerId]
# Were funcational units 0 at least once
isZero = []
for functionalUnitId in functionalUnitIds:
functionalUnitIndex = proteinIds.index(
functionalUnitId)
isZero.append(zeroAtLeastOnce[functionalUnitIndex])
# Is this gene essential
isEssential = geneId in essentialGenes_genes
# Write
f.write("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\n".format(
geneId, rnaId, monomerId, complexIds, isZero,
isEssential))
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()
if len(allDir) <= 1:
print "Skipping - this plot only runs for multigen sims"
return
sim_data = cPickle.load(open(simDataFile, "rb"))
validation_data = cPickle.load(open(validationDataFile, "rb"))
# Get mRNA data
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])
time = []
time_eachGen = []
transcribedBool = []
simulatedSynthProbs = []
transcriptionEvents = []
for gen, simDir in enumerate(allDir):
simOutDir = os.path.join(simDir, "simOut")
if gen < FIRST_N_GENS:
time += TableReader(os.path.join(
simOutDir, "Main")).readColumn("time").tolist()
time_eachGen.append(
TableReader(os.path.join(
simOutDir, "Main")).readColumn("time").tolist()[0])
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)
elif gen < FIRST_N_GENS:
transcriptionEvents = np.vstack(
(transcriptionEvents, (rnaInitEvent != 0)))
else:
pass
time = np.array(time)
time_eachGen.append(time[-1])
time_eachGen = np.array(time_eachGen)
transcribedBool = np.array(transcribedBool)
simulatedSynthProbs = np.array(simulatedSynthProbs)
indexingOrder = np.argsort(np.mean(simulatedSynthProbs, axis=0))
transcribedBoolOrdered = np.mean(transcribedBool,
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
])
plt.style.use('seaborn-deep')
color_cycle = plt.rcParams['axes.prop_cycle'].by_key()['color']
color_always = color_cycle[2]
color_never = color_cycle[4]
color_subgen = color_cycle[0]
colors = np.repeat(color_subgen, len(transcribedBoolOrdered))
colors[alwaysPresentIndexes] = color_always
colors[neverPresentIndexes] = color_never
always = transcribedBoolOrdered[alwaysPresentIndexes]
never = transcribedBoolOrdered[neverPresentIndexes]
sometimes = transcribedBoolOrdered[sometimesPresentIndexes]
alwaysTranscriptionEvents = []
for i in alwaysPresentIndexes:
v = (time[transcriptionEventsOrdered[:, i]] / 3600.).tolist()
if transcriptionEventsOrdered[:, i].sum() == 0:
v = [-1]
alwaysTranscriptionEvents.append(v)
neverTranscriptionEvents = []
for i in neverPresentIndexes:
v = (time[transcriptionEventsOrdered[:, i]] / 3600.).tolist()
if transcriptionEventsOrdered[:, i].sum() == 0:
v = [-1]
neverTranscriptionEvents.append(v)
sometimesTranscriptionEvents = []
for i in sometimesPresentIndexes:
v = (time[transcriptionEventsOrdered[:, i]] / 3600.).tolist()
if transcriptionEventsOrdered[:, i].sum() == 0:
v = [-1]
sometimesTranscriptionEvents.append(v)
# Plot
plt.figure(figsize=(11, 8))
scatterAxis = plt.subplot2grid((2, 4), (0, 0), colspan=3, rowspan=2)
histAxis = plt.subplot2grid((2, 4), (0, 3),
colspan=1,
rowspan=2,
sharey=scatterAxis)
scatterAxis.scatter(np.arange(len(transcribedBoolOrdered)),
transcribedBoolOrdered,
marker='o',
facecolors=colors,
edgecolors="none",
s=20)
scatterAxis.set_xlim([0, len(transcribedBoolOrdered)])
scatterAxis.set_ylim([0, 1])
whitePadSparklineAxis(scatterAxis)
N, bins, patches = histAxis.hist(transcribedBoolOrdered,
bins=len(allDir) + 1,
orientation='horizontal')
for i in xrange(1, len(patches) - 1):
plt.setp(patches[i], facecolor="none", edgecolor=color_subgen)
plt.setp(patches[0], facecolor="none", edgecolor=color_never)
plt.setp(patches[-1], facecolor="none", edgecolor=color_always)
whitePadSparklineAxis(histAxis)
histAxis.xaxis.tick_bottom()
histXmin, histXmax = histAxis.get_xlim()
scatterAxis.set_ylim([-.01, 1.01])
scatterAxis.set_yticklabels([])
scatterAxis.set_xticklabels([])
histAxis.set_xscale("log")
histAxis.set_xlim([10, 2000])
histAxis.set_yticklabels([])
histAxis.set_xticklabels([])
plt.subplots_adjust(wspace=0.6,
hspace=0.4,
right=0.9,
bottom=0.1,
left=0.1,
top=0.9)
exportFigure(plt, plotOutDir,
plotOutFileName + "_frequency_histogram__clean", metadata)
if PLOT_GENES_OF_INTEREST:
## Identifying particular genes
dcurId = "G7826_RNA[c]"
clppId = "EG10158_RNA[c]"
dcucId = "G6347_RNA[c]"
dcurIndex = np.where(mRnaIdsOrdered == dcurId)[0]
clppIndex = np.where(mRnaIdsOrdered == clppId)[0]
dcucIndex = np.where(mRnaIdsOrdered == dcucId)[0]
scatterAxis.scatter(dcurIndex,
transcribedBoolOrdered[dcurIndex],
facecolor="orange",
edgecolors="none")
scatterAxis.scatter(clppIndex,
transcribedBoolOrdered[clppIndex],
facecolor="orange",
edgecolors="none")
scatterAxis.scatter(dcucIndex,
transcribedBoolOrdered[dcucIndex],
facecolor="orange",
edgecolors="none")
scatterAxis.text(dcurIndex + 500,
transcribedBoolOrdered[dcurIndex],
"dcuR",
fontsize=18)
scatterAxis.text(clppIndex + 500,
transcribedBoolOrdered[clppIndex],
"clpP",
fontsize=18)
scatterAxis.text(dcucIndex + 500,
transcribedBoolOrdered[dcucIndex],
"dcuC",
fontsize=18)
exportFigure(
plt, plotOutDir,
plotOutFileName + "_frequency_histogram__clean__genes",
metadata)
plt.suptitle(
"Frequency of observing at least 1 transcript per generation",
fontsize=14)
scatterAxis.set_xlabel(
"Genes ordered by simulated synthesis probability", fontsize=12)
histAxis.text(histXmax * 1.6,
0,
"%s genes\n(%0.1f%%)" %
(len(never), 100. *
(len(never) / float(len(transcribedBoolOrdered)))),
fontsize=14,
verticalalignment="center",
color=color_never)
histAxis.text(histXmax * 1.6,
1,
"%s genes\n(%0.1f%%)" %
(len(always), 100. *
(len(always) / float(len(transcribedBoolOrdered)))),
fontsize=14,
verticalalignment="center",
color=color_always)
histAxis.text(histXmax * 1.6,
0.5,
"%s genes\n(%0.1f%%)" %
(len(sometimes), 100. *
(len(sometimes) / float(len(transcribedBoolOrdered)))),
fontsize=14,
verticalalignment="center",
color=color_subgen)
scatterAxis.set_yticklabels([0, 1])
scatterAxis.set_xticklabels([0, len(transcribedBoolOrdered)])
histAxis.set_xticks([10, 2000])
histAxis.set_xticklabels([10, 2000])
histAxis.set_yticklabels([0, 1])
exportFigure(plt, plotOutDir, plotOutFileName + "_frequency_histogram",
metadata)
plt.close("all")
plt.figure(figsize=(16, 8))
alwaysAxis = plt.subplot(2, 1, 1)
sometimesAxis = plt.subplot(2, 1, 2, sharex=alwaysAxis)
alwaysAxis.eventplot(alwaysTranscriptionEvents,
orientation="horizontal",
linewidths=2.,
linelengths=4.,
color=color_always)
alwaysAxis.set_xlim([0, time[-1] / 3600.])
alwaysAxis.set_ylim([-1, len(always)])
alwaysAxis.set_xticks([])
alwaysAxis.set_yticks([])
alwaysAxis.tick_params(top="off")
alwaysAxis.tick_params(bottom="off")
alwaysAxis.tick_params(axis="x", labelbottom='off')
sometimesAxis.eventplot(sometimesTranscriptionEvents,
orientation="horizontal",
linewidths=2.,
linelengths=4.,
color=color_subgen)
sometimesAxis.set_xlim([0, time[-1] / 3600.])
sometimesAxis.set_ylim([-1, len(sometimes)])
sometimesAxis.set_xticks([0, time[-1] / 3600.])
sometimesAxis.set_yticks([])
sometimesAxis.tick_params(top="off")
sometimesAxis.tick_params(which='both', direction='out', labelsize=12)
time_eachGen = np.array(time_eachGen)
sometimesAxis.set_xticks(time_eachGen / 3600.)
sometimesAxis.set_xticklabels([])
plt.subplots_adjust(wspace=0,
hspace=0,
right=0.9,
bottom=0.1,
left=0.1,
top=0.9)
exportFigure(plt, plotOutDir, plotOutFileName + "_eventplot__clean",
metadata)
plt.suptitle("Transcription initiation events", fontsize=14)
alwaysAxis.set_ylabel("Freq. = 1", fontsize=14)
sometimesAxis.set_ylabel("0 < Freq. < 1", fontsize=14)
sometimesAxis.set_xlabel("Time (gens)", fontsize=14)
sometimesAxis.set_xticklabels(np.arange(FIRST_N_GENS + 1))
exportFigure(plt, plotOutDir, plotOutFileName + "_eventplot", metadata)
plt.close("all")
# Essential genes figure
nRed = len(never)
nGreen = len(sometimes)
nBlue = len(always)
plotRed = 0
plotGreen = 0
plotBlue = 0
essentialGenes_rna = validation_data.essentialGenes.essentialRnas
for g in essentialGenes_rna:
i = np.where(mRnaIdsOrdered == str(g))[0][0]
f = transcribedBoolOrdered[i]
if f == 0.0:
plotRed += 1
elif f == 1.0:
plotBlue += 1
else:
plotGreen += 1
xloc = np.arange(3)
width = 0.8
plt.figure()
ax = plt.subplot(1, 1, 1)
ax.bar(xloc + width, [
plotRed / float(len(essentialGenes_rna)),
plotGreen / float(len(essentialGenes_rna)),
plotBlue / float(len(essentialGenes_rna))
],
width,
color=[color_never, color_subgen, color_always],
edgecolor="none")
whitePadSparklineAxis(ax)
ax.spines["left"].set_position(("outward", 0))
ax.set_yticks([0.0, 0.2, 0.4, 0.6, 0.8])
ax.set_yticklabels(["0%", "20%", "40%", "60%", "80%"])
ax.set_ylabel("Percentage of essential genes")
ax.set_xticks(xloc + 1.5 * width)
ax.set_xticklabels([
"%s / %s" % (plotRed, len(essentialGenes_rna)),
"%s / %s" % (plotGreen, len(essentialGenes_rna)),
"%s / %s" % (plotBlue, len(essentialGenes_rna))
])
ax.set_xlabel("Total number of essential genes: %s" %
len(essentialGenes_rna))
plt.subplots_adjust(right=0.9, bottom=0.15, left=0.2, top=0.9)
exportFigure(plt, plotOutDir, plotOutFileName + "_essential_genes",
metadata)
ax.set_yticklabels([])
ax.set_ylabel("")
remove_xaxis(ax)
exportFigure(plt, plotOutDir,
plotOutFileName + "_essential_genes__clean", metadata)
if PLOT_DENOMINATOR_N_EACH_FREQ_GROUP:
plt.figure()
ax = plt.subplot(1, 1, 1)
ax.bar(xloc + width, [
plotRed / float(nRed), plotGreen / float(nGreen),
plotBlue / float(nBlue)
],
width,
color=[color_never, color_subgen, color_always],
edgecolor="none")
whitePadSparklineAxis(ax)
ax.spines["left"].set_position(("outward", 0))
ax.set_yticks([0.0, 0.1, 0.2])
ax.set_yticklabels(["0%", "10%", "20%"])
ax.set_ylabel("Percentage of genes that are essential genes")
ax.set_xticks(xloc + 1.5 * width)
ax.set_xticklabels([
"%s / %s" % (plotRed, nRed),
"%s / %s" % (plotGreen, nGreen),
"%s / %s" % (plotBlue, nBlue)
])
plt.subplots_adjust(right=0.9, bottom=0.1, left=0.2, top=0.9)
exportFigure(plt, plotOutDir,
plotOutFileName + "_essential_genes_v2", metadata)
plt.close()
# Gene annotation/antibiotics figure
geneFunctions = validation_data.geneFunctions.geneFunctions
unknown = {"r": 0, "g": 0, "b": 0}
resistance = {"r": 0, "g": 0, "b": 0}
for frameID, function_ in geneFunctions.iteritems():
if function_ in [
"Unknown function", "Unclear/under-characterized"
]:
i = np.where([frameID in x for x in mRnaIdsOrdered])[0][0]
f = transcribedBoolOrdered[i]
if f == 0.0:
unknown["r"] += 1
elif f == 1.0:
unknown["b"] += 1
else:
unknown["g"] += 1
elif function_ in ["Antibiotic resistance", "Toxin/antitoxin"]:
i = np.where([frameID in x for x in mRnaIdsOrdered])[0][0]
f = transcribedBoolOrdered[i]
if f == 0.0:
resistance["r"] += 1
elif f == 1.0:
resistance["b"] += 1
else:
resistance["g"] += 1
nUnknown = np.sum([unknown[x] for x in ["r", "g", "b"]])
plt.figure()
ax = plt.subplot(1, 1, 1)
ax.bar(xloc + width, [
unknown["r"] / float(nUnknown), unknown["g"] / float(nUnknown),
unknown["b"] / float(nUnknown)
],
width,
color=[color_never, color_subgen, color_always],
edgecolor="none")
whitePadSparklineAxis(ax)
ax.spines["left"].set_position(("outward", 0))
ax.set_yticks([0.0, 0.2, 0.4, 0.6, 0.8])
ax.set_yticklabels(["0%", "20%", "40%", "60%", "80%"])
ax.set_ylabel("Percentage of poorly understood / annotated genes")
ax.set_xticks(xloc + 1.5 * width)
ax.set_xticklabels([
"%s / %s" % (unknown["r"], nUnknown),
"%s / %s" % (unknown["g"], nUnknown),
"%s / %s" % (unknown["b"], nUnknown)
])
ax.set_xlabel(
"Total number of poorly understood / annotated genes: %s" %
nUnknown)
plt.subplots_adjust(right=0.9, bottom=0.15, left=0.2, top=0.9)
exportFigure(plt, plotOutDir, plotOutFileName + "_unannotated",
metadata)
ax.set_yticklabels([])
ax.set_ylabel("")
remove_xaxis(ax)
exportFigure(plt, plotOutDir, plotOutFileName + "_unannotated__clean",
metadata)
if PLOT_DENOMINATOR_N_EACH_FREQ_GROUP:
plt.figure()
ax = plt.subplot(1, 1, 1)
ax.bar(xloc + width, [
unknown["r"] / float(nRed), unknown["g"] / float(nGreen),
unknown["b"] / float(nBlue)
],
width,
color=[color_never, color_subgen, color_always],
edgecolor="none")
whitePadSparklineAxis(ax)
ax.spines["left"].set_position(("outward", 0))
ax.set_yticks([0.0, 0.2, 0.4, 0.6])
ax.set_yticklabels(["0%", "20%", "40%", "60%"])
ax.set_ylabel(
"Percentage of genes that are poorly understood / annotated")
ax.set_xticks(xloc + 1.5 * width)
ax.set_xticklabels([
"%s / %s" % (unknown["r"], nRed),
"%s / %s" % (unknown["g"], nGreen),
"%s / %s" % (unknown["b"], nBlue)
])
plt.subplots_adjust(right=0.9, bottom=0.1, left=0.2, top=0.9)
exportFigure(plt, plotOutDir, plotOutFileName + "_v2", metadata)
plt.close()
nResistance = float(np.sum([resistance[x] for x in ["r", "g", "b"]]))
plt.figure()
ax = plt.subplot(1, 1, 1)
ax.bar(xloc + width, [
resistance["r"] / nResistance, resistance["g"] / nResistance,
resistance["b"] / nResistance
],
width,
color=[color_never, color_subgen, color_always],
edgecolor="none")
whitePadSparklineAxis(ax)
ax.spines["left"].set_position(("outward", 0))
ax.set_yticks([0.0, 0.2, 0.4, 0.6, 0.8])
ax.set_yticklabels(["0%", "20%", "40%", "60%", "80%"])
ax.set_ylabel("Percentage of antibiotic related genes")
ax.set_xticks(xloc + 1.5 * width)
ax.set_xticklabels([
"%s / %s" % (resistance["r"], int(nResistance)),
"%s / %s" % (resistance["g"], int(nResistance)),
"%s / %s" % (resistance["b"], int(nResistance))
])
ax.set_xlabel("Total number of antibiotic related genes: %s" %
int(nResistance))
plt.subplots_adjust(right=0.9, bottom=0.15, left=0.2, top=0.9)
exportFigure(plt, plotOutDir, plotOutFileName + "_antibiotic",
metadata)
ax.set_yticklabels([])
ax.set_ylabel("")
remove_xaxis(ax)
exportFigure(plt, plotOutDir, plotOutFileName + "_antibiotic__clean",
metadata)
if PLOT_DENOMINATOR_N_EACH_FREQ_GROUP:
plt.figure()
ax = plt.subplot(1, 1, 1)
ax.bar(xloc + width, [
resistance["r"] / float(nRed), resistance["g"] / float(nGreen),
resistance["b"] / float(nBlue)
],
width,
color=[color_never, color_subgen, color_always],
edgecolor="none")
whitePadSparklineAxis(ax)
ax.spines["left"].set_position(("outward", 0))
ax.set_yticks([0.0, 0.025])
ax.set_yticklabels(["0%", "2.5%"])
ax.set_ylabel("Percentage of genes that are antibiotic related")
ax.set_xticks(xloc + 1.5 * width)
ax.set_xticklabels([
"%s / %s" % (resistance["r"], nRed),
"%s / %s" % (resistance["g"], nGreen),
"%s / %s" % (resistance["b"], nBlue)
])
plt.subplots_adjust(right=0.9, bottom=0.1, left=0.2, top=0.9)
exportFigure(plt, plotOutDir, plotOutFileName + "_antibiotic_v2",
metadata)
plt.close()
def do_plot(self, inputDir, plotOutDir, plotOutFileName, simDataFile,
validationDataFile, metadata):
if not os.path.isdir(inputDir):
raise Exception, "inputDir does not currently exist as a directory"
if not os.path.exists(plotOutDir):
os.mkdir(plotOutDir)
# Get cells
ap = AnalysisPaths(inputDir, variant_plot=True)
if ap.n_variant != 9:
print "This plot expects all variants of meneParams"
return
# Get constants from wildtype variant
sim_data = cPickle.load(open(ap.get_variant_kb(4),
"rb")) # 4 is the wildtype variant
cellDensity = sim_data.constants.cellDensity
nAvogadro = sim_data.constants.nAvogadro
# Initialize variables
enzymeId = "MENE-CPLX[c]"
endProductIds = ["REDUCED-MENAQUINONE[c]", "CPD-12115[c]"]
TARGET_CONC = len(endProductIds) * TARGET_CONC_SINGLE
# Check for cache
cacheFileName = "%s.pickle" % plotOutFileName
CACHE_EXISTS = False
if os.path.exists(os.path.join(plotOutDir, cacheFileName)):
CACHE_EXISTS = True
if not CACHE_EXISTS:
# Investigate each variant
meneDepletion = np.zeros([ap.n_seed, ap.n_variant])
endProductDepletion = np.zeros([ap.n_seed, ap.n_variant])
for variant in xrange(ap.n_variant):
for seed in xrange(ap.n_seed):
cells = ap.get_cells(variant=[variant], seed=[seed])
timeMeneDepleted = [] # seconds
timeEndProdDepleted = [] # seconds
for i, simDir in enumerate(cells):
simOutDir = os.path.join(simDir, "simOut")
# Get molecule counts
bulkMolecules = TableReader(
os.path.join(simOutDir, "BulkMolecules"))
moleculeIds = bulkMolecules.readAttribute(
"objectNames")
meneIndex = moleculeIds.index(enzymeId)
meneCounts = bulkMolecules.readColumn(
"counts")[:, meneIndex]
endProductIndices = [
moleculeIds.index(x) for x in endProductIds
]
endProductCounts = bulkMolecules.readColumn(
"counts")[:, endProductIndices]
bulkMolecules.close()
# Compute time with zero counts of tetramer (MENE-CPLX)
timeStepSec = TableReader(
os.path.join(simOutDir,
"Main")).readColumn("timeStepSec")
meneDepletionIndices = np.where(meneCounts == 0)[0]
timeMeneDepleted.append(
timeStepSec[meneDepletionIndices].sum())
# Compute time with end products under the target concentration
mass = TableReader(os.path.join(
simOutDir,
"Mass")).readColumn("cellMass") * units.fg
volume = mass / cellDensity
endProductConcentrations = np.sum([
endProductCounts[:, col] / nAvogadro / volume
for col in xrange(endProductCounts.shape[1])
],
axis=0)
endProductDepletionIndices = np.where(
endProductConcentrations < (
(1 - THRESHOLD) * TARGET_CONC))[0]
timeEndProdDepleted.append(
timeStepSec[endProductDepletionIndices].sum())
# Record MENE-CPLX depletion
totalTime = TableReader(os.path.join(
simOutDir,
"Main")).readColumn("time")[-1] + timeStepSec[-1]
fractionMeneDepleted = np.sum(timeMeneDepleted) / totalTime
meneDepletion[seed, variant] = fractionMeneDepleted
# Record end product depletion
fractionEndProdDepleted = np.sum(
timeEndProdDepleted) / totalTime
endProductDepletion[seed,
variant] = fractionEndProdDepleted
# Cache
D = {"mene": meneDepletion, "endProduct": endProductDepletion}
cPickle.dump(D, open(os.path.join(plotOutDir, cacheFileName),
"wb"))
else:
D = cPickle.load(
open(os.path.join(plotOutDir, cacheFileName), "rb"))
meneDepletion = D["mene"]
endProductDepletion = D["endProduct"]
# Compute average and standard deviations
meneDepletion_avg = np.average(meneDepletion, axis=0)
meneDepletion_std = np.std(meneDepletion, axis=0)
endProductDepletion_avg = np.average(endProductDepletion, axis=0)
endProductDepletion_std = np.std(endProductDepletion, axis=0)
# Plot
fig, axesList = plt.subplots(2, 1, figsize=(8, 8))
ax1, ax2 = axesList
xvals = np.arange(ap.n_variant)
fig.suptitle("Sensitivity Analysis: menE depletion")
for ax, avg, std in zip(axesList,
[meneDepletion_avg, endProductDepletion_avg],
[meneDepletion_std, endProductDepletion_std]):
ax.scatter(xvals,
avg,
edgecolor="none",
clip_on=False,
s=MARKERSIZE)
ax.errorbar(xvals,
avg,
yerr=std,
color="b",
linewidth=1,
clip_on=False,
fmt="o",
capsize=4,
capthick=1,
markeredgecolor="none")
ax1.set_title("MenE tetramer depletion", fontsize=FONTSIZE)
ax2.set_title("Menaquinone products depletion", fontsize=FONTSIZE)
xlabels = [
"1/10 x", "1/8 x", "1/4 x", "1/2 x", "1 x", "2 x", "4 x", "8 x",
"10 x"
]
title_tags = [
"counts = 0",
"<%s percent of wildtype" % (THRESHOLD * 100)
]
for i, ax in enumerate([ax1, ax2]):
ax.set_ylabel("Fraction of Time\n%s" % title_tags[i],
fontsize=FONTSIZE)
ax.set_xlabel("Factor of increase of menE synthesis probability",
fontsize=FONTSIZE)
ax.set_xlim([-0.25, 8.25])
whitePadSparklineAxis(ax)
ax.set_xticks(xvals)
ax.set_xticklabels(xlabels)
ax.set_yticks([0, 1])
plt.subplots_adjust(hspace=1, wspace=1, top=0.9, bottom=0.1)
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
plt.close("all")
# Plot clean versions for figure
FIRST = True
for avg, std, filename in zip(
[meneDepletion_avg, endProductDepletion_avg],
[meneDepletion_std, endProductDepletion_std],
["mene", "menaquinone"]):
fig, ax = plt.subplots(1, 1, figsize=(10, 3))
ax.scatter(xvals,
avg,
edgecolor="none",
clip_on=False,
s=MARKERSIZE)
ax.errorbar(xvals,
avg,
yerr=std,
color="b",
linewidth=1,
clip_on=False,
fmt="o",
capsize=4,
capthick=1,
markeredgecolor="none")
ax.set_xlim([-0.25, 8.25])
if FIRST:
FIRST = False
whitePadSparklineAxis(ax, False)
else:
whitePadSparklineAxis(ax)
ax.set_xticks(xvals)
ax.set_xticklabels([])
ax.set_yticks([0, 1])
ax.set_yticklabels([])
exportFigure(plt, plotOutDir, plotOutFileName + "_%s" % filename,
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"))
cellDensity = sim_data.constants.cellDensity
rnaIds = sim_data.process.transcription.rnaData["id"]
enzyme_rna_transcription_index = np.where(
rnaIds == ENZYME_RNA_ID)[0][0]
simOutDir = os.path.join(allDir[0], "simOut")
bulk_molecules_reader = TableReader(
os.path.join(simOutDir, "BulkMolecules"))
fba_results_reader = TableReader(os.path.join(simOutDir, "FBAResults"))
moleculeIDs = bulk_molecules_reader.readAttribute("objectNames")
reactionIDs = np.array(fba_results_reader.readAttribute("reactionIDs"))
enzyme_complex_index = moleculeIDs.index(ENZYME_COMPLEX_ID)
enzyme_monomer_index = moleculeIDs.index(ENZYME_MONOMER_ID)
enzyme_rna_counts_index = moleculeIDs.index(ENZYME_RNA_ID)
metabolite_indexes = [moleculeIDs.index(x) for x in METABOLITE_IDS]
reaction_index = np.where(reactionIDs == ENZYME_REACTION_ID)[0][0]
# Initialize arrays
time = []
enzyme_fluxes = []
enzyme_complex_counts = []
enzyme_monomer_counts = []
enzyme_rna_counts = []
enzyme_rna_init_events = []
metabolite_counts = np.empty((0, len(METABOLITE_IDS)))
cellMass = []
dryMass = []
timeStepSec = []
generationTicks = [0.]
n_transcription_init_events_per_gen = []
enzyme_complex_avg_counts = []
for simDir in allDir:
simOutDir = os.path.join(simDir, "simOut")
main_reader = TableReader(os.path.join(simOutDir, "Main"))
mass_reader = TableReader(os.path.join(simOutDir, "Mass"))
bulk_molecules_reader = TableReader(
os.path.join(simOutDir, "BulkMolecules"))
fba_results_reader = TableReader(
os.path.join(simOutDir, "FBAResults"))
rnap_data_reader = TableReader(os.path.join(simOutDir, "RnapData"))
time.extend(main_reader.readColumn("time").tolist())
generationTicks.append(time[-1])
timeStepSec.extend(main_reader.readColumn("timeStepSec").tolist())
cellMass.extend(mass_reader.readColumn("cellMass").tolist())
dryMass.extend(mass_reader.readColumn("dryMass").tolist())
molecule_counts = bulk_molecules_reader.readColumn("counts")
enzyme_monomer_counts.extend(
molecule_counts[:, enzyme_monomer_index].tolist())
enzyme_rna_counts.extend(
molecule_counts[:, enzyme_rna_counts_index].tolist())
enzyme_complex_counts_this_gen = molecule_counts[:,
enzyme_complex_index]
enzyme_complex_counts.extend(
enzyme_complex_counts_this_gen.tolist())
enzyme_complex_avg_counts.append(
np.mean(enzyme_complex_counts_this_gen))
metabolite_counts = np.vstack(
(metabolite_counts, molecule_counts[:, metabolite_indexes]))
reactionFluxes = np.array(
fba_results_reader.readColumn("reactionFluxes"))
enzyme_fluxes.extend(reactionFluxes[:, reaction_index].tolist())
rna_init_events_this_gen = rnap_data_reader.readColumn(
"rnaInitEvent")[:, enzyme_rna_transcription_index]
enzyme_rna_init_events.extend(rna_init_events_this_gen.tolist())
n_transcription_init_events_per_gen.append(
np.sum(rna_init_events_this_gen))
coefficient = (units.fg * np.array(dryMass)) / (
units.fg * np.array(cellMass)) * (timeStepSec *
units.s) * cellDensity
enzyme_fluxes = (((COUNTS_UNITS / VOLUME_UNITS) * enzyme_fluxes) /
coefficient).asNumber(units.mmol / units.g / units.h)
# Convert time to hours
time = np.array(time)
time_hours = time / 3600.
# Plot
plt.figure(figsize=(11, 8.5))
plt.suptitle("O-succinylbenzoate-CoA ligase downstream behaviors",
fontsize=FONTSIZE)
# Define axes
rnaInitAxis = plt.subplot(6, 1, 1)
rnaAxis = plt.subplot(6, 1, 2, sharex=rnaInitAxis)
monomerAxis = plt.subplot(6, 1, 3, sharex=rnaInitAxis)
complexAxis = plt.subplot(6, 1, 4, sharex=rnaInitAxis)
fluxAxis = plt.subplot(6, 1, 5, sharex=rnaInitAxis)
metAxis = plt.subplot(6, 1, 6)
# Plot transcription initiation events
rnaInitAxis.plot(time_hours, enzyme_rna_init_events, c="b")
rnaInitAxis.set_ylabel(r"$menE$" + "\n transcription\nevents",
fontsize=FONTSIZE,
rotation=0)
rnaInitAxis.yaxis.set_label_coords(-.1, 0.25)
rnaInitAxis.set_xlim([time_hours[0], time_hours[-1]])
whitePadSparklineAxis(rnaInitAxis, xAxis=False)
rnaInitAxis.set_yticks([0, 1])
rnaAxis.plot(time_hours, enzyme_rna_counts, c="b")
rnaAxis.set_ylabel("menE mRNA\ncounts", fontsize=FONTSIZE, rotation=0)
rnaAxis.yaxis.set_label_coords(-.1, 0.25)
whitePadSparklineAxis(rnaAxis, xAxis=False)
rnaAxis.set_yticks([0, max(enzyme_rna_counts)])
monomerAxis.plot(time_hours, enzyme_monomer_counts, c="b")
monomerAxis.set_ylabel("MenE monomer\ncounts",
fontsize=FONTSIZE,
rotation=0)
monomerAxis.yaxis.set_label_coords(-.1, 0.25)
whitePadSparklineAxis(monomerAxis, xAxis=False)
monomerAxis.set_yticks([0, 4, max(enzyme_monomer_counts)])
complexAxis.plot(time_hours, enzyme_complex_counts, c="b")
complexAxis.set_ylabel("MenE tetramer\ncounts",
fontsize=FONTSIZE,
rotation=0)
complexAxis.yaxis.set_label_coords(-.1, 0.25)
whitePadSparklineAxis(complexAxis, xAxis=False)
complexAxis.set_yticks([0, max(enzyme_complex_counts)])
fluxAxis.plot(time_hours, enzyme_fluxes, c="b")
fluxAxis.set_ylabel("SUCBZL flux\n(mmol/gDCW/hour)",
fontsize=FONTSIZE,
rotation=0)
fluxAxis.yaxis.set_label_coords(-.1, 0.25)
whitePadSparklineAxis(fluxAxis, xAxis=False)
fluxAxis.set_yticks([min(enzyme_fluxes), max(enzyme_fluxes)])
metAxis.plot(time_hours, np.sum(metabolite_counts, axis=1), c="b")
metAxis.set_ylabel("End product\ncounts",
fontsize=FONTSIZE,
rotation=0)
metAxis.yaxis.set_label_coords(-.1, 0.25)
metAxis.set_xlabel("Time (hour)\ntickmarks at each new generation",
fontsize=FONTSIZE)
metAxis.set_ylim([metAxis.get_ylim()[0] * 0.2, metAxis.get_ylim()[1]])
metAxis.set_xlim([time_hours[0], time_hours[-1]])
whitePadSparklineAxis(metAxis)
metAxis.set_yticklabels(
["%0.1e" % metAxis.get_ylim()[0],
"%0.1e" % metAxis.get_ylim()[1]])
metAxis.set_xticks(np.array(generationTicks) / 3600.)
xticklabels = np.repeat(" ", len(generationTicks))
xticklabels[0] = "0"
xticklabels[-1] = "%0.2f" % (time_hours[-1])
metAxis.set_xticklabels(xticklabels)
noComplexIndexes = np.where(np.array(enzyme_complex_counts) == 0)[0]
patchStart = []
patchEnd = []
if len(noComplexIndexes):
prev = noComplexIndexes[0]
patchStart.append(prev)
for i in noComplexIndexes:
if np.abs(i - prev) > 1:
patchStart.append(i)
patchEnd.append(prev)
prev = i
patchEnd.append(prev)
axesList = [
rnaInitAxis, rnaAxis, monomerAxis, complexAxis, fluxAxis, metAxis
]
for axis in axesList:
axis.tick_params(labelsize=LABELSIZE)
for i in xrange(len(patchStart)):
width = time_hours[patchEnd[i]] - time_hours[patchStart[i]]
if width <= 0.1:
continue
height = axis.get_ylim()[1] - axis.get_ylim()[0]
axis.add_patch(
patches.Rectangle(
(time_hours[patchStart[i]], axis.get_ylim()[0]),
width,
height,
alpha=0.25,
color="gray",
linewidth=0.))
plt.subplots_adjust(hspace=0.5,
right=0.9,
bottom=0.1,
left=0.15,
top=0.9)
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
# Get clean version of plot
for a in axesList:
clearLabels(a)
plt.suptitle("")
metAxis.set_xticklabels([])
metAxis.set_xlabel("")
exportFigure(plt, plotOutDir, plotOutFileName + "__clean", "")
plt.close("all")
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
ap = AnalysisPaths(variantDir, cohort_plot=True)
allDir = ap.get_cells()
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")
try:
massListener = TableReader(os.path.join(simOutDir, "Mass"))
cellMass = massListener.readColumn("cellMass")
dryMass = massListener.readColumn("dryMass")
massListener.close()
except Exception as e:
print(e)
continue
# skip if no data
if cellMass.shape is ():
continue
coefficient = dryMass / cellMass * 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 = []
rxn_order = []
for rxn, toyaFlux in toyaFluxesDict.iteritems():
rxn_order.append(rxn)
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)))
outlier_indicies = np.zeros(len(toyaReactions), bool)
outlier_indicies[rxn_order.index(
'SUCCINATE-DEHYDROGENASE-UBIQUINONE-RXN-SUC/UBIQUINONE-8//FUM/CPD-9956.31.'
)] = True
outlier_indicies[rxn_order.index('ISOCITDEH-RXN')] = True
toyaVsReactionAve = np.array(toyaVsReactionAve)
rWithAll = pearsonr(toyaVsReactionAve[:, 0], toyaVsReactionAve[:, 1])
rWithoutOutliers = pearsonr(toyaVsReactionAve[~outlier_indicies, 0],
toyaVsReactionAve[~outlier_indicies, 1])
plt.figure(figsize=(3.5, 3.5))
ax = plt.axes()
plt.title(
"Central Carbon Metabolism Flux, Pearson R = %.4f, p = %s\n(%.4f, %s without outliers)"
% (rWithAll[0], rWithAll[1], rWithoutOutliers[0],
rWithoutOutliers[1]),
fontsize=6)
plt.errorbar(toyaVsReactionAve[:, 1],
toyaVsReactionAve[:, 0],
xerr=toyaVsReactionAve[:, 3],
yerr=toyaVsReactionAve[:, 2],
fmt="none",
ecolor="k",
alpha=0.5,
linewidth=0.5)
ylim = plt.ylim()
plt.plot([ylim[0], ylim[1]], [ylim[0], ylim[1]], color="k")
plt.plot(toyaVsReactionAve[~outlier_indicies, 1],
toyaVsReactionAve[~outlier_indicies, 0],
"ob",
markeredgewidth=0.1,
alpha=0.9)
plt.plot(toyaVsReactionAve[outlier_indicies, 1],
toyaVsReactionAve[outlier_indicies, 0],
"o",
color='#ed713a',
markeredgewidth=0.1,
alpha=0.9)
plt.xlabel("Toya 2010 Reaction Flux [mmol/g/hr]")
plt.ylabel("Mean WCM Reaction Flux [mmol/g/hr]")
ax = plt.axes()
whitePadSparklineAxis(ax)
xlim = [-20, 30]
ylim = [-20, 70]
ax.set_xlim(xlim)
ax.set_ylim(ylim)
ax.set_xticks(range(int(xlim[0]), int(xlim[1]) + 1, 10))
ax.set_yticks(range(int(ylim[0]), int(ylim[1]) + 1, 10))
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
ax.set_xlabel("")
ax.set_ylabel("")
ax.set_title("")
ax.set_xticklabels([])
ax.set_yticklabels([])
exportFigure(plt, plotOutDir, plotOutFileName + "_stripped", metadata)
plt.close("all")
def do_plot(self, inputDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata):
if not os.path.isdir(inputDir):
raise Exception, "inputDir does not currently exist as a directory"
if not os.path.exists(plotOutDir):
os.mkdir(plotOutDir)
# Get cells
ap = AnalysisPaths(inputDir, variant_plot = True)
if ap.n_variant != len(FACTORS):
print("This plot expects all variants of subgen_expression")
return
# Get constants from wildtype variant
sim_data = cPickle.load(open(ap.get_variant_kb(4), "rb")) # 4 is the wildtype variant
cellDensity = sim_data.constants.cellDensity
nAvogadro = sim_data.constants.nAvogadro
metabolite_target = sim_data.process.metabolism.concDict[METABOLITE_ID]
metabolite_threshold = (THRESHOLD * metabolite_target).asNumber(CONC_UNITS)
# Investigate each variant
enzyme_depletion = np.zeros([ap.n_seed, ap.n_variant])
metabolite_depletion = np.zeros([ap.n_seed, ap.n_variant])
for variant in xrange(ap.n_variant):
for seed in xrange(ap.n_seed):
cells = ap.get_cells(variant=[variant], seed=[seed])
time_enzyme_depleted = [] # seconds
time_metabolite_depleted = [] # seconds
for i, simDir in enumerate(cells):
simOutDir = os.path.join(simDir, "simOut")
main_reader = TableReader(os.path.join(simOutDir, "Main"))
mass_reader = TableReader(os.path.join(simOutDir, "Mass"))
# Get molecule counts
(enzyme_counts, metabolite_counts) = read_bulk_molecule_counts(simOutDir, (ENZYME_IDS, [METABOLITE_ID]))
# Compute time with zero counts of enzyme
time_step_sec = main_reader.readColumn("timeStepSec")
time_enzyme_depleted.append(time_step_sec[np.sum(enzyme_counts, axis=1) == 0].sum())
# Compute time with end products under the target concentration
mass = units.fg * mass_reader.readColumn("cellMass")
volume = mass / cellDensity
metabolite_conc = (1 / nAvogadro / volume * metabolite_counts).asNumber(CONC_UNITS)
time_metabolite_depleted.append(time_step_sec[metabolite_conc < metabolite_threshold].sum())
# Record MENE-CPLX depletion
total_time = main_reader.readColumn("time")[-1] + time_step_sec[-1]
fraction_enzyme_depleted = np.sum(time_enzyme_depleted) / total_time
enzyme_depletion[seed, variant] = fraction_enzyme_depleted
# Record end product depletion
fraction_metabolite_depleted = np.sum(time_metabolite_depleted) / total_time
metabolite_depletion[seed, variant] = fraction_metabolite_depleted
# Compute average and standard deviations
metabolite_depletion_avg = np.average(metabolite_depletion, axis = 0)
metabolite_depletion_std = np.std(metabolite_depletion, axis = 0)
enzyme_depletion_avg = np.average(enzyme_depletion, axis = 0)
enzyme_depletion_std = np.std(enzyme_depletion, axis = 0)
# Plot
fig, axesList = plt.subplots(2, 1, figsize = (8, 8))
ax1, ax2 = axesList
xvals = np.arange(ap.n_variant)
fig.suptitle("Sensitivity Analysis: pabB depletion")
for ax, avg, std in zip(axesList, [metabolite_depletion_avg, enzyme_depletion_avg], [metabolite_depletion_std, enzyme_depletion_std]):
ax.scatter(xvals, avg, edgecolor = "none", clip_on = False, s = MARKERSIZE)
ax.errorbar(xvals, avg, yerr = std, color = "b", linewidth = 1, clip_on = False, fmt = "o", capsize = 4, capthick = 1, markeredgecolor = "none")
ax1.set_title("Enzyme depletion", fontsize = FONTSIZE)
ax2.set_title("Metabolite depletion", fontsize = FONTSIZE)
xlabels = ["1/10 x", "1/8 x", "1/4 x", "1/2 x", "1 x", "2 x", "4 x", "8 x", "10 x"]
title_tags = ["counts = 0", "<%s%% of wildtype" % (THRESHOLD * 100)]
for i, ax in enumerate([ax1, ax2]):
ax.set_ylabel("Fraction of Time\n%s" % title_tags[i], fontsize = FONTSIZE)
ax.set_xlabel("Factor of change of pabB synthesis probability", fontsize = FONTSIZE)
ax.set_xlim([-0.25, 8.25])
whitePadSparklineAxis(ax)
ax.set_xticks(xvals)
ax.set_xticklabels(xlabels)
ax.set_yticks([0, 1])
plt.subplots_adjust(hspace = 1, wspace = 1, top = 0.9, bottom = 0.1)
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
plt.close("all")
# Plot clean versions for figure
FIRST = True
for avg, std, filename in zip([metabolite_depletion_avg, enzyme_depletion_avg], [metabolite_depletion_std, enzyme_depletion_std], ["pabB", "methylene-thf"]):
fig, ax = plt.subplots(1, 1, figsize = (10, 3))
ax.scatter(xvals, avg, edgecolor = "none", clip_on = False, s = MARKERSIZE)
ax.errorbar(xvals, avg, yerr = std, color = "b", linewidth = 1, clip_on = False, fmt = "o", capsize = 4, capthick = 1, markeredgecolor = "none")
ax.set_xlim([-0.25, 8.25])
if FIRST:
FIRST = False
whitePadSparklineAxis(ax, False)
else:
whitePadSparklineAxis(ax)
ax.set_xticks(xvals)
ax.set_xticklabels([])
ax.set_yticks([0, 1])
ax.set_yticklabels([])
exportFigure(plt, plotOutDir, plotOutFileName + "_%s" % filename, 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, 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"))
rxnStoich = sim_data.process.metabolism.reactionStoich
reactants = [
"GLC[p]",
"GLC-6-P[c]",
"FRUCTOSE-6P[c]",
"FRUCTOSE-16-DIPHOSPHATE[c]",
"DIHYDROXY-ACETONE-PHOSPHATE[c]",
"GAP[c]",
"DPG[c]",
"G3P[c]",
"2-PG[c]",
"PHOSPHO-ENOL-PYRUVATE[c]",
"PYRUVATE[c]",
"ACETYL-COA[c]",
"CIT[c]",
"CIS-ACONITATE[c]",
"THREO-DS-ISO-CITRATE[c]",
"2-KETOGLUTARATE[c]",
"SUC-COA[c]",
"SUC[c]",
"FUM[c]",
"MAL[c]",
"GLC-6-P[c]",
"D-6-P-GLUCONO-DELTA-LACTONE[c]",
"CPD-2961[c]",
"RIBULOSE-5P[c]",
"RIBULOSE-5P[c]",
"XYLULOSE-5-PHOSPHATE[c]",
"D-SEDOHEPTULOSE-7-P[c]",
"FRUCTOSE-6P[c]",
"WATER[c]",
"SER[c]",
"ACETYLSERINE[c]",
"H**O-CYS[c]",
"GLT[c]",
"GLT[c]",
"INDOLE[c]",
"HISTIDINAL[c]",
"PYRUVATE[c]",
"L-ALPHA-ALANINE[c]",
"GLT[c]",
"GLT[c]",
"GLT[c]",
"L-ASPARTATE[c]",
"O-PHOSPHO-L-HOMOSERINE[c]",
"MESO-DIAMINOPIMELATE[c]",
"L-ARGININO-SUCCINATE[c]",
"2-KETOGLUTARATE[c]",
"GLT[c]",
"L-DELTA1-PYRROLINE_5-CARBOXYLATE[c]",
"DGMP[c]",
"DGDP[c]",
"DGMP[c]",
"DAMP[c]",
"DADP[c]",
"DAMP[c]",
"TMP[c]",
"TDP[c]",
"TMP[c]",
"DUMP[c]",
"DUDP[c]",
"DUMP[c]",
"DCMP[c]",
"DCDP[c]",
"DCMP[c]",
"GMP[c]",
"GDP[c]",
"GMP[c]",
"AMP[c]",
"ADP[c]",
"AMP[c]",
"UMP[c]",
"UDP[c]",
"UMP[c]",
"CMP[c]",
"CDP[c]",
"CMP[c]",
"GDP[c]",
"GTP[c]",
"ADP[c]",
"ATP[c]",
"TMP[c]",
"UDP[c]",
"UTP[c]",
"UTP[c]",
"CDP[c]",
"CTP[c]",
"GUANOSINE[c]",
"CYTIDINE[c]",
"OROTIDINE-5-PHOSPHATE[c]",
]
products = [
"GLC-6-P[c]",
"FRUCTOSE-6P[c]",
"FRUCTOSE-16-DIPHOSPHATE[c]",
"DIHYDROXY-ACETONE-PHOSPHATE[c]",
"GAP[c]",
"DPG[c]",
"G3P[c]",
"2-PG[c]",
"PHOSPHO-ENOL-PYRUVATE[c]",
"PYRUVATE[c]",
"ACETYL-COA[c]",
"CIT[c]",
"CIS-ACONITATE[c]",
"THREO-DS-ISO-CITRATE[c]",
"2-KETOGLUTARATE[c]",
"SUC-COA[c]",
"SUC[c]",
"FUM[c]",
"MAL[c]",
"OXALACETIC_ACID[c]",
"D-6-P-GLUCONO-DELTA-LACTONE[c]",
"CPD-2961[c]",
"RIBULOSE-5P[c]",
"XYLULOSE-5-PHOSPHATE[c]",
"RIBOSE-5P[c]",
"D-SEDOHEPTULOSE-7-P[c]",
"ERYTHROSE-4P[c]",
"ERYTHROSE-4P[c]",
"SER[c]",
"GLY[c]",
"CYS[c]",
"MET[c]",
"TYR[c]",
"PHE[c]",
"TRP[c]",
"HIS[c]",
"L-ALPHA-ALANINE[c]",
"VAL[c]",
"LEU[c]",
"ILE[c]",
"L-ASPARTATE[c]",
"ASN[c]",
"THR[c]",
"LYS[c]",
"ARG[c]",
"GLT[c]",
"GLN[c]",
"PRO[c]",
"DGDP[c]",
"DGTP[c]",
"DGTP[c]",
"DADP[c]",
"DATP[c]",
"DATP[c]",
"TDP[c]",
"TTP[c]",
"TTP[c]",
"DUDP[c]",
"DUTP[c]",
"DUTP[c]",
"DCDP[c]",
"DCTP[c]",
"DCTP[c]",
"GDP[c]",
"GTP[c]",
"GTP[c]",
"ADP[c]",
"ATP[c]",
"ATP[c]",
"UDP[c]",
"UTP[c]",
"UTP[c]",
"CDP[c]",
"CTP[c]",
"CTP[c]",
"DGDP[c]",
"DGTP[c]",
"DADP[c]",
"DATP[c]",
"DUMP[c]",
"DUDP[c]",
"DUTP[c]",
"CTP[c]",
"DCDP[c]",
"DCTP[c]",
"GMP[c]",
"CMP[c]",
"UMP[c]",
]
transports = [
"GLC[p]",
"OXYGEN-MOLECULE[p]",
]
fullReactants = [
"2-KETOGLUTARATE[c]",
"L-DELTA1-PYRROLINE_5-CARBOXYLATE[c]",
"DADP[c]",
]
fullProducts = [
"SUC-COA[c]",
"PRO[c]",
"DATP[c]",
]
figAll = plt.figure(figsize = (17, 22))
figFull = plt.figure()
subplotRows = 10
subplotCols = 9
firstGen = True
for simDir in allDir:
simOutDir = os.path.join(simDir, "simOut")
mainListener = TableReader(os.path.join(simOutDir, "Main"))
initialTime = mainListener.readAttribute("initialTime")
time = mainListener.readColumn("time")
mainListener.close()
# ignore initial and final points to avoid moving average edge effects
timeIdx = np.logical_and(np.logical_and(np.logical_or(np.logical_and(time >= START, time < SHIFT - MA_WIDTH), np.logical_and(time > SHIFT + BURNIN, time <= END)), time > initialTime + BURNIN), time < time[-MA_WIDTH])
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) # units - g/L
fbaResults = TableReader(os.path.join(simOutDir, "FBAResults"))
reactionIDs = fbaResults.readAttribute("reactionIDs")
flux = (COUNTS_UNITS / MASS_UNITS / TIME_UNITS) * (fbaResults.readColumn("reactionFluxes").T / coefficient).T
transportFluxes = fbaResults.readColumn("externalExchangeFluxes")
transportMolecules = fbaResults.readAttribute("externalMoleculeIDs")
fbaResults.close()
flux = flux.asNumber(units.mmol / units.g / units.h)
plt.figure(figAll.number)
for idx, transport in enumerate(transports):
ax = plt.subplot(subplotRows, subplotCols, idx + 1)
if firstGen:
ax.axhline(0, color = "#aaaaaa", linewidth = 0.25)
ax.axvline(SHIFT, color = "#aaaaaa", linewidth = 0.25)
ax.set_title("Transport for %s" % (transport,), fontsize = 4)
ax.tick_params(axis = "both", labelsize = 4)
if transport in transportMolecules:
maFlux = np.array([np.convolve(-transportFluxes[:, transportMolecules.index(transport)], np.ones(MA_WIDTH) / MA_WIDTH, mode = "same")]).T
ax.plot(time[timeIdx], maFlux[timeIdx], color = "b", linewidth = 0.5)
for idx, (reactant, product) in enumerate(zip(reactants, products)):
ax = plt.subplot(subplotRows, subplotCols, idx + 1 + len(transports))
totalFlux = np.zeros_like(flux[:, 0])
for rxn in rxnStoich:
if reactant in rxnStoich[rxn] and product in rxnStoich[rxn]:
if rxnStoich[rxn][reactant] < 0 and rxnStoich[rxn][product] > 0:
direction = 1
elif rxnStoich[rxn][reactant] > 0 and rxnStoich[rxn][product] < 0:
direction = -1
else:
continue
totalFlux += flux[:, reactionIDs.index(rxn)] * direction
if firstGen:
ax.axhline(0, color = "#aaaaaa", linewidth = 0.25)
ax.axvline(SHIFT, color = "#aaaaaa", linewidth = 0.25)
ax.set_title("%s to %s" % (reactant, product), fontsize = 4)
ax.tick_params(axis = "both", labelsize = 4)
totalFlux = np.array([np.convolve(totalFlux, np.ones(MA_WIDTH) / MA_WIDTH, mode = "same")]).T
ax.plot(time[timeIdx], totalFlux[timeIdx], color = "b", linewidth = 0.5)
plt.figure(figFull.number)
for idx, (reactant, product) in enumerate(zip(fullReactants, fullProducts)):
ax = plt.subplot(3, 1, idx+1)
totalFlux = np.zeros_like(flux[:, 0])
for rxn in rxnStoich:
if reactant in rxnStoich[rxn] and product in rxnStoich[rxn]:
if rxnStoich[rxn][reactant] < 0 and rxnStoich[rxn][product] > 0:
direction = 1
elif rxnStoich[rxn][reactant] > 0 and rxnStoich[rxn][product] < 0:
direction = -1
else:
continue
totalFlux += flux[:, reactionIDs.index(rxn)] * direction
if firstGen:
ax.axhline(0, color = "#aaaaaa", linewidth = 0.25)
ax.axvline(SHIFT / 60, color = "#aaaaaa", linewidth = 0.25)
ax.set_title("%s to %s" % (reactant, product), fontsize = 4)
ax.tick_params(axis = "both", labelsize = 4)
totalFlux = np.array([np.convolve(totalFlux, np.ones(MA_WIDTH) / MA_WIDTH, mode = "same")]).T
ax.plot(time / 60, totalFlux, color = "b", linewidth = 0.5)
firstGen = False
plt.figure(figAll.number)
for i in range(subplotRows * subplotCols):
ax = plt.subplot(subplotRows, subplotCols, i + 1)
plt.minorticks_off()
whitePadSparklineAxis(ax)
xlim = ax.get_xlim()
ylim = ax.get_ylim()
ax.set_yticks([ylim[0], ylim[1]])
ax.set_xticks([xlim[0], xlim[1]])
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
for i in range(subplotRows * subplotCols):
ax = plt.subplot(subplotRows, subplotCols, i + 1)
ax.set_axis_off()
exportFigure(plt, plotOutDir, plotOutFileName + "_stripped", metadata)
plt.figure(figFull.number)
for i in range(3):
ax = plt.subplot(3, 1, i+1)
plt.minorticks_off()
whitePadSparklineAxis(ax)
bounds = ax.dataLim.bounds
xlim = [bounds[0], bounds[2]]
ylim = [bounds[1], bounds[3]]
ax.set_xticks(xlim)
ax.set_yticks(ylim)
ax.set_xlim(xlim)
ax.set_ylim(ylim)
exportFigure(plt, plotOutDir, plotOutFileName + "_full", 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)
mass = TableReader(os.path.join(simOutDir, "Mass"))
protein = mass.readColumn("proteinMass")
tRna = mass.readColumn("tRnaMass")
rRna = mass.readColumn("rRnaMass")
mRna = mass.readColumn("mRnaMass")
dna = mass.readColumn("dnaMass")
smallMolecules = mass.readColumn("smallMoleculeMass")
initialTime = TableReader(os.path.join(
simOutDir, "Main")).readAttribute("initialTime")
t = TableReader(os.path.join(simOutDir,
"Main")).readColumn("time") - initialTime
masses = np.vstack([
protein / protein[0],
rRna / rRna[0],
tRna / tRna[0],
mRna / mRna[0],
dna / dna[0],
smallMolecules / smallMolecules[0],
]).T
massLabels = ["Protein", "rRNA", "tRNA", "mRNA", "DNA", "Small Mol."]
plt.figure(figsize=(2, 2.5))
ax = plt.gca()
ax.set_prop_cycle(
plt.style.library['fivethirtyeight']['axes.prop_cycle'])
plt.plot(t / 60., masses, linewidth=1)
plt.xlabel("Time (min)")
plt.ylabel("Mass (normalized by t = 0 min)")
plt.title("Biomass components")
plt.legend(massLabels, loc="best")
plt.axhline(2, linestyle='--', color='k')
whitePadSparklineAxis(ax)
xticks = [0, t[-1] / 60]
yticks = [1, 2, 2.2]
ax.set_xlim(xticks)
ax.set_ylim((yticks[0], yticks[-1]))
ax.set_xticks(xticks)
ax.set_yticks(yticks)
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
ax.set_xlabel("")
ax.set_ylabel("")
ax.set_title("")
ax.set_xticklabels([])
ax.set_yticklabels([])
ax.legend_.remove()
exportFigure(plt, plotOutDir, plotOutFileName + "_stripped", 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)
# Read data from listeners
enzymeKinetics = TableReader(os.path.join(simOutDir, "EnzymeKinetics"))
actualConc = enzymeKinetics.readColumn("metaboliteConcentrations")[
1:, :]
enzymeKinetics.close()
fbaResults = TableReader(os.path.join(simOutDir, "FBAResults"))
targetConc = fbaResults.readColumn("targetConcentrations")[1:, :]
moleculeNames = np.array(
fbaResults.readAttribute("homeostaticTargetMolecules"))
fbaResults.close()
mainReader = TableReader(os.path.join(simOutDir, "Main"))
time = mainReader.readColumn("time")[1:] - mainReader.readAttribute(
"initialTime")
mainReader.close()
# Average concentrations over time for subplot 1
actualConcAve = np.nanmean(actualConc, axis=0)
targetConcAve = np.nanmean(targetConc, axis=0)
plt.figure(figsize=(8.5, 11))
# Plot average comparison with lines denoting order of magnitude
ax = plt.subplot(3, 1, 1)
ax.plot([-6, 6], [-6, 6], 'k')
ax.plot([-5, 6], [-6, 5], 'k')
ax.plot([-6, 5], [-5, 6], 'k')
ax.plot(np.log10(targetConcAve),
np.log10(actualConcAve),
"ob",
markeredgewidth=0,
alpha=0.25)
ax.set_xlabel("Log10(Target Concentration [mmol/L])", fontsize=8)
ax.set_ylabel("Log10(Actual Concentration [mmol/L])", fontsize=8)
whitePadSparklineAxis(ax)
xlim = ax.get_xlim()
ylim = ax.get_ylim()
ax.set_ylim(ylim[0] - 0.1, ylim[1])
ax.set_xlim(xlim[0] - 0.1, xlim[1])
ax.set_yticks(range(-6, int(ylim[1]) + 1, 2))
ax.set_xticks(range(-6, int(xlim[1]) + 1, 2))
ax.tick_params(axis='both', which='major', labelsize=6)
# Plot ratio of actual concentration to target concentration
ratio = np.log10(actualConc / targetConc)
ax = plt.subplot(3, 1, 2)
ax.plot(time / 60, ratio)
ax.set_xlabel("Time (min)", fontsize=8)
ax.set_ylabel("Log10(Concentration to Target)", fontsize=8)
ax.tick_params(axis='both', which='major', labelsize=6)
# Plot outliers of ratio
means = np.mean(ratio, axis=0)
mean = np.mean(means)
std = np.std(means)
outliers = np.unique(
np.where((ratio[1:, :] > mean + std / 2)
| (ratio[1:, :] < mean - std / 2))[1])
idx = outliers[np.argsort(means[outliers])][::-1]
ax = plt.subplot(3, 1, 3)
if len(idx):
ax.plot(time / 60, ratio[:, idx])
ax.legend(moleculeNames[idx], fontsize=6)
ax.set_xlabel("Time (min)", fontsize=8)
ax.set_ylabel("Log10(Concentration to Target)", fontsize=8)
ax.tick_params(axis='both', which='major', labelsize=6)
plt.tight_layout()
exportFigure(plt, plotOutDir, plotOutFileName)
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"))
cellDensity = sim_data.constants.cellDensity
rna_ids = sim_data.process.transcription.rnaData["id"]
enzyme_rna_transcription_indexes = np.array([
np.where(rna_ids == enzyme_rna_id)[0][0]
for enzyme_rna_id in ENZYME_RNA_IDS
])
simOutDir = os.path.join(allDir[0], "simOut")
bulk_molecules_reader = TableReader(os.path.join(simOutDir, "BulkMolecules"))
fba_results_reader = TableReader(os.path.join(simOutDir, "FBAResults"))
moleculeIDs = bulk_molecules_reader.readAttribute("objectNames")
reactionIDs = np.array(fba_results_reader.readAttribute("reactionIDs"))
enzyme_rna_count_indexes = np.array([
moleculeIDs.index(enzyme_rna_id)
for enzyme_rna_id in ENZYME_RNA_IDS
])
enzyme_monomer_indexes = np.array([
moleculeIDs.index(enzyme_monomer_id)
for enzyme_monomer_id in ENZYME_MONOMER_IDS
])
enzyme_complex_indexes = np.array([
moleculeIDs.index(enzyme_complex_id)
for enzyme_complex_id in ENZYME_COMPLEX_IDS
])
reaction_indexes = np.array([
np.where(reactionIDs == reaction_id)[0][0]
for reaction_id in ENZYME_REACTION_IDS
])
metabolite_index = moleculeIDs.index(METABOLITE_ID)
# Initialize arrays
time = []
enzyme_rna_init_events = np.empty((0, len(ENZYME_RNA_IDS)))
enzyme_rna_counts = np.empty((0, len(ENZYME_RNA_IDS)))
enzyme_total_monomer_counts = np.empty((0, len(ENZYME_RNA_IDS)))
enzyme_complex_counts = np.empty((0, len(ENZYME_COMPLEX_IDS)))
enzyme_fluxes = np.empty((0, len(ENZYME_REACTION_IDS)))
metabolite_counts = []
cellMass = []
dryMass = []
timeStepSec = []
generationTicks = []
proteins_produced_per_gen = np.empty((0, len(ENZYME_RNA_IDS)))
average_complex_counts_per_gen = []
first_gen = True
for simDir in allDir:
simOutDir = os.path.join(simDir, "simOut")
main_reader = TableReader(os.path.join(simOutDir, "Main"))
mass_reader = TableReader(os.path.join(simOutDir, "Mass"))
bulk_molecules_reader = TableReader(
os.path.join(simOutDir, "BulkMolecules"))
fba_results_reader = TableReader(os.path.join(simOutDir, "FBAResults"))
rnap_data_reader = TableReader(os.path.join(simOutDir, "RnapData"))
time.extend(main_reader.readColumn("time").tolist())
if first_gen:
generationTicks.extend([time[0], time[-1]])
first_gen = False
else:
generationTicks.append(time[-1])
timeStepSec.extend(main_reader.readColumn("timeStepSec").tolist())
cellMass.extend(mass_reader.readColumn("cellMass").tolist())
dryMass.extend(mass_reader.readColumn("dryMass").tolist())
rna_init_events_this_gen = rnap_data_reader.readColumn(
"rnaInitEvent")[:, enzyme_rna_transcription_indexes]
enzyme_rna_init_events = np.vstack((
enzyme_rna_init_events, rna_init_events_this_gen))
molecule_counts = bulk_molecules_reader.readColumn("counts")
enzyme_rna_counts = np.vstack((
enzyme_rna_counts,
molecule_counts[:, enzyme_rna_count_indexes]))
enzyme_monomer_counts_this_gen = molecule_counts[:, enzyme_monomer_indexes]
enzyme_complex_counts_this_gen = molecule_counts[:, enzyme_complex_indexes]
enzyme_total_monomer_counts_this_gen = (
enzyme_monomer_counts_this_gen +
enzyme_complex_counts_this_gen.sum(axis=1)[:, None])
enzyme_total_monomer_counts = np.vstack((
enzyme_total_monomer_counts,
enzyme_total_monomer_counts_this_gen))
enzyme_complex_counts = np.vstack((
enzyme_complex_counts,
enzyme_complex_counts_this_gen))
proteins_produced_per_gen = np.vstack((
proteins_produced_per_gen,
(enzyme_total_monomer_counts_this_gen[-1, :] -
enzyme_total_monomer_counts_this_gen[0, :])
))
average_complex_counts_per_gen.append(
enzyme_complex_counts_this_gen.sum(axis=1).mean())
metabolite_counts.extend(molecule_counts[:, metabolite_index])
reactionFluxes = np.array(fba_results_reader.readColumn("reactionFluxes"))
enzyme_fluxes = np.vstack((
enzyme_fluxes, reactionFluxes[:, reaction_indexes]))
# Sum reaction fluxes and convert units
flux_conversion_coeff = (units.fg * np.array(dryMass)) / (units.fg * np.array(cellMass)) * (timeStepSec * units.s) * cellDensity
enzyme_fluxes = (((COUNTS_UNITS / VOLUME_UNITS) * enzyme_fluxes.sum(axis=1)) / flux_conversion_coeff).asNumber(units.mmol / units.g / units.h)
# Convert time to hours
time = np.array(time)
time_hours = time / 3600.
# Add counts of complexed monomers to monomer counts
enzyme_total_monomer_counts += enzyme_complex_counts.sum(axis=1)[:, None]
# Plot
plt.figure(figsize = (14, 8.5))
plt.style.use('seaborn-deep')
color_cycle = plt.rcParams['axes.prop_cycle'].by_key()['color']
plt.suptitle(
"4-amino-4-deoxychorismate synthase downstream effects",
fontsize = FONTSIZE)
pre_merge_colors = [color_cycle[0], color_cycle[2]]
post_merge_color = color_cycle[3]
# Define axes
rna_init_axis = plt.subplot(6, 1, 1)
rna_axis = plt.subplot(6, 1, 2, sharex=rna_init_axis)
monomer_axis = plt.subplot(6, 1, 3, sharex=rna_init_axis)
complex_axis = plt.subplot(6, 1, 4, sharex=rna_init_axis)
flux_axis = plt.subplot(6, 1, 5, sharex=rna_init_axis)
met_axis = plt.subplot(6, 1, 6, sharex=rna_init_axis)
# Plot transcription initiation events
rna_init_axis.set_prop_cycle(color=pre_merge_colors)
rna_init_axis.plot(time_hours, enzyme_rna_init_events)
rna_init_axis.set_ylabel("Transcription\nevents", fontsize = FONTSIZE, rotation = 0)
rna_init_axis.yaxis.set_label_coords(-.12, 0.25)
rna_init_axis.set_xlim([time_hours[0], time_hours[-1]])
rna_init_axis.set_ylim([0, 1])
whitePadSparklineAxis(rna_init_axis, xAxis = False)
# Print average transcription frequency of each gene
for rna_id, prob in zip(ENZYME_RNA_IDS,
enzyme_rna_init_events.sum(axis=0)/len(proteins_produced_per_gen)):
print("%s transcription frequency: %.3f"%(rna_id, prob))
rna_axis.set_prop_cycle(color=pre_merge_colors)
rna_axis.plot(time_hours, enzyme_rna_counts)
rna_axis.set_ylabel("mRNA\ncounts", fontsize = FONTSIZE, rotation = 0)
rna_axis.yaxis.set_label_coords(-.12, 0.25)
rna_axis.set_ylim([0, np.max(enzyme_rna_counts)])
whitePadSparklineAxis(rna_axis, xAxis = False)
monomer_axis.set_prop_cycle(color=pre_merge_colors)
monomer_axis.plot(time_hours, enzyme_total_monomer_counts)
monomer_axis.set_ylabel("Protein monomer\ncounts", fontsize = FONTSIZE, rotation = 0)
monomer_axis.yaxis.set_label_coords(-.12, 0.25)
monomer_axis.set_ylim([0, np.max(enzyme_total_monomer_counts)])
whitePadSparklineAxis(monomer_axis, xAxis = False)
# Print average number of protein produced per generation
for rna_id, count in zip(ENZYME_RNA_IDS,
proteins_produced_per_gen.mean(axis=0)):
print("%s average proteins produced per gen: %.2f" % (rna_id, count))
complex_axis.plot(time_hours, enzyme_complex_counts.sum(axis=1), color=post_merge_color)
complex_axis.set_ylabel("Protein complex\ncounts", fontsize = FONTSIZE, rotation = 0)
complex_axis.yaxis.set_label_coords(-.12, 0.25)
complex_axis.set_ylim([0, np.max(enzyme_complex_counts.sum(axis=1))])
whitePadSparklineAxis(complex_axis, xAxis = False)
# Print mean and std of average complex counts in each gen
print("Complex counts average: %.2f" % (np.array(average_complex_counts_per_gen).mean(),))
print("Complex counts std: %.2f" % (np.array(average_complex_counts_per_gen).std(),))
flux_axis.plot(time_hours, enzyme_fluxes, color=post_merge_color)
flux_axis.set_yscale("symlog", linthreshy=FLUX_LINEAR_THRESHOLD)
flux_axis.set_ylabel("PABASYN-RXN\n(reverse)\ntotal flux\n(mmol/gDCW/hour)", fontsize = FONTSIZE, rotation = 0)
flux_axis.yaxis.set_label_coords(-.12, 0.25)
flux_axis.set_ylim([0, np.max(enzyme_fluxes)])
whitePadSparklineAxis(flux_axis, xAxis=False)
flux_axis.get_yaxis().set_tick_params(which='minor', size=0)
flux_axis.get_xaxis().set_tick_params(which='minor', width=0)
flux_max = flux_axis.get_ylim()[1]
flux_axis.set_yticks([0, FLUX_LINEAR_THRESHOLD, flux_max])
flux_axis.set_yticklabels(["0", "%0.0e"%(FLUX_LINEAR_THRESHOLD, ), "%.2f"%(flux_max, )])
met_axis.plot(time_hours, metabolite_counts, color=post_merge_color)
met_axis.set_ylabel("End product\ncounts", fontsize = FONTSIZE, rotation = 0)
met_axis.yaxis.set_label_coords(-.12, 0.25)
met_axis.set_xlabel("Time (hour)\ntickmarks at each new generation", fontsize = FONTSIZE)
met_axis.set_ylim([0, np.max(metabolite_counts)])
met_axis.set_xlim([time_hours[0], time_hours[-1]])
whitePadSparklineAxis(met_axis)
met_axis.set_yticklabels([0, "%0.1e" % met_axis.get_ylim()[1]])
met_axis.set_xticks(np.array(generationTicks) / 3600.)
xticklabels = np.repeat(" ", len(generationTicks))
xticklabels[0] = "%0.2f" % (time_hours[0])
xticklabels[-1] = "%0.2f" % (time_hours[-1])
met_axis.set_xticklabels(xticklabels)
# Add patches to indicate absence of complexes
noComplexIndexes = np.where(np.array(enzyme_complex_counts.sum(axis=1)) == 0)[0]
patchStart = []
patchEnd = []
if len(noComplexIndexes):
prev = noComplexIndexes[0]
patchStart.append(prev)
for i in noComplexIndexes:
if np.abs(i - prev) > 1:
patchStart.append(i)
patchEnd.append(prev)
prev = i
patchEnd.append(prev)
axesList = [rna_init_axis, rna_axis, monomer_axis, complex_axis, flux_axis, met_axis]
for axis in axesList:
axis.tick_params(labelsize = LABELSIZE)
for i in xrange(len(patchStart)):
width = time_hours[patchEnd[i]] - time_hours[patchStart[i]]
if width <= 0.1:
continue
height = axis.get_ylim()[1] - axis.get_ylim()[0]
axis.add_patch(patches.Rectangle((time_hours[patchStart[i]], axis.get_ylim()[0]), width, height, alpha = 0.25, color = "gray", linewidth = 0.))
plt.subplots_adjust(hspace = 0.5, right = 0.9, bottom = 0.1, left = 0.15, top = 0.9)
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
# Get clean version of plot
for a in axesList:
clearLabels(a)
plt.suptitle("")
met_axis.set_xticklabels([])
met_axis.set_xlabel("")
exportFigure(plt, plotOutDir, plotOutFileName + "__clean", "")
plt.close("all")
def do_plot(self, inputDir, plotOutDir, plotOutFileName, simDataFile,
validationDataFile, metadata):
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)
if ap.n_generation == 1:
print "Need more data to create addedMass"
return
allScatter = plt.figure()
allScatter.set_figwidth(11)
allScatter.set_figheight(6)
xHist = plt.figure()
xHist.set_figwidth(11)
xHist.set_figheight(6)
yHist = plt.figure()
yHist.set_figwidth(11)
yHist.set_figheight(6)
plt.style.use('seaborn-deep')
color_cycle = plt.rcParams['axes.prop_cycle'].by_key()['color']
title_list = [
"Glucose minimal\n" + r"$\tau = $" + "44 min",
"Glucose minimal anaerobic\n" + r"$\tau = $" + "100 min",
"Glucose minimal + 20 amino acids\n" + r"$\tau = $" + "22 min"
]
plot = False
for varIdx in ap.get_variants():
if varIdx == 0:
plotIdx = 1
gen = [2, 3]
elif varIdx == 1:
plotIdx = 0
gen = [2, 3]
elif varIdx == 2:
plotIdx = 2
gen = [2, 3]
else:
continue
initial_masses = np.zeros(0)
final_masses = np.zeros(0)
all_cells = ap.get_cells(generation=gen, variant=[varIdx])
if len(all_cells) == 0:
continue
plot = True
fail = 0
for simDir in all_cells:
try:
simOutDir = os.path.join(simDir, "simOut")
mass = TableReader(os.path.join(simOutDir, "Mass"))
cellMass = mass.readColumn("dryMass")
initial_masses = np.hstack((initial_masses, cellMass[0]))
final_masses = np.hstack((final_masses, cellMass[-1]))
except Exception as e:
print e
fail += 1
added_masses = final_masses - initial_masses
all_scaled_initial_masses = initial_masses / initial_masses.mean()
all_scaled_added_masses = added_masses / added_masses.mean()
idxs_to_keep = np.where((0.6 < all_scaled_initial_masses)
& (all_scaled_initial_masses < 1.25)
& (0.45 < all_scaled_added_masses)
& (all_scaled_added_masses < 1.5))
scaled_initial_masses = all_scaled_initial_masses[idxs_to_keep]
scaled_added_masses = all_scaled_added_masses[idxs_to_keep]
nbins = 5
n, xbin = np.histogram(scaled_initial_masses, bins=nbins)
sy, xbin = np.histogram(scaled_initial_masses,
bins=nbins,
weights=scaled_added_masses)
sy2, xbin = np.histogram(scaled_initial_masses,
bins=nbins,
weights=scaled_added_masses *
scaled_added_masses)
mean = sy / n
std = np.sqrt(sy2 / (n - 1) - n * mean * mean / (n - 1))
slope, intercept, r_value, p_value, std_err = linregress(
scaled_initial_masses, scaled_added_masses)
# plot all scatter plots
plt.figure(allScatter.number)
ax = plt.subplot2grid((1, 3), (0, plotIdx))
ax.plot(scaled_initial_masses,
scaled_added_masses,
'.',
color="black",
alpha=0.2,
zorder=1,
markeredgewidth=0.0)
ax.errorbar(((xbin[1:] + xbin[:-1]) / 2),
mean,
yerr=std,
color="black",
linewidth=1,
zorder=2)
ax.plot(scaled_initial_masses,
slope * scaled_initial_masses + intercept,
color="blue")
ax.set_title(
title_list[varIdx] + ", n=%d, n*=%d" %
((len(all_cells) - fail), len(scaled_initial_masses)) + "\n" +
r"$m_{add}$=%.3f$\times$$m_{init}$ + %.3f" %
(slope, intercept) + "\n" + "p-value=%0.2g" % p_value,
fontsize=FONT_SIZE)
ax.set_xlim([0.6, 1.25])
ax.set_ylim([0.45, 1.5])
ax.get_yaxis().get_major_formatter().set_useOffset(False)
ax.get_xaxis().get_major_formatter().set_useOffset(False)
if varIdx == 1:
ax.set_ylabel("Normed added mass", fontsize=FONT_SIZE)
ax.set_xlabel("Normed initial mass", fontsize=FONT_SIZE)
plt.subplots_adjust(bottom=0.2)
whitePadSparklineAxis(ax)
for tick in ax.yaxis.get_major_ticks():
tick.label.set_fontsize(FONT_SIZE)
for tick in ax.xaxis.get_major_ticks():
tick.label.set_fontsize(FONT_SIZE)
# plot stripped figure
fig = plt.figure()
fig.set_figwidth(1.73)
fig.set_figheight(1.18)
ax = plt.subplot2grid((1, 1), (0, 0))
ax.plot(scaled_initial_masses,
scaled_added_masses,
'.',
color=color_cycle[0],
alpha=0.2,
zorder=1,
markeredgewidth=0.0)
ax.set_title(title_list[varIdx] + ", n=%d, n*=%d" %
(len(all_cells) - fail, len(scaled_initial_masses)),
fontsize=FONT_SIZE)
ax.plot(scaled_initial_masses,
slope * scaled_initial_masses + intercept,
color='k')
ax.set_ylim([0.45, 1.5])
ax.get_yaxis().get_major_formatter().set_useOffset(False)
ax.get_xaxis().get_major_formatter().set_useOffset(False)
plt.subplots_adjust(bottom=0.2)
whitePadSparklineAxis(ax)
ax.tick_params(axis='x',
which='both',
bottom='off',
top='off',
labelbottom='off')
ax.tick_params(axis='y',
which='both',
left='off',
right='off',
labelleft='off')
ax.set_xlabel("")
ax.set_ylabel("")
plt.subplots_adjust(top=0.95,
bottom=3 * trim,
left=2 * trim,
right=0.95,
hspace=0,
wspace=0)
exportFigure(plt,
plotOutDir,
plotOutFileName + str(varIdx) + "_stripped",
metadata,
transparent=True)
# plot histogram for x-axis
plt.figure(xHist.number)
bins = 25
ax = plt.subplot2grid((1, 3), (0, plotIdx))
ax.hist(all_scaled_initial_masses, bins, color=color_cycle[0])
ax.axvline(x=0.6, color="k", linestyle="--")
ax.axvline(x=1.25, color="k", linestyle="--")
ax.set_title(title_list[varIdx] + "\n" + "[0.6, 1.25]",
fontsize=FONT_SIZE)
ax.yaxis.set_major_locator(MaxNLocator(integer=True))
ax.set_xlabel("Normed initial mass", fontsize=FONT_SIZE)
plt.subplots_adjust(bottom=0.2)
whitePadSparklineAxis(ax)
for tick in ax.yaxis.get_major_ticks():
tick.label.set_fontsize(FONT_SIZE)
for tick in ax.xaxis.get_major_ticks():
tick.label.set_fontsize(FONT_SIZE)
# plot histogram for y-axis
plt.figure(yHist.number)
ax = plt.subplot2grid((1, 3), (0, plotIdx))
ax.hist(all_scaled_added_masses, bins, color=color_cycle[0])
ax.axvline(x=0.45, color="k", linestyle="--")
ax.axvline(x=1.5, color="k", linestyle="--")
ax.set_title(title_list[varIdx] + "\n" + "[0.45, 1.5]",
fontsize=FONT_SIZE)
ax.yaxis.set_major_locator(MaxNLocator(integer=True))
ax.set_xlabel("Normed added mass", fontsize=FONT_SIZE)
plt.subplots_adjust(bottom=0.2)
whitePadSparklineAxis(ax)
for tick in ax.yaxis.get_major_ticks():
tick.label.set_fontsize(FONT_SIZE)
for tick in ax.xaxis.get_major_ticks():
tick.label.set_fontsize(FONT_SIZE)
if plot:
plt.figure(allScatter.number)
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
plt.figure(xHist.number)
exportFigure(plt,
plotOutDir,
plotOutFileName + "_histogram_scaled_initial_mass",
metadata,
transparent=True)
plt.figure(yHist.number)
exportFigure(plt,
plotOutDir,
plotOutFileName + "_histogram_scaled_added_mass",
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)
BUILD_CACHE = True
if os.path.exists(os.path.join(plotOutDir, "figure5D.pickle")):
BUILD_CACHE = False
enzymeComplexId = "MENE-CPLX[c]"
enzymeMonomerId = "O-SUCCINYLBENZOATE-COA-LIG-MONOMER[c]"
enzymeRnaId = "EG12437_RNA[c]"
reactionId = "O-SUCCINYLBENZOATE-COA-LIG-RXN"
metaboliteIds = ["REDUCED-MENAQUINONE[c]", "CPD-12115[c]"]
# Get all cells
ap = AnalysisPaths(seedOutDir, multi_gen_plot=True)
if 0 not in ap._path_data["seed"]:
print "Skipping -- figure5D only runs for seed 0"
return
allDir = ap.get_cells(seed=[0])
sim_data = cPickle.load(open(simDataFile, "rb"))
cellDensity = sim_data.constants.cellDensity
nAvogadro = sim_data.constants.nAvogadro
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")
enzymeComplexIndex = moleculeIds.index(enzymeComplexId)
enzymeMonomerIndex = moleculeIds.index(enzymeMonomerId)
enzymeRnaIndex = moleculeIds.index(enzymeRnaId)
metaboliteIndexes = [moleculeIds.index(x) for x in metaboliteIds]
bulkMolecules.close()
if BUILD_CACHE:
time = []
enzymeFluxes = []
enzymeComplexCounts = []
enzymeMonomerCounts = []
enzymeRnaCounts = []
enzymeRnaInitEvent = []
metaboliteCounts = np.array([])
cellMass = []
dryMass = []
timeStepSec = []
generationTicks = [0.]
nTranscriptionInitEventsPerGen = []
nAvgTetramersPerGen = []
for gen, simDir in enumerate(allDir):
simOutDir = os.path.join(simDir, "simOut")
time += TableReader(os.path.join(
simOutDir, "Main")).readColumn("time").tolist()
generationTicks.append(time[-1])
timeStepSec += TableReader(os.path.join(
simOutDir, "Main")).readColumn("timeStepSec").tolist()
cellMass += TableReader(os.path.join(
simOutDir, "Mass")).readColumn("cellMass").tolist()
dryMass += TableReader(os.path.join(
simOutDir, "Mass")).readColumn("dryMass").tolist()
bulkMolecules = TableReader(
os.path.join(simOutDir, "BulkMolecules"))
moleculeCounts = bulkMolecules.readColumn("counts")
enzymeComplexCountsInThisGen = moleculeCounts[:,
enzymeComplexIndex].tolist(
)
enzymeMonomerCounts += moleculeCounts[:,
enzymeMonomerIndex].tolist(
)
enzymeRnaCounts += moleculeCounts[:, enzymeRnaIndex].tolist()
enzymeComplexCounts += enzymeComplexCountsInThisGen
nAvgTetramersPerGen.append(
np.mean(enzymeComplexCountsInThisGen))
if gen == 0:
metaboliteCounts = moleculeCounts[:, metaboliteIndexes]
else:
metaboliteCounts = np.vstack(
(metaboliteCounts, moleculeCounts[:,
metaboliteIndexes]))
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"))
rnaInitEventsInThisGen = rnapDataReader.readColumn(
"rnaInitEvent")[:,
np.where(
rnaIds == enzymeRnaId)[0][0]].tolist()
rnapDataReader.close()
enzymeRnaInitEvent += rnaInitEventsInThisGen
nTranscriptionInitEventsPerGen.append(
np.sum(rnaInitEventsInThisGen))
time = np.array(time)
cPickle.dump(
{
"time": time,
"enzymeRnaInitEvent": enzymeRnaInitEvent,
"enzymeRnaCounts": enzymeRnaCounts,
"enzymeMonomerCounts": enzymeMonomerCounts,
"enzymeComplexCounts": enzymeComplexCounts,
"enzymeFluxes": enzymeFluxes,
"metaboliteCounts": metaboliteCounts,
"dryMass": dryMass,
"cellMass": cellMass,
"timeStepSec": timeStepSec,
"generationTicks": generationTicks,
"nTranscriptionInitEventsPerGen":
nTranscriptionInitEventsPerGen, # storing value to report in paper
"nAvgTetramersPerGen":
nAvgTetramersPerGen, # storing value to report in paper
},
open(os.path.join(plotOutDir, "figure5D.pickle"), "wb"))
else:
D = cPickle.load(
open(os.path.join(plotOutDir, "figure5D.pickle"), "r"))
time = D["time"]
enzymeRnaInitEvent = D["enzymeRnaInitEvent"]
enzymeRnaCounts = D["enzymeRnaCounts"]
enzymeMonomerCounts = D["enzymeMonomerCounts"]
enzymeComplexCounts = D["enzymeComplexCounts"]
enzymeFluxes = D["enzymeFluxes"]
metaboliteCounts = D["metaboliteCounts"]
dryMass = D["dryMass"]
cellMass = D["cellMass"]
timeStepSec = D["timeStepSec"]
generationTicks = D["generationTicks"]
cellVolume = units.g * np.array(cellMass) / cellDensity
coefficient = (units.fg * np.array(dryMass)) / (
units.fg * np.array(cellMass)) * cellDensity * (timeStepSec *
units.s)
enzymeFluxes = (((COUNTS_UNITS / VOLUME_UNITS) * enzymeFluxes) /
coefficient).asNumber(units.mmol / units.g / units.h)
averages = []
indices = [np.where(time == x)[0][0] for x in generationTicks]
for x in np.arange(len(indices) - 1):
avg = np.average(enzymeComplexCounts[indices[x]:indices[x + 1]])
averages.append(avg)
# Plot
fig = plt.figure(figsize=(11, 8.5))
plt.suptitle("O-succinylbenzoate-CoA ligase downstream behaviors",
fontsize=FONTSIZE)
rnaInitAxis = plt.subplot(6, 1, 1)
rnaAxis = plt.subplot(6, 1, 2, sharex=rnaInitAxis)
monomerAxis = plt.subplot(6, 1, 3, sharex=rnaInitAxis)
complexAxis = plt.subplot(6, 1, 4, sharex=rnaInitAxis)
fluxAxis = plt.subplot(6, 1, 5, sharex=rnaInitAxis)
metAxis = plt.subplot(6, 1, 6)
rnaInitLine = rnaInitAxis.plot(time / 3600., enzymeRnaInitEvent, c="b")
rnaInitAxis.set_ylabel(r"$menE$" + "\n transcription\nevents",
fontsize=FONTSIZE,
rotation=0)
rnaInitAxis.yaxis.set_label_coords(-.1, 0.25)
rnaInitAxis.set_xlim([time[0] / 3600., time[-1] / 3600.])
whitePadSparklineAxis(rnaInitAxis, xAxis=False)
rnaInitAxis.set_yticks([0, 1])
rnaLine = rnaAxis.plot(time / 3600., enzymeRnaCounts, c="b")
rnaAxis.set_ylabel("menE mRNA\ncounts", fontsize=FONTSIZE, rotation=0)
rnaAxis.yaxis.set_label_coords(-.1, 0.25)
whitePadSparklineAxis(rnaAxis, xAxis=False)
rnaAxis.set_yticks([0, max(enzymeRnaCounts)])
monomerLine = monomerAxis.plot(time / 3600.,
enzymeMonomerCounts,
c="b")
monomerAxis.set_ylabel("MenE monomer\ncounts",
fontsize=FONTSIZE,
rotation=0)
monomerAxis.yaxis.set_label_coords(-.1, 0.25)
whitePadSparklineAxis(monomerAxis, xAxis=False)
monomerAxis.set_yticks([0, 4, max(enzymeMonomerCounts)])
complexLine = complexAxis.plot(time / 3600.,
enzymeComplexCounts,
c="b")
complexAxis.set_ylabel("MenE tetramer\ncounts",
fontsize=FONTSIZE,
rotation=0)
complexAxis.yaxis.set_label_coords(-.1, 0.25)
whitePadSparklineAxis(complexAxis, xAxis=False)
complexAxis.set_yticks([0, max(enzymeComplexCounts)])
fluxLine = fluxAxis.plot(time / 3600., enzymeFluxes, c="b")
fluxAxis.set_ylabel("SUCBZL flux\n(mmol/gDCW/hour)",
fontsize=FONTSIZE,
rotation=0)
fluxAxis.yaxis.set_label_coords(-.1, 0.25)
whitePadSparklineAxis(fluxAxis, xAxis=False)
fluxAxis.set_yticks([min(enzymeFluxes), max(enzymeFluxes)])
metLine = metAxis.plot(time / 3600.,
np.sum(metaboliteCounts, axis=1),
c="b")
metAxis.set_ylabel("End product\ncounts",
fontsize=FONTSIZE,
rotation=0)
metAxis.yaxis.set_label_coords(-.1, 0.25)
metAxis.set_xlabel("Time (hour)\ntickmarks at each new generation",
fontsize=FONTSIZE)
metAxis.set_ylim([metAxis.get_ylim()[0] * 0.2, metAxis.get_ylim()[1]])
metAxis.set_xlim([time[0] / 3600., time[-1] / 3600.])
whitePadSparklineAxis(metAxis)
metAxis.set_yticklabels(
["%0.1e" % metAxis.get_ylim()[0],
"%0.1e" % metAxis.get_ylim()[1]])
metAxis.set_xticks(np.array(generationTicks) / 3600.)
xticklabels = np.repeat(" ", len(generationTicks))
xticklabels[0] = "0"
xticklabels[-1] = "%0.2f" % (time[-1] / 3600.)
metAxis.set_xticklabels(xticklabels)
noComplexIndexes = np.where(np.array(enzymeComplexCounts) == 0)[0]
patchStart = []
patchEnd = []
if len(noComplexIndexes):
prev = noComplexIndexes[0]
patchStart.append(prev)
for i in noComplexIndexes:
if np.abs(i - prev) > 1:
patchStart.append(i)
patchEnd.append(prev)
prev = i
patchEnd.append(prev)
axesList = [
rnaInitAxis, rnaAxis, monomerAxis, complexAxis, fluxAxis, metAxis
]
for axis in axesList:
axis.tick_params(labelsize=LABELSIZE)
for i in xrange(len(patchStart)):
width = time[patchEnd[i]] / 3600. - time[patchStart[i]] / 3600.
if width <= 0.1:
continue
height = axis.get_ylim()[1] - axis.get_ylim()[0]
axis.add_patch(
patches.Rectangle(
(time[patchStart[i]] / 3600., axis.get_ylim()[0]),
width,
height,
alpha=0.25,
color="gray",
linewidth=0.))
plt.subplots_adjust(hspace=0.5,
right=0.9,
bottom=0.1,
left=0.15,
top=0.9)
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
axesList = [
rnaInitAxis, rnaAxis, monomerAxis, complexAxis, fluxAxis, metAxis
]
for a in axesList:
clearLabels(a)
plt.suptitle("")
metAxis.set_xticklabels([])
metAxis.set_xlabel("")
exportFigure(plt, plotOutDir, plotOutFileName + "__clean", "")
plt.close("all")
if PLOT_DOWNSTREAM:
fig, axesList = plt.subplots(12, figsize=(11, 8.5))
plt.subplots_adjust(hspace=0.5,
right=0.95,
bottom=0.05,
left=0.15,
top=0.95)
enzymeIds = [
"MENE-CPLX[c]", "CPLX0-7882[c]", "CPLX0-8128[c]",
"DMK-MONOMER[i]", "2-OCTAPRENYL-METHOXY-BENZOQ-METH-MONOMER[c]"
]
reactionIds = [
"O-SUCCINYLBENZOATE-COA-LIG-RXN", "NAPHTHOATE-SYN-RXN",
"RXN-9311", "DMK-RXN", "ADOMET-DMK-METHYLTRANSFER-RXN"
]
reactantIds = ["CPD-12115[c]"]
enzymeIndexes = [moleculeIds.index(x) for x in enzymeIds]
reactantIndexes = [moleculeIds.index(x) for x in reactantIds]
for gen, simDir in enumerate(allDir):
simOutDir = os.path.join(simDir, "simOut")
time_ = TableReader(os.path.join(simOutDir,
"Main")).readColumn("time")
timeStepSec = TableReader(os.path.join(
simOutDir, "Main")).readColumn("timeStepSec")
cellMass = TableReader(os.path.join(
simOutDir, "Mass")).readColumn("cellMass")
dryMass = TableReader(os.path.join(
simOutDir, "Mass")).readColumn("dryMass")
bulkMolecules = TableReader(
os.path.join(simOutDir, "BulkMolecules"))
moleculeCounts = bulkMolecules.readColumn("counts")
enzymeCounts = moleculeCounts[:, enzymeIndexes]
metCounts = moleculeCounts[:, metaboliteIndexes[0]]
reactantCounts = moleculeCounts[:, reactantIndexes]
bulkMolecules.close()
fbaResults = TableReader(os.path.join(simOutDir, "FBAResults"))
reactionIDs = np.array(
fbaResults.readAttribute("reactionIDs")).tolist()
reactionIndexes = [reactionIDs.index(x) for x in reactionIds]
reactionFluxes = np.array(
fbaResults.readColumn("reactionFluxes"))
enzymeFluxes = reactionFluxes[:, reactionIndexes]
fbaResults.close()
cellVolume = units.g * np.array(cellMass) / cellDensity
coefficient = (units.fg * np.array(dryMass)) / (
units.fg *
np.array(cellMass)) * cellDensity * (units.s * timeStepSec)
for i, row in enumerate(xrange(0, 2 * len(enzymeIds), 2)):
countAxis = axesList[row]
fluxAxis = axesList[row + 1]
plotFlux = (
((COUNTS_UNITS / VOLUME_UNITS) * enzymeFluxes[:, i]) /
coefficient).asNumber(units.mmol / units.g / units.h)
countAxis.plot(time_ / 3600.,
enzymeCounts[:, i],
color="b")
fluxAxis.plot(time_ / 3600., plotFlux, color="b")
axesList[-2].plot(time_ / 3600., reactantCounts, color="b")
axesList[-1].plot(time_ / 3600., metCounts, color="b")
ylabels = [
"menE", "menB", "menI", "menA", "ubiE", "CPD-12115",
"Menaquinone"
]
for i, axis in enumerate(axesList[::2]):
axis.set_xlim([0, time_[-1] / 3600.])
axis.set_ylabel("%s" % ylabels[i], rotation=0)
whitePadSparklineAxis(axis, False)
for axis in axesList[1::2]:
axis.set_xlim([0, time_[-1] / 3600.])
whitePadSparklineAxis(axis)
axesList[-1].set_ylabel(ylabels[-1], rotation=0)
for axis in axesList:
for i in xrange(len(patchStart)):
width = time[patchEnd[i]] / 3600. - time[
patchStart[i]] / 3600.
if width <= 0.1:
continue
height = axis.get_ylim()[1] - axis.get_ylim()[0]
axis.add_patch(
patches.Rectangle(
(time[patchStart[i]] / 3600., axis.get_ylim()[0]),
width,
height,
alpha=0.25,
color="gray",
linewidth=0.))
plt.subplots_adjust(hspace=0.5,
right=0.95,
bottom=0.05,
left=0.11,
top=0.95)
exportFigure(plt, plotOutDir,
plotOutFileName + "__downstreamFluxes", 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)
# Get all cells
ap = AnalysisPaths(variantDir, cohort_plot=True)
allDir = ap.get_cells()
sim_data = cPickle.load(open(simDataFile, "rb"))
constraintIsKcatOnly = sim_data.process.metabolism.constraintIsKcatOnly
targetFluxList = []
actualFluxList = []
reactionConstraintlist = []
for simDir in allDir:
simOutDir = os.path.join(simDir, "simOut")
try:
mainListener = TableReader(os.path.join(simOutDir, "Main"))
except Exception as e:
print(e)
continue
time = mainListener.readColumn("time")
mainListener.close()
# skip if no data
if time.shape is ():
continue
burnIn = time > BURN_IN_TIME
burnIn[0] = False
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.nanmean(targetFluxes[burnIn, :], axis=0)
actualAve = np.nanmean(actualFluxes[burnIn, :], axis=0)
if len(targetFluxList) == 0:
targetFluxList = np.array([targetAve])
actualFluxList = np.array([actualAve])
reactionConstraintList = np.array(
reactionConstraint[burnIn, :])
else:
targetFluxList = np.concatenate(
(targetFluxList, np.array([targetAve])), axis=0)
actualFluxList = np.concatenate(
(actualFluxList, np.array([actualAve])), axis=0)
reactionConstraintList = np.concatenate(
(reactionConstraintList,
np.array(reactionConstraint[burnIn, :])),
axis=0)
# determine average across all cells
targetAve = np.nanmean(targetFluxList, axis=0)
actualAve = np.nanmean(actualFluxList, axis=0)
# categorize reactions that use constraints with only kcat, Km and kcat, or switch between both types of constraints
kcatOnlyReactions = np.all(
constraintIsKcatOnly[reactionConstraintList], axis=0)
kmAndKcatReactions = ~np.any(
constraintIsKcatOnly[reactionConstraintList], axis=0)
mixedReactions = ~(kcatOnlyReactions ^ kmAndKcatReactions)
# categorize how well the actual flux matches the target flux
thresholds = [2, 10]
categorization = np.zeros(reactionConstraint.shape[1])
for i, threshold in enumerate(thresholds):
categorization[actualAve / targetAve < 1. / threshold] = i + 1
categorization[actualAve / targetAve > threshold] = i + 1
categorization[actualAve == 0] = -2
categorization[actualAve == targetAve] = -1
# write data for each reaction to a file
csvFile = open(os.path.join(plotOutDir, plotOutFileName + ".tsv"),
"wb")
output = csv.writer(csvFile, delimiter="\t")
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()
# add small number to allow plotting of 0 flux on log scale
targetAve += 1e-6
actualAve += 1e-6
pearsonAll = pearsonr(np.log10(targetAve), np.log10(actualAve))
pearsonNoZeros = pearsonr(np.log10(targetAve[(categorization != -2)]),
np.log10(actualAve[(categorization != -2)]))
# plot data
plt.figure(figsize=(4, 4))
ax = plt.axes()
plt.plot([-6, 4], [-6, 4], 'k', linewidth=0.75)
plt.plot([-5, 4], [-6, 3], 'k', linewidth=0.5)
plt.plot([-6, 3], [-5, 4], 'k', linewidth=0.5)
plt.plot(np.log10(targetAve),
np.log10(actualAve),
'o',
color="black",
markersize=8,
alpha=0.15,
zorder=1,
markeredgewidth=0.0)
plt.xlabel("Log10(Target Flux [mmol/g/hr])")
plt.ylabel("Log10(Actual Flux [mmol/g/hr])")
plt.title("PCC = %.3f, p = %s\n(%.3f, p = %s without points at zero)" %
(pearsonAll[0], pearsonAll[1], pearsonNoZeros[0],
pearsonNoZeros[1]))
plt.minorticks_off()
whitePadSparklineAxis(ax)
xlim = ax.get_xlim()
ylim = ax.get_ylim()
ax.set_ylim(ylim[0] - 0.5, ylim[1])
ax.set_xlim(xlim[0] - 0.5, xlim[1])
ax.set_yticks(range(-6, int(ylim[1]) + 1, 2))
ax.set_xticks(range(-6, int(xlim[1]) + 1, 2))
exportFigure(plt, plotOutDir, plotOutFileName)
ax.set_xlabel("")
ax.set_ylabel("")
ax.set_title("")
ax.set_xticklabels([])
ax.set_yticklabels([])
exportFigure(plt, plotOutDir, plotOutFileName + "_stripped", metadata)
plt.close("all")
def do_plot(self, inputDir, plotOutDir, plotOutFileName, simDataFile,
validationDataFile, metadata):
if metadata["variant"] != "condition":
print("This plot only runs for the 'condition' variant.")
return
if not os.path.isdir(inputDir):
raise Exception, 'inputDir does not currently exist as a directory'
filepath.makedirs(plotOutDir)
ap = AnalysisPaths(inputDir, variant_plot=True)
variants = ap.get_variants()
gens = [2, 3]
initial_volumes = []
added_volumes = []
for variant in variants:
with open(ap.get_variant_kb(variant), 'rb') as f:
sim_data = cPickle.load(f)
cell_density = sim_data.constants.cellDensity
initial_masses = np.zeros(0)
final_masses = np.zeros(0)
all_cells = ap.get_cells(variant=[variant], generation=gens)
if len(all_cells) == 0:
continue
for simDir in all_cells:
try:
simOutDir = os.path.join(simDir, "simOut")
mass = TableReader(os.path.join(simOutDir, "Mass"))
cellMass = mass.readColumn("cellMass")
initial_masses = np.hstack((initial_masses, cellMass[0]))
final_masses = np.hstack((final_masses, cellMass[-1]))
except:
continue
added_masses = final_masses - initial_masses
initial_volume = initial_masses / cell_density.asNumber(
units.fg / units.um**3)
added_volume = added_masses / cell_density.asNumber(
units.fg / units.um**3)
initial_volumes.append(initial_volume)
added_volumes.append(added_volume)
plt.style.use('seaborn-deep')
color_cycle = plt.rcParams['axes.prop_cycle'].by_key()['color']
plt.figure(figsize=(4, 4))
ax = plt.subplot2grid((1, 1), (0, 0))
options = {
"edgecolors": color_cycle[0],
"alpha": 0.2,
"s": 50,
"clip_on": False
}
labels = ["minimal", "anaerobic", "minimal + AA"]
ax.scatter(initial_volumes[2],
added_volumes[2],
marker="x",
label=labels[2],
**options)
ax.scatter(initial_volumes[0],
added_volumes[0],
facecolors="none",
marker="o",
label=labels[0],
**options)
ax.scatter(initial_volumes[1],
added_volumes[1],
facecolors="none",
marker="^",
label=labels[1],
**options)
ax.set_xlim([0, 4])
ax.set_ylim([0, 4])
ax.set_xlabel("Birth Volume ($\mu m^3$)")
ax.set_ylabel("Added Volume ($\mu m^3$)")
ax.legend()
ax.get_yaxis().get_major_formatter().set_useOffset(False)
ax.get_xaxis().get_major_formatter().set_useOffset(False)
whitePadSparklineAxis(ax)
ax.tick_params(which='both',
bottom=True,
left=True,
top=False,
right=False,
labelbottom=True,
labelleft=True)
plt.tight_layout()
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
# Get clean version of plot
ax.set_xlabel("")
ax.set_ylabel("")
ax.set_yticklabels([])
ax.set_xticklabels([])
exportFigure(plt, plotOutDir, plotOutFileName + "_clean", metadata)
plt.close("all")
def do_plot(self, inputDir, plotOutDir, plotOutFileName, simDataFile, validationDataFile, metadata):
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)
if ap.n_generation == 1:
print "Need more data to create plot"
return
fig = plt.figure()
fig.set_figwidth(15)
fig.set_figheight(5)
doublingTimeVariants = [44, 100, 22]
for varIdx in range(ap.n_variant):
if varIdx == 0:
plotIdx = 1
gen = [2,3]
elif varIdx == 1:
plotIdx = 0
gen = [2,3]
elif varIdx == 2:
plotIdx = 2
gen = [6,7]
else:
continue
initial_masses = np.zeros(0)
final_masses = np.zeros(0)
all_cells = ap.get_cells(generation=[2,3], variant=[varIdx])
if len(all_cells) == 0:
continue
doublingTimes = np.zeros(len(all_cells))
for idx, simDir in enumerate(all_cells):
try:
simOutDir = os.path.join(simDir, "simOut")
time = TableReader(os.path.join(simOutDir, "Main")).readColumn("time")
except Exception as e:
print 'Error reading data for %s; %s' % (simDir, e)
doublingTimes[idx] = (time[-1] - time[0]) / 60.
bins = 16
ax = plt.subplot2grid((1, 3), (0, plotIdx))
ax.hist(doublingTimes, bins)
ax.axvline(x = doublingTimeVariants[varIdx], color = "r", linestyle = "--")
ax.set_title("%i min" % (doublingTimeVariants[varIdx]), fontsize = FONT_SIZE)
ax.set_xlabel("Doubling Time (min)", fontsize = FONT_SIZE)
plt.subplots_adjust(bottom = 0.2)
whitePadSparklineAxis(ax)
for tick in ax.yaxis.get_major_ticks():
tick.label.set_fontsize(FONT_SIZE)
for tick in ax.xaxis.get_major_ticks():
tick.label.set_fontsize(FONT_SIZE)
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)
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, 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):
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)
# Get all ids reqiured
sim_data = cPickle.load(open(simDataFile, "rb"))
ids_complexation = sim_data.process.complexation.moleculeNames # Complexe of proteins, and protein monomers
ids_complexation_complexes = sim_data.process.complexation.ids_complexes # Only complexes
ids_equilibrium = sim_data.process.equilibrium.moleculeNames # Complexes of proteins + small molecules, small molecules, protein monomers
ids_equilibrium_complexes = sim_data.process.equilibrium.ids_complexes # Only complexes
ids_translation = sim_data.process.translation.monomerData[
"id"].tolist() # Only protein monomers
# ids_ribosome =
data_50s = sim_data.process.complexation.getMonomers(
sim_data.moleculeIds.s50_fullComplex)
data_30s = sim_data.process.complexation.getMonomers(
sim_data.moleculeIds.s30_fullComplex)
ribosome_subunit_ids = data_50s["subunitIds"].tolist(
) + data_30s["subunitIds"].tolist()
ribosome_subunit_stoich = np.hstack(
(data_50s["subunitStoich"], data_30s["subunitStoich"]))
data_rnap = sim_data.process.complexation.getMonomers(
sim_data.moleculeIds.rnapFull)
rnap_subunit_ids = data_rnap["subunitIds"].tolist()
rnap_subunit_stoich = data_rnap["subunitStoich"]
# Get all cells
ap = AnalysisPaths(seedOutDir, cohort_plot=True)
allDir = ap.get_cells(seed=[0])
first_build = True
# Pre-allocate variables. Rows = Generations, Cols = Monomers
n_monomers = sim_data.process.translation.monomerData['id'].size
n_sims = ap.n_generation
monomerExistMultigen = np.zeros((n_sims, n_monomers), dtype=np.bool)
ratioFinalToInitialCountMultigen = np.zeros((n_sims, n_monomers),
dtype=np.float)
initiationEventsPerMonomerMultigen = np.zeros((n_sims, n_monomers),
dtype=np.int)
monomerCountInitialMultigen = np.zeros((n_sims, n_monomers),
dtype=np.int)
cellMassInitialMultigen = np.zeros(n_sims, dtype=np.float)
if not FROM_CACHE:
for gen_idx, simDir in enumerate(allDir):
simOutDir = os.path.join(simDir, "simOut")
time = TableReader(os.path.join(simOutDir,
"Main")).readColumn("time")
## READ DATA ##
# Read in bulk ids and counts
bulkMolecules = TableReader(
os.path.join(simOutDir, "BulkMolecules"))
if first_build:
moleculeIds = bulkMolecules.readAttribute("objectNames")
complexationIdx = np.array([
moleculeIds.index(x) for x in ids_complexation
]) # Complexe of proteins, and protein monomers
complexation_complexesIdx = np.array([
moleculeIds.index(x)
for x in ids_complexation_complexes
]) # Only complexes
equilibriumIdx = np.array(
[moleculeIds.index(x) for x in ids_equilibrium]
) # Complexes of proteins + small molecules, small molecules, protein monomers
equilibrium_complexesIdx = np.array([
moleculeIds.index(x) for x in ids_equilibrium_complexes
]) # Only complexes
translationIdx = np.array([
moleculeIds.index(x) for x in ids_translation
]) # Only protein monomers
ribosomeIdx = np.array(
[moleculeIds.index(x) for x in ribosome_subunit_ids])
rnapIdx = np.array(
[moleculeIds.index(x) for x in rnap_subunit_ids])
first_build = False
bulkCounts = bulkMolecules.readColumn("counts")
bulkMolecules.close()
# Dissociate protein-protein complexes
bulkCounts[:, complexationIdx] += np.dot(
sim_data.process.complexation.stoichMatrixMonomers(),
bulkCounts[:, complexation_complexesIdx].transpose() *
-1).transpose()
# Dissociate protein-small molecule complexes
bulkCounts[:, equilibriumIdx] += np.dot(
sim_data.process.equilibrium.stoichMatrixMonomers(),
bulkCounts[:, equilibrium_complexesIdx].transpose() *
-1).transpose()
# Load unique molecule data for RNAP and ribosomes
uniqueMoleculeCounts = TableReader(
os.path.join(simOutDir, "UniqueMoleculeCounts"))
ribosomeIndex = uniqueMoleculeCounts.readAttribute(
"uniqueMoleculeIds").index("activeRibosome")
rnaPolyIndex = uniqueMoleculeCounts.readAttribute(
"uniqueMoleculeIds").index("activeRnaPoly")
nActiveRibosome = uniqueMoleculeCounts.readColumn(
"uniqueMoleculeCounts")[:, ribosomeIndex]
nActiveRnaPoly = uniqueMoleculeCounts.readColumn(
"uniqueMoleculeCounts")[:, rnaPolyIndex]
uniqueMoleculeCounts.close()
# Add subunits from RNAP and ribosomes
ribosomeSubunitCounts = (
nActiveRibosome.reshape((nActiveRibosome.size, 1)) *
ribosome_subunit_stoich.reshape(
(1, ribosome_subunit_stoich.size)))
rnapSubunitCounts = (nActiveRnaPoly.reshape(
(nActiveRnaPoly.size, 1)) * rnap_subunit_stoich.reshape(
(1, rnap_subunit_stoich.size)))
bulkCounts[:, ribosomeIdx] += ribosomeSubunitCounts
bulkCounts[:, rnapIdx] += rnapSubunitCounts
# Get protein monomer counts for calculations now that all complexes are dissociated
proteinMonomerCounts = bulkCounts[:, translationIdx]
## CALCULATIONS ##
# Calculate if monomer exists over course of cell cycle
monomerExist = proteinMonomerCounts.sum(axis=0) > 1
# Calculate if monomer comes close to doubling
ratioFinalToInitialCount = (
proteinMonomerCounts[-1, :] +
1) / (proteinMonomerCounts[0, :].astype(np.float) + 1)
# monomerDouble = ratioFinalToInitialCount > (1 - CLOSE_TO_DOUBLE)
# Load transcription initiation event data
rnapData = TableReader(os.path.join(simOutDir, "RnapData"))
initiationEventsPerRna = rnapData.readColumn(
"rnaInitEvent").sum(axis=0)
# Map transcription initiation events to monomers
initiationEventsPerMonomer = initiationEventsPerRna[
sim_data.relation.rnaIndexToMonomerMapping]
# Load cell mass
cellMassInitial = TableReader(os.path.join(
simOutDir, "Mass")).readColumn("cellMass")[0]
# Log data
monomerExistMultigen[gen_idx, :] = monomerExist
ratioFinalToInitialCountMultigen[
gen_idx, :] = ratioFinalToInitialCount
initiationEventsPerMonomerMultigen[
gen_idx, :] = initiationEventsPerMonomer
monomerCountInitialMultigen[gen_idx, :] = proteinMonomerCounts[
0, :]
cellMassInitialMultigen[gen_idx] = cellMassInitial
cPickle.dump(
monomerExistMultigen,
open(os.path.join(plotOutDir, "monomerExistMultigen.pickle"),
"wb"))
cPickle.dump(
ratioFinalToInitialCountMultigen,
open(
os.path.join(plotOutDir,
"ratioFinalToInitialCountMultigen.pickle"),
"wb"))
cPickle.dump(
initiationEventsPerMonomerMultigen,
open(
os.path.join(plotOutDir,
"initiationEventsPerMonomerMultigen.pickle"),
"wb"))
cPickle.dump(
monomerCountInitialMultigen,
open(
os.path.join(plotOutDir,
"monomerCountInitialMultigen.pickle"), "wb"))
cPickle.dump(
cellMassInitialMultigen,
open(
os.path.join(plotOutDir, "cellMassInitialMultigen.pickle"),
"wb"))
monomerExistMultigen = cPickle.load(
open(os.path.join(plotOutDir, "monomerExistMultigen.pickle"),
"rb"))
ratioFinalToInitialCountMultigen = cPickle.load(
open(
os.path.join(plotOutDir,
"ratioFinalToInitialCountMultigen.pickle"), "rb"))
initiationEventsPerMonomerMultigen = cPickle.load(
open(
os.path.join(plotOutDir,
"initiationEventsPerMonomerMultigen.pickle"),
"rb"))
monomerCountInitialMultigen = cPickle.load(
open(
os.path.join(plotOutDir, "monomerCountInitialMultigen.pickle"),
"rb"))
cellMassInitialMultigen = cPickle.load(
open(os.path.join(plotOutDir, "cellMassInitialMultigen.pickle"),
"rb"))
cellMassInitialMultigen = units.fg * cellMassInitialMultigen
existFractionPerMonomer = monomerExistMultigen.mean(axis=0)
averageFoldChangePerMonomer = ratioFinalToInitialCountMultigen #.mean(axis=0)
averageInitiationEventsPerMonomer = initiationEventsPerMonomerMultigen.mean(
axis=0)
averageInitiationEventsPerMonomer = np.tile(
averageInitiationEventsPerMonomer, (6, 1))
mws = sim_data.getter.getMass(
sim_data.process.translation.monomerData['id'])
monomerInitialMasses = (mws * monomerCountInitialMultigen /
sim_data.constants.nAvogadro)
# np.tile(cellMassInitialMultigen.asNumber().reshape((1,10)), (n_monomers,1))
# initialMassFractions = monomerInitialMasses.asNumber(units.fg).transpose() / np.tile(cellMassInitialMultigen.asNumber().reshape((1,10)), (n_monomers,1))
# averageInitialMassFractions = initialMassFractions.mean(axis = 1)
# avgMonomerInitialMass = monomerInitialMasses.asNumber(units.fg).mean(axis=0)
# avgMonomerInitialMassFraction = avgMonomerInitialMass / avgMonomerInitialMass.sum()
# uniqueBurstSizes = np.unique(initiationEventsPerMonomerMultigen)
# probExistByBurstSize = np.zeros(uniqueBurstSizes.size)
# probDoubleByBurstSize = np.zeros(uniqueBurstSizes.size)
# for idx, burstSize in enumerate(uniqueBurstSizes):
# mask = initiationEventsPerMonomerMultigen == burstSize
# mask_sum = mask.sum()
# probExistByBurstSize[idx] = monomerExistMultigen[mask].sum() / float(mask.sum())
# probDoubleByBurstSize[idx] = monomerDoubleMultigen[mask].sum() / float(mask.sum())
# fig, axesList = plt.subplots(4,1)
mult = 3
fig = plt.figure()
fig.set_figwidth(mm2inch(80) * mult)
fig.set_figheight(mm2inch(50) * mult)
scatterAxis = plt.subplot2grid(
(3, 4), (0, 0), colspan=3,
rowspan=3) #, sharex = xhistAxis, sharey = yhistAxis)
# scatterAxis.axhline(1.0, linewidth=0.5, color='black', linestyle="--", xmin = 0.5, xmax = 1.)
# scatterAxis.axhline(2.0, linewidth=0.5, color='black', linestyle="--", xmin = 0.5, xmax = 1.)
# xhistAxis = plt.subplot2grid((4,5), (0,0), colspan=3, sharex = scatterAxis)
yhistAxis = plt.subplot2grid((3, 4), (0, 3),
rowspan=3) #, sharey = scatterAxis)
# yhistAxis.axhline(1.0, linewidth=1.0, color='black', linestyle = 'dotted')
# yhistAxis.axhline(2.0, linewidth=1.0, color='black', linestyle = 'dotted')
#yhistAxis_2 = plt.subplot2grid((4,5), (1,4), rowspan=3, sharey = scatterAxis)
#yhistAxis_2.axhline(1.0, linewidth=0.5, color='black', linestyle="--")
#yhistAxis_2.axhline(2.0, linewidth=0.5, color='black', linestyle="--")
# xhistAxis.xaxis.set_visible(False)
#yhistAxis.yaxis.set_visible(False)
smallBurst = averageInitiationEventsPerMonomer <= 1.
# scatterAxis.set_xlim([1e-1, 1e3])
# ----> scatterAxis.set_ylim([0.7, 100])
# scatterAxis.semilogx(averageInitiationEventsPerMonomer[smallBurst], averageFoldChangePerMonomer[smallBurst], marker = '.', color = "red", alpha = 0.9, lw = 0.)#, s = 5)
# scatterAxis.semilogx(averageInitiationEventsPerMonomer[~smallBurst], averageFoldChangePerMonomer[~smallBurst], marker = '.', color = "blue", alpha = 0.9, lw = 0.)#, s = 5)
## scatterAxis.semilogx(averageInitiationEventsPerMonomer[smallBurst], averageFoldChangePerMonomer[smallBurst], marker = '.', color = "green", alpha = 0.9, lw = 0.)#, s = 5)
## scatterAxis.semilogx(averageInitiationEventsPerMonomer[~smallBurst], averageFoldChangePerMonomer[~smallBurst], marker = '.', color = "blue", alpha = 0.9, lw = 0.)#, s = 5)
scatterAxis.loglog(averageInitiationEventsPerMonomer[smallBurst],
averageFoldChangePerMonomer[smallBurst],
marker='.',
color="blue",
alpha=0.5,
lw=0.) #, s = 5)
scatterAxis.loglog(averageInitiationEventsPerMonomer[~smallBurst],
averageFoldChangePerMonomer[~smallBurst],
marker='.',
color="red",
alpha=0.5,
lw=0.) #, s = 5)
scatterAxis.set_ylabel(
"Fold change per protein\nin each generation ({} generations)".
format(ap.n_generation),
fontsize=FONT_SIZE)
scatterAxis.set_xlabel(
"Average number of transcription events\nper protein per generation ({} generations)"
.format(ap.n_generation),
fontsize=FONT_SIZE)
# lims = yhistAxis.get_ylim()
# step = (lims[1] - lims[0]) / 125
# bins = np.arange(lims[0], lims[1] + step, step)
# mass_in_binrange = np.zeros(bins.size-1, dtype=np.float)
# for i in range(len(bins) - 1):
# in_bin_range = np.logical_and(averageFoldChangePerMonomer > bins[i], averageFoldChangePerMonomer < bins[i+1])
# mass_in_binrange[i] = avgMonomerInitialMassFraction[in_bin_range].sum()
#yhistAxis_2.barh(bottom = bins[:-1], width = mass_in_binrange, height=(lims[1] - lims[0]) / 125, color = "white")
#yhistAxis_2.set_xlim([0., 1.])
#yhistAxis_2.yaxis.set_label_position("right")
#yhistAxis_2.set_xlabel("Fraction of\nproteome mass", fontsize = FONT_SIZE)
#scatterAxis.set_xlim([-10., 1000.])
# yhistAxis.hist(averageFoldChangePerMonomer[~smallBurst], histtype = 'step', bins = 25, orientation='horizontal', log = True)
# yhistAxis.hist(averageFoldChangePerMonomer[smallBurst], histtype = 'step', bins = 100, orientation='horizontal', log = True, color="green")
yhistAxis.hist(averageFoldChangePerMonomer[~smallBurst],
histtype='step',
bins=np.logspace(np.log10(0.01), np.log10(1000.), 25),
range=[0.7, 100],
log=True,
orientation='horizontal',
color="red",
linewidth=1)
yhistAxis.hist(averageFoldChangePerMonomer[smallBurst],
histtype='step',
bins=np.logspace(np.log10(0.01), np.log10(1000.), 125),
range=[0.7, 100],
log=True,
orientation='horizontal',
color="blue",
linewidth=1)
# yhistAxis.set_ylim([0.7, 100])
yhistAxis.set_yscale("log")
# xhistAxis.hist(averageInitiationEventsPerMonomer[smallBurst], histtype = 'step', color = "green", bins = np.logspace(np.log10(0.01), np.log10(1000.), 125), log = True, range = [-10., 1000.])
# xhistAxis.hist(averageInitiationEventsPerMonomer[~smallBurst], histtype = 'step', bins = np.logspace(np.log10(0.01), np.log10(1000.), 125), log = True, range = [-10., 1000.])
# xhistAxis.set_xscale("log")
for label in yhistAxis.xaxis.get_ticklabels()[::2]:
label.set_visible(False)
whitePadSparklineAxis(scatterAxis)
whitePadSparklineAxis(yhistAxis)
# whitePadSparklineAxis(xhistAxis)
yhistAxis.set_yticks([1., 2.])
yhistAxis.set_yticklabels([])
# Label 1 and 2 with arrows
yhistAxis.annotate("1",
xy=(1e4, 1),
xytext=(1e5, 1),
fontsize=FONT_SIZE,
arrowprops=dict(facecolor="black",
edgecolor="none",
width=0.5,
headwidth=4),
verticalalignment="center")
yhistAxis.annotate("2",
xy=(1e4, 2),
xytext=(1e5, 2),
fontsize=FONT_SIZE,
arrowprops=dict(facecolor="black",
edgecolor="none",
width=0.5,
headwidth=4),
verticalalignment="center")
for tick in scatterAxis.xaxis.get_major_ticks():
tick.label.set_fontsize(FONT_SIZE)
for tick in scatterAxis.yaxis.get_major_ticks():
tick.label.set_fontsize(FONT_SIZE)
for tick in yhistAxis.xaxis.get_major_ticks():
tick.label.set_fontsize(FONT_SIZE)
for tick in yhistAxis.yaxis.get_major_ticks():
tick.label.set_fontsize(FONT_SIZE)
scatterAxis.tick_params(
axis='both', # which axis
which='both', # both major and minor ticks are affected
right='off', # ticks along the bottom edge are off
left='on', # ticks along the top edge are off
top='off',
bottom='on',
)
yhistAxis.tick_params(
axis='both', # which axis
which='both', # both major and minor ticks are affected
right='off', # ticks along the bottom edge are off
left='on', # ticks along the top edge are off
top='off',
bottom='on',
)
# xhistAxis.tick_params(
# axis='both', # which axis
# which='both', # both major and minor ticks are affected
# right='off', # ticks along the bottom edge are off
# left='on', # ticks along the top edge are off
# top = 'off',
# bottom = 'on',
# )
plt.subplots_adjust(wspace=0.3, hspace=0.3, bottom=0.2)
# for label in yhistAxis_2.xaxis.get_ticklabels()[::2]:
# label.set_visible(False)
# axesList[0].semilogy(uniqueBurstSizes, probExistByBurstSize)
# axesList[1].semilogy(uniqueBurstSizes, probDoubleByBurstSize)
# # axesList[0].set_ylabel("Probability exists")
# # axesList[1].set_ylabel("Probability doubles")
# # axesList[1].set_xlabel("Number of transcription events per generation")
# axesList[2].semilogy(uniqueBurstSizes, probExistByBurstSize)
# axesList[2].set_xlim([0., 10.])
# #axesList[2].set_ylim([0.96, 1.0])
# axesList[3].semilogy(uniqueBurstSizes, probDoubleByBurstSize)
# axesList[3].set_xlim([0., 10.])
# #axesList[3].set_ylim([0.96, 1.0])
# axesList[0].set_ylabel("Probability\nexists")
# axesList[1].set_ylabel("Probability\ndoubles")
# axesList[2].set_ylabel("Probability\nexists")
# axesList[3].set_ylabel("Probability\ndoubles")
# axesList[3].set_xlabel("Number of transcription events per generation")
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
#plt.close("all")
scatterAxis.set_xlabel("")
scatterAxis.set_ylabel("")
scatterAxis.set_xticklabels([])
scatterAxis.set_yticklabels([])
yhistAxis.set_xlabel("")
yhistAxis.set_ylabel("")
yhistAxis.set_xticklabels([])
exportFigure(plt, plotOutDir, plotOutFileName + "_stripped", 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, cohort_plot=True)
# Get all cells
allDir = ap.get_cells(seed=[0])
# fig = plt.figure(figsize = (14, 10))
# ax1 = plt.subplot2grid((4,2), (0,0), rowspan = 4)
# ax2 = plt.subplot2grid((4,2), (0,1))
# ax3 = plt.subplot2grid((4,2), (1,1))
# ax4 = plt.subplot2grid((4,2), (2,1))
# ax5 = plt.subplot2grid((4,2), (3,1))
# axesList = [ax2, ax3, ax4, ax5]
# colors = ["blue", "green", "red", "cyan"]
colors = ["#43aa98", "#0071bb", "#bf673c"]
mult = 2.3
fig, axis = plt.subplots(1, 1)
fig.set_figwidth(mm2inch(55.2) * mult)
fig.set_figheight(mm2inch(53.36) * mult)
width = 200
timeMultigen = np.zeros(0)
cellMassGrowthRateMultigen = np.zeros(0)
proteinGrowthRateMultigen = np.zeros(0)
rnaGrowthRateMultigen = np.zeros(0)
for gen, simDir in enumerate(allDir):
simOutDir = os.path.join(simDir, "simOut")
time = TableReader(os.path.join(simOutDir,
"Main")).readColumn("time")
timeStep = TableReader(os.path.join(
simOutDir, "Main")).readColumn("timeStepSec")
mass = TableReader(os.path.join(simOutDir, "Mass"))
cellMass = mass.readColumn("cellMass")
proteinMass = mass.readColumn("proteinMass")
rnaMass = mass.readColumn("rnaMass")
dnaMass = mass.readColumn("dnaMass")
cellmassGrowthRate = np.diff(
cellMass) / cellMass[1:] / timeStep[:-1]
proteinGrowthRate = np.diff(
proteinMass) / proteinMass[1:] / timeStep[:-1]
rnaGrowthRate = np.diff(rnaMass) / rnaMass[1:] / timeStep[:-1]
dnaGrowthRate = np.diff(dnaMass) / dnaMass[1:] / timeStep[:-1]
timeMultigen = np.hstack((timeMultigen, time[:-1]))
cellMassGrowthRateMultigen = np.hstack(
(cellMassGrowthRateMultigen, cellmassGrowthRate))
proteinGrowthRateMultigen = np.hstack(
(proteinGrowthRateMultigen, proteinGrowthRate))
rnaGrowthRateMultigen = np.hstack(
(rnaGrowthRateMultigen, rnaGrowthRate))
# seriesScrubber(cellMassGrowthRateMultigen, 1.5)
# seriesScrubber(proteinGrowthRateMultigen, 1.5)
# seriesScrubber(rnaGrowthRateMultigen, 1.5)
cellMassGrowthRateMultigen = np.convolve(cellMassGrowthRateMultigen,
np.ones(width) / width,
mode="same")
proteinGrowthRateMultigen = np.convolve(proteinGrowthRateMultigen,
np.ones(width) / width,
mode="same")
rnaGrowthRateMultigen = np.convolve(rnaGrowthRateMultigen,
np.ones(width) / width,
mode="same")
# seriesScrubber(proteinGrowthRateMultigen, 2)
# rnaGrowthRate = np.convolve(rnaGrowthRate, np.ones(width) / width, mode = "same")
# dnaGrowthRate = np.convolve(dnaGrowthRate, np.ones(width) / width, mode = "same")
# seriesScrubber(rnaGrowthRate,1.25)
# seriesScrubber(dnaGrowthRate,3.25)
linewidth = 2
axis.plot(timeMultigen[:-width] / 60.,
cellMassGrowthRateMultigen[:-width] * 60.,
color=colors[0],
alpha=0.9,
label="Cell mass",
linewidth=linewidth)
axis.plot(timeMultigen[:-width] / 60.,
proteinGrowthRateMultigen[:-width] * 60.,
color=colors[1],
alpha=0.9,
label="Protein fraction",
linewidth=linewidth)
axis.plot(timeMultigen[:-width] / 60.,
rnaGrowthRateMultigen[:-width] * 60.,
color=colors[2],
alpha=0.9,
label="RNA fraction",
linewidth=linewidth)
axis.legend(loc=4, frameon=False)
axis.set_ylim([0.014, 0.029])
whitePadSparklineAxis(axis)
axis.set_xlabel("Time (min)")
axis.set_ylabel("Averaged instantaneous growth rate " +
r"$(\frac{\frac{dX}{dt}}{X} [=] \frac{1}{min})$")
plt.subplots_adjust(bottom=0.2, left=0.2)
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
for axes in [axis]:
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 + "_stripped",
metadata,
transparent=True)
plt.close("all")
################ ALTERNATE SIZE ######################
mult = 3
fig, axis = plt.subplots(1, 1)
fig.set_figwidth(mm2inch(29.25) * mult)
fig.set_figheight(mm2inch(24.401) * mult)
width = 200
timeMultigen = np.zeros(0)
cellMassGrowthRateMultigen = np.zeros(0)
proteinGrowthRateMultigen = np.zeros(0)
rnaGrowthRateMultigen = np.zeros(0)
for gen, simDir in enumerate(allDir):
simOutDir = os.path.join(simDir, "simOut")
time = TableReader(os.path.join(simOutDir,
"Main")).readColumn("time")
timeStep = TableReader(os.path.join(
simOutDir, "Main")).readColumn("timeStepSec")
mass = TableReader(os.path.join(simOutDir, "Mass"))
cellMass = mass.readColumn("cellMass")
proteinMass = mass.readColumn("proteinMass")
rnaMass = mass.readColumn("rnaMass")
dnaMass = mass.readColumn("dnaMass")
cellmassGrowthRate = np.diff(
cellMass) / cellMass[1:] / timeStep[:-1]
proteinGrowthRate = np.diff(
proteinMass) / proteinMass[1:] / timeStep[:-1]
rnaGrowthRate = np.diff(rnaMass) / rnaMass[1:] / timeStep[:-1]
dnaGrowthRate = np.diff(dnaMass) / dnaMass[1:] / timeStep[:-1]
timeMultigen = np.hstack((timeMultigen, time[:-1]))
cellMassGrowthRateMultigen = np.hstack(
(cellMassGrowthRateMultigen, cellmassGrowthRate))
proteinGrowthRateMultigen = np.hstack(
(proteinGrowthRateMultigen, proteinGrowthRate))
rnaGrowthRateMultigen = np.hstack(
(rnaGrowthRateMultigen, rnaGrowthRate))
# seriesScrubber(cellMassGrowthRateMultigen, 1.5)
# seriesScrubber(proteinGrowthRateMultigen, 1.5)
# seriesScrubber(rnaGrowthRateMultigen, 1.5)
cellMassGrowthRateMultigen = np.convolve(cellMassGrowthRateMultigen,
np.ones(width) / width,
mode="same")
proteinGrowthRateMultigen = np.convolve(proteinGrowthRateMultigen,
np.ones(width) / width,
mode="same")
rnaGrowthRateMultigen = np.convolve(rnaGrowthRateMultigen,
np.ones(width) / width,
mode="same")
# seriesScrubber(proteinGrowthRateMultigen, 2)
# rnaGrowthRate = np.convolve(rnaGrowthRate, np.ones(width) / width, mode = "same")
# dnaGrowthRate = np.convolve(dnaGrowthRate, np.ones(width) / width, mode = "same")
# seriesScrubber(rnaGrowthRate,1.25)
# seriesScrubber(dnaGrowthRate,3.25)
linewidth = 2
axis.plot(timeMultigen[:-width] / 60.,
cellMassGrowthRateMultigen[:-width] * 60.,
color=colors[0],
alpha=0.9,
label="Cell mass",
linewidth=linewidth)
axis.plot(timeMultigen[:-width] / 60.,
proteinGrowthRateMultigen[:-width] * 60.,
color=colors[1],
alpha=0.9,
label="Protein fraction",
linewidth=linewidth)
axis.plot(timeMultigen[:-width] / 60.,
rnaGrowthRateMultigen[:-width] * 60.,
color=colors[2],
alpha=0.9,
label="RNA fraction",
linewidth=linewidth)
# axis.legend(loc=4,frameon=False)
axis.set_ylim([0.014, 0.029])
whitePadSparklineAxis(axis)
axis.set_xlabel("Time (min)")
axis.set_ylabel("Averaged instantaneous growth rate " +
r"$(\frac{\frac{dX}{dt}}{X} [=] \frac{1}{min})$")
plt.subplots_adjust(bottom=0.2, left=0.2)
exportFigure(plt, plotOutDir, plotOutFileName + "_altsize", metadata)
for axes in [axis]:
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_1, left=trim_1, right=1)
exportFigure(plt,
plotOutDir,
plotOutFileName + "_altsize_stripped",
metadata,
transparent=True)
plt.close("all")
