no longer pass mean to sample generator

Sim/Scan/AlphaScan.cpp

@@ -31,11 +31,11 @@ size_t nResolSamples(const ScanResolution* resol)
     return resol ? resol->nSamples() : 1L;
 }
 
-std::vector<ParameterSample> drawResolution(const ScanResolution* resol, double mean)
+std::vector<ParameterSample> drawResolution(const ScanResolution* resol)
 {
-    if (resol)
-        return resol->resolutionSamples(mean);
-    return {{mean, 1}};
+    if (!resol)
+        return {{0., 1}};
+    return resol->resolutionSamples(0.);
 }
 
 } // namespace
@@ -81,18 +81,16 @@ std::vector<SpecularElement> AlphaScan::generateElements() const
     result.reserve(nSteps());
 
     for (size_t i = 0; i < m_axis->size(); ++i) {
-        const std::vector<ParameterSample> lambdaDistrib =
-            drawResolution(m_lambda_distrib.get(), wavelength());
-        const std::vector<ParameterSample> alphaDistrib =
-            drawResolution(m_alpha_distrib.get(), m_axis->binCenters()[i]);
+        const std::vector<ParameterSample> lambdaDistrib = drawResolution(m_lambda_distrib.get());
+        const std::vector<ParameterSample> alphaDistrib = drawResolution(m_alpha_distrib.get());
         for (size_t j = 0; j < alphaDistrib.size(); ++j) {
-            const double alpha = alphaDistrib[j].value;
+            const double alpha = m_axis->binCenters()[i] + alphaDistrib[j].value;
             for (size_t k = 0; k < lambdaDistrib.size(); ++k) {
-                const double wavelength = lambdaDistrib[k].value;
-                const bool computable = wavelength >= 0 && alpha >= 0 && alpha <= M_PI_2;
+                const double lambda = wavelength() + lambdaDistrib[k].value;
+                const bool computable = lambda >= 0 && alpha >= 0 && alpha <= M_PI_2;
                 const double weight = alphaDistrib[j].weight * lambdaDistrib[k].weight;
                 const double footprint = m_footprint ? m_footprint->calculate(alpha) : 1;
-                result.emplace_back(SpecularElement::FromAlphaScan(i, weight, wavelength, -alpha,
+                result.emplace_back(SpecularElement::FromAlphaScan(i, weight, lambda, -alpha,
                                                                    footprint, polarizerMatrix(),
                                                                    analyzerMatrix(), computable));
             }