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)