def run_multipart_sweep(ri, length_seconds=0, state=None, description='', num_tones_read_at_once=32, verbose=False, **kwargs): num_tones = ri.tone_bins.shape[1] num_steps = num_tones // num_tones_read_at_once if num_steps == 0: num_steps = 1 indices_to_read = range(num_tones) parts = [] for step in range(num_steps): if verbose: print("running sweep step {} of {}.".format(step, num_steps)) parts.append( run_loaded_sweep(ri, length_seconds=length_seconds, state=state, description=description, bin_indices=indices_to_read[step::num_steps], **kwargs)) stream_arrays = core.MeasurementList() for part in parts: stream_arrays.extend(list(part.stream_arrays)) return basic.SweepArray(stream_arrays, state=state, description=description)
def run_sweep(ri, tone_banks, num_tone_samples, length_seconds=0, state=None, description='', verbose=False, wait_for_sync=0.1, **kwargs): """ Return a SweepArray acquired using the given tone banks. Parameters ---------- ri : RoachInterface An instance of a subclass. tone_banks : iterable of ndarray (float) An iterable of arrays (or a 2-D array) of frequencies to use for the sweep. num_tone_samples : int The number of samples in the playback buffer; must be a power of two. length_seconds : float The duration of each data stream; the default of 0 means the minimum unit of data that can be read out in the current configuration. state : dict The non-roach state to pass to the SweepArray. description : str A human-readable description of the measurement. verbose : bool If true, print progress messages. wait_for_sync : float Sleep for this time in seconds to let the ROACH sync finish. kwargs Keyword arguments passed to ri.get_measurement(). Returns ------- SweepArray """ stream_arrays = core.MeasurementList() if verbose: print("Measuring bank") for n, tone_bank in enumerate(tone_banks): if verbose: print n, sys.stdout.flush() ri.set_tone_freqs(tone_bank, nsamp=num_tone_samples) ri.select_fft_bins(np.arange(tone_bank.size)) # we wait a bit here to let the roach2 sync catch up. figuring this out still. time.sleep(wait_for_sync) stream_arrays.append( ri.get_measurement(num_seconds=length_seconds, **kwargs)) return basic.SweepArray(stream_arrays, state=state, description=description)
def run_loaded_sweep(ri, length_seconds=0, state=None, description='', tone_bank_indices=None, bin_indices=None, verbose=False, **kwargs): """ Return a SweepArray acquired using previously-loaded tones. Parameters ---------- ri : RoachInterface An instance of a subclass. length_seconds : float The duration of each data stream; the default of 0 means the minimum unit of data that can be read out in the current configuration. state : dict The non-roach state to pass to the SweepArray. description : str A human-readable description of the measurement. tone_bank_indices : numpy.ndarray[int] The indices of the tone banks to use in the sweep; the default is to use all existing. bin_indices : numpy.ndarray[int] The indices of the filterbank bins to read out; the default is to read out all bins. verbose : bool If true, print progress messages. kwargs Keyword arguments passed to ri.get_measurement(). Returns ------- SweepArray """ if tone_bank_indices is None: tone_bank_indices = np.arange(ri.tone_bins.shape[0]) if bin_indices is None: bin_indices = np.arange(ri.tone_bins.shape[1]) stream_arrays = core.MeasurementList() if verbose: print "Measuring bank:", for tone_bank_index in tone_bank_indices: if verbose: print tone_bank_index, sys.stdout.flush() ri.select_bank(tone_bank_index) ri.select_fft_bins(bin_indices) stream_arrays.append( ri.get_measurement(num_seconds=length_seconds, **kwargs)) return basic.SweepArray(stream_arrays, state=state, description=description)
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))
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())) time.sleep(wait)