def test_get_parameter_data_independent_parameters(
standalone_parameters_dataset):
ds = standalone_parameters_dataset
params = mut.get_non_dependencies(ds.conn, ds.run_id)
expected_toplevel_params = ['param_1', 'param_2', 'param_3']
assert params == expected_toplevel_params
data = mut.get_parameter_data(ds.conn, ds.table_name)
assert len(data.keys()) == len(expected_toplevel_params)
expected_names = {}
expected_names['param_1'] = ['param_1']
expected_names['param_2'] = ['param_2']
expected_names['param_3'] = ['param_3', 'param_0']
expected_shapes = {}
expected_shapes['param_1'] = [(10**3, )]
expected_shapes['param_2'] = [(10**3, )]
expected_shapes['param_3'] = [(10**3, )] * 2
expected_values = {}
expected_values['param_1'] = [np.arange(10000, 10000 + 1000)]
expected_values['param_2'] = [np.arange(20000, 20000 + 1000)]
expected_values['param_3'] = [
np.arange(30000, 30000 + 1000),
np.arange(0, 1000)
]
verify_data_dict(data, expected_toplevel_params, expected_names,
expected_shapes, expected_values)
def get_parameter_data(
self,
*params: Union[str, ParamSpec, _BaseParameter],
start: Optional[int] = None,
end: Optional[int] = None) -> Dict[str, Dict[str, numpy.ndarray]]:
"""
Returns the values stored in the DataSet for the specified parameters
and their dependencies. If no paramerers are supplied the values will
be returned for all parameters that are not them self dependencies.
The values are returned as a dictionary with names of the requested
parameters as keys and values consisting of dictionaries with the
names of the parameters and its dependencies as keys and numpy arrays
of the data as values. If some of the parameters are stored as arrays
the remaining parameters are expanded to the same shape as these.
Apart from this expansion the data returned by this method
is the transpose of the date returned by `get_data`.
If provided, the start and end arguments select a range of results
by result count (index). If the range is empty - that is, if the end is
less than or equal to the start, or if start is after the current end
of the DataSet – then a list of empty arrays is returned.
Args:
*params: string parameter names, QCoDeS Parameter objects, and
ParamSpec objects. If no parameters are supplied data for
all parameters that are not a dependency of another
parameter will be returned.
start: start value of selection range (by result count); ignored
if None
end: end value of selection range (by results count); ignored if
None
Returns:
Dictionary from requested parameters to Dict of parameter names
to numpy arrays containing the data points of type numeric,
array or string.
"""
if len(params) == 0:
valid_param_names = get_non_dependencies(self.conn,
self.run_id)
else:
valid_param_names = self._validate_parameters(*params)
return get_parameter_data(self.conn, self.table_name,
valid_param_names, start, end)
def test_get_parameter_data(scalar_dataset):
ds = scalar_dataset
input_names = ['param_3']
data = mut.get_parameter_data(ds.conn, ds.table_name, input_names)
assert len(data.keys()) == len(input_names)
expected_names = {}
expected_names['param_3'] = ['param_0', 'param_1', 'param_2', 'param_3']
expected_shapes = {}
expected_shapes['param_3'] = [(10**3, )] * 4
expected_values = {}
expected_values['param_3'] = [
np.arange(10000 * a, 10000 * a + 1000) for a in range(4)
]
verify_data_dict(data, input_names, expected_names, expected_shapes,
expected_values)