updated check_indices to be nested

Author: alexhroom

RATapi/inputs.py

@@ -50,7 +50,7 @@ class FileHandles:
 
     def __init__(self, files=None):
         self.index = 0
-        self.files = [] if files is None else [file.dict() for file in files]
+        self.files = [] if files is None else [file.model_dump() for file in files]
 
     def __iter__(self):
         self.index = 0
@@ -90,6 +90,9 @@ def __next__(self):
         else:
             raise StopIteration
 
+    def __len__(self):
+        return len(self.files)
+
 
 def make_input(project: RATapi.Project, controls: RATapi.Controls) -> tuple[ProblemDefinition, Limits, Priors, Control]:
     """Constructs the inputs required for the compiled RAT code using the data defined in the input project and
@@ -106,8 +109,6 @@ def make_input(project: RATapi.Project, controls: RATapi.Controls) -> tuple[Prob
     -------
     problem : RAT.rat_core.ProblemDefinition
         The problem input used in the compiled RAT code.
-    cells : RAT.rat_core.Cells
-        The set of inputs that are defined in MATLAB as cell arrays.
     limits : RAT.rat_core.Limits
         A list of min/max values for each parameter defined in the project.
     priors : RAT.rat_core.Priors
@@ -232,10 +233,31 @@ def make_problem(project: RATapi.Project, checks: Checks) -> ProblemDefinition:
     for contrast in project.contrasts:
         background = project.backgrounds[contrast.background]
         contrast_background_types.append(background.type)
+        contrast_background_param = []
         if background.type == TypeOptions.Data:
-            contrast_background_params.append([-1])
+            contrast_background_param.append(project.data.index(background.source, True))
+            if background.value_1 != "":
+                contrast_background_param.append(project.background_parameters.index(background.value_1))
+        elif background.type == TypeOptions.Function:
+            contrast_background_param.append(project.custom_files.index(background.source, True))
+            contrast_background_param.extend(
+                [
+                    project.background_parameters.index(value, True)
+                    for value in [
+                        background.value_1,
+                        background.value_2,
+                        background.value_3,
+                        background.value_4,
+                        background.value_5,
+                    ]
+                    if value != ""
+                ]
+            )
+
         else:
-            contrast_background_params.append([project.background_parameters.index(background.source, True)])
+            contrast_background_param.append(project.background_parameters.index(background.source, True))
+
+        contrast_background_params.append(contrast_background_param)
 
     # Set resolution parameters, with -1 used to indicate a data resolution
     all_data = []
@@ -412,27 +434,58 @@ def check_indices(problem: ProblemDefinition) -> None:
         "bulkOuts": "contrastBulkOuts",
         "scalefactors": "contrastScalefactors",
         "domainRatios": "contrastDomainRatios",
-        # "backgroundParams": "contrastBackgroundParams",
         "resolutionParams": "contrastResolutionParams",
     }
 
     # Check the indices -- note we have switched to 1-based indexing at this point
     for params in index_list:
         param_list = getattr(problem, params)
-        if len(param_list) > 0 and not all(
-            (element > 0 or element == -1) and element <= len(param_list)
-            for element in getattr(problem, index_list[params])
-        ):
+        if len(param_list) > 0:
             elements = [
                 element
                 for element in getattr(problem, index_list[params])
-                if not ((element > 0 or element == -1) and element <= len(param_list))
+                if (element != -1) and not (0 < element <= len(param_list))
             ]
+            if elements:
+                raise IndexError(
+                    f'The problem field "{index_list[params]}" contains: {", ".join(str(i) for i in elements)}'
+                    f', which lie{"s"*(len(elements)==1)} outside of the range of "{params}"',
+                )
+
+    # backgroundParams has a different structure, so is handled separately:
+    # it is of type list[list[int]], where each list[int] is the indices for
+    # source, value_1, value_2, value_3, value_4, value_5 where they are defined
+    # e.g. for a data background with offset it is [source value_1], for a function
+    # with 3 values it is [source value_1 value_2 value_3], etc.
+
+    source_param_lists = {
+        "constant": "backgroundParams",
+        "data": "data",
+        "function": "customFiles",
+    }
+
+    for i, background_data in enumerate(problem.contrastBackgroundParams):
+        background_type = problem.contrastBackgroundTypes[i]
+
+        # check source param is in range of the relevant parameter list
+        param_list = getattr(problem, source_param_lists[background_type])
+        source_index = background_data[0]
+        if not 0 < source_index <= len(param_list):
             raise IndexError(
-                f'The problem field "{index_list[params]}" contains: {", ".join(str(i) for i in elements)}'
-                f', which lie outside of the range of "{params}"',
+                f'Entry {i} of contrastBackgroundParams has type "{background_type}" '
+                f"and source index {source_index}, "
+                f'which is outside the range of "{source_param_lists[background_type]}".'
             )
 
+        # check value params are in range for background params
+        if len(background_data) > 1:
+            elements = [element for element in background_data[1:] if not 0 < element <= len(problem.backgroundParams)]
+            if elements:
+                raise IndexError(
+                    f'Entry {i} of contrastBackgroundParams contains: {", ".join(str(i) for i in elements)}'
+                    f', which lie{"s"*(len(elements)==1)} outside of the range of "backgroundParams"',
+                )
+
 
 def make_controls(input_controls: RATapi.Controls) -> Control:
     """Converts the controls object to the format required by the compiled RAT code.

