def get_X_y(fname, unit_num=0):
varlist = ['M', 'FX', 'FY', 'TH']
blk = neoUtils.get_blk(fname)
cbool = neoUtils.get_Cbool(blk)
X = GLM.create_design_matrix(blk, varlist)
Xdot, Xsmooth = GLM.get_deriv(blk, blk, varlist, [0, 5, 9])
X = np.concatenate([X, Xdot], axis=1)
X = neoUtils.replace_NaNs(X, 'pchip')
X = neoUtils.replace_NaNs(X, 'interp')
scaler = sklearn.preprocessing.StandardScaler(with_mean=False)
X = scaler.fit_transform(X)
y = neoUtils.get_rate_b(blk, unit_num)[1][:, np.newaxis]
yhat = np.zeros_like(y)
return (X, y, cbool)
def get_PS_given_R(blk, unit_num=0):
if True:
raise Exception('This doesnt work yet')
CP = neoUtils.get_var(blk, 'CP')
S = float(blk.annotations['s'][2:-1])
CP /= S
FR = neoUtils.get_rate_b(blk, unit_num=unit_num, sigma=2 * pq.ms)[1]
spiked = np.logical_and(np.all(np.isfinite(CP), axis=1), FR)
idx = np.all(np.isfinite(CP), axis=1)
PR_S, edges = np.histogramdd(CP.magnitude[spiked, :], bins=50)
PS, edges = np.histogramdd(CP.magnitude[idx, :], bins=50)
return (post)
def smoothed_best():
df = pd.read_csv(min_entropy, index_col='id')
smooth_vals = np.arange(5, 100, 10).tolist()
best_smooth = df.mode(axis=1)[0]
best_idx = [smooth_vals.index(x) for x in best_smooth]
best_idx = pd.DataFrame({'idx': best_idx}, index=best_smooth.index)
for f in glob.glob(os.path.join(p_load, '*NEO.h5')):
try:
blk = neoUtils.get_blk(f)
blk_smooth = GLM.get_blk_smooth(f, p_smooth)
num_units = len(blk.channel_indexes[-1].units)
for unit_num in range(num_units):
varlist = ['M', 'F', 'TH', 'PHIE']
root = neoUtils.get_root(blk, unit_num)
print('Working on {}'.format(root))
if root not in best_idx.index:
print('{} not found in best smoothing derivative data'.
format(root))
continue
outname = os.path.join(
p_save,
'best_smoothing_deriv\\{}_best_smooth_pillowX.mat'.format(
root))
X = GLM.create_design_matrix(blk, varlist)
smoothing_to_use = best_idx.loc[root][0]
Xdot = GLM.get_deriv(blk,
blk_smooth,
varlist,
smoothing=[smoothing_to_use])[0]
X = np.concatenate([X, Xdot], axis=1)
y = neoUtils.get_rate_b(blk, unit_num)[1]
cbool = neoUtils.get_Cbool(blk)
arclengths = get_arclength_bool(blk, unit_num)
sio.savemat(
outname, {
'X': X,
'y': y,
'cbool': cbool,
'smooth': best_smooth.loc[root],
'arclengths': arclengths
})
except Exception as ex:
print('Problem with {}:{}'.format(os.path.basename(f), ex))
def get_X_y(fname, p_smooth, unit_num, pca_tgl=False, n_pcs=3):
varlist = ['M', 'F', 'TH', 'PHIE']
blk = neoUtils.get_blk(fname)
blk_smooth = get_blk_smooth(fname, p_smooth)
cbool = neoUtils.get_Cbool(blk)
X = GLM.create_design_matrix(blk, varlist)
Xdot, Xsmooth = GLM.get_deriv(blk, blk_smooth, varlist, [0, 5, 9])
# if using the PCA decomposition of the inputs:
if pca_tgl:
X = neoUtils.replace_NaNs(X, 'pchip')
X = neoUtils.replace_NaNs(X, 'interp')
Xsmooth = neoUtils.replace_NaNs(Xsmooth, 'pchip')
Xsmooth = neoUtils.replace_NaNs(Xsmooth, 'interp')
scaler = sklearn.preprocessing.StandardScaler(with_mean=False)
X = scaler.fit_transform(X)
scaler = sklearn.preprocessing.StandardScaler(with_mean=False)
Xsmooth = scaler.fit_transform(Xsmooth)
pca = sklearn.decomposition.PCA()
X_pc = pca.fit_transform(X)[:, :n_pcs]
pca = sklearn.decomposition.PCA()
Xs_pc = pca.fit_transform(Xsmooth)[:, :n_pcs]
zero_pad = np.zeros([1, n_pcs])
Xd_pc = np.diff(np.concatenate([zero_pad, Xs_pc], axis=0), axis=0)
X = np.concatenate([X_pc, Xd_pc], axis=1)
scaler = sklearn.preprocessing.StandardScaler(with_mean=False)
X = scaler.fit_transform(X)
else:
X = np.concatenate([X, Xdot], axis=1)
X = neoUtils.replace_NaNs(X, 'pchip')
X = neoUtils.replace_NaNs(X, 'interp')
scaler = sklearn.preprocessing.StandardScaler(with_mean=False)
X = scaler.fit_transform(X)
y = neoUtils.get_rate_b(blk, unit_num)[1][:, np.newaxis]
# Xc = X[cbool,:]
# yc = y[cbool]
yhat = np.zeros_like(y)
return (X, y, cbool)
def get_X_y(fname,p_smooth,unit_num=0):
varlist = ['M', 'F', 'TH', 'PHIE']
blk = neoUtils.get_blk(fname)
blk_smooth = GLM.get_blk_smooth(fname,p_smooth)
cbool = neoUtils.get_Cbool(blk)
X = GLM.create_design_matrix(blk,varlist)
Xdot,Xsmooth = GLM.get_deriv(blk,blk_smooth,varlist,[9])
X = np.concatenate([X,Xdot],axis=1)
X = neoUtils.replace_NaNs(X,'pchip')
X = neoUtils.replace_NaNs(X,'interp')
scaler = sklearn.preprocessing.StandardScaler(with_mean=False)
X = scaler.fit_transform(X)
y = neoUtils.get_rate_b(blk,unit_num)[1][:,np.newaxis]
y[np.invert(cbool)]=0
return(X,y,cbool)
def MB_curve(blk,unit_num,save_tgl=False,im_ext='svg',dpi_res=300):
root = neoUtils.get_root(blk, unit_num)
M = neoUtils.get_var(blk)
use_flags = neoUtils.get_Cbool(blk)
MB = mechanics.get_MB_MD(M)[0].magnitude.ravel()
MB[np.invert(use_flags)]=0
sp = neoUtils.concatenate_sp(blk)['cell_{}'.format(unit_num)]
r, b = neoUtils.get_rate_b(blk, unit_num, sigma=5 * pq.ms)
MB_bayes,edges = varTuning.stim_response_hist(MB*1e6,r,use_flags,nbins=100,min_obs=5)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(edges[:-1],MB_bayes,'o',color='k')
ax.set_ylabel('Spike Rate (sp/s)')
ax.set_xlabel('Bending Moment ($\mu$N-m)')
plt.tight_layout()
if save_tgl:
plt.savefig('./figs/{}_MB_tuning.{}'.format(root,im_ext),dpi=dpi_res)
plt.close('all')
def smoothed_mechanics():
"""
use this function to grab the data from the smoothed mechanics and the
derivative of the same
"""
f_arclength = '/projects/p30144/_VG3D/deflections/direction_arclength_FR_group_data.csv'
f_list = glob.glob(os.path.join(p_load, '*NEO.h5'))
f_list.sort()
for f in f_list:
try:
blk = neoUtils.get_blk(f)
blk_smooth = GLM.get_blk_smooth(f, p_smooth)
num_units = len(blk.channel_indexes[-1].units)
for unit_num in range(num_units):
varlist = ['M', 'F', 'TH', 'PHIE']
root = neoUtils.get_root(blk, unit_num)
print('Working on {}'.format(root))
outname = os.path.join(p_save,
'{}_smooth_mechanicsX.mat'.format(root))
Xdot, X = GLM.get_deriv(blk,
blk_smooth,
varlist,
smoothing=[5])
X = np.concatenate([X, Xdot], axis=1)
y = neoUtils.get_rate_b(blk, unit_num)[1]
cbool = neoUtils.get_Cbool(blk)
arclengths = get_arclength_bool(blk,
unit_num,
fname=f_arclength)
sio.savemat(
outname, {
'X': X,
'y': y,
'cbool': cbool,
'smooth': 55,
'arclengths': arclengths
})
except Exception as ex:
print('Problem with {}:{}'.format(os.path.basename(f), ex))
def FX_plots(blk,unit_num,save_tgl=False,im_ext='svg',dpi_res=300):
root = neoUtils.get_root(blk, unit_num)
F = neoUtils.get_var(blk,'F')
Fx = F.magnitude[:,0]
use_flags = neoUtils.get_Cbool(blk)
sp = neoUtils.concatenate_sp(blk)['cell_{}'.format(unit_num)]
r, b = neoUtils.get_rate_b(blk, unit_num, sigma=5 * pq.ms)
Fx[np.invert(use_flags)] = 0
Fx_bayes, edges = varTuning.stim_response_hist(Fx * 1e6, r, use_flags, nbins=50, min_obs=5)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(edges[:-1], Fx_bayes*1000, 'o', color='k')
ax.set_ylabel('Spike Rate (sp/s)')
ax.set_xlabel('Axial Force ($\mu$N-m)')
plt.tight_layout()
if save_tgl:
plt.savefig('./figs/{}_Fx_tuning.{}'.format(root,im_ext), dpi=dpi_res)
plt.close('all')
def ent_analyses(blk, X_disc=128, Y_disc=64):
CP = neoUtils.get_var(blk, 'CP')
S = float(blk.annotations['s'][2:-1])
CP /= S
CP = CP.magnitude
idx = np.all(np.isfinite(CP), axis=1)
s = np.empty_like(CP)
s[:] = np.nan
s[idx, :] = pye.quantise(CP[idx, :], X_disc, uniform='bins')[0]
FR = neoUtils.get_rate_b(blk, unit_num=unit_num, sigma=2 * pq.ms)[0]
FR = pye.quantise(FR, Y_disc, uniform='bins')[0]
idx = np.all(np.isfinite(s), axis=1)
X = s.astype('int64').T[:, idx]
Y = FR[np.newaxis, idx]
DS = pye.DiscreteSystem(X, (X.shape[0], bins), Y, (1, bins))
DS.calculate_entropies()
#TODO: I have created a discrete FR and Stimulus, now I need to perform the actual entropy calcs
if True:
raise Exception('This is not done')
def smoothed(smooth_idx=9):
smooth_vals = np.arange(5, 100, 10)
sub_p_save = os.path.join(
p_save, '{}ms_smoothing_deriv'.format(smooth_vals[smooth_idx]))
if not os.path.isdir(sub_p_save):
os.mkdir(sub_p_save)
for f in glob.glob(os.path.join(p_load, '*NEO.h5')):
try:
blk = neoUtils.get_blk(f)
blk_smooth = GLM.get_blk_smooth(f, p_smooth)
num_units = len(blk.channel_indexes[-1].units)
for unit_num in range(num_units):
varlist = ['M', 'F', 'TH', 'PHIE']
root = neoUtils.get_root(blk, unit_num)
print('Working on {}'.format(root))
outname = os.path.join(
sub_p_save,
'{}ms_{}_pillowX.mat'.format(smooth_vals[smooth_idx],
root))
X = GLM.create_design_matrix(blk, varlist)
Xdot = GLM.get_deriv(blk, blk_smooth, varlist, [smooth_idx])[0]
X = np.concatenate([X, Xdot], axis=1)
sp = neoUtils.concatenate_sp(blk)['cell_{}'.format(unit_num)]
y = neoUtils.get_rate_b(blk, unit_num)[1]
cbool = neoUtils.get_Cbool(blk)
arclengths = get_arclength_bool(blk, unit_num)
sio.savemat(outname, {
'X': X,
'y': y,
'cbool': cbool,
'arclengths': arclengths
})
except Exception as ex:
print('Problem with {}:{}'.format(os.path.basename(f), ex))
def phase_plots(blk,unit_num,save_tgl=False,bin_stretch=False,p_save=None,im_ext='png',dpi_res=300):
''' Plot Phase planes for My and Mz'''
root = neoUtils.get_root(blk, unit_num)
M = neoUtils.get_var(blk).magnitude
sp = neoUtils.concatenate_sp(blk)['cell_{}'.format(unit_num)]
r, b = neoUtils.get_rate_b(blk, unit_num, sigma=5 * pq.ms)
use_flags = neoUtils.get_Cbool(blk)
Mdot = mechanics.get_deriv(M)
if bin_stretch:
raise Exception('Not finished with use_flags')
# MY, logit_y = nl(M[idx, 1], 90)
# MZ, logit_z = nl(M[idx, 2], 90)
# MY_dot, logit_ydot = nl(Mdot[idx, 1], 95)
# MZ_dot, logit_zdot = nl(Mdot[idx, 2], 95)
else:
MY = M[:, 1] * 1e-6
MZ = M[:, 2] * 1e-6
MY_dot = Mdot[:, 1] * 1e-6
MZ_dot = Mdot[:, 2] * 1e-6
My_response,My_edges,Mydot_edges = varTuning.joint_response_hist(MY, MY_dot, r, use_flags, [100,30],min_obs=15)
Mz_response,Mz_edges,Mzdot_edges = varTuning.joint_response_hist(MZ, MZ_dot, r, use_flags, [100,30],min_obs=15)
if bin_stretch:
My_edges = logit_y(My_edges)
Mz_edges = logit_z(Mz_edges)
Mydot_edges = logit_ydot(Mydot_edges)
Mzdot_edges = logit_zdot(Mzdot_edges)
else:
pass
axy = varTuning.plot_joint_response(My_response,My_edges,Mydot_edges,contour=False)
axz = varTuning.plot_joint_response(Mz_response,Mz_edges,Mzdot_edges,contour=False)
# Set bounds
y_mask = My_response.mask.__invert__()
if not y_mask.all():
axy.set_ylim(Mydot_edges[np.where(y_mask)[0].min()], Mydot_edges[np.where(y_mask)[0].max()])
axy.set_xlim(My_edges[np.where(y_mask)[1].min()], My_edges[np.where(y_mask)[1].max()])
z_mask = Mz_response.mask.__invert__()
if not z_mask.all():
axz.set_ylim(Mzdot_edges[np.where(z_mask)[0].min()], Mzdot_edges[np.where(z_mask)[0].max()])
axz.set_xlim(Mz_edges[np.where(z_mask)[1].min()], Mz_edges[np.where(z_mask)[1].max()])
# other annotations
axy.set_title('M$_y$ Phase Plane')
axz.set_title('M$_z$ Phase Plane')
axy.set_xlabel('M$_y$ ($\mu$N-m)')
axy.set_ylabel('M$_\dot{y}$ ($\mu$N-m/ms)')
axz.set_xlabel('M$_z$ ($\mu$N-m)')
axz.set_ylabel('M$_\dot{z}$ ($\mu$N-m/ms)')
axy.grid('off')
axy.set_facecolor([0.6, 0.6, 0.6])
axy.axvline(color='k',linewidth=1)
axy.axhline(color='k',linewidth=1)
axz.grid('off')
axz.set_facecolor([0.6, 0.6, 0.6])
axz.axvline(color='k', linewidth=1)
axz.axhline(color='k', linewidth=1)
plt.sca(axy)
plt.tight_layout()
if save_tgl:
if p_save is None:
raise ValueError("figure save location is required")
else:
plt.savefig(os.path.join(p_save,'{}_My_phaseplane.{}'.format(root,im_ext)),dpi=dpi_res)
plt.sca(axz)
plt.tight_layout()
if save_tgl:
if p_save is None:
raise ValueError("figure save location is required")
else:
plt.savefig(os.path.join(p_save,'{}_Mz_phaseplane.{}'.format(root,im_ext)),dpi=dpi_res)
plt.close('all')
def calc_world_geom_hist(p_load,p_save,n_bins=100):
"""
Since calculation takes so long on getting the histograms (mostly loading of data)
we want to calculate them once and save the data.
This calculates the Geometry.
:param p_load: Location where all the neo h5 files live
:param p_save: Location to save the output data files
:param n_bins: Number of bins in with which to split the data
:return None: Saves a 'world_geom_hists.npz' file.
"""
# init
ID = []
all_S_bayes = []
all_TH_bayes = []
all_PHIE_bayes = []
all_ZETA_bayes = []
all_S_edges = []
all_TH_edges = []
all_PHIE_edges = []
all_ZETA_edges = []
# loop files
for f in glob.glob(os.path.join(p_load,'rat*.h5')):
# load in
print(os.path.basename(f))
blk = neoUtils.get_blk(f)
# get contact
Cbool = neoUtils.get_Cbool(blk)
use_flags = neoUtils.concatenate_epochs(blk)
# get vars
S = neoUtils.get_var(blk, 'S').magnitude
TH = neoUtils.get_var(blk, 'TH').magnitude
neoUtils.center_var(TH, use_flags)
PHIE = neoUtils.get_var(blk, 'PHIE').magnitude
neoUtils.center_var(PHIE, use_flags)
ZETA = neoUtils.get_var(blk, 'ZETA').magnitude
neoUtils.center_var(ZETA, use_flags)
# loop units
for unit in blk.channel_indexes[-1].units:
# get unit info
unit_num = int(unit.name[-1])
r, b = neoUtils.get_rate_b(blk, unit_num, sigma=5 * pq.ms)
sp = neoUtils.concatenate_sp(blk)['cell_{}'.format(unit_num)]
root = neoUtils.get_root(blk,unit_num)
ID.append(root)
# Create hists
S_bayes, S_edges = varTuning.stim_response_hist(S.ravel(), r, Cbool, nbins=n_bins, min_obs=5)
TH_bayes, TH_edges = varTuning.stim_response_hist(TH.ravel(), r, Cbool, nbins=n_bins, min_obs=5)
PHIE_bayes, PHIE_edges = varTuning.stim_response_hist(PHIE.ravel(), r, Cbool, nbins=n_bins,min_obs=5)
ZETA_bayes, ZETA_edges = varTuning.stim_response_hist(ZETA.ravel(), r, Cbool, nbins=n_bins,min_obs=5)
# append outputs
plt.close('all')
all_S_bayes.append(S_bayes)
all_TH_bayes.append(TH_bayes)
all_PHIE_bayes.append(PHIE_bayes)
all_ZETA_bayes.append(ZETA_bayes)
all_S_edges.append(S_edges)
all_TH_edges.append(TH_edges)
all_PHIE_edges.append(PHIE_edges)
all_ZETA_edges.append(ZETA_edges)
np.savez(os.path.join(p_save, 'world_geom_hists.npz'),
all_S_bayes=all_S_bayes,
all_TH_bayes=all_TH_bayes,
all_PHIE_bayes=all_PHIE_bayes,
all_ZETA_bayes=all_ZETA_bayes,
all_S_edges=all_S_edges,
all_TH_edges=all_TH_edges,
all_PHIE_edges=all_PHIE_edges,
all_ZETA_edges=all_ZETA_edges,
ID=ID
)
def calc_all_mech_hists(p_load,p_save,n_bins=100):
"""
Since calculation takes so long on getting the histograms (mostly loading of data)
we want to calculate them once and save the data.
This calculates the mechanics.
:param p_load: Location where all the neo h5 files live
:param p_save: Location to save the output data files
:param n_bins: Number of bins in with which to split the data
:return None: Saves a 'mech_histograms.npz' file.
"""
# TODO: This is currently pretty gross, it is really too hardcoded (I wrote it in a car). Do better.
# TODO: Combine with geometry
# Case in point:
all_F_edges = []
all_M_edges = []
all_F_bayes = []
all_M_bayes = []
all_MB_edges = []
all_MD_edges = []
all_MD_bayes = []
all_MB_bayes = []
ID = []
# Loop all neo files
for f in glob.glob(os.path.join(p_load,'rat*.h5')):
print(os.path.basename(f))
blk = neoUtils.get_blk(f)
Cbool = neoUtils.get_Cbool(blk)
# Loop all units
for unit in blk.channel_indexes[-1].units:
unit_num = int(unit.name[-1])
# grab needed variables
r, b = neoUtils.get_rate_b(blk, unit_num, sigma=5 * pq.ms)
sp = neoUtils.concatenate_sp(blk)['cell_{}'.format(unit_num)]
root = neoUtils.get_root(blk,unit_num)
M = neoUtils.get_var(blk).magnitude
F = neoUtils.get_var(blk,'F').magnitude
MB, MD = neoUtils.get_MB_MD(M)
# init histograms
M_bayes = np.empty([n_bins,3])
F_bayes = np.empty([n_bins, 3])
M_edges = np.empty([n_bins+1, 3])
F_edges = np.empty([n_bins+1, 3])
#calculate tuning curves (seperately on each dimension)
for ii in range(3):
F_bayes[:, ii], F_edges[:, ii] = varTuning.stim_response_hist(F[:, ii] * 1e6, r, Cbool, nbins=n_bins, min_obs=5)
M_bayes[:, ii], M_edges[:, ii] = varTuning.stim_response_hist(M[:, ii] * 1e6, r, Cbool, nbins=n_bins, min_obs=5)
MB_bayes, MB_edges = varTuning.stim_response_hist(MB.squeeze() * 1e6, r, Cbool, nbins=n_bins, min_obs=5)
MD_bayes, MD_edges,_,_ = varTuning.angular_response_hist(MD.squeeze(), r, Cbool, nbins=n_bins)
plt.close('all')
# append to output lists
all_F_edges.append(F_edges)
all_M_edges.append(M_edges)
all_MB_edges.append(MB_edges)
all_MD_edges.append(MD_edges)
all_F_bayes.append(F_bayes)
all_M_bayes.append(M_bayes)
all_MB_bayes.append(MB_bayes)
all_MD_bayes.append(MD_bayes)
ID.append(root)
# save
np.savez(os.path.join(p_save,'mech_histograms.npz'),
all_F_bayes=all_F_bayes,
all_F_edges=all_F_edges,
all_M_bayes=all_M_bayes,
all_M_edges=all_M_edges,
all_MB_bayes=all_MB_bayes,
all_MB_edges=all_MB_edges,
all_MD_bayes=all_MD_bayes,
all_MD_edges=all_MD_edges,
ID=ID
)
'verbosity': 0,
'threshold': 1e-8,
'max_iter': 1e2,
'regularize_weights': {
'strength': 1e-3,
'norm': 'L2'
}
}
# comment this line out if not testing
# the test params make the iteration faster
#params=test_params ;print('testing params!!')
for unit_num in range(len(blk.channel_indexes[-1].units)):
R = {}
yhat, yhat_sim, model = run_dropout(fname, p_smooth, unit_num, params)
y = neoUtils.get_rate_b(blk, unit_num)[1]
X, y, cbool = get_X_y(fname, p_smooth, unit_num, pca_tgl=True,
n_pcs=6) #change to 6postest
root = neoUtils.get_root(blk, unit_num)
for key in yhat.iterkeys():
R[key], kernel_sizes = get_correlations(y, yhat[key],
yhat_sim[key], cbool)
root = neoUtils.get_root(blk, unit_num)
np.savez(os.path.join(p_save, '{}_STM_PCA.npz'.format(root)),
X=X,
y=y,
yhat=yhat,
yhat_sim=yhat_sim,
cbool=cbool,
R=R,
def plot_smooth_hists(blk,blk_smooth,unit_num=0,p_save=None,nbins=75):
DPI_RES=600
id = neoUtils.get_root(blk, unit_num)
fig_name = os.path.join(p_save, '{}_derivative_smoothing_compare.png'.format(id))
if os.path.isfile(fig_name):
print('{} found, skipping...'.format(fig_name))
return(None)
smoothing_windows = range(5,101,10)
use_flags = neoUtils.concatenate_epochs(blk)
cbool = neoUtils.get_Cbool(blk)
r,b =neoUtils.get_rate_b(blk,unit_num,2*pq.ms)
# catch empty smoothed data
if len(blk_smooth.segments)==0 or len(blk_smooth.segments[0].analogsignals)==0:
print('Smoothed data not found in {}'.format(id))
return(-1)
# get vars
M = neoUtils.get_var(blk_smooth,'M_smoothed').magnitude
M[np.invert(cbool),:]=np.nan
Mdot = neoUtils.get_deriv(M)
F = neoUtils.get_var(blk_smooth,'F_smoothed').magnitude
F[np.invert(cbool),:]=np.nan
Fdot = neoUtils.get_deriv(F)
PHI = neoUtils.get_var(blk_smooth,'PHIE_smoothed').magnitude
PHI = neoUtils.center_var(PHI.squeeze(),use_flags)
PHI[np.invert(cbool),:]=np.nan
PHIdot = neoUtils.get_deriv(PHI)
TH = neoUtils.get_var(blk_smooth,'TH_smoothed').magnitude
TH = neoUtils.center_var(TH.squeeze(),use_flags)
TH[np.invert(cbool),:]=np.nan
THdot = neoUtils.get_deriv(TH)
# ROT = np.sqrt(np.add(np.power(PHI,2),np.power(TH,2)))
# ROTdot = neoUtils.get_deriv(ROT)
# calculate histograms
R_Mdot, bins_Mdot, edgesx_Mdot, edgesy_Mdot = mult_join_plots(Mdot[:, 1, :], Mdot[:, 2, :], r, cbool, bins=nbins)
newbins =[np.linspace(bins_Mdot[0][edgesx_Mdot][0],bins_Mdot[0][edgesx_Mdot][1],nbins),
np.linspace(bins_Mdot[1][edgesy_Mdot][0], bins_Mdot[1][edgesy_Mdot][1], nbins)]
R_Mdot, bins_Mdot, edgesx_Mdot, edgesy_Mdot = mult_join_plots(Mdot[:, 1, :], Mdot[:, 2, :], r, cbool, bins=newbins)
R_Fdot, bins_Fdot, edgesx_Fdot, edgesy_Fdot = mult_join_plots(Fdot[:, 1, :], Fdot[:, 2, :], r, cbool,bins=nbins)
newbins = [np.linspace(bins_Fdot[0][edgesx_Fdot][0], bins_Fdot[0][edgesx_Fdot][1], nbins),
np.linspace(bins_Fdot[1][edgesy_Fdot][0], bins_Fdot[1][edgesy_Fdot][1], nbins)]
R_Fdot, bins_Fdot, edgesx_Fdot, edgesy_Fdot = mult_join_plots(Fdot[:, 1, :], Fdot[:, 2, :], r, cbool, bins=newbins)
R_ROTdot, bins_ROTdot, edgesx_ROTdot, edgesy_ROTdot = mult_join_plots(THdot, PHIdot, r, cbool,bins=nbins)
newbins = [np.linspace(bins_ROTdot[0][edgesx_ROTdot][0], bins_ROTdot[0][edgesx_ROTdot][1], nbins),
np.linspace(bins_ROTdot[1][edgesy_ROTdot][0], bins_ROTdot[1][edgesy_ROTdot][1], nbins)]
R_ROTdot, bins_ROTdot, edgesx_ROTdot, edgesy_ROTdot = mult_join_plots(THdot, PHIdot, r, cbool, bins=newbins)
FR = []
FR.append(np.nanmax([x.max() for x in R_Mdot.values()]))
FR.append(np.nanmax([x.max() for x in R_Fdot.values()]))
FR.append(np.nanmax([x.max() for x in R_ROTdot.values()]))
colormax = np.nanmax(FR)
# Plots
f = plt.figure()
figManager = plt.get_current_fig_manager()
figManager.window.showMaximized()
# hardcoded for 5 smoothing steps
for loc,ii in enumerate(range(0,10,2)):
ax = f.add_subplot(3,5,loc+1)
ax.pcolormesh(bins_Mdot[0],bins_Mdot[1],R_Mdot[ii], cmap='OrRd', edgecolors='None',vmin=0,vmax=colormax)
ax.set_xlim(bins_Mdot[0][edgesx_Mdot])
ax.set_ylim(bins_Mdot[1][edgesy_Mdot])
ax.set_title('Smoothing window = {}ms'.format(smoothing_windows[ii]))
ax.axvline(color='k',linewidth=1)
ax.axhline(color='k',linewidth=1)
if ii==0:
ax.set_ylabel('$\\dot{M_y}$ vs $\\dot{M_z}$',rotation=0,labelpad=20)
for loc,ii in enumerate(range(0,10,2)):
ax = f.add_subplot(3, 5, loc + 1+5)
ax.pcolormesh(bins_Fdot[0], bins_Fdot[1], R_Fdot[ii], cmap='OrRd', edgecolors='None', vmin=0, vmax=colormax)
ax.set_xlim(bins_Fdot[0][edgesx_Fdot])
ax.set_ylim(bins_Fdot[1][edgesy_Fdot])
ax.axvline(color='k', linewidth=1)
ax.axhline(color='k', linewidth=1)
if ii==0:
ax.set_ylabel('$\\dot{F_y}$ vs $\\dot{F_z}$',rotation=0,labelpad=20)
for loc,ii in enumerate(range(0,10,2)):
ax = f.add_subplot(3, 5, loc + 1+10)
h=ax.pcolormesh(bins_ROTdot[0], bins_ROTdot[1], R_ROTdot[ii], cmap='OrRd', edgecolors='None', vmin=0, vmax=colormax)
ax.set_xlim(bins_ROTdot[0][edgesx_ROTdot])
ax.set_ylim(bins_ROTdot[1][edgesy_ROTdot])
ax.axvline(color='k', linewidth=1)
ax.axhline(color='k', linewidth=1)
if ii==0:
ax.set_ylabel('$\\dot{\\theta}$ vs $\\dot{\\phi}$',rotation=0,labelpad=20)
plt.suptitle('{}'.format(id))
plt.colorbar(h)
plt.pause(0.1)
if p_save is not None:
plt.savefig(fig_name,dpi=DPI_RES)
plt.close('all')
return(None)
