Adds and refines printed output to users (#50)

* Adds text to run routine, including elapsed time

* Adds routine to make sure background and resolution values are checked based on type

* Adds __str__ methods to output classes

* Hides input in custom errors

* Refines and tests __str__ methods for output classes

* Addresses review comments

* Removes unused function

Author: DrPaulSharp

RATapi/controls.py

@@ -91,7 +91,7 @@ def warn_setting_incorrect_properties(self, handler: ValidatorFunctionWrapHandle
                 f'{", ".join(fields.get("procedure", []))}\n',
             }
             custom_error_list = custom_pydantic_validation_error(exc.errors(), custom_error_msgs)
-            raise ValidationError.from_exception_data(exc.title, custom_error_list) from None
+            raise ValidationError.from_exception_data(exc.title, custom_error_list, hide_input=True) from None
 
         if isinstance(model_input, validated_self.__class__):
             # This is for changing fields in a defined model

RATapi/examples/domains/alloy_domains.py

@@ -18,7 +18,7 @@ def alloy_domains(params, bulkIn, bulkOut, contrast, domain):
     gold = [goldThick, goldSLD, goldRough]
 
     # Make the model depending on which domain we are looking at
-    if domain == 1:
+    if domain == 0:
         output = [alloyUp, gold]
     else:
         output = [alloyDn, gold]

RATapi/examples/domains/domains_XY_model.py

@@ -33,7 +33,7 @@ def domains_XY_model(params, bulk_in, bulk_out, contrast, domain):
     oxSLD = vfOxide * 3.41e-6
 
     # Layer SLD depends on whether we are calculating the domain or not
-    if domain == 1:
+    if domain == 0:
         laySLD = vfLayer * layerSLD
     else:
         laySLD = vfLayer * domainSLD

RATapi/outputs.py

@@ -1,22 +1,73 @@
 """Converts outputs from the compiled RAT code to python dataclasses"""
 
 from dataclasses import dataclass
-from typing import Optional, Union
+from typing import Any, Optional, Union
 
 import numpy as np
 
 import RATapi.rat_core
 from RATapi.utils.enums import Procedures
 
 
+def get_field_string(field: str, value: Any, array_limit: int):
+    """Returns a string representation of class fields where large and multidimensional arrays are represented by their
+    shape.
+
+    Parameters
+    ----------
+    field : str
+        The name of the field in the RAT output class.
+    value : Any
+        The value of the given field in the RAT output class.
+    array_limit : int
+        The maximum length of 1D arrays which will be fully displayed.
+
+    Returns
+    -------
+    field_string : str
+        The string representation of the field in the RAT output class.
+    """
+    array_text = "Data array: "
+    if isinstance(value, list) and len(value) > 0:
+        if isinstance(value[0], np.ndarray):
+            array_strings = [f"{array_text}[{' x '.join(str(i) for i in array.shape)}]" for array in value]
+            field_string = f"{field} = [{', '.join(str(string) for string in array_strings)}],\n"
+        elif isinstance(value[0], list) and len(value[0]) > 0 and isinstance(value[0][0], np.ndarray):
+            array_strings = [
+                [f"{array_text}[{' x '.join(str(i) for i in array.shape)}]" for array in sub_list] for sub_list in value
+            ]
+            list_strings = [f"[{', '.join(string for string in list_string)}]" for list_string in array_strings]
+            field_string = f"{field} = [{', '.join(list_strings)}],\n"
+        else:
+            field_string = f"{field} = {str(value)},\n"
+    elif isinstance(value, np.ndarray):
+        if value.ndim == 1 and value.size < array_limit:
+            field_string = f"{field} = {str(value) if value.size > 0 else '[]'},\n"
+        else:
+            field_string = f"{field} = {array_text}[{' x '.join(str(i) for i in value.shape)}],\n"
+    else:
+        field_string = f"{field} = {str(value)},\n"
+
+    return field_string
+
+
+class RATResult:
+    def __str__(self):
+        output = f"{self.__class__.__name__}(\n"
+        for key, value in self.__dict__.items():
+            output += "\t" + get_field_string(key, value, 100)
+        output += ")"
+        return output
+
+
 @dataclass
-class CalculationResults:
+class CalculationResults(RATResult):
     chiValues: np.ndarray
     sumChi: float
 
 
 @dataclass
-class ContrastParams:
+class ContrastParams(RATResult):
     backgroundParams: np.ndarray
     scalefactors: np.ndarray
     bulkIn: np.ndarray
@@ -39,9 +90,15 @@ class Results:
     fitParams: np.ndarray
     fitNames: list[str]
 
+    def __str__(self):
+        output = ""
+        for key, value in self.__dict__.items():
+            output += get_field_string(key, value, 100)
+        return output
+
 
 @dataclass
-class PredictionIntervals:
+class PredictionIntervals(RATResult):
     reflectivity: list
     sld: list
     reflectivityXData: list
@@ -50,14 +107,14 @@ class PredictionIntervals:
 
 
 @dataclass
-class ConfidenceIntervals:
+class ConfidenceIntervals(RATResult):
     percentile95: np.ndarray
     percentile65: np.ndarray
     mean: np.ndarray
 
 
 @dataclass
-class DreamParams:
+class DreamParams(RATResult):
     nParams: float
     nChains: float
     nGenerations: float
@@ -80,7 +137,7 @@ class DreamParams:
 
 
 @dataclass
-class DreamOutput:
+class DreamOutput(RATResult):
     allChains: np.ndarray
     outlierChains: np.ndarray
     runtime: float
@@ -92,7 +149,7 @@ class DreamOutput:
 
 
 @dataclass
-class NestedSamplerOutput:
+class NestedSamplerOutput(RATResult):
     logZ: float
     nestSamples: np.ndarray
     postSamples: np.ndarray

RATapi/project.py

@@ -33,16 +33,26 @@
 }
 
 values_defined_in = {
-    "backgrounds.value_1": "background_parameters",
-    "backgrounds.value_2": "background_parameters",
-    "backgrounds.value_3": "background_parameters",
-    "backgrounds.value_4": "background_parameters",
-    "backgrounds.value_5": "background_parameters",
-    "resolutions.value_1": "resolution_parameters",
-    "resolutions.value_2": "resolution_parameters",
-    "resolutions.value_3": "resolution_parameters",
-    "resolutions.value_4": "resolution_parameters",
-    "resolutions.value_5": "resolution_parameters",
+    "backgrounds.constant.value_1": "background_parameters",
+    "backgrounds.constant.value_2": "background_parameters",
+    "backgrounds.constant.value_3": "background_parameters",
+    "backgrounds.constant.value_4": "background_parameters",
+    "backgrounds.constant.value_5": "background_parameters",
+    "backgrounds.data.value_1": "data",
+    "backgrounds.data.value_2": "data",
+    "backgrounds.data.value_3": "data",
+    "backgrounds.data.value_4": "data",
+    "backgrounds.data.value_5": "data",
+    "resolutions.constant.value_1": "resolution_parameters",
+    "resolutions.constant.value_2": "resolution_parameters",
+    "resolutions.constant.value_3": "resolution_parameters",
+    "resolutions.constant.value_4": "resolution_parameters",
+    "resolutions.constant.value_5": "resolution_parameters",
+    "resolutions.data.value_1": "data",
+    "resolutions.data.value_2": "data",
+    "resolutions.data.value_3": "data",
+    "resolutions.data.value_4": "data",
+    "resolutions.data.value_5": "data",
     "layers.thickness": "parameters",
     "layers.SLD": "parameters",
     "layers.SLD_real": "parameters",
@@ -434,8 +444,13 @@ def update_renamed_models(self) -> "Project":
     def cross_check_model_values(self) -> "Project":
         """Certain model fields should contain values defined elsewhere in the project."""
         value_fields = ["value_1", "value_2", "value_3", "value_4", "value_5"]
-        self.check_allowed_values("backgrounds", value_fields, self.background_parameters.get_names())
-        self.check_allowed_values("resolutions", value_fields, self.resolution_parameters.get_names())
+        self.check_allowed_background_resolution_values(
+            "backgrounds", value_fields, self.background_parameters.get_names(), self.data.get_names()
+        )
+        self.check_allowed_background_resolution_values(
+            "resolutions", value_fields, self.resolution_parameters.get_names(), self.data.get_names()
+        )
+
         self.check_allowed_values(
             "layers",
             ["thickness", "SLD", "SLD_real", "SLD_imaginary", "roughness"],
@@ -526,6 +541,49 @@ def check_allowed_values(self, attribute: str, field_list: list[str], allowed_va
                         f'"{values_defined_in[f"{attribute}.{field}"]}".',
                     )
 
+    def check_allowed_background_resolution_values(
+        self, attribute: str, field_list: list[str], allowed_constants: list[str], allowed_data: list[str]
+    ) -> None:
+        """Check the values of the given fields in the given model are in the supplied list of allowed values.
+
+        For backgrounds and resolutions, the list of allowed values depends on whether the type of the
+        background/resolution is "constant" or "data".
+
+        Parameters
+        ----------
+        attribute : str
+            The attribute of Project being validated.
+        field_list : list [str]
+            The fields of the attribute to be checked for valid values.
+        allowed_constants : list [str]
+            The list of allowed values for the fields given in field_list if the type is "constant".
+        allowed_data : list [str]
+            The list of allowed values for the fields given in field_list if the type is "data".
+
+        Raises
+        ------
+        ValueError
+            Raised if any field in field_list has a value not specified in allowed_constants or allowed_data as
+            appropriate.
+
+        """
+        class_list = getattr(self, attribute)
+        for model in class_list:
+            if model.type == TypeOptions.Constant:
+                allowed_values = allowed_constants
+            elif model.type == TypeOptions.Data:
+                allowed_values = allowed_data
+            else:
+                raise ValueError('"Function" type backgrounds and resolutions are not yet supported.')
+
+            for field in field_list:
+                value = getattr(model, field, "")
+                if value and value not in allowed_values:
+                    raise ValueError(
+                        f'The value "{value}" in the "{field}" field of "{attribute}" must be defined in '
+                        f'"{values_defined_in[f"{attribute}.{model.type}.{field}"]}".',
+                    )
+
     def check_contrast_model_allowed_values(
         self,
         contrast_attribute: str,
@@ -648,7 +706,7 @@ def wrapped_func(*args, **kwargs):
             except ValidationError as exc:
                 class_list.data = previous_state
                 custom_error_list = custom_pydantic_validation_error(exc.errors())
-                raise ValidationError.from_exception_data(exc.title, custom_error_list) from None
+                raise ValidationError.from_exception_data(exc.title, custom_error_list, hide_input=True) from None
             except (TypeError, ValueError):
                 class_list.data = previous_state
                 raise

RATapi/run.py

@@ -1,6 +1,9 @@
+import time
+
 import RATapi.rat_core
 from RATapi.inputs import make_input
 from RATapi.outputs import make_results
+from RATapi.utils.enums import Display
 
 
 def run(project, controls):
@@ -15,15 +18,25 @@ def run(project, controls):
         "resolution_parameters": "resolutionParams",
     }
 
+    horizontal_line = "\u2500" * 107 + "\n"
+
     problem_definition, cells, limits, priors, cpp_controls = make_input(project, controls)
 
+    if controls.display != Display.Off:
+        print("Starting RAT " + horizontal_line)
+
+    start = time.time()
     problem_definition, output_results, bayes_results = RATapi.rat_core.RATMain(
         problem_definition,
         cells,
         limits,
         cpp_controls,
         priors,
     )
+    end = time.time()
+
+    if controls.display != Display.Off:
+        print(f"Elapsed time is {end-start:.3f} seconds\n")
 
     results = make_results(controls.procedure, output_results, bayes_results)
 
@@ -32,4 +45,7 @@ def run(project, controls):
         for index, value in enumerate(getattr(problem_definition, parameter_field[class_list])):
             getattr(project, class_list)[index].value = value
 
+    if controls.display != Display.Off:
+        print("Finished RAT " + horizontal_line)
+
     return project, results

cpp/rat.cpp

@@ -1146,7 +1146,7 @@ BayesResults bayesResultsFromStruct8T(const RAT::struct8_T results)
     bayesResults.dreamParams.delta = results.dreamParams.delta;
     bayesResults.dreamParams.steps = results.dreamParams.steps;
     bayesResults.dreamParams.zeta = results.dreamParams.zeta;
-    bayesResults.dreamParams.outlier = std::string(results.dreamParams.outlier);
+    bayesResults.dreamParams.outlier = std::string(results.dreamParams.outlier, 3);
     bayesResults.dreamParams.adaptPCR = results.dreamParams.adaptPCR;
     bayesResults.dreamParams.thinning = results.dreamParams.thinning;
     bayesResults.dreamParams.epsilon = results.dreamParams.epsilon;