def test_revert_1D_twice(self): arrs = {} with Measurement("revert_1D_twice") as msmt: p_measure1 = Parameter('p_measure1', set_cmd=None) p_measure2 = Parameter('p_measure2', set_cmd=None) p_sweep = Parameter('p_sweep', set_cmd=None) for k, val in enumerate(Sweep(p_sweep.sweep(0, 1, 0.1))): arr1 = arrs.setdefault(msmt.action_indices, np.zeros(msmt.loop_shape)) p_measure1(1) arr1[k] = msmt.measure(p_measure1) arr2 = arrs.setdefault(msmt.action_indices, np.zeros(msmt.loop_shape)) p_measure2(2) arr2[k] = msmt.measure(p_measure2) if k == 5: msmt.revert(2) p_measure1(3) p_measure2(4) arr1[k] = msmt.measure(p_measure1) arr2[k] = msmt.measure(p_measure2) verify_msmt(msmt, arrs)
def test_double_multi_parameter(self): multi_parameter1 = MultiParameterTest("multi_param1") multi_parameter2 = MultiParameterTest("multi_param2") multi_parameter2.values = (2,3,4) sweep_param = Parameter("sweep_param", set_cmd=None) with Measurement("test_double_multi_parameter") as msmt: for val in Sweep(sweep_param.sweep(0, 10, 1)): msmt.measure(multi_parameter1) msmt.measure(multi_parameter2) self.assertEqual(msmt.data_groups[(0, 0)].name, "multi_param1") self.assertEqual(msmt.data_groups[(0, 1)].name, "multi_param2") verification_arrays = { (0, 0, 0): [1] * 11, (0, 0, 1): [2] * 11, (0, 0, 2): [3] * 11, (0, 1, 0): [2] * 11, (0, 1, 1): [3] * 11, (0, 1, 2): [4] * 11, } self.assertListEqual(list(verification_arrays), list(msmt.data_arrays)) verify_msmt(msmt, verification_arrays=verification_arrays)
def test_mask_parameter_attr(self): p = Parameter("masking_param", set_cmd=None, initial_value=1) p.x = 1 with Measurement("mask_parameter_attr") as msmt: self.assertEqual(p.x, 1) msmt.mask(p, x=2) self.assertEqual(len(msmt._masked_properties), 1) self.assertDictEqual( msmt._masked_properties[0], { "type": "attr", "obj": p, "attr": "x", "original_value": 1, "value": 2, }, ) for k in Sweep(range(10), "repetition"): msmt.measure({"a": 3, "b": 4}, "acquire_values") self.assertEqual(p.x, 2) self.assertEqual(p(), 1) self.assertEqual(p.x, 2) self.assertEqual(p.x, 1) self.assertEqual(len(msmt._masked_properties), 0)
def test_scan1D(self, verbose=0): p = Parameter('p', set_cmd=None) q = Parameter('q', set_cmd=None) r = VoltageDivider(p, 4) _ = MultiParameter(instrumentName('multi_param'), [p, q]) gates = VirtualIVVI( name=qtt.measurements.scans.instrumentName('gates'), model=None) station = qcodes.Station(gates) station.gates = gates if verbose: print('test_scan1D: running scan1D') scanjob = scanjob_t({'sweepdata': dict( {'param': p, 'start': 0, 'end': 10, 'step': 2, 'wait_time': 0.}), 'minstrument': [r]}) _ = scan1D(station, scanjob, liveplotwindow=False, verbose=0) scanjob = scanjob_t({'sweepdata': dict( {'param': p, 'start': 0, 'end': 10, 'step': 2, 'wait_time': 0.}), 'minstrument': [q, r]}) _ = scan1D(station, scanjob, liveplotwindow=False, verbose=0) scanjob = scanjob_t({'sweepdata': dict( {'param': 'dac1', 'start': 0, 'end': 10, 'step': 2}), 'minstrument': [r]}) _ = scan1D(station, scanjob, liveplotwindow=False, verbose=0) scanjob = scanjob_t({'sweepdata': dict( {'param': {'dac1': 1}, 'start': 0, 'range': 10, 'step': 2}), 'minstrument': [r]}) data = scan1D(station, scanjob, liveplotwindow=False, verbose=0, extra_metadata={'hi': 'world'}) self.assertTrue('hi' in data.metadata) gates.close()
def test_old_loop_1D_2D(self): self.p_sweep2 = Parameter("p_sweep2", set_cmd=None) loop = Loop(self.p_sweep.sweep(0, 5, 1)).each( self.p_measure, Loop(self.p_sweep2.sweep(0, 5, 1)).each(self.p_measure) ) loop.run(name="old_loop_1D_2D", thread=False)
def test_revert_multi_parameter(self): multi_parameter = MultiParameterTest("multi_param") sweep_param = Parameter("sweep_param", set_cmd=None) with Measurement("test_multi_parameter") as msmt: for k, val in enumerate(Sweep(sweep_param.sweep(0, 10, 1))): msmt.measure(multi_parameter) if k == 4: msmt.revert() multi_parameter.values = (2,3,4) msmt.measure(multi_parameter) multi_parameter.values = (1,2,3) self.assertEqual(msmt.data_groups[(0, 0)].name, "multi_param") verification_arrays = { (0, 0, 0): [1] * 11, (0, 0, 1): [2] * 11, (0, 0, 2): [3] * 11, } for key, val in verification_arrays.items(): val[4] += 1 verify_msmt(msmt, verification_arrays=verification_arrays)
def init(): a_property = Parameter('a_property', set_cmd=None, get_cmd=None, initial_value=0) another_property = Parameter('another_property', set_cmd=None, get_cmd=None, initial_value='abc', vals=validators.Strings()) station = Station(a_property, another_property) return station
def test_with_set_conversion_and_initial_value_given(): value = 36 p = Parameter('testparam', set_cmd=None, get_cmd=None) c = ConversionParameter('test_conversion_parameter', p, lambda x: x, set_conv=lambda x: x * 2, initial_value=value) assert value * 2 == p.get_latest() assert value == c.get_latest()
def test_measurement_except_final_actions_no_fail(self): p_except = Parameter(initial_value=42, set_cmd=None) p_final = Parameter(initial_value=41, set_cmd=None) with Measurement('measurement_fail') as msmt: msmt.except_actions.append(partial(p_except, 43)) msmt.final_actions.append(partial(p_final, 40)) self.assertEqual(p_except(), 42) self.assertEqual(p_final(), 40)
def test_with_set_conversion(): p = Parameter('testparam', set_cmd=None, get_cmd=None) c = ConversionParameter('test_conversion_parameter', p, lambda x: x, set_conv=lambda x: x * 2, unit='V') new_value = 25 c.set(new_value) assert new_value * 2 == p.get_latest() assert new_value == c.get_latest()
def test_simple_measurement_verification_no_error_parameter(self): msmt_param = Parameter("msmt_param", get_cmd=np.random.rand) msmt_param2 = Parameter("msmt_param", get_cmd=np.random.rand) # Notice we give the same name with Measurement( "test_simple_measurement_verification_no_error_parameter" ) as msmt: for k, _ in enumerate(Sweep(range(10), "sweep_param")): if k < 7: msmt.measure(msmt_param) else: msmt.measure(msmt_param2)
def test_simple_measurement_verification_error_parameter(self): msmt_param = Parameter("msmt_param", get_cmd=np.random.rand) different_msmt_param = Parameter("different_msmt_param", get_cmd=np.random.rand) with self.assertRaises(RuntimeError): with Measurement( "test_simple_measurement_verification_error_parameter" ) as msmt: for k, _ in enumerate(Sweep(range(10), "sweep_param")): if k < 7: msmt.measure(msmt_param) else: msmt.measure(different_msmt_param)
def test_measurement_except_final_actions(self): p_except = Parameter(initial_value=42, set_cmd=None) p_final = Parameter(initial_value=41, set_cmd=None) with self.assertRaises(RuntimeError): with Measurement('measurement_fail') as msmt: msmt.except_actions.append(partial(p_except, 43)) msmt.final_actions.append(partial(p_final, 40)) raise RuntimeError('help') self.assertEqual(p_except(), 43) self.assertEqual(p_final(), 40)
def test_measure_node_dict(self): arrs = {} node = self.DictResultsNode("measurable_node") p_sweep = Parameter("sweep", set_cmd=None) with Measurement("measure_node") as msmt: for k, val in enumerate(Sweep(p_sweep.sweep(0, 1, 0.1))): results = msmt.measure(node.get) # Save results to verification arrays for kk, result in enumerate(results.values()): arrs.setdefault((0, 0, kk), np.zeros(msmt.loop_shape)) arrs[(0, 0, kk)][k] = result
def _mk_frequency(self, max_frequency: float) -> Parameter: frequency = Parameter( name="frequency", instrument=self, label="Frequency", unit="Hz", vals=validators.Numbers(min_value=250e3, max_value=max_frequency), get_cmd="RA:frequency", get_parser=int, set_cmd=self._set_frequency, set_parser=lambda freq: str(int(freq)), ) frequency.__doc__ = "The RF Frequency in Hz." return frequency
def _mk_sweep_step_frequency(self, max_frequency: float) -> Parameter: sweep_step_frequency = Parameter( name="sweep_step_frequency", instrument=self, label="Sweep step", unit="Hz", vals=validators.Numbers(min_value=0, max_value=max_frequency), get_cmd=f"RA:{_CMD_TO_JSON_MAPPING['S3']}", get_parser=int, set_cmd="S3{}", set_parser=lambda freq: str(int(freq)), ) sweep_step_frequency.__doc__ = "Sweep step frequency in Hz." return sweep_step_frequency
def test_new_loop_2D(self): arrs = {} self.p_sweep2 = Parameter("p_sweep2", set_cmd=None) with Measurement("new_loop_1D_double") as msmt: for k, val in enumerate(Sweep(self.p_sweep2.sweep(0, 1, 0.1))): for kk, val2 in enumerate(Sweep(self.p_sweep.sweep(0, 1, 0.1))): self.assertEqual(msmt.loop_shape, (11, 11)) arr = arrs.setdefault( msmt.action_indices, np.zeros(msmt.loop_shape) ) arr[k, kk] = msmt.measure(self.p_measure) verify_msmt(msmt, arrs)
def test_measure_parameter_array_2D(self): arrs = {} p_measure = Parameter("p_measure", get_cmd=lambda: np.random.rand(5, 12)) with Measurement("new_loop_parameter_array_2D") as msmt: for k, val in enumerate(Sweep(self.p_sweep.sweep(0, 1, 0.1))): arr = arrs.setdefault( msmt.action_indices, np.zeros(msmt.loop_shape + (5, 12)) ) result = msmt.measure(p_measure) arr[k] = result dataset = verify_msmt(msmt, arrs) # Perform additional test on set arrays set_array = np.broadcast_to(np.arange(5), (11, 5)) np.testing.assert_array_almost_equal( dataset.arrays["p_measure_set0_0_0"], set_array ) set_array = np.broadcast_to(np.arange(12), (11, 5, 12)) np.testing.assert_array_almost_equal( dataset.arrays["p_measure_set1_0_0_0"], set_array )
def test_dict_function_custom_name(self): arrs = {} p_sweep = Parameter("sweep", set_cmd=None) with Measurement("measure_node") as msmt: for k, val in enumerate(Sweep(p_sweep.sweep(0, 1, 0.1))): results = msmt.measure(self.dict_function, name="custom_name") # Save results to verification arrays for kk, result in enumerate(results.values()): arrs.setdefault((0, 0, kk), np.zeros(msmt.loop_shape)) arrs[(0, 0, kk)][k] = result self.assertEqual(msmt.data_groups[(0, 0)].name, "custom_name") verify_msmt(msmt, arrs)
def test_param_setter(): p = Parameter("p", unit="P", get_cmd=None, set_cmd=None) strr = parameter_setter(p) assert hasattr(strr, "getter_setter_decorated") _strr, table = strr() assert _strr(0) == {"p": 0} assert p.get() == 0 table.resolve_dependencies() assert table.nests == [["p"]] param_spec, = table.param_specs assert param_spec.name == "p" assert param_spec.unit == "P"
def __init__(self, awg, awg_number=0): """ Implements the common functionality of the AwgCommon for the Zurich Instruments HDAWG8 to be controlled by the virtual AWG. Note: Channels are zero based so channel '0' is output '1' on the physical device. Note: This backend is setup to work with grouping 1x8 where one awg controls 8 outputs. Args: awg (ZIHDAWG8): Instance of the QCoDeS ZIHDAWG8 driver. awg_number (int): The number of the AWG that is to be controlled. The ZI HDAWG8 has 4 AWGs and the default one is the first one (index 0). """ super().__init__('ZIHDAWG8', channel_numbers=list(range(0, 8)), marker_numbers=list(range(0, 8))) if type(awg).__name__ is not self._awg_name: raise AwgCommonError('The AWG does not correspond with {}'.format( self._awg_name)) self.__awg = awg self.__awg_number = awg_number self.__settings = { 'sampling_rate': Parameter(name='sampling_rate', unit='GS/s', set_cmd=self.update_sampling_rate, get_cmd=self.retrieve_sampling_rate) }
def test_mask_parameters_in_node(self): node = ParameterNode('node', use_as_attributes=True) node.p1 = Parameter(set_cmd=None, initial_value=1) node.p2 = Parameter(set_cmd=None, initial_value=2) node.p3 = 3 with Measurement('mask_parameters_in_node') as msmt: msmt.mask(node, p1=42, p2=43, p3=44) self.assertEqual(node.p1, 42) self.assertEqual(node.p2, 43) self.assertEqual(node.p3, 44) self.assertEqual(node.p1, 1) self.assertEqual(node.p2, 2) self.assertEqual(node.p3, 3)
def time_trace(interval_time, total_time=None, stop_condition=None): start_time = None # Set when we call "generator_function" if total_time is None: if stop_condition is None: raise ValueError("Either specify the total time or the stop " "condition") else: def stop_condition(): global start_time return time.time() - start_time > total_time def generator_function(): global start_time start_time = time.time() while not stop_condition(): yield time.time() - start_time time.sleep(interval_time) time_parameter = Parameter(name="time", unit="s", set_cmd=None, get_cmd=None) return sweep(time_parameter, generator_function)
def test_scan2D(verbose=0): p = Parameter('p', set_cmd=None) q = Parameter('q', set_cmd=None) r = VoltageDivider(p, 4) _ = MultiParameter(instrumentName('multi_param'), [p, q]) gates = VirtualIVVI( name=qtt.measurements.scans.instrumentName('gates'), model=None) station = qcodes.Station(gates) station.gates = gates if verbose: print('test_scan2D: running scan2D') scanjob = scanjob_t({'sweepdata': dict( {'param': p, 'start': 0, 'end': 10, 'step': 2}), 'minstrument': [r]}) scanjob['stepdata'] = dict( {'param': q, 'start': 24, 'end': 30, 'step': 1.}) _ = scan2D(station, scanjob, liveplotwindow=False, verbose=0) scanjob = scanjob_t({'sweepdata': dict({'param': { 'dac1': 1, 'dac2': .1}, 'start': 0, 'range': 10, 'step': 2}), 'minstrument': [r]}) scanjob['stepdata'] = dict( {'param': {'dac2': 1}, 'start': 24, 'range': 6, 'end': np.NaN, 'step': 1.}) _ = scan2D(station, scanjob, liveplotwindow=False, verbose=0) scanjob = scanjob_t({'sweepdata': dict( {'param': {'dac1': 1}, 'start': 0, 'range': 10, 'step': 2}), 'minstrument': [r]}) scanjob['stepdata'] = {'param': MultiParameter('multi_param', [gates.dac2, gates.dac3])} scanjob['stepvalues'] = np.array([[2 * i, 3 * i] for i in range(10)]) try: with warnings.catch_warnings(): warnings.simplefilter('ignore') data = scan2D(station, scanjob, liveplotwindow=False, verbose=0) except Exception as ex: print(ex) warnings.warn('MultiParameter test failed!') # not supported: try: scanjob = scanjob_t({'sweepdata': dict({'param': { 'dac1': 1}, 'start': 0, 'range': 10, 'step': 2, 'wait_time': 0.}), 'minstrument': [r]}) scanjob['stepdata'] = dict( {'param': q, 'start': 24, 'range': 6, 'end': np.NaN, 'step': 1.}) _ = scan2D(station, scanjob, liveplotwindow=False, verbose=0) except Exception as ex: if verbose: print('combination of Parameter and vector argument not supported') gates.close()
def generate_DB_file_with_some_runs(version=VERSION): """ Generate a .db-file with a handful of runs with some interdependent parameters """ # This function will run often on CI and re-generate the .db-files # That should ideally be a deterministic action # (although this hopefully plays no role) np.random.seed(0) vNfixturepath = os.path.join(utils.fixturepath, f'version{version}') os.makedirs(vNfixturepath, exist_ok=True) path = os.path.join(vNfixturepath, 'some_runs.db') if os.path.exists(path): os.remove(path) from qcodes.dataset.sqlite.database import connect from qcodes.dataset.measurements import Measurement from qcodes.dataset.experiment_container import Experiment from qcodes import Parameter connect(path) exp = Experiment(path_to_db=path, name='experiment_1', sample_name='no_sample_1') # Now make some parameters to use in measurements params = [] for n in range(5): params.append( Parameter(f'p{n}', label=f'Parameter {n}', unit=f'unit {n}', set_cmd=None, get_cmd=None)) # Set up an experiment meas = Measurement(exp) meas.register_parameter(params[0]) meas.register_parameter(params[1]) meas.register_parameter(params[2], basis=(params[0], )) meas.register_parameter(params[3], basis=(params[1], )) meas.register_parameter(params[4], setpoints=(params[2], params[3])) # Make a number of identical runs for _ in range(10): with meas.run() as datasaver: for x in np.random.rand(10): for y in np.random.rand(10): z = np.random.rand() datasaver.add_result((params[0], 0), (params[1], 1), (params[2], x), (params[3], y), (params[4], z))
def mk_tuple(name): param = Parameter(name, set_cmd=None, get_cmd=None) def getter(): return {name: param.get()} return param, getter, ParamTable([ParamSpec(name, "numeric")])
def test_scan1D_no_gates(self): p = Parameter('p', set_cmd=None) r = VoltageDivider(p, 4) scanjob = scanjob_t({'sweepdata': {'param': p, 'start': 0, 'end': 10, 'step': 2}, 'minstrument': [r]}) station=qcodes.Station() dataset = scan1D(station, scanjob, liveplotwindow=False, verbose=0) default_record_label = 'scan1D' self.assertTrue(default_record_label in dataset.location)
def test_unmask_parameter(self): p1 = Parameter("masking_param1", set_cmd=None, initial_value=1) p2 = Parameter("masking_param2", set_cmd=None, initial_value=1) with Measurement("mask_parameter") as msmt: msmt.mask(p1, 2) msmt.mask(p2, 3) self.assertEqual(p1(), 2) self.assertEqual(p2(), 3) msmt.unmask(p2) self.assertEqual(p1(), 2) self.assertEqual(p2(), 1) self.assertEqual(p1(), 1) self.assertEqual(p2(), 1)
def test_unmask_parameter_attr(self): p = Parameter("masking_param", set_cmd=None, initial_value=1) p.x = 1 with Measurement("mask_parameter") as msmt: msmt.mask(p, 2) msmt.mask(p, x=3) self.assertEqual(p(), 2) self.assertEqual(p.x, 3) msmt.unmask(p, attr="x") self.assertEqual(p(), 2) self.assertEqual(p.x, 1) self.assertEqual(p(), 1) self.assertEqual(p.x, 1)
def test_nested_function(self): arrs = {} p_sweep = Parameter("sweep", set_cmd=None) with Measurement("measure_node") as msmt: for k, val in enumerate(Sweep(p_sweep.sweep(0, 1, 0.1))): results = {"result1": np.random.rand(), "result2": np.random.rand()} msmt.measure(partial(self.nested_function, results)) # Save results to verification arrays for kk, result in enumerate(results.values()): arrs.setdefault((0, 0, kk), np.zeros(msmt.loop_shape)) arrs[(0, 0, kk)][k] = result self.assertEqual(msmt.data_groups[(0, 0)].name, "nested_function_name") verify_msmt(msmt, arrs)