Feature addition to check if p_sigma and q_sigma co-(in)exist.

.pre-commit-config.yaml

@@ -4,7 +4,7 @@
 
 repos:
   - repo: https://github.com/fsfe/reuse-tool
-    rev: v1.0.0
+    rev: v2.1.0
     hooks:
       - id: reuse
   - repo: https://github.com/pycqa/isort

docs/user_manual/components.md

@@ -470,7 +470,7 @@ Because of this distribution, at least one appliance is required to be connected
 | name                     | data type                                                                     | unit             | description                                                                                                                                                                                 |              required               |  update  |                     valid values                     |
 | ------------------------ | ----------------------------------------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------: | :------: | :--------------------------------------------------: |
 | `measured_terminal_type` | {py:class}`MeasuredTerminalType <power_grid_model.enum.MeasuredTerminalType>` | -                | indicate if it measures an `appliance` or a `branch`                                                                                                                                        |              &#10004;               | &#10060; | the terminal type should match the `measured_object` |
-| `power_sigma`            | `double`                                                                      | volt-ampere (VA) | standard deviation of the measurement error. Usually this is the absolute measurement error range divided by 3. See {hoverxreftooltip}`user_manual/components:Power Sensor Complete Types`. | &#10024; only for state estimation. | &#10004; |                        `> 0`                         |
+| `power_sigma`            | `double`                                                                      | volt-ampere (VA) | standard deviation of the measurement error. Usually this is the absolute measurement error range divided by 3. See {hoverxreftooltip}`user_manual/components:Power Sensor Concrete Types`. | &#10024; only for state estimation. | &#10004; |                        `> 0`                         |
 
 #### Power Sensor Concrete Types
 

src/power_grid_model/validation/rules.py

@@ -50,6 +50,7 @@
     InvalidIdError,
     MissingValueError,
     MultiComponentNotUniqueError,
+    MultiFieldValidationError,
     NotBetweenError,
     NotBetweenOrAtError,
     NotBooleanError,
