do w/o extractValue

Sim/Scan/AlphaScan.cpp

@@ -22,21 +22,6 @@
 #include "Param/Distrib/RangedDistributions.h"
 #include "Resample/Element/SpecularElement.h"
 #include "Sim/Scan/ScanResolution.h"
-#include <algorithm>
-
-namespace {
-
-std::vector<double> extractValues1(const std::vector<ParameterSample>& samples,
-                                   const std::function<double(const ParameterSample&)> extractor)
-{
-    std::vector<double> result;
-    result.reserve(samples.size());
-    std::for_each(samples.begin(), samples.end(),
-                  [&](const ParameterSample& sample) { result.push_back(extractor(sample)); });
-    return result;
-}
-
-} // namespace
 
 AlphaScan::AlphaScan(double wl, std::vector<double> inc_angle)
     : m_lambda(wl)
@@ -82,7 +67,6 @@ AlphaScan::~AlphaScan() = default;
 
 std::vector<SpecularElement> AlphaScan::generateElements() const
 {
-
     std::vector<SpecularElement> result;
     result.reserve(nSteps());
 
@@ -92,12 +76,10 @@ std::vector<SpecularElement> AlphaScan::generateElements() const
         m_alpha_distrib->generateResolutionSamples(m_alpha_axis->binCenters());
 
     for (size_t i = 0; i < m_alpha_axis->size(); ++i) {
-        const auto wls = extractValues1(lambdaDistrib[i],
-                                        [](const ParameterSample& sample) { return sample.value; });
-        const auto incs = extractValues1(
-            alphaDistrib[i], [](const ParameterSample& sample) { return sample.value; });
-        for (const double alpha : incs) {
-            for (const double wavelength : wls) {
+        for (size_t j = 0; j < alphaDistrib[i].size(); ++j) {
+            const double alpha = alphaDistrib[i][j].value;
+            for (size_t k = 0; k < lambdaDistrib[i].size(); ++k) {
+                const double wavelength = lambdaDistrib[i][k].value;
                 const bool computable = wavelength >= 0 && alpha >= 0 && alpha <= M_PI_2;
                 result.emplace_back(SpecularElement::FromAlphaScan(
                     wavelength, -alpha, polarizerMatrix(), analyzerMatrix(), computable));
@@ -156,11 +138,9 @@ std::vector<double> AlphaScan::footprint(size_t start, size_t n_elements) const
     int left = static_cast<int>(n_elements);
     size_t pos_res = 0;
     for (size_t i = pos_out; left > 0; ++i) {
-        const auto sample_values = extractValues1(
-            alphaDistrib[i], [](const ParameterSample& sample) { return sample.value; });
         for (size_t k = pos_inc; k < n_inc_samples && left > 0; ++k) {
             pos_inc = 0;
-            const double angle = sample_values[k];
+            const double angle = alphaDistrib[i][k].value;
             const double footprint =
                 (angle >= 0 && angle <= M_PI_2) ? m_footprint->calculate(angle) : 1.0;
             for (size_t j = pos_wl; j < n_wl_samples && left > 0; ++j) {
@@ -196,14 +176,12 @@ std::vector<double> AlphaScan::createIntensities(const std::vector<SpecularEleme
 
     size_t elem_pos = 0;
     for (size_t i = 0; i < axis_size; ++i) {
-        const auto wl_weights = extractValues1(
-            lambdaDistrib[i], [](const ParameterSample& sample) { return sample.weight; });
-        const auto inc_weights = extractValues1(
-            alphaDistrib[i], [](const ParameterSample& sample) { return sample.weight; });
-        double& current = result[i];
-        for (const double inc_weight : inc_weights) {
-            for (const double wl_weight : wl_weights) {
-                current += eles[elem_pos].intensity() * inc_weight * wl_weight;
+        for (size_t j = 0; j < alphaDistrib[i].size(); ++j) {
+            const double alpha_wgt = alphaDistrib[i][j].weight;
+            for (size_t k = 0; k < lambdaDistrib[i].size(); ++k) {
+                const double lambda_wgt = lambdaDistrib[i][k].weight;
+
+                result[i] += eles[elem_pos].intensity() * alpha_wgt * lambda_wgt;
                 ++elem_pos;
             }
         }