tests/test_inputs.py

@@ -8,7 +8,7 @@
 
 import RATapi
 import RATapi.wrappers
-from RATapi.inputs import check_indices, make_controls, make_input, make_problem
+from RATapi.inputs import FileHandles, check_indices, make_controls, make_input, make_problem
 from RATapi.rat_core import Checks, Control, Limits, Priors, ProblemDefinition
 from RATapi.utils.enums import (
     BackgroundActions,
@@ -133,6 +133,7 @@ def standard_layers_problem():
     problem.contrastScalefactors = [1]
     problem.contrastBackgroundParams = [[1]]
     problem.contrastBackgroundActions = [BackgroundActions.Add]
+    problem.contrastBackgroundTypes = ["constant"]
     problem.contrastResolutionParams = [1]
     problem.contrastCustomFiles = [float("NaN")]
     problem.contrastDomainRatios = [0]
@@ -155,6 +156,7 @@ def standard_layers_problem():
         [6.2e-06, 6.35e-06],
         [0.01, 0.05],
     ]
+    problem.customFiles = FileHandles([])
 
     return problem
 
@@ -181,6 +183,7 @@ def domains_problem():
     problem.contrastScalefactors = [1]
     problem.contrastBackgroundParams = [[1]]
     problem.contrastBackgroundActions = [BackgroundActions.Add]
+    problem.contrastBackgroundTypes = ["constant"]
     problem.contrastResolutionParams = [1]
     problem.contrastCustomFiles = [float("NaN")]
     problem.contrastDomainRatios = [1]
@@ -204,6 +207,7 @@ def domains_problem():
         [0.01, 0.05],
         [0.4, 0.6],
     ]
+    problem.customFiles = FileHandles([])
 
     return problem
 
@@ -230,6 +234,7 @@ def custom_xy_problem():
     problem.contrastScalefactors = [1]
     problem.contrastBackgroundParams = [[1]]
     problem.contrastBackgroundActions = [BackgroundActions.Add]
+    problem.contrastBackgroundTypes = ["constant"]
     problem.contrastResolutionParams = [1]
     problem.contrastCustomFiles = [1]
     problem.contrastDomainRatios = [0]
@@ -252,6 +257,9 @@ def custom_xy_problem():
         [6.2e-06, 6.35e-06],
         [0.01, 0.05],
     ]
+    problem.customFiles = FileHandles(
+        [RATapi.models.CustomFile(name="Test Custom File", filename="cpp_test.dll", language="cpp")]
+    )
 
     return problem
 
