rename -> ProcessedSample::m_stack

Resample/Processed/ProcessedSample.cpp

@@ -230,12 +230,12 @@ ProcessedSample::ProcessedSample(const MultiLayer& sample, bool polarized,
     : m_sample(sample)
     , m_polarized(polarized)
     , m_layouts(std::move(layouts))
-    , m_refined_stack(refined_stack)
+    , m_stack(refined_stack)
 {
 }
 
 ProcessedSample::ProcessedSample(ProcessedSample&&)
-    : ProcessedSample(m_sample, m_polarized, std::move(m_layouts), m_refined_stack)
+    : ProcessedSample(m_sample, m_polarized, std::move(m_layouts), m_stack)
 {
 }
 
@@ -243,17 +243,17 @@ ProcessedSample::~ProcessedSample() = default;
 
 size_t ProcessedSample::numberOfSlices() const
 {
-    return m_refined_stack.size();
+    return m_stack.size();
 }
 
 const SliceStack& ProcessedSample::averageSlices() const
 {
-    return m_refined_stack;
+    return m_stack;
 }
 
 const Slice& ProcessedSample::avgeSlice(size_t i) const
 {
-    return m_refined_stack.at(i);
+    return m_stack.at(i);
 }
 
 const std::vector<ProcessedLayout>& ProcessedSample::layouts() const
@@ -263,12 +263,12 @@ const std::vector<ProcessedLayout>& ProcessedSample::layouts() const
 
 double ProcessedSample::sliceTopZ(size_t i) const
 {
-    return m_refined_stack.at(i).zTop();
+    return m_stack.at(i).zTop();
 }
 
 double ProcessedSample::sliceBottomZ(size_t i) const
 {
-    return m_refined_stack.at(i).zBottom();
+    return m_stack.at(i).zBottom();
 }
 
 bool ProcessedSample::containsMagneticMaterial() const
@@ -283,7 +283,7 @@ bool ProcessedSample::polarizing() const
 
 bool ProcessedSample::hasRoughness() const
 {
-    for (const auto& slice : m_refined_stack)
+    for (const auto& slice : m_stack)
         if (slice.topRoughness())
             return true;
     return false;
@@ -292,15 +292,15 @@ bool ProcessedSample::hasRoughness() const
 Fluxes ProcessedSample::fluxesIn(const kvector_t& k) const
 {
     if (m_polarized)
-        return Compute::SpecularMagnetic::fluxes(m_refined_stack, k, true);
-    return Compute::SpecularScalar::fluxes(m_refined_stack, k);
+        return Compute::SpecularMagnetic::fluxes(m_stack, k, true);
+    return Compute::SpecularScalar::fluxes(m_stack, k);
 }
 
 Fluxes ProcessedSample::fluxesOut(const kvector_t& k) const
 {
     if (m_polarized)
-        return Compute::SpecularMagnetic::fluxes(m_refined_stack, -k, false);
-    return Compute::SpecularScalar::fluxes(m_refined_stack, -k);
+        return Compute::SpecularMagnetic::fluxes(m_stack, -k, false);
+    return Compute::SpecularScalar::fluxes(m_stack, -k);
 }
 
 double ProcessedSample::crossCorrSpectralFun(const kvector_t kvec, size_t j, size_t k) const
@@ -310,8 +310,8 @@ double ProcessedSample::crossCorrSpectralFun(const kvector_t kvec, size_t j, siz
         return 0.0;
     const double z_j = sliceBottomZ(j);
     const double z_k = sliceBottomZ(k);
-    const LayerRoughness* rough_j = m_refined_stack.at(j + 1).topRoughness();
-    const LayerRoughness* rough_k = m_refined_stack.at(k + 1).topRoughness();
+    const LayerRoughness* rough_j = m_stack.at(j + 1).topRoughness();
+    const LayerRoughness* rough_k = m_stack.at(k + 1).topRoughness();
     if (!rough_j || !rough_k)
         return 0.0;
     const double sigma_j = rough_j->getSigma();

Resample/Processed/ProcessedSample.h

@@ -70,7 +70,7 @@ private:
     const MultiLayer& m_sample;
     const bool m_polarized;
     std::vector<ProcessedLayout> m_layouts; // const forbidden by &&-c'tor < needed by tests
-    const SliceStack m_refined_stack;
+    const SliceStack m_stack;
 };
 
 #endif // BORNAGAIN_RESAMPLE_PROCESSED_PROCESSEDSAMPLE_H