Updates API and tests with recently added input and output objects

RATapi/examples/__init__.py

@@ -3,11 +3,11 @@
 from RATapi.examples.domains.domains_custom_layers import domains_custom_layers
 from RATapi.examples.domains.domains_custom_XY import domains_custom_XY
 from RATapi.examples.domains.domains_standard_layers import domains_standard_layers
-from RATapi.examples.non_polarised.DSPC_custom_layers import DSPC_custom_layers
-from RATapi.examples.non_polarised.DSPC_custom_XY import DSPC_custom_XY
-from RATapi.examples.non_polarised.DSPC_data_background import DSPC_data_background
-from RATapi.examples.non_polarised.DSPC_function_background import DSPC_function_background
-from RATapi.examples.non_polarised.DSPC_standard_layers import DSPC_standard_layers
+from RATapi.examples.normal_reflectivity.DSPC_custom_layers import DSPC_custom_layers
+from RATapi.examples.normal_reflectivity.DSPC_custom_XY import DSPC_custom_XY
+from RATapi.examples.normal_reflectivity.DSPC_data_background import DSPC_data_background
+from RATapi.examples.normal_reflectivity.DSPC_function_background import DSPC_function_background
+from RATapi.examples.normal_reflectivity.DSPC_standard_layers import DSPC_standard_layers
 
 __all__ = [
     "absorption",

RATapi/examples/convert_rascal_project/convert_rascal.py

@@ -5,7 +5,7 @@
 
 
 # convert R1 project to Project class
-def convert_rascal():
+def convert_rascal(mat_filename="lipid_bilayer.mat"):
     project_path = pathlib.Path(__file__).parent / "R1monolayerVolumeModel.mat"
     project = RAT.utils.convert.r1_to_project_class(project_path)
 
@@ -16,7 +16,7 @@ def convert_rascal():
 
     # convert DSPC standard layers example to a struct and save as file
     lipid_bilayer_project = RAT.examples.DSPC_standard_layers()[0]
-    RAT.utils.convert.project_class_to_r1(lipid_bilayer_project, filename="lipid_bilayer.mat")
+    RAT.utils.convert.project_class_to_r1(lipid_bilayer_project, filename=mat_filename)
 
     # convert and return as a Python dictionary
     struct = RAT.utils.convert.project_class_to_r1(lipid_bilayer_project, return_struct=True)

RATapi/examples/non_polarised/DSPC_function_background.py → RATapi/examples/normal_reflectivity/DSPC_function_background.py

@@ -142,11 +142,10 @@ def DSPC_function_background():
     )
     problem.backgrounds.append(name="SMW Background", type="constant", source="Background parameter SMW")
 
-    # FIXME: replace this with a Python custom file when Python backgrounds are added!
     problem.custom_files.append(
         name="D2O Background Function",
-        filename="backgroundFunction.m",
-        language="matlab",
+        filename="background_function.py",
+        language="python",
         path=pathlib.Path(__file__).parent.resolve(),
     )
 

RATapi/examples/non_polarised/backgroundFunction.py → RATapi/examples/normal_reflectivity/background_function.py

@@ -8,8 +8,6 @@ def backgroundFunction(xdata, params):
     back_const = params[2]
 
     # Make an exponential decay background
-    background = np.zeros(len(xdata))
-    for i in range(0, len(xdata)):
-        background[i] = Ao * np.exp(-k * xdata[i]) + back_const
+    background = Ao * np.exp(-k * np.array(xdata)) + back_const
 
     return background

RATapi/inputs.py

@@ -247,6 +247,7 @@ def make_problem(project: RATapi.Project, checks: Checks) -> ProblemDefinition:
         background = project.backgrounds[contrast.background]
         contrast_background_types.append(background.type)
         contrast_background_param = []
+
         if background.type == TypeOptions.Data:
             contrast_background_param.append(project.data.index(background.source, True))
             if background.value_1 != "":
@@ -275,17 +276,34 @@ def make_problem(project: RATapi.Project, checks: Checks) -> ProblemDefinition:
 
         contrast_background_params.append(contrast_background_param)
 
