def test_node_composite_add_origin():
original = utilities.fake_single_sweep_stream()
io = memory.Dictionary()
name = 'sweep_stream'
io.write(original, name)
ss = io.read(name)
ss_df = ss.to_dataframe()
for k, row in ss_df.iterrows():
assert row.io_class == 'Dictionary'
assert row.root_path is None
assert row.node_path == core.join('/', name)
sweep = io.read(core.join(name, 'sweep'))
stream = io.read(core.join(name, 'stream'))
composite = basic.SingleSweepStream(sweep=sweep, stream=stream)
composite_df = composite.to_dataframe()
for k, row in composite_df.iterrows():
assert row.io_class is None
assert row.root_path is None
assert row.node_path is None
assert row['sweep.io_class'] == 'Dictionary'
assert row['sweep.root_path'] is None
assert row['sweep.node_path'] == core.join('/', name, 'sweep')
assert row['stream.io_class'] == 'Dictionary'
assert row['stream.root_path'] is None
assert row['stream.node_path'] == core.join('/', name, 'stream')
def get_sweep_stream_list(self, deglitch=False):
result = []
for stream in self.stream_list:
sss = basic.SingleSweepStream(sweep=self.single_sweep,
stream=stream,
state=stream.state,
description=stream.description)
result.append(sss)
return result
def sweep_stream_set(self, number):
sweep = self.sweep.sweep(number)
on_sweep_stream = self.on_stream.stream(number)
mod_sweep_stream = self.mod_stream.stream(number)
try:
off_sweep_stream = self.off_stream.stream(number)
except AttributeError:
off_sweep_stream = None
if off_sweep_stream:
return (
basic.SingleSweepStream(sweep,
off_sweep_stream,
number=number,
state=self.state,
description=self.description),
basic.SingleSweepStream(sweep,
on_sweep_stream,
number=number,
state=self.state,
description=self.description),
basic.SingleSweepStream(sweep,
mod_sweep_stream,
number=number,
state=self.state,
description=self.description),
)
else:
return (
None,
basic.SingleSweepStream(sweep,
on_sweep_stream,
number=number,
state=self.state,
description=self.description),
basic.SingleSweepStream(sweep,
mod_sweep_stream,
number=number,
state=self.state,
description=self.description),
)
fine_sweep = acquire.run_loaded_sweep(
ri,
length_seconds=sweep_length_seconds,
tone_bank_indices=fine_indices)[0]
ri.select_bank(
np.argmin(np.abs(f_baseband_bin_center - f_baseband)))
ri.select_fft_bins(np.array([0]))
vpp_out = float_input(
"Enable the function generator output and enter the p-p voltage: "
)
vpp_resistor = float_input(
"Enter the p-p voltage across the resistor: ")
state['generator']['V_pp'] = vpp_out
state['resistor']['V_pp'] = vpp_resistor
logger.info(
"Recording {:.1f} s stream".format(stream_length_seconds))
stream = ri.get_measurement(num_seconds=stream_length_seconds,
demod=True)[0]
sweep_stream = basic.SingleSweepStream(sweep=fine_sweep,
stream=stream,
state=state)
npd.write(sweep_stream)
npd.write(ri.get_adc_measurement())
raw_input("Disable the function generator output.")
state['generator']['V_pp'] = 0
state['resistor']['V_pp'] = 0
finally:
npd.close()
print("Wrote {}".format(npd.root_path))
print("Elapsed time {:.0f} minutes.".format((time.time() - tic) / 60))
f_stream_MHz = ri.add_tone_freqs(np.array(
[f0_MHz, f0_MHz + f_stream_offset_MHz]),
overwrite_last=~is_first_loop)
# NB: it may be true that select_bank() has to be called before select_fft_bins()
ri.select_bank(num_sweep_tones)
ri.select_fft_bins(np.arange(f_stream_MHz.size))
logger.info(
"Recording {:.1f} s streams at MHz frequencies {}".format(
stream_length_seconds, f_stream_MHz))
stream_array = ri.get_measurement(
num_seconds=stream_length_seconds)
on_stream = stream_array[0]
off_stream = stream_array[1]
sweep_stream = basic.SingleSweepStream(
sweep=on_sweep,
stream=on_stream,
state=state,
description='f_0 = {:.1f}'.format(f0_MHz))
logger.debug("Writing on-resonance SingleSweepStream.")
ncf.write(sweep_stream)
logger.debug("Writing off-resonance SingleSweep.")
ncf.write(off_sweep)
logger.debug("Writing off-resonance SingleStream.")
ncf.write(off_stream)
# Record an ADCSnap with the stream tones playing.
logger.debug("Recording ADCSnap.")
adc_snap = ri.get_adc_measurement()
logger.debug("Writing ADCSnap.")
ncf.write(adc_snap)
finally:
ncf.close()
'frequency_b': 1e6 * ri.lo_valon.get_frequency_b()
}
sweep = acquire.run_loaded_sweep(
ri,
length_seconds=length_seconds_sweep,
tone_bank_indices=np.arange(num_tones_sweep),
state=state)[0]
f0_MHz_fit = 1e-6 * sweep.resonator.f_0
logger.info(
"Fit resonance frequency is {:.3f} MHz".format(f0_MHz_fit))
is_not_first_loop = (resonator_index > 0) or (
attenuation_index > 0) or (offset_index > 0)
f_stream_MHz = ri.add_tone_freqs(
np.array([f0_MHz_fit]), overwrite_last=is_not_first_loop)
ri.select_bank(num_tones_sweep)
ri.select_fft_bins(np.arange(f_stream_MHz.size))
time.sleep(wait)
logger.info("Recording {:.1f} s stream at {:.3f} MHz".format(
length_seconds_stream, f_stream_MHz[0]))
stream = ri.get_measurement(num_seconds=length_seconds_stream,
state=state)[0]
sss = basic.SingleSweepStream(sweep=sweep,
stream=stream,
state=state)
npd.write(sss)
npd.write(ri.get_adc_measurement())
finally:
npd.close()
print("Wrote {}".format(npd.root_path))
print("Elapsed time {:.0f} minutes.".format((time.time() - tic) / 60))