#attenlist = attenlist[:4] for atten in attenlist: print "setting attenuator to",atten ri.set_dac_attenuator(atten) measured_freqs = sweeps.prepare_sweep(ri,f0binned,offsets,nsamp=nsamp) print "loaded waveforms in", (time.time()-start),"seconds" sweep_data = sweeps.do_prepared_sweep(ri, nchan_per_step=atonce, reads_per_step=8) orig_sweep_data = sweep_data meas_cfs = [] idxs = [] delays = [] for m in range(len(f0s)): fr,s21,errors = sweep_data.select_by_freq(f0s[m]) thiscf = f0s[m] res = fit_best_resonator(fr[1:-1],s21[1:-1],errors=errors[1:-1]) #Resonator(fr,s21,errors=errors) delay = res.delay delays.append(delay) s21 = s21*np.exp(2j*np.pi*res.delay*fr) res = fit_best_resonator(fr,s21,errors=errors) fmin = fr[np.abs(s21).argmin()] print "s21 fmin", fmin, "original guess",thiscf,"this fit", res.f_0, "delay",delay,"resid delay",res.delay if use_fmin: meas_cfs.append(fmin) else: if abs(res.f_0 - thiscf) > 0.1: if abs(fmin - thiscf) > 0.1: print "using original guess" meas_cfs.append(thiscf) else: print "using fmin"
delay = -31.3 print "median delay is ", delay df = data_file.DataFile(suffix=suffix) df.nc.mmw_atten_turns = mmw_atten_turns df.log_hw_state(ri) sweep_data = sweeps.do_prepared_sweep(ri, nchan_per_step=atonce, reads_per_step=2) df.add_sweep(sweep_data) meas_cfs = [] idxs = [] for m in range(len(f0s)): fr, s21, errors = sweep_data.select_by_freq(f0s[m]) thiscf = f0s[m] s21 = s21 * np.exp(2j * np.pi * delay * fr) res = fit_best_resonator(fr, s21, errors=errors) #Resonator(fr,s21,errors=errors) fmin = fr[np.abs(s21).argmin()] print "s21 fmin", fmin, "original guess", thiscf, "this fit", res.f_0 if use_fmin: meas_cfs.append(fmin) else: if abs(res.f_0 - thiscf) > 0.1: if abs(fmin - thiscf) > 0.1: print "using original guess" meas_cfs.append(thiscf) else: print "using fmin" meas_cfs.append(fmin) else: print "using this fit" meas_cfs.append(res.f_0)
print "median delay is ", delay df = data_file.DataFile(suffix=suffix) df.nc.mmw_atten_turns = mmw_atten_turns df.log_hw_state(ri) sweep_data = sweeps.do_prepared_sweep(ri, nchan_per_step=atonce, reads_per_step=2) df.add_sweep(sweep_data) meas_cfs = [] idxs = [] for m in range(len(f0s)): fr, s21, errors = sweep_data.select_by_freq(f0s[m]) thiscf = f0s[m] s21 = s21 * np.exp(2j * np.pi * delay * fr) res = fit_best_resonator( fr, s21, errors=errors) #Resonator(fr,s21,errors=errors) fmin = fr[np.abs(s21).argmin()] print "s21 fmin", fmin, "original guess", thiscf, "this fit", res.f_0 if use_fmin: meas_cfs.append(fmin) else: if abs(res.f_0 - thiscf) > 0.1: if abs(fmin - thiscf) > 0.1: print "using original guess" meas_cfs.append(thiscf) else: print "using fmin" meas_cfs.append(fmin) else: print "using this fit" meas_cfs.append(res.f_0)
ri.set_dac_attenuator(atten) measured_freqs = sweeps.prepare_sweep(ri, f0binned, offsets, nsamp=nsamp) print "loaded waveforms in", (time.time() - start), "seconds" sweep_data = sweeps.do_prepared_sweep(ri, nchan_per_step=atonce, reads_per_step=4) orig_sweep_data = sweep_data meas_cfs = [] idxs = [] delays = [] for m in range(len(f0s)): fr, s21, errors = sweep_data.select_by_freq(f0s[m]) thiscf = f0s[m] res = fit_best_resonator( fr[1:-1], s21[1:-1], errors=errors[1:-1]) #Resonator(fr,s21,errors=errors) delay = res.delay delays.append(delay) s21 = s21 * np.exp(2j * np.pi * res.delay * fr) res = fit_best_resonator(fr, s21, errors=errors) fmin = fr[np.abs(s21).argmin()] print "s21 fmin", fmin, "original guess", thiscf, "this fit", res.f_0, "delay", delay, "resid delay", res.delay if use_fmin: meas_cfs.append(fmin) else: if abs(res.f_0 - thiscf) > 0.1: if abs(fmin - thiscf) > 0.1: print "using original guess" meas_cfs.append(thiscf) else:
atten_list = np.linspace(15, 46, 8) #[30]#[35.5,33.5,46.5,43.5,40.5,37.5] #atten_list = [33.0] for atten in atten_list: df = data_file.DataFile() ri.set_dac_attenuator(atten) sweep_data = sweeps.do_prepared_sweep(ri, nchan_per_step=atonce, reads_per_step=8) df.add_sweep(sweep_data) meas_cfs = [] idxs = [] for m in range(len(f0s)): fr, s21, errors = sweep_data.select_by_freq(f0s[m]) thiscf = f0s[m] res = fit_best_resonator(fr[2:-2], s21[2:-2], errors=errors[2:-2]) delay = res.delay # delays.append(delay) s21 = s21 * np.exp(2j * np.pi * res.delay * fr) res = fit_best_resonator(fr, s21, errors=errors) fmin = fr[np.abs(s21).argmin()] print "s21 fmin", fmin, "original guess", thiscf, "this fit", res.f_0, "delay", delay, "resid", res.delay if abs(res.f_0 - thiscf) > 0.1: if abs(fmin - thiscf) > 0.1: print "using original guess" meas_cfs.append(thiscf) else: print "using fmin" meas_cfs.append(fmin) else: print "using this fit"
sys.stdout.flush() time.sleep(1) atten_list = np.linspace(15,46,8)#[30]#[35.5,33.5,46.5,43.5,40.5,37.5] #atten_list = [33.0] for atten in atten_list: df = data_file.DataFile() ri.set_dac_attenuator(atten) sweep_data = sweeps.do_prepared_sweep(ri, nchan_per_step=atonce, reads_per_step=8) df.add_sweep(sweep_data) meas_cfs = [] idxs = [] for m in range(len(f0s)): fr,s21,errors = sweep_data.select_by_freq(f0s[m]) thiscf = f0s[m] res = fit_best_resonator(fr[2:-2],s21[2:-2],errors=errors[2:-2]) delay = res.delay # delays.append(delay) s21 = s21*np.exp(2j*np.pi*res.delay*fr) res = fit_best_resonator(fr,s21,errors=errors) fmin = fr[np.abs(s21).argmin()] print "s21 fmin", fmin, "original guess",thiscf,"this fit", res.f_0,"delay",delay,"resid",res.delay if abs(res.f_0 - thiscf) > 0.1: if abs(fmin - thiscf) > 0.1: print "using original guess" meas_cfs.append(thiscf) else: print "using fmin" meas_cfs.append(fmin) else: print "using this fit"
def extract_and_pickle(nc_filename): """ The format is that the file contains equal numbers of sweeps and timestreams. The first sweep is used to locate the resonances and is taken with the source off at the lowest power level, i.e. the maximum attenuation. The first timestream is taken under the same conditions except that the source is modulated. Subsequent sweeps and timestreams are paired. :param nc_filename: the file name of the netCDF4 file with the above format. :return: a dictionary """ try: all_noise_on = [] all_noise_off = [] all_noise_modulated = [] all_coarse_sweep_params = [] coarse_sweep_index = 0 modulated_timestream_index = 0 print("Processing {}".format(nc_filename)) rnc = ReadoutNetCDF(nc_filename) resonator_indices = sorted(set(rnc.sweeps[0].index)) n_attenuations = len(rnc.sweeps) - 1 for resonator_index in resonator_indices: noise_on = [] for on_index in range(1, n_attenuations, 2): noise_on.append(SweepNoiseMeasurement(nc_filename, resonator_index=resonator_index, sweep_group_index=on_index, timestream_group_index=on_index)) all_noise_on.extend(noise_on) noise_off = [] for off_index in range(2, n_attenuations + 1, 2): noise_off.append(SweepNoiseMeasurement(nc_filename, resonator_index=resonator_index, sweep_group_index=off_index, timestream_group_index=off_index)) all_noise_off.extend(noise_off) # Create the modulated measurement from the modulated timestream and the noise off sweep at the same power. # Skip deglitching. attenuations = [snm.atten for snm in noise_off] off_max_attenuation_index = 1 + 2 * attenuations.index(max(attenuations)) + 1 noise_modulated = SweepNoiseMeasurement(nc_filename, resonator_index=resonator_index, sweep_group_index=off_max_attenuation_index, timestream_group_index=modulated_timestream_index, deglitch_threshold=None) noise_modulated.folded_projected_timeseries = noise_modulated.projected_timeseries.reshape( (-1, noise_modulated.timestream_modulation_period_samples)) folded = noise_modulated.folded_projected_timeseries.mean(0) high, low, rising_edge = find_high_low(folded) noise_modulated.folded_projected_timeseries = np.roll(noise_modulated.folded_projected_timeseries, -rising_edge, axis=1) noise_modulated.folded_normalized_timeseries = np.roll( noise_modulated.normalized_timeseries.reshape((-1, noise_modulated.timestream_modulation_period_samples)), -rising_edge, axis=1) all_noise_modulated.append(noise_modulated) # Add the ZBD voltage from the modulated timestream to the modulated and static on measurements: zbd_voltage = rnc.timestreams[modulated_timestream_index].zbd_voltage[0] noise_modulated.zbd_voltage = zbd_voltage for snm in noise_on: snm.zbd_voltage = zbd_voltage # Save only the Parameters object from a fit to the coarse sweep. freq, s21, err = rnc.sweeps[coarse_sweep_index].select_by_index(resonator_index) coarse_resonator = fit_best_resonator(freq, s21, errors=err) all_coarse_sweep_params.append(coarse_resonator.result.params) rnc.close() data = {'noise_on_measurements': all_noise_on, 'noise_off_measurements': all_noise_off, 'noise_modulated_measurements': all_noise_modulated, 'coarse_sweep_params': all_coarse_sweep_params} # We decided to keep the .pkl files in /home/data regardless of origin. pkl_filename = os.path.join('/home/data/pkl', os.path.splitext(os.path.split(nc_filename)[1])[0] + '.pkl') save_noise_pkl(pkl_filename, data) print("Saved {}".format(pkl_filename)) except KeyboardInterrupt: print("Aborting {}".format(nc_filename))
def __init__(self,swg,tsg,hwg,chip,id,index=0,phasecorr=phasecorr,scale=scale,filtlen=2**16,loss = -42, ntones=None, use_bif=False, delay_estimate = -7.11): self.id = id self.swp_epoch = swg.groups['datablocks'].variables['epoch'][0] self.start_temp = get_temperature_at(self.swp_epoch) self.ts_epoch = tsg.variables['epoch'][:][-1] self.end_temp = get_temperature_at(self.ts_epoch) self.index = index self.chip = chip self.phasecorr = phasecorr if scale is None: self.scale = 1/tsg.variables['wavenorm'][index] else: self.scale = scale self.filtlen = filtlen self.loss = loss try: hwidx = bisect.bisect(hwg.variables['epoch'][:],self.swp_epoch) if hwidx == hwg.variables['epoch'].shape[0]: hwidx = -1 if ntones is None: ntones = hwg.variables['ntones'][hwidx] self.atten = hwg.variables['dac_atten'][hwidx] self.power_dbm = loss - self.atten - ntone_power_correction(ntones) except: print "failed to find attenuator settings" self.atten = np.nan self.power_dbm = np.nan idx = swg.variables['index'][:] self.fr = swg.variables['frequency'][:] self.s21 = swg.variables['s21'][:].view('complex128')*np.exp(-1j*self.fr*phasecorr)*self.scale self.fr = self.fr[idx==index]#[1:]#[4:-4] self.s21 = self.s21[idx==index]#[1:]#[4:-4] tones = tsg.variables['tone'][:] nsamp = tsg.variables['nsamp'][:] fs = tsg.variables['fs'][:] fmeas = fs*tones/nsamp tone_index = np.argmin(abs(fmeas-self.fr.mean())) ts = tsg.variables['data'][tone_index,:].view('complex128') self.fs = fs[tone_index] self.nfft = tsg.variables['nfft'][tone_index] window = int(2**np.ceil(np.log2(self.fs*1e6/(2*self.nfft)))) if window > ts.shape[0]: window = ts.shape[0]//2 ts = deglitch_window(ts,window,thresh=6) self.fr = np.hstack((self.fr,[fmeas[tone_index]])) self.s21 = np.hstack((self.s21,[ts[:2048].mean()])) blkidx = swg.groups['datablocks'].variables['sweep_index'][:] blks = swg.groups['datablocks'].variables['data'][:][blkidx==index,:].view('complex') errors = blks.real.std(1) + 1j*blks.imag.std(1) self.errors = errors self.errors = np.hstack((self.errors,[ts[:2048].real.std()+ts[:2048].imag.std()])) order = self.fr.argsort() self.fr = self.fr[order] self.s21 = self.s21[order] self.errors = self.errors[order] def delay_guess(*args): if use_bif: p = khalil.bifurcation_guess(*args) else: p = khalil.delayed_generic_guess(*args) p['delay'].value = delay_estimate return p if use_bif: rr = Resonator(self.fr[2:-2],self.s21[2:-2],model=khalil.bifurcation_s21,guess=delay_guess,errors=errors[2:-2]) else: rr = Resonator(self.fr[2:-2],self.s21[2:-2],errors=errors[2:-2],guess=delay_guess) self.delay = rr.delay self.s21 = self.s21*np.exp(2j*np.pi*rr.delay*self.fr) # if use_bif: # rr = Resonator(self.fr,self.s21,model=khalil.bifurcation_s21,guess=khalil.bifurcation_guess,errors=errors) # else: # rr = Resonator(self.fr,self.s21,mask=rr.mask)#errors=errors) rr = fit_best_resonator(self.fr,self.s21,errors=errors)#,min_a=0) self.Q_i = rr.Q_i self.params = rr.result.params self.ch = tones[tone_index] self.nsamp = nsamp[tone_index] self.f0 = self.fs*self.ch/float(self.nsamp) self.tss_raw = ts*np.exp(-1j*self.f0*phasecorr + 2j*np.pi*self.delay*self.f0) self.tsl_raw = fftfilt(scipy.signal.firwin(filtlen,1.0/filtlen), self.tss_raw)[filtlen:] self.s0 = self.tss_raw.mean() #rr.model(f=self.f0) self.sres = rr.model(f=rr.f_0) self.ds0 = rr.model(f=self.f0+1e-6)-rr.model(f=self.f0) #tsl_hz = np.real((self.tsl_raw - self.s0)/self.ds0) #self.ds0s = rr.model(f=self.f0+(tsl_hz+1)*1e-6)-rr.model(f=self.f0+tsl_hz*1e-6) self.frm = np.linspace(self.fr.min(),self.fr.max(),1000) self.s21m = rr.model(f=self.frm) - self.s0 self.tss = (self.tss_raw-self.s0) * np.exp(-1j*np.angle(self.ds0)) self.tss = self.tss/np.abs(self.ds0)/(self.f0*1e6) #self.tss = (self.tss_raw[:len(self.tsl_raw)] - self.tsl_raw)/self.ds0s fr,S,evals,evects,angles,piq = iqnoise.pca_noise(self.tss, NFFT=None, Fs=self.fs*1e6/(2*self.nfft)) self.pca_fr = fr self.pca_S = S self.pca_evals = evals self.pca_evects = evects self.pca_angles = angles self.pca_piq = piq self.prr_fine,self.fr_fine = mlab.psd(self.tss.real,NFFT=2**18,window=mlab.window_none,Fs=self.fs*1e6/(2*self.nfft)) self.pii_fine,fr = mlab.psd(self.tss.imag,NFFT=2**18,window=mlab.window_none,Fs=self.fs*1e6/(2*self.nfft)) self.prr_coarse,self.fr_coarse = mlab.psd(self.tss.real,NFFT=2**12,window=mlab.window_none,Fs=self.fs*1e6/(2*self.nfft)) self.pii_coarse,fr = mlab.psd(self.tss.imag,NFFT=2**12,window=mlab.window_none,Fs=self.fs*1e6/(2*self.nfft)) self.tss_raw = self.tss_raw[:2048].copy() self.tss = self.tss[:2048].copy() self.tsl_raw = self.tsl_raw[::(filtlen/4)].copy()
def _restore_resonator_model(self): self._resonator_model = fit_best_resonator(self.sweep_freqs_MHz,self.sweep_s21,errors=self.sweep_errors, delay_estimate=self.fit_params['delay'].value)
def __init__(self,sweep_filename,sweep_group_index=0,timestream_filename=None,timestream_group_index=0, resonator_index=0,low_pass_cutoff_Hz=4.0, dac_chain_gain = -49, delay_estimate=-7.29, deglitch_threshold=5, cryostat=None, mask_sweep_indicies=None): """ sweep_filename : str NetCDF4 file with at least the sweep data. By default, this is also used for the timestream data. sweep_group_index : int (default 0) Index of the sweep group to process timestream_filename : str or None (optional) If None, use sweep_filename for the timestream data otherwise, this is the NetCDF4 file with the timestream data timestream_group_index : int (default 0) Index of the timestream group to process resonator_index : int (default 0) index of the resonator to process data for low_pass_cutoff_Hz : float Cutoff frequency used for low pass filtering the timeseries for display dac_chain_gain : float Estimate of the gain from output of DAC to device. Default value of -49 represents -2 dB loss intrinsic to analog signal conditioning board, 7 dB misc cable loss and 40 dB total cold attenuation. delay_estimate : float Estimate of basic cable delay to help fitting proceed more smoothly. Default value is appropriate for the wideband noise firmware deglitch_threshold : float Threshold for glitch detection in units of median absolute deviation. cryostat : str (Optional) Override the cryostat used to take this data. By default, the cryostat is guessed based on the machine you are processing data on. The guess is made by the get_experiment_info_at function """ self.sweep_filename = sweep_filename if timestream_filename: self.timestream_filename = timestream_filename else: self.timestream_filename = self.sweep_filename self.sweep_group_index = sweep_group_index self.timestream_group_index = timestream_group_index self._sweep_file = None self._timestream_file = None self.sweep_epoch = self.sweep.start_epoch pkg1,pkg2,load1,load2 = get_temperatures_at(self.sweep.start_epoch) self.sweep_primary_package_temperature = pkg1 self.sweep_secondary_package_temperature = pkg2 self.sweep_primary_load_temperature = load1 self.sweep_secondary_load_temperature = load2 self.start_temp = self.sweep_primary_package_temperature self.resonator_index = resonator_index description,is_dark,optical_load = experiments.get_experiment_info_at(self.sweep_epoch, cryostat=cryostat) self.chip_name = description self.is_dark = is_dark self.optical_load = optical_load self.dac_chain_gain = dac_chain_gain try: self.atten, self.total_dac_atten = self._sweep_file.get_effective_dac_atten_at(self.sweep_epoch) self.power_dbm = dac_chain_gain - self.total_dac_atten except: print "failed to find attenuator settings" self.atten = np.nan self.total_dac_atten = np.nan self.power_dbm = np.nan self.sweep_freqs_MHz, self.sweep_s21, self.sweep_errors = self.sweep.select_by_index(resonator_index) # find the time series that was measured closest to the sweep frequencies # this is a bit sloppy... timestream_index = np.argmin(abs(self.timestream.measurement_freq-self.sweep_freqs_MHz.mean())) self.timestream_index = timestream_index original_timeseries = self.timestream.get_data_index(timestream_index) self.adc_sampling_freq_MHz = self.timestream.adc_sampling_freq[timestream_index] self.noise_measurement_freq_MHz = self.timestream.measurement_freq[timestream_index] self.nfft = self.timestream.nfft[timestream_index] self.timeseries_sample_rate = self.timestream.sample_rate[timestream_index] self.timestream_epoch = self.timestream.epoch[timestream_index] self.timestream_duration = original_timeseries.shape[0]/self.timeseries_sample_rate # The following hack helps fix a long standing timing bug which was recently fixed/improved if self.timestream_epoch < 1399089567: self.timestream_epoch -= self.timestream_duration # end hack self.timestream_temperatures_sample_times = np.arange(self.timestream_duration) pkg1,pkg2,load1,load2 = get_temperatures_at(self.timestream_epoch + self.timestream_temperatures_sample_times) self.timestream_primary_package_temperature = pkg1 self.timestream_secondary_package_temperature = pkg2 self.timestream_primary_load_temperature = load1 self.timestream_secondary_load_temperature = load2 self.end_temp = self.timestream_primary_package_temperature[-1] # We can use the timestream measurement as an additional sweep point. # We average only the first 2048 points of the timeseries to avoid any drift. if False: self.sweep_freqs_MHz = np.hstack((self.sweep_freqs_MHz,[self.noise_measurement_freq_MHz])) self.sweep_s21 = np.hstack((self.sweep_s21,[original_timeseries[:2048].mean()])) self.sweep_errors = np.hstack((self.sweep_errors, [original_timeseries[:2048].real.std()/np.sqrt(2048) +1j*original_timeseries[:2048].imag.std()/np.sqrt(2048)])) # Now put all the sweep data in increasing frequency order so it plots nicely order = self.sweep_freqs_MHz.argsort() self.sweep_freqs_MHz = self.sweep_freqs_MHz[order] self.sweep_s21 = self.sweep_s21[order] self.sweep_errors = self.sweep_errors[order] if mask_sweep_indicies is None: rr = fit_best_resonator(self.sweep_freqs_MHz,self.sweep_s21,errors=self.sweep_errors,delay_estimate=delay_estimate) else: mask = np.ones(self.sweep_s21.shape,dtype=np.bool) mask[mask_sweep_indicies] = False rr = fit_best_resonator(self.sweep_freqs_MHz[mask],self.sweep_s21[mask],errors=self.sweep_errors[mask],delay_estimate=delay_estimate) self._resonator_model = rr self.Q_i = rr.Q_i self.fit_params = rr.result.params decimation_factor = self.timeseries_sample_rate/low_pass_cutoff_Hz normalized_timeseries = rr.normalize(self.noise_measurement_freq_MHz,original_timeseries) self.low_pass_normalized_timeseries = low_pass_fir(normalized_timeseries, num_taps=1024, cutoff=low_pass_cutoff_Hz, nyquist_freq=self.timeseries_sample_rate, decimate_by=decimation_factor) self.normalized_timeseries_mean = normalized_timeseries.mean() projected_timeseries = rr.project_s21_to_delta_freq(self.noise_measurement_freq_MHz,normalized_timeseries, s21_already_normalized=True) # calculate the number of samples for the deglitching window. # the following will be the next power of two above 1 second worth of samples window = int(2**np.ceil(np.log2(self.timeseries_sample_rate))) # reduce the deglitching window if we don't have enough samples if window > projected_timeseries.shape[0]: window = projected_timeseries.shape[0]//2 self.deglitch_window = window self.deglitch_threshold = deglitch_threshold if deglitch_threshold: deglitched_timeseries = deglitch_window(projected_timeseries,window,thresh=deglitch_threshold) else: deglitched_timeseries = projected_timeseries self.low_pass_projected_timeseries = low_pass_fir(deglitched_timeseries, num_taps=1024, cutoff=low_pass_cutoff_Hz, nyquist_freq=self.timeseries_sample_rate, decimate_by=decimation_factor) self.low_pass_timestep = decimation_factor/self.timeseries_sample_rate self.normalized_model_s21_at_meas_freq = rr.normalized_model(self.noise_measurement_freq_MHz) self.normalized_model_s21_at_resonance = rr.normalized_model(rr.f_0) self.normalized_ds21_df_at_meas_freq = rr.approx_normalized_gradient(self.noise_measurement_freq_MHz) self.sweep_normalized_s21 = rr.normalize(self.sweep_freqs_MHz,self.sweep_s21) self.sweep_model_freqs_MHz = np.linspace(self.sweep_freqs_MHz.min(),self.sweep_freqs_MHz.max(),1000) self.sweep_model_normalized_s21 = rr.normalized_model(self.sweep_model_freqs_MHz) self.sweep_model_normalized_s21_centered = self.sweep_model_normalized_s21 - self.normalized_timeseries_mean fractional_fluctuation_timeseries = deglitched_timeseries / (self.noise_measurement_freq_MHz*1e6) self._fractional_fluctuation_timeseries = fractional_fluctuation_timeseries fr,S,evals,evects,angles,piq = iqnoise.pca_noise(fractional_fluctuation_timeseries, NFFT=None, Fs=self.timeseries_sample_rate) self.pca_freq = fr self.pca_S = S self.pca_eigvals = evals self.pca_eigvects = evects self.pca_angles = angles self.pca_piq = piq self.freqs_coarse,self.prr_coarse,self.pii_coarse = self.get_projected_fractional_fluctuation_spectra(NFFT=2**12) self._normalized_timeseries = normalized_timeseries[:2048].copy() self._close_files()
def extract_and_pickle(nc_filename): """ The format is that the file contains equal numbers of sweeps and timestreams. The first sweep is used to locate the resonances and is taken with the source off at the lowest power level, i.e. the maximum attenuation. The first timestream is taken under the same conditions except that the source is modulated. Subsequent sweeps and timestreams are paired. :param nc_filename: the file name of the netCDF4 file with the above format. :return: a dictionary """ try: all_noise_on = [] all_noise_off = [] all_noise_modulated = [] all_coarse_sweep_params = [] coarse_sweep_index = 0 modulated_timestream_index = 0 print("Processing {}".format(nc_filename)) rnc = ReadoutNetCDF(nc_filename) resonator_indices = sorted(set(rnc.sweeps[0].index)) n_attenuations = len(rnc.sweeps) - 1 for resonator_index in resonator_indices: noise_on = [] for on_index in range(1, n_attenuations, 2): noise_on.append( SweepNoiseMeasurement(nc_filename, resonator_index=resonator_index, sweep_group_index=on_index, timestream_group_index=on_index)) all_noise_on.extend(noise_on) noise_off = [] for off_index in range(2, n_attenuations + 1, 2): noise_off.append( SweepNoiseMeasurement(nc_filename, resonator_index=resonator_index, sweep_group_index=off_index, timestream_group_index=off_index)) all_noise_off.extend(noise_off) # Create the modulated measurement from the modulated timestream and the noise off sweep at the same power. # Skip deglitching. attenuations = [snm.atten for snm in noise_off] off_max_attenuation_index = 1 + 2 * attenuations.index( max(attenuations)) + 1 noise_modulated = SweepNoiseMeasurement( nc_filename, resonator_index=resonator_index, sweep_group_index=off_max_attenuation_index, timestream_group_index=modulated_timestream_index, deglitch_threshold=None) noise_modulated.folded_projected_timeseries = noise_modulated.projected_timeseries.reshape( (-1, noise_modulated.timestream_modulation_period_samples)) folded = noise_modulated.folded_projected_timeseries.mean(0) high, low, rising_edge = find_high_low(folded) noise_modulated.folded_projected_timeseries = np.roll( noise_modulated.folded_projected_timeseries, -rising_edge, axis=1) noise_modulated.folded_normalized_timeseries = np.roll( noise_modulated.normalized_timeseries.reshape( (-1, noise_modulated.timestream_modulation_period_samples)), -rising_edge, axis=1) all_noise_modulated.append(noise_modulated) # Add the ZBD voltage from the modulated timestream to the modulated and static on measurements: zbd_voltage = rnc.timestreams[ modulated_timestream_index].zbd_voltage[0] noise_modulated.zbd_voltage = zbd_voltage for snm in noise_on: snm.zbd_voltage = zbd_voltage # Save only the Parameters object from a fit to the coarse sweep. freq, s21, err = rnc.sweeps[coarse_sweep_index].select_by_index( resonator_index) coarse_resonator = fit_best_resonator(freq, s21, errors=err) all_coarse_sweep_params.append(coarse_resonator.result.params) rnc.close() data = { 'noise_on_measurements': all_noise_on, 'noise_off_measurements': all_noise_off, 'noise_modulated_measurements': all_noise_modulated, 'coarse_sweep_params': all_coarse_sweep_params } # We decided to keep the .pkl files in /home/data regardless of origin. pkl_filename = os.path.join( '/home/data/pkl', os.path.splitext(os.path.split(nc_filename)[1])[0] + '.pkl') save_noise_pkl(pkl_filename, data) print("Saved {}".format(pkl_filename)) except KeyboardInterrupt: print("Aborting {}".format(nc_filename))