-        # contrast data has exactly six columns to include background data if relevant
-        all_data.append(np.column_stack((data, np.zeros((data.shape[0], 6 - data.shape[1])))))
-
-        # Set resolution parameters, with -1 used to indicate a data resolution
-        contrast_resolution_param = []
+        # set resolution parameters
         resolution = project.resolutions[contrast.resolution]
         contrast_resolution_types.append(resolution.type)
-        if resolution.source:
+        contrast_resolution_param = []
+        if resolution.type == TypeOptions.Function:
+            contrast_resolution_param.append(project.custom_files.index(resolution.source, True))
+            contrast_resolution_param.extend(
+                [
+                    project.resolution_parameters.index(value, True)
+                    for value in [
+                        resolution.value_1,
+                        resolution.value_2,
+                        resolution.value_3,
+                        resolution.value_4,
+                        resolution.value_5,
+                    ]
+                    if value != ""
+                ]
+            )
+
+        elif resolution.type == TypeOptions.Constant:
             contrast_resolution_param.append(project.resolution_parameters.index(resolution.source, True))
+
         contrast_resolution_params.append(contrast_resolution_param)
 
+        # contrast data has exactly six columns to include background data if relevant
+        all_data.append(np.column_stack((data, np.zeros((data.shape[0], 6 - data.shape[1])))))
+
     problem = ProblemDefinition()
 
     problem.TF = project.calculation

RATapi/outputs.py

@@ -81,6 +81,7 @@ class Results:
     simulation: list
     shiftedData: list
     backgrounds: list
+    resolutions: list
     layerSlds: list
     sldProfiles: list
     resampledLayers: list
