def demo_locatable_axes_hard(fig):
from mpl_toolkits.axes_grid1 import SubplotDivider, Size
from mpl_toolkits.axes_grid1.mpl_axes import Axes
divider = SubplotDivider(fig, 2, 2, 2, aspect=True)
# axes for image
ax = Axes(fig, divider.get_position())
# axes for colorbar
ax_cb = Axes(fig, divider.get_position())
h = [
Size.AxesX(ax), # main axes
Size.Fixed(0.05), # padding, 0.1 inch
Size.Fixed(0.2), # colorbar, 0.3 inch
]
v = [Size.AxesY(ax)]
divider.set_horizontal(h)
divider.set_vertical(v)
ax.set_axes_locator(divider.new_locator(nx=0, ny=0))
ax_cb.set_axes_locator(divider.new_locator(nx=2, ny=0))
fig.add_axes(ax)
fig.add_axes(ax_cb)
ax_cb.axis["left"].toggle(all=False)
ax_cb.axis["right"].toggle(ticks=True)
Z, extent = get_demo_image()
im = ax.imshow(Z, extent=extent, interpolation="nearest")
plt.colorbar(im, cax=ax_cb)
plt.setp(ax_cb.get_yticklabels(), visible=False)
def fix_sz_fig(width, height, width_ext=2, padding=.5):
# These code is to make fixed size article
# Makesure matplotlib can draw Chinese characters
plt.rcParams['font.sans-serif'] = ['SimHei']
# Init figure
fig = plt.figure(figsize=(width + 2 * padding + width_ext,
height + 2 * padding))
# The first items are for padding and the second items are for the axes.
# Article width and height
w = [Size.Fixed(padding), Size.Fixed(width)]
h = [Size.Fixed(padding), Size.Fixed(height)]
divider = Divider(fig, (0.0, 0.0, 1., 1.), w, h, aspect=False)
# the width and height of the rectangle is ignored.
ax = Axes(fig, divider.get_position())
ax.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(ax)
return fig, ax
def create_plot(two_sided=False,
colors=[
'#6F4C9B', '#5568B8', '#4D8AC6', '#60AB9E', '#77B77D',
'#A6BE54', '#D1B541', '#E49C39', '#DF4828', '#990D38'
],
markers=['o', 'v', '^', 's', 'D', '*'],
figsize=(5, 3.4)):
"""
Crée un environnement de plot
Parameters
----------
twosided : bool
allows to change the size of the figure accordingly.
colors : list of strings
a default list exists but this allows to change it if u want
markers : list of strings
a default list of markers exists, but u can change it if needed
Returns
-------
fig, ax : matplotlib objects to be used as normal
"""
color = cycle(colors)
marker = cycle(markers)
if two_sided:
fig = plt.figure(figsize=(3.4, 3.4))
else:
fig = plt.figure(figsize=figsize)
# The first & third items are for padding and the second items are for the
# axes. Sizes are in inches.
h = [Size.Fixed(1.0), Size.Scaled(1.), Size.Fixed(.2)]
v = [Size.Fixed(0.7), Size.Scaled(1.), Size.Fixed(.5)]
divider = Divider(fig, (0.0, 0.0, 1., 1.), h, v, aspect=False)
# the width and height of the rectangle is ignored.
ax = Axes(fig, divider.get_position())
ax.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(ax)
return fig, ax, color, marker
def add_cbar(mappable, ax):
"""
Append colorbar to axes
Copied from DaViTPy: https://github.com/vtsuperdarn/davitpy/blob/1b578ea2491888e3d97d6e0a8bc6d8cc7c9211fb/davitpy/utils/plotUtils.py#L674
"""
from mpl_toolkits.axes_grid1 import SubplotDivider, Size
from mpl_toolkits.axes_grid1.mpl_axes import Axes
import matplotlib.pyplot as plt
fig1 = ax.get_figure()
divider = SubplotDivider(fig1, *ax.get_geometry(), aspect=True)
# axes for colorbar
cbax = Axes(fig1, divider.get_position())
h = [
Size.AxesX(ax), # main axes
Size.Fixed(0.1), # padding
Size.Fixed(0.2)
] # colorbar
v = [Size.AxesY(ax)]
_ = divider.set_horizontal(h)
_ = divider.set_vertical(v)
_ = ax.set_axes_locator(divider.new_locator(nx=0, ny=0))
_ = cbax.set_axes_locator(divider.new_locator(nx=2, ny=0))
_ = fig1.add_axes(cbax)
_ = cbax.axis["left"].toggle(all=False)
_ = cbax.axis["top"].toggle(all=False)
_ = cbax.axis["bottom"].toggle(all=False)
_ = cbax.axis["right"].toggle(ticklabels=True, label=True)
_ = plt.colorbar(mappable, cax=cbax)
return cbax
def demo_locatable_axes_hard(fig1):
from mpl_toolkits.axes_grid1 import SubplotDivider, Size
from mpl_toolkits.axes_grid1.mpl_axes import Axes
divider = SubplotDivider(fig1, 2, 2, 2, aspect=True)
# axes for image
ax = Axes(fig1, divider.get_position())
# axes for colorbar
ax_cb = Axes(fig1, divider.get_position())
h = [Size.AxesX(ax), # main axes
Size.Fixed(0.05), # padding, 0.1 inch
Size.Fixed(0.2), # colorbar, 0.3 inch
]
v = [Size.AxesY(ax)]
divider.set_horizontal(h)
divider.set_vertical(v)
ax.set_axes_locator(divider.new_locator(nx=0, ny=0))
ax_cb.set_axes_locator(divider.new_locator(nx=2, ny=0))
fig1.add_axes(ax)
fig1.add_axes(ax_cb)
ax_cb.axis["left"].toggle(all=False)
ax_cb.axis["right"].toggle(ticks=True)
Z, extent = get_demo_image()
im = ax.imshow(Z, extent=extent, interpolation="nearest")
plt.colorbar(im, cax=ax_cb)
plt.setp(ax_cb.get_yticklabels(), visible=False)
def demo_fixed_pad_axes():
fig = plt.figure(figsize=(6, 6))
# The first & third items are for padding and the second items are for the
# axes. Sizes are in inches.
h = [Size.Fixed(1.0), Size.Scaled(1.), Size.Fixed(.2)]
v = [Size.Fixed(0.7), Size.Scaled(1.), Size.Fixed(.5)]
divider = Divider(fig, (0.0, 0.0, 1., 1.), h, v, aspect=False)
# the width and height of the rectangle is ignored.
ax = Axes(fig, divider.get_position())
ax.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(ax)
ax.plot([1, 2, 3])
def demo_fixed_size_axes():
fig1 = plt.figure(1, (6, 6))
# The first items are for padding and the second items are for the axes.
# sizes are in inch.
h = [Size.Fixed(1.0), Size.Fixed(4.5)]
v = [Size.Fixed(0.7), Size.Fixed(5.)]
divider = Divider(fig1, (0.0, 0.0, 1., 1.), h, v, aspect=False)
# the width and height of the rectangle is ignored.
ax = Axes(fig1, divider.get_position())
ax.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig1.add_axes(ax)
ax.plot([1, 2, 3])
all_cell_p = all_cell_p[~np.isnan(fr_diff)]
fr_diff = fr_diff[~np.isnan(fr_diff)]
cell_hyp_sig_fr = fr_diff[all_cell_p < 0.05]
cell_hyp_no_fr = fr_diff[(all_dVm < 0) & (all_cell_p >= 0.05)]
cell_dep_sig_fr = fr_diff[all_cell_p > 0.95]
cell_dep_no_fr = fr_diff[(all_dVm > 0) & (all_cell_p <= 0.95)]
# Event-based correlation between dVm and dFR - all true spikes
#fig, ax = plt.subplots(1, figsize=[1.9, 1.8])
# create a figure with axes of defined size
fig = plt.figure(figsize=[2, 2])
# The first items are for padding and the second items are for the axes.
# sizes are in inch.
h = [Size.Fixed(0.5), Size.Fixed(1.2)]
v = [Size.Fixed(0.5), Size.Fixed(1.2)]
divider = Divider(fig, (0.0, 0.0, 1., 1.), h, v, aspect=False)
ax = Axes(fig, divider.get_position())
ax.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(ax)
n = 0
for i in np.arange(len(data)):
for j in np.arange(data[i][state + '_start'].size):
x = data[i][state + '_dVm'][j]
fr_bef = np.logical_and(
data[i][state + '_spike'][j] > states[l]['bef'],
data[i][state + '_spike'][j] <
states[l]['bef'] + states[l]['samp_time'])
fr_bef = np.sum(fr_bef) / states[l]['samp_time']
fr_aft = np.logical_and(
data[i][state + '_spike'][j] > states[l]['aft'],
data[i][state + '_spike'][j] <
states[l]['aft'] + states[l]['samp_time'])
def delay_avg_svg(self, ttype, b64encode=True):
fig = pyplot.figure(figsize=self.FIGSIZE)
h = [Size.Fixed(1.2), Size.Scaled(1.), Size.Fixed(.2)]
v = [Size.Fixed(0.7), Size.Scaled(1.), Size.Fixed(.5)]
divider = Divider(fig, (0.0, 0.0, 1., 1.), h, v, aspect=False)
plt = Axes(fig, divider.get_position())
plt.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(plt)
result = self.result
runinfo = result.runinfo
# ----
# The X limits are -rampupMins, runMins
# ----
plt.set_xlim(-int(runinfo['rampupMins']), int(runinfo['runMins']))
plt.axvspan(-int(runinfo['rampupMins']), 0, facecolor='0.2', alpha=0.1)
# ----
# offset the timestamps by -rampupMins so that the graph
# starts with negative minutes elapsed and switches to
# positive when the measurement begins.
# ----
offset = (int(runinfo['rampupMins'])) * 60.0
# ----
# ttype transaction delay. First get the timestamp
# and delay numbers from the result data.
# The X vector then is the sorted unique timestamps rounded
# to an interval.
# ----
interval = 10
data = numpy.array([[(int(tup[0] / interval) * interval - offset) / 60,
tup[1], tup[5]]
for tup in result.result_ttype[ttype]])
x = sorted(numpy.unique(data[:, 0]))
# ----
# The Y vector is the sums of transactions delay divided by
# the sums of the count, grouped by X.
# ----
y = []
for ts in x:
tmp = data[numpy.where(data[:, 0] == ts)]
y.append(numpy.sum(tmp[:, 2]) / (numpy.sum(tmp[:, 1]) + 0.000001))
# ----
# Plot the ttype delay and add all the decorations
# ----
plt.plot(x, y, 'r', label='Delay')
# ----
# Now do the same aggregation for the latency
# ----
data = numpy.array([[(int(tup[0] / interval) * interval - offset) / 60,
tup[1], tup[2]]
for tup in result.result_ttype[ttype]])
# ----
# The Y vector is similar by based on latency
# ----
y = []
for ts in x:
tmp = data[numpy.where(data[:, 0] == ts)]
y.append(numpy.sum(tmp[:, 2]) / (numpy.sum(tmp[:, 1]) + 0.000001))
plt.plot(x, y, 'b', label='Latency')
plt.set_title("{} Average Latency and Delay".format(ttype))
plt.set_xlabel("Elapsed Minutes")
plt.set_ylabel("Latency/Delay in ms")
plt.legend(loc='upper left')
plt.grid()
buf = io.StringIO()
pyplot.savefig(buf, format='svg')
if not b64encode:
return buf.getvalue()
return base64.b64encode(buf.getvalue().encode('utf-8')).decode('utf-8')
def memory_svg(self,
host=None,
title="Memory Usage",
unit="Bytes",
factor=1.0,
b64encode=True):
fig = pyplot.figure(figsize=self.FIGSIZE)
h = [Size.Fixed(1.2), Size.Scaled(1.), Size.Fixed(.2)]
v = [Size.Fixed(0.7), Size.Scaled(1.), Size.Fixed(.5)]
divider = Divider(fig, (0.0, 0.0, 1., 1.), h, v, aspect=False)
plt = Axes(fig, divider.get_position())
plt.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(plt)
result = self.result
runinfo = result.runinfo
# ----
# The X limits are -rampupMins, runMins
# ----
plt.set_xlim(-int(runinfo['rampupMins']), int(runinfo['runMins']))
plt.axvspan(-int(runinfo['rampupMins']), 0, facecolor='0.2', alpha=0.1)
x, y_used = self._get_metric_xy({
'host': host,
'metric': 'memory.memory-used',
'factor': factor,
})
_, y_cached = self._get_metric_xy(
{
'host': host,
'metric': 'memory.memory-cached',
'factor': factor,
}, x)
_, y_buffered = self._get_metric_xy(
{
'host': host,
'metric': 'memory.memory-buffered',
'factor': factor,
}, x)
_, y_free = self._get_metric_xy(
{
'host': host,
'metric': 'memory.memory-free',
'factor': factor,
}, x)
# ----
# It is possible that the mqtt based metric collector produces
# CSV files with different numbers of lines. We cut all of them
# to a combined minimum length.
# ----
min_len = min(len(x), len(y_used), len(y_cached), len(y_buffered),
len(y_free))
x = x[:min_len]
y_used = y_used[:min_len]
y_cached = y_cached[:min_len]
y_buffered = y_buffered[:min_len]
y_free = y_free[:min_len]
plt.stackplot(x,
y_used,
y_cached,
y_buffered,
y_free,
colors=[
'b',
'y',
'g',
'gray',
],
labels=[
'Used',
'Cached',
'Buffered',
'Free',
])
# ----
# Title and labels
# ----
plt.set_title(title)
plt.set_xlabel("Elapsed Minutes")
plt.set_ylabel(unit)
plt.legend(loc='upper left')
plt.grid()
# ----
# Now turn this into an in-memory SVG and return it as requested
# (raw or b64-encoded)
# ----
buf = io.StringIO()
pyplot.savefig(buf, format='svg')
if not b64encode:
return buf.getvalue()
return base64.b64encode(buf.getvalue().encode('utf-8')).decode('utf-8')
def cpu_svg(self,
host=None,
title="CPU Usage",
ylabel="Percent",
b64encode=True):
fig = pyplot.figure(figsize=self.FIGSIZE)
h = [Size.Fixed(1.2), Size.Scaled(1.), Size.Fixed(.2)]
v = [Size.Fixed(0.7), Size.Scaled(1.), Size.Fixed(.5)]
divider = Divider(fig, (0.0, 0.0, 1., 1.), h, v, aspect=False)
plt = Axes(fig, divider.get_position())
plt.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(plt)
result = self.result
runinfo = result.runinfo
# ----
# The X limits are -rampupMins, runMins, Y limits are 0..100
# ----
plt.set_xlim(-int(runinfo['rampupMins']), int(runinfo['runMins']))
plt.set_ylim(0, 100)
plt.axvspan(-int(runinfo['rampupMins']), 0, facecolor='0.2', alpha=0.1)
# ----
# Gather all the relevant data
# ----
x, y_user = self._get_metric_xy({
'host': host,
'metric': 'cpu.percent-user',
})
_, y_sys = self._get_metric_xy(
{
'host': host,
'metric': 'cpu.percent-system',
}, x)
_, y_wait = self._get_metric_xy(
{
'host': host,
'metric': 'cpu.percent-wait',
}, x)
_, y_intr = self._get_metric_xy(
{
'host': host,
'metric': 'cpu.percent-interrupt',
}, x)
_, y_softirq = self._get_metric_xy(
{
'host': host,
'metric': 'cpu.percent-softirq',
}, x)
_, y_idle = self._get_metric_xy(
{
'host': host,
'metric': 'cpu.percent-idle',
}, x)
# ----
# It is possible that the mqtt based metric collector produces
# CSV files with different numbers of lines. We cut all of them
# to a combined minimum length.
# ----
min_len = min(len(x), len(y_user), len(y_sys), len(y_wait),
len(y_intr), len(y_softirq), len(y_idle))
x = x[:min_len]
y_user = y_user[:min_len]
y_sys = y_sys[:min_len]
y_wait = y_wait[:min_len]
y_intr = y_intr[:min_len]
y_softirq = y_softirq[:min_len]
y_idle = y_idle[:min_len]
# ----
# Plot the CPU usage
# ----
plt.stackplot(x,
y_user,
y_sys,
y_wait,
y_intr,
y_softirq,
y_idle,
colors=[
'g',
'b',
'r',
'c',
'm',
'y',
],
labels=[
'User',
'System',
'Wait',
'Interrupt',
'SoftIrq',
'Idle',
])
# ----
# Title and labels
# ----
plt.set_title(title)
plt.set_xlabel("Elapsed Minutes")
plt.set_ylabel(ylabel)
plt.legend(loc='upper left')
plt.grid()
# ----
# Now turn this into an in-memory SVG and return it as requested
# (raw or b64-encoded)
# ----
buf = io.StringIO()
pyplot.savefig(buf, format='svg')
if not b64encode:
return buf.getvalue()
return base64.b64encode(buf.getvalue().encode('utf-8')).decode('utf-8')
def metric_svg(self,
host=None,
title="undefined",
ylabel="undefined",
metrics=[],
b64encode=True):
fig = pyplot.figure(figsize=self.FIGSIZE)
h = [Size.Fixed(1.2), Size.Scaled(1.), Size.Fixed(.2)]
v = [Size.Fixed(0.7), Size.Scaled(1.), Size.Fixed(.5)]
divider = Divider(fig, (0.0, 0.0, 1., 1.), h, v, aspect=False)
plt = Axes(fig, divider.get_position())
plt.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(plt)
result = self.result
runinfo = result.runinfo
# ----
# The X limits are -rampupMins, runMins
# ----
plt.set_xlim(-int(runinfo['rampupMins']), int(runinfo['runMins']))
plt.axvspan(-int(runinfo['rampupMins']), 0, facecolor='0.2', alpha=0.1)
# ----
# Draw all the requested graphs
# ----
x = None
for m in metrics:
if x is None:
x, y = self._get_metric_tree(m)
else:
_, y = self._get_metric_tree(m, x)
plt.plot(x, y, m['color'], label=m['label'])
# ----
# Title and labels
# ----
plt.set_title(title)
plt.set_xlabel("Elapsed Minutes")
plt.set_ylabel(ylabel)
plt.legend(loc='upper left')
plt.grid()
# ----
# Now turn this into an in-memory SVG and return it as requested
# (raw or b64-encoded)
# ----
buf = io.StringIO()
pyplot.savefig(buf, format='svg')
if not b64encode:
return buf.getvalue()
return base64.b64encode(buf.getvalue().encode('utf-8')).decode('utf-8')
def tpmc_svg(self, b64encode=True):
fig = pyplot.figure(figsize=self.FIGSIZE)
h = [Size.Fixed(1.2), Size.Scaled(1.), Size.Fixed(.2)]
v = [Size.Fixed(0.7), Size.Scaled(1.), Size.Fixed(.5)]
divider = Divider(fig, (0.0, 0.0, 1., 1.), h, v, aspect=False)
plt = Axes(fig, divider.get_position())
plt.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(plt)
result = self.result
runinfo = result.runinfo
# ----
# The X limits are -rampupMins, runMins
# ----
plt.set_xlim(-int(runinfo['rampupMins']), int(runinfo['runMins']))
plt.axvspan(-int(runinfo['rampupMins']), 0, facecolor='0.2', alpha=0.1)
# ----
# offset the timestamps by -rampupMins so that the graph
# starts with negative minutes elapsed and switches to
# positive when the measurement begins.
# ----
offset = (int(runinfo['rampupMins'])) * 60.0
# ----
# NEW_ORDER transactions per minute. First get the timestamp
# and number of transactions from the result data.
# The X vector then is the sorted unique timestamps rounded
# to an interval.
# ----
interval = 10
data = numpy.array([[(int(tup[0] / interval) * interval - offset) / 60,
tup[1] * (60 / interval)]
for tup in result.result_ttype['NEW_ORDER']])
x = sorted(numpy.unique(data[:, 0]))
# ----
# The Y vector is the sums of transactions grouped by X
# ----
y = []
for ts in x:
tmp = data[numpy.where(data[:, 0] == ts)]
y.append(numpy.sum(tmp[:, 1]))
# ----
# Plot the NOPM and add all the decorations
# ----
plt.plot(x, y, 'b')
plt.set_title("NEW_ORDER Transactions per Minute (tpmC)")
plt.set_xlabel("Elapsed Minutes")
plt.set_ylabel("tpmC")
plt.grid()
buf = io.StringIO()
pyplot.savefig(buf, format='svg')
if not b64encode:
return buf.getvalue()
return base64.b64encode(buf.getvalue().encode('utf-8')).decode('utf-8')
# rgba = colors.hsv_to_rgb(hsv)
# rgba = np.dstack([rgba, alpha])
# # else:
# hsv[:, :, 2] = alpha.clip(min=0.2, max=value)
# rgba_l = colors.hsv_to_rgb(hsv)
# alpha_l = np.abs(1 - alpha).clip(min=value, max=1)
# hsv[:, :, 2] = alpha_l
# rgba_lr = colors.hsv_to_rgb(hsv)
cmap = colors.ListedColormap(cmap, name='test1')
fig = plt.figure(1, figsize=(12, 8))
h = [Size.Fixed(0.), Size.Fixed(6.5)]
v = [Size.Fixed(0.5), Size.Fixed(3.25)]
win = Divider(fig, (0.1, 0.1, 0.8, 0.8), h, v, aspect=False)
ax = Axes(fig, win.get_position())
ax.set_axes_locator(win.new_locator(nx=1, ny=1))
fig.add_axes(ax)
# fig = plt.gcf()
for ii in range(1, 2):
if ii == 0:
to_plot = rgb
title = 'Model'
elif ii == 1:
to_plot = rgba
title = 'Model + Resolution (Transparency)'
elif ii == 2:
to_plot = rgba_l
title = 'Model + Resolution (Lightness)'
else:
to_plot = rgba_lr
x = x[no_nans]
y = y[no_nans]
var_p = var_p[no_nans]
all_cell_p = all_cell_p[no_nans]
all_dVm = all_dVm[no_nans]
# make the scatter
s_cell = 20
#fig, ax = plt.subplots(1, 1, figsize=[1.75, 1.75])
# create a figure with axes of defined size
fig = plt.figure(figsize=[2.5, 2.5])
# The first items are for padding and the second items are for the axes.
# sizes are in inch.
h = [Size.Fixed(0.75), Size.Fixed(1.4)]
v = [Size.Fixed(0.75), Size.Fixed(1.4)]
divider = Divider(fig, (0.0, 0.0, 1., 1.), h, v, aspect=False)
ax = Axes(fig, divider.get_position())
ax.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(ax)
ax.scatter(x[all_cell_p < 0.05],
y[all_cell_p < 0.05],
s=10,
facecolors='none',
edgecolors=c_hyp,
zorder=3)
ax.scatter(x[(all_cell_p < 0.05) & (var_p < 0.05)],
y[(all_cell_p < 0.05) & (var_p < 0.05)],
s=s_cell,
facecolors=c_hyp,
edgecolors=c_hyp,
zorder=3)
ax.scatter(x[all_cell_p > 0.95],
if measure == 'duration':
bins = np.arange(0, 30, 0.01)
if measure == 'pupil':
bins = np.arange(0, 50, 0.1)
if measure == 'norm_pupil': # use this one
bins = np.arange(1, 3, 0.001)
if measure == 'theta_delta':
bins = np.arange(-2, 4, 0.01)
# create a figure with axes of defined size
fig = plt.figure(figsize=[1.6, 1.6])
# The first items are for padding and the second items are for the axes.
# sizes are in inch.
h = [Size.Fixed(0.5), Size.Fixed(0.9)]
v = [Size.Fixed(0.5), Size.Fixed(0.8)]
divider = Divider(fig, (0.0, 0.0, 1., 1.), h, v, aspect=False)
ax = Axes(fig, divider.get_position())
ax.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(ax)
if measure == 'norm_pupil':
ax.hist([states[0][measure][np.isnan(states[0][measure]) == 0],
states[1][measure][np.isnan(states[1][measure]) == 0],
states[2][measure][np.isnan(states[2][measure]) == 0],
states[3][measure][np.isnan(states[3][measure]) == 0]],
bins=bins, color=[c_grn, c_run_theta, c_bwn, c_mgry], density=True,
label=['run theta', 'rest theta', 'LIA', 'nost'], histtype='step',
cumulative=True)
else:
ax.hist([states[0][measure][np.isnan(states[0][measure]) == 0],
states[1][measure][np.isnan(states[1][measure]) == 0],
states[2][measure][np.isnan(states[2][measure]) == 0]],
bins=bins, color=[c_grn, c_run_theta, c_bwn], density=True,
# fig.tight_layout()
# plt.savefig(os.path.join(fig_folder, 'Rin_scatter_'+state[l]+'.png'),
# transparent=True)
# make a stack and bar plot of Rin (change from nost) - theta only
l = 0
s_cell = 40
#fig, ax = plt.subplots(1, figsize=[0.8, 1.5])
# create a figure with axes of defined size
fig = plt.figure(figsize=[2, 2])
# The first items are for padding and the second items are for the axes.
# sizes are in inch.
h = [Size.Fixed(0.5), Size.Fixed(0.6)]
v = [Size.Fixed(0.5), Size.Fixed(1.1)]
divider = Divider(fig, (0.0, 0.0, 1., 1.), h, v, aspect=False)
ax = Axes(fig, divider.get_position())
ax.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(ax)
for i in np.arange(len(data)):
cell_Rin_nost = np.nanmean(data[i]['Rin'][data[i]['nost_Rin']])
cell_Rin_state = np.nanmean(data[i]['Rin'][data[i][state[l] + '_Rin']])
cell_Rin_state = (cell_Rin_state - cell_Rin_nost) / cell_Rin_nost
if state_Rin_t_p[i, l] < 0.05:
ax.scatter(random.uniform(0, 1),
cell_Rin_state,
facecolors=c_state[l],
edgecolors=c_state[l],
zorder=2,
s=s_cell)
else:
ax.scatter(random.uniform(0, 1),
'axes.titlesize': 30,
'xtick.labelsize': 30,
'ytick.labelsize': 30,
'legend.fontsize': 30
}
plt.rcParams.update(params)
fig = plt.figure(figsize=(11, 9))
h = [Size.Fixed(1.8), Size.Fixed(8.5)]
v = [Size.Fixed(1.2), Size.Fixed(7.5)]
divider = Divider(fig, (0.0, 0.0, 1., 1.), h, v, aspect=False)
# the width and height of the rectangle is ignored.
ax = Axes(fig, divider.get_position())
ax.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(ax)
ax.set_yscale('log')
ax.set_xlim(-500, 10000)
ax.set_ylim(bottom=1e-4, top=1e4)
ax.set_xlabel('Iteration')
ax.set_ylabel('Imitation Loss')
ax.tick_params(axis='both', which='major')
ax.set_facecolor('#E6E6E6')
ax.grid()
ax.set_position([1, 1, 10, 6])
# load inverse kkt results
def segtrends(x, segments=2, charts=True):
"""
Turn minitrends to iterative process more easily adaptable to
implementation in simple trading systems; allows backtesting functionality.
:param x: One-dimensional data set
:param window: How long the trendlines should be. If window < 1, then it
will be taken as a percentage of the size of the data
:param charts: Boolean value saying whether to print chart to screen
"""
import numpy as np
y = np.array(x['Close'])
# for i in range(len(y),1200):
# y = np.append(y, y[len(y)-1])
# Implement trendlines
segments = int(segments)
maxima = np.ones(segments)
minima = np.ones(segments)
segsize = int(len(y) / segments)
for i in range(1, segments + 1):
ind2 = i * segsize
ind1 = ind2 - segsize
maxima[i - 1] = max(y[ind1:ind2])
minima[i - 1] = min(y[ind1:ind2])
# Find the indexes of these maxima in the data
x_maxima = np.ones(segments)
x_minima = np.ones(segments)
for i in range(0, segments):
x_maxima[i] = np.where(y == maxima[i])[0][0]
x_minima[i] = np.where(y == minima[i])[0][0]
if charts:
import matplotlib.pyplot as plt
plt.rc('font', size=6)
fig = plt.figure(figsize=(8, 6))
h = [Size.Fixed(0.5), Size.Fixed(7.)]
v = [Size.Fixed(0.7), Size.Fixed(5.)]
divider = Divider(fig, (0.0, 0.0, 0., 0.), h, v, aspect=False)
ax = Axes(fig, divider.get_position())
ax.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(ax)
plt.plot(y, linewidth=1)
plt.grid(True)
for i in range(0, segments - 1):
maxslope = (maxima[i + 1] - maxima[i]) / (x_maxima[i + 1] -
x_maxima[i])
a_max = maxima[i] - (maxslope * x_maxima[i])
b_max = maxima[i] + (maxslope * (len(y) + 300 - x_maxima[i]))
maxline = np.linspace(a_max, b_max, len(y) + 300)
minslope = (minima[i + 1] - minima[i]) / (x_minima[i + 1] -
x_minima[i])
a_min = minima[i] - (minslope * x_minima[i])
b_min = minima[i] + (minslope * (len(y) + 300 - x_minima[i]))
minline = np.linspace(a_min, b_min, len(y) + 300)
if charts:
plt.plot(maxline, 'g', linewidth=0.15)
plt.plot(minline, 'r', linewidth=.15)
if charts:
#plt.show()
plt.ylim(min(y[-120:] * .9), max(y[-120:] * 1.1))
plt.rc('xtick', labelsize=6)
plt.xticks(range(0, 1200, 4), x.index[range(0, 910, 4)], rotation=90)
plt.rc('xtick', labelsize=6)
plt.xlim(800, 1000)
# plt.xlim(datetime.datetime(2016,1,1),datetime.datetime(2022,1,1))
plt.savefig('C:/git/TRADE/chart.png', dpi=750)
plt.close()
# OUTPUT
return x_maxima, maxima, x_minima, minima
# remove outliers
values = data[i]['th_dist'][data[i][ntl[l] + '_thresh_bool']]
values = values[np.logical_and(values > -15, values < 0)]
measure[i, l] = -1 * np.nanmedian(values)
# remove unwanted cells
measure = measure[keep_cells_thresh, :]
# make the plot
#fig, ax = plt.subplots(1, figsize=[1.5, 1.75])
# create a figure with axes of defined size
fig = plt.figure(figsize=[2, 2])
# The first items are for padding and the second items are for the axes.
# sizes are in inch.
h = [Size.Fixed(0.5), Size.Fixed(1.1)]
v = [Size.Fixed(0.5), Size.Fixed(1.2)]
divider = Divider(fig, (0.0, 0.0, 1., 1.), h, v, aspect=False)
ax = Axes(fig, divider.get_position())
ax.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(ax)
line_x = np.array([1.75, 3.25])
bar_x = np.array([1, 4])
y = measure[:, d_l]
dVm = states[d_l[-1] - 1]['cell_dVm'][keep_cells_thresh]
for i in np.arange(y.shape[0]):
ax.plot(line_x, y[i, :], color=c_lgry, zorder=1)
if dVm[i] == -1:
ax.plot(line_x, y[i, :], color=c_hyp, zorder=2)
elif dVm[i] == 1:
ax.plot(line_x, y[i, :], color=c_dep, zorder=2)
for l in np.arange(y.shape[1]):
# remove nans
no_nan = y[:, l]
def plot_it():
# fig = plt.figure(1, figsize=(8, 4.5))
fig = plt.figure(1, figsize=(16, 12))
# h = [Size.Fixed(0.), Size.Fixed(6.5)]
# v = [Size.Fixed(0.5), Size.Fixed(3.25)]
h = [Size.Fixed(0.), Size.Fixed(13)]
v = [Size.Fixed(0.5), Size.Fixed(7)]
win = Divider(fig, (0.1, 0.08, 0.8, 0.8), h, v, aspect=False)
ax = Axes(fig, win.get_position())
ax.set_axes_locator(win.new_locator(nx=1, ny=1))
fig.add_axes(ax)
# fig = plt.figure(figsize=(16, 12))
# ax = fig.add_subplot(111)
for ii, ellipse in enumerate(ellipses):
ax.fill(ellipse[0], ellipse[1], color=cmap(norm_vals[ii]), zorder=0)
ax.plot(ellipse[0], ellipse[1], 'k-', linewidth=0.2)
ax.invert_yaxis()
plt.xlabel('Northing (km)', fontsize=16)
plt.ylabel(r'$\log_{10}$ Period (s)', fontsize=16)
# ax.set_aspect(1)
ax.tick_params(axis='both', labelsize=14)
# locs, labels = plt.xticks()
# plt.xticks(locs, [int(x * 10) for x in locs])
fake_vals = np.linspace(lower, upper, len(fill_vals))
fake_im = ax.scatter(loc, periods, c=fake_vals, cmap=cmap)
fake_im.set_visible(False)
# ax.set_ylim([-2.6, 3.25])
# ax.set_xlim([526.5, 538.2])
# ax.invert_yaxis()
# cb = plt.colorbar(mappable=fake_im)
#############################################
# Colour bar and site labelling
# cbaxes = fig.add_axes([0.925, 0.1351, 0.015, 0.72])
# cb = plt.colorbar(fake_im)
# if 'phi' in fill_param[:3]:
# label = r'${}{}(\degree)$'.format('\phi', fill_param[-2:])
# else:
# label = r'$\{}(\degree)$'.format(fill_param)
# cb.set_label(label,
# rotation=270,
# labelpad=20,
# fontsize=18)
# ax.tick_params(axis='both', labelsize=14)
# ax.set_xlim(x_lim)
# for ii, site in enumerate(main_sites):
# txt = site[-4:-1]
# if linear_xaxis:
# ax.text(linear_site[ii],
# label_offset, site, rotation=45) # 3.6
# else:
# ax.text(main_transect.sites[site].locations['X'],
# label_offset, site, rotation=45) # 3.6
plt.show()
return fig
l = 0
# scatter dVm vs Vm0 for theta and LIA
# prep the bools to separate events with and without holding current
Ih0 = (np.abs(events[l]['Ih']) < 10)
# make the scatter
#fig, ax = plt.subplots(1, 1, figsize=[2.2, 1.8])
# create a figure with axes of defined size
fig = plt.figure(figsize=[2, 2])
# The first items are for padding and the second items are for the axes.
# sizes are in inch.
h = [Size.Fixed(0.5), Size.Fixed(1.3)]
v = [Size.Fixed(0.5), Size.Fixed(1.1)]
divider = Divider(fig, (0.0, 0.0, 1., 1.), h, v, aspect=False)
ax = Axes(fig, divider.get_position())
ax.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(ax)
ax.scatter(events[l]['Vm0'][Ih0],
events[l]['dVm'][Ih0],
s=10,
facecolors=c_state[l],
edgecolors=c_state[l])
ax.set_ylim([-15, 15])
ax.set_xlim([-70, -20])
ax.set_yticks([-15, 0, 15])
ax.set_xticks([-60, -40, -20])
ax.tick_params(top=False, right=False, length=6)
ax.spines['left'].set_bounds(-15, 15)
ax.set_xlabel('initial Vm (mV)')
ax.set_ylabel(r'$\Delta$ Vm (mV)', labelpad=0)
sumFinalAnalysisTE = np.matmul(-np.transpose(npTE), lstFinalAnalysis)
A = np.array([[ndados, sumTE], [sumTE, prodTE]])
B = np.array([[sumFinalAnalysis], [sumFinalAnalysisTE]])
invA = np.linalg.inv(A)
P = np.matmul(invA, B)
T2[indexValue] = (P[1][0])
for i, t in enumerate(T2):
T2[i] = math.inf if t[0] == 0 else 1000 / t[0]
T2Star = np.reshape(T2, (400, 400))
fig = plt.figure(figsize=(6, 6))
h = [Size.Fixed(1.0), Size.Fixed(5.)]
v = [Size.Fixed(1.0), Size.Fixed(5.)]
divider = Divider(fig, (0.0, 0.0, 1., 1.), h, v, aspect=False)
ax = Axes(fig, divider.get_position())
ax.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(ax)
plt.pcolor(np.flip(T2Star, 0), cmap=jet_combined, vmin=0, vmax=180)
toc = time.perf_counter()
print(f"Executed in {toc - tic:0.4f} seconds")
# toggle_selector.RS = RectangleSelector(ax, line_select_callback,
# drawtype='box', useblit=True,
# button=[1, 3], # don't use middle button
# minspanx=5, minspany=5,
# spancoords='pixels',
# interactive=True)
# plt.connect('key_press_event', toggle_selector)
plt.show()
S = np.full([len(all_cells), 2], np.nan)
for i in np.arange(len(all_cells)):
values = df[measure][(df['cell_id'] == all_cells[i])]
S[i, 0] = np.nanmean(values)
values = th_df[measure][(th_df['cell_id'] == all_cells[i])]
S[i, 1] = np.nanmean(values)
#fig, ax = plt.subplots(1, figsize=[1.5, 1.5])
# create a figure with axes of defined size
fig = plt.figure(figsize=[2, 2])
# The first items are for padding and the second items are for the axes.
# sizes are in inch.
h = [Size.Fixed(0.5), Size.Fixed(1.1)]
v = [Size.Fixed(0.5), Size.Fixed(1.3)]
divider = Divider(fig, (0.0, 0.0, 1., 1.), h, v, aspect=False)
ax = Axes(fig, divider.get_position())
ax.set_axes_locator(divider.new_locator(nx=1, ny=1))
fig.add_axes(ax)
bar_x = np.array([1, 4])
line_x = np.array([0.75, 2.25])
for i in np.arange(S.shape[0]):
for l in np.arange(S.shape[1]-1):
ax.plot(bar_x[l]+line_x, S[i, l:l+2], color=c_small, zorder=1)
if measure == 'amplitude':
if S[i, 0] > 5:
ax.plot(bar_x[l]+line_x, S[i, l:l+2], color=c_big, zorder=2)
ax.set_yticks([0, 10, 20, 30, 40, 50, 60])
ax.set_yticklabels([0, '', 20, '', 40, '', 60])
ax.set_ylim([0, 60])
ax.set_ylabel('amplitude (mV)')
if measure == 'rise_time':
