def test_io_list(): num_streams = 3 streams = core.MeasurementList( [utilities.CornerCases() for n in range(num_streams)]) io = memory.Dictionary() sweep = basic.SingleSweep(core.IOList()) io.write(sweep) sweep.streams.extend(streams) assert io.read(io.node_names()[0]) == basic.SingleSweep(streams)
current_f0s[problems + 1]) / 2.0 if np.any(np.diff(current_f0s) < 0.015): print "repeated problematic resonator collision:", current_f0s print "deltas:", np.diff(current_f0s) problems = np.flatnonzero(np.diff(current_f0s) < 0.015) + 1 current_f0s[problems] = (current_f0s[problems - 1] + current_f0s[problems + 1]) / 2.0 ri.set_tone_freqs(current_f0s, nsamp) ri.select_fft_bins(range(initial_f0s.shape[0])) hittite.on() ri.set_modulation_output(7) for n in range(100): ncf = new_nc_file(suffix='cw_sweep_hwp_step_%03d' % n) sweepstream = mmw_source_sweep.MMWSweepList(swpa, core.IOList(), state=setup.state()) ncf.write(sweepstream) hwp_motor.increment() for hittite_power in [0]: hittite.set_power(hittite_power) for freq in mmw_freqs: hittite.set_freq(freq / 12.) try: meas = ri.get_measurement(num_seconds=0.2) meas.state = setup.state(fast=True) print n, hittite_power, freq, meas.state.lockin.rms_voltage try: sweepstream.stream_list.append(meas)
offset_frequency = np.linspace(10, 200, 16) num_tone_samples = 2**15 dac_attenuation = 62 # The maximum lo_frequency = 3000 # Hardware conditioner = analog.HeterodyneMarkII() hw = hardware.Hardware(conditioner) ri = hardware_tools.r1_with_mk2() ri.initialize(use_config=False) ri.set_dac_attenuator(dac_attenuation) ri.set_lo(lomhz=lo_frequency) ri.set_tone_freqs(freqs=lo_frequency + offset_frequency, nsamp=num_tone_samples) ri.select_fft_bins(np.arange(offset_frequency.size)) assert np.all(ri.lo_valon.get_phase_locks()) # Acquire sweep = basic.SweepArray(core.IOList(), description="T_c measurement") name = 'sweep' npd = acquire.new_npy_directory(suffix='Tc') npd.write(sweep, name) try: while True: sweep.stream_arrays.append( ri.get_measurement(num_seconds=length_seconds, state=hw.state())) sleep(wait) finally: npd.close() print("Wrote {}".format(npd.root_path))
ri.set_dac_attenuator(attenuation) ri.set_tone_baseband_freqs(freqs=1e-6 * np.array([f_baseband[0, :]]), nsamp=2 ** tone_sample_exponent) time.sleep(1) tools.optimize_fft_gain(ri, fraction_of_maximum=0.5) time.sleep(1) sweep_array = acquire.run_sweep(ri=ri, tone_banks=1e-6 * (f_lo + f_baseband), num_tone_samples=2 ** tone_sample_exponent, length_seconds=sweep_length_seconds, state=hw.state()) fit_f_r = np.array([sweep_array[number].resonator.f_0 for number in range(sweep_array.num_channels)]) logger.info("Fit resonance frequencies [MHz] {}".format(', '.join( "{:.1f}".format(1e-6 * f_r) for f_r in fit_f_r))) fit_Q = [sweep_array[number].resonator.Q for number in range(sweep_array.num_channels)] logger.info("Fit quality factors {}".format(', '.join( '{:.3g}'.format(Q) for Q in fit_Q))) ri.set_tone_freqs(freqs=1e-6 * np.array(fit_f_r), nsamp=2 ** tone_sample_exponent) sweep_stream_list = basic.SweepStreamList(sweep=sweep_array, stream_list=core.IOList(), state={'band_index': band_index, 'num_dummy_frequencies': num_dummy_frequencies}) npd.write(sweep_stream_list) npd.write(ri.get_adc_measurement()) ri.set_modulation_output(7) time.sleep(3) # Let the lock-in catch up for hwp_index in range(num_hwp_angles): logger.info("Recording {:.1f} s stream with source modulating at HWP angle {:d} of {:d}".format( stream_length_seconds, hwp_index, num_hwp_angles)) sweep_stream_list.stream_list.append(ri.get_measurement(num_seconds=stream_length_seconds, state=hw.state())) logger.info("Incrementing HWP by {:d} steps".format(num_hwp_increments_per_angle)) for _ in range(num_hwp_increments_per_angle): hwp.increment() time.sleep(wait_between_increments) time.sleep(wait_between_angles)
"With {:.2f} fractional overlap, LO frequencies are separated by {:.1f} MHz" .format(overlap_fraction, 1e-6 * df_lo)) num_sweeps = int(np.ceil((f_stop - f_start) / df_lo)) logger.info("The {:d} sweeps span {:.1f} MHz to {:.1f} MHz".format( num_sweeps, 1e-6 * f_start, 1e-6 * (f_start + df_lo * num_sweeps))) f_baseband_all = (f_baseband_minimum + df_baseband * np.arange(num_waveforms * num_tones).reshape( (num_waveforms, num_tones), order='F')) #ri.set_tone_baseband_freqs(freqs=1e-6 * f_baseband_all, nsamp=2 ** tone_sample_exponent) f_lo_all = f_start - f_baseband_minimum + df_lo * np.arange(num_sweeps) # Run npd = acquire.new_npy_directory(suffix=suffix) tic = time.time() try: scan = basic.Scan(sweep_arrays=core.IOList()) npd.write(scan) ri.set_dac_attenuator(attenuation) for lo_index, f_lo in enumerate(f_lo_all): assert np.all(ri.adc_valon.get_phase_locks()) tools.set_and_attempt_external_phase_lock(ri=ri, f_lo=1e-6 * f_lo, f_lo_spacing=1e-6 * f_lo_resolution) if lo_index == 0: ri.set_tone_baseband_freqs(freqs=1e-6 * f_baseband_all[0, :], nsamp=2**tone_sample_exponent) ri.select_fft_bins( readout_selection=np.arange(ri.tone_bins.shape[1])) time.sleep(1) tools.optimize_fft_gain(ri)
print("Using {} simultaneous tones spanning {:.1f} MHz.".format(num_tones, 1e-6 * f_block)) f_center_MHz = 1e-6 * np.arange(f_start, f_stop, f_block) print("Block center frequencies in MHz: {}".format(', '.join(['{:.1f}'.format(f) for f in f_center_MHz]))) f_lo_offset_MHz = 1e-6 * (np.arange(-f_tone / 2, f_tone / 2, f_lo_resolution) - f_minimum) # This order covers the entire band then comes back to fill in the gaps. f_lo_MHz = (f_center_MHz[np.newaxis, :] + f_lo_offset_MHz[:, np.newaxis]).flatten() n_minimum = np.ceil(f_minimum / f_roach_resolution) step = np.floor(f_tone / f_roach_resolution) n_baseband = n_minimum + step * np.arange(num_tones) f_baseband_MHz = 1e-6 * n_baseband * f_roach_resolution # State state = {'cryostat': 'hpd', 'canceling_magnet': {'orientation': 'up', 'distance_from_base_mm': 25}} # Acquire ri.set_tone_baseband_freqs(freqs=f_baseband_MHz, nsamp=num_tone_samples) ri.select_fft_bins(np.arange(f_baseband_MHz.size)) sweep = basic.SweepArray(core.IOList(), state=state, description=acquire.script_code()) ncf = new_nc_file(suffix='lo_scan') ncf.write(sweep) try: for f_lo in make_iterable(f_lo_MHz): ri.set_lo(lomhz=f_lo, chan_spacing=1e-6 * f_lo_resolution) sweep.stream_arrays.append(ri.get_measurement(num_seconds=stream_seconds, state=state)) finally: ncf.close() print("Wrote {}".format(ncf.root_path)) print("Elapsed time {:.0f} minutes.".format((time.time() - tic) / 60))
fft_gains = [6, 7, 8, 9] tone_sample_exponent = 15 length_seconds = 0.1 wait = 10 # Hardware conditioner = analog.Baseband() shield = hardware.Thing(name='magnetic_shield_bucket', state={}) hw = hardware.Hardware(conditioner, shield) ri = r2baseband.Roach2Baseband(roachip=ROACH2_IP, adc_valon=ROACH2_VALON) ri.set_modulation_output('high') ri.set_tone_freqs(freqs=frequency, nsamp=2**tone_sample_exponent) # Run sweeps = [ basic.SweepArray(core.IOList(), description="T_c {:.1f} dB".format(attenuation)) for attenuation in attenuations ] ncf = acquire.new_nc_file(suffix='Tc') for sweep in sweeps: ncf.write(sweep) try: while True: for sweep, attenuation, fft_gain in zip(sweeps, attenuations, fft_gains): ri.set_fft_gain(fft_gain) ri.set_dac_attenuator(attenuation) sweep.stream_arrays.append( ri.get_measurement(num_seconds=length_seconds, state=hw.state()))
nsamp = 2**18 #going above 2**18 with 128 simultaneous tones doesn't quite work yet offsets = np.arange(-16,16)*512./nsamp mmw_freqs = np.linspace(140e9, 165e9, 500) ri.set_dac_atten(20) setup.hittite.off() ri.set_modulation_output('high') tic = time.time() ncf = new_nc_file(suffix='mmw_source_sweep') swpa = acquire.run_sweep(ri, tone_banks=initial_f0s[None,:] + offsets[:,None], num_tone_samples=nsamp, length_seconds=0, verbose=True, ) sweepstream = mmw_source_sweep.MMWSweepList(swpa, core.IOList(), state=setup.state()) ncf.write(sweepstream) current_f0s = [] for sidx in range(initial_f0s.shape[0]): swp = swpa.sweep(sidx) res = swp.resonator print res.f_0, res.Q, res.current_result.redchi, (initial_f0s[sidx]*1e6-res.f_0) if np.abs(res.f_0 - initial_f0s[sidx]*1e6) > 200e3: current_f0s.append(initial_f0s[sidx]*1e6) print "using original frequency for ",initial_f0s[sidx] else: current_f0s.append(res.f_0) print "fits complete", (time.time()-tic)/60. current_f0s = np.array(current_f0s)/1e6 current_f0s.sort() if np.any(np.diff(current_f0s)<0.015):