@@ -552,81 +560,98 @@ def test_make_problem(test_project, test_problem, test_check, request) -> None:
     check_problem_equal(problem, test_problem)
 
 
-@pytest.mark.parametrize(
-    "test_problem",
-    [
-        "standard_layers_problem",
-        "custom_xy_problem",
-        "domains_problem",
-    ],
-)
-def test_check_indices(test_problem, request) -> None:
-    """The check_indices routine should not raise errors for a properly defined ProblemDefinition object."""
-    test_problem = request.getfixturevalue(test_problem)
-
-    check_indices(test_problem)
-
-
-@pytest.mark.parametrize(
-    ["test_problem", "index_list", "bad_value"],
-    [
-        ("standard_layers_problem", "contrastBulkIns", [0.0]),
-        ("standard_layers_problem", "contrastBulkIns", [2.0]),
-        ("standard_layers_problem", "contrastBulkOuts", [0.0]),
-        ("standard_layers_problem", "contrastBulkOuts", [2.0]),
-        ("standard_layers_problem", "contrastScalefactors", [0.0]),
-        ("standard_layers_problem", "contrastScalefactors", [2.0]),
-        # ("standard_layers_problem", "contrastBackgroundParams", [0.0]),
-        # ("standard_layers_problem", "contrastBackgroundParams", [2.0]),
-        ("standard_layers_problem", "contrastResolutionParams", [0.0]),
-        ("standard_layers_problem", "contrastResolutionParams", [2.0]),
-        ("custom_xy_problem", "contrastBulkIns", [0.0]),
-        ("custom_xy_problem", "contrastBulkIns", [2.0]),
-        ("custom_xy_problem", "contrastBulkOuts", [0.0]),
-        ("custom_xy_problem", "contrastBulkOuts", [2.0]),
-        ("custom_xy_problem", "contrastScalefactors", [0.0]),
-        ("custom_xy_problem", "contrastScalefactors", [2.0]),
-        # ("custom_xy_problem", "contrastBackgroundParams", [0.0]),
-        # ("custom_xy_problem", "contrastBackgroundParams", [2.0]),
-        ("custom_xy_problem", "contrastResolutionParams", [0.0]),
-        ("custom_xy_problem", "contrastResolutionParams", [2.0]),
-        ("domains_problem", "contrastBulkIns", [0.0]),
-        ("domains_problem", "contrastBulkIns", [2.0]),
-        ("domains_problem", "contrastBulkOuts", [0.0]),
-        ("domains_problem", "contrastBulkOuts", [2.0]),
-        ("domains_problem", "contrastScalefactors", [0.0]),
-        ("domains_problem", "contrastScalefactors", [2.0]),
-        ("domains_problem", "contrastDomainRatios", [0.0]),
-        ("domains_problem", "contrastDomainRatios", [2.0]),
-        # ("domains_problem", "contrastBackgroundParams", [0.0]),
-        # ("domains_problem", "contrastBackgroundParams", [2.0]),
-        ("domains_problem", "contrastResolutionParams", [0.0]),
-        ("domains_problem", "contrastResolutionParams", [2.0]),
-    ],
-)
-def test_check_indices_error(test_problem, index_list, bad_value, request) -> None:
-    """The check_indices routine should raise an IndexError if a contrast list contains an index that is out of the
-    range of the corresponding parameter list in a ProblemDefinition object.
-    """
-    param_list = {
-        "contrastBulkIns": "bulkIns",
-        "contrastBulkOuts": "bulkOuts",
-        "contrastScalefactors": "scalefactors",
-        "contrastDomainRatios": "domainRatios",
-        "contrastBackgroundParams": "backgroundParams",
-        "contrastResolutionParams": "resolutionParams",
-    }
+@pytest.mark.parametrize("test_problem", ["standard_layers_problem", "custom_xy_problem", "domains_problem"])
+class TestCheckIndices:
+    """Tests for check_indices over a set of three test problems."""
 
