ratapi 0.0.0.dev13__tar.gz → 0.0.0.dev15__tar.gz

{ratapi-0.0.0.dev13/ratapi.egg-info → ratapi-0.0.0.dev15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ratapi
-Version: 0.0.0.dev13
+Version: 0.0.0.dev15
 Summary: Python extension for the Reflectivity Analysis Toolbox (RAT)
 Project-URL: Documentation, https://rascalsoftware.github.io/RAT/
 Project-URL: Repository, https://github.com/RascalSoftware/python-RAT

{ratapi-0.0.0.dev13 → ratapi-0.0.0.dev15}/cpp/RAT/domainsReflectivity.cpp

@@ -295,6 +295,8 @@ namespace RAT
       ::coder::array<cell_wrap_9, 1U> contrastLayers2;
       ::coder::array<cell_wrap_9, 1U> contrastSlds1;
       ::coder::array<cell_wrap_9, 1U> contrastSlds2;
+      ::coder::array<double, 2U> inputDomainContrastLayers1_tmp;
+      ::coder::array<double, 2U> inputDomainContrastLayers2;
       ::coder::array<double, 2U> r1;
       ::coder::array<double, 1U> b_simulationXData;
       ::coder::array<double, 1U> domainRatios;
@@ -313,7 +315,7 @@ namespace RAT
       int iv5[2];
       int iv6[2];
       int switch_expression_size[2];
-      int b_index;
+      int b_loop_ub;
       int loop_ub;
       int loop_ub_tmp;
       int nParams;
@@ -428,18 +430,18 @@ namespace RAT
                    switch_expression_data, switch_expression_size);
       if (coder::internal::k_strcmp(switch_expression_data,
            switch_expression_size)) {
-        b_index = 0;
+        loop_ub = 0;
       } else if (coder::internal::n_strcmp(switch_expression_data,
                   switch_expression_size)) {
-        b_index = 1;
+        loop_ub = 1;
       } else if (coder::internal::o_strcmp(switch_expression_data,
                   switch_expression_size)) {
-        b_index = 2;
+        loop_ub = 2;
       } else {
-        b_index = -1;
+        loop_ub = -1;
       }
 
