diff --git a/Core/Examples/SimulationFactory.cpp b/Core/Examples/SimulationFactory.cpp
index 12bb55c8a145062db1d3b8e7f1749fdc5bc777ea..74de82be2add49fe26f34ee0ad1104e2345efd80 100644
--- a/Core/Examples/SimulationFactory.cpp
+++ b/Core/Examples/SimulationFactory.cpp
@@ -84,24 +84,6 @@ SimulationFactory::SimulationFactory()
 
     registerItem("OffSpecularMini", StandardSimulations::MiniOffSpecular);
 
-    // polarized specular
-
-    registerItem("BasicSpecularPP", StandardSimulations::BasicSpecularPP);
-
-    registerItem("BasicSpecularMM", StandardSimulations::BasicSpecularMM);
-
-    registerItem("BasicSpecularPM", StandardSimulations::BasicSpecularPM);
-
-    registerItem("BasicSpecularMP", StandardSimulations::BasicSpecularMP);
-
-    registerItem("BasicQSpecularPP", StandardSimulations::BasicSpecularQPP);
-
-    registerItem("BasicQSpecularMM", StandardSimulations::BasicSpecularQMM);
-
-    registerItem("BasicQSpecularPM", StandardSimulations::BasicSpecularQPM);
-
-    registerItem("BasicQSpecularMP", StandardSimulations::BasicSpecularQMP);
-
     // depth probe simulations
 
     registerItem("BasicDepthProbe", StandardSimulations::BasicDepthProbe);
diff --git a/Core/Examples/StandardSimulations.cpp b/Core/Examples/StandardSimulations.cpp
index bbd1654ffe054e1879b410914569541085234601..6bb2183d6cc2b92b52a9bfe64ade5be86721c499 100644
--- a/Core/Examples/StandardSimulations.cpp
+++ b/Core/Examples/StandardSimulations.cpp
@@ -45,18 +45,18 @@ const double rdet_width(20.0), rdet_height(18.0), rdet_distance(1000.0);
 const R3 zplus(0.0, 0.0, 1.0);
 const R3 yplus(0.0, 1.0, 0.0);
 
-const std::map<std::string, std::pair<R3,R3>> ZPolarizationCases = {
-    {"PP", { +zplus, +zplus }},
-    {"PM", { +zplus, -zplus }},
-    {"MP", { -zplus, +zplus }},
-    {"MM", { -zplus, -zplus }},
+const std::map<std::string, std::pair<R3, R3>> ZPolarizationCases = {
+    {"PP", {+zplus, +zplus}},
+    {"PM", {+zplus, -zplus}},
+    {"MP", {-zplus, +zplus}},
+    {"MM", {-zplus, -zplus}},
 };
 
-const std::map<std::string, std::pair<R3,R3>> YPolarizationCases = {
-    {"PP", { +yplus, +yplus }},
-    {"PM", { +yplus, -yplus }},
-    {"MP", { -yplus, +yplus }},
-    {"MM", { -yplus, -yplus }},
+const std::map<std::string, std::pair<R3, R3>> YPolarizationCases = {
+    {"PP", {+yplus, +yplus}},
+    {"PM", {+yplus, -yplus}},
+    {"MP", {-yplus, +yplus}},
+    {"MM", {-yplus, -yplus}},
 };
 
 } // namespace
@@ -415,62 +415,6 @@ SpecularSimulation* StandardSimulations::TOFRWithPointwiseResolution()
     return result;
 }
 
-// ------------ polarized specular ----------------
-SpecularSimulation* StandardSimulations::BasicSpecularPP()
-{
-    auto* simulation = BasicSpecular();
-    simulation->instrument().setPolFilters(yplus, yplus, 1.0, 0.5);
-    return simulation;
-}
-
-SpecularSimulation* StandardSimulations::BasicSpecularPM()
-{
-    auto* simulation = BasicSpecular();
-    simulation->instrument().setPolFilters(yplus, -yplus, 1.0, 0.5);
-    return simulation;
-}
-
-SpecularSimulation* StandardSimulations::BasicSpecularMP()
-{
-    auto* simulation = BasicSpecular();
-    simulation->instrument().setPolFilters(-yplus, yplus, 1.0, 0.5);
-    return simulation;
-}
-
-SpecularSimulation* StandardSimulations::BasicSpecularMM()
-{
-    auto* simulation = BasicSpecular();
-    simulation->instrument().setPolFilters(-yplus, -yplus, 1.0, 0.5);
-    return simulation;
-}
-
-SpecularSimulation* StandardSimulations::BasicSpecularQPP()
-{
-    auto* simulation = BasicSpecularQ();
-    simulation->instrument().setPolFilters(yplus, yplus, 1.0, 0.5);
-    return simulation;
-}
-
-SpecularSimulation* StandardSimulations::BasicSpecularQPM()
-{
-    auto* simulation = BasicSpecularQ();
-    simulation->instrument().setPolFilters(yplus, -yplus, 1.0, 0.5);
-    return simulation;
-}
-
-SpecularSimulation* StandardSimulations::BasicSpecularQMP()
-{
-    auto* simulation = BasicSpecularQ();
-    simulation->instrument().setPolFilters(-yplus, yplus, 1.0, 0.5);
-    return simulation;
-}
-
-SpecularSimulation* StandardSimulations::BasicSpecularQMM()
-{
-    auto* simulation = BasicSpecularQ();
-    simulation->instrument().setPolFilters(-yplus, -yplus, 1.0, 0.5);
-    return simulation;
-}
 
 // ----------------------- off-spec simulations ------------------
 
@@ -549,8 +493,8 @@ GISASSimulation StdSimulations::MiniGISAS_v2(const MultiLayer& sample)
     return GISASSimulation(beam, sample, det);
 }
 