@@ -697,6 +698,38 @@ def none_missing(data: SingleDataset, component: str, fields: Union[str, List[st
     return errors
 
 
+def valid_p_q_sigma(data: SingleDataset, component: str) -> List[MultiFieldValidationError]:
+    """
+    Check validity of the pair `(p_sigma, q_sigma)` for 'sym_power_sensor' and 'asym_power_sensor'.
+
+    Args:
+        data: The input/update data set for all components
+        component: The component of interest, in this case only 'sym_power_sensor' or 'asym_power_sensor'
+
+    Returns:
+        A list containing zero or one MultiFieldValidationError, listing the p_sigma and q_sigma mismatch.
+        Note that with asymetric power sensors, partial assignment of p_sigma and q_sigma is also considered mismatch.
+    """
+    errors = []
+    p_sigma = data[component]["p_sigma"]
+    q_sigma = data[component]["q_sigma"]
+    p_nan = np.isnan(p_sigma)
+    q_nan = np.isnan(q_sigma)
+    p_inf = np.isinf(p_sigma)
+    q_inf = np.isinf(q_sigma)
+    if p_sigma.ndim > 1:  # if component == 'asym_power_sensor':
+        p_nan = p_nan.any(axis=-1)
+        q_nan = q_nan.any(axis=-1)
+        p_inf = p_inf.any(axis=-1)
+        q_inf = q_inf.any(axis=-1)
+    mis_match = p_nan != q_nan
+    mis_match |= p_inf.any() or q_inf.any()
+    if mis_match.any():
+        ids = [data[component]["id"].flatten().tolist()]
+        errors.append(MultiFieldValidationError(component, ["p_sigma", "q_sigma"], ids))
+    return errors
+
+
 def all_valid_clocks(
     data: SingleDataset, component: str, clock_field: str, winding_from_field: str, winding_to_field: str
 ) -> List[TransformerClockError]:

src/power_grid_model/validation/validation.py

@@ -53,6 +53,7 @@
     all_valid_fault_phases,
     all_valid_ids,
     none_missing,
+    valid_p_q_sigma,
 )
 from power_grid_model.validation.utils import update_input_data
 
@@ -708,6 +709,8 @@ def validate_generic_power_sensor(data: SingleDataset, component: str) -> List[V
         ref_components="node",
         measured_terminal_type=MeasuredTerminalType.node,
     )
+    if component in ("sym_power_sensor", "asym_power_sensor"):
+        errors += valid_p_q_sigma(data, component)
 
     return errors
 

tests/unit/validation/test_validation_functions.py

@@ -14,8 +14,11 @@
 from power_grid_model.validation.errors import (
     IdNotInDatasetError,
     InfinityError,
+    InvalidIdError,
     MissingValueError,
     MultiComponentNotUniqueError,
+    MultiFieldValidationError,
+    NotUniqueError,
 )
 from power_grid_model.validation.validation import (
     assert_valid_data_structure,
@@ -431,6 +434,140 @@ def test_validate_values__infinite_sigmas(sensor_type, parameter):
         assert not isinstance(error, InfinityError)
 
 
+@pytest.mark.parametrize(
+    ("sensor_type", "parameter", "values", "error_types"),
+    [
+        ("sym_power_sensor", ["p_sigma", "q_sigma"], [NaN, NaN], [InvalidIdError, NotUniqueError]),
+        (
+            "sym_power_sensor",
+            ["p_sigma", "q_sigma"],
+            [0.1, NaN],
+            [InvalidIdError, NotUniqueError, MultiFieldValidationError],
+        ),
+        (
+            "sym_power_sensor",
+            ["p_sigma", "q_sigma"],
+            [NaN, 0.1],
+            [InvalidIdError, NotUniqueError, MultiFieldValidationError],
+        ),
+        ("sym_power_sensor", ["p_sigma", "q_sigma"], [0.1, 0.1], [InvalidIdError, NotUniqueError]),
+        (
+            "asym_power_sensor",
+            ["p_sigma", "q_sigma"],
+            [[NaN, NaN, NaN], [NaN, NaN, NaN]],
+            [InvalidIdError, NotUniqueError],
+        ),
+        (
+            "asym_power_sensor",
+            ["p_sigma", "q_sigma"],
+            [[0.1, NaN, 0.1], [NaN, 0.1, NaN]],
+            [InvalidIdError, NotUniqueError, MultiFieldValidationError],
+        ),
+        (
+            "asym_power_sensor",
+            ["p_sigma", "q_sigma"],
+            [[0.1, NaN, NaN], [NaN, NaN, NaN]],
+            [InvalidIdError, NotUniqueError, MultiFieldValidationError],
+        ),
+        (
+            "asym_power_sensor",
+            ["p_sigma", "q_sigma"],
+            [[NaN, NaN, NaN], [0.1, NaN, NaN]],
+            [InvalidIdError, NotUniqueError, MultiFieldValidationError],
+        ),
+        (
+            "asym_power_sensor",
+            ["p_sigma", "q_sigma"],
+            [[0.1, 0.1, 0.1], [NaN, NaN, NaN]],
+            [InvalidIdError, NotUniqueError, MultiFieldValidationError],
+        ),
+        (
+            "asym_power_sensor",
+            ["p_sigma", "q_sigma"],
+            [[NaN, NaN, NaN], [0.1, 0.1, 0.1]],
+            [InvalidIdError, NotUniqueError, MultiFieldValidationError],
+        ),
+        (
+            "asym_power_sensor",
+            ["p_sigma", "q_sigma"],
+            [[NaN, NaN, NaN], [0.1, NaN, NaN]],
+            [InvalidIdError, NotUniqueError, MultiFieldValidationError],
+        ),
+        (
+            "asym_power_sensor",
+            ["p_sigma", "q_sigma"],
+            [[0.1, NaN, NaN], [0.1, NaN, NaN]],
+            [InvalidIdError, NotUniqueError, MultiFieldValidationError],
+        ),
+        (
+            "asym_power_sensor",
+            ["p_sigma", "q_sigma"],
+            [[0.1, 0.1, 0.1], [0.1, 0.1, 0.1]],
+            [InvalidIdError, NotUniqueError],
+        ),
+    ],
+)
+def test_validate_values__bad_p_q_sigma(sensor_type, parameter, values, error_types):
+    def arbitrary_fill(array, sensor_type, parameter, values):
+        if sensor_type == "sym_power_sensor":
+            array[parameter[0]] = values[0]
+            array[parameter[1]] = values[1]
+        else:
+            array[parameter[0]][0][0] = values[0][0]
+            array[parameter[0]][0][1] = values[0][1]
+            array[parameter[0]][0][2] = values[0][2]
+            array[parameter[1]][0][0] = values[1][0]
+            array[parameter[1]][0][1] = values[1][1]
+            array[parameter[1]][0][2] = values[1][2]
+
+    sensor_array = initialize_array("input", sensor_type, 3)
+    arbitrary_fill(sensor_array, sensor_type, parameter, values)
+    all_errors = validate_values({sensor_type: sensor_array})
+
+    for error in all_errors:
+        assert any(isinstance(error, error_type) for error_type in error_types)
+        assert sensor_array["id"][0] == error.ids[0]
+
+
+@pytest.mark.parametrize(
+    ("values", "error_types"),
+    [
+        ([[NaN, NaN], [[NaN, NaN, NaN], [NaN, NaN, NaN]]], [InvalidIdError]),
+        ([[0.1, NaN], [[NaN, NaN, NaN], [NaN, NaN, NaN]]], [InvalidIdError, MultiFieldValidationError]),
+        ([[NaN, NaN], [[NaN, 0.1, NaN], [NaN, NaN, NaN]]], [InvalidIdError, MultiFieldValidationError]),
+        ([[NaN, NaN], [[NaN, 0.1, NaN], [NaN, 0.1, NaN]]], [InvalidIdError, MultiFieldValidationError]),
+        ([[0.1, 0.1], [[NaN, NaN, NaN], [NaN, NaN, NaN]]], [InvalidIdError, MultiFieldValidationError]),
+        ([[0.1, 0.1], [[NaN, NaN, NaN], [NaN, NaN, NaN]]], [InvalidIdError]),
+        ([[NaN, NaN], [[0.1, 0.1, 0.1], [0.1, 0.1, 0.1]]], [InvalidIdError]),
+        ([[0.1, 0.1], [[0.1, 0.1, 0.1], [0.1, 0.1, 0.1]]], [InvalidIdError]),
+    ],
+)
+def test_validate_values__bad_p_q_sigma_both_components(values, error_types):
+    def two_component_data(values):
+        node = initialize_array("input", "node", 1)
+        node["id"] = 123
+        sym_power_sensor = initialize_array("input", "sym_power_sensor", 1)
+        sym_power_sensor["p_sigma"] = values[0][0]
+        sym_power_sensor["q_sigma"] = values[0][1]
+        sym_power_sensor["id"] = 456
+        asym_power_sensor = initialize_array("input", "asym_power_sensor", 1)
+        asym_power_sensor["p_measured"] = values[1][0]
+        asym_power_sensor["q_measured"] = values[1][1]
+        asym_power_sensor["id"] = 789
+
+        return {
+            "node": node,
+            "sym_power_sensor": sym_power_sensor,
+            "asym_power_sensor": asym_power_sensor,
+        }
+
+    data = two_component_data(values)
+    all_errors = validate_values(data)
+    for error in all_errors:
+        assert any(isinstance(error, error_type) for error_type in error_types)
+        assert data[error.component]["id"][0] == error.ids[0]
+
+
 @pytest.mark.parametrize("measured_terminal_type", MeasuredTerminalType)
 @patch("power_grid_model.validation.validation.validate_base", new=MagicMock())
 @patch("power_grid_model.validation.validation.all_greater_than_zero", new=MagicMock())