def plot_gc_content(self, fontsize=16, ec="k", bins=100):
"""plot GC content histogram
:params bins: a value for the number of bins or an array (with a copy()
method)
:param ec: add black contour on the bars
.. plot::
:include-source:
from sequana import BAM, sequana_data
b = BAM(sequana_data('test.bam'))
b.plot_gc_content()
"""
data = self.get_gc_content()
try:
X = np.linspace(0, 100, bins)
except:
X = bins.copy()
pylab.hist(data, X, density=True, ec=ec)
pylab.grid(True)
mu = pylab.mean(data)
sigma = pylab.std(data)
X = pylab.linspace(X.min(), X.max(), 100)
from sequana.misc import normpdf
pylab.plot(X, normpdf(X, mu, sigma), lw=2, color="r", ls="--")
pylab.xlabel("GC content", fontsize=16)
def hist_concordance(self, method, bins=100, fontsize=16):
"""
formula : 1 - (in + del + mismatch / (in + del + mismatch + match) )
For BWA and BLASR, the get_cigar_stats are different !!!
BWA for instance has no X stored while Pacbio forbids the use of the M
(CMATCH) tag. Instead, it uses X (CDIFF) and = (CEQUAL) characters.
Subread Accuracy: The post-mapping accuracy of the basecalls.
Formula: [1 - (errors/subread length)], where errors = number of deletions +
insertions + substitutions.
"""
try:
concordance = self._concordance
except:
self._set_concordance(method)
concordance = self._concordance
pylab.hist(concordance, bins=bins)
pylab.grid()
mu = np.mean(concordance)
median = np.median(concordance)
pylab.axvline(mu, color='r', alpha=0.5)
pylab.axvline(median, color='r', alpha=0.5, ls="--")
pylab.xlabel("concordance", fontsize=fontsize)
def hist_contig_length(self, bins=30, fontsize=16):
pylab.clf()
pylab.hist(self.df.length, lw=1, ec="k", bins=bins)
pylab.grid()
pylab.xlabel("Contig length", fontsize=fontsize)
pylab.ylabel("#", fontsize=fontsize)
pylab.title("Distribution {} contigs".format(len(self.df)))
def hist_length_repeats(self,
bins=None,
alpha=0.5,
hold=False,
fontsize=12,
grid=True,
label="Repeat length",
xlabel="Repeat length",
ylabel="#"):
"""Plots histogram of the repeat lengths
"""
# check that user has set a threshold
if self._list_len_repeats is None:
self._get_list_len_repeats()
if bins is None:
bins = range(max(0, self.threshold - 1),
max(self._list_len_repeats) + 2)
if hold is False:
pylab.clf()
pylab.hist(self._list_len_repeats, alpha=alpha, label=label, bins=bins)
pylab.legend()
pylab.xlabel(xlabel, fontsize=fontsize)
pylab.ylabel(ylabel, fontsize=fontsize)
if grid is True:
pylab.grid(True)
def hist_ORF_CDS_linearscale(self,
alpha=0.5,
bins=40,
xlabel="Length",
ylabel="#"):
if self._ORF_pos is None:
self._find_ORF_CDS()
n_ORF = self._ORF_pos["len_ORF"].dropna().shape[0]
n_CDS = self._ORF_pos["len_CDS"].dropna().shape[0]
# plot for all ORF and CDS
pylab.hist(self._ORF_pos["len_ORF"].dropna(),
alpha=alpha,
label="ORF, N = " + str(n_ORF),
bins=bins)
pylab.hist(self._ORF_pos["len_CDS"].dropna(),
alpha=alpha,
label="CDS, N = " + str(n_CDS),
bins=bins)
pylab.xlabel(xlabel)
pylab.ylabel(ylabel)
pylab.legend()
pylab.title("Length of ORF and CDS (after filter %s > %d)" \
%(self._type_filter, self._threshold))
def hist_concordance(self, bins=100, fontsize=16):
"""
formula : 1 - (in + del + mismatch / (in + del + mismatch + match) )
For BWA and BLASR, the get_cigar_stats are different !!!
BWA for instance has no X stored while Pacbio forbids the use of the M
(CMATCH) tag. Instead, it uses X (CDIFF) and = (CEQUAL) characters.
Subread Accuracy: The post-mapping accuracy of the basecalls.
Formula: [1 - (errors/subread length)], where errors = number of deletions +
insertions + substitutions.
"""
try:
concordance = self._concordance
except:
self._set_concordance()
concordance = self._concordance
pylab.hist(concordance, bins=bins)
pylab.grid()
mu = np.mean(concordance)
median = np.median(concordance)
pylab.axvline(mu, color='r', alpha=0.5)
pylab.axvline(median, color='r', alpha=0.5, ls="--")
pylab.xlabel("concordance", fontsize=fontsize)
def plot_gc_content(self, fontsize=16, ec="k", bins=100):
"""plot GC content histogram
:params bins: a value for the number of bins or an array (with a copy()
method)
:param ec: add black contour on the bars
.. plot::
:include-source:
from sequana import BAM, sequana_data
b = BAM(sequana_data('test.bam'))
b.plot_gc_content()
"""
data = self.get_gc_content()
try:
X = np.linspace(0, 100, bins)
except:
X = bins.copy()
pylab.hist(data, X, normed=True, ec=ec)
pylab.grid(True)
mu = pylab.mean(data)
sigma = pylab.std(data)
X = pylab.linspace(X.min(), X.max(), 100)
pylab.plot(X, pylab.normpdf(X, mu, sigma), lw=2, color="r", ls="--")
pylab.xlabel("GC content", fontsize=16)
def hist_length_repeats(self,
bins=20,
alpha=0.5,
hold=False,
fontsize=12,
grid=True,
title="Repeat length",
xlabel="Repeat length",
ylabel="#"):
"""Plots histogram of the repeat lengths
"""
# check that user has set a threshold
if self._list_len_repeats is None:
self._get_list_len_repeats()
if hold is False:
pylab.clf()
pylab.hist(self._list_len_repeats, alpha=alpha, bins=bins)
pylab.title(title)
pylab.xlabel(xlabel, fontsize=fontsize)
pylab.ylabel(ylabel, fontsize=fontsize)
if grid is True:
pylab.grid(True)
def hist_plot_contig_length(self, bins=40, fontsize=16):
"""Plot distribution of contig lengths"""
L = len(self.fasta.sequences)
pylab.hist(self.fasta.lengths, lw=1, ec="k", bins=bins)
pylab.grid()
pylab.xlabel("Contig length", fontsize=fontsize)
pylab.ylabel("#", fontsize=fontsize)
pylab.title("Distribution {} contigs".format(L))
def plot_padj_hist(self, bins=60, fontsize=16):
pylab.hist(self.df.padj.dropna(), bins=bins, ec="k")
pylab.grid(True)
pylab.xlabel("Adjusted p-value", fontsize=fontsize)
pylab.ylabel("Occurences", fontsize=fontsize)
try:
pylab.tight_layout()
except:
pass
def plot_pvalue_hist(self, bins=60, fontsize=16, rotation=0):
pylab.hist(self.df.pvalue.dropna(), bins=bins, ec="k")
pylab.grid(True)
pylab.xlabel("raw p-value", fontsize=fontsize)
pylab.ylabel("Occurences", fontsize=fontsize)
try:
pylab.tight_layout()
except:
pass
def hist_GC(self,
bins=50,
alpha=0.5,
hold=False,
fontsize=12,
grid=True,
xlabel="GC %",
ylabel="#",
label="",
title=None):
"""Plot histogram GC content
:param int bins: binning for the histogram
:param float alpha: transparency of the histograms
:param bool hold:
:param int fontsize: fontsize of the x and y labels and title.
:param bool grid: add grid or not
:param str xlabel:
:param str ylabel:
:param str label: label of the histogram (for the legend)
:param str title:
.. plot::
:include-source:
from sequana.pacbio import PacbioSubreads
from sequana import sequana_data
b = PacbioSubreads(sequana_data("test_pacbio_subreads.bam"))
b.hist_GC()
"""
mean_GC = np.mean(self.df.loc[:, 'GC_content'])
# set title if needed
if title is None:
title = "GC %% \n Mean GC : %.2f" % (mean_GC)
# histogram GC percent
if hold is False:
pylab.clf()
pylab.hist(self.df.loc[:, 'GC_content'],
bins=bins,
alpha=alpha,
label=label + ", mean : " + str(round(mean_GC, 2)) +
", N : " + str(len(self)))
pylab.xlabel(xlabel, fontsize=fontsize)
pylab.ylabel(ylabel, fontsize=fontsize)
pylab.title(title, fontsize=fontsize)
if grid is True:
pylab.grid(True)
pylab.xlim([0, 100])
try:
pylab.tight_layout()
except:
pass
def plot_genesets_hist(self, bins=20):
N = len(self.gene_sets.keys())
pylab.clf()
pylab.hist([len(v) for k, v in self.gene_sets.items()],
bins=bins,
lw=1,
ec="k")
pylab.title("{} gene sets".format(N))
pylab.xlabel("Gene set sizes")
pylab.grid(True)
a, b = pylab.xlim()
pylab.xlim([0, b])
def hist_isoform_length_mapped_vs_unmapped(self, bins=None):
df = self.df
if bins is None:
bins = range(0, len(df.reference_length.max()), 100)
mapped = df[df.reference_name != -1]
unmapped = df[df.reference_name == -1]
pylab.hist(mapped.reference_length, bins=bins, alpha=0.5,
label="mapped {}".format(len(mapped)), density=False)
pylab.hist(unmapped.reference, bins=bins, alpha=0.5,
label="unmapped {}".format(len(unmapped)), density=False)
pylab.xlabel("Isoform length")
pylab.legend()
def hist_isoform_length_mapped_vs_unmapped(self, bins=None):
df = self.df
if bins is None:
bins = range(0, df.read_length.max(), 100)
mapped = df[df.reference_name != -1]
unmapped = df[df.reference_name == -1]
pylab.hist(mapped.read_length, bins=bins, alpha=0.5,
label="mapped {}".format(len(mapped)), normed=True)
pylab.hist(unmapped.read_length, bins=bins, alpha=0.5,
label="unmapped {}".format(len(unmapped)), normed=True)
pylab.xlabel("Isoform length")
pylab.legend()
def hist_len(self,
bins=50,
alpha=0.5,
hold=False,
fontsize=12,
grid=True,
xlabel="Read Length",
ylabel="#",
label="",
title=None):
"""Plot histogram Read length
:param int bins: binning for the histogram
:param float alpha: transparency of the histograms
:param bool hold:
:param int fontsize:
:param bool grid:
:param str xlabel:
:param str ylabel:
:param str label: label of the histogram (for the legend)
:param str title:
.. plot::
:include-source:
from sequana.pacbio import BAMPacbio
from sequana import sequana_data
b = BAMPacbio(sequana_data("test_pacbio_subreads.bam"))
b.hist_len()
"""
if self._df is None:
self._get_df()
mean_len = np.mean(self._df.loc[:, 'read_length'])
# set title if not provided
if title is None:
title = "Read length \n Mean length : %.2f" % (mean_len)
# histogram GC percent
if hold is False:
pylab.clf()
pylab.hist(self._df.loc[:, 'read_length'],
bins=bins,
alpha=alpha,
label="%s, mean : %.0f, N : %d" %
(label, mean_len, self._N))
pylab.xlabel(xlabel, fontsize=fontsize)
pylab.ylabel(ylabel, fontsize=fontsize)
pylab.title(title, fontsize=fontsize)
if grid is True:
pylab.grid(True)
def hist_nb_passes(self,
bins=None,
alpha=0.5,
hold=False,
fontsize=12,
grid=True,
xlabel="Number of ZMW passes",
logy=True,
ylabel="#",
label="",
title="Number of ZMW passes"):
"""Plot histogram of number of reads per ZMW (number of passes)
:param float alpha: transparency of the histograms
:param bool hold:
:param int fontsize:
:param bool grid:
:param str xlabel:
:param str ylabel:
:param bool logy: use log scale on the y axis (default to True)
:param str label: label of the histogram (for the legend)
:param str title:
.. plot::
:include-source:
from sequana.pacbio import PacbioSubreads
from sequana import sequana_data
b = PacbioSubreads(sequana_data("test_pacbio_subreads.bam"))
b.hist_nb_passes()
"""
max_nb_pass = self.df.nb_passes.max()
if bins is None:
k = range(1, max_nb_pass + 1)
# histogram nb passes
if hold is False:
pylab.clf()
pylab.hist(self.df.nb_passes,
bins=bins,
alpha=alpha,
label=label,
log=logy,
width=1)
if len(k) < 5:
pylab.xticks(range(6), range(6))
pylab.xlabel(xlabel, fontsize=fontsize)
pylab.ylabel(ylabel, fontsize=fontsize)
pylab.title(title, fontsize=fontsize)
if grid is True:
pylab.grid(True)
def hist_qual(self, fontsize=16, bins=100):
"""
This uses the QUAL information to be found in the VCF and should
work for all VCF with version 4.1 (at least)
"""
# TODO: could be moved to VCFBase
self.vcf.rewind()
data = [x.QUAL for x in self.vcf]
pylab.hist(data, bins=bins)
pylab.grid(True)
pylab.xlabel("Variant quality", fontsize=fontsize)
def run(self,
bins=50,
xmin=0,
xmax=30000,
step=1000,
burn=1000,
alpha=1,
output_filename=None):
# compute histogram of the input reads once for all to be used
# in the target_distribution method
self.bins = bins
self.Y, self.X = np.histogram(self.bam.df.read_length,
bins=bins,
normed=True)
lengths = self.bam_simul.df.read_length.values
self.tokeep = []
vec = []
x = self.bam.df.read_length.mean()
for i in range(self.bam_simul.df.shape[0]):
can = lengths[i]
aprob = min([
alpha,
self.target_distribution(can) / self.target_distribution(x)
])
#acceptance probability
u = pylab.uniform(0, 1)
if u < aprob:
x = can
vec.append(x)
self.tokeep.append(True)
else:
self.tokeep.append(False)
#plotting the results:
#theoretical curve
x = pylab.arange(xmin, xmax, step)
y = self.target_distribution(x)
pylab.subplot(211)
pylab.title('Metropolis-Hastings')
pylab.plot(vec)
pylab.subplot(212)
pylab.hist(vec[burn:], bins=bins, normed=1)
pylab.plot(x, y, 'r-')
pylab.ylabel('Frequency')
pylab.xlabel('x')
pylab.legend(('PDF', 'Samples'))
if output_filename is not None:
self.bam_simul.filter_bool(output_filename, self.tokeep)
def plot(self,
normed=True,
N=1000,
Xmin=None,
Xmax=None,
bins=50,
color='red',
lw=2,
hist_kw={
'color': '#5F9EA0',
"edgecolor": "k"
},
ax=None):
if ax:
ax.hist(self.data, normed=normed, bins=bins, **hist_kw)
else:
pylab.hist(self.data, density=normed, bins=bins, **hist_kw)
if Xmin is None:
Xmin = self.data.min()
if Xmax is None:
Xmax = self.data.max()
X = pylab.linspace(Xmin, Xmax, N)
if ax:
ax.plot(X, [self.model.pdf(x, self.results.x) for x in X],
color=color,
lw=lw)
else:
pylab.plot(X, [self.model.pdf(x, self.results.x) for x in X],
color=color,
lw=lw)
K = len(self.results.x)
# The PIs must be normalised
import scipy.stats as ss
for i in range(self.k):
mu, sigma, pi_ = self.results.mus[i], self.results.sigmas[
i], self.results.pis[i]
if ax:
ax.plot(X, [pi_ * ss.norm.pdf(x, mu, sigma) for x in X],
'k--',
alpha=0.7,
lw=2)
else:
pylab.plot(X, [pi_ * ss.norm.pdf(x, mu, sigma) for x in X],
'k--',
alpha=0.7,
lw=2)
def hist_snr(self, bins=50, alpha=0.5, hold=False, fontsize=12,
grid=True, xlabel="SNR", ylabel="#",title="", clip_upper_SNR=30):
"""Plot histogram of the ACGT SNRs for all reads
:param int bins: binning for the histogram. Note that the range starts
at 0 and ends at clip_upper_SNR
:param float alpha: transparency of the histograms
:param bool hold:
:param int fontsize:
:param bool grid:
:param str xlabel:
:param str ylabel:
:param str title:
.. plot::
:include-source:
from sequana.pacbio import PacbioSubreads
from sequana import sequana_data
b = PacbioSubreads(sequana_data("test_pacbio_subreads.bam"))
b.hist_snr()
"""
if self._df is None:
self._get_df()
# old pacbio format has no SNR stored
if len(self._df['snr_A'].dropna()) == 0:
# nothing to plot
from sequana import sequana_data
pylab.clf()
pylab.imshow(pylab.imread(sequana_data("no_data.jpg")))
pylab.gca().axis('off')
return
if hold is False:
pylab.clf()
maxSNR = 0
for letter in "ACGT":
m = self._df.loc[:,"snr_{}".format(letter)].max()
if m > maxSNR:
maxSNR = m
if maxSNR > clip_upper_SNR:
maxSNR = clip_upper_SNR
bins = pylab.linspace(0, maxSNR, bins)
pylab.hist(self._df.loc[:,'snr_A'].clip_upper(maxSNR), alpha=alpha, label="A", bins=bins)
pylab.hist(self._df.loc[:,'snr_C'].clip_upper(maxSNR), alpha=alpha, label="C", bins=bins)
pylab.hist(self._df.loc[:,'snr_G'].clip_upper(maxSNR), alpha=alpha, label="G", bins=bins)
pylab.hist(self._df.loc[:,'snr_T'].clip_upper(maxSNR), alpha=alpha, label="T", bins=bins)
pylab.legend()
pylab.xlabel(xlabel, fontsize=fontsize)
pylab.ylabel(ylabel, fontsize=fontsize)
pylab.title(title,fontsize=fontsize)
if grid is True:
pylab.grid(True)
def hist_ORF_CDS_linearscale(self, alpha=0.5, bins=40, xlabel="Length", ylabel="#"):
if self._ORF_pos is None:
self._find_ORF_CDS()
n_ORF = self._ORF_pos["len_ORF"].dropna().shape[0]
n_CDS = self._ORF_pos["len_CDS"].dropna().shape[0]
# plot for all ORF and CDS
pylab.hist(self._ORF_pos["len_ORF"].dropna(),alpha=alpha, label="ORF, N = " + str(n_ORF),bins=bins)
pylab.hist(self._ORF_pos["len_CDS"].dropna(),alpha=alpha, label="CDS, N = " + str(n_CDS),bins=bins)
pylab.xlabel(xlabel)
pylab.ylabel(ylabel)
pylab.legend()
pylab.title("Length of ORF and CDS (after filter %s > %d)" \
%(self._type_filter, self._threshold))
def hist_coverage(self, bins=100):
"""
.. plot::
:include-source:
from sequana import sequana_data, BAM
b = BAM(sequana_data("measles.fa.sorted.bam"))
b.hist_coverage()
"""
try: self.coverage
except: self.set_fast_stats()
pylab.hist(self.coverage, bins=bins)
pylab.xlabel("Coverage")
pylab.ylabel("Number of mapped bases")
pylab.grid()
def hist_read_length_consensus_isoform(self, mode="all", bins=80, rwidth=0.8,
align="left", fontsize=16, edgecolor="k", **kwargs):
"""
mode can be all, lq, hq
"""
pylab.clf()
L1 = [len(read['sequence']) for read in self.lq_sequence]
L2 = [len(read['sequence']) for read in self.hq_sequence]
if mode == "all":
L = L1 + L2
elif mode == "lq":
L = L1
else:
L = L2
Y, X, _ = pylab.hist(L, bins=bins, rwidth=rwidth, align=align,
ec=edgecolor, **kwargs)
pylab.gca().set_ylim(bottom=0)
pylab.gca().set_xlim(left=0)
pylab.xlabel("Read length", fontsize=fontsize)
pylab.ylabel("Number of reads", fontsize=fontsize)
pylab.grid()
ax_twin = pylab.gca().twinx()
shift = (X[1] - X[0]) / 2
ax_twin.plot(X[0:-1]- shift, len(L) - pylab.cumsum(Y), "k")
ax_twin.set_ylim(bottom=0)
pylab.ylabel("CDF", fontsize=fontsize)
pylab.title("Read length of Consensus isoforms reads")
def hist_read_length_consensus_isoform(self, mode="all", bins=80, rwidth=0.8,
align="left", fontsize=16, edgecolor="k", **kwargs):
"""
mode can be all, lq, hq
"""
pylab.clf()
L1 = [len(read['sequence']) for read in self.lq_sequence]
L2 = [len(read['sequence']) for read in self.hq_sequence]
if mode == "all":
L = L1 + L2
elif mode == "lq":
L = L1
else:
L = L2
Y, X, _ = pylab.hist(L, bins=bins, rwidth=rwidth, align=align,
ec=edgecolor, **kwargs)
pylab.gca().set_ylim(bottom=0)
pylab.gca().set_xlim(left=0)
pylab.xlabel("Read length", fontsize=fontsize)
pylab.ylabel("Number of reads", fontsize=fontsize)
pylab.grid()
ax_twin = pylab.gca().twinx()
shift = (X[1] - X[0]) / 2
ax_twin.plot(X[0:-1]- shift, len(L) - pylab.cumsum(Y), "k")
ax_twin.set_ylim(bottom=0)
pylab.ylabel("CDF", fontsize=fontsize)
pylab.title("Read length of Consensus isoforms reads")
def hist_coverage(self, bins=100):
"""
.. plot::
:include-source:
from sequana import sequana_data, BAM
b = BAM(sequana_data("measles.fa.sorted.bam"))
b.hist_coverage()
"""
try: self.coverage
except: self._set_coverage()
pylab.hist(self.coverage, bins=bins)
pylab.xlabel("Coverage")
pylab.ylabel("Number of mapped bases")
pylab.grid()
def check(self, bins=60):
y, x, _ = pylab.hist(self.vec, bins, density=True, lw=0.5, ec="k")
M1 = max(y)
# this normalisation is an approximation/hack
pylab.plot(self.Xtarget, self.Ytarget/ (max(self.Ytarget)/M1), "-ro")
pylab.title("simulated (blue) and target (red) distributions")
def hist_GC(self, bins=50, hold=False, fontsize=12,
grid=True,xlabel="GC %",ylabel="#"):
"""Plot histogram GC content"""
if self._df is None:
self._get_df()
mean_GC = np.mean(self._df.loc[:,'GC_content'])
# histogram GC percent
if hold is False:
pylab.clf()
pylab.hist(self._df.loc[:,'GC_content'], bins=bins)
pylab.xlabel(xlabel, fontsize=fontsize)
pylab.ylabel(ylabel, fontsize=fontsize)
pylab.title("GC %% \n Mean GC : %.2f" %(mean_GC), fontsize=fontsize)
if grid is True:
pylab.grid(True)
def hist_length_repeats(self, bins=20, alpha=0.5, hold=False,
fontsize=12, grid=True, title="Repeat length",
xlabel="Repeat length", ylabel="#", logy=True):
"""Plots histogram of the repeat lengths
"""
# check that user has set a threshold
if hold is False:
pylab.clf()
pylab.hist(self.list_len_repeats, alpha=alpha, bins=bins)
pylab.title(title)
pylab.xlabel(xlabel, fontsize=fontsize)
pylab.ylabel(ylabel, fontsize=fontsize)
if grid is True:
pylab.grid(True)
if logy:
pylab.semilogy()
def histogram_gc_content(self):
"""Plot histogram of GC content
.. plot::
:include-source:
from sequana import sequana_data
from sequana import FastQC
filename = sequana_data("test.fastq", "testing")
qc = FastQC(filename)
qc.histogram_gc_content()
"""
pylab.hist(self.gc_list, bins=range(0, 100))
pylab.grid()
pylab.title("GC content distribution (per sequence)")
pylab.xlabel(r"Mean GC content (%)", fontsize=self.fontsize)
pylab.xlim([0,100])
def diagnostics(self, bins=60, clear=True):
if clear: pylab.clf()
pylab.subplot(3,1,1)
pylab.hist(self.aprob, bins=bins)
pylab.title("Acceptation")
pylab.subplot(3,1,2)
pylab.plot(self.vec)
pylab.title("proposition")
pylab.subplot(3,1,3)
y, x, _ = pylab.hist(self.vec, bins, density=True, lw=0.5, ec="k")
M1 = max(y)
# this normalisation is an approximation/hack
pylab.plot(self.Xtarget, self.Ytarget/ (max(self.Ytarget)/M1), "-ro")
pylab.title("simulated (blue) and target (red) distributions")
def hist_GC(self, bins=50, alpha=0.5, hold=False, fontsize=12,
grid=True, xlabel="GC %", ylabel="#", label="",title=None):
"""Plot histogram GC content
:param int bins: binning for the histogram
:param float alpha: transparency of the histograms
:param bool hold:
:param int fontsize: fontsize of the x and y labels and title.
:param bool grid: add grid or not
:param str xlabel:
:param str ylabel:
:param str label: label of the histogram (for the legend)
:param str title:
.. plot::
:include-source:
from sequana.pacbio import PacbioSubreads
from sequana import sequana_data
b = PacbioSubreads(sequana_data("test_pacbio_subreads.bam"))
b.hist_GC()
"""
mean_GC = np.mean(self.df.loc[:,'GC_content'])
# set title if needed
if title is None:
title = "GC %% \n Mean GC : %.2f" %(mean_GC)
# histogram GC percent
if hold is False:
pylab.clf()
pylab.hist(self.df.loc[:,'GC_content'], bins=bins,
alpha=alpha, label=label + ", mean : " + str(round(mean_GC, 2))
+ ", N : " + str(len(self)))
pylab.xlabel(xlabel, fontsize=fontsize)
pylab.ylabel(ylabel, fontsize=fontsize)
pylab.title(title, fontsize=fontsize)
if grid is True:
pylab.grid(True)
pylab.xlim([0, 100])
try: pylab.tight_layout()
except:pass
def hist_snr(self,
bins=50,
alpha=0.5,
hold=False,
fontsize=12,
grid=True,
xlabel="SNR",
ylabel="#",
title=""):
"""Plot histogram of the ACGT SNRs for all reads
:param int bins: binning for the histogram
:param float alpha: transparency of the histograms
:param bool hold:
:param int fontsize:
:param bool grid:
:param str xlabel:
:param str ylabel:
:param str title:
.. plot::
:include-source:
from sequana.pacbio import BAMPacbio
from sequana import sequana_data
b = BAMPacbio(sequana_data("test_pacbio_subreads.bam"))
b.hist_snr()
"""
if self._df is None:
self._get_df()
# old pacbio format has no SNR stored
if len(self._df['snr_A'].dropna()) == 0:
# nothing to plot
from sequana import sequana_data
pylab.clf()
pylab.imshow(pylab.imread(sequana_data("no_data.jpg")))
pylab.gca().axis('off')
return
if hold is False:
pylab.clf()
pylab.hist(self._df.loc[:, 'snr_A'], alpha=alpha, label="A", bins=bins)
pylab.hist(self._df.loc[:, 'snr_C'], alpha=alpha, label="C", bins=bins)
pylab.hist(self._df.loc[:, 'snr_G'], alpha=alpha, label="G", bins=bins)
pylab.hist(self._df.loc[:, 'snr_T'], alpha=alpha, label="T", bins=bins)
pylab.legend()
pylab.xlabel(xlabel, fontsize=fontsize)
pylab.ylabel(ylabel, fontsize=fontsize)
pylab.title(title, fontsize=fontsize)
if grid is True:
pylab.grid(True)
def hist_nb_passes(self, bins=None, alpha=0.5, hold=False, fontsize=12,
grid=True, xlabel="Number of ZMW passes", logy=True,
ylabel="#", label="", title="Number of ZMW passes"):
"""Plot histogram of number of reads per ZMW (number of passes)
:param float alpha: transparency of the histograms
:param bool hold:
:param int fontsize:
:param bool grid:
:param str xlabel:
:param str ylabel:
:param bool logy: use log scale on the y axis (default to True)
:param str label: label of the histogram (for the legend)
:param str title:
.. plot::
:include-source:
from sequana.pacbio import PacbioSubreads
from sequana import sequana_data
b = PacbioSubreads(sequana_data("test_pacbio_subreads.bam"))
b.hist_nb_passes()
"""
max_nb_pass = self.df.nb_passes.max()
if bins is None:
k = range(1, max_nb_pass+1)
# histogram nb passes
if hold is False:
pylab.clf()
pylab.hist(self.df.nb_passes, bins=bins, alpha=alpha,
label=label, log=logy, width=1)
if len(k) < 5:
pylab.xticks(range(6), range(6))
pylab.xlabel(xlabel, fontsize=fontsize)
pylab.ylabel(ylabel, fontsize=fontsize)
pylab.title(title, fontsize=fontsize)
if grid is True:
pylab.grid(True)
def hist_ZMW_subreads(self, hold=False, fontsize=12,
grid=True,xlabel="Number of ZMW passes",ylabel="#"):
"""
Plot histogram of number of reads per ZMW
"""
if self._nb_pass is None:
self._get_ZMW_passes()
max_nb_pass = max(self._nb_pass.keys())
k = range(1,max_nb_pass+1)
val = [self._nb_pass[i] for i in k]
# histogram nb passes
if hold is False:
pylab.clf()
pylab.hist(k, weights=val, bins=max_nb_pass)
pylab.xlabel(xlabel, fontsize=fontsize)
pylab.ylabel(ylabel, fontsize=fontsize)
pylab.yscale('log')
pylab.title("Number of ZMW passes",fontsize=fontsize)
if grid is True:
pylab.grid(True)
def run(self, bins=50, xmin=0, xmax=30000, step=1000, burn=1000,alpha=1,output_filename=None):
# compute histogram of the input reads once for all to be used
# in the target_distribution method
self.bins = bins
self.Y, self.X = np.histogram(self.bam.df.read_length, bins=bins, density=True)
lengths = self.bam_simul.df.read_length.values
self.tokeep = []
vec = []
x = self.bam.df.read_length.mean()
for i in range(self.bam_simul.df.shape[0]):
can = lengths[i]
aprob = min([alpha,self.target_distribution(can)/self.target_distribution(x)])
#acceptance probability
u = pylab.uniform(0,1)
if u < aprob:
x = can
vec.append(x)
self.tokeep.append(True)
else:
self.tokeep.append(False)
#plotting the results:
#theoretical curve
x = pylab.arange(xmin, xmax, step)
y = self.target_distribution(x)
pylab.subplot(211)
pylab.title('Metropolis-Hastings')
pylab.plot(vec)
pylab.subplot(212)
pylab.hist(vec[burn:], bins=bins, density=1)
pylab.plot(x,y,'r-')
pylab.ylabel('Frequency')
pylab.xlabel('x')
pylab.legend(('PDF','Samples'))
if output_filename is not None:
self.bam_simul.filter_bool(output_filename, self.tokeep)
def hist_snr(self, bins=50, alpha=0.5, hold=False, fontsize=12,
grid=True,xlabel="SNR",ylabel="#"):
"""Plot histogram of the ACGT SNRs for all reads"""
if self._df is None:
self._get_df()
if hold is False:
pylab.clf()
pylab.hist(self._df.loc[:,'snr_A'], alpha=alpha, label="A", bins=bins)
pylab.hist(self._df.loc[:,'snr_C'], alpha=alpha, label="C", bins=bins)
pylab.hist(self._df.loc[:,'snr_G'], alpha=alpha, label="G", bins=bins)
pylab.hist(self._df.loc[:,'snr_T'], alpha=alpha, label="T", bins=bins)
pylab.legend()
pylab.xlabel(xlabel, fontsize=fontsize)
pylab.ylabel(ylabel, fontsize=fontsize)
if grid is True:
pylab.grid(True)
def plot_hist_coverage(self, logx=True, logy=True, fontsize=16, N=20,
fignum=1, hold=False, alpha=0.5, filename=None, **kw_hist):
"""
"""
if hold is False:
pylab.figure(fignum)
pylab.clf()
ax = pylab.gca()
ax.set_facecolor('#eeeeee')
data = self.df['cov'].dropna().values
maxcov = data.max()
if logx is True and logy is True:
bins = pylab.logspace(0, pylab.log10(maxcov), N)
pylab.hist(data, bins=bins, log=True, label=self.chrom_name,
alpha=alpha, **kw_hist)
pylab.semilogx()
pylab.xlabel("Coverage (log scale)", fontsize=fontsize)
pylab.ylabel("Count (log scale)", fontsize=fontsize)
elif logx is False and logy is True:
pylab.hist(data, bins=N, log=True, label=self.chrom_name,
alpha=alpha, **kw_hist)
pylab.xlabel("Coverage", fontsize=fontsize)
pylab.ylabel("Count (log scale)", fontsize=fontsize)
elif logx is True and logy is False:
bins = pylab.logspace(0, pylab.log10(maxcov), N)
pylab.hist(data, bins=N, label=self.chrom_name, alpha=alpha,
**kw_hist)
pylab.xlabel("Coverage (log scale)", fontsize=fontsize)
pylab.ylabel("Count", fontsize=fontsize)
pylab.semilogx()
else:
pylab.hist(data, bins=N, label=self.chrom_name, alpha=alpha,
**kw_hist)
pylab.xlabel("Coverage", fontsize=fontsize)
pylab.ylabel("Count", fontsize=fontsize)
pylab.grid(True)
if filename:
pylab.savefig(filename)
def plot(self, bins=80, rwidth=0.8, **kwargs):
pylab.clf()
Y, X, _ = pylab.hist(self.data, bins=bins, rwidth=rwidth, **kwargs)
pylab.xlabel(self.xlabel, fontsize=self.fontsize)
pylab.ylabel(self.ylabel, fontsize=self.fontsize)
"""self.Y = Y
self.X = X
ax_twin = pylab.gca().twinx()
shift = (X[1] - X[0]) / 2
ax_twin.plot(X[0:-1]- shift, len(self.data) - pylab.cumsum(Y), "k")
ax_twin.set_ylim(bottom=0)
pylab.ylabel("CDF", fontsize=self.fontsize)
"""
pylab.grid(self.grid)
pylab.title(self.title)
try: pylab.tight_layout()
except:pass
def plot(self, bins=80, rwidth=0.8, **kwargs):
pylab.clf()
Y, X, _ = pylab.hist(self.data, bins=bins, rwidth=rwidth, **kwargs)
pylab.xlabel(self.xlabel, fontsize=self.fontsize)
pylab.ylabel(self.ylabel, fontsize=self.fontsize)
"""self.Y = Y
self.X = X
ax_twin = pylab.gca().twinx()
shift = (X[1] - X[0]) / 2
ax_twin.plot(X[0:-1]- shift, len(self.data) - pylab.cumsum(Y), "k")
ax_twin.set_ylim(bottom=0)
pylab.ylabel("CDF", fontsize=self.fontsize)
"""
pylab.grid(self.grid)
pylab.title(self.title)
try:
pylab.tight_layout()
except:
pass
def hist_snr(self,
bins=50,
alpha=0.5,
hold=False,
fontsize=12,
grid=True,
xlabel="SNR",
ylabel="#",
title="",
clip_upper_SNR=30):
"""Plot histogram of the ACGT SNRs for all reads
:param int bins: binning for the histogram. Note that the range starts
at 0 and ends at clip_upper_SNR
:param float alpha: transparency of the histograms
:param bool hold:
:param int fontsize:
:param bool grid:
:param str xlabel:
:param str ylabel:
:param str title:
.. plot::
:include-source:
from sequana.pacbio import PacbioSubreads
from sequana import sequana_data
b = PacbioSubreads(sequana_data("test_pacbio_subreads.bam"))
b.hist_snr()
"""
if self._df is None:
self._get_df()
# old pacbio format has no SNR stored
if len(self._df['snr_A'].dropna()) == 0:
# nothing to plot
from sequana import sequana_data
pylab.clf()
pylab.imshow(pylab.imread(sequana_data("no_data.jpg")))
pylab.gca().axis('off')
return
if hold is False:
pylab.clf()
maxSNR = 0
for letter in "ACGT":
m = self._df.loc[:, "snr_{}".format(letter)].max()
if m > maxSNR:
maxSNR = m
if maxSNR > clip_upper_SNR:
maxSNR = clip_upper_SNR
bins = pylab.linspace(0, maxSNR, bins)
pylab.hist(self._df.loc[:, 'snr_A'].clip_upper(maxSNR),
alpha=alpha,
label="A",
bins=bins)
pylab.hist(self._df.loc[:, 'snr_C'].clip_upper(maxSNR),
alpha=alpha,
label="C",
bins=bins)
pylab.hist(self._df.loc[:, 'snr_G'].clip_upper(maxSNR),
alpha=alpha,
label="G",
bins=bins)
pylab.hist(self._df.loc[:, 'snr_T'].clip_upper(maxSNR),
alpha=alpha,
label="T",
bins=bins)
pylab.legend()
pylab.xlabel(xlabel, fontsize=fontsize)
pylab.ylabel(ylabel, fontsize=fontsize)
pylab.title(title, fontsize=fontsize)
if grid is True:
pylab.grid(True)
def hist_read_length(self, bins=100):
pylab.hist(self.lengths, bins=bins)
def hist_passes(self, bins=100):
pylab.hist(self.passes, bins=bins)
def hist_read_length(self, bins=100):
pylab.hist(self.lengths, bins=bins)
