def makePowerSpectrum(
self, freqs: np.array, power: np.array, sm_power: np.array,
band_max_power: float, freq_at_band_max_power: float,
max_freq: int = 50, theta_range: tuple = [6, 12],
ax: matplotlib.axes = None, **kwargs) -> matplotlib.axes:
# downsample frequencies and power
freqs = freqs[0::50]
power = power[0::50]
sm_power = sm_power[0::50]
if ax is None:
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(freqs, power, alpha=0.5, color=[0.8627, 0.8627, 0.8627])
ax.plot(freqs, sm_power)
ax.set_xlim(0, max_freq)
ylim = [0, band_max_power / 0.8]
if 'ylim' in kwargs:
ylim = kwargs['ylim']
ax.set_ylim(ylim)
ax.set_ylabel('Power')
ax.set_xlabel('Frequency')
ax.text(
x=theta_range[1] / 0.9, y=band_max_power,
s=str(freq_at_band_max_power)[0:4], fontsize=20)
from matplotlib.patches import Rectangle
r = Rectangle((
theta_range[0], 0), width=np.diff(theta_range)[0],
height=np.diff(ax.get_ylim())[0], alpha=0.25, color='r', ec='none')
ax.add_patch(r)
return ax
def plot_openness_by_hour(data: list, period: dict, ax: Axes):
"""
Plots the openness by hour from the raw data.
:param data: Raw data
:param period: Period over which to average the openness
:param ax: Axes object in which to put the plot
:return: None
"""
num_hrs = 24
# Get data
hour_bins = get_openness_by_hour(data, period)
# Plot bar chart
ax.bar(range(num_hrs + 1), hour_bins)
# Decorate the axes
ax.yaxis.grid(True, which="both", linestyle="-.")
ax.set_xlim(1, num_hrs)
ax.set_xticks(range(num_hrs + 1))
ax.set_xticklabels([f"{t:02d}" for t in ax.get_xticks()])
ax.set_yticklabels([f"{o * 100:.1f}{percent()}" for o in ax.get_yticks()])
ax.set_ylabel("Andel åpen")
ax.set_xlabel("Tid på døgnet")
def plotPRITransformVal(ax: axes,
bins: np.array,
vals: np.array,
title: str = None,
plot_ylabel: bool = False) -> None:
ax.plot(bins, vals, linewidth=2)
ax.set_title(title, fontsize=10)
ax.set_xlabel('pri[us]', fontsize=8, loc='right')
if plot_ylabel:
ax.set_ylabel('interval values', fontsize=10)
def plotTTPMat(ax: axes,
toa: np.array,
ttp: np.array,
title: str = None,
plot_ylabel: bool = False) -> None:
ax.scatter(toa, ttp, marker='o', c=ttp, alpha=0.75)
ax.set_ylim(PRI_DETECTED_RANGE[0], PRI_DETECTED_RANGE[1])
ax.xaxis.get_major_formatter().set_powerlimits((0, 1))
ax.set_title(title, fontsize=10)
ax.set_xlabel('toa[us]', fontsize=8, loc='right')
if plot_ylabel:
ax.set_ylabel('pri[us]', fontsize=9)
def make_stats_plot(cohort_averages: dict,
observable: str,
in_ax: matplotlib.axes,
geo: bool = False,
labelsize: int = 12,
ticksize: int = 10,
legendsize: int = 8,
box=False) -> None:
"""Plots an observable for all cohorts on a single axes object.
Parameters
----------
cohort_averages : dict
Dictionary of averages and variations within a cohort for all severities.
observable : str
The quantity which is going to be plotted.
in_ax : matplotlib.axes
The axes on which values are going to be plotted.
geo: bool, optional
Specifies geometric or arithmetic averaging.
labelsize : int, optional
Size of axes labels.
ticksize : int, optional
Size of tick labels.
legendsize : int, optional
Specifies font size of strings in legend.
box : bool, optional
Specifies whether or not a box plot has been plotted.
Returns
-------
None
"""
cohort_plot(cohort_averages, observable, in_ax=in_ax, geo=geo)
# Name of xlabel for each observable.
xlabels = {
'cdr3 length': 'HCDR3 length [aa]',
'vd ins': 'VD insertions [nt]',
'vd del': 'VD deletions [nt]',
'dj ins': 'DJ insertions [nt]',
'dj del': 'DJ deletions [nt]'
}
in_ax.set_xlabel(xlabels[observable], fontname="Arial")
in_ax.set_ylabel("relative counts", family="Arial")
format_axes(in_ax,
labelsize=labelsize,
ticksize=ticksize,
legendsize=legendsize,
box=False)
def plot_visit_durations(data: list, ax: Axes):
"""
Plot the visit durations from the raw data.
:param data: Raw data
:param ax: Axes object in which to put the plot
:return: None
"""
# Histogram options
min_visit_s = 30
max_visit_s = 60 * 60 * 3
nbins = 150
# Regression line options
fit_start = 6
fit_stop = 144
# Create histogram
durations = get_visit_durations(data)
n, bins, _ = ax.hist(durations, bins=linspace(min_visit_s, max_visit_s, nbins))
# Create regression line
bin_width = (bins[fit_stop - 1] - bins[fit_start]) / (fit_start - fit_stop)
lin_fitting_bins = [b + bin_width / 2 for b in bins[fit_start:fit_stop]]
lin_fitting_n = n[fit_start:fit_stop]
[a, b] = polyfit(lin_fitting_bins, log(lin_fitting_n), 1, w=sqrt(lin_fitting_n))
fitted_n = [exp(b + a * t) for t in lin_fitting_bins]
regression_line_opts = {"linestyle": "--", "color": "black", "linewidth": 2}
regression_label_text = "y={:.0f}exp({:.6f}*t)".format(exp(b), a)
regression_label_coords = (max_visit_s * 0.6, max(n) * 0.5)
ax.plot(lin_fitting_bins, fitted_n, **regression_line_opts)
ax.text(*regression_label_coords, regression_label_text)
# Label axes
ax.set_xlabel("Varighet for visitt (s)")
ax.set_ylabel("Andel visitter (vilkårlig)")
ax.set_yscale("log")
def plot_histogram(data: List[np.float64], bins: int, axes: matplotlib.axes):
axes.hist(x=data, bins=bins)
axes.set_title('KDE plot')
axes.set_xlabel('x')
axes.set_ylabel('f')
def plot_kdeplot(data: List[np.float64], axes: matplotlib.axes):
sns.kdeplot(data=data, kernel='gau', bw='scott', ax=axes)
axes.set_title('KDE plot')
axes.set_xlabel('x')
axes.set_ylabel('f')
