def makeXCorr(self, spk_times: np.array, ax: matplotlib.axes = None,
**kwargs) -> matplotlib.axes:
# spk_times in samples provided in seconds but convert to
# ms for a more display friendly scale
spk_times = spk_times / 3e4 * 1000.
S = SpikeCalcsGeneric(spk_times)
y = S.xcorr(spk_times)
if ax is None:
fig = plt.figure()
ax = fig.add_subplot(111)
ax.hist(
y[y != 0], bins=201, range=[-500, 500],
color='k', histtype='stepfilled')
ax.set_xlim(-500, 500)
ax.set_xticks((-500, 0, 500))
ax.set_xticklabels('')
ax.tick_params(
axis='both', which='both', left=False, right=False,
bottom=False, top=False)
ax.set_yticklabels('')
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.xaxis.set_ticks_position('bottom')
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 plot_openness_by_weekday_by_semester(period: dict, ax: Axes):
"""
Plot openness by semester.
:param period: Period over which to average the openness
:param ax: Axes object in which to put the plot
:return: None
"""
# Configuration
num_weekdays = 5
init_year = 2015
init_semester = "Vår"
# Get data for plot
dataseries = get_openness_by_weekday_by_semester(period)
num_series = len(dataseries)
bar_width = 1 / (num_series + 1)
# Create plot
cur_year = init_year
cur_semester = init_semester
legend = []
for semester_index, week_bins in enumerate(dataseries):
# Add bars
ax.bar(
[
weekday_index + semester_index * bar_width
for weekday_index in range(num_weekdays)
],
height=week_bins[:num_weekdays],
width=bar_width,
)
# Add to legend
legend.append(f"{cur_semester} {cur_year}")
# Update semester and year for next bars
if cur_semester == "Høst":
cur_semester = "Vår"
cur_year += 1
else:
cur_semester = "Høst"
# Place legend and labels
ax.legend(legend, loc="lower right")
ax.set_xticklabels(("", "Mandag", "Tirsdag", "Onsdag", "Torsdag", "Fredag"))
ax.set_yticklabels(
[f"{openness * 100:.1f}{percent()}" for openness in ax.get_yticks()]
)
ax.set_ylabel("Andel åpen")
def plot_openness_by_weekday(data: list, period: dict, ax: Axes):
"""
Plot the openness by weekday 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
"""
week_bins = get_openness_by_weekday(data, period)
weekday_avg = sum(week_bins[0:5]) / 5
weekend_avg = sum(week_bins[5:7]) / 2
# Plot bar
ax.bar(range(7), week_bins)
# Plot averages
ax.text(
2,
weekday_avg * 1.05,
f"Gjennomsnitt ukedager: {weekday_avg * 100:.0f}{percent()}",
)
ax.text(
4.5,
weekend_avg * 1.1,
f"Gjennomsnitt helgedager: {weekend_avg * 100:.0f}{percent()}",
)
ax.plot((0, 5 - 1), (weekday_avg, weekday_avg), "k--")
ax.plot((5, 7 - 1), (weekend_avg, weekend_avg), "k--")
# Decorate axes
ax.set_xticklabels(
("", "Mandag", "Tirsdag", "Onsdag", "Torsdag", "Fredag", "Lørdag", "Søndag")
)
ax.set_yticklabels(
[f"{openness * 100:.1f}{percent()}" for openness in ax.get_yticks()]
)
ax.set_ylabel("Andel åpen")
def plot_chromatograph(
seq: SeqRecord, region: Tuple[int, int] = None, ax: mpl.axes = None
) -> plt.axes:
"""Plot Sanger chromatograph.
region: include both start and end (1-based)
"""
if seq is None:
return ax
if region is None:
# turn into 0 based for better indexing
region_start, region_end = 0, len(seq)
else:
region_start = max(region[0], 0)
region_end = min(region[1], len(seq) - 1)
if ax is None:
_, ax = plt.subplots(1, 1, figsize=(16, 6))
_colors = defaultdict(
lambda: "purple", {"A": "g", "C": "b", "G": "k", "T": "r"}
)
# Get signals
peaks = seq.annotations["peak positions"]
trace_x = seq.annotations["trace_x"]
traces_y = [seq.annotations["channel " + str(i)] for i in range(1, 5)]
bases = seq.annotations["channels"]
xlim_left, xlim_right = peaks[region_start] - 1, peaks[region_end] + 0.5
# subset peak and sequence
# TODO: this might fix the bug
peak_start = peaks[0]
peak_zip = [
(p, s)
for i, (p, s) in enumerate(zip(peaks, seq))
if region_start <= i <= region_end
]
peaks, seq = list(zip(*peak_zip))
# subset trace_x and traces_y together
trace_zip = [
(x + peak_start, *ys)
for x, *ys in zip(trace_x, *traces_y)
if xlim_left <= x <= xlim_right
]
if not trace_zip:
return ax
trace_x, *traces_y = list(zip(*trace_zip))
# Plot traces
trmax = max(map(max, traces_y))
for base in bases:
trace_y = [1.0 * ci / trmax for ci in traces_y[bases.index(base)]]
ax.plot(trace_x, trace_y, color=_colors[base], lw=2, label=base)
ax.fill_between(
trace_x, 0, trace_y, facecolor=_colors[base], alpha=0.125
)
# Plot bases at peak positions
for i, peak in enumerate(peaks):
# LOGGER.debug(f"{i}, {peak}, {seq[i]}, {xlim_left + i}")
ax.text(
peak,
-0.11,
seq[i],
color=_colors[seq[i]],
va="center",
ha="center",
alpha=0.66,
fontsize="x-large",
fontweight="bold",
)
ax.set_ylim(bottom=-0.15, top=1.05)
# peaks[0] - max(2, 0.02 * (peaks[-1] - peaks[0])),
# right=peaks[-1] + max(2, 0.02 * (peaks[-1] - peaks[0])),
ax.set_xlim(xlim_left + 0.5, xlim_right)
ax.set_xticks(peaks)
ax.set_xticklabels(list(range(region_start + 1, region_end + 2)))
# hide y axis
ax.set_yticklabels([])
ax.get_yaxis().set_visible(False)
# hide border
ax.spines["left"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.spines["top"].set_visible(False)
# hide grid
ax.grid(False)
# set legend
ax.legend(loc="upper left", bbox_to_anchor=(0.95, 0.99))
return ax
def cohort_bar(cohort_averages: dict,
cohort_data: dict,
observable: str,
yaxis_upper: int = None,
ax: matplotlib.axes = None,
labelsize: int = 12,
ticksize: int = 10,
legendsize: int = 8,
markersize=15) -> None:
"""Plots either the V- or J-gene usages.
Parameters
----------
cohort_averages : dict
Dictionary of averages and variations within a cohort for all severities.
cohort_dict : dict
Dictionary of all statistics of all individuals in a cohort for all severities.
observable : str
The quantity which is going to be plotted.
yaxis_upper : int, optional
Specifies the upper limit of the y-axis on the plot.
ax : matplotlib.axes, optional
Used to modify an already existing axes when creating a figure with a grid.
labelsize : int, optional
Size of axes labels.
ticksize : int, optional
Size of tick labels.
legendsize : int, optional
Specifies font size of strings in legend.
Returns
-------
None
"""
if ax is None:
fig = plt.figure(dpi=300, figsize=(16, 4))
ax = fig.add_subplot(111)
# Give the bars for each gene some space among each other.
width = 1.0 / len(cohort_averages) - 0.02
bars = []
if 'Asymptomatic' in cohort_averages:
ordering = ['Healthy', 'Mild', 'Moderate', 'Severe', 'Asymptomatic']
else:
ordering = sorted(cohort_averages.keys())
# Sort the genes by descending usage in the healthy cohort.
if 'Briney/GRP' in cohort_averages:
sorted_genes = [
gene for _, gene in sorted(zip(
cohort_averages['Briney/GRP'][observable][0],
cohort_averages['Briney/GRP'][observable][-1]),
key=lambda pair: pair[0],
reverse=True)
]
else:
sorted_genes = [
gene for _, gene in sorted(zip(
cohort_averages['Healthy'][observable][0],
cohort_averages['Healthy'][observable][-1]),
key=lambda pair: pair[0],
reverse=True)
]
# Because there are so many V genes, plot only those which have at least
# 1% average usage in at least one cohort.
if 'v' in observable:
good_genes = []
for gene in sorted_genes:
bools = 0
for severity in cohort_averages:
idx = cohort_averages[severity][observable][-1].index(gene)
value = cohort_averages[severity][observable][0][idx]
bools += value >= 0.01
if bools != 0:
good_genes.append(gene)
else:
good_genes = sorted_genes
xlabels = good_genes
default_x = np.arange(0, len(good_genes), 1)
xs, ys = [], []
for i, severity in enumerate(ordering):
x = default_x + width * i
xs.append(x)
indices = [
cohort_averages[severity][observable][-1].index(gene)
for gene in good_genes
]
y = [cohort_averages[severity][observable][0][k] for k in indices]
ys.append(y)
if observable == 'v gene':
ax.set_xlim(-0.3, xs[0][-1] + 1.0)
if yaxis_upper is not None:
ax.set_ylim(0, yaxis_upper)
else:
ax.set_ylim(0, 0.35)
else:
ax.set_xlim(-0.3, xs[0][-1] + 1.0)
if yaxis_upper is not None:
ax.set_ylim(0, yaxis_upper)
else:
ax.set_ylim(0, 0.55)
# Specifiy location of xticks as being in the middle of the grouping of bars.
middle = np.mean(np.arange(0, len(cohort_averages)))
middle_xticks = default_x + middle * width
ax.set_xticks(middle_xticks)
ax.set_xticklabels(xlabels, rotation=90, family='Arial')
ax.set_ylabel('relative counts', fontname="Arial")
# Plot the bars.
for i, severity in enumerate(ordering):
bar = ax.bar(xs[i],
ys[i],
width,
color=colors[severity],
label=severity)
for d in cohort_data[severity][observable]:
# Plot the full distributions of values to get a better sense
# of variation within cohorts.
for gidx, rect in enumerate(bar):
ax.scatter(xs[i][gidx],
d[good_genes[gidx]],
marker='.',
color=lightercolors[severity],
zorder=3,
s=markersize,
edgecolors='black',
linewidths=0.3)
format_axes(ax,
labelsize=labelsize,
ticksize=ticksize,
legendsize=legendsize)