def _plot_image(self, index):
# Setup figure
fig = plt.figure(figsize=(20.0, 8.0), dpi=80)
fig.subplots_adjust(wspace=0, hspace=0)
ax1 = plt.subplot2grid((3, 1), (0, 0), rowspan=2)
ax2 = plt.subplot2grid((3, 1), (2, 0))
# Get time array
time_array = np.arange(self.waveforms.shape[1]) * 1 / self.graph.network.hyper_params['fs']
# Get labels
label = self.labels[index]
# Get logits
logits = self.logits[index, :]
# Get softmax
sigmoid = expit(logits)
# Get prediction
prediction = int(np.squeeze(np.argmax(sigmoid)))
# Get non-zero-pad indices
non_zero_index = np.where(self.waveforms[index, :, 0] != 0)[0]
def hrd(self, z='Nstars', bins=200):
ax1 = plt.subplot2grid((3, 3), (1, 0), rowspan=2, colspan=2)
ax2 = plt.subplot2grid((3, 3), (0, 0), colspan=2)
ax3 = plt.subplot2grid((3, 3), (1, 2), rowspan=2)
l = ax1.scatter(data1['LOG_TE'],
data1['LOG_L'],
c=data1['MASS'],
edgecolors='none',
cmap=plt.cm.Blues)
if z != 'Nstars':
N, xe, ye = self.bs2d('LOG_TE', 'LOG_L', z, bins=bins)
l = ax.imshow(N.T,
extent=[xe[-1], xe[0], ye[-1], ye[0]],
cmap=plt.cm.Blues,
interpolation='nearest',
aspect=0.1)
cb = plt.colorbar(l)
else:
pass
ax.set_xlabel(r'$\log\ T_{\rm{eff}}\ \rm{(K)}$', fontsize=20)
ax.set_ylabel(r'$\log\ L\ {\rm{(L_\odot)}}$', fontsize=20)
ax.set_title(r'$Z=%.4f\ \log {\rm{Age:}} %g-%g$' %
(self.logz, self.lagei, self.lagef),
fontsize=12)
ax.set_xlim(ax.get_xlim()[::-1])
ax.set_ylim(ax.get_ylim()[::-1])
cb.set_label('$%s$' % z, fontsize=16)
return ax
def plot_figure5():
""" Plot Figure 5, see text for more details regarding Figure 3.
"""
N, M = 10000, 70000 # Temporal window - get rid of transient
# Load data
base = "../data/"
t = np.load(base + "Fig5_V.npy")[N:, 0]
v = np.load(base + "Fig5_V.npy")[N:, 1]
h = np.load(base + "Fig5_V.npy")[N:, 2]
# Plot phase plane
fig = plt.figure(figsize=(8, 10))
fig.subplots_adjust(wspace=1., hspace=1.)
ax = plt.subplot2grid((7, 3), (0, 0), colspan=3, rowspan=4)
ax.plot(h, v, 'k', lw=1)
ax.set_ylim([-80, 20])
ax.set_xlim([0, 0.1])
ax.set_ylabel("V (mV)", fontsize=16, weight='bold')
ax.set_xlabel("h", fontsize=15, weight='bold')
ticks = ax.get_xticks()
ax.set_xticklabels(ticks, fontsize=15, weight='bold')
ticks = ax.get_yticks()
ax.set_yticklabels(ticks, fontsize=15, weight='bold')
# Plot membrane potential
ax = plt.subplot2grid((7, 3), (4, 0), colspan=3, rowspan=2)
ax.plot(t, v, 'k', lw=1)
ax.set_ylim([-80, 20])
ax.set_xticks([])
ax.set_ylabel("V (mV)", fontsize=16, weight='bold')
ticks = ax.get_yticks().astype('i')
ax.set_yticklabels(ticks, fontsize=15, weight='bold')
ax.get_yaxis().set_tick_params(which='both', direction='out')
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
# Plot h
ax = plt.subplot2grid((7, 3), (6, 0), colspan=3, rowspan=1)
ax.plot(t, h, 'b', lw=1)
ax.set_ylim([0.017, 0.077])
ax.set_xlabel("Time (s)", fontsize=16, weight='bold')
ax.set_ylabel("h", fontsize=16, weight='bold')
ticks = ax.get_xticks().astype('i')
ticks = [i / 1000 for i in ticks]
ax.set_xticklabels(ticks, fontsize=15, weight='bold')
ax.set_yticks([0.02, 0.07])
ticks = ax.get_yticks()
ax.set_yticklabels(ticks, fontsize=15, weight='bold')
ax.get_xaxis().set_tick_params(which='both', direction='out')
ax.get_yaxis().set_tick_params(which='both', direction='out')
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
plt.savefig('../article/figs/Figure5.pdf', axis='tight')
def quicklook_wf(wfo, logAmp=True, show=True):
after_dm = proper.prop_get_amplitude(wfo)
phase_afterdm = proper.prop_get_phase(wfo)
fig = plt.figure(figsize=(14, 10))
ax1 = plt.subplot2grid((3, 2), (0, 0), rowspan=2)
ax2 = plt.subplot2grid((3, 2), (0, 1), rowspan=2)
ax3 = plt.subplot2grid((3, 2), (2, 0))
ax4 = plt.subplot2grid((3, 2), (2, 1))
if logAmp:
ax1.imshow(after_dm, origin='lower', cmap="YlGnBu_r", norm=LogNorm())
else:
ax1.imshow(after_dm, origin='lower', cmap="YlGnBu_r")
ax2.imshow(phase_afterdm, origin='lower',
cmap="YlGnBu_r") #, vmin=-0.5, vmax=0.5)
ax3.plot(after_dm[int(tp.grid_size / 2)])
ax3.plot(np.sum(np.eye(tp.grid_size) * after_dm, axis=1))
# plt.plot(np.sum(after_dm,axis=1)/after_dm[128,128])
ax4.plot(phase_afterdm[int(tp.grid_size / 2)])
# ax4.plot(np.sum(np.eye(tp.grid_size)*phase_afterdm,axis=1))
plt.xlim([0, proper.prop_get_gridsize(wfo)])
fig.set_tight_layout(True)
if show == True:
plt.show()
def render(self, state):
width = self.resolution[0] / self.dpi
height = self.resolution[1] / self.dpi
fig = plt.figure(0, figsize=(width, height), dpi=self.dpi)
current, wait, backlog, time = state
lines = current.shape[0]
# Axes {{{
axs_current = [
plt.subplot2grid((lines, 3), (i, 0)) for i in range(lines)
]
axs_wait = [plt.subplot2grid((lines, 3), (i, 1)) for i in range(lines)]
ax_backlog = plt.subplot2grid((lines, 3), (0, 2), rowspan=lines)
# End of Axes }}}
for i, (ax_current, ax_wait) in enumerate(zip(axs_current, axs_wait)):
self.plot_substate(ax_current, f'Current resources {i}',
current[i])
self.plot_substate(ax_wait, f'Waiting jobs stack {i}',
np.mean(wait[i], axis=0))
self.plot_substate(ax_backlog, 'Backlog', backlog, True)
fig.tight_layout()
canvas = agg.FigureCanvasAgg(fig)
canvas.draw()
renderer = canvas.get_renderer()
raw_data = renderer.tostring_rgb()
size = canvas.get_width_height()
plt.close(fig)
return np.frombuffer(raw_data, dtype=np.uint8).reshape(
(size[0], size[1], 3))
def plotPriceAndTradeSignals(valData):
fig = plt.figure(figsize=(12, 8))
#plt.figure(figsize=(9,4))
#plt.title('Comparison of beLong vs. Predicted beLong')
plt.subplots_adjust(hspace=0.05)
fig.suptitle('Comparison of beLong vs. Predicted beLong')
#plt.title('Comparison of beLong vs. Predicted beLong')
ax1 = plt.subplot2grid((5, 1), (0, 0), rowspan=3, colspan=1)
ax2 = plt.subplot2grid((5, 1), (3, 0), rowspan=1, colspan=1)
ax3 = plt.subplot2grid((5, 1), (4, 0), rowspan=1, colspan=1)
ax2.plot(valData['valBeLong'], color='green', alpha=0.6)
ax1.plot(valData['Close'])
ax3.plot(valData['beLong'], color='purple', alpha=0.6)
ax1.label_outer()
ax2.label_outer()
ax2.tick_params(axis='x', which='major', bottom=True)
axes = [ax1, ax2, ax3]
for x in range(len(axes)):
axes[x].grid(True, which='major', color='k', linestyle='-', alpha=0.6)
axes[x].grid(True, which='minor', color='r', linestyle='-', alpha=0.2)
axes[x].minorticks_on()
axes[x].legend(loc='upper left', frameon=True, fontsize=10)
axes[x].label_outer()
plt.show(block=True)
def survival_and_stats(feature, surv, upper_lim=5, axs=None, figsize=(7, 5), title=None,
order=None, colors=None, **args):
if axs is None:
fig = plt.figure(figsize=figsize)
ax1 = plt.subplot2grid((3, 3), (0, 0), colspan=3, rowspan=2)
ax2 = plt.subplot2grid((3, 3), (2, 0), colspan=2)
ax3 = plt.subplot2grid((3, 3), (2, 2))
else:
ax1, ax2, ax3 = axs
fig = plt.gcf()
if feature.dtype != str:
feature = feature.astype(str)
if colors is None:
colors = colors_global
t = get_surv_fit(surv, feature)
if order is None:
t = t.sort([('5y Survival', 'Surv')], ascending=True)
else:
t = t.ix[order]
survival_stat_plot(t, axs=[ax2, ax3], upper_lim=upper_lim, colors=colors)
r = pd.Series({s:i for i, s in enumerate(t.index)})
color_lookup = {c: colors[i % len(colors)] for i, c in enumerate(t.index)}
draw_survival_curve(feature, surv, ax=ax1, colors=color_lookup, **args)
ax1.legend().set_visible(False)
if title:
ax1.set_title(title)
fig.tight_layout()
def show_results(self, ag_attr='language', step=None,
plot_results=True, plot_type='imshow', save_fig=False):
grid_size = (3, 5)
self.create_agents_attrs_data(ag_attr)
data_2_plot = self.datacollector.get_model_vars_dataframe()[:step]
data_2D = self.df_attrs_avg.reset_index()
ax1 = plt.subplot2grid(grid_size, (0, 3), rowspan=1, colspan=2)
data_2_plot[["count_bil", "count_cat", "count_spa"]].plot(ax=ax1, title='lang_groups')
ax1.xaxis.tick_bottom()
ax1.legend(loc='best', prop={'size': 8})
ax2 = plt.subplot2grid(grid_size, (1, 3), rowspan=1, colspan=2)
data_2_plot['total_num_agents'].plot(ax=ax2, title='num_agents')
ax3 = plt.subplot2grid(grid_size, (2, 3), rowspan=1, colspan=2)
data_2_plot[['biling_evol_h', 'biling_evol_s']].plot(ax=ax3, title='biling_quality')
ax3.legend(loc='best', prop={'size': 8})
ax4 = plt.subplot2grid(grid_size, (0, 0), rowspan=3, colspan=3)
if plot_type == 'imshow':
s = ax4.imshow(self.df_attrs_avg.unstack('x'), vmin=0, vmax=2, cmap='viridis',
interpolation='nearest', origin='lower')
else:
s = ax4.scatter(data_2D['x'],
data_2D['y'],
c=data_2D['values'],
vmin=0, vmax=2, s=35,
cmap='viridis')
ax4.text(0.02, 0.95, 'time = %.1f' % self.schedule.steps, transform=ax4.transAxes)
plt.colorbar(s)
plt.tight_layout()
if save_fig:
plt.savefig('step' + str(step) + '.png')
if plot_results:
plt.show()
def quicklook_IQ(wfo, logAmp=False, show=True):
I = np.real(wfo.wfarr)
Q = np.imag(wfo.wfarr)
print(np.sum(I), np.sum(Q))
I = proper.prop_shift_center(I)
Q = proper.prop_shift_center(Q)
fig = plt.figure(figsize=(14, 10))
ax1 = plt.subplot2grid((3, 2), (0, 0), rowspan=2)
ax2 = plt.subplot2grid((3, 2), (0, 1), rowspan=2)
ax3 = plt.subplot2grid((3, 2), (2, 0))
ax4 = plt.subplot2grid((3, 2), (2, 1))
if logAmp:
ax1.imshow(I, origin='lower', cmap="YlGnBu_r", norm=LogNorm())
else:
ax1.imshow(I, origin='lower', cmap="YlGnBu_r")
ax2.imshow(Q, origin='lower', cmap="YlGnBu_r") # , vmin=-0.5, vmax=0.5)
ax3.plot(I[int(tp.grid_size / 2)])
ax3.plot(np.sum(np.eye(tp.grid_size) * I, axis=1))
# plt.plot(np.sum(after_dm,axis=1)/after_dm[128,128])
ax4.plot(Q[int(tp.grid_size / 2)])
# ax4.plot(np.sum(np.eye(tp.grid_size)*phase_afterdm,axis=1))
plt.xlim([0, proper.prop_get_gridsize(wfo)])
fig.set_tight_layout(True)
if show == True:
plt.show()
def __init__(self):
self.fig = plt.figure()
# размер поля для графика
egrid = (4, 2)
#Описание осей для графиков
self.ax1 = plt.subplot2grid(egrid, (0, 0), colspan=2, rowspan=2)
self.ax1.set_title("Курсы валют")
self.ax1.set_ylabel("Стоимость в рублях")
self.ax1.set_xlabel("Дата формата м-д")
self.ax1.grid()
self.ax2 = plt.subplot2grid(egrid, (2, 0))
self.ax2.set_ylabel("--> USD")
self.ax2.set_xlabel("Дата формата м-д")
self.ax2.grid()
self.ax3 = plt.subplot2grid(egrid, (2, 1))
self.ax3.set_ylabel("--> EUR")
self.ax3.set_xlabel("Дата формата м-д")
self.ax3.grid()
self.ax4 = plt.subplot2grid(egrid, (3, 0))
self.ax4.set_ylabel("--> CNY")
self.ax4.set_xlabel("Дата формата м-д")
self.ax4.grid()
self.ax5 = plt.subplot2grid(egrid, (3, 1))
self.ax5.set_ylabel("--> JPY")
self.ax5.set_xlabel("Дата формата м-д")
self.ax5.grid()
def pretty_fig(spks, states, t_stop=1000):
spikes = np.zeros((4, t_stop))
spks = spks.astype('i')
for i in range(4):
idx = spks[0, spks[1, :] == i]
if len(idx) > 0:
spikes[i, idx] = 1
spikes[spikes == 0] = np.nan
K = 5000
ax1 = plt.subplot2grid((5, 5), (0, 0), colspan=5, rowspan=1)
for i in range(4):
if i == 3:
col = (0.192, 0.647, 0.796)
al = 1
else:
col = (0.847, 0, 0.329)
al = 1 - i*0.2
ax1.plot(spikes[i, :K]+i, '|', c=col, ms=20, mew=3, alpha=al)
ax1.set_ylim([0, 5])
ax1.set_xticks([])
ax1.spines['right'].set_visible(False)
ax1.spines['top'].set_visible(False)
ax1.spines['bottom'].set_visible(False)
ax1.yaxis.set_ticks_position('left')
ax1.set_ylabel("Neuron", fontsize=22, weight='bold')
ax1.set_yticklabels(ax1.get_yticks().astype('i'),
fontsize=18,
weight='bold')
for i in range(1, 5):
if i == 1:
col = (0.192, 0.647, 0.796)
al = 1
else:
col = (0.847, 0, 0.329)
al = 0.2 + i*0.2
ax2 = plt.subplot2grid((5, 5), (i, 0), colspan=5, rowspan=1)
ax2.plot(states[:K, 4-i, 0], c=col, alpha=al)
ax2.set_ylim([-500, 200])
ax2.set_yticklabels(ax2.get_yticks().astype('i'),
fontsize=18,
weight='bold')
ax2.set_ylabel("V", fontsize=18, weight='bold')
ax2.spines['top'].set_visible(False)
ax2.spines['right'].set_visible(False)
ax2.yaxis.set_ticks_position('left')
ax2.xaxis.set_ticks_position('bottom')
if i != 4:
ax2.spines['right'].set_visible(False)
ax2.spines['bottom'].set_visible(False)
ax2.set_xticks([])
else:
ax2.set_xlabel("Time (ticks)", fontsize=18, weight='bold')
ax2.set_xticklabels(ax2.get_xticks().astype('i'),
fontsize=18,
weight='bold')
def plot_data(tag):
data_array = tag.references[0]
voltage = np.zeros(data_array.data.shape)
data_array.data.read_direct(voltage)
x_axis = data_array.dimensions[0]
time = x_axis.axis(data_array.data_extent[0])
spike_times = tag.positions[:]
feature_data_array = tag.features[0].data
snippets = tag.features[0].data[:]
single_snippet = tag.retrieve_feature_data(3, 0)[:]
snippet_time_dim = feature_data_array.dimensions[1]
snippet_time = snippet_time_dim.axis(feature_data_array.data_extent[1])
response_axis = plt.subplot2grid((2, 2), (0, 0), rowspan=1, colspan=2)
single_snippet_axis = plt.subplot2grid((2, 2), (1, 0), rowspan=1, colspan=1)
average_snippet_axis = plt.subplot2grid((2, 2), (1, 1), rowspan=1, colspan=1)
response_axis.plot(time, voltage, color="dodgerblue", label=data_array.name)
response_axis.scatter(spike_times, np.ones(spike_times.shape) * np.max(voltage), color="red", label=tag.name)
response_axis.set_xlabel(x_axis.label + ((" [" + x_axis.unit + "]") if x_axis.unit else ""))
response_axis.set_ylabel(data_array.label + ((" [" + data_array.unit + "]") if data_array.unit else ""))
response_axis.set_title(data_array.name)
response_axis.set_xlim(0, np.max(time))
response_axis.set_ylim((1.2 * np.min(voltage), 1.2 * np.max(voltage)))
response_axis.legend()
single_snippet_axis.plot(snippet_time, single_snippet.T, color="red", label=("snippet No 4"))
single_snippet_axis.set_xlabel(
snippet_time_dim.label + ((" [" + snippet_time_dim.unit + "]") if snippet_time_dim.unit else "")
)
single_snippet_axis.set_ylabel(
feature_data_array.label + ((" [" + feature_data_array.unit + "]") if feature_data_array.unit else "")
)
single_snippet_axis.set_title("single stimulus snippet")
single_snippet_axis.set_xlim(np.min(snippet_time), np.max(snippet_time))
single_snippet_axis.set_ylim((1.2 * np.min(snippets[3, :]), 1.2 * np.max(snippets[3, :])))
single_snippet_axis.legend()
mean_snippet = np.mean(snippets, axis=0)
std_snippet = np.std(snippets, axis=0)
average_snippet_axis.fill_between(
snippet_time, mean_snippet + std_snippet, mean_snippet - std_snippet, color="red", alpha=0.5
)
average_snippet_axis.plot(snippet_time, mean_snippet, color="red", label=(feature_data_array.name + str(4)))
average_snippet_axis.set_xlabel(
snippet_time_dim.label + ((" [" + snippet_time_dim.unit + "]") if snippet_time_dim.unit else "")
)
average_snippet_axis.set_ylabel(
feature_data_array.label + ((" [" + feature_data_array.unit + "]") if feature_data_array.unit else "")
)
average_snippet_axis.set_title("spike-triggered average")
average_snippet_axis.set_xlim(np.min(snippet_time), np.max(snippet_time))
average_snippet_axis.set_ylim((1.2 * np.min(mean_snippet - std_snippet), 1.2 * np.max(mean_snippet + std_snippet)))
plt.subplots_adjust(left=0.15, top=0.875, bottom=0.1, right=0.98, hspace=0.35, wspace=0.25)
plt.show()
def triple_plot(cccsum, cccsum_hist, trace, threshold, save=False,
savefile=''):
r"""Main function to make a triple plot with a day-long seismogram, \
day-long correlation sum trace and histogram of the correlation sum to \
show normality.
:type cccsum: numpy.ndarray
:param cccsum: Array of the cross-channel cross-correlation sum
:type cccsum_hist: numpy.ndarray
:param cccsum_hist: cccsum for histogram plotting, can be the same as \
cccsum but included if cccsum is just an envelope.
:type trace: obspy.Trace
:param trace: A sample trace from the same time as cccsum
:type threshold: float
:param threshold: Detection threshold within cccsum
:type save: bool, optional
:param save: If True will svae and not plot to screen, vice-versa if False
:type savefile: str, optional
:param savefile: Path to save figure to, only required if save=True
"""
if len(cccsum) != len(trace.data):
print('cccsum is: ' +
str(len(cccsum))+' trace is: '+str(len(trace.data)))
msg = ' '.join(['cccsum and trace must have the',
'same number of data points'])
raise ValueError(msg)
df = trace.stats.sampling_rate
npts = trace.stats.npts
t = np.arange(npts, dtype=np.float32) / (df * 3600)
# Generate the subplot for the seismic data
ax1 = plt.subplot2grid((2, 5), (0, 0), colspan=4)
ax1.plot(t, trace.data, 'k')
ax1.axis('tight')
ax1.set_ylim([-15 * np.mean(np.abs(trace.data)),
15 * np.mean(np.abs(trace.data))])
# Generate the subplot for the correlation sum data
ax2 = plt.subplot2grid((2, 5), (1, 0), colspan=4, sharex=ax1)
# Plot the threshold values
ax2.plot([min(t), max(t)], [threshold, threshold], color='r', lw=1,
label="Threshold")
ax2.plot([min(t), max(t)], [-threshold, -threshold], color='r', lw=1)
ax2.plot(t, cccsum, 'k')
ax2.axis('tight')
ax2.set_ylim([-1.7 * threshold, 1.7 * threshold])
ax2.set_xlabel("Time after %s [hr]" % trace.stats.starttime.isoformat())
# ax2.legend()
# Generate a small subplot for the histogram of the cccsum data
ax3 = plt.subplot2grid((2, 5), (1, 4), sharey=ax2)
ax3.hist(cccsum_hist, 200, normed=1, histtype='stepfilled',
orientation='horizontal', color='black')
ax3.set_ylim([-5, 5])
fig = plt.gcf()
fig.suptitle(trace.id)
fig.canvas.draw()
if not save:
plt.show()
plt.close()
else:
plt.savefig(savefile)
return
def plot(X,
Y,
x,
y,
acquisition=None,
next_X=None,
f=None,
title=None,
output=None):
# Plot posterior samples and their mean, target function, and observations.
fig = plt.figure()
if acquisition is not None:
axs0 = plt.subplot2grid((4, 1), (0, 0), rowspan=3, colspan=1, fig=fig)
else:
axs0 = plt.subplot2grid((4, 1), (0, 0), rowspan=4, colspan=1, fig=fig)
if y is not None:
num_results = y.shape[0]
axs0.plot(np.stack([x[:, 0]] * num_results).T, y.T, c='r', alpha=.01)
mean = np.mean(y, axis=0)
var = np.var(y, axis=0)
axs0.plot(x[:, 0], mean, c='k')
axs0.fill_between(x[:, 0],
mean - 2 * np.sqrt(var),
mean + 2 * np.sqrt(var),
color='C0',
alpha=0.2)
if acquisition is not None:
axs1 = plt.subplot2grid((4, 1), (3, 0), rowspan=1, colspan=1, fig=fig)
axs1.plot(x, acquisition)
axs1.set_yticks([])
axs1.set_xticks([])
axs1.set_xlim(axs0.get_xlim())
if next_X is not None:
axs1.axvline(x=next_X, color='k', linestyle='--')
if next_X is not None:
axs0.axvline(x=next_X, color='k', linestyle='--')
if f is not None:
axs0.plot(x[:, 0], f(x))
axs0.scatter(X[:, 0], Y, zorder=1200)
if title is not None:
plt.suptitle(title)
if output is not None:
plt.savefig(output)
plt.tight_layout()
plt.show()
plt.close()
def plot_state_timeseries(state, length):
ax_main = pylab.subplot2grid((8, 8), (0, 0), colspan=4, rowspan=4)
ax_main.grid(1)
plot_state(ax_main, state, 10, length)
for si, s in enumerate(["x", "y", "phi", "theta"]):
ax_i = pylab.subplot2grid((8, 8), (4 + si, 0), colspan=8)
ax_i.plot(state[s])
ax_i.grid(1)
def plot_state_timeseries(state, length):
ax_main = pylab.subplot2grid((8, 8), (0, 0), colspan=4, rowspan=4)
ax_main.grid(1)
plot_state(ax_main, state, 10, length)
for si, s in enumerate(['x', 'y', 'phi', 'theta']):
ax_i = pylab.subplot2grid((8, 8), (4 + si, 0), colspan=8)
ax_i.plot(state[s])
ax_i.grid(1)
def plots1d(nimages=30,
nreplicas=4,
with_hist=True,
show=True,
height=5,
width=8):
plt.clf()
fig = plt.gcf()
fig.set_figheight(height)
fig.set_figwidth(width)
if with_hist:
ncol_hist = 2
else:
ncol_hist = 0
ax_list = [
plt.subplot2grid((1, nimages + ncol_hist), (0, i),
colspan=1,
rowspan=nimages) for i in range(nimages)
]
for ax in ax_list:
ax.set_ylim(0, 1)
ax.set_xticks([])
ax.set_yticks([])
ypos = np.random.uniform(0, 1, nreplicas)
ymax = ypos.max()
ax.axhspan(0, ymax, alpha=0.2)
xpos = np.zeros(nreplicas, )
ax.scatter(xpos, ypos, c='k', facecolors="none")
ax.scatter(0, ymax, c='r', linewidths=0, s=40)
if with_hist:
ax = plt.subplot2grid((1, nimages + ncol_hist), (0, nimages),
colspan=ncol_hist,
rowspan=nimages)
ax.set_xticks([])
ax.set_yticks([])
ax.set_ylim(0, 1)
n = 100000
rmax = np.random.beta(nreplicas, 1, size=n)
ax.hist(rmax,
bins=old_div(np.sqrt(n), 10),
orientation='horizontal',
normed=True)
if False:
y = np.arange(1, 0, -.01)
x = y**(nreplicas - 1)
x /= x.max()
ax.plot(x, y)
ax.relim()
if show:
plt.show()
def createRegressionPlots(predictions,performance,coefs,fb_coefs,nfb_coefs,GroupDF,goodsubj,savefig=True):
f=plt.figure(figsize=(22,12))
ax1=plt.subplot2grid((2,4),(0,0), colspan=3)
ax2=plt.subplot2grid((2,4),(0,3))
ax3=plt.subplot2grid((2,4),(1,0), colspan=2)
ax4=plt.subplot2grid((2,4),(1,2), colspan=2)
dmnIdeal=pd.read_csv('/home/jmuraskin/Projects/NFB/analysis/DMN_ideal_2.csv')
sns.tsplot(data=predictions,time='TR',value='predicted',unit='subj',condition='fb',ax=ax1)
ax1.plot((dmnIdeal['Wander']-dmnIdeal['Focus'])/3,'k--')
ax1.set_title('Average Predicted Time Series')
g=sns.violinplot(data=performance,x='fb',y='R',split=True,bw=.3,inner='quartile',ax=ax2)
# plt.close(g.fig)
g=sns.violinplot(data=coefs,x='pe',y='Coef',hue='fb',split=True,bw=.3,inner='quartile',ax=ax3)
g.plot([-1,len(unique(coefs['pe']))],[0,0],'k--')
g.set_xlim([-.5,len(unique(coefs['pe']))])
ylim=g.get_ylim()
t,p = ttest_1samp(np.array(performance[performance.fb=='FEEDBACK']['R'])-np.array(performance[performance.fb=='NOFEEDBACK']['R']),0)
ax2.set_title('Mean Subject Time Series Correlations-p=%0.2f' % p)
t,p = ttest_1samp(np.array(fb_coefs['Coef'].reshape(len(unique(GroupDF[GroupDF.Subject_ID.isin(goodsubj)]['Subject_ID'])),len(unique(coefs['pe'])))),0)
p05_FB,padj=fdr_correction(p,0.05)
t,p = ttest_1samp(np.array(nfb_coefs['Coef'].reshape(len(unique(GroupDF[GroupDF.Subject_ID.isin(goodsubj)]['Subject_ID'])),len(unique(coefs['pe'])))),0)
p05_NFB,padj=fdr_correction(p,0.05)
for idx,(pFDR_FB,pFDR_NFB) in enumerate(zip(p05_FB,p05_NFB)):
if pFDR_FB:
ax3.scatter(idx,ylim[1]-.05,marker='*',s=75)
if pFDR_NFB:
ax3.scatter(idx,ylim[0]+.05,marker='*',s=75)
t,p=ttest_1samp(np.array(fb_coefs['Coef']-nfb_coefs['Coef']).reshape(len(unique(GroupDF[GroupDF.Subject_ID.isin(goodsubj)]['Subject_ID'])),len(unique(coefs['pe']))),0)
p05,padj=fdr_correction(p,0.05)
sns.barplot(x=range(len(t)),y=t,ax=ax4,color='Red')
for idx,pFDR in enumerate(p05):
if pFDR:
ax4.scatter(idx,t[idx]+ np.sign(t[idx])*0.2,marker='*',s=75)
ax4.set_xlim([-0.5,len(unique(coefs['pe']))])
ax4.set_xlabel('pe')
ax4.set_ylabel('t-value')
ax4.set_title('FB vs. nFB PE')
for ax in [ax1,ax2,ax3,ax4]:
for item in ([ax.title, ax.xaxis.label, ax.yaxis.label]):
item.set_fontsize(18)
for item in (ax.get_xticklabels() + ax.get_yticklabels()):
item.set_fontsize(12)
f.tight_layout()
if savefig:
f.savefig('%s/RSN_LinearRegPrediction.pdf' % saveFigureLocation,dpi=300)
def plot_data(tag):
data_array = tag.references[0]
voltage = np.zeros(data_array.data.shape)
data_array.data.read_direct(voltage)
x_axis = data_array.dimensions[0]
time = x_axis.axis(data_array.data_extent[0])
spike_times = tag.positions[:]
feature_data_array = tag.features[0].data
snippets = tag.features[0].data[:]
single_snippet = tag.feature_data(3, 0)[:]
snippet_time_dim = feature_data_array.dimensions[1]
snippet_time = snippet_time_dim.axis(feature_data_array.data_extent[1])
response_axis = plt.subplot2grid((2, 2), (0, 0), rowspan=1, colspan=2)
single_snippet_axis = plt.subplot2grid((2, 2), (1, 0), rowspan=1, colspan=1)
average_snippet_axis = plt.subplot2grid((2, 2), (1, 1), rowspan=1, colspan=1)
response_axis.plot(time, voltage, color='dodgerblue', label=data_array.name)
response_axis.scatter(spike_times, np.ones(spike_times.shape)*np.max(voltage), color='red', label=tag.name)
response_axis.set_xlabel(x_axis.label + ((" [" + x_axis.unit + "]") if x_axis.unit else ""))
response_axis.set_ylabel(data_array.label + ((" [" + data_array.unit + "]") if data_array.unit else ""))
response_axis.set_title(data_array.name)
response_axis.set_xlim(0, np.max(time))
response_axis.set_ylim((1.2 * np.min(voltage), 1.2 * np.max(voltage)))
response_axis.legend(ncol=2, loc="lower center", fontsize=8)
single_snippet_axis.plot(snippet_time, single_snippet.T, color="red", label=("snippet No 4"))
single_snippet_axis.set_xlabel(snippet_time_dim.label + ((" [" + snippet_time_dim.unit + "]") if snippet_time_dim.unit else ""))
single_snippet_axis.set_ylabel(feature_data_array.label + ((" [" + feature_data_array.unit + "]") if feature_data_array.unit else ""))
single_snippet_axis.set_title("single stimulus snippet")
single_snippet_axis.set_xlim(np.min(snippet_time), np.max(snippet_time))
single_snippet_axis.set_ylim((1.2 * np.min(snippets[3,:]), 1.2 * np.max(snippets[3,:])))
single_snippet_axis.legend()
mean_snippet = np.mean(snippets, axis=0)
std_snippet = np.std(snippets, axis=0)
average_snippet_axis.fill_between(snippet_time, mean_snippet + std_snippet, mean_snippet - std_snippet, color="tab:red", alpha=0.25)
average_snippet_axis.plot(snippet_time, mean_snippet, color="red", label=(feature_data_array.name + str(4)))
average_snippet_axis.set_xlabel(snippet_time_dim.label + ((" [" + snippet_time_dim.unit + "]") if snippet_time_dim.unit else ""))
average_snippet_axis.set_ylabel(feature_data_array.label + ((" [" + feature_data_array.unit + "]") if feature_data_array.unit else ""))
average_snippet_axis.set_title("spike-triggered average")
average_snippet_axis.set_xlim(np.min(snippet_time), np.max(snippet_time))
average_snippet_axis.set_ylim((1.2 * np.min(mean_snippet - std_snippet), 1.2 * np.max(mean_snippet + std_snippet)))
plt.subplots_adjust(left=0.15, top=0.875, bottom=0.1, right=0.98, hspace=0.35, wspace=0.25)
plt.gcf().set_size_inches((5.5, 4.5))
# plt.savefig("../images/spike_features.png")
plt.show()
def quicklook(self, wf=None, logZ=True, show=True, title=None):
"""
Produces a figure with an image of amplitude and one of phase as well as 1D slices through these images
:param wf: optics.Wavefront
:param logZ: bool logarithmic Z scaling
:param show: bool display figure now or leave show() to be called by user later on
:param title: str
:return:
"""
if wf == None:
wf = self.wf_collection[0,0]
amp_map = proper.prop_get_amplitude(wf)
phase_map = proper.prop_get_phase(wf)
fig = plt.figure(figsize=(12, 10))
ax1 = plt.subplot2grid((1, 2), (0, 0), rowspan=2) # ((shape of grid to place axis x,y),(location x,y))
ax2 = plt.subplot2grid((1, 2), (0, 1), rowspan=2)
# ax3 = plt.subplot2grid((3, 2), (2, 0))
# ax4 = plt.subplot2grid((3, 2), (2, 1))
if logZ:
im1 = ax1.imshow(amp_map, origin='lower', cmap="YlGnBu_r", norm=LogNorm())
else:
im1 = ax1.imshow(amp_map, origin='lower', cmap="YlGnBu_r")
ax1.set_title('Amplitude Map')
plt.colorbar(im1, ax=ax1)
im2 = ax2.imshow(phase_map, origin='lower', cmap=sunlight) # , vmin=-0.5, vmax=0.5)
ax2.set_title('Phase Map')
plt.colorbar(im2, ax=ax2)
# ax3.plot(after_dm[int(sp.grid_size / 2)])
# ax3.plot(np.sum(np.eye(sp.grid_size) * after_dm, axis=1), label=f'row {int(sp.grid_size / 2)}')
# ax3.legend()
#
# # plt.plot(np.sum(after_dm,axis=1)/after_dm[128,128])
#
# ax4.plot(phase_afterdm[int(sp.grid_size / 2)], label=f'row {int(sp.grid_size / 2)}')
# ax4.legend()
# # ax4.plot(np.sum(np.eye(ap.grid_size)*phase_afterdm,axis=1))
# plt.xlim([0, proper.prop_get_gridsize(wf)])
if not title:
title = input(f"Always Add A Title\n "
f"Please Enter Plane Name:")
fig.suptitle(f"plane: {title}, lambda: {wf.lamda} m, body: {wf.name}", fontsize=18)
else:
fig.suptitle(f"plane: {title}, lambda: {wf.lamda} m, body: {wf.name}", fontsize=18)
plt.subplots_adjust(top=0.9)
if show:
plt.show(block=True)
def triptych_fitfdiff(tfdata, foci, foci_colors, color_scales, filenames, title=None, lines=True):
fig = plt.figure(figsize=(28, 8), dpi=200);
ax1 = plt.subplot2grid((1, 3), (0, 0), colspan=1, rowspan=1)
panel_fitfdiff(tfdata, title, lines)
ax1 = plt.subplot2grid((1, 3), (0, 1), colspan=1, rowspan=1)
panel_mesh_sagittal(foci, foci_colors, color_scales)
ax1 = plt.subplot2grid((1, 3), (0, 2), colspan=1, rowspan=1)
panel_mesh_axial(foci, foci_colors, color_scales)
for filename in filenames:
plt.savefig(filename, bbox_inches='tight');
plt.clf();
plt.close(fig);
def plot_observed_vs_predicted(observations, predictions, fig=None):
if fig is None:
fig = plt.figure(figsize=(9, 9 + 3))
ax_obs_pred = plt.subplot2grid((3, 4), (0, 1), rowspan=2, colspan=3)
ax_residuals = plt.subplot2grid((3, 4), (2, 1), colspan=3, sharex=ax_obs_pred)
ax_residual_kde = plt.subplot2grid((3, 4), (2, 0), sharey=ax_residuals)
_actual_plot_observed_vs_predicted(observations, predictions, ax=ax_obs_pred)
plot_residuals(observations, predictions, ax=ax_residuals)
plot_residual_kde(residuals=observations - predictions, ax=ax_residual_kde)
ax_residual_kde.set_zorder(-1)
fig.tight_layout()
fig.subplots_adjust(hspace=0)
return fig
def plot_data(tag):
data_array = tag.references[0]
voltage = data_array[:]
x_axis = data_array.dimensions[0]
time = x_axis.axis(data_array.data_extent[0])
stimulus_onset = tag.position
stimulus_duration = tag.extent
stimulus = tag.feature_data(0)
stimulus_array = tag.features[0].data
stim_time_dim = stimulus_array.dimensions[0]
stimulus_time = stim_time_dim.axis(stimulus_array.data_extent[0])
response_axis = plt.subplot2grid((2, 2), (0, 0), rowspan=1, colspan=2)
response_axis.tick_params(direction='out')
response_axis.spines['top'].set_color('none')
response_axis.spines['right'].set_color('none')
response_axis.xaxis.set_ticks_position('bottom')
response_axis.yaxis.set_ticks_position('left')
stimulus_axis = plt.subplot2grid((2, 2), (1, 0), rowspan=1, colspan=2)
stimulus_axis.tick_params(direction='out')
stimulus_axis.spines['top'].set_color('none')
stimulus_axis.spines['right'].set_color('none')
stimulus_axis.xaxis.set_ticks_position('bottom')
stimulus_axis.yaxis.set_ticks_position('left')
response_axis.plot(time, voltage, color='tab:blue', label=data_array.name, zorder=1)
response_axis.set_xlabel(x_axis.label + ((" [" + x_axis.unit + "]") if x_axis.unit else ""))
response_axis.set_ylabel(data_array.label + ((" [" + data_array.unit + "]") if data_array.unit else ""))
response_axis.set_xlim(0, np.max(time))
response_axis.set_ylim((1.2 * np.min(voltage), 1.2 * np.max(voltage)))
response_axis.barh((np.max(voltage) - np.min(voltage))/2, stimulus_duration, np.min(voltage) - np.max(voltage),
stimulus_onset, color='silver', alpha=0.5, zorder=0, label="stimulus epoch")
response_axis.legend(fontsize=9, ncol=2, loc=9)
stimulus_axis.plot(stimulus_time, stimulus[:], color="slategray", label="stimulus")
stimulus_axis.set_xlabel(stim_time_dim.label + ((" [" + stim_time_dim.unit + "]") if stim_time_dim.unit else ""))
stimulus_axis.set_ylabel(stimulus_array.label + ((" [" + stimulus_array.unit + "]") if stimulus_array.unit else ""))
stimulus_axis.set_xlim(np.min(stimulus_time), np.max(stimulus_time))
stimulus_axis.set_ylim(1.2 * np.min(stimulus), 1.2 * np.max(stimulus))
stimulus_axis.legend(fontsize=9, loc=1)
plt.subplots_adjust(left=0.15, top=0.875, bottom=0.1, right=0.98, hspace=0.45, wspace=0.25)
plt.gcf().set_size_inches((5.5, 5))
# plt.savefig("../images/untagged_feature.png")
plt.show()
def time_freq_plot(t, freqs, data, coefs, xunits='s', yunits=''):
if xunits == 'ms':
t = 1e3 * t
fig = plt.figure(figsize=(12, 6))
plt.subplots_adjust(wspace=.8, hspace=.5, bottom=.2)
# signal plot
plt.subplot2grid((3, 7), (0, 0), colspan=6)
plt.plot(t, data)
plt.ylabel(yunits)
plt.xlim([t[0], t[-1]])
# time frequency power plot
plt.subplot2grid((3, 7), (1, 0), rowspan=2, colspan=6)
c = plt.contourf(t, freqs, coefs, cmap='PRGn', aspect='auto')
plt.xlabel('time (' + xunits + ')')
plt.ylabel('frequency (Hz)')
# mean power plot over intervals
plt.subplot2grid((3, 7), (1, 6), rowspan=2)
plt.xlabel('power')
# max of power over intervals
plt.subplot2grid((3, 8), (1, 7), rowspan=2)
plt.barh(freqs, np.power(coefs,2).mean(axis=1),\
label='mean', height=freqs[-1]-freqs[-2])
# plt.plot(np.power(coefs,2).max(axis=1), freqs,\
# label='max.')
plt.xlabel(' power')
plt.legend(prop={'size': 'small'}, loc=(0.1, 1.1))
return fig
def makeP(pFolder, pName, supDir=supDir):
csv = os.path.join(pFolder, ''.join(['meanTable_', pName, '.csv']))
nii = os.path.join(pFolder, ''.join(['tMap_', pName, '.nii']))
fig, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4, figsize=(16, 3))
ax1 = plt.subplot2grid((1, 14), (0, 0), colspan=2)
ax1.text(0.05, 0.95, pName, size=24)
ax1 = plotting.plot_stat_map(nii,
display_mode='y',
cut_coords=([15]),
colorbar=False,
threshold=3,
axes=ax1,
bg_img='%s/data/external/ch2better.nii.gz' %
supDir,
black_bg=False,
draw_cross=False)
ax2 = plt.subplot2grid((1, 14), (0, 2), colspan=5)
ax2 = plotting.plot_stat_map(nii,
display_mode='x',
cut_coords=(-50, 50),
colorbar=False,
threshold=3,
axes=ax2,
bg_img='%s/data/external/ch2better.nii.gz' %
supDir,
black_bg=False,
draw_cross=False)
meanPredDf = pd.read_csv(csv, index_col=[0, 1], header=0)
pGroup = meanPredDf.loc[
'2d',
['left', 'bilateral', 'right', 'inconclusive']].loc['full'].idxmax()
ax3 = plt.subplot2grid((1, 14), (0, 8), colspan=3)
ax3 = singlePlot2d(meanPredDf, cDict[pGroup], ax3)
ax4 = plt.subplot2grid((1, 14), (0, 11), colspan=3)
ax4 = makeDonut(meanPredDf, ax4)
figName = '%s/fig_%s.png' % (pFolder, pName)
plt.savefig(figName, bbox_inches='tight', dpi=300)
return figName
def BS_plot(t, sol):
def plot_p():
## Plot pump evolution
fig_p, ax_p = pl.subplots()
for s in a_sol:
ax_p.plot(t, s[:,2])
ax_p.plot(t, s[:,3])
ax_e = pl.subplot2grid((2,2),(1,0), colspan=2)
ax_s = pl.subplot2grid((2,2),(0,0))
ax_i = pl.subplot2grid((2,2),(0,1))
plot_t(t, sol, (ax_s,ax_i))
plot_e(t, sol, ax_e)
def plot_single_cell_sim(data,
XTICKS=None,
COLORS=[Green, Blue, Red, Orange],
savefig=''):
Model = data['Model']
Vthre = Model[Model['NRN_KEY'] + '_Vthre']
fig, N1, N2 = plt.figure(figsize=(4, 5)), 5, 1
plt.subplots_adjust(left=.15, bottom=.05, top=.96, right=.99)
ax1 = plt.subplot2grid((N1, N2), (0, 0))
ax2 = plt.subplot2grid((N1, N2), (1, 0), rowspan=2)
ax3 = plt.subplot2grid((N1, N2), (3, 0), rowspan=2)
# presynaptic raster
j = 0
for i in range(len(Model['POP_STIM'])):
prespikes = data['t_prespikes'][i]
Npre = Model['N_' + Model['POP_STIM'][i]]
y = j + np.random.randint(Npre, size=len(prespikes))
ax1.plot(prespikes, y, 'o', color=color(Model['POP_STIM'][i]), ms=2.)
j += Npre
ax1.set_yticks([])
ax1.set_ylabel('presynaptic\n neurons')
# synaptic currents
ax2.plot(np.arange(len(data['Vm'][0])) * float(Model['dt']),
data['Ie'][0],
lw=1,
color=Green)
ax2.plot(np.arange(len(data['Vm'][0])) * float(Model['dt']),
data['Ii'][0],
lw=1,
color=Red)
ax2.set_ylabel('synaptic\ncurrents (nA)')
# Vm and spikes
for i in range(Model['N_SEED']):
ax3.plot(np.arange(len(data['Vm'][i])) * float(Model['dt']),
data['Vm'][i],
lw=1.,
color='k')
for t in data['tspikes']:
ax3.plot([t, t], [Vthre, Vthre + 5], ':', lw=2, color='k')
for label, func in zip(['time (ms)', '$V_m$ (mV)'],
[ax3.set_xlabel, ax3.set_ylabel]):
func(label) # labeling
ax3.set_yticks([-70, -60, -50])
if XTICKS is not None:
ax1.set_xticks(XTICKS)
ax2.set_xticks(XTICKS)
ax3.set_xticks(XTICKS)
ax2.set_xticklabels([])
ax1.set_xticklabels([])
return fig
def onpick(event):
ind = event.ind
#print('onpick scatter event number:', ind)
#print('Shown index', ind[0])
#print('length of index', len(ind))
#print('area of event', ds_child["area_um"][ind[0]])
#plt.figure(figsize=(10,5))
samples = ds.config["fluorescence"]["samples per event"]
sample_rate = ds.config["fluorescence"]["sample rate"]
t = np.arange(samples) / sample_rate * 1e6
figure, axes = plt.subplots(nrows=5, sharex=False, sharey=False)
axes[0] = plt.subplot2grid((5, 3), (0, 0), colspan=5)
axes[1] = plt.subplot2grid((5, 3), (1, 0), colspan=5)
axes[2] = plt.subplot2grid((5, 3), (2, 1))
axes[3] = plt.subplot2grid((5, 3), (3, 1))
axes[4] = plt.subplot2grid((5, 3), (4, 1))
axes[0].imshow(ds_child["image"][ind[0]], cmap="gray")
axes[1].imshow(ds_child["mask"][ind[0]])
axes[2].plot(t, ds_child["trace"]["fl1_median"][ind[0]], color="#16A422",
label=ds.config["fluorescence"]["channel 1 name"])
axes[3].plot(t, ds_child["trace"]["fl2_median"][ind[0]], color="#CE9720",
label=ds.config["fluorescence"]["channel 2 name"])
axes[4].plot(t, ds_child["trace"]["fl3_median"][ind[0]], color="#CE2026",
label=ds.config["fluorescence"]["channel 3 name"])
axes[2].set_xlim(0, 570) #(200, 350)
axes[2].grid()
axes[3].set_xlim(0, 570) #(200, 350)
axes[3].grid()
axes[4].set_xlim(0, 570) #(200, 350)
axes[4].grid()
axes[2].axvline(ds_child["fl1_pos"][ind[0]] + ds_child["fl1_width"][ind[0]]/2, color="gray")
axes[2].axvline(ds_child["fl1_pos"][ind[0]] - ds_child["fl1_width"][ind[0]]/2, color="gray")
#axes[2].axvline(350, color="black")
#axes[2].axvline(200, color="black")
axes[3].axvline(ds_child["fl2_pos"][ind[0]] + ds_child["fl2_width"][ind[0]]/2, color="gray")
axes[3].axvline(ds_child["fl2_pos"][ind[0]] - ds_child["fl2_width"][ind[0]]/2, color="gray")
#axes[3].axvline(350, color="black")
#axes[3].axvline(200, color="black")
axes[4].axvline(ds_child["fl3_pos"][ind[0]] + ds_child["fl3_width"][ind[0]]/2, color="gray")
axes[4].axvline(ds_child["fl3_pos"][ind[0]] - ds_child["fl3_width"][ind[0]]/2, color="gray")
#axes[4].axvline(350, color="black")
#axes[4].axvline(200, color="black")
plt.show()
print(ds_child["trace"][ind[0]])
def plots1d(nimages=30, nreplicas=4, with_hist=True, show=True,
height=5, width=8):
plt.clf()
fig = plt.gcf()
fig.set_figheight(height)
fig.set_figwidth(width)
if with_hist:
ncol_hist = 2
else:
ncol_hist = 0
ax_list = [plt.subplot2grid((1,nimages+ncol_hist), (0,i),
colspan=1, rowspan=nimages)
for i in xrange(nimages)]
for ax in ax_list:
ax.set_ylim(0,1)
ax.set_xticks([])
ax.set_yticks([])
ypos = np.random.uniform(0,1,nreplicas)
ymax= ypos.max()
ax.axhspan(0, ymax, alpha=0.2)
xpos = np.zeros(nreplicas, )
ax.scatter(xpos, ypos, c='k', facecolors="none")
ax.scatter(0, ymax, c='r', linewidths=0, s=40)
if with_hist:
ax = plt.subplot2grid((1,nimages+ncol_hist), (0,nimages),
colspan=ncol_hist, rowspan=nimages)
ax.set_xticks([])
ax.set_yticks([])
ax.set_ylim(0,1)
n = 100000
rmax = np.random.beta(nreplicas, 1, size=n)
ax.hist(rmax, bins=np.sqrt(n)/10, orientation='horizontal', normed=True)
if False:
y = np.arange(1,0,-.01)
x = y**(nreplicas-1)
x /= x.max()
ax.plot(x,y)
ax.relim()
if show:
plt.show()
def fig_rv():
plt.rcParams['lines.markersize'] = 3
post = ktwo19.keplerian.max_a_posteriori()
plotter = orbit_plots.GPMultipanelPlot(
post,
subtract_orbit_model=False,
nobin=True,
phase_nrows=None,
phase_ncols=3,
)
fig = plt.figure(figsize=(8, 5.5))
ax1 = plt.subplot2grid((2, 3), (0, 0), colspan=3)
ax2 = plt.subplot2grid(
(2, 3),
(1, 0),
)
ax3 = plt.subplot2grid(
(2, 3),
(1, 1),
)
ax4 = plt.subplot2grid(
(2, 3),
(1, 2),
)
axL = [ax1, ax2, ax3, ax4]
plt.rc('font', size=9)
plotter.nobin = True
plotter.legend = False
plotter.epoch = 2454833
plotter.phasetext_size = 'small'
plt.sca(ax1)
plotter.plot_timeseries()
radvel.plot.labelfig(97)
plt.sca(ax2)
plotter.plot_phasefold(98, 1)
plt.sca(ax3)
plotter.plot_phasefold(99, 2)
plt.sca(ax4)
plotter.plot_phasefold(100, 3)
plt.setp(axL[2:], ylabel='')
_ = plt.setp(axL[1:],
ylim=(-23, 23),
yticks=[-20, -15, -10, -5, 0, 5, 10, 15, 20])
_ = plt.setp(axL[0], ylim=(-38, 38), xlim=(2200, 3300))
plt.tight_layout(True)
plt.subplots_adjust(wspace=0.2)
def plot_data(tag):
data_array = tag.references[0]
voltage = data_array[:]
x_axis = data_array.dimensions[0]
time = x_axis.axis(data_array.data_extent[0])
stimulus_onset = tag.position
stimulus_duration = tag.extent
stimulus = tag.retrieve_feature_data(0)
stimulus_array = tag.features[0].data
stim_time_dim = stimulus_array.dimensions[0]
stimulus_time = stim_time_dim.axis(stimulus_array.data_extent[0])
response_axis = plt.subplot2grid((2, 2), (0, 0), rowspan=1, colspan=2)
response_axis.tick_params(direction='out')
response_axis.spines['top'].set_color('none')
response_axis.spines['right'].set_color('none')
response_axis.xaxis.set_ticks_position('bottom')
response_axis.yaxis.set_ticks_position('left')
stimulus_axis = plt.subplot2grid((2, 2), (1, 0), rowspan=1, colspan=2)
stimulus_axis.tick_params(direction='out')
stimulus_axis.spines['top'].set_color('none')
stimulus_axis.spines['right'].set_color('none')
stimulus_axis.xaxis.set_ticks_position('bottom')
stimulus_axis.yaxis.set_ticks_position('left')
response_axis.plot(time, voltage, color='dodgerblue', label=data_array.name, zorder=1)
response_axis.set_xlabel(x_axis.label + ((" [" + x_axis.unit + "]") if x_axis.unit else ""))
response_axis.set_ylabel(data_array.label + ((" [" + data_array.unit + "]") if data_array.unit else ""))
response_axis.set_xlim(0, np.max(time))
response_axis.set_ylim((1.2 * np.min(voltage), 1.2 * np.max(voltage)))
response_axis.barh(1.2 * np.min(voltage), stim_duration, (1.2*np.max(voltage)) - (1.2*np.min(voltage)),
stim_onset, color='silver', alpha=0.25, zorder=0, label="stimulus epoch")
response_axis.legend()
stimulus_axis.plot(stimulus_time, stimulus, color="slategray", label="stimulus")
stimulus_axis.set_xlabel(stim_time_dim.label + ((" [" + stim_time_dim.unit + "]") if stim_time_dim.unit else ""))
stimulus_axis.set_ylabel(stimulus_array.label + ((" [" + stimulus_array.unit + "]") if stimulus_array.unit else ""))
stimulus_axis.set_xlim(np.min(stimulus_time), np.max(stimulus_time))
stimulus_axis.set_ylim(1.2 * np.min(stimulus), 1.2 * np.max(stimulus))
stimulus_axis.legend()
plt.subplots_adjust(left=0.15, top=0.875, bottom=0.1, right=0.98, hspace=0.45, wspace=0.25)
plt.show()
def makePlot(iFile, title, pltz, c):
roiMat = []
for l in iFile:
roiMat.append(l)
roiMat = np.array(roiMat)
roiMat = roiMat.astype(np.float)
axes = plt.subplot2grid((4,1), (c, 0))
pltz.append(axes)
#pltz[c].set_title(title)
#_#_#_#_#_#
cmap = plt.get_cmap(lut=np.nanmax(roiMat)-np.nanmin(roiMat)+1)
pltz[c].matshow(roiMat, aspect='auto', cmap=cmap, vmin=0, vmax=40)
#pltz[c].colorbar(label='Count')
if c == 3:
pltz[c].set_xlabel('ROI')
pltz[c].set_ylabel(title)
if c == 0:
pltz[c].set_xticks(range(30))
pltz[c].set_xticklabels(["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30"])
else:
pltz[c].set_xticklabels([])
pltz[c].set_yticks(range(7))
pltz[c].set_yticklabels(["E", "G", "L", "M", "R", "S", "W"], rotation =90)
for asd, cas in enumerate(roiMat):
for sdf, c in enumerate(cas):
plt.text(sdf-.4, asd+.2, int(c), fontsize=8)
def plot_waveforms(index, waveforms):
"""Plots one univariate time series."""
# Get file name
file_name = list(waveforms.keys())[index]
# Setup plot
fig = plt.figure(figsize=(15, 6))
fig.subplots_adjust(hspace=0.25)
ax1 = plt.subplot2grid((1, 1), (0, 0))
ax1.set_title('File Name: ' + file_name + '\n'
'Label: ' + waveforms[file_name]['label_str'],
fontsize=20)
# Plot waveform
ax1.plot(waveforms[file_name]['time'],
waveforms[file_name]['filtered'],
'-k',
label='Filtered')
ax1.vlines(waveforms[file_name]['rpeaks_ts'],
waveforms[file_name]['filtered'].min() - 0.01,
waveforms[file_name]['filtered'].max() + 0.01,
color=[0.7, 0.7, 0.7],
linewidth=4,
label='R-Peaks')
ax1.set_xlabel('Time, seconds', fontsize=25)
ax1.set_ylabel('Normalized Amplitude', fontsize=25)
ax1.set_xlim([0, waveforms[file_name]['duration']])
ax1.set_ylim([
waveforms[file_name]['filtered'].min() - 0.01,
waveforms[file_name]['filtered'].max() + 0.01
])
ax1.tick_params(labelsize=18)
def diff_data(ts_train):
data_diff = ts_train.diff(1)
data_diff = data_diff.dropna()
layout1 = (1, 2)
data_train_ax = plt.subplot2grid(layout1, (0, 0))
data_diff_ax = plt.subplot2grid(layout1, (0, 1))
data_train_ax.plot(ts_train)
data_train_ax.set_title('原数据')
data_diff_ax.plot(data_diff)
data_diff_ax.set_title('一阶差分')
# fig.tight_layout()
plt.show()
sns.despine()
print(data_diff.shape)
return data_diff
def plot_waveform(index, labels, waveform_path, fs):
# Get file name
file_name = labels.loc[index, 'file_name']
# Get label
label = labels.loc[index, 'label']
# Get waveform
time, waveform = load_waveform(path=os.path.join(waveform_path,
file_name + '.mat'),
fs=fs)
# Setup plot
fig = plt.figure(figsize=(15, 6))
fig.subplots_adjust(hspace=0.25)
ax1 = plt.subplot2grid((1, 1), (0, 0))
ax1.set_title('File Name: ' + file_name + '\nLabel: ' + label, fontsize=20)
# Plot waveform
ax1.plot(time, waveform, '-k')
# Configure axes
ax1.set_xlabel('Time, seconds', fontsize=25)
ax1.set_ylabel('Amplitude, mV', fontsize=25)
ax1.set_xlim([time[0], time[-1]])
ax1.tick_params(labelsize=18)
def multiPlot(myData):
ax=plt.subplot2grid((ncol,nrow),(yPanel,xPanel))
ax.hist(df[quantVar[myData]],alpha=0.5)#alpha??
ax.set_xlabel(quantVar[myData],fontsize=14,fontweight='bold')
#ax.set_ylabel('Y',fontsize=14,fontweight='bold',rotation='Vertical')
plt.locator_params(axis = 'x', nbins = 2)
ax.tick_params(labelsize=14)
def time_freq_plot(t, freqs, data, coefs):
"""
a plot to illustrate the output of the wavelet analysis
"""
dt = t[1] - t[0]
import matplotlib.pylab as plt
fig = plt.figure(figsize=(8, 5))
plt.subplots_adjust(wspace=.8, hspace=.5, bottom=.2)
# signal plot
plt.subplot2grid((3, 8), (0, 0), colspan=6)
plt.plot(1e3 * t, data, 'k-', lw=2)
plt.ylabel('signal')
plt.xlim([1e3 * t[0], 1e3 * t[-1]])
# time frequency power plot
ax1 = plt.subplot2grid((3, 8), (1, 0), rowspan=2, colspan=6)
c = plt.contourf(1e3 * t, freqs, coefs, cmap='PRGn', aspect='auto')
plt.xlabel('time (ms)')
plt.ylabel('frequency (Hz)')
# inset with legend
acb = plt.axes([.4, .4, .02, .2])
plt.colorbar(c, cax=acb, label='coeffs (a.u.)', ticks=[-1, 0, 1])
# mean power plot over intervals
plt.subplot2grid((3, 8), (1, 6), rowspan=2)
plt.barh(freqs, np.power(coefs, 2).mean(axis=1) * dt)
plt.xticks([])
plt.xlabel(' mean \n power \n (a.u.)')
# max of power over intervals
plt.subplot2grid((3, 8), (1, 7), rowspan=2)
plt.barh(freqs, np.power(coefs, 2).max(axis=1) * dt)
plt.xticks([])
plt.xlabel(' max. \n power \n (a.u.)')
return fig
def get_fig(height, n, layout='one_large_three_small'):
import matplotlib.pylab as plt
if layout == 'one_large_three_small':
# Generate a figure
fig = plt.figure(figsize = (4*height, 3*height))
# Create the four subplots
ax1 = plt.subplot2grid((3,4), (0,0), colspan=3, rowspan=3)
ax2 = plt.subplot2grid((3,4), (0,3))
ax3 = plt.subplot2grid((3,4), (1,3))
ax4 = plt.subplot2grid((3,4), (2,3))
# Create your axes list
ax_list = [ ax1, ax2, ax3, ax4 ]
fontsizes = [ 10*height, 5*height, 5*height, 5*height ] # Marker sizes
if layout == 'one_row':
# Generate a figure
fig = plt.figure(figsize = (n*height, height))
ax_list = []
for i in range(n):
ax = plt.subplot2grid((1,n), (0,i))
ax_list.append(ax)
fontsizes = [ 15, 15, 15, 15, 15, 15, 15, 15 ] # Marker sizes
if layout == 'just_one':
# Generate a figure
fig = plt.figure(figsize = (height*1.5, height))
# Add just one subplot
ax1 = plt.axes()
ax_list = [ ax1 ]
fontsizes = [ 15 ]
return fig, ax_list, fontsizes
def quadriptych(importances, foci, foci_colors, cluster_means, cluster_predictive_score, cluster_poly_proportion, cid, title, filenames, lines=True):
fig = plt.figure(figsize=(40, 8), dpi=300);
vlim = np.max([np.abs(np.min(cluster_means)), np.abs(np.max(cluster_means))]) * 1.2
# overall importances
ax1 = plt.subplot2grid((2, 8), (0, 0), colspan=2, rowspan=2)
panel_importance(importances, title, lines)
# 4 most prominents clusters of activity under the important regions
ax1 = plt.subplot2grid((2, 8), (0, 2))
panel_cluster_mean(0, cluster_means, cluster_predictive_score, cluster_poly_proportion, np.sum(foci_colors == 'green'), vlim, 'green', cid, lines=True, xlabels=False, ylabels=True)
ax1 = plt.subplot2grid((2, 8), (0, 3))
panel_cluster_mean(1, cluster_means, cluster_predictive_score, cluster_poly_proportion, np.sum(foci_colors == 'blue'), vlim, 'blue', cid, lines=True, xlabels=False, ylabels=False)
ax1 = plt.subplot2grid((2, 8), (1, 2))
panel_cluster_mean(2, cluster_means, cluster_predictive_score, cluster_poly_proportion, np.sum(foci_colors == 'red'), vlim, 'red', cid, lines=True, xlabels=True, ylabels=True)
ax1 = plt.subplot2grid((2, 8), (1, 3))
panel_cluster_mean(3, cluster_means, cluster_predictive_score, cluster_poly_proportion, np.sum(foci_colors == 'black'), vlim, 'black', cid, lines=True, xlabels=True, ylabels=False)
# sagittal
ax1 = plt.subplot2grid((2, 8), (0, 4), colspan=2, rowspan=2)
panel_mesh_sagittal(foci, foci_colors, {'blue': 0.6, 'black': 0.6, 'red': 0.6, 'green': 0.6, 'whitesmoke': 0.6})
# axial
ax1 = plt.subplot2grid((2, 8), (0, 6), colspan=2, rowspan=2)
panel_mesh_axial(foci, foci_colors, {'blue': 0.6, 'black': 0.6, 'red': 0.6, 'green': 0.6, 'whitesmoke': 0.6})
# store the figure
for filename in filenames:
plt.savefig(filename, bbox_inches='tight');
plt.clf();
plt.close(fig);
def plot_data(tag):
data_array = tag.references[0]
voltage = data_array[:]
x_axis = data_array.dimensions[0]
time = x_axis.axis(data_array.data_extent[0])
spike_times = tag.positions[:]
feature_data_array = tag.features[0].data
stimulus = feature_data_array[:]
stim_time_dim = feature_data_array.dimensions[0]
stimulus_time = stim_time_dim.axis(feature_data_array.data_extent[0])
response_axis = plt.subplot2grid((2, 2), (0, 0), rowspan=1, colspan=2)
stimulus_axis = plt.subplot2grid((2, 2), (1, 0), rowspan=1, colspan=2, sharex=response_axis)
response_axis.plot(time, voltage, color="dodgerblue", label=data_array.name)
response_axis.scatter(spike_times, np.ones(spike_times.shape) * np.max(voltage), color="red", label=tag.name)
response_axis.set_xlabel(x_axis.label + ((" [" + x_axis.unit + "]") if x_axis.unit else ""))
response_axis.set_ylabel(data_array.label + ((" [" + data_array.unit + "]") if data_array.unit else ""))
response_axis.set_title(data_array.name)
response_axis.set_xlim(0, np.max(time))
response_axis.set_ylim((1.2 * np.min(voltage), 1.2 * np.max(voltage)))
response_axis.legend()
stimulus_axis.plot(stimulus_time, stimulus, color="black", label="stimulus")
stimulus_axis.scatter(spike_times, np.ones(spike_times.shape) * np.max(stimulus), color="red", label=tag.name)
stimulus_axis.set_xlabel(stim_time_dim.label + ((" [" + stim_time_dim.unit + "]") if stim_time_dim.unit else ""))
stimulus_axis.set_ylabel(
feature_data_array.label + ((" [" + feature_data_array.unit + "]") if feature_data_array.unit else "")
)
stimulus_axis.set_title("stimulus")
stimulus_axis.set_xlim(np.min(stimulus_time), np.max(stimulus_time))
stimulus_axis.set_ylim(1.2 * np.min(stimulus), 1.2 * np.max(stimulus))
stimulus_axis.legend()
plt.subplots_adjust(left=0.15, top=0.875, bottom=0.1, right=0.98, hspace=0.45, wspace=0.25)
# plt.savefig('taggedFeature.png')
plt.show()
def survival_stat_plot(t, upper_lim=5, axs=None, colors=None):
"""
t is the DataFrame returned from a get_surv_fit call.
"""
if axs is None:
fig = plt.figure(figsize=(6, 1.5))
ax = plt.subplot2grid((1, 3), (0, 0), colspan=2)
ax2 = plt.subplot2grid((1, 3), (0, 2))
else:
ax, ax2 = axs
fig = plt.gcf()
if colors is None:
colors = colors_global
for i, (idx, v) in enumerate(t.iterrows()):
conf_int = v['Median Survival']
median_surv = v[('Median Survival', 'Median')]
if (v['Stats']['# Events'] / v['Stats']['# Patients']) < .5:
median_surv = np.nanmin([median_surv, 20])
conf_int['Upper'] = np.nanmin([conf_int['Upper'], 20])
l = ax.plot(*zip(*[[conf_int['Lower'], i], [median_surv, i], [conf_int['Upper'], i]]), lw=3, ls='--',
marker='o', dash_joinstyle='bevel', color=colors[i])
ax.scatter(median_surv, i, marker='s', s=100, color=l[0].get_color(), edgecolors=['black'], zorder=10,
label=idx)
ax.set_yticks(range(len(t)))
ax.set_yticklabels(['{} ({})'.format(idx, int(t.ix[idx]['Stats']['# Patients']))
for idx in t.index])
ax.set_ylim(-.5, i + .5)
ax.set_xlim(0, upper_lim)
ax.set_xlabel('Median Survival (Years)')
tt = t['5y Survival']
(tt['Surv']).plot(kind='barh', ax=ax2,
color=[l.get_color() for l in ax.lines],
xerr=[tt.Surv - tt.Lower, tt.Upper - tt.Surv],
width=.75,
ecolor='black')
ax2.set_ybound(-.5,len(t)-.5)
ax2.set_xlabel('5Y Survival')
ax2.set_xticks([0, .5, 1.])
ax2.set_yticks([])
fig.tight_layout()
def get_fig(height, layout='one_large_three_small'):
import matplotlib.pylab as plt
if layout == 'one_large_three_small':
# Generate a figure
fig = plt.figure(figsize = (4*height, 3*height))
# Create the four subplots
ax1 = plt.subplot2grid((3,4), (0,0), colspan=3, rowspan=3)
ax2 = plt.subplot2grid((3,4), (0,3))
ax3 = plt.subplot2grid((3,4), (1,3))
ax4 = plt.subplot2grid((3,4), (2,3))
# Create your axes list
ax = [ ax1, ax2, ax3, ax4 ]
msizes = [ 50, 15, 15, 15 ] # Marker sizes
if layout == 'four_equal_size_one_row':
# Generate a figure
fig = plt.figure(figsize = (4*height, height))
# Create four subplots
ax1 = plt.subplot2grid((1,4), (0,0))
ax2 = plt.subplot2grid((1,4), (0,1))
ax3 = plt.subplot2grid((1,4), (0,2))
ax4 = plt.subplot2grid((1,4), (0,3))
msizes = [ 5, 5, 5, 5 ] # Marker sizes
# Create your axes list
ax = [ ax1, ax2, ax3, ax4 ]
if layout == 'just_one':
# Generate a figure
fig = plt.figure(figsize = (height*1.5, height))
# Add just one subplot
ax1 = plt.axes()
ax = [ ax1 ]
msizes = [ 5 ]
# Set the marker sizes
msizes = [ m * height for m in msizes ]
return fig, ax, msizes
def test_step(self):
"""Test function ``step``."""
figure(); plot_shape = (1, 3)
#Test SISO system
A, B, C, D = self.make_SISO_mats()
sys = ss(A, B, C, D)
#print(sys)
#print("gain:", dcgain(sys))
subplot2grid(plot_shape, (0, 0))
t, y = step(sys)
plot(t, y)
subplot2grid(plot_shape, (0, 1))
T = linspace(0, 2, 100)
X0 = array([1, 1])
t, y = step(sys, T, X0)
plot(t, y)
#Test MIMO system
A, B, C, D = self.make_MIMO_mats()
sys = ss(A, B, C, D)
subplot2grid(plot_shape, (0, 2))
t, y = step(sys)
plot(t, y)
def plot_update(fig, axarr, data1, data2, round):
plt.cla()
dota1 = data1 / STARTING_PCT
dota2 = data2 / STARTING_PCT
center_of_mass1 = ndimage.measurements.center_of_mass(dota1)
center_of_mass2 = ndimage.measurements.center_of_mass(dota2)
axarr = [plt.subplot(fig[0, 0]), plt.subplot2grid((2, 2), (1, 0), colspan=2), plt.subplot(fig[0, 1])]
img1 = axarr[0].imshow(
dota1,
interpolation="nearest",
cmap=plt.cm.ocean,
extent=(0.5, np.shape(dota1)[0] + 0.5, 0.5, np.shape(dota1)[1] + 0.5),
)
axarr[0].plot([center_of_mass1[1]], [center_of_mass1[0]], "or") # adds dot at center of mass
axarr[0].plot([center_of_mass2[1]], [center_of_mass2[0]], "oy") # adds dot for other teams c o m
axarr[0].axis((1, 101, 1, 101))
axarr[1].plot(avg_deal_data1, color="green")
axarr[1].set_xlim(0, rounds)
axarr[1].set_title("Current Round:" + str(round))
axarr[0].set_title("Player1")
axarr[2].set_title("Player2")
axarr[0].set_ylabel("Give")
axarr[0].set_xlabel("Accept")
axarr[1].set_ylabel("Average Cash per Deal")
axarr[1].set_xlabel("Round Number")
plt.colorbar(img1, ax=axarr[0], label="Prevalence vs. Uniform")
img2 = axarr[2].imshow(
dota2,
interpolation="nearest",
cmap=plt.cm.ocean,
extent=(0.5, np.shape(dota2)[0] + 0.5, 0.5, np.shape(dota2)[1] + 0.5),
)
axarr[2].plot([center_of_mass2[1]], [center_of_mass2[0]], "or") # adds dot at center of mass
axarr[2].plot([center_of_mass1[1]], [center_of_mass1[0]], "oy") # adds dot for other teams c o m
axarr[2].axis((1, 101, 1, 101))
axarr[1].plot(avg_deal_data2, color="purple")
plt.title("Current Round:" + str(round))
axarr[2].set_ylabel("Give")
axarr[2].set_xlabel("Accept")
plt.colorbar(img2, ax=axarr[2], label="Prevalence vs. Uniform")
plt.draw()
def plot_init(data1, data2):
sns.set_style("dark")
fig = gridspec.GridSpec(2, 2)
axarr = [plt.subplot(fig[0, 0]), plt.subplot2grid((2, 2), (1, 0), colspan=2), plt.subplot(fig[0, 1])]
img1 = axarr[0].imshow(
data1,
interpolation="nearest",
cmap=plt.cm.ocean,
extent=(0.5, np.shape(data1)[0] + 0.5, 0.5, np.shape(data1)[1] + 0.5),
)
plt.title("Current Round:" + str(0))
axarr[0].set_ylabel("Give")
axarr[0].set_xlabel("Accept")
axarr[0].set_title("Distribution of Teams")
axarr[1].plot(avg_deal_data1, color="green")
axarr[1].set_xlim(0, rounds)
axarr[1].set_ylabel("Average Cash per Deal")
axarr[1].set_xlabel("Round Number")
plt.colorbar(img1, ax=axarr[0], label="Prevalence vs. Uniform")
img2 = axarr[2].imshow(
data2,
interpolation="nearest",
cmap=plt.cm.ocean,
extent=(0.5, np.shape(data2)[0] + 0.5, 0.5, np.shape(data2)[1] + 0.5),
)
plt.title("Current Round:" + str(0))
axarr[2].set_ylabel("Give")
axarr[2].set_xlabel("Accept")
axarr[2].set_title("Distribution of Teams")
axarr[1].plot(avg_deal_data2, color="purple")
plt.colorbar(img2, ax=axarr[2], label="Prevalence vs. Uniform")
plt.ion()
mng = plt.get_current_fig_manager()
mng.window.state("zoomed")
plt.show()
return fig, axarr
def test_initial(self):
A, B, C, D = self.make_SISO_mats()
sys = ss(A, B, C, D)
figure(); plot_shape = (1, 3)
#X0=0 : must produce line at 0
subplot2grid(plot_shape, (0, 0))
t, y = initial(sys)
plot(t, y)
#X0=[1,1] : produces a spike
subplot2grid(plot_shape, (0, 1))
t, y = initial(sys, X0=matrix("1; 1"))
plot(t, y)
#Test MIMO system
A, B, C, D = self.make_MIMO_mats()
sys = ss(A, B, C, D)
#X0=[1,1] : produces same spike as above spike
subplot2grid(plot_shape, (0, 2))
t, y = initial(sys, X0=[1, 1, 0, 0])
plot(t, y)
meta_infile = meta_infile[0]
d = pickle.load(open(meta_infile, 'r'))
if 'infile' not in d: # And this gross hack is due to our parametric exploration
# of the hypers above, where we directly generate the .data from the raw source=
orig_processed_data = d
else:
very_original_data = d['infile']
orig_processed_data = pickle.load(open(very_original_data, 'r'))
canonical_neuron_ordering = orig_processed_data['canonical_neuron_ordering']
chains = [c for c in chains if type(c['scores']) != int]
CHAINN = len(chains)
f = pylab.figure(figsize= (12, 8))
ax_z = pylab.subplot2grid((2,2), (0, 0))
ax_score = pylab.subplot2grid((2,2), (0, 1))
###### zmatrix
av = [np.array(d['state']['domains']['d1']['assignment']) for d in chains]
z = irm.util.compute_zmatrix(av)
z_ord = irm.plot.plot_zmatrix(ax_z, z)
### Plot scores
for di, d in enumerate(chains):
subsamp = 4
s = np.array(d['scores'])[::subsamp]
t = np.array(d['times'])[::subsamp] - d['times'][0]
ax_score.plot(t, s, alpha=0.7, c='k')
data_filename = exp['data_filename']
data = pickle.load(open(data_filename))
data_basename, _ = os.path.splitext(data_filename)
meta = pickle.load(open(data_basename + ".meta"))
if 'count_infile' in meta:
meta_infile = meta['count_infile']
else:
meta_infile = meta['infile']
chains = [c for c in chains if type(c['scores']) != int]
CHAINN = len(chains)
f = pylab.figure(figsize= (12, 8))
ax_z = pylab.subplot2grid((2,2), (0, 0))
ax_score = pylab.subplot2grid((2,2), (0, 1))
ax_purity =pylab.subplot2grid((2,2), (1, 0), colspan=2)
### Plot scores
for di, d in enumerate(chains):
subsamp = 4
s = np.array(d['scores'])[::subsamp]
print "Scores=", s
t = np.array(d['times'])[::subsamp] - d['times'][0]
ax_score.plot(t, s, alpha=0.7, c='k')
f.tight_layout()
f.savefig(plot_latent_filename)
def get_app_phot(coords, image, plot_only=False, store=True, wcsin="world", fwhm=2, plotdir=".", box=15):
'''
coords: files:
wcsin: can be "world", "logic"
'''
# Load packages; splot is in the onedspec package, which is in noao.
# The special keyword _doprint=0 turns off displaying the tasks
# when loading a package.
if (not plot_only):
iraf.noao(_doprint=0)
iraf.digiphot(_doprint=0)
iraf.apphot(_doprint=0)
iraf.unlearn("apphot")
imdir = os.path.dirname(image)
imname = os.path.basename(image)
plotdir = os.path.join(imdir, "photometry")
if not os.path.isdir(plotdir):
os.makedirs(plotdir)
out_name = os.path.join(plotdir, imname + ".seq.mag")
clean_name = os.path.join(plotdir, imname + ".app.mag")
# Read values from .ec file
ecfile= image+".ec"
filter_value=''.join(ecfile).split('.',1)[0]
fwhm_value = fwhm
if (fitsutils.has_par(image, 'FWHM')):
fwhm_value = fitsutils.get_par(image, 'FWHM')
if (fitsutils.has_par(image, 'AIRMASS')):
airmass_value = fitsutils.get_par(image, 'AIRMASS')
else:
airmass_value = 1.3
exptime = fitsutils.get_par(image, 'EXPTIME')
gain = fitsutils.get_par(image, 'GAIN')
try:
with open(''.join(ecfile),'r') as f:
for line in f:
if "airmass" in line:
airmass_value = line.split('=',1)[1]
else:
airmass_value = 1
if "FWHM" in line:
print line
fwhm_value = line.split('FWHM=',1)[1]
fwhm_value = fwhm_value.rsplit("aperture")[0]
except:
pass
print "FWHM", fwhm_value
aperture_rad = math.ceil(float(fwhm_value)*2) # Set aperture radius to three times the PSF radius
sky_rad= math.ceil(aperture_rad)*5
print aperture_rad, sky_rad
if (not plot_only):
if os.path.isfile(out_name): os.remove(out_name)
if os.path.isfile(clean_name): os.remove(clean_name)
# Check if files in list, otherwise exit
if not ecfile:
print "No .ec files in directory, exiting"
sys.exit()
iraf.noao.digiphot.apphot.qphot(image = image,\
cbox = box ,\
annulus = sky_rad ,\
dannulus = 15. ,\
aperture = str(aperture_rad),\
coords = coords ,\
output = out_name ,\
plotfile = "" ,\
zmag = 0. ,\
exposure = "exptime" ,\
airmass = "airmass" ,\
filter = "filters" ,\
obstime = "DATE" ,\
epadu = gain ,\
interactive = "no" ,\
radplots = "yes" ,\
verbose = "no" ,\
graphics = "stdgraph" ,\
display = "stdimage" ,\
icommands = "" ,\
wcsin = wcsin,
wcsout = "logical",
gcommands = "")
#iraf.noao.digiphot.apphot.phot(image=image, cbox=5., annulus=12.4, dannulus=10., salgori = "centroid", aperture=9.3,wcsin="world",wcsout="tv", interac = "no", coords=coords, output=out_name)
iraf.txdump(out_name, "id,image,xcenter,ycenter,xshift,yshift,fwhm,msky,stdev,mag,merr", "yes", Stdout=clean_name)
ma = np.genfromtxt(clean_name, comments="#", dtype=[("id","<f4"), ("image","|S20"), ("X","<f4"), ("Y","<f4"), ("Xshift","<f4"), ("Yshift","<f4"),("fwhm","<f4"), ("ph_mag","<f4"), ("stdev","<f4"), ("fit_mag","<f4"), ("fiterr","<f4")])
if (ma.size > 0):
m = ma[~np.isnan(ma["fit_mag"])]
else:
print "Only one object found!"
m = np.array([ma])
hdulist = pf.open(image)
prihdr = hdulist[0].header
img = hdulist[0].data * 1.
nx, ny = img.shape
dimX = int(4)
dimY = int(np.ceil(len(m)*1./4))
outerrad = sky_rad+10
cutrad = outerrad + 15
plt.suptitle("FWHM="+str(fwhm_value))
k = 0
for i in np.arange(dimX):
for j in np.arange(dimY):
if ( k < len(m)):
ax = plt.subplot2grid((dimX,dimY),(i, j))
y1, y2, x1, x2 = m[k]["X"]-cutrad, m[k]["X"]+cutrad, m[k]["Y"]-cutrad, m[k]["Y"]+cutrad
y1, y2, x1, x2 = int(y1), int(y2), int(x1), int(x2)
try:
zmin, zmax = zscale.zscale(img[x1:x2,y1:y2], nsamples=1000, contrast=0.25)
except:
sh= img[x1:x2,y1:y2].shape
if sh[0]>0 and sh[1]>0:
zmin = np.nanmin(img[x1:x2,y1:y2])
zmax = np.nanmax(img[x1:x2,y1:y2])
continue
else:
continue
ax.imshow(img[x1:x2,y1:y2], aspect="equal", extent=(-cutrad, cutrad, -cutrad, cutrad), origin="lower", cmap=matplotlib.cm.gray_r, interpolation="none", vmin=zmin, vmax=zmax)
c1 = plt.Circle( (0, 0), edgecolor="r", facecolor="none", radius=5.)
c2 = plt.Circle( (0, 0), edgecolor="orange", facecolor="none", radius=sky_rad)
c3 = plt.Circle( (0, 0), edgecolor="yellow", facecolor="none", radius=sky_rad+10)
plt.gca().add_artist(c1)
plt.gca().add_artist(c2)
plt.gca().add_artist(c3)
ax.set_xticks([])
ax.set_yticks([])
plt.text(+5, +5, "%d"%m[k]["id"])
plt.text(-cutrad, -cutrad, "%.2f$\pm$%.2f"%(m[k]["fit_mag"], m[k]["fiterr"]), color="b")
k = k+1
plt.savefig(os.path.join(plotdir, imname + "plot.png"))
plt.clf()
def plot_chains_hypers(f, chains, data):
from matplotlib import pylab
CHAINN = len(chains)
RELATIONS = data['relations'].keys()
per_r_hp = {}
per_r_hp_ax = {}
hp_n = 0
for r in RELATIONS:
m = data['relations'][r]['model']
per_r_hp[r] = []
per_r_hp_ax[r] = []
if m == 'BetaBernoulli':
per_r_hp[r].append('alpha')
hp_n +=1
per_r_hp[r].append('beta')
hp_n +=1
elif m == 'BetaBernoulliNonConj':
per_r_hp[r].append('alpha')
hp_n +=1
per_r_hp[r].append('beta')
hp_n +=1
elif m == 'GammaPoisson':
per_r_hp[r].append('alpha')
hp_n +=1
per_r_hp[r].append('beta')
hp_n +=1
elif m == 'LogisticDistance':
for p in ['mu_hp', 'lambda_hp', 'p_min', 'p_max']:
per_r_hp[r].append(p)
hp_n +=1
elif m == 'LogisticDistanceFixedLambda':
for p in ['mu_hp', 'lambda', 'p_min', 'p_scale_alpha_hp', 'p_scale_beta_hp']:
per_r_hp[r].append(p)
hp_n +=1
elif m == 'NormalDistanceFixedWidth':
for p in ['mu_hp', 'p_alpha', 'p_beta', 'p_min', 'width']:
per_r_hp[r].append(p)
hp_n +=1
elif m == 'SquareDistanceBump':
for p in ['mu_hp', 'p_alpha', 'p_beta', 'p_min']:
per_r_hp[r].append(p)
hp_n +=1
elif m == 'ExponentialDistancePoisson':
for p in ['rate_scale_hp', 'mu_hp']:
per_r_hp[r].append(p)
hp_n +=1
elif m == 'LogisticDistancePoisson':
for p in ['rate_scale_hp', 'mu_hp', 'lambda']:
per_r_hp[r].append(p)
hp_n +=1
elif m == 'NormalInverseChiSq':
for p in ['mu', 'kappa', 'nu', 'sigmasq']:
per_r_hp[r].append(p)
hp_n +=1
elif m == 'MixtureModelDistribution':
for p in ['comp_k', 'dir_alpha', 'var_scale']:
per_r_hp[r].append(p)
hp_n +=1
else:
raise RuntimeError("Unknown model'%s'" % m)
pos = 1
for r in RELATIONS:
per_r_hp_ax[r] = []
for hp_name in per_r_hp[r]:
per_r_hp_ax[r].append(pylab.subplot2grid((1+hp_n, 1), (pos, 0)))
pos += 1
ax_crp_alpha = pylab.subplot2grid((1+hp_n, 1), (0, 0))
### Plot scores
for di, d in enumerate(chains):
ki = sorted(d['latents'].keys())
alpha_x_jitter = 0.1
alpha_y_jitter = 1.0
alphas = np.array([d['latents'][k]['domains']['d1']['hps']['alpha'] for k in ki])
y_jitter = np.random.normal(0, alpha_y_jitter, size=len(alphas))
ax_crp_alpha.scatter(ki, alphas + y_jitter, edgecolor='none',
alpha=0.2)
ax_crp_alpha.grid(1)
for ri, rel_name in enumerate(per_r_hp.keys()):
print "rel_name", rel_name
for hp_i, hp_name in enumerate(per_r_hp[rel_name]):
print "hp_name=", hp_name
ax = per_r_hp_ax[rel_name][hp_i]
vals = np.array([d['latents'][k]['relations'][rel_name]['hps'][hp_name] for k in ki])
print vals, ki
min_val = np.min(vals)
max_val = np.max(vals)
range_mid = (min_val + max_val)/2.
range_val = max_val - min_val
#ax.set_ylim(range_mid - range_val,
# range_mid + range_val)
y_jitter = np.random.normal(0, 1, size=len(vals)) * (range_val * 0.05)
ax.scatter(ki, vals + y_jitter, edgecolor='none',
alpha=0.2)
ax.set_ylabel("%s : %s" % (rel_name, hp_name),
fontsize=6)
ax.grid(1)
ax.ticklabel_format(style='plain', axis='y', scilimits=(-8, 8))
for tick in ax.xaxis.get_major_ticks():
tick.label.set_fontsize(6)
for tick in ax.yaxis.get_major_ticks():
tick.label.set_fontsize(6)
def _plot_hdf5_model_horizontal(f, component, output_filename,
vmin=None, vmax=None):
import matplotlib.cm
import matplotlib.pylab as plt
data = xarray.DataArray(
f["data"][component][:], [
("latitude", 90.0 - f["coordinate_0"][:]),
("longitude", f["coordinate_1"][:]),
("radius", f["coordinate_2"][:] / 1000.0)])
plt.style.use('seaborn-pastel')
from lasif.domain import RectangularSphericalSection
domain = RectangularSphericalSection(**dict(f["_meta"]["domain"].attrs))
plt.figure(figsize=(32, 18))
depth_position_map = {
50: (0, 0),
100: (0, 1),
150: (1, 0),
250: (1, 1),
400: (2, 0),
600: (2, 1)
}
for depth, location in depth_position_map.items():
ax = plt.subplot2grid((3, 5), location)
radius = 6371.0 - depth
# set up a map and colourmap
m = domain.plot(ax=ax, resolution="c", skip_map_features=True)
import lasif.colors
my_colormap = lasif.colors.get_colormap(
"tomo_full_scale_linear_lightness")
from lasif import rotations
x, y = np.meshgrid(data.longitude, data.latitude)
x_shape = x.shape
y_shape = y.shape
lat_r, lon_r = rotations.rotate_lat_lon(
y.ravel(), x.ravel(),
domain.rotation_axis,
domain.rotation_angle_in_degree)
x, y = m(lon_r, lat_r)
x.shape = x_shape
y.shape = y_shape
plot_data = data.sel(radius=radius, method="nearest")
plot_data = np.ma.masked_invalid(plot_data.data)
# Overwrite colormap things if given.
if vmin is not None and vmax is not None:
min_val_plot = vmin
max_val_plot = vmax
else:
mean = plot_data.mean()
max_diff = max(abs(mean - plot_data.min()),
abs(plot_data.max() - mean))
min_val_plot = mean - max_diff
max_val_plot = mean + max_diff
# Plotting essentially constant models.
min_delta = 0.001 * abs(max_val_plot)
if (max_val_plot - min_val_plot) < min_delta:
max_val_plot = max_val_plot + min_delta
min_val_plot = min_val_plot - min_delta
# Plot.
im = m.pcolormesh(
x, y, plot_data,
cmap=my_colormap, vmin=min_val_plot, vmax=max_val_plot,
shading="gouraud")
# make a colorbar and title
m.colorbar(im, "right", size="3%", pad='2%')
plt.title(str(depth) + ' km')
# Depth based statistics.
plt.subplot2grid((3, 5), (0, 4), rowspan=3)
plt.title("Depth statistics")
mean = data.mean(axis=(0, 1))
std = data.std(axis=(0, 1))
_min = data.min(axis=(0, 1))
_max = data.max(axis=(0, 1))
plt.fill_betweenx(data.radius, mean - std, mean + std,
label="std", color="#FF3C83")
plt.plot(mean, data.radius, label="mean", color="k", lw=2)
plt.plot(_min, data.radius, color="grey", label="min")
plt.plot(_max, data.radius, color="grey", label="max")
plt.legend(loc="best")
plt.xlabel("Value")
plt.ylabel("Radius")
plt.hlines(data.radius, plt.xlim()[0], plt.xlim()[1], color="0.8",
zorder=-10, linewidth=0.5)
# Roughness plots.
plt.subplot2grid((3, 5), (0, 2))
_d = np.abs(data.diff("latitude", n=1)).sum("latitude").data
plt.title("Roughness in latitude direction, Total: %g" % _d.sum())
plt.pcolormesh(data.longitude.data, data.radius.data,
_d.T, cmap=matplotlib.cm.viridis)
try:
plt.colorbar()
except:
pass
plt.xlabel("Longitude")
plt.ylabel("Radius")
plt.subplot2grid((3, 5), (1, 2))
_d = np.abs(data.diff("longitude", n=1)).sum("longitude").data
plt.title("Roughness in longitude direction. Total: %g" % data.sum())
plt.pcolormesh(data.latitude.data, data.radius.data, _d.T,
cmap=matplotlib.cm.viridis)
try:
plt.colorbar()
except:
pass
plt.xlabel("Latitude")
plt.ylabel("Radius")
plt.subplot2grid((3, 5), (2, 2))
_d = np.abs(data.diff("radius", n=1)).sum("radius").data
plt.title("Roughness in radius direction. Total: %g" % _d.sum())
plt.pcolormesh(data.longitude.data, data.latitude.data,
_d, cmap=matplotlib.cm.viridis)
try:
plt.colorbar()
except:
pass
plt.xlabel("Longitude")
plt.ylabel("Latitude")
# L2
plt.subplot2grid((3, 5), (0, 3))
_d = (data ** 2).sum("latitude").data
plt.title("L2 Norm in latitude direction, Total: %g" % _d.sum())
plt.pcolormesh(data.longitude.data, data.radius.data,
_d.T, cmap=matplotlib.cm.viridis)
try:
plt.colorbar()
except:
pass
plt.xlabel("Longitude")
plt.ylabel("Radius")
plt.subplot2grid((3, 5), (1, 3))
_d = (data ** 2).sum("longitude").data
plt.title("L2 Norm in longitude direction, Total: %g" % _d.sum())
plt.pcolormesh(data.latitude.data, data.radius.data, _d.T,
cmap=matplotlib.cm.viridis)
try:
plt.colorbar()
except:
pass
plt.xlabel("Latitude")
plt.ylabel("Radius")
plt.subplot2grid((3, 5), (2, 3))
_d = (data ** 2).sum("radius").data
plt.title("L2 Norm in radius direction, Total: %g" % _d.sum())
plt.pcolormesh(data.longitude.data, data.latitude.data,
_d, cmap=matplotlib.cm.viridis)
try:
plt.colorbar()
except:
pass
plt.xlabel("Longitude")
plt.ylabel("Latitude")
plt.suptitle("Component %s - File %s" % (component, output_filename),
fontsize=20)
plt.tight_layout(rect=(0, 0, 1, 0.95))
plt.savefig(output_filename, dpi=150)
plt.close()
def plot_pose(data, filename=None, gitsha1=None):
t = pose.get_time_vector(data)
ts = data['timestamp']
dt = (ts - np.roll(ts, 1))[1:] # length is now 1 shorter than data
# convert from system ticks to us
t = t.astype('int') * 1000 * 1000 / 10000
dt = dt.astype('int') * 1000 * 1000 / 10000
rows = round((len(data.dtype.names) + 4) / 2)
cols = 2
names = data.dtype.names
colors = sns.color_palette('husl', len(names))
fig, axes = plt.subplots(rows, cols, sharex=True)
axes = axes.ravel()
base_title = 'bicycle pose'
if filename is not None:
base_title += ' (file \'{}\''.format(filename)
if gitsha1 is not None:
base_title += ', {}'.format(gitsha1)
base_title += ')'
title_size = mpl.rcParams['font.size'] + 2
def set_title_func(f, x):
title = base_title
if x > 0:
title = '{}\ndecimation factor {}'.format(base_title, x)
f.suptitle(title, size=title_size)
# convert angle data from radians to degrees
angle_names = ('pitch', 'yaw', 'roll', 'steer', 'rear_wheel')
data_np = []
for name in names:
if name in angle_names:
data_np.append(data[name] * 180/np.pi)
#elif name == 'timestamp':
# continue
else:
data_np.append(data[name])
print('appending', name, 'to data')
# plot objects to be added later
dd_display = DecimatingDisplay(data_np, t, dt, set_title_func,
None, None, None, None)
full_time_range = (t.min(), t.max()) # start with full range of data
td, datad, dfactor, indices = dd_display.decimate(full_time_range)
set_title_func(fig, dfactor)
lines = []
for n, dd in enumerate(datad):
axes_index = n + 4
name = names[n]
if name in angle_names:
labelname = name + ' [°]'
elif name in ('x', 'y'):
labelname = name + ' [m]'
elif name == 'v':
labelname = name + ' [m/s]'
elif name == 'timestamp':
labelname = name + ' [system ticks @ 10 kHz]'
elif name == 'computation_time':
labelname = name + ' [us]'
else:
labelname = name
print('creating line for', name)
ax = axes[axes_index]
lines.append(ax.plot(td, dd, label=labelname, color=colors[n])[0])
ax.legend()
ax.set_autoscale_on(False)
ax.callbacks.connect('xlim_changed', dd_display.ax_update)
if name == 'y':
ax.invert_yaxis()
# create dt plot
ax = axes[3]
lines.append(ax.plot(t[:-1], dt[indices[:-1]],
label='dt [us]', color=colors[-1])[0])
ax.legend()
ax.set_autoscale_on(False)
ax.callbacks.connect('xlim_changed', dd_display.ax_update)
axes[-1].set_xlabel('time [us]')
axes[-2].set_xlabel('time [us]')
# display trajectory plot
ax = plt.subplot2grid((rows, cols), (0, 0), rowspan=2, sharey=axes[5])
husl100 = mpl.colors.ListedColormap(sns.color_palette('husl', 100))
lc, markers = _plot_trajectory(ax, data['x'][::100], data['y'][::100],
t[::100], xpos='top', yinvert=True,
cmap=husl100)
axes[0] = ax # overwrite original axes
# display histogram of sample time
ax = plt.subplot2grid((rows, cols), (0, 1))
histf = lambda dt: _plot_histogram(
ax, dt, logscale=True, color=colors[-1],
label='loop time [us]\nmax time = {}'.format(dt.max()))
histf(dt)
axes[1] = ax
dd_display.lines = lines
dd_display.lc = lc
dd_display.markers = markers
dd_display.histf = histf
fig._timeseries_display = dd_display
return fig
radial_step=radial_step, clip=clip,
threshold=threshold))
# angular_integration - direct from `linbasex` transform
radial = LIM.radial
speed = LIM.Beta[0]
# normalize to max intensity peak
speed /= speed[200:].max() # exclude transform noise near centerline of image
# PAD - photoelectron angular distribution - direct from `linbasex` transform
beta = LIM.Beta[1]
# plots of the analysis
fig = plt.figure(figsize=(16, 4))
ax1 = plt.subplot2grid((1, 3), (0, 0))
ax2 = plt.subplot2grid((1, 3), (0, 1))
ax3 = plt.subplot2grid((1, 3), (0, 2), sharex=ax2)
# join 1/2 raw data : 1/2 inversion image
inv_IM = LIM.transform
cols = inv_IM.shape[1]
c2 = cols//2 + cols % 2
vmax = IM[:, :c2-100].max()
inv_IM *= vmax/inv_IM[:, c2+100:].max()
JIM = np.concatenate((IM[:, :c2], inv_IM[:, c2:]), axis=1)
# Prettify the plot a little bit:
# Plot the raw data
im1 = ax1.imshow(JIM, origin='lower', aspect='auto', vmin=0, vmax=vmax)
#fig.colorbar(im1, ax=ax1, fraction=.1, shrink=0.9, pad=0.03)
def getdata(*args):
'''if not firsttime:
xlims=ax2.xlim()
ylims=ax2.ylim()'''
#import IR data
# set up some constants
MDB = 'C:\DLOG2\IR\IR' + today + '.mdb'; DRV = '{Microsoft Access Driver (*.mdb)}'; PWD = ''
if os.path.isfile(MDB):
pass
else:
MDB = 'C:\DLOG2\BackupIR\IR' + today + '.mdb'; DRV = '{Microsoft Access Driver (*.mdb)}'; PWD = ''
OESMDB = 'C:\DLOG2\OES\OES' + today + '.mdb'; DRV = '{Microsoft Access Driver (*.mdb)}'; PWD = ''
# connect to db
filefound=False
for i in range(tries):
if os.path.isfile(MDB) and os.path.isfile(OESMDB):
con = pyodbc.connect('DRIVER={};DBQ={};PWD={}'.format(DRV,MDB,PWD))
cur = con.cursor()
filefound=True
else:
if istoday:
print ""
print "Data file not found (takes a few minutes for new data to register)...trying again in 20s..."
time.sleep(20)
if not filefound:
if istoday:
print ""
print "hmm...something is wonky here...it...must be the apocalypse! RUN!"
print ""
time.sleep(1.6)
print "Actually, wait. Double check that the TCO Monitor program is open and you have \"Save Data\" checked, and try again."
print ""
else:
print ""
print "Data file not found. Double check that you entered the date correctly."
print ""
time.sleep(2.5)
print "self destructing in:"
print ""
time.sleep(1)
for k in range(11):
print 10-k
time.sleep(2)
print "BOOM!"
time.sleep(2.7)
try:
input('press enter key to exit')
exit()
except SyntaxError:
exit()
# run a query and get the results
SQL = 'SELECT DT, IR_Reflection_0, IR_Reflection_1, ABSORPTION FROM IRLOG;' # your query goes here
rows = cur.execute(SQL).fetchall()
cur.close()
con.close()
data=numpy.array(rows)
datetimes=data[:,0]
IR_0=data[:,1]
IR_1=data[:,2]
ABSORPTION=data[:,3]
abs_mvgavg=pandas.rolling_mean(ABSORPTION,20)
IRdates = matplotlib.dates.date2num(datetimes)
#import OES data
# connect to db
con = pyodbc.connect('DRIVER={};DBQ={};PWD={}'.format(DRV,OESMDB,PWD))
cur = con.cursor()
# run a query and get the results
SQL = 'SELECT DT, V2, FOS1, FOS2, FOS3, FOS4, FOS5, FOS6, FOS7, FOS8, FOS9, FOS10, FOS11, FOS12 FROM OESLOG;'
rows = cur.execute(SQL).fetchall()
cur.close()
con.close()
data=numpy.array(rows)
datetimes=data[:,0]
OESdates = matplotlib.dates.date2num(datetimes)
Z1A=data[:,2]
Z1B=data[:,3]
Z2A=data[:,4]
Z2B=data[:,5]
Z3A=data[:,6]
Z3B=data[:,7]
Z4A=data[:,8]
Z4B=data[:,9]
Z5A=data[:,10]
Z5B=data[:,11]
Z6A=data[:,12]
Z6B=data[:,13]
In_OES=numpy.empty([len(Z1A)/8,12])
In_OESdates=[]
counter=0
for each in range(len(Z1A)):
if data[each,1]=='In_451':
In_OESdates.append(datetimes[each])
In_OES[counter,0]=Z1A[each]
In_OES[counter,1]=Z1B[each]
In_OES[counter,2]=Z2A[each]
In_OES[counter,3]=Z2B[each]
In_OES[counter,4]=Z3A[each]
In_OES[counter,5]=Z3B[each]
In_OES[counter,6]=Z4A[each]
In_OES[counter,7]=Z4B[each]
In_OES[counter,8]=Z5A[each]
In_OES[counter,9]=Z5B[each]
In_OES[counter,10]=Z6A[each]
In_OES[counter,11]=Z6B[each]
counter+=1
O2_OES=numpy.empty([len(Z1A)/8,12])
counter=0
for each in range(len(Z1A)):
if data[each,1]=='O2_777':
O2_OES[counter,0]=Z1A[each]
O2_OES[counter,1]=Z1B[each]
O2_OES[counter,2]=Z2A[each]
O2_OES[counter,3]=Z2B[each]
O2_OES[counter,4]=Z3A[each]
O2_OES[counter,5]=Z3B[each]
O2_OES[counter,6]=Z4A[each]
O2_OES[counter,7]=Z4B[each]
O2_OES[counter,8]=Z5A[each]
O2_OES[counter,9]=Z5B[each]
O2_OES[counter,10]=Z6A[each]
O2_OES[counter,11]=Z6B[each]
counter+=1
H2_OES=numpy.empty([len(Z1A)/8,12])
counter=0
for each in range(len(Z1A)):
if data[each,1]=='H2_656':
H2_OES[counter,0]=Z1A[each]
H2_OES[counter,1]=Z1B[each]
H2_OES[counter,2]=Z2A[each]
H2_OES[counter,3]=Z2B[each]
H2_OES[counter,4]=Z3A[each]
H2_OES[counter,5]=Z3B[each]
H2_OES[counter,6]=Z4A[each]
H2_OES[counter,7]=Z4B[each]
H2_OES[counter,8]=Z5A[each]
H2_OES[counter,9]=Z5B[each]
H2_OES[counter,10]=Z6A[each]
H2_OES[counter,11]=Z6B[each]
counter+=1
OESdates=matplotlib.dates.date2num(In_OESdates)
ax2 = plt.subplot2grid((4,4), (1,0), colspan=4)
ax1 = plt.subplot2grid((4,4), (0,0), colspan=4, sharex=ax2)
ax4 = plt.subplot2grid((4,4), (2, 2), colspan=2, sharex=ax2)
ax5 = plt.subplot2grid((4,4), (3, 0), colspan=2, sharex=ax2)
ax6 = plt.subplot2grid((4,4), (3, 2), colspan=2, sharex=ax2)
ax3 = plt.subplot2grid((4,4), (2, 0), colspan=2, sharex=ax2)
ax1.plot_date(IRdates, ABSORPTION, color='DarkMagenta')
ax1.set_ylabel('Absorption')
ax1.set_ylim([0,60])
ax1.axhline(45,ls='--',color='Red',linewidth=4)
ax1.plot_date(IRdates, abs_mvgavg,'-', color='Orange', linewidth=4)
ax1.grid()
ax2.grid()
ax3.grid()
ax4.grid()
ax5.grid()
ax6.grid()
#start, end = ax1.get_xlim() #can be used to get axes min and max
ax1.yaxis.set_ticks(numpy.arange(0, 70, 10))
plt.setp(ax1.get_xticklabels(), visible=False)
ax2.plot_date(IRdates, IR_0, color="Blue", label="IR0")#, fmt='-', linewidth=4)
ax2.plot_date(IRdates, IR_1, color="Red", label="IR1")#, fmt='-', linewidth=4)
ax2.set_ylabel('IR reflection')
ax2.set_ylim([0,30])
ax2.yaxis.set_ticks(numpy.arange(0, 30, 10))
legend2 = ax2.legend(bbox_to_anchor=(1.1, -0.45), loc='lower right', borderaxespad=0., shadow=True, labelspacing=0, numpoints=1)
# The frame is matplotlib.patches.Rectangle instance surrounding the legend.
frame2 = legend2.get_frame()
frame2.set_facecolor('0.90')
# Set the fontsize
for label in legend2.get_texts():
label.set_fontsize('25')
ax3.plot_date(OESdates, O2_OES[:,0], color='DarkRed', fmt='-', linewidth=4, label='Z1A')
ax3.plot_date(OESdates, O2_OES[:,1], color='Crimson', fmt='--', linewidth=4, label='Z1B')
ax3.plot_date(OESdates, O2_OES[:,2], color='OrangeRed', fmt='-', linewidth=4, label='Z2A')
ax3.plot_date(OESdates, O2_OES[:,3], color='DarkOrange', fmt='--', linewidth=4, label='Z2B')
ax3.plot_date(OESdates, O2_OES[:,4], color='cadetblue', fmt='-', linewidth=4, label='Z3A')
ax3.plot_date(OESdates, O2_OES[:,5], color='chartreuse', fmt='--', linewidth=4, label='Z3B')
ax3.plot_date(OESdates, O2_OES[:,6], color='DarkGreen', fmt='-', linewidth=4, label='Z4A')
ax3.plot_date(OESdates, O2_OES[:,7], color='ForestGreen', fmt='--', linewidth=4, label='Z4B')
ax3.plot_date(OESdates, O2_OES[:,8], color='Navy', fmt='-', linewidth=4, label='Z5A')
ax3.plot_date(OESdates, O2_OES[:,9], color='Blue', fmt='--', linewidth=4, label='Z5B')
ax3.plot_date(OESdates, O2_OES[:,10], color='Purple', fmt='-', linewidth=4, label='Z6A')
ax3.plot_date(OESdates, O2_OES[:,11], color='MediumPurple', fmt='--', linewidth=4, label='Z6B')
ax3.yaxis.set_ticks(numpy.arange(0, 10, 2))
ax3.set_ylabel('O2 OES')
legend = ax3.legend(bbox_to_anchor=(2.3, 0.65), loc='upper right', borderaxespad=0., shadow=True, labelspacing=0, numpoints=1)
# The frame is matplotlib.patches.Rectangle instance surrounding the legend.
frame = legend.get_frame()
frame.set_facecolor('0.90')
# Set the fontsize
for label in legend.get_texts():
label.set_fontsize('25')
#ax4.plot_date(OESdates, In_OES[:,0], color='DarkRed', fmt='-', linewidth=4, label='Z1A')
#ax4.plot_date(OESdates, In_OES[:,1], color='Crimson', fmt='--', linewidth=4, label='Z1B')
#ax4.plot_date(OESdates, In_OES[:,2], color='OrangeRed', fmt='-', linewidth=4, label='Z2A')
#ax4.plot_date(OESdates, In_OES[:,3], color='DarkOrange', fmt='--', linewidth=4, label='Z2B')
#ax4.plot_date(OESdates, In_OES[:,4], color='cadetblue', fmt='-', linewidth=4, label='Z3A')
#ax4.plot_date(OESdates, In_OES[:,5], color='chartreuse', fmt='--', linewidth=4, label='Z3B')
ax4.plot_date(OESdates, In_OES[:,6], color='DarkGreen', fmt='-', linewidth=4, label='Z4A')
ax4.plot_date(OESdates, In_OES[:,7], color='ForestGreen', fmt='--', linewidth=4, label='Z4B')
ax4.plot_date(OESdates, In_OES[:,8], color='Navy', fmt='-', linewidth=4, label='Z5A')
ax4.plot_date(OESdates, In_OES[:,9], color='Blue', fmt='--', linewidth=4, label='Z5B')
ax4.plot_date(OESdates, In_OES[:,10], color='Purple', fmt='-', linewidth=4, label='Z6A')
ax4.plot_date(OESdates, In_OES[:,11], color='MediumPurple', fmt='--', linewidth=4, label='Z6B')
ax4.yaxis.set_ticks(numpy.arange(0, 100, 20))
ax4.set_ylabel('In OES')
ax5.plot_date(OESdates, H2_OES[:,0], color='DarkRed', fmt='-', linewidth=4, label='Z1A')
ax5.plot_date(OESdates, H2_OES[:,1], color='Crimson', fmt='-', linewidth=4, label='Z1B')
ax5.plot_date(OESdates, H2_OES[:,2], color='OrangeRed', fmt='-', linewidth=4, label='Z2A')
ax5.plot_date(OESdates, H2_OES[:,3], color='DarkOrange', fmt='-', linewidth=4, label='Z2B')
ax5.plot_date(OESdates, H2_OES[:,4], color='cadetblue', fmt='-', linewidth=4, label='Z3A')
ax5.plot_date(OESdates, H2_OES[:,5], color='chartreuse', fmt='--', linewidth=4, label='Z3B')
ax5.plot_date(OESdates, H2_OES[:,6], color='DarkGreen', fmt='-', linewidth=4, label='Z4A')
ax5.plot_date(OESdates, H2_OES[:,7], color='ForestGreen', fmt='-', linewidth=4, label='Z4B')
ax5.plot_date(OESdates, H2_OES[:,8], color='Navy', fmt='-', linewidth=4, label='Z5A')
ax5.plot_date(OESdates, H2_OES[:,9], color='Blue', fmt='-', linewidth=4, label='Z5B')
ax5.plot_date(OESdates, H2_OES[:,10], color='Purple', fmt='-', linewidth=4, label='Z6A')
ax5.plot_date(OESdates, H2_OES[:,11], color='MediumPurple', fmt='-', linewidth=4, label='Z6B')
ax5.yaxis.set_ticks(numpy.arange(0, 18, 2))
ax5.set_ylabel('H2 OES')
#ax6.plot_date(OESdates, In_OES[:,0]/O2_OES[:,0], color='DarkRed', fmt='-', linewidth=4, label='Z1A')
#ax6.plot_date(OESdates, In_OES[:,1]/O2_OES[:,1], color='Crimson', fmt='--', linewidth=4, label='Z1B')
#ax6.plot_date(OESdates, In_OES[:,2]/O2_OES[:,2], color='OrangeRed', fmt='-', linewidth=4, label='Z2A')
#ax6.plot_date(OESdates, In_OES[:,3]/O2_OES[:,3], color='DarkOrange', fmt='--', linewidth=4, label='Z2B')
#ax6.plot_date(OESdates, In_OES[:,4]/O2_OES[:,4], color='cadetblue', fmt='-', linewidth=4, label='Z3A')
#ax6.plot_date(OESdates, In_OES[:,5]/O2_OES[:,5], color='chartreuse', fmt='--', linewidth=4, label='Z3B')
ax6.plot_date(OESdates, In_OES[:,6]/O2_OES[:,6], color='DarkGreen', fmt='-', linewidth=4, label='Z4A')
ax6.plot_date(OESdates, In_OES[:,7]/O2_OES[:,7], color='ForestGreen', fmt='--', linewidth=4, label='Z4B')
ax6.plot_date(OESdates, In_OES[:,8]/O2_OES[:,8], color='Navy', fmt='-', linewidth=4, label='Z5A')
ax6.plot_date(OESdates, In_OES[:,9]/O2_OES[:,9], color='Blue', fmt='--', linewidth=4, label='Z5B')
ax6.plot_date(OESdates, In_OES[:,10]/O2_OES[:,10], color='Purple', fmt='-', linewidth=4, label='Z6A')
ax6.plot_date(OESdates, In_OES[:,11]/O2_OES[:,11], color='MediumPurple', fmt='--', linewidth=4, label='Z6B')
ax6.set_ylabel('In:O2 OES')
ax6.set_ylim([0,40])
ax6.yaxis.set_ticks(numpy.arange(0, 50, 10))
ax2.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
ax3.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
plt.setp(ax3.get_xticklabels(), visible=False)
plt.setp(ax4.get_xticklabels(), visible=False)
ax5.set_xlabel('time')
ax6.set_xlabel('time')
'''if not firsttime:
p.show()
# Encode the filter output v=u*h with an IAF neuron
# -------------------------------------------------
# Specify parameters of the Ideal IAF neuron
delta = 0.007 # set the threshold
bias = 0.28 # set the bias
kappa = 1. # set capacitance
# # Encode the filter output
spk_train, vol_trace = cim.iaf_encode(dt, t_proper, v_proper, b=bias, d=delta, C=kappa)
run_time('Initialization time:',tic_init) # display the initialization time
# Plot the voltage trace and the associated spike train
p.figure(4)
ax1 = p.subplot2grid((7, 1), (0, 0),rowspan=5,xlim=(0., 1.0),
ylabel='Amplitude', ylim=(min(vol_trace), delta*1.1),
title='Output of the [Filter]-[Ideal IAF] neural circuit')
p.setp(ax1.get_xticklabels(), visible=False)
ax2 = p.subplot2grid((7, 1), (5, 0),rowspan=2,sharex=ax1,
xlabel='Time, [s]', ylim=(0., 1.1),xlim=(0., 1.0),
yticks = (),yticklabels = ())
ax1.plot(t_proper-t_proper[0],vol_trace,'b-',
label='Membrane voltage $v\qquad$')
ax1.plot((0, t_proper[-1]-t_proper[0]),(delta,delta),'--r',
label='Threshold $\delta=' + repr(delta) + '$')
ax1.plot(spk_train-t_proper[0],delta*np.ones_like(spk_train),'ro',
label= '$v(t)=\delta$')
ax1.legend(loc='lower right')
ax2.stem(spk_train-t_proper[0],np.ones_like(spk_train),
linefmt='k-', markerfmt='k^', label='$(t_k)_{k\in Z}$')
ax2.legend(loc='lower right')
grid_i = flex.int(flex.grid(grid.all()))
for i, g in enumerate(grid):
grid_i[i] = int(g)
mask_normal = discriminate_normal(grid_i)
mask_poisson = discriminate_poisson(grid_i)
normal_pixels = flex.select(grid, flags=(mask_normal == 1))
poisson_pixels = flex.select(grid, flags=(mask_poisson == 1))
all_pixels = list(grid)
line = grid.as_numpy_array()[15,:]
from matplotlib import pylab
pylab.subplot2grid((3, 3), (0, 0))
pylab.hist(all_pixels, bins=20)
pylab.subplot2grid((3, 3), (0, 1))
pylab.hist(normal_pixels, bins=20)
pylab.subplot2grid((3, 3), (0, 2))
pylab.hist(poisson_pixels, bins=20)
pylab.subplot2grid((3, 3), (1, 0), colspan=3)
pylab.plot(line)
pylab.subplot2grid((3, 3), (2, 0))
pylab.imshow(grid.as_numpy_array(), interpolation='none')
pylab.subplot2grid((3, 3), (2, 1))
pylab.imshow(mask_normal.as_numpy_array(), interpolation='none')
pylab.subplot2grid((3, 3), (2, 2))
pylab.imshow(mask_poisson.as_numpy_array(), interpolation='none')
pylab.show()
plt.plot(d.extra['scores'], label='Scores')
plt.twinx()
plt.plot(d.extra['counts'], label='Counts')
plt.legend(fontsize='xx-small', framealpha=0.2)
plt.savefig(os.path.join(feature_dir, 'scores-and-counts.png'))
plt.close()
parts_dir = os.path.join(feature_dir, 'parts')
os.mkdir(parts_dir)
originals = d.extra.get('originals')
for pi in xrange(d.num_features):
#plt.clf()
f = plt.figure()
# Look inside view_bkg_stack.py for code to go here.
plt.subplot2grid((7,10), (0, 0), colspan=4, rowspan=4).set_axis_off()
plt.imshow(d.visparts[pi], interpolation='nearest', cmap=plt.cm.gray)
for i in xrange(4):
plt.subplot2grid((7,10), (2* (i//2), 6+(i%2)*2), colspan=2, rowspan=2).set_axis_off()
plt.imshow(d.parts[pi,...,i], interpolation='nearest', vmin=0, vmax=1)
plt.title(EDGE_TITLES[i])
#if i == 3:
if False and originals:
for i in xrange(min(20, len(originals))):
plt.subplot2grid((7,10), (5+i//10, i%10)).set_axis_off()
plt.imshow(originals[pi][i], interpolation='nearest', vmin=0, vmax=1, cmap=plt.cm.gray)
if i == 4:
plt.title('Original background parts')
bins=[0,0,0,0,0]
for m in range(0,len(mags)):
if ((mags[m] >= 4) and (mags[m] < 5)):
bins[0] += 1
elif ((mags[m] >= 5) and (mags[m] < 6)):
bins[1] += 1
elif ((mags[m] >= 6) and (mags[m] < 7)):
bins[2] += 1
elif ((mags[m] >= 7) and (mags[m] < 8)):
bins[3] += 1
elif (mags[m] >=8):
bins[4] += 1
print(bins)
ax1 = plt.subplot2grid((1, 10), (0, 0), colspan=7)
ax1.axhline(4, linewidth=.3, color='k')
ax1.axhline(5, linewidth=.3, color='k')
ax1.axhline(6, linewidth=.3, color='k')
ax1.axhline(7, linewidth=.3, color='k')
ax1.axhline(8, linewidth=.3, color='k')
ax1.scatter(dist_deg, mags, s=0.3, c='k', edgecolor='k')
ax1.set_xlabel(u'epicentral distance [°]', fontsize=11, labelpad=3)
ax1.set_ylabel('moment magnitude', fontsize=11)
ax1.set_xlim(-40,180)
ax1.set_ylim(3,9.2)
ax1.set_yticks([4,5,6,7,8,9])
ax1.set_xticks([0,30,60,90,120,150])
ax1.text(s='# events', x=-35, y=9.0, fontsize=9)
ax1.text(s=str(bins[0]), x=-35, y=4.35, fontsize=9)
ax1.text(s=str(bins[1]), x=-35, y=5.35, fontsize=9)
def test_lsim(self):
A, B, C, D = self.make_SISO_mats()
sys = ss(A, B, C, D)
figure(); plot_shape = (2, 2)
#Test with arrays
subplot2grid(plot_shape, (0, 0))
t = linspace(0, 1, 100)
u = r_[1:1:50j, 0:0:50j]
y, _t, _x = lsim(sys, u, t)
plot(t, y, label='y')
plot(t, u/10, label='u/10')
legend(loc='best')
#Test with U=None - uses 2nd algorithm which is much faster.
subplot2grid(plot_shape, (0, 1))
t = linspace(0, 1, 100)
x0 = [-1, -1]
y, _t, _x = lsim(sys, U=None, T=t, X0=x0)
plot(t, y, label='y')
legend(loc='best')
#Test with U=0, X0=0
#Correct reaction to zero dimensional special values
subplot2grid(plot_shape, (0, 1))
t = linspace(0, 1, 100)
y, _t, _x = lsim(sys, U=0, T=t, X0=0)
plot(t, y, label='y')
legend(loc='best')
#Test with matrices
subplot2grid(plot_shape, (1, 0))
t = matrix(linspace(0, 1, 100))
u = matrix(r_[1:1:50j, 0:0:50j])
x0 = matrix("0.; 0")
y, t_out, _x = lsim(sys, u, t, x0)
plot(t_out, y, label='y')
plot(t_out, asarray(u/10)[0], label='u/10')
legend(loc='best')
#Test with MIMO system
subplot2grid(plot_shape, (1, 1))
A, B, C, D = self.make_MIMO_mats()
sys = ss(A, B, C, D)
t = matrix(linspace(0, 1, 100))
u = array([r_[1:1:50j, 0:0:50j],
r_[0:1:50j, 0:0:50j]])
x0 = [0, 0, 0, 0]
y, t_out, _x = lsim(sys, u, t, x0)
plot(t_out, y[0], label='y[0]')
plot(t_out, y[1], label='y[1]')
plot(t_out, u[0]/10, label='u[0]/10')
plot(t_out, u[1]/10, label='u[1]/10')
legend(loc='best')
#Test with wrong values for t
#T is None; - special handling: Value error
self.assertRaises(ValueError, lsim(sys, U=0, T=None, x0=0))
#T="hello" : Wrong type
#TODO: better wording of error messages of ``lsim`` and
# ``_check_convert_array``, when wrong type is given.
# Current error message is too cryptic.
self.assertRaises(TypeError, lsim(sys, U=0, T="hello", x0=0))
#T=0; - T can not be zero dimensional, it determines the size of the
# input vector ``U``
self.assertRaises(ValueError, lsim(sys, U=0, T=0, x0=0))
#T is not monotonically increasing
self.assertRaises(ValueError, lsim(sys, U=0, T=[0., 1., 2., 2., 3.], x0=0))