@@ -239,6 +240,7 @@ def make_results(
             simulation=output_results.simulation,
             shiftedData=output_results.shiftedData,
             backgrounds=output_results.backgrounds,
+            resolutions=output_results.resolutions,
             layerSlds=output_results.layerSlds,
             sldProfiles=output_results.sldProfiles,
             resampledLayers=output_results.resampledLayers,
@@ -260,6 +262,7 @@ def make_results(
             simulation=output_results.simulation,
             shiftedData=output_results.shiftedData,
             backgrounds=output_results.backgrounds,
+            resolutions=output_results.resolutions,
             layerSlds=output_results.layerSlds,
             sldProfiles=output_results.sldProfiles,
             resampledLayers=output_results.resampledLayers,

RATapi/project.py

@@ -62,7 +62,6 @@ def discriminate_contrasts(contrast_input):
     "resolutions.value_4": "resolution_parameters",
     "resolutions.value_5": "resolution_parameters",
     "resolutions.constant.source": "resolution_parameters",
-    "resolutions.data.source": "data",
     "resolutions.function.source": "custom_files",
     "layers.thickness": "parameters",
     "layers.SLD": "parameters",
@@ -90,7 +89,6 @@ def discriminate_contrasts(contrast_input):
     "data": [
         AllFields("contrasts", ["data"]),
         AllFields("backgrounds", ["source"]),
-        AllFields("resolutions", ["source"]),
     ],
     "custom_files": [AllFields("backgrounds", ["source"]), AllFields("resolutions", ["source"])],
     "backgrounds": [AllFields("contrasts", ["background"])],

cpp/rat.cpp

@@ -1013,7 +1013,7 @@ py::list pyListFromRatCellWrap0(coder::array<RAT::cell_wrap_0, 2U> values)
     py::list result;
     for (int32_T idx0{0}; idx0 < values.size(1); idx0++) {
         std::string tmp;
-        stringToRatBoundedArray(tmp, values[idx0].f1.data, values[idx0].f1.size);
+        stringFromRatBoundedArray(values[idx0].f1.data, values[idx0].f1.size, tmp);
         result.append(tmp);
     }
 
@@ -1853,13 +1853,13 @@ PYBIND11_MODULE(rat_core, m) {
                                       p.bulkIns, p.bulkOuts, p.resolutionParams, p.params, p.numberOfLayers, p.contrastLayers, p.layersDetails, 
                                       p.customFiles, p.modelType, p.contrastCustomFiles, p.contrastDomainRatios, p.domainRatios, 
                                       p.numberOfDomainContrasts, p.domainContrastLayers, p.fitParams, p.otherParams, p.fitLimits, 
-                                      p.otherLimits, p.names.backgroundParams, p.names.scalefactors, p.names.qzshifts, p.names.bulkIns, 
-                                      p.names.bulkOuts, p.names.resolutionParams, p.names.domainRatios, p.names.contrasts, 
+                                      p.otherLimits, p.names.params, p.names.backgroundParams, p.names.scalefactors, p.names.qzshifts,
+                                      p.names.bulkIns, p.names.bulkOuts, p.names.resolutionParams, p.names.domainRatios, p.names.contrasts, 
                                       p.checks.params, p.checks.backgroundParams, p.checks.scalefactors, p.checks.qzshifts,  
                                       p.checks.bulkIns, p.checks.bulkOuts, p.checks.resolutionParams, p.checks.domainRatios);
             },
             [](py::tuple t) { // __setstate__
-                if (t.size() != 57)
+                if (t.size() != 58)
                     throw std::runtime_error("Encountered invalid state unpickling ProblemDefinition object!");
 
                 /* Create a new C++ instance */
@@ -1907,23 +1907,24 @@ PYBIND11_MODULE(rat_core, m) {
                 p.fitLimits = t[39].cast<py::array_t<real_T>>();
                 p.otherLimits = t[40].cast<py::array_t<real_T>>();
 
-                p.names.backgroundParams = t[41].cast<py::list>(); 
-                p.names.scalefactors = t[42].cast<py::list>();
-                p.names.qzshifts = t[43].cast<py::list>();
-                p.names.bulkIns = t[44].cast<py::list>();
-                p.names.bulkOuts = t[45].cast<py::list>();
-                p.names.resolutionParams = t[46].cast<py::list>();
-                p.names.domainRatios = t[47].cast<py::list>();
-                p.names.contrasts = t[48].cast<py::list>(); 
-
-                p.checks.params = t[49].cast<py::array_t<real_T>>(); 
-                p.checks.backgroundParams = t[50].cast<py::array_t<real_T>>(); 
-                p.checks.scalefactors = t[51].cast<py::array_t<real_T>>();
-                p.checks.qzshifts = t[52].cast<py::array_t<real_T>>(); 
-                p.checks.bulkIns = t[53].cast<py::array_t<real_T>>(); 
-                p.checks.bulkOuts = t[54].cast<py::array_t<real_T>>(); 
-                p.checks.resolutionParams = t[55].cast<py::array_t<real_T>>(); 
-                p.checks.domainRatios = t[56].cast<py::array_t<real_T>>();
+                p.names.params = t[41].cast<py::list>(); 
+                p.names.backgroundParams = t[42].cast<py::list>(); 
+                p.names.scalefactors = t[43].cast<py::list>();
+                p.names.qzshifts = t[44].cast<py::list>();
+                p.names.bulkIns = t[45].cast<py::list>();
+                p.names.bulkOuts = t[46].cast<py::list>();
+                p.names.resolutionParams = t[47].cast<py::list>();
+                p.names.domainRatios = t[48].cast<py::list>();
+                p.names.contrasts = t[49].cast<py::list>(); 
+
+                p.checks.params = t[50].cast<py::array_t<real_T>>(); 
+                p.checks.backgroundParams = t[51].cast<py::array_t<real_T>>(); 
+                p.checks.scalefactors = t[52].cast<py::array_t<real_T>>();
+                p.checks.qzshifts = t[53].cast<py::array_t<real_T>>(); 
+                p.checks.bulkIns = t[54].cast<py::array_t<real_T>>(); 
+                p.checks.bulkOuts = t[55].cast<py::array_t<real_T>>(); 
+                p.checks.resolutionParams = t[56].cast<py::array_t<real_T>>(); 
+                p.checks.domainRatios = t[57].cast<py::array_t<real_T>>();
 
                 return p;
             }));