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'
filepath.makedirs(plotOutDir)
with open(validationDataFile, 'rb') as f:
validation_data = cPickle.load(f)
ap = AnalysisPaths(inputDir, variant_plot=True)
variants = ap.get_variants()
for variant in variants:
with open(ap.get_variant_kb(variant), 'rb') as f:
sim_data = cPickle.load(f)
for sim_dir in ap.get_cells(variant=[variant]):
simOutDir = os.path.join(sim_dir, "simOut")
# Listeners used
main_reader = TableReader(os.path.join(simOutDir, 'Main'))
# Load data
time = main_reader.readColumn('time')
plt.figure()
### Create Plot ###
exportFigure(plt, plotOutDir, plotOutFileName, 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 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')
plt.figure(figsize=(5, 5))
plt.scatter(initial_volumes[0], added_volumes[0], s=3, label="minimal")
plt.scatter(initial_volumes[1],
added_volumes[1],
s=3,
label="anaerobic")
plt.scatter(initial_volumes[2], added_volumes[2], s=3, label="+AA")
plt.xlim([0, 4])
plt.ylim([0, 4])
plt.xlabel("Birth Volume ($\mu m^3$)")
plt.ylabel("Added Volume ($\mu m^3$)")
plt.legend()
exportFigure(plt, plotOutDir, plotOutFileName, 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)
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)
# 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 not os.path.isdir(inputDir):
raise Exception, "inputDir does not currently exist as a directory"
ap = AnalysisPaths(inputDir, variant_plot=True)
all_cells = ap.get_cells()
if not os.path.exists(plotOutDir):
os.mkdir(plotOutDir)
rnaToProteinDict = {}
dnaToProteinDict = {}
elngRateDict = {}
stableRnaFractionDict = {}
doublingPerHourDict = {}
variantSimDataFile = ap.get_variant_kb(ap.get_variants()[0])
sim_data = cPickle.load(open(variantSimDataFile, "rb"))
nAvogadro = sim_data.constants.nAvogadro.asNumber()
chromMass = (sim_data.getter.getMass(['CHROM_FULL[c]'])[0] /
sim_data.constants.nAvogadro).asNumber()
for simDir in all_cells:
simOutDir = os.path.join(simDir, "simOut")
variant = int(simDir[simDir.rfind('generation_') -
14:simDir.rfind('generation_') - 8])
mass = TableReader(os.path.join(simOutDir, "Mass"))
protein = mass.readColumn("proteinMass") * 10**-15
rna = mass.readColumn("rnaMass") * 10**-15
dna = mass.readColumn("dnaMass") * 10**-15
growthRate = mass.readColumn("instantaniousGrowthRate")
doublingTime = np.nanmean(np.log(2) / growthRate / 60)
rnaNT = rna / NT_MW * nAvogadro
proteinAA = protein / PROTEIN_MW * nAvogadro
# Count chromosome equivalents
chromEquivalents = dna / chromMass
# Load ribosome data
ribosomeDataFile = TableReader(
os.path.join(simOutDir, "RibosomeData"))
actualElongations = ribosomeDataFile.readColumn(
"actualElongations")
ribosomeDataFile.close()
transcriptDataFile = TableReader(
os.path.join(simOutDir, "TranscriptElongationListener"))
rnaSynth = transcriptDataFile.readColumn("countRnaSynthesized")
isTRna = sim_data.process.transcription.rnaData["isTRna"]
isRRna = sim_data.process.transcription.rnaData["isRRna"]
stableRnaSynth = np.sum(rnaSynth[:, isTRna], axis=1) + np.sum(
rnaSynth[:, isRRna], axis=1)
totalRnaSynth = np.sum(rnaSynth, axis=1).astype(float)
rnaFraction = stableRnaSynth / totalRnaSynth
uniqueMoleculeCounts = TableReader(
os.path.join(simOutDir, "UniqueMoleculeCounts"))
ribosomeIndex = uniqueMoleculeCounts.readAttribute(
"uniqueMoleculeIds").index("activeRibosome")
activeRibosome = uniqueMoleculeCounts.readColumn(
"uniqueMoleculeCounts")[:, ribosomeIndex]
uniqueMoleculeCounts.close()
initialTime = TableReader(os.path.join(
simOutDir, "Main")).readAttribute("initialTime")
t = TableReader(os.path.join(
simOutDir, "Main")).readColumn("time") - initialTime
timeStepSec = TableReader(os.path.join(
simOutDir, "Main")).readColumn("timeStepSec")
if variant in rnaToProteinDict.keys():
rnaToProteinDict[variant] = np.append(
rnaToProteinDict[variant], rnaNT / (proteinAA / 100))
dnaToProteinDict[variant] = np.append(
dnaToProteinDict[variant],
chromEquivalents / (proteinAA / 10**9))
elngRateDict[variant] = np.append(
elngRateDict[variant],
(actualElongations / activeRibosome / timeStepSec)[3:])
stableRnaFractionDict[variant] = np.append(
stableRnaFractionDict[variant],
np.asarray(rnaFraction)[~np.isnan(rnaFraction)])
doublingPerHourDict[variant] = np.append(
doublingPerHourDict[variant], 60 / doublingTime)
else:
rnaToProteinDict[variant] = rnaNT / (proteinAA / 100)
dnaToProteinDict[variant] = chromEquivalents / (proteinAA /
10**9)
elngRateDict[variant] = (actualElongations / activeRibosome /
timeStepSec)[3:]
stableRnaFractionDict[variant] = np.asarray(
rnaFraction)[~np.isnan(rnaFraction)]
doublingPerHourDict[variant] = 60 / doublingTime
rnaToProtein = []
dnaToProtein = []
elngRate = []
stableRnaFraction = []
doublingPerHour = []
for key in rnaToProteinDict.keys():
rnaToProtein += [rnaToProteinDict[key]]
dnaToProtein += [dnaToProteinDict[key]]
elngRate += [elngRateDict[key]]
stableRnaFraction += [stableRnaFractionDict[key]]
doublingPerHour += [np.mean(doublingPerHourDict[key])]
plt.figure(figsize=(8.5, 11))
sp = plt.subplot(4, 1, 1)
sp.violinplot(rnaToProtein, positions=doublingPerHour, showmeans=True)
sp.set_ylabel("RNA to Protein\n(nuc/100 aa)")
sp = plt.subplot(4, 1, 2)
sp.violinplot(dnaToProtein, positions=doublingPerHour, showmeans=True)
sp.set_ylabel("DNA to Protein\n(chrom eq/10^9 aa)")
sp = plt.subplot(4, 1, 3)
sp.violinplot(elngRate, positions=doublingPerHour, showmeans=True)
sp.set_ylabel("Ribosome Elongation\nRate (aa/s)")
sp = plt.subplot(4, 1, 4)
sp.violinplot(stableRnaFraction,
positions=doublingPerHour,
showmeans=True)
sp.set_ylabel("Rate Stable RNA to\nRate Total RNA")
sp.set_xlabel("Doublings per Hour")
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
plt.close("all")
def do_plot(self, inputDir, plotOutDir, plotOutFileName, simDataFile,
validationDataFile, metadata):
if metadata["variant"] != "tfActivity":
print "This plot only runs for the 'tfActivity' variant."
return
if not os.path.isdir(inputDir):
raise Exception, "inputDir does not currently exist as a directory"
ap = AnalysisPaths(inputDir, variant_plot=True)
variants = sorted(ap._path_data['variant'].tolist()
) # Sorry for accessing private data
if 0 in variants:
variants.remove(0)
if len(variants) == 0:
return
all_cells = sorted(
ap.get_cells(variant=variants, seed=[0], generation=[0]))
if not os.path.exists(plotOutDir):
os.mkdir(plotOutDir)
expectedProbBound = []
simulatedProbBound = []
expectedSynthProb = []
simulatedSynthProb = []
targetId = []
targetCondition = []
targetToTfType = {}
for variant, simDir in zip(variants, all_cells):
sim_data = cPickle.load(open(ap.get_variant_kb(variant), "rb"))
shape = sim_data.process.transcription_regulation.recruitmentData[
"shape"]
hI = sim_data.process.transcription_regulation.recruitmentData[
"hI"]
hJ = sim_data.process.transcription_regulation.recruitmentData[
"hJ"]
hV = sim_data.process.transcription_regulation.recruitmentData[
"hV"]
H = np.zeros(shape, np.float64)
H[hI, hJ] = hV
colNames = sim_data.process.transcription_regulation.recruitmentColNames
tfList = ["basal (no TF)"] + sorted(
sim_data.tfToActiveInactiveConds)
simOutDir = os.path.join(simDir, "simOut")
tf = tfList[(variant + 1) // 2]
tfStatus = None
if variant % 2 == 1:
tfStatus = "active"
else:
tfStatus = "inactive"
bulkMoleculesReader = TableReader(
os.path.join(simOutDir, "BulkMolecules"))
bulkMoleculeIds = bulkMoleculesReader.readAttribute("objectNames")
rnaSynthProbReader = TableReader(
os.path.join(simOutDir, "RnaSynthProb"))
rnaIds = rnaSynthProbReader.readAttribute("rnaIds")
tfTargetBoundIds = []
tfTargetBoundIndices = []
tfTargetSynthProbIds = []
tfTargetSynthProbIndices = []
for tfTarget in sorted(sim_data.tfToFC[tf]):
tfTargetBoundIds.append(tfTarget + "__" + tf)
tfTargetBoundIndices.append(
bulkMoleculeIds.index(tfTargetBoundIds[-1]))
tfTargetSynthProbIds.append(tfTarget + "[c]")
tfTargetSynthProbIndices.append(
rnaIds.index(tfTargetSynthProbIds[-1]))
tfTargetBoundCountsAll = bulkMoleculesReader.readColumn(
"counts")[:, tfTargetBoundIndices]
tfTargetSynthProbAll = rnaSynthProbReader.readColumn(
"rnaSynthProb")[:, tfTargetSynthProbIndices]
for targetIdx, tfTarget in enumerate(sorted(sim_data.tfToFC[tf])):
tfTargetBoundCounts = tfTargetBoundCountsAll[:,
targetIdx].reshape(
-1)
expectedProbBound.append(sim_data.pPromoterBound[tf + "__" +
tfStatus][tf])
simulatedProbBound.append(tfTargetBoundCounts[5:].mean())
tfTargetSynthProbId = [tfTarget + "[c]"]
tfTargetSynthProbIndex = np.array(
[rnaIds.index(x) for x in tfTargetSynthProbId])
tfTargetSynthProb = tfTargetSynthProbAll[:,
targetIdx].reshape(-1)
rnaIdx = np.where(
sim_data.process.transcription.rnaData["id"] == tfTarget +
"[c]")[0][0]
regulatingTfIdxs = np.where(H[rnaIdx, :])
for i in regulatingTfIdxs[0]:
if colNames[i].split("__")[1] != "alpha":
if tfTarget not in targetToTfType:
targetToTfType[tfTarget] = []
targetToTfType[tfTarget].append(
sim_data.process.transcription_regulation.
tfToTfType[colNames[i].split("__")[1]])
expectedSynthProb.append(
sim_data.process.transcription.rnaSynthProb[
tf + "__" + tfStatus][rnaIdx])
simulatedSynthProb.append(tfTargetSynthProb[5:].mean())
targetId.append(tfTarget)
targetCondition.append(tf + "__" + tfStatus)
bulkMoleculesReader.close()
rnaSynthProbReader.close()
expectedProbBound = np.array(expectedProbBound)
simulatedProbBound = np.array(simulatedProbBound)
expectedSynthProb = np.array(expectedSynthProb)
simulatedSynthProb = np.array(simulatedSynthProb)
regressionResult = scipy.stats.linregress(
np.log10(expectedProbBound[expectedProbBound > NUMERICAL_ZERO]),
np.log10(simulatedProbBound[expectedProbBound > NUMERICAL_ZERO]))
regressionResultLargeValues = scipy.stats.linregress(
np.log10(expectedProbBound[expectedProbBound > 1e-2]),
np.log10(simulatedProbBound[expectedProbBound > 1e-2]))
ax = plt.subplot(2, 1, 1)
ax.scatter(np.log10(expectedProbBound), np.log10(simulatedProbBound))
plt.xlabel("log10(Expected probability bound)", fontsize=6)
plt.ylabel("log10(Simulated probability bound)", fontsize=6)
plt.title(
"Slope: %0.3f Intercept: %0.3e (Without Small Values: Slope: %0.3f Intercept: %0.3e)"
% (regressionResult.slope, regressionResult.intercept,
regressionResultLargeValues.slope,
regressionResultLargeValues.intercept),
fontsize=6)
ax.tick_params(which='both', direction='out', labelsize=6)
regressionResult = scipy.stats.linregress(
np.log10(expectedSynthProb[expectedSynthProb > NUMERICAL_ZERO]),
np.log10(simulatedSynthProb[expectedSynthProb > NUMERICAL_ZERO]))
ax = plt.subplot(2, 1, 2)
ax.scatter(np.log10(expectedSynthProb), np.log10(simulatedSynthProb))
plt.xlabel("log10(Expected synthesis probability)", fontsize=6)
plt.ylabel("log10(Simulated synthesis probability)", fontsize=6)
plt.title("Slope: %0.3f Intercept: %0.3e" %
(regressionResult.slope, regressionResult.intercept),
fontsize=6)
ax.tick_params(which='both', direction='out', labelsize=6)
plt.tight_layout()
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
plt.close("all")
# Probability bound - hover for ID
source1 = ColumnDataSource(data=dict(x=np.log10(expectedProbBound),
y=np.log10(simulatedProbBound),
ID=targetId,
condition=targetCondition))
hover1 = HoverTool(tooltips=[("ID", "@ID"), ("condition",
"@condition")])
tools1 = [
hover1,
BoxZoomTool(),
LassoSelectTool(),
PanTool(),
WheelZoomTool(),
ResizeTool(),
UndoTool(),
RedoTool(), "reset"
]
s1 = figure(x_axis_label="log10(Expected probability bound)",
y_axis_label="log10(Simulated probability bound)",
width=800,
height=500,
tools=tools1)
s1.scatter("x", "y", source=source1)
if not os.path.exists(os.path.join(plotOutDir, "html_plots")):
os.makedirs(os.path.join(plotOutDir, "html_plots"))
bokeh.io.output_file(os.path.join(
plotOutDir, "html_plots",
plotOutFileName + "__probBound" + ".html"),
title=plotOutFileName,
autosave=False)
bokeh.io.save(s1)
# Synthesis probability - hover for ID
source2 = ColumnDataSource(data=dict(x=np.log10(expectedSynthProb),
y=np.log10(simulatedSynthProb),
ID=targetId,
condition=targetCondition))
hover2 = HoverTool(tooltips=[("ID", "@ID"), ("condition",
"@condition")])
tools2 = [
hover2,
BoxZoomTool(),
LassoSelectTool(),
PanTool(),
WheelZoomTool(),
ResizeTool(),
UndoTool(),
RedoTool(), "reset"
]
s2 = figure(x_axis_label="log10(Expected synthesis probability)",
y_axis_label="log10(Simulated synthesis probability)",
width=800,
height=500,
tools=tools2)
s2.scatter("x", "y", source=source2)
bokeh.io.output_file(os.path.join(
plotOutDir, "html_plots",
plotOutFileName + "__synthProb" + ".html"),
title=plotOutFileName,
autosave=False)
bokeh.io.save(s2)
# Synthesis probability - filter targets by TF type
bokeh.io.output_file(os.path.join(
plotOutDir, "html_plots",
plotOutFileName + "__synthProb__interactive" + ".html"),
title=plotOutFileName,
autosave=False)
tfTypes = []
for i in targetId:
if i in targetToTfType:
uniqueSet = np.unique(targetToTfType[i])
if uniqueSet.shape[0] == 1:
tfTypes.append(uniqueSet[0])
elif uniqueSet.shape[0] == 3:
tfTypes.append("all")
else:
tfTypes.append(uniqueSet[0] + "_" + uniqueSet[1])
else:
tfTypes.append("none")
tfTypes = np.array(tfTypes)
x0 = np.copy(expectedSynthProb)
x0[np.where(tfTypes != "0CS")] = np.nan
x1 = np.copy(expectedSynthProb)
x1[np.where(tfTypes != "1CS")] = np.nan
x2 = np.copy(expectedSynthProb)
x2[np.where(tfTypes != "2CS")] = np.nan
x01 = np.copy(expectedSynthProb)
x01[np.where(tfTypes != "0CS_1CS")] = np.nan
x02 = np.copy(expectedSynthProb)
x02[np.where(tfTypes != "0CS_2CS")] = np.nan
x12 = np.copy(expectedSynthProb)
x12[np.where(tfTypes != "1CS_2CS")] = np.nan
y0 = np.copy(simulatedSynthProb)
y0[np.where(tfTypes != "0CS")] = np.nan
y1 = np.copy(simulatedSynthProb)
y1[np.where(tfTypes != "1CS")] = np.nan
y2 = np.copy(simulatedSynthProb)
y2[np.where(tfTypes != "2CS")] = np.nan
y01 = np.copy(simulatedSynthProb)
y01[np.where(tfTypes != "0CS_1CS")] = np.nan
y02 = np.copy(simulatedSynthProb)
y02[np.where(tfTypes != "0CS_2CS")] = np.nan
y12 = np.copy(simulatedSynthProb)
x12[np.where(tfTypes != "1CS_2CS")] = np.nan
source_all = ColumnDataSource(data=dict(x=np.log10(expectedSynthProb),
y=np.log10(simulatedSynthProb),
ID=targetId,
condition=targetCondition))
source_tf = ColumnDataSource(
data=dict(x0=np.log10(x0),
y0=np.log10(y0),
x1=np.log10(x1),
y1=np.log10(y1),
x2=np.log10(x2),
y2=np.log10(y2),
x01=np.log10(x01),
y01=np.log10(y01),
x02=np.log10(x02),
y02=np.log10(y02),
x12=np.log10(x12),
y12=np.log10(y12),
x123=np.log10(expectedSynthProb),
y123=np.log10(simulatedSynthProb),
ID=targetId,
condition=targetCondition))
hover3 = HoverTool(tooltips=[("ID", "@ID"), ("condition",
"@condition")])
tools3 = [
hover3,
BoxZoomTool(),
LassoSelectTool(),
PanTool(),
WheelZoomTool(),
ResizeTool(),
UndoTool(),
RedoTool(), "reset"
]
axis_max = np.ceil(np.log10(expectedSynthProb).max())
for i in np.sort(expectedSynthProb):
if i > 0:
break
axis_min = np.floor(np.log10(i))
s3 = figure(
x_axis_label="log10(Expected synthesis probability)",
y_axis_label="log10(Simulated synthesis probability)",
plot_width=800,
plot_height=500,
x_range=(axis_min, axis_max),
y_range=(axis_min, axis_max),
tools=tools3,
)
s3.scatter("x", "y", source=source_all)
callback = CustomJS(args=dict(source_all=source_all,
source_tf=source_tf),
code="""
var data_all = source_all.get('data');
var data_tf = source_tf.get('data');
data_all['x'] = data_tf['x' + cb_obj.get("name")];
data_all['y'] = data_tf['y' + cb_obj.get("name")];
source_all.trigger('change');
""")
toggle0 = Button(label="0CS", callback=callback, name="0")
toggle1 = Button(label="1CS", callback=callback, name="1")
toggle2 = Button(label="2CS", callback=callback, name="2")
toggle3 = Button(label="0CS and 1CS", callback=callback, name="01")
toggle4 = Button(label="0CS and 2CS", callback=callback, name="02")
toggle5 = Button(label="1CS and 2CS", callback=callback, name="12")
toggle6 = Button(label="All", callback=callback, name="123")
layout = vplot(toggle0, toggle1, toggle2, toggle3, toggle4, toggle5,
toggle6, s3)
bokeh.io.save(layout)
bokeh.io.curstate().reset()
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"
ap = AnalysisPaths(inputDir, variant_plot=True)
variants = sorted(ap._path_data['variant'].tolist()
) # Sorry for accessing private data
if len(variants) <= 1:
return
all_cells = sorted(
ap.get_cells(variant=variants, seed=[0], generation=[0]))
if not os.path.exists(plotOutDir):
os.mkdir(plotOutDir)
#make structures to hold mean flux values
mean_fluxes = []
BURN_IN_STEPS = 20
n_variants = 0
IDs = []
#Puts you into the specific simulation's data. Pull fluxes from here #TODO LEARN HOW TO PULL FLUXES FROM LISTENER FILE (see kineticsflux comparison)
for variant, simDir in zip(variants, all_cells):
sim_data = cPickle.load(open(ap.get_variant_kb(variant), "rb"))
simOutDir = os.path.join(simDir, "simOut")
#crafting area
enzymeKineticsReader = TableReader(
os.path.join(simOutDir, "FBAResults")) # "EnzymeKinetics"))
actualFluxes = enzymeKineticsReader.readColumn(
"reactionFluxes") #"actualFluxes")
IDs = enzymeKineticsReader.readAttribute("reactionIDs")
enzymeKineticsReader.close()
actualAve = np.mean(actualFluxes[BURN_IN_STEPS:, :], axis=0)
mean_fluxes.append(actualAve)
n_variants = n_variants + 1
###Plot the fluxes
plt.figure(figsize=(8.5, 11))
#Generalizred plotting
for j in range(0, n_variants):
for k in range(0, n_variants):
if j <= k:
continue
plt.subplot(n_variants - 1, n_variants - 1, j + k)
plt.plot(np.log10(mean_fluxes[j][:]),
np.log10(mean_fluxes[k][:]), 'o')
plt.plot([-12, 0], [-12, 0],
color='k',
linestyle='-',
linewidth=2)
plt.xlabel('Variant ' + str(j) + ' Flux')
plt.ylabel('Variant ' + str(k) + ' Flux')
plt.ylim((-11, 0))
plt.xlim((-11, 0))
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
plt.close("all")
#nifty fun tool
# Bokeh
if len(mean_fluxes) < 2:
return
# Plot first metabolite to initialize plot settings
x = np.log10(mean_fluxes[0][:])
y = np.log10(mean_fluxes[1][:])
source = ColumnDataSource(data=dict(x=x, y=y, rxn=IDs))
hover = HoverTool(tooltips=[
("ID", "@rxn"),
])
TOOLS = [
hover,
BoxZoomTool(),
LassoSelectTool(),
PanTool(),
WheelZoomTool(),
ResizeTool(),
UndoTool(),
RedoTool(), "reset"
]
p = figure(
x_axis_label="Variant 0 Flux",
y_axis_label="Variant 1 Flux",
width=800,
height=800,
tools=TOOLS,
)
p.circle(
'x', 'y', size=5, source=source
) #np.log10(mean_fluxes[0][:]),np.log10(mean_fluxes[1][:]), size=10)
p.line([-12, 0], [-12, 0], color="firebrick", line_width=2)
if not os.path.exists(os.path.join(plotOutDir, "html_plots")):
os.makedirs(os.path.join(plotOutDir, "html_plots"))
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, 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, 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)
ap = AnalysisPaths(inputDir, variant_plot=True)
variants = sorted(ap._path_data['variant'].tolist()
) # Sorry for accessing private data
variant = variants[0]
sim_data = cPickle.load(open(ap.get_variant_kb(variant), "rb"))
targetToFC = {}
targetToFCTF = {}
for tf in sim_data.tfToActiveInactiveConds:
for target in sim_data.tfToFC[tf]:
if target not in targetToFC:
targetToFC[target] = []
targetToFCTF[target] = []
targetToFC[target].append(np.log2(sim_data.tfToFC[tf][target]))
targetToFCTF[target].append(tf)
for target in targetToFC:
targetToFC[target] = np.array(targetToFC[target])
targets = sorted(targetToFC)
x = []
y = []
maxVals = []
tfs = []
targetIds = []
for idx, target in enumerate(targets):
for FC, tf in zip(targetToFC[target], targetToFCTF[target]):
x.append(idx)
y.append(FC)
if targetToFC[target].max() >= -1. * targetToFC[target].min():
maxVals.append(targetToFC[target].max())
else:
maxVals.append(targetToFC[target].min())
tfs.append(tf)
targetIds.append(target)
conditions = [
sim_data.conditions[tf + "__active"]["nutrients"] for tf in tfs
]
x = np.array(x)
y = np.array(y)
maxVals = np.array(maxVals)
sortedIdxs = np.argsort(maxVals)
conditions = [conditions[i] for i in sortedIdxs]
tfs = [tfs[i] for i in sortedIdxs]
targetIds = [targetIds[i] for i in sortedIdxs]
fig = plt.figure(figsize=(11, 8.5))
ax = plt.subplot(1, 1, 1)
ax.plot(x, y[sortedIdxs], ".")
xlabel = "Gene targets (sorted)"
ylabel = "log2 (Target expression fold change)"
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
plt.close("all")
source = ColumnDataSource(data=dict(x=x,
y=y[sortedIdxs],
targetId=targetIds,
tfId=tfs,
condition=conditions))
hover = HoverTool(
tooltips=[("target",
"@targetId"), ("TF",
"@tfId"), ("condition", "@condition")])
tools = [
hover,
BoxZoomTool(),
LassoSelectTool(),
PanTool(),
WheelZoomTool(),
ResizeTool(),
UndoTool(),
RedoTool(), "reset"
]
plot = figure(x_axis_label=xlabel,
y_axis_label=ylabel,
width=800,
height=500,
tools=tools)
plot.scatter("x", "y", source=source)
if not os.path.exists(os.path.join(plotOutDir, "html_plots")):
os.makedirs(os.path.join(plotOutDir, "html_plots"))
bokeh.io.output_file(os.path.join(
plotOutDir, "html_plots",
plotOutFileName + "__probBound" + ".html"),
title=plotOutFileName,
autosave=False)
bokeh.io.save(plot)
bokeh.io.curstate().reset()
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)
variants = ap.get_variants()
index_doubling_time = 0
sim_doubling_time = []
index_rna_mass = 1
sim_rna_mass_per_cell = []
sim_rna_mass_per_cell_std = []
index_elng_rate = 2
sim_elng_rate = []
sim_elng_rate_std = []
index_n_origin_init = 3
sim_origins_per_cell_at_initiation = []
sim_origins_per_cell_at_initiation_std = []
index_rrn_init_rate = 4
sim_rrn_init_rate = []
sim_rrn_init_rate_std = []
for varIdx in range(ap.n_variant):
variant = variants[varIdx]
print("variant {}".format(variant))
sim_dirs = ap.get_cells(variant=[variant])
n_sims = len(sim_dirs)
print("Total cells: {}".format(n_sims))
try:
sim_data = cPickle.load(open(ap.get_variant_kb(variant)))
global is_rRNA
is_rRNA = sim_data.process.transcription.rnaData["isRRna"]
except Exception as e:
print "Couldn't load sim_data object. Exiting.", e
return
p = Pool(parallelization.cpus())
output = np.array(p.map(mp_worker, sim_dirs))
p.close()
p.join()
# Filter output from broken files using np.nanmean and np.nanstd
sim_doubling_time.append(np.nanmean(output[:, index_doubling_time]) / 60.)
sim_rna_mass_per_cell.append(np.nanmean(output[:, index_rna_mass]))
sim_rna_mass_per_cell_std.append(np.nanstd(output[:, index_rna_mass]))
sim_elng_rate.append(np.nanmean(output[:, index_elng_rate]))
sim_elng_rate_std.append(np.nanstd(output[:, index_elng_rate]))
sim_origins_per_cell_at_initiation.append(np.nanmean(output[:, index_n_origin_init]))
sim_origins_per_cell_at_initiation_std.append(np.nanstd(output[:, index_n_origin_init]))
sim_rrn_init_rate.append(np.nanmean(output[:, index_rrn_init_rate]))
sim_rrn_init_rate_std.append(np.nanstd(output[:, index_rrn_init_rate]))
sim_doubling_time = np.array(sim_doubling_time)
# Plot
fig, axes_list = plt.subplots(1, 4, figsize=(15, 5))
ax0, ax1, ax2, ax3 = axes_list
sort_sim = np.argsort(sim_doubling_time)[::-1]
sort_bremer = np.argsort(bremer_tau)[::-1]
# RNA mass per cell
ax0.errorbar(
sim_doubling_time[sort_sim],
np.array(sim_rna_mass_per_cell)[sort_sim],
yerr=np.array(sim_rna_mass_per_cell_std)[sort_sim],
color='tab:blue', **SIM_PLOT_STYLE)
ax0.errorbar(
bremer_tau[sort_bremer],
bremer_rna_mass_per_cell[sort_bremer],
color=HIGHLIGHT_COLOR, **EXP_PLOT_STYLE)
ax0.set_title('RNA mass per cell (fg)', fontsize=FONT_SIZE)
ax0.set_xlabel('Doubling time (min)', 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)
# Ribosome elongation rate
ax1.errorbar(
sim_doubling_time[sort_sim],
np.array(sim_elng_rate)[sort_sim],
yerr=np.array(sim_elng_rate_std)[sort_sim],
color='tab:blue', **SIM_PLOT_STYLE)
ax1.errorbar(
bremer_tau[sort_bremer],
bremer_elng_rate[sort_bremer],
color=HIGHLIGHT_COLOR, **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([5, 24])
# Number of origins at chromosome initiation
ax2.errorbar(
sim_doubling_time[sort_sim],
np.array(sim_origins_per_cell_at_initiation)[sort_sim],
yerr=np.array(sim_origins_per_cell_at_initiation_std)[sort_sim],
color='tab:blue', **SIM_PLOT_STYLE)
ax2.errorbar(
bremer_tau[sort_bremer],
bremer_origins_per_cell_at_initiation[sort_bremer],
color=HIGHLIGHT_COLOR, **EXP_PLOT_STYLE)
ax2.set_title('Average origins at chrom. init.', fontsize=FONT_SIZE)
ax2.set_xlabel('Doubling time (min)', fontsize=FONT_SIZE)
ax2.set_ylim([0.5, 4.5])
# rRNA initiation rate
ax3.errorbar(
sim_doubling_time[sort_sim],
np.array(sim_rrn_init_rate)[sort_sim],
yerr=np.array(sim_rrn_init_rate_std)[sort_sim],
color='tab:blue', **SIM_PLOT_STYLE)
ax3.errorbar(
bremer_tau[sort_bremer],
bremer_rrn_init_rate[sort_bremer],
color=HIGHLIGHT_COLOR, **EXP_PLOT_STYLE)
ax3.set_title('Rate of rrn initiation (1/min)', fontsize=FONT_SIZE)
ax3.set_ylim([0, 2500])
ax3.set_xlabel('Doubling time (min)', fontsize=FONT_SIZE)
for ax in axes_list:
ax.set_xlim(X_LIM)
ax.set_xticks(X_LIM)
ax.set_ylim(ax.get_ylim())
ax.set_yticks(ax.get_ylim())
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)
plt.subplots_adjust(bottom=0.25, top=0.75, left=0.05, right=0.95, wspace=0.4)
exportFigure(plt, plotOutDir, '{}__test'.format(plotOutFileName), metadata)
plt.close('all')