def several_dphi(b, fp, fc, tps=np.arange(0, 5, 0.5)):
dt = 1 / b.fs
N = int(b.T * b.fs) + 1
t = (np.arange(N) - (N - 1) / 2) * dt
P_det = x2phidet(b.xA, p_x=b.P_det_x)
b2 = lockin.lock2(5e3, fp, fc, b.fs, coeff_ratio=4)
lp = b2[b2.size // 2:]
lp = lp / sum(lp)
dphis = np.empty_like(tps)
tps = tps * b.tau
for i, tp in enumerate(tps):
f = expfall(t, b.tau, toff=tp) * b.df_inf
noise = np.random.randn(N) * psd2sigma(b.P_intrins, b.fs)
m_phi_noise = np.random.randn(N) * psd2sigma(
x2phidet(b.xA, p_x=b.P_det_x), b.fs)
phi = np.cumsum(f + noise) * dt + m_phi_noise
diff = lp2diff(lp, b.fs, tp)
phi_out = signal.fftconvolve(phi, diff, mode='same')
ind = np.argmin(abs(t - tp / 2.))
dphis[i] = phi_out[ind]
return tps, dphis
def average_df(b, Navg, fp_ratio=1, fc_ratio=4):
b.dt = dt = 1 / b.fs
b.N = N = int(b.T * b.fs) + 1
b.t = t = (np.arange(N) - (N - 1) / 2) * dt
b.f = f = expfall(t, b.tau) * b.df_inf
noise = np.random.randn(Navg, N) * psd2sigma(b.P_intrins, b.fs)
m_phi_noise = np.random.randn(Navg, N) * psd2sigma(
x2phidet(b.xA, p_x=b.P_det_x), b.fs)
m_f_noise = np.c_[np.diff(m_phi_noise, axis=1),
np.zeros(m_phi_noise.shape[0])] / dt
f_noised = f + noise + m_f_noise
fir = lockin.lock2(5e3,
fp_ratio / b.tau,
fc_ratio / b.tau,
b.fs,
print_response=False)
f_filt = np.empty_like(f_noised)
for i, out in enumerate(f_noised):
f_filt[i, :] = signal.fftconvolve(out, fir, mode='same')
return b, f_filt
def workup_adiabatic_w_control_correct_phase_bnc3(fh,
fp, fc, fs_dec,
w_before=None,
w_after=None):
tps = fh['tp tip [s]'][:]
tp_groups = fh['ds'][:]
df = pd.DataFrame(index=pd.MultiIndex.from_product(
(['data', 'control'], tp_groups), names=['expt', 'ds']))
lis = {}
locks = {}
i = 0
dt = fh['data/0000/dt [s]'].value
fs = 1./dt
lock_fir = lockin.lock2(62e3, fp=fp, fc=fc, fs=fs, coeff_ratio=8,
window='blackman', print_response=False)
N_dec = int(fs/fs_dec)
for control_or_data in ('control', 'data'):
lis[control_or_data] = []
locks[control_or_data] = []
for (tp_group, tp) in tqdm(zip(tp_groups, tps)):
gr = fh[control_or_data][tp_group]
print_response = i == 0
N2even = gr.attrs['Calc BNC565 CantClk.N2 (even)']
t1 = gr.attrs['Abrupt BNC565 CantClk.t1 [s]']
t2 = np.sum(gr["half periods [s]"][:N2even+1])
tp = np.sum(gr.attrs["Abrupt BNC565 CantClk.tp tip [s]"])
t0 = -(t1 + t2)
x = gr['cantilever-nm'][:]
lock, li = phasekick2.individual_phasekick2(x, dt, t0, t1, t2, tp,
N_dec, lock_fir, w_before, w_after)
dphi = li.delta_phi
phi_at_tp, dA, dphi_tp_end = measure_dA_dphi(lock, li, tp,
dphi_weight_before=w_before, dphi_weight_after=w_after)
lis[control_or_data].append(li)
locks[control_or_data].append(lock)
i += 1
curr_index = (control_or_data, tp_group)
df.loc[curr_index, 'tp'] = tp
df.loc[curr_index, 'dphi [cyc]'] = dphi/(2*np.pi)
df.loc[curr_index, 'f0 [Hz]'] = li.fc0
df.loc[curr_index, 'df_dV [Hz]'] = li.f1 - li.fc0
df.loc[curr_index, 'df2_dV [Hz]'] = li.f2 - li.fc0
df.loc[curr_index, 'dA [nm]'] = dA
df.loc[curr_index, 'dphi_tp_end [cyc]'] = dphi_tp_end
df.loc[curr_index, 'phi_at_tp [rad]'] = phi_at_tp
df.loc[curr_index, 'relative time [s]'] = gr['relative time [s]'].value
try:
df.sort_index(inplace=True)
print(df)
df_clean = df.dropna()
control = df_clean.xs('control')
data = df_clean.xs('data')
popt_phi, pcov_phi = optimize.curve_fit(offset_cos,
control['phi_at_tp [rad]'], control['dphi_tp_end [cyc]'])
popt_A, pcov_A = optimize.curve_fit(offset_cos,
control['phi_at_tp [rad]'], control['dA [nm]'])
df['dphi_corrected [cyc]'] = (df['dphi [cyc]']
- offset_cos(df['phi_at_tp [rad]'], *popt_phi))
df_clean = df.dropna()
df_clean.sort_values('tp', inplace=True)
control = df_clean.xs('control')
data = df_clean.xs('data')
popt_phase_corr, pcov_phase_corr = optimize.curve_fit(phase_step, data['tp'], data['dphi_corrected [cyc]'])
popt_phase, pcov_phase = optimize.curve_fit(phase_step, data['tp'], data['dphi [cyc]'])
# Extra information
filename = fh.filename
extras = {'popt_phi': popt_phi,
'pcov_phi': pcov_phi,
'pdiag_phi': np.diagonal(pcov_phi)**0.5,
'popt_A': popt_A,
'pcov_A': pcov_A,
'pdiag_A': np.diagonal(pcov_A)**0.5,
'popt_phase_corr': popt_phase_corr,
'pcov_phase_corr': pcov_phase_corr,
'pdiag_phase_corr': np.diagonal(pcov_phase_corr)**0.5,
'popt_phase': popt_phase,
'pcov_phase': pcov_phase,
'pdiag_phase': np.diagonal(pcov_phase)**0.5,
'params':
{
'filename': filename,
'w_before': w_after,
'w_after': w_before,
'fp': fp,
'fc': fc,
'fs_dec': fs_dec,
},
'filename': filename,
'file_attrs_str': prnDict(dict(fh.attrs.items()), braces=False),
'dataset_attrs_str': prnDict(dict(fh['data/0000'].attrs.items()), braces=False),
'lis': lis,
'locks': locks}
return df_clean, extras
except Exception as e:
print(e)
raise
'ti': -500e-6,
'tf': 1.4e-3,
'Ndec': 15
}
with h5py.File(fname, 'r') as fh:
trefm = phasekick.AverageTrEFM.from_group(fh['data'], params['fp'],
params['fc'], params['t_phase'],
params['ti'], params['tf'])
t, mu_df, sigma_df = get_t_mu_sigma_df(trefm)
M, N = trefm.t.shape
fs = 1e6
dt = 1e-6
fir = lockin.lock2(62000, params['fp'], params['fc'], fs)
K = fir.size
NK1 = N + K - 1
K2 = int((K - 1) / 2)
t_offset = -dt * K2
tdelay = -3e-6
t_eval = np.arange(NK1) * dt + t[0] + t_offset + tdelay
offset = np.mean(mu_df[t < 0.])
data = {
't_eval': t_eval * 1e3, # ms,
'N': N,
'K': K,
'kern': fir,
'y_err': sigma_df,
delays, dAs, dPhis = delay_dA_dphi(fh800['data'], 1.6e-3, -1e-3, -1e-4, 1e-4,
1e-3)
df.loc[idx[800, :], 'dA'] = dAs
df.loc[idx[800, :], 'dPhi'] = dPhis
fh200 = h5py.File('../data/subcycle-pk-efm/151209-192620-200ns-pulse-10V.h5',
'r')
delays, dAs, dPhis = delay_dA_dphi(fh200['data'], 1.6e-3, -1e-3, -1e-4, 1e-4,
1e-3)
df.loc[idx[200, :], 'dA'] = dAs
df.loc[idx[200, :], 'dPhi'] = dPhis
# In[4]:
locks = []
fir = lockin.lock2(62000, 5000, 15000, 1e6)
for gr in tqdm(fh800['data'].values()):
half_periods = gr["half periods [s]"][:]
N2even = gr.attrs['Calc BNC565 CantClk.N2 (even)']
t1 = gr.attrs['Abrupt BNC565 CantClk.t1 [s]']
t2 = np.sum(gr["half periods [s]"][:N2even + 1])
t0 = -(t1 + t2)
x = gr['cantilever-nm'][:]
dt = gr['dt [s]'].value
t = np.arange(x.size) * dt + t0
lock = lockin.LockIn(t, x, 1 / dt)
lock.lock2(fp=5000, fc=15000, print_response=False)
lock.phase(ti=3e-3, tf=7e-3)
locks.append(lock)
m0 = phasekick.masklh(t, -5e-6, 5e-6)
Ndec = params['Ndec']
with h5py.File(fname, 'r') as fh:
trefm = phasekick.AverageTrEFM.from_group(fh['data'], params['fp'],
params['fc'], params['t_phase'],
params['ti'], params['tf'])
t_, mu_df_, sigma_df_ = get_t_mu_sigma_df(trefm)
t = t_[::Ndec]
mu_df = mu_df_[::Ndec]
sigma_df = sigma_df_[::Ndec]
N = t.size
fs = 1e6
dt = Ndec / fs
fir = lockin.lock2(62000, params['fp'], params['fc'], fs)[::Ndec] * Ndec
K = fir.size
NK1 = N + K - 1
K2 = int((K - 1) / 2)
t_offset = -dt * K2
tdelay = -5e-6
t_eval = np.arange(NK1) * dt + t[0] + t_offset + tdelay
offset = np.mean(mu_df[t < 0.])
data = {
't_eval': t_eval * 1e3, # ms,
'N': N,
'K': K,
'kern': fir,
'y_err': sigma_df,
workups['104-0V-phi'] = phasekick.workup_df(fh, 1000, 4000, 0.1715, 0.1985)
workups['104-10V'] = phasekick.workup_df(fh, 1000, 4000, tmin, tmax-0.001)
workups['0502-0V'] = phasekick.workup_df(fh, 500, 2000, 0.1725, 0.1975)
workups['0502-0V-phi'] = phasekick.workup_df(fh, 500, 2000, 0.1725, 0.1975)
workups['0502-10V'] = phasekick.workup_df(fh, 500, 2000, tmin, tmax-0.002)
out0520 = workup_df(fh, 500, 2000, {0: ((0.1725, 0.1975), np.array([ 0.63894734, 0.00621252, -0.8297541]))})
out1040 = workup_df(fh, 1000, 4000, {0: ((0.1715, 0.1985), np.array([ 0.63894734, 0.00621252, -0.8297541]))})
# Frequency / phase noise figure parts a,b, d,e
# Lock-in filter coefficients (a)
fir0104 = lockin.lock2(f0=62e3, fp=1000, fc=4000, fs=1e6)
fir208 = lockin.lock2(62e3, 2e3, 8e3, 1e6)
fir0502 = workups['0502-0V']['lis'][0].fir
size = 8
labelsize=8
rcParams = {'figure.figsize': (4*0.75, 3*0.75), 'font.size': size,
'lines.markersize': 6,
'lines.linewidth': 1,
'xtick.labelsize': labelsize, 'ytick.labelsize': labelsize,}
Asize = (2.9,0.9)
get_t = lambda fir, fs: (np.arange(fir.size) - (fir.size-1)/2) / fs