-GISASSimulation StdSimulations::MiniZPolarizedGISAS(
-    const MultiLayer& sample, const std::string& polCase)
+GISASSimulation StdSimulations::MiniZPolarizedGISAS(const MultiLayer& sample,
+                                                    const std::string& polCase)
 {
     const auto zCase = ZPolarizationCases.at(polCase);
     Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
@@ -560,8 +504,8 @@ GISASSimulation StdSimulations::MiniZPolarizedGISAS(
     return GISASSimulation(beam, sample, det);
 }
 
-SpecularSimulation StdSimulations::BasicYPolarizedSpecular(
-    const MultiLayer& sample, const std::string& polCase)
+SpecularSimulation StdSimulations::BasicYPolarizedSpecular(const MultiLayer& sample,
+                                                           const std::string& polCase)
 {
     const auto yCase = YPolarizationCases.at(polCase);
     auto simulation = StandardSimulations::BasicSpecular();
@@ -571,8 +515,8 @@ SpecularSimulation StdSimulations::BasicYPolarizedSpecular(
 }
 
 
-SpecularSimulation StdSimulations::BasicYPolarizedSpecularQ(
-    const MultiLayer& sample, const std::string& polCase)
+SpecularSimulation StdSimulations::BasicYPolarizedSpecularQ(const MultiLayer& sample,
+                                                            const std::string& polCase)
 {
     const auto yCase = YPolarizationCases.at(polCase);
     auto simulation = StandardSimulations::BasicSpecularQ();
diff --git a/Core/Examples/StandardSimulations.h b/Core/Examples/StandardSimulations.h
index b4e53d029a6c1588271ece10105974e4e2ff494d..5e012793fe8f8f767980a9fe60fd2ced978db2f6 100644
--- a/Core/Examples/StandardSimulations.h
+++ b/Core/Examples/StandardSimulations.h
@@ -66,16 +66,6 @@ SpecularSimulation* SpecularDivergentBeam();
 SpecularSimulation* TOFRWithRelativeResolution();
 SpecularSimulation* TOFRWithPointwiseResolution();
 
-// polarized specular:
-SpecularSimulation* BasicSpecularPP();
-SpecularSimulation* BasicSpecularMM();
-SpecularSimulation* BasicSpecularPM();
-SpecularSimulation* BasicSpecularMP();
-SpecularSimulation* BasicSpecularQPP();
-SpecularSimulation* BasicSpecularQMM();
-SpecularSimulation* BasicSpecularQPM();
-SpecularSimulation* BasicSpecularQMP();
-
 // OffSpecular simulations
 OffSpecularSimulation* MiniOffSpecular();
 
diff --git a/Fit/TestEngine/IFactory.h b/Fit/TestEngine/IFactory.h
index 8ce057749cfcd2891c57f11f641a726768df087c..fc5616cb3fdb26a6d9739b219117eeb971c41992 100644
--- a/Fit/TestEngine/IFactory.h
+++ b/Fit/TestEngine/IFactory.h
@@ -34,7 +34,7 @@ namespace mumufit::test {
 template <class Key, class AbstractProduct> class IFactory {
 public:
     //! function which will be used to create object of AbstractProduct base type
-    using CreateItemCallback = std::function<AbstractProduct*()> ;
+    using CreateItemCallback = std::function<AbstractProduct*()>;
 
     //! map for correspondence between object identifier and object creation function
     using CallbackMap_t = std::map<Key, CreateItemCallback>;
diff --git a/GUI/Models/FTDistributionItems.cpp b/GUI/Models/FTDistributionItems.cpp
index 60dd27bada563df296303fb72f2297f35fc4cfe3..5507a42a94504f2f82fdfe2b0171129a8d37c331 100644
--- a/GUI/Models/FTDistributionItems.cpp
+++ b/GUI/Models/FTDistributionItems.cpp
@@ -272,8 +272,8 @@ FTDistribution2DVoigtItem::FTDistribution2DVoigtItem() : FTDistribution2DItem(M_
 
 std::unique_ptr<IFTDistribution2D> FTDistribution2DVoigtItem::createFTDistribution() const
 {
-    return std::make_unique<FTDistribution2DVoigt>(
-        omegaX(), omegaY(), Units::deg2rad(gamma()), getItemValue(P_ETA).toDouble());
+    return std::make_unique<FTDistribution2DVoigt>(omegaX(), omegaY(), Units::deg2rad(gamma()),
+                                                   getItemValue(P_ETA).toDouble());
 }
 
 void FTDistribution2DVoigtItem::setEta(double eta)
diff --git a/Sample/Scattering/IFormFactor.cpp b/Sample/Scattering/IFormFactor.cpp
index 414399e98895c7110ae1a89c11134c84817fbd8e..d36f07eeca610c9bef93040fbd474f734e433ef8 100644
--- a/Sample/Scattering/IFormFactor.cpp
+++ b/Sample/Scattering/IFormFactor.cpp
@@ -52,7 +52,7 @@ IFormFactor::IFormFactor(const NodeMeta& meta, const std::vector<double>& PValue
 
 std::string IFormFactor::shapeName() const
 {
-    if (className().substr(0, 10)=="FormFactor")
+    if (className().substr(0, 10) == "FormFactor")
         return className().substr(10);
     return className();
 }
diff --git a/Sample/StandardSamples/ParaCrystalBuilder.cpp b/Sample/StandardSamples/ParaCrystalBuilder.cpp
index 0ca3964d051810fba973904f62475830e2ce5f77..6bfa5a9aa415bfa6e8983634b5495cd0c88327c8 100644
--- a/Sample/StandardSamples/ParaCrystalBuilder.cpp
+++ b/Sample/StandardSamples/ParaCrystalBuilder.cpp
@@ -77,7 +77,7 @@ MultiLayer* Basic2DParaCrystalBuilder::buildSampleWithFTDis(const IFTDistributio
 
     vacuum_layer.addLayout(particle_layout);
 
-    MultiLayer* sample = new MultiLayer("Basic2DParaCrystal_"+pdf2->className());
+    MultiLayer* sample = new MultiLayer("Basic2DParaCrystal_" + pdf2->className());
     sample->addLayer(vacuum_layer);
     sample->addLayer(substrate_layer);
     return sample;
diff --git a/Sample/StandardSamples/ParticleInVacuumBuilder.cpp b/Sample/StandardSamples/ParticleInVacuumBuilder.cpp
index c26396452b276ffac732d6b8db1b59b374db33bc..a289384e5288d570bc0852166a880dfbd188f2db 100644
--- a/Sample/StandardSamples/ParticleInVacuumBuilder.cpp
+++ b/Sample/StandardSamples/ParticleInVacuumBuilder.cpp
@@ -30,7 +30,7 @@ MultiLayer* ParticleInVacuumBuilder::buildSampleWithFF(const IFormFactor* ff) co
     ParticleLayout particle_layout(particle);
     vacuum_layer.addLayout(particle_layout);
 
-    MultiLayer* result = new MultiLayer("ParticleInVacuum_"+ff->shapeName());
+    MultiLayer* result = new MultiLayer("ParticleInVacuum_" + ff->shapeName());
     result->addLayer(vacuum_layer);
     return result;
 }
diff --git a/Sample/StandardSamples/includeStandardSamples.h b/Sample/StandardSamples/includeStandardSamples.h
index 6f64ee9b76eb7a1247d315aa7e0bc79057c94dd1..d5d316faf5e91fb19058db785736808ed29d761f 100644
--- a/Sample/StandardSamples/includeStandardSamples.h
+++ b/Sample/StandardSamples/includeStandardSamples.h
@@ -15,7 +15,6 @@
 #ifndef BORNAGAIN_SAMPLE_STANDARDSAMPLES_INCLUDESTANDARDSAMPLES_H
 #define BORNAGAIN_SAMPLE_STANDARDSAMPLES_INCLUDESTANDARDSAMPLES_H
 
-#include "Sample/StandardSamples/SampleBuilderFactory.h"
 #include "Sample/StandardSamples/BoxCompositionBuilder.h"
 #include "Sample/StandardSamples/BoxesSquareLatticeBuilder.h"
 #include "Sample/StandardSamples/CoreShellParticleBuilder.h"
@@ -41,6 +40,7 @@
 #include "Sample/StandardSamples/ResonatorBuilder.h"
 #include "Sample/StandardSamples/RipplesBuilder.h"
 #include "Sample/StandardSamples/RotatedPyramidsBuilder.h"
+#include "Sample/StandardSamples/SampleBuilderFactory.h"
 #include "Sample/StandardSamples/SizeDistributionModelsBuilder.h"
 #include "Sample/StandardSamples/SlicedCompositionBuilder.h"
 #include "Sample/StandardSamples/SlicedCylindersBuilder.h"
diff --git a/Tests/Functional/Core/Consistence/ConsistenceTests.cpp b/Tests/Functional/Core/Consistence/ConsistenceTests.cpp
index 68f0da1105ae09070a9f6f18973a12daa7d0c03e..f739871605186771f819aa57c6ea588c678d077e 100644
--- a/Tests/Functional/Core/Consistence/ConsistenceTests.cpp
+++ b/Tests/Functional/Core/Consistence/ConsistenceTests.cpp
@@ -50,19 +50,19 @@ TEST_F(Consistence, TOFResolutionComparison)
 
 TEST_F(Consistence, PolarizedQAngleReflectivity)
 {
-    EXPECT_TRUE(compareTwoReferences("PolarizedQAngleReflectivityPP_0",
+    EXPECT_TRUE(compareTwoReferences("BasicSpecularPP",
                                      "PolarizedQAngleReflectivityPP_Q", 2e-10));
-    EXPECT_TRUE(compareTwoReferences("PolarizedQAngleReflectivityMM_0",
+    EXPECT_TRUE(compareTwoReferences("BasicSpecularMM",
                                      "PolarizedQAngleReflectivityMM_Q", 2e-10));
 }
 
 TEST_F(Consistence, PolarizedScalarSpinFlip)
 {
-    auto simulation = StandardSimulations::BasicSpecularQPM();
     auto sample = PlainMultiLayerBySLDBuilder(10).buildSample();
-    simulation->setSample(*sample);
-    simulation->runSimulation();
-    auto result = simulation->result().data();
+    SpecularSimulation simulation = StdSimulations::BasicYPolarizedSpecular(*sample, "PM");
+    simulation.setSample(*sample);
+    simulation.runSimulation();
+    auto result = simulation.result().data();
     for (auto r : *result)
         EXPECT_EQ(r, 0);
 }
diff --git a/Tests/Functional/GUI/Check.cpp b/Tests/Functional/GUI/Check.cpp
index 48353eb8fb693c66550ec85721d46a7de8c603b9..b2d56ff182dac6e99b4107b0e149f0df783d7f8c 100644
--- a/Tests/Functional/GUI/Check.cpp
+++ b/Tests/Functional/GUI/Check.cpp
@@ -72,12 +72,11 @@ bool checkSimulation(const std::string& name, const ISimulation& direct_simulati
 
     // Save simulation, as it differs from reference.
     BaseUtils::Filesystem::createDirectories(BATesting::TestOutDir_Std());
-    std::map<const std::string,
-             const OutputData<double>*> tosave{{"gui", domain_data.get()}, {"std", ref_data.get()}};
-    for (const auto [kind, data]: tosave) {
-        std::string out_fname =
-            BaseUtils::Filesystem::jointPath(BATesting::TestOutDir_Std(),
-                                             name + "." + kind + ".int.gz");
+    std::map<const std::string, const OutputData<double>*> tosave{{"gui", domain_data.get()},
+                                                                  {"std", ref_data.get()}};
+    for (const auto [kind, data] : tosave) {
+        std::string out_fname = BaseUtils::Filesystem::jointPath(BATesting::TestOutDir_Std(),
+                                                                 name + "." + kind + ".int.gz");
         IntensityDataIOFactory::writeOutputData(*data, out_fname);
         std::cout << "Saved " << out_fname << "\n";
     }
diff --git a/Tests/Functional/Std/StandardTests.h b/Tests/Functional/Std/StandardTests.h
index 0e18ae66609af1fd952ecdf5b9a44b86d4a22063..04a07ef281d31085423fcdef6b5e04b45fd625df 100644
--- a/Tests/Functional/Std/StandardTests.h
+++ b/Tests/Functional/Std/StandardTests.h
@@ -19,12 +19,13 @@
 #ifndef BORNAGAIN_TESTS_FUNCTIONAL_STD_STANDARDTESTS_H
 #define BORNAGAIN_TESTS_FUNCTIONAL_STD_STANDARDTESTS_H
 
-#include "Tests/GTestWrapper/google_test.h"
 #include "Core/Examples/StandardSimulations.h"
 #include "Core/Simulation/GISASSimulation.h"
-#include "Sample/ComponentBuilder/FormFactorComponents.h"
+#include "Core/Simulation/SpecularSimulation.h"
 #include "Sample/ComponentBuilder/FTDistribution2DComponents.h"
+#include "Sample/ComponentBuilder/FormFactorComponents.h"
 #include "Sample/StandardSamples/includeStandardSamples.h"
+#include "Tests/GTestWrapper/google_test.h"
 
 #include <iostream>
 #include <regex>
@@ -43,67 +44,68 @@ class Std : public ::testing::Test {
 
 TEST_F(Std, FormFactors)
 {
-    for (const std::string& ffname: FormFactorComponents().keys()) {
+    for (const std::string& ffname : FormFactorComponents().keys()) {
         const IFormFactor* ff = FormFactorComponents().getItem(ffname)->clone();
         ASSERT(ff);
-        std::unique_ptr<MultiLayer> sample(ParticleInVacuumBuilder().buildSampleWithFF(ff));
+        std::unique_ptr<const MultiLayer> sample(ParticleInVacuumBuilder().buildSampleWithFF(ff));
         ASSERT(sample);
         GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
-        EXPECT_TRUE(run("FormFactors_"+ff->shapeName(), sim, 2e-10));
+        EXPECT_TRUE(run("FormFactors_" + ff->shapeName(), sim, 2e-10));
     }
 }
 
 TEST_F(Std, GISASAbsorptiveSLDLayers)
 {
-    std::unique_ptr<MultiLayer> sample(LayersWithAbsorptionBySLDBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(LayersWithAbsorptionBySLDBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("GISASAbsorptiveSLDLayers", sim, 2e-10));
 }
 
 TEST_F(Std, CylindersAndPrisms)
 {
-    std::unique_ptr<MultiLayer> sample(CylindersAndPrismsBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(CylindersAndPrismsBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("CylindersAndPrisms", sim, 2e-10));
 }
 
 TEST_F(Std, RadialParaCrystal)
 {
-    std::unique_ptr<MultiLayer> sample(RadialParaCrystalBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(RadialParaCrystalBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("RadialParaCrystal", sim, 2e-10));
 }
 
 TEST_F(Std, HardDisk)
 {
-    std::unique_ptr<MultiLayer> sample(HardDiskBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(HardDiskBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("HardDisk", sim, 2e-10));
 }
 
 TEST_F(Std, Basic2DParaCrystal)
 {
-    for (const std::string& pdfname: FTDistribution2DComponents().keys()) {
+    for (const std::string& pdfname : FTDistribution2DComponents().keys()) {
         const IFTDistribution2D* pdf2 = FTDistribution2DComponents().getItem(pdfname)->clone();
         ASSERT(pdf2);
         std::cout << pdf2->pythonConstructor() << std::endl;
-        std::unique_ptr<MultiLayer> sample(Basic2DParaCrystalBuilder().buildSampleWithFTDis(pdf2));
+        std::unique_ptr<const MultiLayer> sample(
+            Basic2DParaCrystalBuilder().buildSampleWithFTDis(pdf2));
         ASSERT(sample);
         GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
-        EXPECT_TRUE(run("Basic2DParaCrystal_"+pdf2->className(), sim, 2e-10));
+        EXPECT_TRUE(run("Basic2DParaCrystal_" + pdf2->className(), sim, 2e-10));
     }
 }
 
 TEST_F(Std, HexParaCrystal)
 {
-    std::unique_ptr<MultiLayer> sample(HexParaCrystalBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(HexParaCrystalBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("HexParaCrystal", sim, 2e-10));
 }
 
 TEST_F(Std, Lattice1D)
 {
-    std::unique_ptr<MultiLayer> sample(Lattice1DBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(Lattice1DBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("Lattice1D", sim, 2e-10));
 }
@@ -112,63 +114,63 @@ TEST_F(Std, RectParaCrystal)
 {
     // TODO: investigate numeric integration, which has become problematic under Windows
     //       after moving code from Core/Tools to Base/Utils
-    std::unique_ptr<MultiLayer> sample(RectParaCrystalBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(RectParaCrystalBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("RectParaCrystal", sim, 1e-9));
 }
 
 TEST_F(Std, CoreShellParticle)
 {
-    std::unique_ptr<MultiLayer> sample(CoreShellParticleBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(CoreShellParticleBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("CoreShellParticle", sim, 2e-10));
 }
 
 TEST_F(Std, CoreShellBoxRotateZandY)
 {
-    std::unique_ptr<MultiLayer> sample(CoreShellBoxRotateZandYBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(CoreShellBoxRotateZandYBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("CoreShellBoxRotateZandY", sim, 2e-10));
 }
 
 TEST_F(Std, MultiLayerWithRoughness)
 {
-    std::unique_ptr<MultiLayer> sample(MultiLayerWithRoughnessBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(MultiLayerWithRoughnessBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("MultiLayerWithRoughness", sim, 2e-10));
 }
 
 TEST_F(Std, SquareLattice2D)
 {
-    std::unique_ptr<MultiLayer> sample(SquareLattice2DBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(SquareLattice2DBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("SquareLattice2D", sim, 2e-10));
 }
 
 TEST_F(Std, CenteredSquareLattice2D)
 {
-    std::unique_ptr<MultiLayer> sample(CenteredSquareLattice2DBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(CenteredSquareLattice2DBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("CenteredSquareLattice2D", sim, 2e-10));
 }
 
 TEST_F(Std, RotatedSquareLattice2D)
 {
-    std::unique_ptr<MultiLayer> sample(RotatedSquareLattice2DBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(RotatedSquareLattice2DBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("RotatedSquareLattice2D", sim, 2e-10));
 }
 
 TEST_F(Std, FiniteSquareLattice2D)
 {
-    std::unique_ptr<MultiLayer> sample(FiniteSquareLattice2DBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(FiniteSquareLattice2DBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("FiniteSquareLattice2D", sim, 2e-10));
 }
 
 TEST_F(Std, RotatedPyramids)
 {
-    std::unique_ptr<MultiLayer> sample(RotatedPyramidsBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(RotatedPyramidsBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("RotatedPyramids", sim, 2e-10));
 }
@@ -181,222 +183,222 @@ TEST_F(Std, ThickAbsorptiveSampleWithRoughness)
 
 TEST_F(Std, ParticleComposition)
 {
-    std::unique_ptr<MultiLayer> sample(ParticleCompositionBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(ParticleCompositionBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("ParticleComposition", sim, 2e-10));
 }
 
 TEST_F(Std, BoxCompositionRotateX)
 {
-    std::unique_ptr<MultiLayer> sample(BoxCompositionRotateXBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(BoxCompositionRotateXBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("BoxCompositionRotateX", sim, 2e-10));
 }
 
 TEST_F(Std, BoxCompositionRotateY)
 {
-    std::unique_ptr<MultiLayer> sample(BoxCompositionRotateYBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(BoxCompositionRotateYBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("BoxCompositionRotateY", sim, 2e-10));
 }
 
 TEST_F(Std, BoxCompositionRotateZ)
 {
-    std::unique_ptr<MultiLayer> sample(BoxCompositionRotateZBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(BoxCompositionRotateZBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("BoxCompositionRotateZ", sim, 2e-10));
 }
 
 TEST_F(Std, BoxCompositionRotateZandY)
 {
-    std::unique_ptr<MultiLayer> sample(BoxCompositionRotateZandYBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(BoxCompositionRotateZandYBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("BoxCompositionRotateZandY", sim, 2e-10));
 }
 
 TEST_F(Std, BoxStackComposition)
 {
-    std::unique_ptr<MultiLayer> sample(BoxStackCompositionBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(BoxStackCompositionBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("BoxStackComposition", sim, 2e-10));
 }
 
 DISTRIBUTION_TEST_F(Std, CylindersWithSizeDistribution)
 {
-    std::unique_ptr<MultiLayer> sample(CylindersWithSizeDistributionBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(CylindersWithSizeDistributionBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("CylindersWithSizeDistribution", sim, 2e-10));
 }
 
 DISTRIBUTION_TEST_F(Std, TwoTypesCylindersDistribution)
 {
-    std::unique_ptr<MultiLayer> sample(TwoTypesCylindersDistributionBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(TwoTypesCylindersDistributionBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("TwoTypesCylindersDistribution", sim, 2e-10));
 }
 
 DISTRIBUTION_TEST_F(Std, RotatedPyramidsDistribution)
 {
-    std::unique_ptr<MultiLayer> sample(RotatedPyramidsDistributionBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(RotatedPyramidsDistributionBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("RotatedPyramidsDistribution", sim, 2e-10));
 }
 
 DISTRIBUTION_TEST_F(Std, SpheresWithLimitsDistribution)
 {
-    std::unique_ptr<MultiLayer> sample(SpheresWithLimitsDistributionBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(SpheresWithLimitsDistributionBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("SpheresWithLimitsDistribution", sim, 2e-10));
 }
 
 DISTRIBUTION_TEST_F(Std, ConesWithLimitsDistribution)
 {
-    std::unique_ptr<MultiLayer> sample(ConesWithLimitsDistributionBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(ConesWithLimitsDistributionBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("ConesWithLimitsDistribution", sim, 2e-10));
 }
 
 DISTRIBUTION_TEST_F(Std, LinkedBoxDistribution)
 {
-    std::unique_ptr<MultiLayer> sample(LinkedBoxDistributionBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(LinkedBoxDistributionBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("LinkedBoxDistribution", sim, 2e-10));
 }
 
 TEST_F(Std, MultipleLayout)
 {
-    std::unique_ptr<MultiLayer> sample(MultipleLayoutBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(MultipleLayoutBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("MultipleLayout", sim, 2e-10));
 }
 
 TEST_F(Std, ApproximationDA)
 {
-    std::unique_ptr<MultiLayer> sample(SizeDistributionDAModelBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(SizeDistributionDAModelBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("ApproximationDA", sim, 2e-10));
 }
 
 TEST_F(Std, ApproximationLMA)
 {
-    std::unique_ptr<MultiLayer> sample(SizeDistributionLMAModelBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(SizeDistributionLMAModelBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("ApproximationLMA", sim, 2e-10));
 }
 
 TEST_F(Std, ApproximationSSCA)
 {
-    std::unique_ptr<MultiLayer> sample(SizeDistributionSSCAModelBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(SizeDistributionSSCAModelBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("ApproximationSSCA", sim, 2e-10));
 }
 
 DISTRIBUTION_TEST_F(Std, CylindersInSSCA)
 {
-    std::unique_ptr<MultiLayer> sample(CylindersInSSCABuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(CylindersInSSCABuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("CylindersInSSCA", sim, 2e-10));
 }
 
 TEST_F(Std, CosineRipple)
 {
-    std::unique_ptr<MultiLayer> sample(CosineRippleBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(CosineRippleBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("CosineRipple", sim, 2e-10));
 }
 
 TEST_F(Std, TriangularRipple)
 {
-    std::unique_ptr<MultiLayer> sample(TriangularRippleBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(TriangularRippleBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("TriangularRipple", sim, 2e-10));
 }
 
 TEST_F(Std, AsymRipple)
 {
-    std::unique_ptr<MultiLayer> sample(AsymRippleBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(AsymRippleBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("AsymRipple", sim, 2e-10));
 }
 
 TEST_F(Std, MesoCrystal)
 {
-    std::unique_ptr<MultiLayer> sample(MesoCrystalBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(MesoCrystalBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("MesoCrystal", sim, 2e-10));
 }
 
 TEST_F(Std, CustomMorphology)
 {
-    std::unique_ptr<MultiLayer> sample(CustomMorphologyBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(CustomMorphologyBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("CustomMorphology", sim, 2e-10));
 }
 
 TEST_F(Std, TransformBox)
 {
-    std::unique_ptr<MultiLayer> sample(TransformBoxBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(TransformBoxBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("TransformBox", sim, 1e-10));
 }
 
 TEST_F(Std, MagneticParticleZeroField)
 {
-    std::unique_ptr<MultiLayer> sample(MagneticParticleZeroFieldBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(MagneticParticleZeroFieldBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("MagneticParticleZeroField", sim, 2e-10));
 }
 
 TEST_F(Std, RotatedCylinder)
 {
-    std::unique_ptr<MultiLayer> sample(RotatedCylindersBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(RotatedCylindersBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("RotatedCylinder", sim, 1e-10));
 }
 
 TEST_F(Std, SlicedComposition)
 {
-    std::unique_ptr<MultiLayer> sample(SlicedCompositionBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(SlicedCompositionBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("SlicedComposition", sim, 1e-10));
 }
 
 TEST_F(Std, MagneticSubstrateZeroField)
 {
-    std::unique_ptr<MultiLayer> sample(MagneticSubstrateZeroFieldBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(MagneticSubstrateZeroFieldBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniZPolarizedGISAS(*sample, "PP");
     EXPECT_TRUE(run("MagneticSubstrateZeroField", sim, 2e-10));
 }
 
 TEST_F(Std, MagneticRotation)
 {
-    std::unique_ptr<MultiLayer> sample(MagneticRotationBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(MagneticRotationBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniZPolarizedGISAS(*sample, "PM");
     EXPECT_TRUE(run("MagneticRotation", sim, 2e-10));
 }
 
 TEST_F(Std, MagneticSpheres)
 {
-    std::unique_ptr<MultiLayer> sample(MagneticSpheresBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(MagneticSpheresBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniZPolarizedGISAS(*sample, "PM");
     EXPECT_TRUE(run("MagneticSpheres", sim, 2e-10));
 }
 
 TEST_F(Std, MagneticCylinders)
 {
-    for (const std::string& polCase: { "PP", "MP", "PM", "PP" }) {
-        std::unique_ptr<MultiLayer> sample(MagneticCylindersBuilder().buildSample());
+    for (const std::string& polCase : {"PP", "MP", "PM", "MM"}) {
+        std::unique_ptr<const MultiLayer> sample(MagneticCylindersBuilder().buildSample());
         GISASSimulation sim = StdSimulations::MiniZPolarizedGISAS(*sample, polCase);
-        EXPECT_TRUE(run("MagneticCylinders"+polCase, sim, 2e-10));
+        EXPECT_TRUE(run("MagneticCylinders" + polCase, sim, 2e-10));
     }
 }
 
 TEST_F(Std, MagneticSpheresInMagLayer)
 {
-    for (const std::string& polCase: { "PP", "MP" }) {
-        std::unique_ptr<MultiLayer> sample(MagneticLayerBuilder().buildSample());
+    for (const std::string& polCase : {"PP", "MP"}) {
+        std::unique_ptr<const MultiLayer> sample(MagneticLayerBuilder().buildSample());
         GISASSimulation sim = StdSimulations::MiniZPolarizedGISAS(*sample, polCase);
-        EXPECT_TRUE(run("MagneticSpheresInMagLayer"+polCase, sim, 2e-10));
+        EXPECT_TRUE(run("MagneticSpheresInMagLayer" + polCase, sim, 2e-10));
     }
 }
 
@@ -536,13 +538,14 @@ TEST_F(Std, OffSpecularResonator)
 
 TEST_F(Std, FormFactorsWithAbsorption)
 {
-    for (const std::string& ffname: FormFactorComponents().keys()) {
+    for (const std::string& ffname : FormFactorComponents().keys()) {
         const IFormFactor* ff = FormFactorComponents().getItem(ffname)->clone();
         ASSERT(ff);
-        std::unique_ptr<MultiLayer> sample(LayersWithAbsorptionBuilder().buildSampleWithFF(ff));
+        std::unique_ptr<const MultiLayer> sample(
+            LayersWithAbsorptionBuilder().buildSampleWithFF(ff));
         ASSERT(sample);
         GISASSimulation sim = StdSimulations::MiniGISAS_v2(*sample);
-        EXPECT_TRUE(run("FormFactorsWithAbsorption_"+ff->shapeName(), sim, 2e-10));
+        EXPECT_TRUE(run("FormFactorsWithAbsorption_" + ff->shapeName(), sim, 2e-10));
     }
 }
 #endif // PYTHON_STD_TEST
@@ -562,7 +565,7 @@ TEST_F(Std, NCRoughnessInSpecular)
 
 TEST_F(Std, SuperLattice)
 {
-    std::unique_ptr<MultiLayer> sample(SuperLatticeBuilder().buildSample());
+    std::unique_ptr<const MultiLayer> sample(SuperLatticeBuilder().buildSample());
     GISASSimulation sim = StdSimulations::MiniGISAS(*sample);
     EXPECT_TRUE(run("SuperLattice", sim, 2e-10));
 }
@@ -593,180 +596,97 @@ TEST_F(Std, TOFResolutionComparison)
                     "PlainMultiLayerBySLDBuilder", 1e-10));
 }
 
-TEST_F(Std, BasicSpecularPP)
-{
-    EXPECT_TRUE(run("BasicSpecularPP", "BasicSpecularPP", "SimpleMagneticLayerBuilder", 1e-10));
-}
-
-TEST_F(Std, BasicSpecularMM)
-{
-    EXPECT_TRUE(run("BasicSpecularMM", "BasicSpecularMM", "SimpleMagneticLayerBuilder", 1e-10));
-}
-
-TEST_F(Std, PolarizedQAngleReflectivityPP)
+TEST_F(Std, BasicSpecular)
 {
-    EXPECT_TRUE(run("PolarizedQAngleReflectivityPP_0", "BasicSpecularPP",
-                    "SimpleMagneticLayerBuilder", 1e-10));
-    EXPECT_TRUE(run("PolarizedQAngleReflectivityPP_Q", "BasicQSpecularPP",
-                    "SimpleMagneticLayerBuilder", 1e-10));
+    std::unique_ptr<const MultiLayer> sample(SimpleMagneticLayerBuilder().buildSample());
+    for (const std::string& polCase : {"PP", "MM"}) {
+        SpecularSimulation sim = StdSimulations::BasicYPolarizedSpecular(*sample, polCase);
+        EXPECT_TRUE(run("BasicSpecular" + polCase, sim, 1e-10));
+    }
 }
 
-TEST_F(Std, PolarizedQAngleReflectivityMM)
+TEST_F(Std, PolarizedQAngleReflectivity)
 {
-    EXPECT_TRUE(run("PolarizedQAngleReflectivityMM_0", "BasicSpecularMM",
-                    "SimpleMagneticLayerBuilder", 1e-10));
-    EXPECT_TRUE(run("PolarizedQAngleReflectivityMM_Q", "BasicQSpecularMM",
-                    "SimpleMagneticLayerBuilder", 1e-10));
+    std::unique_ptr<const MultiLayer> sample(SimpleMagneticLayerBuilder().buildSample());
+    for (const std::string& polCase : {"PP", "MM"}) {
+        SpecularSimulation sim = StdSimulations::BasicYPolarizedSpecularQ(*sample, polCase);
+        EXPECT_TRUE(run("PolarizedQAngleReflectivity" + polCase + "_Q", sim, 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", "FeNiBilayerBuilder", 1e-7));
-    EXPECT_TRUE(run("PolarizedFeNiBilayerPP_Q", "BasicQSpecularPP", "FeNiBilayerBuilder", 1e-7));
-}
-
-TEST_F(Std, PolarizedFeNiBilayerMM)
-{
-    EXPECT_TRUE(run("PolarizedFeNiBilayerMM", "BasicSpecularMM", "FeNiBilayerBuilder", 1e-7));
-    EXPECT_TRUE(run("PolarizedFeNiBilayerMM_Q", "BasicQSpecularMM", "FeNiBilayerBuilder", 1e-7));
-}
-
-TEST_F(Std, PolarizedFeNiBilayerTanhPP)
-{
-    EXPECT_TRUE(
-        run("PolarizedFeNiBilayerTanhPP", "BasicSpecularPP", "FeNiBilayerTanhBuilder", 1e-7));
-    EXPECT_TRUE(
-        run("PolarizedFeNiBilayerTanhPP_Q", "BasicQSpecularPP", "FeNiBilayerTanhBuilder", 1e-7));
-}
-
-TEST_F(Std, PolarizedFeNiBilayerTanhMM)
-{
-    EXPECT_TRUE(
-        run("PolarizedFeNiBilayerTanhMM", "BasicSpecularMM", "FeNiBilayerTanhBuilder", 1e-7));
-    EXPECT_TRUE(
-        run("PolarizedFeNiBilayerTanhMM_Q", "BasicQSpecularMM", "FeNiBilayerTanhBuilder", 1e-7));
-}
-
-TEST_F(Std, PolarizedFeNiBilayerNCPP)
-{
-    EXPECT_TRUE(run("PolarizedFeNiBilayerNCPP", "BasicSpecularPP", "FeNiBilayerNCBuilder", 1e-7));
-    EXPECT_TRUE(
-        run("PolarizedFeNiBilayerNCPP_Q", "BasicQSpecularPP", "FeNiBilayerNCBuilder", 1e-7));
-}
-
-TEST_F(Std, PolarizedFeNiBilayerNCMM)
-{
-    EXPECT_TRUE(run("PolarizedFeNiBilayerNCMM", "BasicSpecularMM", "FeNiBilayerTanhBuilder", 1e-7));
-    EXPECT_TRUE(
-        run("PolarizedFeNiBilayerNCMM_Q", "BasicQSpecularMM", "FeNiBilayerNCBuilder", 1e-7));
-}
-
-TEST_F(Std, PolarizedFeNiBilayerSpinFlipPP)
-{
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipPP", "BasicSpecularPP",
-                    "FeNiBilayerSpinFlipBuilder", 1e-7));
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipPP_Q", "BasicQSpecularPP",
-                    "FeNiBilayerSpinFlipBuilder", 1e-7));
-}
-
-TEST_F(Std, PolarizedFeNiBilayerSpinFlipMM)
-{
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipMM", "BasicSpecularMM",
-                    "FeNiBilayerSpinFlipBuilder", 1e-7));
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipMM_Q", "BasicQSpecularMM",
-                    "FeNiBilayerSpinFlipBuilder", 1e-7));
-}
-
-TEST_F(Std, PolarizedFeNiBilayerSpinFlipPM)
-{
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipPM", "BasicSpecularPM",
-                    "FeNiBilayerSpinFlipBuilder", 1e-7));
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipPM_Q", "BasicQSpecularPM",
-                    "FeNiBilayerSpinFlipBuilder", 1e-7));
-}
-
-TEST_F(Std, PolarizedFeNiBilayerSpinFlipMP)
-{
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipMP", "BasicSpecularMP",
-                    "FeNiBilayerSpinFlipBuilder", 1e-7));
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipMP_Q", "BasicQSpecularMP",
-                    "FeNiBilayerSpinFlipBuilder", 1e-7));
-}
-
-TEST_F(Std, PolarizedFeNiBilayerSpinFlipTanhPP)
-{
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipTanhPP", "BasicSpecularPP",
-                    "FeNiBilayerSpinFlipTanhBuilder", 1e-7));
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipTanhPP_Q", "BasicQSpecularPP",
-                    "FeNiBilayerSpinFlipTanhBuilder", 1e-7));
-}
-
-TEST_F(Std, PolarizedFeNiBilayerSpinFlipTanhMM)
-{
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipTanhMM", "BasicSpecularMM",
-                    "FeNiBilayerSpinFlipTanhBuilder", 1e-7));
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipTanhMM_Q", "BasicQSpecularMM",
-                    "FeNiBilayerSpinFlipTanhBuilder", 1e-7));
+    std::unique_ptr<const MultiLayer> sample(SimpleMagneticRotationBuilder().buildSample());
+    for (const std::string& polCase : {"PP", "PM", "MP", "MM"}) {
+        SpecularSimulation sim = StdSimulations::BasicYPolarizedSpecular(*sample, polCase);
+        EXPECT_TRUE(run("MagneticRotationReflectivity" + polCase + "_Flat", sim, 1e-10));
+    }
 }
 
-TEST_F(Std, PolarizedFeNiBilayerSpinFlipTanhPM)
+TEST_F(Std, PolarizedFeNiBilayer)
 {
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipTanhPM", "BasicSpecularPM",
-                    "FeNiBilayerSpinFlipTanhBuilder", 1e-7));
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipTanhPM_Q", "BasicQSpecularPM",
-                    "FeNiBilayerSpinFlipTanhBuilder", 1e-7));
+    std::unique_ptr<const MultiLayer> sample(FeNiBilayerBuilder().buildSample());
+    for (const std::string& polCase : {"PP", "MM"}) {
+        SpecularSimulation sim1 = StdSimulations::BasicYPolarizedSpecular(*sample, polCase);
+        EXPECT_TRUE(run("PolarizedFeNiBilayer" + polCase, sim1, 1e-7));
+        SpecularSimulation sim2 = StdSimulations::BasicYPolarizedSpecularQ(*sample, polCase);
+        EXPECT_TRUE(run("PolarizedFeNiBilayer" + polCase + "_Q", sim2, 1e-7));
+    }
 }
 
-TEST_F(Std, PolarizedFeNiBilayerSpinFlipTanhMP)
+TEST_F(Std, PolarizedFeNiBilayerTanh)
 {
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipTanhMP", "BasicSpecularMP",
-                    "FeNiBilayerSpinFlipTanhBuilder", 1e-7));
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipTanhMP_Q", "BasicQSpecularMP",
-                    "FeNiBilayerSpinFlipTanhBuilder", 1e-7));
+    std::unique_ptr<const MultiLayer> sample(FeNiBilayerTanhBuilder().buildSample());
+    for (const std::string& polCase : {"PP", "MM"}) {
+        SpecularSimulation sim1 = StdSimulations::BasicYPolarizedSpecular(*sample, polCase);
+        EXPECT_TRUE(run("PolarizedFeNiBilayerTanh" + polCase, sim1, 1e-7));
+        SpecularSimulation sim2 = StdSimulations::BasicYPolarizedSpecularQ(*sample, polCase);
+        EXPECT_TRUE(run("PolarizedFeNiBilayerTanh" + polCase + "_Q", sim2, 1e-7));
+    }
 }
 
-TEST_F(Std, PolarizedFeNiBilayerSpinFlipNCPP)
+TEST_F(Std, PolarizedFeNiBilayerNC)
 {
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipNCPP", "BasicSpecularPP",
-                    "FeNiBilayerSpinFlipNCBuilder", 1e-7));
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipNCPP_Q", "BasicQSpecularPP",
-                    "FeNiBilayerSpinFlipNCBuilder", 1e-7));
+    std::unique_ptr<const MultiLayer> sample(FeNiBilayerNCBuilder().buildSample());
+    for (const std::string& polCase : {"PP", "MM"}) {
+        SpecularSimulation sim1 = StdSimulations::BasicYPolarizedSpecular(*sample, polCase);
+        EXPECT_TRUE(run("PolarizedFeNiBilayerNC" + polCase, sim1, 1e-7));
+        SpecularSimulation sim2 = StdSimulations::BasicYPolarizedSpecularQ(*sample, polCase);
+        EXPECT_TRUE(run("PolarizedFeNiBilayerNC" + polCase + "_Q", sim2, 1e-7));
+    }
 }
 
-TEST_F(Std, PolarizedFeNiBilayerSpinFlipNCMM)
+TEST_F(Std, PolarizedFeNiBilayerSpinFlip)
 {
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipNCMM", "BasicSpecularMM",
-                    "FeNiBilayerSpinFlipNCBuilder", 1e-7));
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipNCMM_Q", "BasicQSpecularMM",
-                    "FeNiBilayerSpinFlipNCBuilder", 1e-7));
+    std::unique_ptr<const MultiLayer> sample(FeNiBilayerSpinFlipBuilder().buildSample());
+    for (const std::string& polCase : {"PP", "PM", "MP", "MM"}) {
+        SpecularSimulation sim1 = StdSimulations::BasicYPolarizedSpecular(*sample, polCase);
+        EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlip" + polCase, sim1, 1e-7));
+        SpecularSimulation sim2 = StdSimulations::BasicYPolarizedSpecularQ(*sample, polCase);
+        EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlip" + polCase + "_Q", sim2, 1e-7));
+    }
 }
 
-TEST_F(Std, PolarizedFeNiBilayerSpinFlipNCPM)
+TEST_F(Std, PolarizedFeNiBilayerSpinFlipTanh)
 {
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipNCPM", "BasicSpecularPM",
-                    "FeNiBilayerSpinFlipNCBuilder", 1e-7));
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipNCPM_Q", "BasicQSpecularPM",
-                    "FeNiBilayerSpinFlipNCBuilder", 1e-7));
+    std::unique_ptr<const MultiLayer> sample(FeNiBilayerSpinFlipTanhBuilder().buildSample());
+    for (const std::string& polCase : {"PP", "PM", "MP", "MM"}) {
+        SpecularSimulation sim1 = StdSimulations::BasicYPolarizedSpecular(*sample, polCase);
+        EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipTanh" + polCase, sim1, 1e-7));
+        SpecularSimulation sim2 = StdSimulations::BasicYPolarizedSpecularQ(*sample, polCase);
+        EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipTanh" + polCase + "_Q", sim2, 1e-7));
+    }
 }
 
-TEST_F(Std, PolarizedFeNiBilayerSpinFlipNCMP)
+TEST_F(Std, PolarizedFeNiBilayerSpinFlipNC)
 {
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipNCMP", "BasicSpecularMP",
-                    "FeNiBilayerSpinFlipNCBuilder", 1e-7));
-    EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipNCMP_Q", "BasicQSpecularMP",
-                    "FeNiBilayerSpinFlipNCBuilder", 1e-7));
+    std::unique_ptr<const MultiLayer> sample(FeNiBilayerSpinFlipNCBuilder().buildSample());
+    for (const std::string& polCase : {"PP", "PM", "MP", "MM"}) {
+        SpecularSimulation sim1 = StdSimulations::BasicYPolarizedSpecular(*sample, polCase);
+        EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipNC" + polCase, sim1, 1e-7));
+        SpecularSimulation sim2 = StdSimulations::BasicYPolarizedSpecularQ(*sample, polCase);
+        EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipNC" + polCase + "_Q", sim2, 1e-7));
+    }
 }
 
 TEST_F(Std, DepthProbeTest)
diff --git a/Tests/ReferenceData/Std/PolarizedFeNiBilayerNCMM.int.gz b/Tests/ReferenceData/Std/PolarizedFeNiBilayerNCMM.int.gz
index ff5bf6a34f582372f33cb340c8fe51c0ccb8f87f..7214b36db83f7e371d43aa6949ae63bda2746dde 100644
Binary files a/Tests/ReferenceData/Std/PolarizedFeNiBilayerNCMM.int.gz and b/Tests/ReferenceData/Std/PolarizedFeNiBilayerNCMM.int.gz differ
diff --git a/Tests/ReferenceData/Std/PolarizedQAngleReflectivityMM_0.int.gz b/Tests/ReferenceData/Std/PolarizedQAngleReflectivityMM_0.int.gz
deleted file mode 100644
index 43ff450187b304e24a225b63179dfd8d61706303..0000000000000000000000000000000000000000
Binary files a/Tests/ReferenceData/Std/PolarizedQAngleReflectivityMM_0.int.gz and /dev/null differ
diff --git a/Tests/ReferenceData/Std/PolarizedQAngleReflectivityPP_0.int.gz b/Tests/ReferenceData/Std/PolarizedQAngleReflectivityPP_0.int.gz
deleted file mode 100644
index 436b743918f042317560a4fbba81acca0dbe6a53..0000000000000000000000000000000000000000
Binary files a/Tests/ReferenceData/Std/PolarizedQAngleReflectivityPP_0.int.gz and /dev/null differ
diff --git a/Tests/Unit/Sample/FormFactorBasicTest.cpp b/Tests/Unit/Sample/FormFactorBasicTest.cpp
index 6b83a4c564688340be5afb59dcb454dbf824cb8c..6c4524ee656cbf2ad4c91d67487766d352b48052 100644
--- a/Tests/Unit/Sample/FormFactorBasicTest.cpp
+++ b/Tests/Unit/Sample/FormFactorBasicTest.cpp
@@ -65,7 +65,7 @@ protected:
 
 TEST_F(FormFactorBasicTest, Name)
 {
-    FormFactorBox ff(1.,2.,3.);
+    FormFactorBox ff(1., 2., 3.);
     EXPECT_EQ(ff.className(), "FormFactorBox");
     EXPECT_EQ(ff.shapeName(), "Box");
 }
diff --git a/auto/Wrap/doxygenCore.i b/auto/Wrap/doxygenCore.i
index bcf839e2c10e470567a4c62ed494756cda41239e..33498e332bb96eab797267326bcfd622516e0bd5 100644
--- a/auto/Wrap/doxygenCore.i
+++ b/auto/Wrap/doxygenCore.i
@@ -2261,30 +2261,6 @@ GISAS simulation with an extra long wavelength.
 %feature("docstring")  StandardSimulations::TOFRWithPointwiseResolution "SpecularSimulation * StandardSimulations::TOFRWithPointwiseResolution()
 ";
 
-%feature("docstring")  StandardSimulations::BasicSpecularPP "SpecularSimulation * StandardSimulations::BasicSpecularPP()
-";
-
-%feature("docstring")  StandardSimulations::BasicSpecularMM "SpecularSimulation * StandardSimulations::BasicSpecularMM()
-";
-
-%feature("docstring")  StandardSimulations::BasicSpecularPM "SpecularSimulation * StandardSimulations::BasicSpecularPM()
-";
-
-%feature("docstring")  StandardSimulations::BasicSpecularMP "SpecularSimulation * StandardSimulations::BasicSpecularMP()
-";
-
-%feature("docstring")  StandardSimulations::BasicSpecularQPP "SpecularSimulation * StandardSimulations::BasicSpecularQPP()
-";
-
-%feature("docstring")  StandardSimulations::BasicSpecularQMM "SpecularSimulation * StandardSimulations::BasicSpecularQMM()
-";
-
-%feature("docstring")  StandardSimulations::BasicSpecularQPM "SpecularSimulation * StandardSimulations::BasicSpecularQPM()
-";
-
-%feature("docstring")  StandardSimulations::BasicSpecularQMP "SpecularSimulation * StandardSimulations::BasicSpecularQMP()
-";
-
 %feature("docstring")  StandardSimulations::MiniOffSpecular "OffSpecularSimulation * StandardSimulations::MiniOffSpecular()
 ";