Add functional test to check neighboring magnetic layers

Core/StandardSamples/MagneticLayersBuilder.cpp

@@ -15,10 +15,12 @@
 #include "Core/StandardSamples/MagneticLayersBuilder.h"
 #include "Core/Aggregate/ParticleLayout.h"
 #include "Core/Basics/Units.h"
+#include "Core/Multilayer/LayerRoughness.h"
 #include "Core/HardParticle/FormFactorFullSphere.h"
 #include "Core/Material/MaterialFactoryFuncs.h"
 #include "Core/Multilayer/Layer.h"
 #include "Core/Multilayer/MultiLayer.h"
+#include "Core/Multilayer/RoughnessModels.h"
 #include "Core/Parametrization/RealParameter.h"
 #include "Core/Particle/Particle.h"
 
@@ -102,6 +104,61 @@ MultiLayer* MagneticLayerBuilder::buildSample() const
     return multi_layer;
 }
 
+SimpleMagneticRotationBuilder::SimpleMagneticRotationBuilder() = default;
+
+MultiLayer* SimpleMagneticRotationBuilder::buildSample() const
+{
+}
+
+MultiLayer* SimpleMagneticRotationBuilder::builder(double sigmaRoughness,
+                                                  RoughnessModel roughnessModel)
+{
+    MultiLayer* multi_layer = new MultiLayer();
+
+    kvector_t substr_field = kvector_t(0.0, 1e6, 0.0);
+    kvector_t layer_field(1e6, 0.0, 0.0);
+    Material air_material = HomogeneousMaterial("Air", 0.0, 0.0);
+    Material substrate_material = HomogeneousMaterial("Substrate", 7e-6, 2e-8, substr_field);
+    Material layer_material = HomogeneousMaterial("MagLayer", 6e-4, 2e-8, layer_field);
+
+    auto roughness = LayerRoughness();
+    roughness.setSigma(sigmaRoughness * Units::angstrom);
+
+    Layer air_layer(air_material);
+    Layer substrate_layer(substrate_material);
+    Layer layer(layer_material);
+    multi_layer->addLayer(air_layer);
+    multi_layer->addLayerWithTopRoughness(layer, roughness);
+    multi_layer->addLayerWithTopRoughness(substrate_layer, roughness);
+    multi_layer->setRoughnessModel(roughnessModel);
+    return multi_layer;
+}
+
+size_t SimpleMagneticRotationBuilder::size(){return 3;}
+
+MultiLayer* SimpleMagneticRotationBuilder::createSample(size_t index){
+
+    switch(index){
+
+        case 0:
+            return builder(0.);
+
+        case 1:
+            setName("Tanh");
+            return builder(2., RoughnessModel::TANH);
+
+        case 2:
+            setName("NC");
+            return builder(2., RoughnessModel::NEVOT_CROCE);
+
+        default:
+            throw std::runtime_error("SimpleMagneticRotationBuilder::createSample() -> Error. "
+                                 "Sample index is out of range.");
+    }
+
+}
+
+
 MagneticRotationBuilder::MagneticRotationBuilder() : m_sphere_radius(5 * Units::nanometer) {}
 
 MultiLayer* MagneticRotationBuilder::buildSample() const

Core/StandardSamples/MagneticLayersBuilder.h

@@ -16,6 +16,7 @@
 #define BORNAGAIN_CORE_STANDARDSAMPLES_MAGNETICLAYERSBUILDER_H
 
 #include "Core/Multilayer/IMultiLayerBuilder.h"
+#include "Core/Multilayer/RoughnessModels.h"
 
 class ISample;
 
@@ -55,6 +56,22 @@ private:
     double m_sphere_radius;
 };
 
+//! Builds sample: magnetic layer on a magnetic substrate with the fields rotated by 90°
+//! @ingroup standard_samples
+
+class BA_CORE_API_ SimpleMagneticRotationBuilder : public IMultiLayerBuilder
+{
+public:
+    SimpleMagneticRotationBuilder();
+    MultiLayer* buildSample() const;
+
+    MultiLayer* createSample(size_t index = 0);
+    size_t size();
+protected:
+    MultiLayer* builder(double sigmaRoughness = 0.,
+                        RoughnessModel roughnessModel = RoughnessModel::TANH);
+};
+
 //! Builds sample: rotated magnetic spheres in substrate layer with a unit magnetic field.
 //! @ingroup standard_samples
 

Core/StandardSamples/SampleBuilderFactory.cpp

@@ -113,6 +113,8 @@ SampleBuilderFactory::SampleBuilderFactory()
 
     registerItem("SimpleMagneticLayerBuilder", create_new<SimpleMagneticLayerBuilder>);
 
+    registerItem("SimpleMagneticRotationBuilder", create_new<SimpleMagneticRotationBuilder>);
+
     registerItem("MagneticLayerBuilder", create_new<MagneticLayerBuilder>);
 
     registerItem("FeNiBiLayerBuilder", create_new<FeNiBiLayerBuilder>);

Tests/Functional/Std/StandardTests.h

@@ -515,6 +515,18 @@ TEST_F(Std, PolarizedQAngleReflectivityMM)
                     "SimpleMagneticLayerBuilder", 1e-10));
 }
 
+TEST_F(Std, MagneticRotationReflectivity)
+{
+    EXPECT_TRUE(run("MagneticRotationReflectivityPP", "BasicSpecularPP",
+                    "SimpleMagneticRotationBuilder", 1e-10));
+    EXPECT_TRUE(run("MagneticRotationReflectivityMM", "BasicSpecularMM",
+                    "SimpleMagneticRotationBuilder", 1e-10));
+    EXPECT_TRUE(run("MagneticRotationReflectivityPM", "BasicSpecularPM",
+                    "SimpleMagneticRotationBuilder", 1e-10));
+    EXPECT_TRUE(run("MagneticRotationReflectivityMP", "BasicSpecularMP",
+                    "SimpleMagneticRotationBuilder", 1e-10));
+}
+
 TEST_F(Std, PolarizedFeNiBiLayerPP)
 {
     EXPECT_TRUE(run("PolarizedFeNiBiLayerPP", "BasicSpecularPP",