def get_time_values(self, time_segement=None, stride_length=None, return_value=None):
cov_value_list = []
dummy_key = "stripped_later"
for coverage in self._reference_covs.values():
if isinstance(coverage, AbstractCoverage):
params = coverage.get_time_values(time_segement, stride_length, return_value)
cov_dict = {dummy_key: params}
cov_value_list.append((cov_dict, coverage))
combined_data = self._merge_value_dicts(cov_value_list, override_temporal_key=dummy_key, stride_length=stride_length)
if dummy_key in combined_data:
combined_data = NumpyUtils.sort_flat_arrays(combined_data, dummy_key)
return combined_data[dummy_key] #TODO: Handle case where 'time' may not be temporal parameter name of all sub-coverages
else:
return np.array([])
def _create_parameter_dictionary_of_numpy_arrays(self, numpy_params, function_params=None, params=None, fill_indexes=False):
return_dict = {}
mask_dict = {}
value_set_time_dict = {}
shape_outer_dimmension = 0
span_order = []
span_size_dict = {}
t_dict = {}
if self.alignment_parameter in numpy_params:
for id, span_data in numpy_params[self.alignment_parameter].iteritems():
span_size_dict[id] = span_data[1].get_data().size
shape_outer_dimmension += span_data[1].get_data().size
span_order.append((span_data[0], id))
span_order.sort()
t_dict = numpy_params[self.alignment_parameter]
dt = np.dtype(self.master_manager.parameter_metadata[self.alignment_parameter].parameter_context.param_type.value_encoding)
arr = np.empty(shape_outer_dimmension, dtype=dt)
insert_index = 0
for span_tup in span_order:
span_id = span_tup[1]
np_data = t_dict[span_id][1].get_data()
end_idx = insert_index+np_data.size
arr[insert_index:end_idx] = np_data
insert_index += np_data.size
return_dict[self.alignment_parameter] = arr
mask_dict[self.alignment_parameter] = NumpyUtils.create_filled_array(arr.shape[0], True, dtype=np.bool)
value_set_time_dict[self.alignment_parameter] = self.master_manager.parameter_metadata[self.alignment_parameter].parameter_context.param_type.create_filled_array(arr.shape[0])
ingest_name_ptype = self.master_manager.parameter_metadata[Span.ingest_time_str].parameter_context.param_type
for id, span_data in numpy_params.iteritems():
if id == self.alignment_parameter:
continue
npa_list = []
mask_list = []
value_set_list = []
for span_tup in span_order:
span_id = span_tup[1]
span_time = span_tup[0]
if span_id not in span_data:
npa = self.master_manager.parameter_metadata[id].parameter_context.param_type.create_filled_array(span_size_dict[span_id])
npa_list.append(npa)
value_set_list.append(ingest_name_ptype.create_filled_array(npa.shape[0]))
mask_list.append(NumpyUtils.create_filled_array(npa.shape[0], False, dtype=np.bool))
continue
else:
this_data = span_data[span_id][1].get_data()
npa_list.append(this_data)
mask_list.append(NumpyUtils.create_filled_array(this_data.shape[0], True, dtype=np.bool))
value_set_list.append(ingest_name_ptype.create_filled_array(this_data.shape[0], span_time))
return_dict[id] = self.master_manager.parameter_metadata[id].parameter_context.param_type.create_merged_value_array(npa_list)
from coverage_model.parameter_types import BooleanType
mask_dict[id] = BooleanType().create_merged_value_array(mask_list)
value_set_time_dict[id] = ingest_name_ptype.create_merged_value_array(value_set_list)
for param_name, param_dict in function_params.iteritems():
arr = ConstantOverTime.merge_data_as_numpy_array(return_dict[self.alignment_parameter],
param_dict,
param_type=self.master_manager.parameter_metadata[param_name].parameter_context.param_type)
return_dict[param_name] = arr
mask_dict[param_name] = NumpyUtils.create_filled_array(arr.shape[0], True, dtype=np.bool)
value_set_time_dict[param_name] = ingest_name_ptype.create_filled_array(arr.shape[0], get_current_ntp_time())
return return_dict, mask_dict, value_set_time_dict
def create_ragged_array(cls, data):
return NumpyUtils.create_numpy_object_array(data)
def test_ragged_array_types(self):
param_type = RaggedArrayType()
param_ctx = ParameterContext("array_type", param_type=param_type, fill_value='')
# test well-formed
scov = _make_cov(self.working_dir, ['quantity', param_ctx], nt = 0)
with self.assertRaises(ValueError):
data_dict = {
'time' : np.array([0,1], dtype='<f8'),
'array_type' : np.array([[0,0,0], [1,1,1]], dtype=np.dtype('object'))
}
data_dict = _easy_dict(data_dict)
scov.set_parameter_values(data_dict)
data_dict = {
'time' : np.array([0,1], dtype='<f8'),
'array_type' : np.array([[0,0,0], [1,1,1,1]], dtype=np.dtype('object'))
}
data_dict = _easy_dict(data_dict)
scov.set_parameter_values(data_dict)
returned_dict = scov.get_parameter_values(param_names=data_dict.keys()).get_data()
for k,v in data_dict.iteritems():
np.testing.assert_array_equal(v.get_data(), returned_dict[k])
# test one element
scov = _make_cov(self.working_dir, ['quantity', param_ctx], nt = 0)
from coverage_model.util.numpy_utils import NumpyUtils
data_dict = {
'time' : np.array([0], dtype='<f8'),
'array_type' : RaggedArrayType.create_ragged_array(np.array([[0,0,0]]))
}
data_dict = _easy_dict(data_dict)
scov.set_parameter_values(data_dict)
returned_dict = scov.get_parameter_values(param_names=data_dict.keys()).get_data()
for k,v in data_dict.iteritems():
np.testing.assert_array_equal(v.get_data(), returned_dict[k])
# test numpy array
scov = _make_cov(self.working_dir, ['quantity', param_ctx], nt = 0)
data_dict = {
'time' : np.array([0,1], dtype='<f8'),
'array_type' : NumpyUtils.create_numpy_object_array(np.array([[1,1,1], [2,2,2]], dtype='i4'))
}
data_dict = _easy_dict(data_dict)
scov.set_parameter_values(data_dict)
returned_dict = scov.get_parameter_values(param_names=data_dict.keys()).get_data()
for k,v in data_dict.iteritems():
np.testing.assert_array_equal(v.get_data(), returned_dict[k])
# test numpy array
scov = _make_cov(self.working_dir, ['quantity', param_ctx], nt = 0)
data_dict = {
'time' : np.array([0,1], dtype='<f8'),
'array_type' : NumpyUtils.create_numpy_object_array(np.array([[1,1,1], [2,2,2,2]]))
}
data_dict = _easy_dict(data_dict)
scov.set_parameter_values(data_dict)
data_dict = {
'time' : np.array([2,3], dtype='<f8'),
'array_type' : RaggedArrayType.create_ragged_array(np.array([[1,1,1], [2,2,2]]))
}
data_dict = _easy_dict(data_dict)
scov.set_parameter_values(data_dict)
returned_dict = scov.get_parameter_values(time_segment=(2,3), param_names=data_dict.keys()).get_data()
for k,v in data_dict.iteritems():
np.testing.assert_array_equal(v.get_data(), returned_dict[k])
self.assertEqual(2, returned_dict[k].size)
data_dict = {
'time' : np.array([0,1,2,3], dtype='<f8'),
'array_type' : NumpyUtils.create_numpy_object_array(np.array([[1,1,1], [2,2,2,2], [1,1,1], [2,2,2]]))
}
data_dict = _easy_dict(data_dict)
returned_dict = scov.get_parameter_values(param_names=data_dict.keys()).get_data()
for k,v in data_dict.iteritems():
np.testing.assert_array_equal(v.get_data(), returned_dict[k])
self.assertEqual(4, returned_dict[k].size)
def sort_data_by_parameter(self, sort_parameter):
if sort_parameter is not None:
self._data = NumpyUtils.sort_flat_arrays(self._data, sort_parameter)