-    test_problem = request.getfixturevalue(test_problem)
-    setattr(test_problem, index_list, bad_value)
+    def test_check_indices(self, test_problem, request) -> None:
+        """The check_indices routine should not raise errors for a properly defined ProblemDefinition object."""
+        test_problem = request.getfixturevalue(test_problem)
 
-    with pytest.raises(
-        IndexError,
-        match=f'The problem field "{index_list}" contains: {bad_value[0]}, which lie '
-        f'outside of the range of "{param_list[index_list]}"',
-    ):
         check_indices(test_problem)
 
+    @pytest.mark.parametrize(
+        "index_list",
+        [
+            "contrastBulkIns",
+            "contrastBulkOuts",
+            "contrastScalefactors",
+            "contrastDomainRatios",
+            "contrastResolutionParams",
+        ],
+    )
+    @pytest.mark.parametrize("bad_value", ([0.0], [2.0]))
+    def test_check_indices_error(self, test_problem, index_list, bad_value, request) -> None:
+        """The check_indices routine should raise an IndexError if a contrast list contains an index that is out of the
+        range of the corresponding parameter list in a ProblemDefinition object.
+        """
+        param_list = {
+            "contrastBulkIns": "bulkIns",
+            "contrastBulkOuts": "bulkOuts",
+            "contrastScalefactors": "scalefactors",
+            "contrastDomainRatios": "domainRatios",
+            "contrastResolutionParams": "resolutionParams",
+        }
+        if (test_problem != "domains_problem") and (index_list == "contrastDomainRatios"):
+            # we expect this to not raise an error for non-domains problems as domainRatios is empty
+            pytest.xfail()
+
+        test_problem = request.getfixturevalue(test_problem)
+        setattr(test_problem, index_list, bad_value)
+
+        with pytest.raises(
+            IndexError,
+            match=f'The problem field "{index_list}" contains: {bad_value[0]}, which lies '
+            f'outside of the range of "{param_list[index_list]}"',
+        ):
+            check_indices(test_problem)
+
+    @pytest.mark.parametrize("background_type", ["constant", "data", "function"])
+    @pytest.mark.parametrize("bad_value", ([[0.0]], [[2.0]]))
+    def test_background_params_source_indices(self, test_problem, background_type, bad_value, request):
+        """check_indices should raise an IndexError for bad sources in the nested list contrastBackgroundParams."""
+        test_problem = request.getfixturevalue(test_problem)
+        test_problem.contrastBackgroundParams = bad_value
+        test_problem.contrastBackgroundTypes = [background_type]
+
+        source_param_lists = {
+            "constant": "backgroundParams",
+            "data": "data",
+            "function": "customFiles",
+        }
+
+        with pytest.raises(
+            IndexError,
+            match=f'Entry 0 of contrastBackgroundParams has type "{background_type}" '
+            f"and source index {bad_value[0][0]}, "
+            f'which is outside the range of "{source_param_lists[background_type]}".',
+        ):
+            check_indices(test_problem)
+
+    @pytest.mark.parametrize(
+        "bad_value",
+        (
+            [[1.0, 0.0]],
+            [[1.0, 2.0]],
+            [[1.0, 1.0, 2.0]],
+            [[1.0], [1.0, 0.0]],
+        ),
+    )
+    def test_background_params_value_indices(self, test_problem, bad_value, request):
+        """check_indices should raise an IndexError for bad values in the nested list contrastBackgroundParams."""
+        test_problem = request.getfixturevalue(test_problem)
+        test_problem.contrastBackgroundParams = bad_value
+
+        if len(bad_value) > 1:
+            test_problem.contrastBackgroundTypes.append("constant")
+
+        with pytest.raises(
+            IndexError,
+            match=f"Entry {len(bad_value)-1} of contrastBackgroundParams contains: {bad_value[-1][-1]}"
+            f', which lies outside of the range of "backgroundParams"',
+        ):
+            check_indices(test_problem)
+
 
 def test_get_python_handle():
     path = pathlib.Path(__file__).parent.resolve()