-      switch (b_index) {
+      switch (loop_ub) {
        case 0:
         //  First we need to allocate the absolute values of the input
         //  parameters to all the layers in the layers list. This only
@@ -459,9 +461,61 @@ namespace RAT
           //  layers list are required for this contrast, and put them
           //  in the correct order according to geometry. We run it
           //  twice, once for each domain
-          allocateLayersForContrast(problemStruct.domainContrastLayers[
-            static_cast<int>(problemStruct.contrastLayers[b_i].f1[0]) - 1].f1,
-            layerValues, r1);
+          if ((problemStruct.contrastLayers[b_i].f1.size(0) == 0) ||
+              (problemStruct.contrastLayers[b_i].f1.size(1) == 0)) {
+            inputDomainContrastLayers1_tmp.set_size(0, 0);
+            inputDomainContrastLayers2.set_size(0, 0);
+          } else {
+            inputDomainContrastLayers1_tmp.set_size
+              (problemStruct.domainContrastLayers[problemStruct.domainContrastLayers.size
+               (0) * (static_cast<int>
+                      (problemStruct.contrastLayers[problemStruct.contrastLayers.size
+                       (0) * b_i].f1[0]) - 1)].f1.size(0),
+               problemStruct.domainContrastLayers[problemStruct.domainContrastLayers.size
+               (0) * (static_cast<int>
+                      (problemStruct.contrastLayers[problemStruct.contrastLayers.size
+                       (0) * b_i].f1[0]) - 1)].f1.size(1));
+            loop_ub = problemStruct.domainContrastLayers[static_cast<int>
+              (problemStruct.contrastLayers[b_i].f1[0]) - 1].f1.size(1);
+            for (int i{0}; i < loop_ub; i++) {
+              b_loop_ub = problemStruct.domainContrastLayers[static_cast<int>
+                (problemStruct.contrastLayers[b_i].f1[0]) - 1].f1.size(0);
+              for (int i1{0}; i1 < b_loop_ub; i1++) {
+                inputDomainContrastLayers1_tmp[i1 +
+                  inputDomainContrastLayers1_tmp.size(0) * i] =
+                  problemStruct.domainContrastLayers[static_cast<int>
+                  (problemStruct.contrastLayers[b_i].f1[0]) - 1].f1[i1 +
+                  problemStruct.domainContrastLayers[static_cast<int>
+                  (problemStruct.contrastLayers[b_i].f1[0]) - 1].f1.size(0) * i];
+              }
+            }
+
+            inputDomainContrastLayers2.set_size
+              (problemStruct.domainContrastLayers[problemStruct.domainContrastLayers.size
+               (0) * (static_cast<int>
+                      (problemStruct.contrastLayers[problemStruct.contrastLayers.size
+                       (0) * b_i].f1[1]) - 1)].f1.size(0),
+               problemStruct.domainContrastLayers[problemStruct.domainContrastLayers.size
+               (0) * (static_cast<int>
+                      (problemStruct.contrastLayers[problemStruct.contrastLayers.size
+                       (0) * b_i].f1[1]) - 1)].f1.size(1));
+            loop_ub = problemStruct.domainContrastLayers[static_cast<int>
+              (problemStruct.contrastLayers[b_i].f1[1]) - 1].f1.size(1);
+            for (int i{0}; i < loop_ub; i++) {
+              b_loop_ub = problemStruct.domainContrastLayers[static_cast<int>
+                (problemStruct.contrastLayers[b_i].f1[1]) - 1].f1.size(0);
+              for (int i1{0}; i1 < b_loop_ub; i1++) {
+                inputDomainContrastLayers2[i1 + inputDomainContrastLayers2.size
+                  (0) * i] = problemStruct.domainContrastLayers[static_cast<int>
+                  (problemStruct.contrastLayers[b_i].f1[1]) - 1].f1[i1 +
+                  problemStruct.domainContrastLayers[static_cast<int>
+                  (problemStruct.contrastLayers[b_i].f1[1]) - 1].f1.size(0) * i];
+              }
+            }
+          }
+
+          allocateLayersForContrast(inputDomainContrastLayers1_tmp, layerValues,
+            r1);
           contrastLayers1[b_i].f1.set_size(r1.size(0), 6);
           loop_ub = r1.size(0);
           for (int i{0}; i < 6; i++) {
@@ -471,9 +525,7 @@ namespace RAT
             }
           }
 
-          allocateLayersForContrast(problemStruct.domainContrastLayers[
-            static_cast<int>(problemStruct.contrastLayers[b_i].f1[1]) - 1].f1,
-            layerValues, r1);
+          allocateLayersForContrast(inputDomainContrastLayers2, layerValues, r1);
           contrastLayers2[b_i].f1.set_size(r1.size(0), 6);
           loop_ub = r1.size(0);
           for (int i{0}; i < 6; i++) {
@@ -526,13 +578,13 @@ namespace RAT
           simulation.set_size(loop_ub_tmp);
           reflectivity.set_size(loop_ub_tmp);
           sldProfiles.set_size(loop_ub_tmp, 2);
-          b_index = static_cast<int>(problemStruct.numberOfContrasts) - 1;
+          loop_ub = static_cast<int>(problemStruct.numberOfContrasts) - 1;
 
 #pragma omp parallel for \
  num_threads(omp_get_max_threads()) \
  private(simulationXData,d,b_dataIndices,iv3,iv4,iv5,iv6,dv2,dv3)
 
-          for (int c_i = 0; c_i <= b_index; c_i++) {
+          for (int c_i = 0; c_i <= loop_ub; c_i++) {
             iv3[0] = (*(int (*)[2])((::coder::array<double, 2U> *)
                        &problemStruct.contrastBackgroundParams[c_i].f1)->size())
               [0];
@@ -677,13 +729,13 @@ namespace RAT
         simulation.set_size(loop_ub_tmp);
         reflectivity.set_size(loop_ub_tmp);
         sldProfiles.set_size(loop_ub_tmp, 2);
-        b_index = loop_ub_tmp - 1;
+        loop_ub = loop_ub_tmp - 1;
 
 #pragma omp parallel for \
  num_threads(omp_get_max_threads()) \
  private(simulationXData,d,b_dataIndices,iv3,iv4,iv5,iv6,dv2,dv3)
 
-        for (int c_i = 0; c_i <= b_index; c_i++) {
+        for (int c_i = 0; c_i <= loop_ub; c_i++) {
           iv3[0] = (*(int (*)[2])((::coder::array<double, 2U> *)
                      &problemStruct.contrastBackgroundParams[c_i].f1)->size())[0];
           iv3[1] = (*(int (*)[2])((::coder::array<double, 2U> *)
@@ -828,8 +880,8 @@ namespace RAT
           layers[b_i + layers.size(0) * j].f1.set_size(domainLayers[b_i].f1[j].
             f1.size(0), domainLayers[b_i].f1[j].f1.size(1));
           for (int i{0}; i < loop_ub; i++) {
-            b_index = domainLayers[b_i].f1[j].f1.size(0);
-            for (int i1{0}; i1 < b_index; i1++) {
+            b_loop_ub = domainLayers[b_i].f1[j].f1.size(0);
+            for (int i1{0}; i1 < b_loop_ub; i1++) {
               layers[b_i + layers.size(0) * j].f1[i1 + layers[b_i + layers.size
                 (0) * j].f1.size(0) * i] = domainLayers[b_i].f1[j].f1[i1 +
                 domainLayers[b_i].f1[j].f1.size(0) * i];
@@ -881,6 +933,8 @@ namespace RAT
       ::coder::array<cell_wrap_9, 1U> contrastLayers2;
       ::coder::array<cell_wrap_9, 1U> contrastSlds1;
       ::coder::array<cell_wrap_9, 1U> contrastSlds2;
+      ::coder::array<double, 2U> inputDomainContrastLayers1_tmp;
+      ::coder::array<double, 2U> inputDomainContrastLayers2;
       ::coder::array<double, 2U> r1;
       ::coder::array<double, 1U> b_simulationXData;
       ::coder::array<double, 1U> domainRatios;
@@ -899,7 +953,7 @@ namespace RAT
       int iv5[2];
       int iv6[2];
       int switch_expression_size[2];
-      int b_index;
+      int b_loop_ub;
       int loop_ub;
       int loop_ub_tmp;
       int nParams;
@@ -1012,18 +1066,18 @@ namespace RAT
                    switch_expression_data, switch_expression_size);
       if (coder::internal::k_strcmp(switch_expression_data,
            switch_expression_size)) {
-        b_index = 0;
+        loop_ub = 0;
       } else if (coder::internal::n_strcmp(switch_expression_data,
                   switch_expression_size)) {
-        b_index = 1;
+        loop_ub = 1;
       } else if (coder::internal::o_strcmp(switch_expression_data,
                   switch_expression_size)) {
-        b_index = 2;
+        loop_ub = 2;
       } else {
-        b_index = -1;
+        loop_ub = -1;
       }
 
-      switch (b_index) {
+      switch (loop_ub) {
        case 0:
         //  First we need to allocate the absolute values of the input
         //  parameters to all the layers in the layers list. This only
@@ -1043,9 +1097,61 @@ namespace RAT
           //  layers list are required for this contrast, and put them
           //  in the correct order according to geometry. We run it
           //  twice, once for each domain
-          allocateLayersForContrast(problemStruct.domainContrastLayers[
-            static_cast<int>(problemStruct.contrastLayers[b_i].f1[0]) - 1].f1,
-            layerValues, r1);
+          if ((problemStruct.contrastLayers[b_i].f1.size(0) == 0) ||
+              (problemStruct.contrastLayers[b_i].f1.size(1) == 0)) {
+            inputDomainContrastLayers1_tmp.set_size(0, 0);
+            inputDomainContrastLayers2.set_size(0, 0);
+          } else {
+            inputDomainContrastLayers1_tmp.set_size
+              (problemStruct.domainContrastLayers[problemStruct.domainContrastLayers.size
+               (0) * (static_cast<int>
+                      (problemStruct.contrastLayers[problemStruct.contrastLayers.size
+                       (0) * b_i].f1[0]) - 1)].f1.size(0),
+               problemStruct.domainContrastLayers[problemStruct.domainContrastLayers.size
+               (0) * (static_cast<int>
+                      (problemStruct.contrastLayers[problemStruct.contrastLayers.size
+                       (0) * b_i].f1[0]) - 1)].f1.size(1));
+            loop_ub = problemStruct.domainContrastLayers[static_cast<int>
+              (problemStruct.contrastLayers[b_i].f1[0]) - 1].f1.size(1);
+            for (int i{0}; i < loop_ub; i++) {
+              b_loop_ub = problemStruct.domainContrastLayers[static_cast<int>
+                (problemStruct.contrastLayers[b_i].f1[0]) - 1].f1.size(0);
+              for (int i1{0}; i1 < b_loop_ub; i1++) {
+                inputDomainContrastLayers1_tmp[i1 +
+                  inputDomainContrastLayers1_tmp.size(0) * i] =
+                  problemStruct.domainContrastLayers[static_cast<int>
+                  (problemStruct.contrastLayers[b_i].f1[0]) - 1].f1[i1 +
+                  problemStruct.domainContrastLayers[static_cast<int>
+                  (problemStruct.contrastLayers[b_i].f1[0]) - 1].f1.size(0) * i];
+              }
+            }
+
+            inputDomainContrastLayers2.set_size
+              (problemStruct.domainContrastLayers[problemStruct.domainContrastLayers.size
+               (0) * (static_cast<int>
+                      (problemStruct.contrastLayers[problemStruct.contrastLayers.size
+                       (0) * b_i].f1[1]) - 1)].f1.size(0),
+               problemStruct.domainContrastLayers[problemStruct.domainContrastLayers.size
+               (0) * (static_cast<int>
+                      (problemStruct.contrastLayers[problemStruct.contrastLayers.size
+                       (0) * b_i].f1[1]) - 1)].f1.size(1));
+            loop_ub = problemStruct.domainContrastLayers[static_cast<int>
+              (problemStruct.contrastLayers[b_i].f1[1]) - 1].f1.size(1);
+            for (int i{0}; i < loop_ub; i++) {
+              b_loop_ub = problemStruct.domainContrastLayers[static_cast<int>
+                (problemStruct.contrastLayers[b_i].f1[1]) - 1].f1.size(0);
+              for (int i1{0}; i1 < b_loop_ub; i1++) {
+                inputDomainContrastLayers2[i1 + inputDomainContrastLayers2.size
+                  (0) * i] = problemStruct.domainContrastLayers[static_cast<int>
+                  (problemStruct.contrastLayers[b_i].f1[1]) - 1].f1[i1 +
+                  problemStruct.domainContrastLayers[static_cast<int>
+                  (problemStruct.contrastLayers[b_i].f1[1]) - 1].f1.size(0) * i];
+              }
+            }
+          }
+
+          allocateLayersForContrast(inputDomainContrastLayers1_tmp, layerValues,
+            r1);
           contrastLayers1[b_i].f1.set_size(r1.size(0), 6);
           loop_ub = r1.size(0);
           for (int i{0}; i < 6; i++) {
@@ -1055,9 +1161,7 @@ namespace RAT
             }
           }
 
-          allocateLayersForContrast(problemStruct.domainContrastLayers[
-            static_cast<int>(problemStruct.contrastLayers[b_i].f1[1]) - 1].f1,
-            layerValues, r1);
+          allocateLayersForContrast(inputDomainContrastLayers2, layerValues, r1);
           contrastLayers2[b_i].f1.set_size(r1.size(0), 6);
           loop_ub = r1.size(0);
           for (int i{0}; i < 6; i++) {
@@ -1110,13 +1214,13 @@ namespace RAT
           simulation.set_size(loop_ub_tmp);
           reflectivity.set_size(loop_ub_tmp);
           sldProfiles.set_size(loop_ub_tmp, 2);
-          b_index = static_cast<int>(problemStruct.numberOfContrasts) - 1;
+          loop_ub = static_cast<int>(problemStruct.numberOfContrasts) - 1;
 
 #pragma omp parallel for \
  num_threads(omp_get_max_threads()) \
  private(simulationXData,d,b_dataIndices,iv3,iv4,iv5,iv6,dv2,dv3)
 
-          for (int c_i = 0; c_i <= b_index; c_i++) {
+          for (int c_i = 0; c_i <= loop_ub; c_i++) {
             iv3[0] = (*(int (*)[2])((::coder::array<double, 2U> *)
                        &problemStruct.contrastBackgroundParams[c_i].f1)->size())
               [0];
@@ -1261,13 +1365,13 @@ namespace RAT
         simulation.set_size(loop_ub_tmp);
         reflectivity.set_size(loop_ub_tmp);
         sldProfiles.set_size(loop_ub_tmp, 2);
-        b_index = loop_ub_tmp - 1;
+        loop_ub = loop_ub_tmp - 1;
 
 #pragma omp parallel for \
  num_threads(omp_get_max_threads()) \
  private(simulationXData,d,b_dataIndices,iv3,iv4,iv5,iv6,dv2,dv3)
 
-        for (int c_i = 0; c_i <= b_index; c_i++) {
+        for (int c_i = 0; c_i <= loop_ub; c_i++) {
           iv3[0] = (*(int (*)[2])((::coder::array<double, 2U> *)
                      &problemStruct.contrastBackgroundParams[c_i].f1)->size())[0];
           iv3[1] = (*(int (*)[2])((::coder::array<double, 2U> *)
@@ -1411,8 +1515,8 @@ namespace RAT
           layers[b_i + layers.size(0) * j].f1.set_size(domainLayers[b_i].f1[j].
             f1.size(0), domainLayers[b_i].f1[j].f1.size(1));
           for (int i{0}; i < loop_ub; i++) {
-            b_index = domainLayers[b_i].f1[j].f1.size(0);
-            for (int i1{0}; i1 < b_index; i1++) {
+            b_loop_ub = domainLayers[b_i].f1[j].f1.size(0);
+            for (int i1{0}; i1 < b_loop_ub; i1++) {
               layers[b_i + layers.size(0) * j].f1[i1 + layers[b_i + layers.size
                 (0) * j].f1.size(0) * i] = domainLayers[b_i].f1[j].f1[i1 +
                 domainLayers[b_i].f1[j].f1.size(0) * i];

{ratapi-0.0.0.dev13 → ratapi-0.0.0.dev15}/cpp/RAT/groupLayersMod.cpp

@@ -63,6 +63,7 @@ namespace RAT
         }
       } else {
         int b_sizes_idx_0;
+        int c_sizes_idx_0;
         int i;
         int i1;
         int loop_ub;
@@ -117,8 +118,8 @@ namespace RAT
           }
         }
 
-        sizes_idx_1_tmp = layers.size(0);
-        loop_ub = b_sizes_idx_1_tmp;
+        c_sizes_idx_0 = layers.size(0);
+        sizes_idx_1_tmp = b_sizes_idx_1_tmp;
         outputLayers.set_size(layers.size(0), b_sizes_idx_1_tmp + 4);
         for (i = 0; i < 3; i++) {
           for (i1 = 0; i1 < sizes_idx_0; i1++) {
@@ -131,10 +132,10 @@ namespace RAT
           outputLayers[i + outputLayers.size(0) * 3] = roughnesses[i];
         }
 
-        for (i = 0; i < loop_ub; i++) {
-          for (i1 = 0; i1 < sizes_idx_1_tmp; i1++) {
+        for (i = 0; i < sizes_idx_1_tmp; i++) {
+          for (i1 = 0; i1 < c_sizes_idx_0; i1++) {
             outputLayers[i1 + outputLayers.size(0) * (i + 4)] = c_layers[i1 +
-              sizes_idx_1_tmp * i];
+              c_sizes_idx_0 * i];
           }
         }
       }

{ratapi-0.0.0.dev13 → ratapi-0.0.0.dev15}/cpp/RAT/mrdivide_helper.cpp

@@ -231,7 +231,6 @@ namespace RAT
             }
           }
         } else if (B.size(0) == 1) {
-          int Y_idx_0;
           int loop_ub;
           b_Y.set_size(A.size(0));
           loop_ub = A.size(0);
@@ -239,9 +238,9 @@ namespace RAT
             b_Y[i] = A[i] / B[0];
           }
 
-          Y_idx_0 = b_Y.size(0);
+          loop_ub = b_Y.size(0);
           Y.set_size(b_Y.size(0), 1);
-          for (int i{0}; i < Y_idx_0; i++) {
+          for (int i{0}; i < loop_ub; i++) {
             Y[i] = b_Y[i];
           }
         } else {

{ratapi-0.0.0.dev13 → ratapi-0.0.0.dev15}/cpp/RAT/splitEllipsoid.cpp

@@ -89,16 +89,16 @@ namespace RAT
     ::coder::array<double, 2U> u2new;
     ::coder::array<int, 1U> r;
     ::coder::array<int, 1U> r1;
-    ::coder::array<boolean_T, 2U> d_tmp_data;
+    ::coder::array<boolean_T, 2U> e_tmp_data;
     cell_wrap_9 temp_u1_tmp[50];
     double mu[2];
-    double VE1_tmp_data;
     double b_tmp_data;
+    double c_tmp_data;
     double tmp_data;
     int D;
     int N;
     int b_nosplit;
-    boolean_T c_tmp_data;
+    boolean_T d_tmp_data;
 
     //  Optimally bound a set of points by two ellipsoids.
     //
@@ -307,8 +307,8 @@ namespace RAT
             c_loop_ub = u.size(1);
             iindx = u.size(1);
             for (int i{0}; i < N; i++) {
-              int VE1_tmp_size[2];
               int b_tmp_size[2];
+              int c_tmp_size[2];
               int tmp_size[2];
               int d_loop_ub;
 
@@ -339,15 +339,14 @@ namespace RAT
                   }
                 }
 
-                coder::internal::blas::mtimes(r2, b_u, (double *)&VE1_tmp_data,
-                  VE1_tmp_size);
+                coder::internal::blas::mtimes(r2, b_u, (double *)&tmp_data,
+                  tmp_size);
               } else {
-                c_binary_expand_op((double *)&VE1_tmp_data, r2, u, i, mu1,
-                                   VE1_tmp_size);
+                c_binary_expand_op((double *)&tmp_data, r2, u, i, mu1, tmp_size);
               }
 
               coder::internal::blas::mtimes(VE1_data, VE1_size, (const double *)
-                &VE1_tmp_data, VE1_tmp_size, (double *)&tmp_data, tmp_size);
+                &tmp_data, tmp_size, (double *)&b_tmp_data, b_tmp_size);
               if (u.size(1) == mu2.size(1)) {
                 b_u.set_size(mu2.size(0), u.size(1));
                 for (int b_i{0}; b_i < c_loop_ub; b_i++) {
@@ -373,35 +372,34 @@ namespace RAT
                   }
                 }
 
-                coder::internal::blas::mtimes(r2, b_u, (double *)&VE1_tmp_data,
-                  VE1_tmp_size);
+                coder::internal::blas::mtimes(r2, b_u, (double *)&tmp_data,
+                  tmp_size);
               } else {
-                c_binary_expand_op((double *)&VE1_tmp_data, r2, u, i, mu2,
-                                   VE1_tmp_size);
+                c_binary_expand_op((double *)&tmp_data, r2, u, i, mu2, tmp_size);
               }
 
               coder::internal::blas::mtimes(VE2_data, VE2_size, (const double *)
-                &VE1_tmp_data, VE1_tmp_size, (double *)&b_tmp_data, b_tmp_size);
-              if (b_tmp_size[0] == 1) {
-                end_tmp = tmp_size[0];
-              } else {
+                &tmp_data, tmp_size, (double *)&c_tmp_data, c_tmp_size);
+              if (c_tmp_size[0] == 1) {
                 end_tmp = b_tmp_size[0];
+              } else {
+                end_tmp = c_tmp_size[0];
               }
 
-              if (b_tmp_size[1] == 1) {
-                d_loop_ub = tmp_size[1];
-              } else {
+              if (c_tmp_size[1] == 1) {
                 d_loop_ub = b_tmp_size[1];
+              } else {
+                d_loop_ub = c_tmp_size[1];
               }
 
               for (int b_i{0}; b_i < d_loop_ub; b_i++) {
                 for (int i1{0}; i1 < end_tmp; i1++) {
-                  c_tmp_data = (tmp_data / VS1 < b_tmp_data / VS2);
+                  d_tmp_data = (b_tmp_data / VS1 < c_tmp_data / VS2);
                 }
               }
 
-              d_tmp_data.set(&c_tmp_data, end_tmp, d_loop_ub);
-              if (coder::internal::b_ifWhileCond(d_tmp_data)) {
+              e_tmp_data.set(&d_tmp_data, end_tmp, d_loop_ub);
+              if (coder::internal::b_ifWhileCond(e_tmp_data)) {
                 m1++;
                 end_tmp = u1new.size(1);
                 for (int b_i{0}; b_i < end_tmp; b_i++) {

{ratapi-0.0.0.dev13 → ratapi-0.0.0.dev15}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = 'setuptools.build_meta'
 
 [project]
 name = "ratapi"
-version = "0.0.0.dev13"
+version = "0.0.0.dev15"
 description = "Python extension for the Reflectivity Analysis Toolbox (RAT)"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -28,7 +28,7 @@ Repository = "https://github.com/RascalSoftware/python-RAT"
 
 [project.optional-dependencies]
 dev = [
-    "pytest>=7.4.0",
+    "pytest>=7.4.0,!=9.1.0",
     "pytest-cov>=4.1.0",
     "ruff>=0.4.10"
 ]

{ratapi-0.0.0.dev13 → ratapi-0.0.0.dev15}/ratapi/utils/convert.py

@@ -5,7 +5,7 @@ from collections.abc import Iterable
 from os import PathLike
 from pathlib import Path
 
-from numpy import array, empty
+from numpy import array, empty, ndarray
 from scipy.io.matlab import MatlabOpaque, loadmat
 
 from ratapi import Project, wrappers
@@ -227,6 +227,12 @@ def r1_to_project(filename: str | PathLike) -> Project:
     if isinstance(mat_project["resolNames"], str):
         mat_project["resolNames"] = [mat_project["resolNames"]]
 
+    if isinstance(mat_project["contrastNames"], (ndarray, list)) and len(
+        dict.fromkeys(mat_project["contrastNames"])
+    ) != len(mat_project["contrastNames"]):
+        # contrast names are not unique so create unique ones
+        mat_project["contrastNames"] = [f"Contrast {i + 1}" for i in range(len(mat_project["contrastNames"]))]
+
     contrasts = ClassList(
         [
             Contrast(

{ratapi-0.0.0.dev13 → ratapi-0.0.0.dev15}/ratapi/utils/plotting.py

@@ -36,7 +36,7 @@ def _extract_plot_data(event_data: PlotEventData, q4: bool, show_error_bar: bool
     show_error_bar : bool, default: True
         Controls whether the error bars are shown
     shift_value : float
-        A value between 1 and 100 that controls the spacing between the reflectivity plots for each of the contrasts
+        A value between 0 and 100 that controls the spacing between the reflectivity plots for each of the contrasts
 
     Returns
     -------
@@ -46,14 +46,14 @@ def _extract_plot_data(event_data: PlotEventData, q4: bool, show_error_bar: bool
     """
     results = {"ref": [], "error": [], "sld": [], "sld_resample": []}
 
-    if shift_value < 1 or shift_value > 100:
-        raise ValueError("Parameter `shift_value` must be between 1 and 100")
+    if shift_value < 0 or shift_value > 100:
+        raise ValueError("Parameter `shift_value` must be between 0 and 100")
 
     for i, (r, data, sld) in enumerate(
         zip(event_data.reflectivity, event_data.shiftedData, event_data.sldProfiles, strict=False)
     ):
         # Calculate the divisor
-        div = 1 if i == 0 and not q4 else 10 ** ((i + 1) / 100 * shift_value)
+        div = 10 ** (i / 100 * shift_value)
         q4_data = 1 if not q4 or not event_data.dataPresent[i] else data[:, 0] ** 4
         mult = q4_data / div
 
@@ -137,7 +137,7 @@ def plot_ref_sld_helper(
     show_legend : bool, default: True
         Controls whether the legend is shown
     shift_value : float, default: 100
-        A value between 1 and 100 that controls the spacing between the reflectivity plots for each of the contrasts
+        A value between 0 and 100 that controls the spacing between the reflectivity plots for each of the contrasts
     animated : bool, default: False
         Controls whether the animated property of foreground plot elements should be set.
 
@@ -168,7 +168,7 @@ def plot_ref_sld_helper(
         # Plot confidence intervals if required
         if confidence_intervals is not None:
             # Calculate the divisor
-            div = 1 if i == 0 and not q4 else 10 ** ((i / 100) * shift_value)
+            div = 10 ** (i / 100 * shift_value)
             ref_min, ref_max = confidence_intervals["reflectivity"][i]
             mult = (1 if not q4 else plot_data["ref"][i][0] ** 4) / div
             ref_plot.fill_between(plot_data["ref"][i][0], ref_min * mult, ref_max * mult, alpha=0.6, color="grey")
@@ -277,7 +277,7 @@ def plot_ref_sld(
     show_legend : bool, default: True
             Controls whether the legend is shown
     shift_value : float, default: 100
-        A value between 1 and 100 that controls the spacing between the reflectivity plots for each of the contrasts
+        A value between 0 and 100 that controls the spacing between the reflectivity plots for each of the contrasts
 
     Returns
     -------
@@ -387,7 +387,7 @@ class BlittingSupport:
     show_legend : bool, default: True
         Controls whether the legend is shown
     shift_value : float, default: 100
-        A value between 1 and 100 that controls the spacing between the reflectivity plots for each of the contrasts
+        A value between 0 and 100 that controls the spacing between the reflectivity plots for each of the contrasts
     """
 
     def __init__(
@@ -763,7 +763,7 @@ def plot_one_hist(
     results: ratapi.outputs.BayesResults,
     param: int | str,
     smooth: bool = True,
-    sigma: float | None = None,
+    window_size: int = 8,
     estimated_density: Literal["normal", "lognor", "kernel", None] = None,
     axes: Axes | None = None,
     block: bool = False,
@@ -783,9 +783,9 @@ def plot_one_hist(
     smooth : bool, default True
         Whether to apply Gaussian smoothing to the histogram.
         Defaults to True.
-    sigma: float or None, default None
-        If given, is used as the sigma-parameter for the Gaussian smoothing.
-        If None, the default (1/3rd of parameter chain standard deviation) is used.
+    window_size : int, default 8
+        The width of the smoothing window centered around the element being averaged.
+        The window moves down the length of the data, computing an average over the elements within each window.
     estimated_density : 'normal', 'lognor', 'kernel' or None, default None
         If None (default), ignore. Else, add an estimated density
         of the given form on top of the histogram by the following estimations:
@@ -826,9 +826,7 @@ def plot_one_hist(
     sd_y = np.std(parameter_chain)
 
     if smooth:
-        if sigma is None:
-            sigma = sd_y / 2
-        counts = gaussian_filter1d(counts, sigma)
+        counts = moving_average(counts, window_size=window_size)
     axes.hist(
         bins[:-1],
         bins,
@@ -1134,7 +1132,6 @@ def plot_hists(
             results,
             i,
             smooth=smooth,
-            sigma=sigma,
             estimated_density=estimated_density.get(i),
             axes=ax,
             **hist_settings,
@@ -1233,3 +1230,33 @@ def plot_bayes(project: ratapi.Project, results: ratapi.outputs.BayesResults):
         plot_corner(results)
     else:
         raise ValueError("Bayes plots are only available for the results of Bayesian analysis (NS or DREAM)")
+
+
+def moving_average(data: np.ndarray, window_size: int = 8) -> list[float]:
+    """Calculate the moving average of an array with a given window size.
+
+    This is a python equivalent to MATLABs smoothdata(A, 'movmean')
+
+    Parameters
+    ----------
+    data : np.ndarray
+           The input array to smooth
+    window_size : int
+                  The window slides down the length of the vector,
+                  computing an average over the elements within each window.
+
+    """
+    if not 0 <= window_size <= len(data):
+        raise ValueError(
+            "The moving average window size is out of range. Please change to a positive integer which "
+            "does not exceed the number of histogram bins."
+        )
+    moving_averages = []
+
+    for i in range(len(data)):
+        start_window_ind = floor(float(i - window_size / 2)) if i - window_size / 2 > 0 else 0
+        end_window_ind = floor(float(i + window_size / 2)) if i + window_size / 2 < len(data) else len(data)
+        window_average = np.sum(data[start_window_ind:end_window_ind]) / (end_window_ind + 0 - start_window_ind)
+        moving_averages.append(window_average)
+
+    return moving_averages

{ratapi-0.0.0.dev13 → ratapi-0.0.0.dev15/ratapi.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ratapi
-Version: 0.0.0.dev13
+Version: 0.0.0.dev15
 Summary: Python extension for the Reflectivity Analysis Toolbox (RAT)
 Project-URL: Documentation, https://rascalsoftware.github.io/RAT/
 Project-URL: Repository, https://github.com/RascalSoftware/python-RAT