rm layerRoughness

GUI/Model/FromCore/ItemizeSample.cpp

@@ -654,7 +654,7 @@ SampleItem* itemizeSample(const MultiLayer& sample, const QString& nodeName)
         const auto* layer = sample.layer(layerIndex);
 
         const LayerRoughness* top_roughness =
-            layerIndex == 0 ? nullptr : sample.layerRoughness(layerIndex);
+            layerIndex == 0 ? nullptr : sample.layer(layerIndex)->roughness();
 
         auto* layerItem = result->createLayerItemAt();
         layerItem->setMaterial(findMaterialItem(matItems, layer));

Resample/Processed/ReSample.cpp

@@ -85,7 +85,7 @@ const LayerRoughness* layerTopRoughness(const MultiLayer& sample, size_t i_layer
 {
     if (i_layer == 0)
         return nullptr;
-    return sample.layerRoughness(i_layer);
+    return sample.layer(i_layer)->roughness();
 }
 
 //! Returns a vector of slices that represent the layer structure of the sample.

Sample/Interface/RoughnessMap.cpp

@@ -16,6 +16,7 @@
 #include "Base/Const/PhysicalConstants.h"
 #include "Base/Util/Assert.h"
 #include "Sample/Interface/LayerRoughness.h"
+#include "Sample/Multilayer/Layer.h"
 #include <algorithm>
 
 using PhysConsts::pi;
@@ -80,9 +81,9 @@ double2d_t RoughnessMap::generateMap()
 double2d_t RoughnessMap::mapFromHeights() const
 {
     const size_t z_steps = 3999;
-    const InterlayerModel* interlayerModel = m_sample.layerRoughness(m_i_layer)->interlayerModel();
+    const InterlayerModel* interlayer = m_sample.layer(m_i_layer)->roughness()->interlayerModel();
     const double rms = m_sample.layerRoughnessRMS(m_i_layer);
-    const double sigma_factor = interlayerModel->sigmaRange();
+    const double sigma_factor = interlayer->sigmaRange();
     const double z_limit = rms * sigma_factor;
     const double step = 2 * z_limit / (z_steps - 1);
 
@@ -94,7 +95,7 @@ double2d_t RoughnessMap::mapFromHeights() const
     // fill mesh with weights
     std::vector<double> z_weights(z_steps);
     for (size_t i = 0; i < z_steps; i++)
-        z_weights[i] = interlayerModel->distribution(z_points[i], rms);
+        z_weights[i] = interlayer->distribution(z_points[i], rms);
 
     // fill map with random values
     std::discrete_distribution<int> d(z_weights.begin(), z_weights.end());

Sample/Multilayer/MultiLayer.cpp

@@ -58,14 +58,14 @@ void MultiLayer::addLayer(const Layer& layer)
 
 const AutocorrelationModel* MultiLayer::autocorrAt(int i_layer) const
 {
-    return layerRoughness(i_layer)->autocorrelationModel();
+    return layer(i_layer)->roughness()->autocorrelationModel();
 }
 
 double MultiLayer::maxCutoffSpatialFrequencyAt(size_t i_layer) const
 {
     double result = 0;
     for (size_t i = i_layer; i < m_layers.size(); i++) {
-        const auto autocorr = layerRoughness(i_layer)->autocorrelationModel();
+        const auto autocorr = layer(i_layer)->roughness()->autocorrelationModel();
         result = std::max(autocorr->maxSpatialFrequency(), result);
     }
     return result;
@@ -76,11 +76,6 @@ const Layer* MultiLayer::layer(size_t i_layer) const
     return m_layers.at(i_layer);
 }
 
-const LayerRoughness* MultiLayer::layerRoughness(size_t i_layer) const
-{
-    return m_layers.at(i_layer)->roughness();
-}
-
 void MultiLayer::setExternalField(const R3& ext_field)
 {
     m_ext_field = ext_field;

Sample/Multilayer/MultiLayer.h

@@ -78,7 +78,6 @@ public:
     }
 
     const Layer* layer(size_t i_layer) const;
-    const LayerRoughness* layerRoughness(size_t i_layer) const;
     R3 externalField() const
     {
         return m_ext_field;

Tests/Unit/Sample/MultiLayerTest.cpp

@@ -83,15 +83,15 @@ TEST_F(MultiLayerTest, LayerInterfaces)
     set_four();
 
     // check interfaces
-    const LayerRoughness* roughness1 = mLayer.layerRoughness(1);
+    const LayerRoughness* roughness1 = mLayer.layer(1)->roughness();
     EXPECT_TRUE(nullptr != roughness1);
     EXPECT_EQ(mLayer.layerRoughnessRMS(1), 0.0);
 
-    const LayerRoughness* roughness2 = mLayer.layerRoughness(2);
+    const LayerRoughness* roughness2 = mLayer.layer(2)->roughness();
     EXPECT_TRUE(nullptr != roughness2);
     EXPECT_EQ(mLayer.layerRoughnessRMS(2), 0.0);
 
-    const LayerRoughness* roughness3 = mLayer.layerRoughness(3);
+    const LayerRoughness* roughness3 = mLayer.layer(3)->roughness();
     EXPECT_TRUE(nullptr != roughness3);
     EXPECT_EQ(mLayer.layerRoughnessRMS(3), 0.0);
 }
@@ -112,19 +112,19 @@ TEST_F(MultiLayerTest, Clone)
     EXPECT_EQ(substrate.thickness(), mLayerClone->layer(3)->thickness());
 
     // check interfaces
-    const LayerRoughness* roughness0 = mLayerClone->layerRoughness(0);
+    const LayerRoughness* roughness0 = mLayerClone->layer(1)->roughness();
     EXPECT_TRUE(nullptr != roughness0);
-    EXPECT_EQ(mLayerClone->layerRoughnessRMS(0), 0.0);
+    EXPECT_EQ(mLayerClone->layerRoughnessRMS(1), 0.0);
     EXPECT_TRUE(nullptr == roughness0->crosscorrelationModel());
 
-    const LayerRoughness* roughness1 = mLayerClone->layerRoughness(1);
+    const LayerRoughness* roughness1 = mLayerClone->layer(2)->roughness();
     EXPECT_TRUE(nullptr != roughness1);
-    EXPECT_EQ(mLayerClone->layerRoughnessRMS(1), 0.0);
+    EXPECT_EQ(mLayerClone->layerRoughnessRMS(2), 0.0);
     EXPECT_TRUE(nullptr == roughness1->crosscorrelationModel());
 
-    const LayerRoughness* roughness2 = mLayerClone->layerRoughness(2);
+    const LayerRoughness* roughness2 = mLayerClone->layer(3)->roughness();
     EXPECT_TRUE(nullptr != roughness2);
-    EXPECT_EQ(mLayerClone->layerRoughnessRMS(2), 0.0);
+    EXPECT_EQ(mLayerClone->layerRoughnessRMS(3), 0.0);
     EXPECT_TRUE(nullptr == roughness2->crosscorrelationModel());
 
     delete mLayerClone;
@@ -140,8 +140,8 @@ TEST_F(MultiLayerTest, WithRoughness)
     mLayer.addLayer(Layer(*layer1.material(), layer1.thickness(), &lr));
     mLayer.addLayer(substrate);
 
-    const LayerRoughness* roughness0 = mLayer.layerRoughness(1);
-    const LayerRoughness* roughness1 = mLayer.layerRoughness(2);
+    const LayerRoughness* roughness0 = mLayer.layer(1)->roughness();
+    const LayerRoughness* roughness1 = mLayer.layer(2)->roughness();
 
     EXPECT_TRUE(roughness0);
     auto* roughness0_AC =
@@ -175,8 +175,8 @@ TEST_F(MultiLayerTest, CloneWithRoughness)
 
     MultiLayer* mLayerClone = mLayer.clone();
 
-    const LayerRoughness* roughness1 = mLayerClone->layerRoughness(1);
-    const LayerRoughness* roughness2 = mLayerClone->layerRoughness(2);
+    const LayerRoughness* roughness1 = mLayerClone->layer(1)->roughness();
+    const LayerRoughness* roughness2 = mLayerClone->layer(2)->roughness();
 
     EXPECT_TRUE(roughness1);
     EXPECT_TRUE(roughness2);