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
Exemplo n.º 2
0
    def test_constant_parameter(self):
        name = 'dummy'
        data = 3.14159
        start = 1.0
        stop = 2.0

        fill_val = np.NaN
        arr = np.array([0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5])

        pd = ConstantOverTime(name, data, time_start=start)

        param_type = ConstantType(value_encoding='float32')
        param_type.fill_value = np.NaN

        alignment_array = arr[10:14]
        got = pd.get_data_as_numpy_array(alignment_array, param_type)
        expected = param_type.create_data_array(data, 4)
        np.testing.assert_array_equal(expected, got)

        alignment_array = arr[10:]
        got = pd.get_data_as_numpy_array(alignment_array, param_type)
        expected = param_type.create_data_array(data, alignment_array.size)
        np.testing.assert_array_equal(got, expected)

        alignment_array = arr[0:]
        got = pd.get_data_as_numpy_array(alignment_array, param_type)
        expected = param_type.create_filled_array(alignment_array.size)
        expected[5:alignment_array.size] = data
        np.testing.assert_array_equal(got, expected)

        alignment_array = arr[0:10]
        got = pd.get_data_as_numpy_array(alignment_array, param_type)
        expected = param_type.create_filled_array(alignment_array.size)
        expected[5:alignment_array.size] = data
        np.testing.assert_array_equal(got, expected)


        pd = ConstantOverTime(name, data, time_start=start, time_end=stop)

        alignment_array = arr[10:14]
        got = pd.get_data_as_numpy_array(alignment_array, param_type)
        expected = param_type.create_data_array(data, 4)
        np.testing.assert_array_equal(got, expected)

        alignment_array = arr[10:]
        got = pd.get_data_as_numpy_array(alignment_array, param_type)
        expected = np.empty(11, dtype=np.dtype('float32'))
        expected.fill(fill_val)
        expected[0:6] = data
        np.testing.assert_array_equal(got, expected)

        alignment_array = arr[0:]
        got = pd.get_data_as_numpy_array(alignment_array, param_type)
        expected = np.empty(alignment_array.size, dtype=np.dtype('float32'))
        expected.fill(fill_val)
        expected[5:11+5] = data
        np.testing.assert_array_equal(got, expected)

        alignment_array = arr[0:11]
        got = pd.get_data_as_numpy_array(alignment_array, param_type)
        expected = np.empty(alignment_array.size, dtype=np.dtype('float32'))
        expected.fill(fill_val)
        expected[5:] = data
        expected = np.array([fill_val, fill_val, fill_val, fill_val, fill_val, data, data, data, data, data, data], dtype=np.dtype('float32'))
        np.testing.assert_array_equal(got, expected)

        pd = ConstantOverTime(name, data, time_end=stop)

        alignment_array = arr[10:14]
        got = pd.get_data_as_numpy_array(alignment_array, param_type)
        expected = np.empty(4, dtype=np.dtype('float32'))
        expected.fill(data)
        np.testing.assert_array_equal(got, expected)

        alignment_array = arr[10:]
        got = pd.get_data_as_numpy_array(alignment_array, param_type)
        expected = np.empty(11, dtype=np.dtype('float32'))
        expected.fill(fill_val)
        expected[0:6] = data
        np.testing.assert_array_equal(got, expected)

        alignment_array = arr[0:]
        got = pd.get_data_as_numpy_array(alignment_array, param_type)
        expected = np.empty(alignment_array.size, dtype=np.dtype('float32'))
        expected.fill(fill_val)
        expected[0:11+5] = data
        np.testing.assert_array_equal(got, expected)

        alignment_array = arr[0:11]
        got = pd.get_data_as_numpy_array(alignment_array, param_type)
        expected = np.empty(alignment_array.size, dtype=np.dtype('float32'))
        expected.fill(data)
        np.testing.assert_array_equal(got, expected)

        pd = ConstantOverTime(name, data)

        alignment_array = arr[10:14]
        got = pd.get_data_as_numpy_array(alignment_array, param_type)
        expected = np.empty(4, dtype=np.dtype('float32'))
        expected.fill(data)
        np.testing.assert_array_equal(got, expected)

        alignment_array = arr[10:]
        got = pd.get_data_as_numpy_array(alignment_array, param_type)
        expected = np.empty(11, dtype=np.dtype('float32'))
        expected.fill(data)
        np.testing.assert_array_equal(got, expected)

        alignment_array = arr[0:]
        got = pd.get_data_as_numpy_array(alignment_array, param_type)
        expected = np.empty(alignment_array.size, dtype=np.dtype('float32'))
        expected.fill(data)
        np.testing.assert_array_equal(got, expected)

        alignment_array = arr[0:11]
        got = pd.get_data_as_numpy_array(alignment_array, param_type)
        expected = np.empty(alignment_array.size, dtype=np.dtype('float32'))
        expected.fill(data)
        np.testing.assert_array_equal(got, expected)