def test_multi_parameter(self): p = qcodes.Parameter('p', set_cmd=None) q = qcodes.Parameter('q', set_cmd=None) mp = MultiParameter('multi_param', [p, q]) mp.set([1, 2]) _ = mp.get() mp = CombiParameter('multi_param', [p, q]) mp.set([1, 3]) v = mp.get() self.assertTrue(v == 2)
def test_list_of_strings(experiment): """ Test saving list of strings via DataSaver """ p_values = ["X_Y", "X_X", "X_I", "I_I"] list_of_strings = list(np.random.choice(p_values, (10, ))) p = qc.Parameter('p', label='String parameter', unit='', get_cmd=None, set_cmd=None, initial_value='X_Y') meas = Measurement(experiment) meas.register_parameter(p, paramtype='text') with meas.run() as datasaver: datasaver.add_result((p, list_of_strings)) test_set = load_by_id(datasaver.run_id) expec_data = np.array([item for item in list_of_strings]) actual_data = test_set.get_parameter_data()["p"]["p"] try: np.testing.assert_array_equal(actual_data, expec_data) finally: test_set.conn.close()
def wrap_par_set_get(par): new_par = qc.Parameter(name=par.name, label=par.label, unit=par.unit) def wrap_set(val): par.set(val) par.get() new_par.set = wrap_set return new_par
def __init__(self, gate_names, gate_values=None, station=None, index=None, minstrument=None, virt_gates=None): """ Class representing a sensing dot We assume the sensing dot can be controlled by two barrier gates and a single plunger gate. An instrument to measure the current through the dot is provided by the minstrument argument. Args: gate_names (list): gates to be used gate_values (array or None): values to be set on the gates station (Qcodes station) minstrument (tuple or str or Parameter): measurement instrument to use. tuple of instrument and channel index index (None or int): deprecated fpga_ch (deprecated, int): index of FPGA channel to use for readout virt_gates (None or object): virtual gates object (optional) boxcar_filter_kernel_size (int): size of boxcar filter kernel to use in post-processing """ self.verbose = 1 self.gg = gate_names if gate_values is None: gate_values = [station.gates.get(g) for g in self.gg] self.sdval = gate_values self.targetvalue = np.NaN self.boxcar_filter_kernel_size = 1 self._selected_peak = None self._detune_axis = np.array([1, -1]) self._detune_axis = self._detune_axis / np.linalg.norm( self._detune_axis) self._debug = {} # store debug data self.name = '-'.join([s for s in self.gg]) self.goodpeaks = None self.station = station self.index = index self.minstrument = minstrument if index is not None: raise Exception('use minstrument argument') self.virt_gates = virt_gates self.data = {} self.plunger = qcodes.Parameter('plunger', get_cmd=self.plungervalue, set_cmd=self._set_plunger) # values for measurement if index is not None: self.valuefunc = station.components['keithley%d' % index].amplitude.get else: self.valuefunc = None
def wrap_par_remainder(par, remainder=1): new_par = qc.Parameter(name=par.name, label=par.label, unit=par.unit) def wrap_set(val): val = val % remainder par.set(val) par.get() new_par.set = wrap_set return new_par
class TestNoSorting(TestCase): """ (WilliamHPNielsen): I'm not too sure where this test belongs... It tests that parameters with non-sortable keys can be saved using the gnuplot formatter, so I guess it goes here. """ param = qcodes.Parameter(name='mixed_val_mapping_param', get_cmd=lambda: np.random.randint(1, 3), val_mapping={1: 1, '2': 2} ) def test_can_measure(self): qcodes.measure.Measure(self.param).run()
def test_string_and_date_data_in_array(experiment, p_values): p = qc.Parameter('p', label='String parameter', unit='', get_cmd=None, set_cmd=None, initial_value=p_values) meas = Measurement(experiment) meas.register_parameter(p, paramtype='array') with meas.run() as datasaver: datasaver.add_result((p, p.get())) actual_data = datasaver.dataset.get_parameter_data()["p"]["p"] np.testing.assert_array_equal( actual_data, p_values.reshape((1, *p_values.shape)) )
def test_datasaver_foul_input(experiment): meas = Measurement() meas.register_custom_parameter('foul', label='something unnatural', unit='Fahrenheit') foul_stuff = [qc.Parameter('foul'), set((1, 2, 3))] with meas.run() as datasaver: for ft in foul_stuff: with pytest.raises(ValueError): datasaver.add_result(('foul', ft))
def test_string(experiment): """ Test that we can save text into database via Measurement API """ p = qc.Parameter('p', label='String parameter', unit='', get_cmd=None, set_cmd=None, initial_value='some text') meas = Measurement(experiment) meas.register_parameter(p, paramtype='text') with meas.run() as datasaver: datasaver.add_result((p, "some text")) test_set = load_by_id(datasaver.run_id) assert test_set.get_data("p") == [["some text"]]
def test_string_with_wrong_paramtype(experiment): """ Test that an exception occurs when saving string data if when registering a string parameter the paramtype was not set to 'text' """ p = qc.Parameter('p', label='String parameter', unit='', get_cmd=None, set_cmd=None, initial_value='some text') meas = Measurement(experiment) # intentionally forget `paramtype='text'`, so that the default 'numeric' # is used, and an exception is raised later meas.register_parameter(p) with meas.run() as datasaver: msg = re.escape('Parameter p is of type "numeric", but got a ' "result of type <U9 (some text).") with pytest.raises(ValueError, match=msg): datasaver.add_result((p, "some text"))
def test_string_with_wrong_paramtype(experiment): """ Test that an exception occurs when saving string data if when registering a string parameter the paramtype was not set to 'text' """ p = qc.Parameter('p', label='String parameter', unit='', get_cmd=None, set_cmd=None, initial_value='some text') meas = Measurement(experiment) # intentionally forget `paramtype='text'`, so that the default 'numeric' # is used, and an exception is raised later meas.register_parameter(p) with meas.run() as datasaver: msg = "It is not possible to save a string value for parameter 'p' " \ "because its type class is 'numeric', not 'text'." with pytest.raises(ValueError, match=msg): datasaver.add_result((p, "some text"))
self.i = 2 def get_raw(self): self.i += 1 return (self.i, self.i + 100) now = str(datetime.datetime.now()) path = os.path.join(os.getcwd(), 'test.db') initialise_or_create_database_at(path) load_or_create_experiment('tutorial ' + now, 'no sample') my_param = MyCounter('test_instr') from qcodes.instrument.specialized_parameters import ElapsedTimeParameter x = qc.Parameter(name='x', label='Voltage_x', unit='V', set_cmd=None, get_cmd=None) y = qc.Parameter(name='y', label='Voltage_y', unit='V', set_cmd=None, get_cmd=None) timer = ElapsedTimeParameter('time') my_param_multi_test = dummy_multi_parameter_2dawg('param') from core_tools.GUI.keysight_videomaps.data_getter.scan_generator_Virtual import construct_1D_scan_fast, construct_2D_scan_fast, fake_digitizer param_1D = construct_1D_scan_fast("P2", 10, 10, 5000, True, None, fake_digitizer('test')) param_2D = construct_2D_scan_fast('P2', 10, 10, 'P5', 10, 10, 50000, True, None, fake_digitizer('test'))
class SoftSweepCtl(acquisition_controllers.PostIQCtl): """ An acquisition controller that allows fast software spec. The frequencies can be iterated through without stopping the alazar acquisition. Returns one IQ value per frequency. NOTE: you probably want to use at least 2 or 3 averages per point for this to work without glitches. Set the total number of buffers, and the buffers per block to determine the number of points and the number of averages, n_avgs = buffers / buffers_per_block. You will want to run this when the AWG runs a sequence that triggers the alazar n_avgs times in a row, but each of these trigger trains must be triggered (i.e., AWG is waiting for a trigger). Of course the trigger interval needs to slightly exceed the acquisition time per record, as usual. For determining how to advance from one sweep point to the next, you can specify the function ``next_point_trigger_func()``. Per default this does nothing, but the user can set it to a function that could play a trigger on the AWG. This depends on thow the setup is hooked up. """ sweep_vals = np.array([]) sweep_param = qcodes.Parameter('dummy_parameter', set_cmd=None) settling_time = 0 verbose = True @staticmethod def next_point_trigger_func(): return None def __init__(self, *arg, **kw): super().__init__(*arg, **kw) self._step = 0 def _settle(self): if self.settling_time > 0: time.sleep(self.settling_time) def _perform_step(self, num): """ Set generator to the i-th point whenever buffer_number // buffers_per_block increases. Takes into account that calls to this function lag 2 behind the actual acquisition. """ t0 = time.perf_counter() awg = qcodes.Station.default.awg # we have to increase num by 2: by the time this is called, the # alazar is already measuring the buffer that's 2 after the received one. # this is just a reality of the alazar we have to live with here. if ((num+2) % self.buffers_per_block()) == 0: self._step += 1 if self._step < len(self.sweep_vals): if self.verbose: print(f'Point {self._step + 1} ({self.sweep_vals[self._step]:1.5e})' + 10 * "", end='\r') self.sweep_param(self.sweep_vals[self._step]) self._settle() else: if self.verbose: print('Done!', end='\r') self.next_point_trigger_func() self.step_times[num] = (time.perf_counter() - t0)*1e3 def pre_acquire(self): """ Starts the acquisition. Sets the generator to the first point, triggers the AWG for the first time. """ super().pre_acquire() self.step_times = np.zeros(self.buffers_per_acquisition(), dtype=float) self.sweep_param(self.sweep_vals[0]) self._settle() self._step = 0 self.next_point_trigger_func() def buffer_done_callback(self, buffernum): """ This function is called every time the alazar returns buffer data. """ nextstep = buffernum self._perform_step(nextstep)
# v.X.scale = 1e8 * (v.amplitude.get()/lockinAmplitudeDivider) * 3.874e-5 # v.X.label = lockinLabels[i] # define extra functions #Qdevfit = qdev_fitter() # IEc def Q1Plungers_set(value): qdac.Q1iP(value) qdac.Q1gP(value) Q1Plungers = qc.Parameter('Q1Plungers', label='Q1Plungers', unit='V', set_cmd=Q1Plungers_set) def Q2Plungers_set(value): qdac.Q2iP(value) qdac.Q2gP(value) Q2Plungers = qc.Parameter('Q2Plungers', label='Q2 Plungers', unit='V', set_cmd=Q2Plungers_set) def Q4Plungers_set(value):
from qcodes.instrument.parameter import _BaseParameter from qcodes.data.data_set import DataSet from silq.tools.parameter_tools import create_set_vals from silq.tools.general_tools import SettingsClass, get_truth, \ clear_single_settings, JSONEncoder __all__ = [ 'Condition', 'TruthCondition', 'ConditionSet', 'Measurement', 'Loop0DMeasurement', 'Loop1DMeasurement', 'Loop2DMeasurement' ] logger = logging.getLogger(__name__) _dummy_parameter = qc.Parameter(name='msmt_idx', set_cmd=None, label='Measurement idx') class Condition: def __init__(self, **kwargs): pass def _JSONEncoder(self): """ Converts to JSON encoder for saving metadata Returns: JSON dict """ return JSONEncoder(self)
while True: target = (counter % (no_of_pulses)) + 2 awg.set_sqel_goto_target_index(1, target) counter += 1 yield stepper = step_awg_to_next_pulse(awg, len(hightimes)) def step_setter(value): next(stepper) step_param = qc.Parameter('Pulse width', label='Pulse width', unit='s', set_cmd=step_setter) #%% # At least this code must be run on every measurement # re-initialise the counter stepper = step_awg_to_next_pulse(awg, len(hightimes)) step_param.set = step_setter def make_things_right(): prepareZIUHFLI(zi, demod_freq,