def RelativePsie(ye, xm): Nx = TrackNormal(xm) u = 1j * Nx rx = u * ye + xm Nr = TrackNormal(rx) # psie is sort of backwards: higher angles go to the left return np.angle(Nx) - np.angle(Nr)
def RelativePsie(ye, xm): Nx = TrackNormal(xm) u = 1j * Nx rx = u*ye + xm Nr = TrackNormal(rx) # psie is sort of backwards: higher angles go to the left return np.angle(Nx) - np.angle(Nr)
def calculate_Fi_ci_si(self): ''' Calculate simple calculation of Fi, ci, si: does not include any CPV effects, not time dependece ''' bin_num = self.binning.get_number_of_bins() Fi = np.array([]) ci = np.array([]) si = np.array([]) A_mag = abs(self.amplitude.get_A( 0)) # Just make simple calculation in this class A_ph = np.angle(self.amplitude.get_A(0)) A_mag_inv = np.transpose(A_mag) A_ph_inv = np.transpose(A_ph) avg_eff_over_phsp = self.efficiency.get_time_averaged_eff() for i in range(-bin_num, bin_num + 1): if i == 0: continue bin_idx = self.binning.get_bin_indices(i) inv_bin_idx = self.binning.get_bin_indices(-i) avg_eff = avg_eff_over_phsp[bin_idx] Fi = np.append(Fi, np.sum(avg_eff * A_mag[bin_idx]**2)) ci = np.append( ci, np.sum(avg_eff * A_mag[bin_idx] * A_mag_inv[bin_idx] * np.cos(A_ph[bin_idx] - A_ph_inv[bin_idx]))) si = np.append( si, np.sum(avg_eff * A_mag[bin_idx] * A_mag_inv[bin_idx] * np.sin(A_ph[bin_idx] - A_ph_inv[bin_idx]))) Fi_inv = np.flip(Fi, 0) ci = ci / np.sqrt(Fi * np.flip(Fi, 0)) si = si / np.sqrt(Fi * np.flip(Fi, 0)) Fi = Fi / sum(Fi) return Fi, ci, si
def optimal_rotation_new(Y, p): """Choose the correct representative from each equivalence class. Parameters ---------- Y : ndarray (d*n) Data, with one COLUMN for each of the n data points in d-dimensional space. w : ndarray (d*d) Rotation matrix for p-th root of unity. p : int Order of cyclic group. Returns ------- S : ndarray (n*n) Correct power of w to use for each inner product. Satisfies S + S.T = 0 (mod p) """ # (I'm not convinced this method is actually better, algorithmically.) # Convert Y to complex form: Ycplx = Y[0::2] + 1j * Y[1::2] cplx_ip = Ycplx.T @ Ycplx.conjugate() ip_angles = np.angle(cplx_ip) ip_angles[ip_angles < 0] += 2 * np.pi #np.angles uses range -pi,pi root_angles = np.linspace(0, 2 * np.pi, p + 1) S = np.zeros(ip_angles.shape) for i in range(ip_angles.shape[0]): for j in range(ip_angles.shape[1]): S[i, j] = np.argmin(np.abs(ip_angles[i, j] - root_angles)) S[S == p] = 0 S = S.T # Want the angle to act on the second component. return S
def plotfiltphase(x): f = np.arange(1, 256) w = 2 * np.pi * f / 670.0 z = np.exp(1j * w) h = FilterResponse(z, x) h = h * (h[1] / np.abs(h[1]))**(np.arange(len(h)) - 2) phase = np.angle(h[1:] / h[:-1]) plt.plot(np.log(f[:-1]) / np.log(2), phase)
plt.figure() for order in [1, 2, 3, 4, 5, 6, 9]: b, a = butter_bandpass(8., 12., fs, order=order) w, h = signal.freqz(b, a, worN=2000) plt.plot((fs * 0.5 / np.pi) * w[:200], abs(h[:200]), label="order = %d" % order) plt.xlabel('Frequency (Hz)') plt.ylabel('Gain') plt.grid(True) plt.legend(loc='best') b, a = butter_bandpass(8., 12., fs=1000., order=3) csd_fast_filt = signal.filtfilt(b, a, gpcsd_model.csd_pred_list[1], axis=1) csd_fast_phase = np.angle(signal.hilbert(csd_fast_filt, axis=1), deg=False) lfp_fast_filt = signal.filtfilt(b, a, gpcsd_model.lfp_pred_list[1], axis=1) lfp_fast_phase = np.angle(signal.hilbert(lfp_fast_filt, axis=1), deg=False) # %% compute within-probe PLV matrix over time plv_csd = np.nan * np.zeros((24, 24, gpcsd_model.t_pred.shape[0])) plv_lfp = np.nan * np.zeros((24, 24, gpcsd_model.t_pred.shape[0])) for ci in range(24): for cj in range(ci, 24): if ci == cj: continue res_csd = plv( np.squeeze(csd_fast_phase[ci, :, :]).T, np.squeeze(csd_fast_phase[cj, :, :]).T) plv_csd[ci, cj, :] = res_csd plv_csd[cj, ci, :] = res_csd
def test_angle_complex(): fun = lambda x : np.angle(x) d_fun = lambda x: grad(fun)(x) check_grads(fun)(npr.rand() + 1j*npr.rand()) check_grads(d_fun)(npr.rand() + 1j*npr.rand())
def test_angle_real(): fun = lambda x : np.angle(x) d_fun = lambda x: grad(fun)(x) check_grads(fun)(npr.rand()) check_grads(d_fun)(npr.rand())
def test_angle_complex(): fun = lambda x : to_scalar(np.angle(x)) d_fun = lambda x: to_scalar(grad(fun)(x)) check_grads(fun, npr.rand() + 1j*npr.rand()) check_grads(d_fun, npr.rand() + 1j*npr.rand())
def test_angle_complex(): fun = lambda x: np.angle(x) d_fun = lambda x: grad(fun)(x) check_grads(fun)(npr.rand() + 1j * npr.rand()) check_grads(d_fun)(npr.rand() + 1j * npr.rand())
def test_angle_real(): fun = lambda x: np.angle(x) d_fun = lambda x: grad(fun)(x) check_grads(fun)(npr.rand()) check_grads(d_fun)(npr.rand())
def plot303phase(n): f = np.arange(1, 300) y = np.fft.rfft(-Y[int(n * 670) - 100:int((n + 1) * 670) - 100]) # y = y * (y[1] / np.abs(y[1]))**(np.arange(len(y)) - 2) phase = np.angle(y[1:] / y[:-1]) plt.plot(np.log(f) / np.log(2), phase[f - 1])
b, a = signal.butter(order, [low, high], btype='band') return b, a fs = 2500 bands = {'theta': [3., 7.], 'beta': [20., 24.]} for probe, probe_name in zip(['probeC', 'probeD'], ['V1', 'LM']): phases = {} for bk in bands.keys(): ord, wn = signal.buttord([bands[bk][0], bands[bk][1]], [bands[bk][0] - 2, bands[bk][1] + 2], 10, 20, fs=fs) sos = signal.butter(1, [bands[bk][0], bands[bk][1]], btype='bandpass', fs=fs, output='sos') res = signal.sosfiltfilt(sos, csdMatern[probe] + csdSE[probe], axis=1) phase_tmp = np.angle(signal.hilbert(res, axis=1), deg=False) # TODO get time index of interest ti = np.array([ np.argmin(np.abs(t.squeeze() - 0.0)), np.argmin(np.abs(t.squeeze() - 70.0)) ]) phases[bk] = phase_tmp[:, ti, :] scipy.io.savemat( '%s/results/neuropixel_csd_%s_phases.mat' % (root_path, probe_name), phases) # %%
def real_imag_to_mag_phase(realpart, imagpart): a = realpart + 1j * imagpart return np.abs(a), np.angle(a)
def test_angle_real(): fun = lambda x: to_scalar(np.angle(x)) d_fun = lambda x: to_scalar(grad(fun)(x)) check_grads(fun, npr.rand()) check_grads(d_fun, npr.rand())
def test_angle_complex(): fun = lambda x: to_scalar(np.angle(x)) d_fun = lambda x: to_scalar(grad(fun)(x)) check_grads(fun, npr.rand() + 1j * npr.rand()) check_grads(d_fun, npr.rand() + 1j * npr.rand())
def test_angle_real(): fun = lambda x : to_scalar(np.angle(x)) d_fun = lambda x: to_scalar(grad(fun)(x)) check_grads(fun, npr.rand()) check_grads(d_fun, npr.rand())