From 288857c1595f4cac8ad56de485d64a208570386c Mon Sep 17 00:00:00 2001
From: "Joachim Wuttke (h)" <j.wuttke@fz-juelich.de>
Date: Wed, 8 Sep 2021 20:20:19 +0200
Subject: [PATCH] standard simulations -> namespace test::makeSimulation
---
Core/Examples/StandardSimulations.cpp | 311 ------------------
Core/Examples/StandardSimulations.h | 59 ----
.../Core/Consistence/ConsistenceTests.cpp | 5 +-
Tests/Functional/Core/Fitting/FitTests.cpp | 9 +-
.../Functional/ProStd/StdTestSimulations.cpp | 279 +++++++++++++++-
Tests/Functional/ProStd/StdTestSimulations.h | 27 +-
Tests/Functional/PyCore/utils.py | 2 +-
Tests/Functional/Std/StandardTests.h | 195 ++++++-----
Tests/Performance/Core/Multilayer.cpp | 2 +-
9 files changed, 398 insertions(+), 491 deletions(-)
delete mode 100644 Core/Examples/StandardSimulations.cpp
delete mode 100644 Core/Examples/StandardSimulations.h
diff --git a/Core/Examples/StandardSimulations.cpp b/Core/Examples/StandardSimulations.cpp
deleted file mode 100644
index b2d2dda38ae..00000000000
--- a/Core/Examples/StandardSimulations.cpp
+++ /dev/null
@@ -1,311 +0,0 @@
-// ************************************************************************************************
-//
-// BornAgain: simulate and fit reflection and scattering
-//
-//! @file Core/Examples/StandardSimulations.cpp
-//! @brief Implements functions for standard simulations.
-//!
-//! @homepage http://www.bornagainproject.org
-//! @license GNU General Public License v3 or higher (see COPYING)
-//! @copyright Forschungszentrum Jülich GmbH 2018
-//! @authors Scientific Computing Group at MLZ (see CITATION, AUTHORS)
-//
-// ************************************************************************************************
-
-#include "Core/Examples/StandardSimulations.h"
-#include "Base/Axis/FixedBinAxis.h"
-#include "Base/Const/Units.h"
-#include "Core/Scan/AlphaScan.h"
-#include "Core/Scan/QzScan.h"
-#include "Core/Simulation/GISASSimulation.h"
-#include "Device/Beam/Beam.h"
-#include "Device/Beam/FootprintGauss.h"
-#include "Device/Beam/FootprintSquare.h"
-#include "Device/Data/OutputData.h"
-#include "Device/Detector/RectangularDetector.h"
-#include "Device/Detector/SphericalDetector.h"
-#include "Device/Mask/Ellipse.h"
-#include "Device/Mask/Line.h"
-#include "Device/Mask/Polygon.h"
-#include "Device/Mask/Rectangle.h"
-#include "Device/Resolution/ResolutionFunction2DGaussian.h"
-#include "Device/Resolution/ScanResolution.h"
-#include "Param/Distrib/Distributions.h"
-#include "Param/Distrib/RangedDistributions.h"
-#include "Resample/Options/SimulationOptions.h"
-#include "Sample/StandardSamples/SampleBuilderFactory.h"
-#include <memory>
-
-namespace {
-
-const size_t rdet_nbinsx(40), rdet_nbinsy(30);
-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>> YPolarizationCases = {
- {"PP", {+yplus, +yplus}},
- {"PM", {+yplus, -yplus}},
- {"MP", {-yplus, +yplus}},
- {"MM", {-yplus, -yplus}},
-};
-
-} // namespace
-
-using Units::angstrom;
-using Units::deg;
-
-//! GISAS simulation with small detector and phi[-2,2], theta[0,2].
-
-std::unique_ptr<GISASSimulation> StdSimulations::MiniGISAS(const MultiLayer& sample)
-{
- Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
- SphericalDetector det(25, -2 * deg, 2 * deg, 25, 0, 2 * deg);
- return std::make_unique<GISASSimulation>(beam, sample, det);
-}
-
-
-//! GISAS simulation with small detector and phi[-1,1], theta[0,1].
-
-std::unique_ptr<GISASSimulation> StdSimulations::MiniGISAS_v2(const MultiLayer& sample)
-{
- Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
- SphericalDetector det(25, -1 * deg, 1 * deg, 25, 0, 1 * deg);
- return std::make_unique<GISASSimulation>(beam, sample, det);
-}
-
-std::unique_ptr<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));
- beam.setPolarization(zCase.first);
- SphericalDetector det(25, -2 * deg, 2 * deg, 25, 0, 2 * deg);
- det.setAnalyzer(zCase.second, 1., .5);
- return std::make_unique<GISASSimulation>(beam, sample, det);
-}
-
-
-//! Basic GISAS simulation with the detector phi[0,2], theta[0,2].
-
-std::unique_ptr<GISASSimulation> StdSimulations::BasicGISAS(const MultiLayer& sample)
-{
- Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
- SphericalDetector det(100, 0, 2 * deg, 100, 0, 2 * deg);
- return std::make_unique<GISASSimulation>(beam, sample, det);
-}
-
-//! Basic GISAS simulation for spin flip channel.
-
-std::unique_ptr<GISASSimulation> StdSimulations::SpinflipGISAS(const MultiLayer& sample)
-{
- std::unique_ptr<GISASSimulation> result = BasicGISAS(sample);
- result->instrument().setPolFilters(zplus, zplus, -1.0, 0.5);
- return result;
-}
-
-//! GISAS simulation with beam divergence applied.
-
-std::unique_ptr<GISASSimulation> StdSimulations::MiniGISASBeamDivergence(const MultiLayer& sample)
-{
- std::unique_ptr<GISASSimulation> result = MiniGISAS(sample);
-
- DistributionLogNormal wavelength_distr(1 * angstrom, 0.1);
- DistributionGaussian alpha_distr(0.2 * deg, 0.02 * deg);
- DistributionGate phi_distr(-0.1 * deg, 0.02 * deg);
-
- result->addParameterDistribution(ParameterDistribution::BeamWavelength, wavelength_distr, 5);
- result->addParameterDistribution(ParameterDistribution::BeamInclinationAngle, alpha_distr, 4);
- result->addParameterDistribution(ParameterDistribution::BeamAzimuthalAngle, phi_distr, 3);
-
- return result;
-}
-
-//! GISAS simulation with multiple masks on the detector plane.
-
-std::unique_ptr<GISASSimulation> StdSimulations::GISASWithMasks(const MultiLayer& sample)
-{
- Beam beam(1e7, 1 * angstrom, Direction(0.2 * deg, 0));
- SphericalDetector det(50, -1 * deg, 1 * deg, 50, 0, 2 * deg);
- std::unique_ptr<GISASSimulation> result = std::make_unique<GISASSimulation>(beam, sample, det);
-
- result->maskAll();
- // pacman
- result->addMask(Ellipse(0.0 * deg, 1.0 * deg, 0.5 * deg, 0.5 * deg), false);
- result->addMask(Ellipse(0.11 * deg, 1.25 * deg, 0.05 * deg, 0.05 * deg), true);
-
- std::vector<std::vector<double>> points = {{0.0 * deg, 1.0 * deg},
- {0.5 * deg, 1.2 * deg},
- {0.5 * deg, 0.8 * deg},
- {0.0 * deg, 1.0 * deg}};
- result->addMask(Polygon(points), true);
-
- result->addMask(Rectangle(0.45 * deg, 0.95 * deg, 0.55 * deg, 1.05 * deg), false);
- result->addMask(Rectangle(0.61 * deg, 0.95 * deg, 0.71 * deg, 1.05 * deg), false);
- result->addMask(Rectangle(0.75 * deg, 0.95 * deg, 0.85 * deg, 1.05 * deg), false);
-
- // more masks
- result->addMask(Ellipse(-0.5 * deg, 1.5 * deg, 0.3 * deg, 0.1 * deg, 45. * deg), false);
- result->addMask(VerticalLine(-0.6 * deg), true);
- result->addMask(HorizontalLine(0.3 * deg), false);
-
- return result;
-}
-
-//! GISAS simulation with detector resolution.
-
-std::unique_ptr<GISASSimulation>
-StdSimulations::MiniGISASDetectorResolution(const MultiLayer& sample)
-{
- std::unique_ptr<GISASSimulation> result = MiniGISAS(sample);
- ResolutionFunction2DGaussian resfunc(0.0025, 0.0025);
- result->detector().setResolutionFunction(resfunc);
- return result;
-}
-
-//! GISAS simulation with small detector and including specular peak.
-
-std::unique_ptr<GISASSimulation> StdSimulations::MiniGISASSpecularPeak(const MultiLayer& sample)
-{
- Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
- SphericalDetector det(25, -2 * deg, 2 * deg, 25, 0, 2 * deg);
- std::unique_ptr<GISASSimulation> result = std::make_unique<GISASSimulation>(beam, sample, det);
- result->setBeamParameters(1 * angstrom, 0.2 * deg, 0);
- result->options().setIncludeSpecular(true);
- return result;
-}
-
-//! GISAS simulation with large detector to test performance.
-
-std::unique_ptr<GISASSimulation> StdSimulations::MaxiGISAS(const MultiLayer& sample)
-{
- Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
- SphericalDetector det(256, -2 * deg, 2 * deg, 256, 0, 2 * deg);
- return std::make_unique<GISASSimulation>(beam, sample, det);
-}
-
-//! Basic GISAS for polarization studies.
-
-std::unique_ptr<GISASSimulation> StdSimulations::MaxiGISAS00(const MultiLayer& sample)
-{
- std::unique_ptr<GISASSimulation> result = MaxiGISAS(sample);
- result->instrument().setPolFilters(zplus, zplus, 1.0, 0.5);
- return result;
-}
-
-//! GISAS simulation with generic rectangular detector.
-
-std::unique_ptr<GISASSimulation> StdSimulations::RectDetectorGeneric(const MultiLayer& sample)
-{
- Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
- RectangularDetector det(rdet_nbinsx, rdet_width, rdet_nbinsy, rdet_height);
- det.setPosition(R3(rdet_distance, 10.0, 5.0), rdet_width / 2., 1.0, R3(0.1, -1.0, 0.2));
- return std::make_unique<GISASSimulation>(beam, sample, det);
-}
-
-//! GISAS simulation with the rectangular detector perpendicular to the sample.
-
-std::unique_ptr<GISASSimulation> StdSimulations::RectDetectorPerpToSample(const MultiLayer& sample)
-{
- Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
- RectangularDetector det(rdet_nbinsx, rdet_width, rdet_nbinsy, rdet_height);
- det.setPerpendicularToSampleX(rdet_distance, rdet_width / 2., 1.0);
- return std::make_unique<GISASSimulation>(beam, sample, det);
-}
-
-//! GISAS simulation with the rectangular detector perpendicular to the direct beam.
-
-std::unique_ptr<GISASSimulation>
-StdSimulations::RectDetectorPerpToDirectBeam(const MultiLayer& sample)
-{
- Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
- RectangularDetector det(rdet_nbinsx, rdet_width, rdet_nbinsy, rdet_height);
- det.setPerpendicularToDirectBeam(rdet_distance, rdet_width / 2., 1.0);
- return std::make_unique<GISASSimulation>(beam, sample, det);
-}
-
-//! GISAS simulation with the rectangular detector perpendicular to the reflected beam.
-
-std::unique_ptr<GISASSimulation>
-StdSimulations::RectDetectorPerpToReflectedBeam(const MultiLayer& sample)
-{
- Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
- RectangularDetector det(rdet_nbinsx, rdet_width, rdet_nbinsy, rdet_height);
- det.setPerpendicularToReflectedBeam(rdet_distance, rdet_width / 2., 1.0);
- return std::make_unique<GISASSimulation>(beam, sample, det);
-}
-
-//! GISAS simulation with the rectangular detector perpendicular to the reflected beam when
-//! the coordinates of direct beam are known.
-
-std::unique_ptr<GISASSimulation>
-StdSimulations::RectDetectorPerpToReflectedBeamDpos(const MultiLayer& sample)
-{
- Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
- RectangularDetector det(rdet_nbinsx, rdet_width, rdet_nbinsy, rdet_height);
- det.setPerpendicularToReflectedBeam(rdet_distance);
- det.setDirectBeamPosition(rdet_width / 2., 1.0);
- return std::make_unique<GISASSimulation>(beam, sample, det);
-}
-
-//! GISAS simulation with Monte-Carlo integration switched ON.
-
-std::unique_ptr<GISASSimulation> StdSimulations::MiniGISASMonteCarlo(const MultiLayer& sample)
-{
- std::unique_ptr<GISASSimulation> result = MiniGISAS(sample);
- result->options().setMonteCarloIntegration(true, 100);
- return result;
-}
-
-//! GISAS simulation with spherical detector, region of interest and mask.
-
-std::unique_ptr<GISASSimulation> StdSimulations::SphericalDetWithRoi(const MultiLayer& sample)
-{
- Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
- SphericalDetector det(40, -2 * deg, 2 * deg, 30, 0, 3 * deg);
- std::unique_ptr<GISASSimulation> result = std::make_unique<GISASSimulation>(beam, sample, det);
- result->addMask(Rectangle(-0.5 * deg, 0.3 * deg, -0.2 * deg, 0.6 * deg));
- result->setRegionOfInterest(-1.5 * deg, 0.25 * deg, 1.5 * deg, 1.75 * deg);
- return result;
-}
-
-//! GISAS simulation with rectangular detector, region of interest and mask.
-
-std::unique_ptr<GISASSimulation> StdSimulations::RectDetWithRoi(const MultiLayer& sample)
-{
- std::unique_ptr<GISASSimulation> result = RectDetectorPerpToDirectBeam(sample);
- result->addMask(Rectangle(3.0, 4.0, 5.0, 7.0));
- result->setRegionOfInterest(2.0, 3.0, 18.0, 15.0);
- return result;
-}
-
-//! GISAS simulation with an extra long wavelength
-
-std::unique_ptr<GISASSimulation> StdSimulations::ExtraLongWavelengthGISAS(const MultiLayer& sample)
-{
- Beam beam(1e8, 13.52 * Units::nm, Direction(0.2 * deg, 0));
- SphericalDetector det(100, -1 * deg, 1 * deg, 100, 0.0, 2 * deg);
- auto simulation = std::make_unique<GISASSimulation>(beam, sample, det);
- simulation->options().setIncludeSpecular(true);
- return simulation;
-}
-
-//! ISimulation with fitting.
-//! Beam intensity set to provide reasonably large values in detector channels.
-std::unique_ptr<GISASSimulation> StdSimulations::MiniGISASFit(const MultiLayer& sample)
-{
- auto result = std::make_unique<GISASSimulation>();
- result->setSample(sample);
- result->setDetectorParameters(25, -2 * deg, 2 * deg, 25, 0, 2 * deg);
- result->setBeamParameters(1 * angstrom, 0.2 * deg, 0);
- result->beam().setIntensity(1e6);
- return result;
-}
diff --git a/Core/Examples/StandardSimulations.h b/Core/Examples/StandardSimulations.h
deleted file mode 100644
index 326ce7750cd..00000000000
--- a/Core/Examples/StandardSimulations.h
+++ /dev/null
@@ -1,59 +0,0 @@
-// ************************************************************************************************
-//
-// BornAgain: simulate and fit reflection and scattering
-//
-//! @file Core/Examples/StandardSimulations.h
-//! @brief Defines namespace and functions for standard simulations.
-//!
-//! @homepage http://www.bornagainproject.org
-//! @license GNU General Public License v3 or higher (see COPYING)
-//! @copyright Forschungszentrum Jülich GmbH 2018
-//! @authors Scientific Computing Group at MLZ (see CITATION, AUTHORS)
-//
-// ************************************************************************************************
-
-#ifdef SWIG
-#error no need to expose this header to Swig
-#endif
-
-#ifndef USER_API
-#ifndef BORNAGAIN_CORE_EXAMPLES_STANDARDSIMULATIONS_H
-#define BORNAGAIN_CORE_EXAMPLES_STANDARDSIMULATIONS_H
-
-#include <memory>
-
-class GISASSimulation;
-class MultiLayer;
-
-//! Standard pre-defined simulations.
-
-namespace StdSimulations {
-
-// CoreSuite tests:
-std::unique_ptr<GISASSimulation> MiniGISAS(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> MiniGISAS_v2(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> MiniZPolarizedGISAS(const MultiLayer& sample,
- const std::string& polCase);
-std::unique_ptr<GISASSimulation> BasicGISAS(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> SpinflipGISAS(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> MiniGISASBeamDivergence(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> MiniGISASDetectorResolution(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> MiniGISASSpecularPeak(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> GISASWithMasks(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> MaxiGISAS(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> MaxiGISAS00(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> RectDetectorGeneric(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> RectDetectorPerpToSample(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> RectDetectorPerpToDirectBeam(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> RectDetectorPerpToReflectedBeam(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> RectDetectorPerpToReflectedBeamDpos(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> MiniGISASMonteCarlo(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> SphericalDetWithRoi(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> RectDetWithRoi(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> MiniGISASFit(const MultiLayer& sample);
-std::unique_ptr<GISASSimulation> ExtraLongWavelengthGISAS(const MultiLayer& sample);
-
-} // namespace StdSimulations
-
-#endif // BORNAGAIN_CORE_EXAMPLES_STANDARDSIMULATIONS_H
-#endif // USER_API
diff --git a/Tests/Functional/Core/Consistence/ConsistenceTests.cpp b/Tests/Functional/Core/Consistence/ConsistenceTests.cpp
index b49c1989dfe..2762da04d6c 100644
--- a/Tests/Functional/Core/Consistence/ConsistenceTests.cpp
+++ b/Tests/Functional/Core/Consistence/ConsistenceTests.cpp
@@ -15,7 +15,6 @@
// These tests check whether pairs of reference data sets, generated by
// some other tests, coincide within reasonable numeric error margins.
-#include "Core/Examples/StandardSimulations.h"
#include "Core/Simulation/GISASSimulation.h"
#include "Core/Simulation/SpecularSimulation.h"
#include "Device/Data/OutputData.h"
@@ -58,7 +57,7 @@ TEST_F(Consistence, PolarizedQAngleReflectivity)
TEST_F(Consistence, PolarizedScalarSpinFlip)
{
auto sample = PlainMultiLayerBySLDBuilder(10).buildSample();
- auto simulation = StdTestSimulations::BasicYPolarizedSpecular(*sample, "PM", false);
+ auto simulation = test::makeSimulation::BasicYPolarizedSpecular(*sample, "PM", false);
simulation->setSample(*sample);
simulation->runSimulation();
auto result = simulation->result().data();
@@ -69,7 +68,7 @@ TEST_F(Consistence, PolarizedScalarSpinFlip)
TEST_F(Consistence, PolarizedScalarSpinFlipParticles)
{
auto sample = CylindersAndPrismsBuilder().buildSample();
- auto simulation = StdSimulations::MiniZPolarizedGISAS(*sample, "PM");
+ auto simulation = test::makeSimulation::MiniZPolarizedGISAS(*sample, "PM");
simulation->runSimulation();
auto result = simulation->result().data();
for (auto r : *result)
diff --git a/Tests/Functional/Core/Fitting/FitTests.cpp b/Tests/Functional/Core/Fitting/FitTests.cpp
index 991ffc8fb1d..72c3815b56c 100644
--- a/Tests/Functional/Core/Fitting/FitTests.cpp
+++ b/Tests/Functional/Core/Fitting/FitTests.cpp
@@ -13,7 +13,6 @@
// ************************************************************************************************
#include "Base/Const/Units.h"
-#include "Core/Examples/StandardSimulations.h"
#include "Core/Fitting/FitObjective.h"
#include "Core/Simulation/GISASSimulation.h"
#include "Core/Simulation/OffSpecularSimulation.h"
@@ -66,7 +65,7 @@ const auto build_Resonator = [](const mumufit::Parameters& params) -> MultiLayer
const auto build_CylBA_MiniGISAS =
[](const mumufit::Parameters& params) -> std::unique_ptr<ISimulation> {
- return StdSimulations::MiniGISAS(*build_CylBA(params));
+ return test::makeSimulation::MiniGISAS(*build_CylBA(params));
};
const auto build_CylBA_Masked =
@@ -87,17 +86,17 @@ const auto build_CylBA_Masked =
const auto build_AlternatingLayers_Specular =
[](const mumufit::Parameters& params) -> std::unique_ptr<ISimulation> {
- return StdTestSimulations::BasicSpecular(*build_AlternatingLayers(params), false);
+ return test::makeSimulation::BasicSpecular(*build_AlternatingLayers(params), false);
};
const auto build_AlternatingLayers_SpecularQ =
[](const mumufit::Parameters& params) -> std::unique_ptr<ISimulation> {
- return StdTestSimulations::BasicSpecular(*build_AlternatingLayers(params), true);
+ return test::makeSimulation::BasicSpecular(*build_AlternatingLayers(params), true);
};
const auto build_Resonator_Offspec =
[](const mumufit::Parameters& params) -> std::unique_ptr<ISimulation> {
- return StdTestSimulations::MiniOffSpecular(*build_Resonator(params));
+ return test::makeSimulation::MiniOffSpecular(*build_Resonator(params));
};
diff --git a/Tests/Functional/ProStd/StdTestSimulations.cpp b/Tests/Functional/ProStd/StdTestSimulations.cpp
index cdd7d29044f..5e2b6b9a64d 100644
--- a/Tests/Functional/ProStd/StdTestSimulations.cpp
+++ b/Tests/Functional/ProStd/StdTestSimulations.cpp
@@ -64,11 +64,267 @@ const std::map<std::string, std::pair<R3, R3>> YPolarizationCases = {
using Units::angstrom;
using Units::deg;
+// ************************************************************************************************
+// GISAS simulations
+// ************************************************************************************************
+
+//! GISAS simulation with small detector and phi[-2,2], theta[0,2].
+
+std::unique_ptr<GISASSimulation> test::makeSimulation::MiniGISAS(const MultiLayer& sample)
+{
+ Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
+ SphericalDetector det(25, -2 * deg, 2 * deg, 25, 0, 2 * deg);
+ return std::make_unique<GISASSimulation>(beam, sample, det);
+}
+
+
+//! GISAS simulation with small detector and phi[-1,1], theta[0,1].
+
+std::unique_ptr<GISASSimulation> test::makeSimulation::MiniGISAS_v2(const MultiLayer& sample)
+{
+ Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
+ SphericalDetector det(25, -1 * deg, 1 * deg, 25, 0, 1 * deg);
+ return std::make_unique<GISASSimulation>(beam, sample, det);
+}
+
+std::unique_ptr<GISASSimulation>
+test::makeSimulation::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));
+ beam.setPolarization(zCase.first);
+ SphericalDetector det(25, -2 * deg, 2 * deg, 25, 0, 2 * deg);
+ det.setAnalyzer(zCase.second, 1., .5);
+ return std::make_unique<GISASSimulation>(beam, sample, det);
+}
+
+
+//! Basic GISAS simulation with the detector phi[0,2], theta[0,2].
+
+std::unique_ptr<GISASSimulation> test::makeSimulation::BasicGISAS(const MultiLayer& sample)
+{
+ Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
+ SphericalDetector det(100, 0, 2 * deg, 100, 0, 2 * deg);
+ return std::make_unique<GISASSimulation>(beam, sample, det);
+}
+
+//! Basic GISAS simulation for spin flip channel.
+
+std::unique_ptr<GISASSimulation> test::makeSimulation::SpinflipGISAS(const MultiLayer& sample)
+{
+ std::unique_ptr<GISASSimulation> result = BasicGISAS(sample);
+ result->instrument().setPolFilters(zplus, zplus, -1.0, 0.5);
+ return result;
+}
+
+//! GISAS simulation with beam divergence applied.
+
+std::unique_ptr<GISASSimulation>
+test::makeSimulation::MiniGISASBeamDivergence(const MultiLayer& sample)
+{
+ std::unique_ptr<GISASSimulation> result = MiniGISAS(sample);
+
+ DistributionLogNormal wavelength_distr(1 * angstrom, 0.1);
+ DistributionGaussian alpha_distr(0.2 * deg, 0.02 * deg);
+ DistributionGate phi_distr(-0.1 * deg, 0.02 * deg);
+
+ result->addParameterDistribution(ParameterDistribution::BeamWavelength, wavelength_distr, 5);
+ result->addParameterDistribution(ParameterDistribution::BeamInclinationAngle, alpha_distr, 4);
+ result->addParameterDistribution(ParameterDistribution::BeamAzimuthalAngle, phi_distr, 3);
+
+ return result;
+}
+
+//! GISAS simulation with multiple masks on the detector plane.
+
+std::unique_ptr<GISASSimulation> test::makeSimulation::GISASWithMasks(const MultiLayer& sample)
+{
+ Beam beam(1e7, 1 * angstrom, Direction(0.2 * deg, 0));
+ SphericalDetector det(50, -1 * deg, 1 * deg, 50, 0, 2 * deg);
+ std::unique_ptr<GISASSimulation> result = std::make_unique<GISASSimulation>(beam, sample, det);
+
+ result->maskAll();
+ // pacman
+ result->addMask(Ellipse(0.0 * deg, 1.0 * deg, 0.5 * deg, 0.5 * deg), false);
+ result->addMask(Ellipse(0.11 * deg, 1.25 * deg, 0.05 * deg, 0.05 * deg), true);
+
+ std::vector<std::vector<double>> points = {{0.0 * deg, 1.0 * deg},
+ {0.5 * deg, 1.2 * deg},
+ {0.5 * deg, 0.8 * deg},
+ {0.0 * deg, 1.0 * deg}};
+ result->addMask(Polygon(points), true);
+
+ result->addMask(Rectangle(0.45 * deg, 0.95 * deg, 0.55 * deg, 1.05 * deg), false);
+ result->addMask(Rectangle(0.61 * deg, 0.95 * deg, 0.71 * deg, 1.05 * deg), false);
+ result->addMask(Rectangle(0.75 * deg, 0.95 * deg, 0.85 * deg, 1.05 * deg), false);
+
+ // more masks
+ result->addMask(Ellipse(-0.5 * deg, 1.5 * deg, 0.3 * deg, 0.1 * deg, 45. * deg), false);
+ result->addMask(VerticalLine(-0.6 * deg), true);
+ result->addMask(HorizontalLine(0.3 * deg), false);
+
+ return result;
+}
+
+//! GISAS simulation with detector resolution.
+
+std::unique_ptr<GISASSimulation>
+test::makeSimulation::MiniGISASDetectorResolution(const MultiLayer& sample)
+{
+ std::unique_ptr<GISASSimulation> result = MiniGISAS(sample);
+ ResolutionFunction2DGaussian resfunc(0.0025, 0.0025);
+ result->detector().setResolutionFunction(resfunc);
+ return result;
+}
+
+//! GISAS simulation with small detector and including specular peak.
+
+std::unique_ptr<GISASSimulation>
+test::makeSimulation::MiniGISASSpecularPeak(const MultiLayer& sample)
+{
+ Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
+ SphericalDetector det(25, -2 * deg, 2 * deg, 25, 0, 2 * deg);
+ std::unique_ptr<GISASSimulation> result = std::make_unique<GISASSimulation>(beam, sample, det);
+ result->setBeamParameters(1 * angstrom, 0.2 * deg, 0);
+ result->options().setIncludeSpecular(true);
+ return result;
+}
+
+//! GISAS simulation with large detector to test performance.
+
+std::unique_ptr<GISASSimulation> test::makeSimulation::MaxiGISAS(const MultiLayer& sample)
+{
+ Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
+ SphericalDetector det(256, -2 * deg, 2 * deg, 256, 0, 2 * deg);
+ return std::make_unique<GISASSimulation>(beam, sample, det);
+}
+
+//! Basic GISAS for polarization studies.
+
+std::unique_ptr<GISASSimulation> test::makeSimulation::MaxiGISAS00(const MultiLayer& sample)
+{
+ std::unique_ptr<GISASSimulation> result = MaxiGISAS(sample);
+ result->instrument().setPolFilters(zplus, zplus, 1.0, 0.5);
+ return result;
+}
+
+//! GISAS simulation with generic rectangular detector.
+
+std::unique_ptr<GISASSimulation> test::makeSimulation::RectDetectorGeneric(const MultiLayer& sample)
+{
+ Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
+ RectangularDetector det(rdet_nbinsx, rdet_width, rdet_nbinsy, rdet_height);
+ det.setPosition(R3(rdet_distance, 10.0, 5.0), rdet_width / 2., 1.0, R3(0.1, -1.0, 0.2));
+ return std::make_unique<GISASSimulation>(beam, sample, det);
+}
+
+//! GISAS simulation with the rectangular detector perpendicular to the sample.
+
+std::unique_ptr<GISASSimulation>
+test::makeSimulation::RectDetectorPerpToSample(const MultiLayer& sample)
+{
+ Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
+ RectangularDetector det(rdet_nbinsx, rdet_width, rdet_nbinsy, rdet_height);
+ det.setPerpendicularToSampleX(rdet_distance, rdet_width / 2., 1.0);
+ return std::make_unique<GISASSimulation>(beam, sample, det);
+}
+
+//! GISAS simulation with the rectangular detector perpendicular to the direct beam.
+
+std::unique_ptr<GISASSimulation>
+test::makeSimulation::RectDetectorPerpToDirectBeam(const MultiLayer& sample)
+{
+ Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
+ RectangularDetector det(rdet_nbinsx, rdet_width, rdet_nbinsy, rdet_height);
+ det.setPerpendicularToDirectBeam(rdet_distance, rdet_width / 2., 1.0);
+ return std::make_unique<GISASSimulation>(beam, sample, det);
+}
+
+//! GISAS simulation with the rectangular detector perpendicular to the reflected beam.
+
+std::unique_ptr<GISASSimulation>
+test::makeSimulation::RectDetectorPerpToReflectedBeam(const MultiLayer& sample)
+{
+ Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
+ RectangularDetector det(rdet_nbinsx, rdet_width, rdet_nbinsy, rdet_height);
+ det.setPerpendicularToReflectedBeam(rdet_distance, rdet_width / 2., 1.0);
+ return std::make_unique<GISASSimulation>(beam, sample, det);
+}
+
+//! GISAS simulation with the rectangular detector perpendicular to the reflected beam when
+//! the coordinates of direct beam are known.
+
+std::unique_ptr<GISASSimulation>
+test::makeSimulation::RectDetectorPerpToReflectedBeamDpos(const MultiLayer& sample)
+{
+ Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
+ RectangularDetector det(rdet_nbinsx, rdet_width, rdet_nbinsy, rdet_height);
+ det.setPerpendicularToReflectedBeam(rdet_distance);
+ det.setDirectBeamPosition(rdet_width / 2., 1.0);
+ return std::make_unique<GISASSimulation>(beam, sample, det);
+}
+
+//! GISAS simulation with Monte-Carlo integration switched ON.
+
+std::unique_ptr<GISASSimulation> test::makeSimulation::MiniGISASMonteCarlo(const MultiLayer& sample)
+{
+ std::unique_ptr<GISASSimulation> result = MiniGISAS(sample);
+ result->options().setMonteCarloIntegration(true, 100);
+ return result;
+}
+
+//! GISAS simulation with spherical detector, region of interest and mask.
+
+std::unique_ptr<GISASSimulation> test::makeSimulation::SphericalDetWithRoi(const MultiLayer& sample)
+{
+ Beam beam(1.0, 1 * angstrom, Direction(0.2 * deg, 0));
+ SphericalDetector det(40, -2 * deg, 2 * deg, 30, 0, 3 * deg);
+ std::unique_ptr<GISASSimulation> result = std::make_unique<GISASSimulation>(beam, sample, det);
+ result->addMask(Rectangle(-0.5 * deg, 0.3 * deg, -0.2 * deg, 0.6 * deg));
+ result->setRegionOfInterest(-1.5 * deg, 0.25 * deg, 1.5 * deg, 1.75 * deg);
+ return result;
+}
+
+//! GISAS simulation with rectangular detector, region of interest and mask.
+
+std::unique_ptr<GISASSimulation> test::makeSimulation::RectDetWithRoi(const MultiLayer& sample)
+{
+ std::unique_ptr<GISASSimulation> result = RectDetectorPerpToDirectBeam(sample);
+ result->addMask(Rectangle(3.0, 4.0, 5.0, 7.0));
+ result->setRegionOfInterest(2.0, 3.0, 18.0, 15.0);
+ return result;
+}
+
+//! GISAS simulation with an extra long wavelength
+
+std::unique_ptr<GISASSimulation>
+test::makeSimulation::ExtraLongWavelengthGISAS(const MultiLayer& sample)
+{
+ Beam beam(1e8, 13.52 * Units::nm, Direction(0.2 * deg, 0));
+ SphericalDetector det(100, -1 * deg, 1 * deg, 100, 0.0, 2 * deg);
+ auto simulation = std::make_unique<GISASSimulation>(beam, sample, det);
+ simulation->options().setIncludeSpecular(true);
+ return simulation;
+}
+
+//! ISimulation with fitting.
+//! Beam intensity set to provide reasonably large values in detector channels.
+std::unique_ptr<GISASSimulation> test::makeSimulation::MiniGISASFit(const MultiLayer& sample)
+{
+ auto result = std::make_unique<GISASSimulation>();
+ result->setSample(sample);
+ result->setDetectorParameters(25, -2 * deg, 2 * deg, 25, 0, 2 * deg);
+ result->setBeamParameters(1 * angstrom, 0.2 * deg, 0);
+ result->beam().setIntensity(1e6);
+ return result;
+}
+
// ************************************************************************************************
// off-specular simulations
// ************************************************************************************************
-std::unique_ptr<OffSpecularSimulation> StdTestSimulations::MiniOffSpecular(const MultiLayer& sample)
+std::unique_ptr<OffSpecularSimulation>
+test::makeSimulation::MiniOffSpecular(const MultiLayer& sample)
{
auto result = std::make_unique<OffSpecularSimulation>();
result->setSample(sample);
@@ -99,8 +355,8 @@ std::unique_ptr<OffSpecularSimulation> StdTestSimulations::MiniOffSpecular(const
// specular simulations
// ************************************************************************************************
-std::unique_ptr<SpecularSimulation> StdTestSimulations::BasicSpecular(const MultiLayer& sample,
- bool vsQ)
+std::unique_ptr<SpecularSimulation> test::makeSimulation::BasicSpecular(const MultiLayer& sample,
+ bool vsQ)
{
const double wavelength = 1.54 * angstrom;
const int number_of_bins = 2000;
@@ -128,8 +384,8 @@ std::unique_ptr<SpecularSimulation> StdTestSimulations::BasicSpecular(const Mult
}
std::unique_ptr<SpecularSimulation>
-StdTestSimulations::BasicYPolarizedSpecular(const MultiLayer& sample, const std::string& polCase,
- bool vsQ)
+test::makeSimulation::BasicYPolarizedSpecular(const MultiLayer& sample, const std::string& polCase,
+ bool vsQ)
{
const auto yCase = YPolarizationCases.at(polCase);
auto simulation = BasicSpecular(sample, vsQ);
@@ -139,7 +395,7 @@ StdTestSimulations::BasicYPolarizedSpecular(const MultiLayer& sample, const std:
}
std::unique_ptr<SpecularSimulation>
-StdTestSimulations::SpecularWithGaussianBeam(const MultiLayer& sample)
+test::makeSimulation::SpecularWithGaussianBeam(const MultiLayer& sample)
{
const double wavelength = 1.54 * angstrom;
const int number_of_bins = 2000;
@@ -156,7 +412,7 @@ StdTestSimulations::SpecularWithGaussianBeam(const MultiLayer& sample)
}
std::unique_ptr<SpecularSimulation>
-StdTestSimulations::SpecularWithSquareBeam(const MultiLayer& sample)
+test::makeSimulation::SpecularWithSquareBeam(const MultiLayer& sample)
{
const double wavelength = 1.54 * angstrom;
const int number_of_bins = 2000;
@@ -173,7 +429,7 @@ StdTestSimulations::SpecularWithSquareBeam(const MultiLayer& sample)
}
std::unique_ptr<SpecularSimulation>
-StdTestSimulations::SpecularDivergentBeam(const MultiLayer& sample)
+test::makeSimulation::SpecularDivergentBeam(const MultiLayer& sample)
{
const double wavelength = 1.54 * angstrom;
const int number_of_bins = 20;
@@ -202,7 +458,7 @@ StdTestSimulations::SpecularDivergentBeam(const MultiLayer& sample)
}
std::unique_ptr<SpecularSimulation>
-StdTestSimulations::TOFRWithRelativeResolution(const MultiLayer& sample)
+test::makeSimulation::TOFRWithRelativeResolution(const MultiLayer& sample)
{
FixedBinAxis qs("axis", 500, 0.0, 1.0);
QzScan q_scan(qs);
@@ -216,7 +472,7 @@ StdTestSimulations::TOFRWithRelativeResolution(const MultiLayer& sample)
}
std::unique_ptr<SpecularSimulation>
-StdTestSimulations::TOFRWithPointwiseResolution(const MultiLayer& sample)
+test::makeSimulation::TOFRWithPointwiseResolution(const MultiLayer& sample)
{
FixedBinAxis qs("axis", 500, 0.0, 1.0);
QzScan q_scan(qs);
@@ -239,7 +495,8 @@ StdTestSimulations::TOFRWithPointwiseResolution(const MultiLayer& sample)
// depth probe simulations
// ************************************************************************************************
-std::unique_ptr<DepthProbeSimulation> StdTestSimulations::BasicDepthProbe(const MultiLayer& sample)
+std::unique_ptr<DepthProbeSimulation>
+test::makeSimulation::BasicDepthProbe(const MultiLayer& sample)
{
auto result = std::make_unique<DepthProbeSimulation>();
diff --git a/Tests/Functional/ProStd/StdTestSimulations.h b/Tests/Functional/ProStd/StdTestSimulations.h
index c05da762f92..f1d5177cf3f 100644
--- a/Tests/Functional/ProStd/StdTestSimulations.h
+++ b/Tests/Functional/ProStd/StdTestSimulations.h
@@ -30,7 +30,30 @@ class MultiLayer;
//! Simulations for standard tests.
-namespace StdTestSimulations {
+namespace test::makeSimulation {
+
+std::unique_ptr<GISASSimulation> MiniGISAS(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> MiniGISAS_v2(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> MiniZPolarizedGISAS(const MultiLayer& sample,
+ const std::string& polCase);
+std::unique_ptr<GISASSimulation> BasicGISAS(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> SpinflipGISAS(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> MiniGISASBeamDivergence(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> MiniGISASDetectorResolution(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> MiniGISASSpecularPeak(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> GISASWithMasks(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> MaxiGISAS(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> MaxiGISAS00(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> RectDetectorGeneric(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> RectDetectorPerpToSample(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> RectDetectorPerpToDirectBeam(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> RectDetectorPerpToReflectedBeam(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> RectDetectorPerpToReflectedBeamDpos(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> MiniGISASMonteCarlo(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> SphericalDetWithRoi(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> RectDetWithRoi(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> MiniGISASFit(const MultiLayer& sample);
+std::unique_ptr<GISASSimulation> ExtraLongWavelengthGISAS(const MultiLayer& sample);
std::unique_ptr<OffSpecularSimulation> MiniOffSpecular(const MultiLayer& sample);
@@ -45,7 +68,7 @@ std::unique_ptr<SpecularSimulation> TOFRWithPointwiseResolution(const MultiLayer
std::unique_ptr<DepthProbeSimulation> BasicDepthProbe(const MultiLayer& sample);
-} // namespace StdTestSimulations
+} // namespace test::makeSimulations
#endif // BORNAGAIN_TESTS_FUNCTIONAL_PROSTD_STDTESTSIMULATIONS_H
#endif // USER_API
diff --git a/Tests/Functional/PyCore/utils.py b/Tests/Functional/PyCore/utils.py
index 3ec9b57a6b6..3f03dacc324 100644
--- a/Tests/Functional/PyCore/utils.py
+++ b/Tests/Functional/PyCore/utils.py
@@ -39,7 +39,7 @@ def get_reference_data(filename):
return ba.IntensityDataIOFactory.readIntensityData(
os.path.join(REFERENCE_DIR, filename))
-# TODO rather use StdSimulations::MiniGISAS
+# TODO rather use test::makeSimulation::MiniGISAS
def get_simulation_MiniGISAS(sample):
detector = ba.SphericalDetector(25, -2*deg, 2*deg, 25, 0, 2*deg)
beam = ba.Beam(1., 1*angstrom, ba.Direction(0.2*deg, 0))
diff --git a/Tests/Functional/Std/StandardTests.h b/Tests/Functional/Std/StandardTests.h
index a3acefc52a2..5d658cb15a3 100644
--- a/Tests/Functional/Std/StandardTests.h
+++ b/Tests/Functional/Std/StandardTests.h
@@ -20,7 +20,6 @@
#define BORNAGAIN_TESTS_FUNCTIONAL_STD_STANDARDTESTS_H
#include "Core/Background/ConstantBackground.h"
-#include "Core/Examples/StandardSimulations.h"
#include "Core/Simulation/DepthProbeSimulation.h"
#include "Core/Simulation/GISASSimulation.h"
#include "Core/Simulation/OffSpecularSimulation.h"
@@ -52,7 +51,7 @@ TEST_F(Std, FormFactors)
ASSERT(ff);
std::unique_ptr<const MultiLayer> sample(ParticleInVacuumBuilder().buildSampleWithFF(ff));
ASSERT(sample);
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("FormFactors_" + ff->shapeName(), *sim, 2e-10));
}
}
@@ -60,28 +59,28 @@ TEST_F(Std, FormFactors)
TEST_F(Std, GISASAbsorptiveSLDLayers)
{
std::unique_ptr<const MultiLayer> sample(LayersWithAbsorptionBySLDBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("GISASAbsorptiveSLDLayers", *sim, 2e-10));
}
TEST_F(Std, CylindersAndPrisms)
{
std::unique_ptr<const MultiLayer> sample(CylindersAndPrismsBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("CylindersAndPrisms", *sim, 2e-10));
}
TEST_F(Std, RadialParaCrystal)
{
std::unique_ptr<const MultiLayer> sample(RadialParaCrystalBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("RadialParaCrystal", *sim, 2e-10));
}
TEST_F(Std, HardDisk)
{
std::unique_ptr<const MultiLayer> sample(HardDiskBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("HardDisk", *sim, 2e-10));
}
@@ -94,7 +93,7 @@ TEST_F(Std, Basic2DParaCrystal)
std::unique_ptr<const MultiLayer> sample(
Basic2DParaCrystalBuilder().buildSampleWithFTDis(pdf2));
ASSERT(sample);
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("Basic2DParaCrystal_" + pdf2->className(), *sim, 2e-10));
}
}
@@ -102,14 +101,14 @@ TEST_F(Std, Basic2DParaCrystal)
TEST_F(Std, HexParaCrystal)
{
std::unique_ptr<const MultiLayer> sample(HexParaCrystalBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("HexParaCrystal", *sim, 2e-10));
}
TEST_F(Std, Lattice1D)
{
std::unique_ptr<const MultiLayer> sample(Lattice1DBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("Lattice1D", *sim, 2e-10));
}
@@ -118,273 +117,273 @@ 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<const MultiLayer> sample(RectParaCrystalBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("RectParaCrystal", *sim, 1e-9));
}
TEST_F(Std, CoreShellParticle)
{
std::unique_ptr<const MultiLayer> sample(CoreShellParticleBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("CoreShellParticle", *sim, 2e-10));
}
TEST_F(Std, CoreShellBoxRotateZandY)
{
std::unique_ptr<const MultiLayer> sample(CoreShellBoxRotateZandYBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("CoreShellBoxRotateZandY", *sim, 2e-10));
}
TEST_F(Std, MultiLayerWithRoughness)
{
std::unique_ptr<const MultiLayer> sample(MultiLayerWithRoughnessBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("MultiLayerWithRoughness", *sim, 2e-10));
}
TEST_F(Std, SquareLattice2D)
{
std::unique_ptr<const MultiLayer> sample(SquareLattice2DBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("SquareLattice2D", *sim, 2e-10));
}
TEST_F(Std, CenteredSquareLattice2D)
{
std::unique_ptr<const MultiLayer> sample(CenteredSquareLattice2DBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("CenteredSquareLattice2D", *sim, 2e-10));
}
TEST_F(Std, RotatedSquareLattice2D)
{
std::unique_ptr<const MultiLayer> sample(RotatedSquareLattice2DBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("RotatedSquareLattice2D", *sim, 2e-10));
}
TEST_F(Std, FiniteSquareLattice2D)
{
std::unique_ptr<const MultiLayer> sample(FiniteSquareLattice2DBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("FiniteSquareLattice2D", *sim, 2e-10));
}
TEST_F(Std, RotatedPyramids)
{
std::unique_ptr<const MultiLayer> sample(RotatedPyramidsBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("RotatedPyramids", *sim, 2e-10));
}
TEST_F(Std, ThickAbsorptiveSampleWithRoughness)
{
std::unique_ptr<const MultiLayer> sample(ThickAbsorptiveSampleBuilder().buildSample());
- auto sim = StdSimulations::ExtraLongWavelengthGISAS(*sample);
+ auto sim = test::makeSimulation::ExtraLongWavelengthGISAS(*sample);
EXPECT_TRUE(run("ThickAbsorptiveSampleWithRoughness", *sim, 2e-10));
}
TEST_F(Std, ParticleComposition)
{
std::unique_ptr<const MultiLayer> sample(ParticleCompositionBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("ParticleComposition", *sim, 2e-10));
}
TEST_F(Std, BoxCompositionRotateX)
{
std::unique_ptr<const MultiLayer> sample(BoxCompositionRotateXBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("BoxCompositionRotateX", *sim, 2e-10));
}
TEST_F(Std, BoxCompositionRotateY)
{
std::unique_ptr<const MultiLayer> sample(BoxCompositionRotateYBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("BoxCompositionRotateY", *sim, 2e-10));
}
TEST_F(Std, BoxCompositionRotateZ)
{
std::unique_ptr<const MultiLayer> sample(BoxCompositionRotateZBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("BoxCompositionRotateZ", *sim, 2e-10));
}
TEST_F(Std, BoxCompositionRotateZandY)
{
std::unique_ptr<const MultiLayer> sample(BoxCompositionRotateZandYBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("BoxCompositionRotateZandY", *sim, 2e-10));
}
TEST_F(Std, BoxStackComposition)
{
std::unique_ptr<const MultiLayer> sample(BoxStackCompositionBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("BoxStackComposition", *sim, 2e-10));
}
DISTRIBUTION_TEST_F(Std, CylindersWithSizeDistribution)
{
std::unique_ptr<const MultiLayer> sample(CylindersWithSizeDistributionBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("CylindersWithSizeDistribution", *sim, 2e-10));
}
DISTRIBUTION_TEST_F(Std, TwoTypesCylindersDistribution)
{
std::unique_ptr<const MultiLayer> sample(TwoTypesCylindersDistributionBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("TwoTypesCylindersDistribution", *sim, 2e-10));
}
DISTRIBUTION_TEST_F(Std, RotatedPyramidsDistribution)
{
std::unique_ptr<const MultiLayer> sample(RotatedPyramidsDistributionBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("RotatedPyramidsDistribution", *sim, 2e-10));
}
DISTRIBUTION_TEST_F(Std, SpheresWithLimitsDistribution)
{
std::unique_ptr<const MultiLayer> sample(SpheresWithLimitsDistributionBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("SpheresWithLimitsDistribution", *sim, 2e-10));
}
DISTRIBUTION_TEST_F(Std, ConesWithLimitsDistribution)
{
std::unique_ptr<const MultiLayer> sample(ConesWithLimitsDistributionBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("ConesWithLimitsDistribution", *sim, 2e-10));
}
DISTRIBUTION_TEST_F(Std, LinkedBoxDistribution)
{
std::unique_ptr<const MultiLayer> sample(LinkedBoxDistributionBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("LinkedBoxDistribution", *sim, 2e-10));
}
TEST_F(Std, MultipleLayout)
{
std::unique_ptr<const MultiLayer> sample(MultipleLayoutBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("MultipleLayout", *sim, 2e-10));
}
TEST_F(Std, ApproximationDA)
{
std::unique_ptr<const MultiLayer> sample(SizeDistributionDAModelBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("ApproximationDA", *sim, 2e-10));
}
TEST_F(Std, ApproximationLMA)
{
std::unique_ptr<const MultiLayer> sample(SizeDistributionLMAModelBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("ApproximationLMA", *sim, 2e-10));
}
TEST_F(Std, ApproximationSSCA)
{
std::unique_ptr<const MultiLayer> sample(SizeDistributionSSCAModelBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("ApproximationSSCA", *sim, 2e-10));
}
DISTRIBUTION_TEST_F(Std, CylindersInSSCA)
{
std::unique_ptr<const MultiLayer> sample(CylindersInSSCABuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("CylindersInSSCA", *sim, 2e-10));
}
TEST_F(Std, CosineRipple)
{
std::unique_ptr<const MultiLayer> sample(CosineRippleBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("CosineRipple", *sim, 2e-10));
}
TEST_F(Std, TriangularRipple)
{
std::unique_ptr<const MultiLayer> sample(TriangularRippleBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("TriangularRipple", *sim, 2e-10));
}
TEST_F(Std, AsymRipple)
{
std::unique_ptr<const MultiLayer> sample(AsymRippleBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("AsymRipple", *sim, 2e-10));
}
TEST_F(Std, MesoCrystal)
{
std::unique_ptr<const MultiLayer> sample(MesoCrystalBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("MesoCrystal", *sim, 2e-10));
}
TEST_F(Std, CustomMorphology)
{
std::unique_ptr<const MultiLayer> sample(CustomMorphologyBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("CustomMorphology", *sim, 2e-10));
}
TEST_F(Std, TransformBox)
{
std::unique_ptr<const MultiLayer> sample(TransformBoxBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("TransformBox", *sim, 1e-10));
}
TEST_F(Std, MagneticParticleZeroField)
{
std::unique_ptr<const MultiLayer> sample(MagneticParticleZeroFieldBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("MagneticParticleZeroField", *sim, 2e-10));
}
TEST_F(Std, RotatedCylinder)
{
std::unique_ptr<const MultiLayer> sample(RotatedCylindersBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("RotatedCylinder", *sim, 1e-10));
}
TEST_F(Std, SlicedComposition)
{
std::unique_ptr<const MultiLayer> sample(SlicedCompositionBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("SlicedComposition", *sim, 1e-10));
}
TEST_F(Std, MagneticSubstrateZeroField)
{
std::unique_ptr<const MultiLayer> sample(MagneticSubstrateZeroFieldBuilder().buildSample());
- auto sim = StdSimulations::MiniZPolarizedGISAS(*sample, "PP");
+ auto sim = test::makeSimulation::MiniZPolarizedGISAS(*sample, "PP");
EXPECT_TRUE(run("MagneticSubstrateZeroField", *sim, 2e-10));
}
TEST_F(Std, MagneticRotation)
{
std::unique_ptr<const MultiLayer> sample(MagneticRotationBuilder().buildSample());
- auto sim = StdSimulations::MiniZPolarizedGISAS(*sample, "PM");
+ auto sim = test::makeSimulation::MiniZPolarizedGISAS(*sample, "PM");
EXPECT_TRUE(run("MagneticRotationZPM", *sim, 2e-10));
}
TEST_F(Std, MagneticSpheres)
{
std::unique_ptr<const MultiLayer> sample(MagneticSpheresBuilder().buildSample());
- auto sim = StdSimulations::MiniZPolarizedGISAS(*sample, "PM");
+ auto sim = test::makeSimulation::MiniZPolarizedGISAS(*sample, "PM");
EXPECT_TRUE(run("MagneticSpheres", *sim, 2e-10));
}
@@ -392,7 +391,7 @@ TEST_F(Std, MagneticCylinders)
{
for (const std::string& polCase : {"PP", "MP", "PM", "MM"}) {
std::unique_ptr<const MultiLayer> sample(MagneticCylindersBuilder().buildSample());
- auto sim = StdSimulations::MiniZPolarizedGISAS(*sample, polCase);
+ auto sim = test::makeSimulation::MiniZPolarizedGISAS(*sample, polCase);
EXPECT_TRUE(run("MagneticCylinders" + polCase, *sim, 2e-10));
}
}
@@ -401,7 +400,7 @@ TEST_F(Std, MagneticSpheresInMagLayer)
{
for (const std::string& polCase : {"PP", "MP"}) {
std::unique_ptr<const MultiLayer> sample(MagneticLayerBuilder().buildSample());
- auto sim = StdSimulations::MiniZPolarizedGISAS(*sample, polCase);
+ auto sim = test::makeSimulation::MiniZPolarizedGISAS(*sample, polCase);
EXPECT_TRUE(run("MagneticSpheresInMagLayer" + polCase, *sim, 2e-10));
}
}
@@ -409,91 +408,91 @@ TEST_F(Std, MagneticSpheresInMagLayer)
TEST_F(Std, BeamDivergence)
{
std::unique_ptr<const MultiLayer> sample(CylindersInBABuilder().buildSample());
- auto sim = StdSimulations::MiniGISASBeamDivergence(*sample);
+ auto sim = test::makeSimulation::MiniGISASBeamDivergence(*sample);
EXPECT_TRUE(run("BeamDivergence", *sim, 2e-10));
}
TEST_F(Std, DetectorResolution)
{
std::unique_ptr<const MultiLayer> sample(CylindersInBABuilder().buildSample());
- auto sim = StdSimulations::MiniGISASDetectorResolution(*sample);
+ auto sim = test::makeSimulation::MiniGISASDetectorResolution(*sample);
EXPECT_TRUE(run("DetectorResolution", *sim, 2e-10));
}
TEST_F(Std, SimulationWithMasks)
{
std::unique_ptr<const MultiLayer> sample(CylindersAndPrismsBuilder().buildSample());
- auto sim = StdSimulations::GISASWithMasks(*sample);
+ auto sim = test::makeSimulation::GISASWithMasks(*sample);
EXPECT_TRUE(run("SimulationWithMasks", *sim, 1e-10));
}
TEST_F(Std, RectDetectorGeneric)
{
std::unique_ptr<const MultiLayer> sample(CylindersInBABuilder().buildSample());
- auto sim = StdSimulations::RectDetectorGeneric(*sample);
+ auto sim = test::makeSimulation::RectDetectorGeneric(*sample);
EXPECT_TRUE(run("RectDetectorGeneric", *sim, 1e-10));
}
TEST_F(Std, RectDetectorPerpToSample)
{
std::unique_ptr<const MultiLayer> sample(CylindersInBABuilder().buildSample());
- auto sim = StdSimulations::RectDetectorPerpToSample(*sample);
+ auto sim = test::makeSimulation::RectDetectorPerpToSample(*sample);
EXPECT_TRUE(run("RectDetectorPerpToSample", *sim, 1e-10));
}
TEST_F(Std, RectDetectorPerpToDirectBeam)
{
std::unique_ptr<const MultiLayer> sample(CylindersInBABuilder().buildSample());
- auto sim = StdSimulations::RectDetectorPerpToDirectBeam(*sample);
+ auto sim = test::makeSimulation::RectDetectorPerpToDirectBeam(*sample);
EXPECT_TRUE(run("RectDetectorPerpToDirectBeam", *sim, 1e-10));
}
TEST_F(Std, RectDetectorPerpToReflectedBeam)
{
std::unique_ptr<const MultiLayer> sample(CylindersInBABuilder().buildSample());
- auto sim = StdSimulations::RectDetectorPerpToReflectedBeam(*sample);
+ auto sim = test::makeSimulation::RectDetectorPerpToReflectedBeam(*sample);
EXPECT_TRUE(run("RectDetectorPerpToReflectedBeam", *sim, 1e-10));
}
TEST_F(Std, RectDetectorPerpToReflectedBeamDpos)
{
std::unique_ptr<const MultiLayer> sample(CylindersInBABuilder().buildSample());
- auto sim = StdSimulations::RectDetectorPerpToReflectedBeamDpos(*sample);
+ auto sim = test::makeSimulation::RectDetectorPerpToReflectedBeamDpos(*sample);
EXPECT_TRUE(run("RectDetectorPerpToReflectedBeamDpos", *sim, 1e-10));
}
TEST_F(Std, LargeCylindersMonteCarlo)
{
std::unique_ptr<const MultiLayer> sample(LargeCylindersInDWBABuilder().buildSample());
- auto sim = StdSimulations::MiniGISASMonteCarlo(*sample);
+ auto sim = test::makeSimulation::MiniGISASMonteCarlo(*sample);
EXPECT_TRUE(run("LargeCylindersMonteCarlo", *sim, 5e-1));
}
TEST_F(Std, SphericalDetWithRoi)
{
std::unique_ptr<const MultiLayer> sample(CylindersAndPrismsBuilder().buildSample());
- auto sim = StdSimulations::SphericalDetWithRoi(*sample);
+ auto sim = test::makeSimulation::SphericalDetWithRoi(*sample);
EXPECT_TRUE(run("SphericalDetWithRoi", *sim, 1e-10));
}
TEST_F(Std, RectDetWithRoi)
{
std::unique_ptr<const MultiLayer> sample(CylindersAndPrismsBuilder().buildSample());
- auto sim = StdSimulations::RectDetWithRoi(*sample);
+ auto sim = test::makeSimulation::RectDetWithRoi(*sample);
EXPECT_TRUE(run("RectDetWithRoi", *sim, 1e-10));
}
TEST_F(Std, BoxesWithSpecular)
{
std::unique_ptr<const MultiLayer> sample(BoxesSquareLattice2DBuilder().buildSample());
- auto sim = StdSimulations::MiniGISASSpecularPeak(*sample);
+ auto sim = test::makeSimulation::MiniGISASSpecularPeak(*sample);
EXPECT_TRUE(run("BoxesWithSpecular", *sim, 1e-10));
}
TEST_F(Std, ConstantBackground)
{
auto sample = CylindersInBABuilder().buildSample();
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
sim->setBackground(ConstantBackground(1e3));
EXPECT_TRUE(run("ConstantBackground", *sim, 1e-10));
}
@@ -501,42 +500,42 @@ TEST_F(Std, ConstantBackground)
TEST_F(Std, HomogeneousTiNiSample)
{
auto sample = HomogeneousMultilayerBuilder().buildSample();
- auto sim = StdTestSimulations::BasicSpecular(*sample, false);
+ auto sim = test::makeSimulation::BasicSpecular(*sample, false);
EXPECT_TRUE(run("HomogeneousTiNiSample", *sim, 1e-10));
}
TEST_F(Std, HomogeneousTiNiSampleWithAbsorption)
{
auto sample = PlainMultiLayerBySLDBuilder().buildSample();
- auto sim = StdTestSimulations::BasicSpecular(*sample, false);
+ auto sim = test::makeSimulation::BasicSpecular(*sample, false);
EXPECT_TRUE(run("HomogeneousTiNiSampleWithAbsorption", *sim, 1e-10));
}
TEST_F(Std, RoughnessInSpecular)
{
auto sample = MultiLayerWithRoughnessBuilder().buildSample();
- auto sim = StdTestSimulations::BasicSpecular(*sample, false);
+ auto sim = test::makeSimulation::BasicSpecular(*sample, false);
EXPECT_TRUE(run("RoughnessInSpecular", *sim, 2e-9));
}
TEST_F(Std, GaussianBeamFootprint)
{
auto sample = HomogeneousMultilayerBuilder().buildSample();
- auto sim = StdTestSimulations::SpecularWithGaussianBeam(*sample);
+ auto sim = test::makeSimulation::SpecularWithGaussianBeam(*sample);
EXPECT_TRUE(run("GaussianBeamFootprint", *sim, 1e-10));
}
TEST_F(Std, SquareBeamFootprint)
{
auto sample = HomogeneousMultilayerBuilder().buildSample();
- auto sim = StdTestSimulations::SpecularWithSquareBeam(*sample);
+ auto sim = test::makeSimulation::SpecularWithSquareBeam(*sample);
EXPECT_TRUE(run("SquareBeamFootprint", *sim, 1e-10));
}
TEST_F(Std, SpecularDivergentBeam)
{
auto sample = HomogeneousMultilayerBuilder().buildSample();
- auto sim = StdTestSimulations::SpecularDivergentBeam(*sample);
+ auto sim = test::makeSimulation::SpecularDivergentBeam(*sample);
EXPECT_TRUE(run("SpecularDivergentBeam", *sim, 1e-10));
}
@@ -549,7 +548,7 @@ TEST_F(Std, SpecularDivergentBeam)
TEST_F(Std, RelativeResolutionTOF)
{
auto sample = PlainMultiLayerBySLDBuilder().buildSample();
- auto sim = StdTestSimulations::TOFRWithRelativeResolution(*sample);
+ auto sim = test::makeSimulation::TOFRWithRelativeResolution(*sample);
EXPECT_TRUE(run("RelativeResolutionTOF", *sim, 1e-10));
}
@@ -564,7 +563,7 @@ TEST_F(Std, RelativeResolutionTOF)
TEST_F(Std, OffSpecularResonator)
{
auto sample = ResonatorBuilder().buildSample();
- auto sim = StdTestSimulations::MiniOffSpecular(*sample);
+ auto sim = test::makeSimulation::MiniOffSpecular(*sample);
EXPECT_TRUE(run("OffSpecularResonator", *sim, 1e-10));
}
@@ -576,7 +575,7 @@ TEST_F(Std, FormFactorsWithAbsorption)
std::unique_ptr<const MultiLayer> sample(
LayersWithAbsorptionBuilder().buildSampleWithFF(ff));
ASSERT(sample);
- auto sim = StdSimulations::MiniGISAS_v2(*sample);
+ auto sim = test::makeSimulation::MiniGISAS_v2(*sample);
EXPECT_TRUE(run("FormFactorsWithAbsorption_" + ff->shapeName(), *sim, 2e-10));
}
}
@@ -592,14 +591,14 @@ TEST_F(Std, FormFactorsWithAbsorption)
TEST_F(Std, NCRoughnessInSpecular)
{
auto sample = MultiLayerWithNCRoughnessBuilder().buildSample();
- auto sim = StdTestSimulations::BasicSpecular(*sample, false);
+ auto sim = test::makeSimulation::BasicSpecular(*sample, false);
EXPECT_TRUE(run("NCRoughnessInSpecular", *sim, 2e-9));
}
TEST_F(Std, SuperLattice)
{
std::unique_ptr<const MultiLayer> sample(SuperLatticeBuilder().buildSample());
- auto sim = StdSimulations::MiniGISAS(*sample);
+ auto sim = test::makeSimulation::MiniGISAS(*sample);
EXPECT_TRUE(run("SuperLattice", *sim, 2e-10));
}
@@ -607,16 +606,16 @@ TEST_F(Std, SpecularWithSlicing1)
{
// data almost fully agree with SpecularWithSlicing2, as verified by ConsistenceTest
auto sample = SlicedCylindersBuilder().buildSample();
- auto sim = StdTestSimulations::BasicSpecular(*sample, false);
+ auto sim = test::makeSimulation::BasicSpecular(*sample, false);
EXPECT_TRUE(run("SpecularWithSlicing1", *sim, 1e-10));
}
TEST_F(Std, SpecularWithSlicing2)
{
auto sample = SLDSlicedCylindersBuilder().buildSample();
- auto sim = StdTestSimulations::BasicSpecular(*sample, false);
+ auto sim = test::makeSimulation::BasicSpecular(*sample, false);
EXPECT_TRUE(run("SpecularWithSlicing2", *sim, 1e-10));
- auto simQ = StdTestSimulations::BasicSpecular(*sample, true);
+ auto simQ = test::makeSimulation::BasicSpecular(*sample, true);
EXPECT_TRUE(run("SpecularWithSlicing2Q", *simQ, 1e-10));
}
@@ -624,25 +623,25 @@ TEST_F(Std, SpecularWithSlicing3)
{
// data fully agree with SpecularWithSlicing2, as verified by ConsistenceTest
auto sample = AveragedSlicedCylindersBuilder().buildSample();
- auto sim = StdTestSimulations::BasicSpecular(*sample, false);
+ auto sim = test::makeSimulation::BasicSpecular(*sample, false);
EXPECT_TRUE(run("SpecularWithSlicing3", *sim, 1e-10));
}
TEST_F(Std, InstrumentDefinitionComparison)
{
auto sample = PlainMultiLayerBySLDBuilder().buildSample();
- auto sim = StdTestSimulations::BasicSpecular(*sample, false);
+ auto sim = test::makeSimulation::BasicSpecular(*sample, false);
EXPECT_TRUE(run("InstrumentDefinitionComparison_0", *sim, 1e-10));
- auto simQ = StdTestSimulations::BasicSpecular(*sample, true);
+ auto simQ = test::makeSimulation::BasicSpecular(*sample, true);
EXPECT_TRUE(run("InstrumentDefinitionComparison_Q", *simQ, 1e-10));
}
TEST_F(Std, TOFResolutionComparison)
{
auto sample = PlainMultiLayerBySLDBuilder().buildSample();
- auto sim1 = StdTestSimulations::TOFRWithRelativeResolution(*sample);
+ auto sim1 = test::makeSimulation::TOFRWithRelativeResolution(*sample);
EXPECT_TRUE(run("TOFResolutionComparison_TR", *sim1, 1e-10));
- auto sim2 = StdTestSimulations::TOFRWithPointwiseResolution(*sample);
+ auto sim2 = test::makeSimulation::TOFRWithPointwiseResolution(*sample);
EXPECT_TRUE(run("TOFResolutionComparison_TP", *sim2, 1e-10));
}
@@ -650,7 +649,7 @@ TEST_F(Std, BasicSpecular)
{
std::unique_ptr<const MultiLayer> sample(SimpleMagneticLayerBuilder().buildSample());
for (const std::string& polCase : {"PP", "MM"}) {
- auto sim = StdTestSimulations::BasicYPolarizedSpecular(*sample, polCase, false);
+ auto sim = test::makeSimulation::BasicYPolarizedSpecular(*sample, polCase, false);
EXPECT_TRUE(run("BasicSpecular" + polCase, *sim, 1e-10));
}
}
@@ -659,7 +658,7 @@ TEST_F(Std, PolarizedQAngleReflectivity)
{
std::unique_ptr<const MultiLayer> sample(SimpleMagneticLayerBuilder().buildSample());
for (const std::string& polKey : {"PP", "MM"}) {
- auto sim = StdTestSimulations::BasicYPolarizedSpecular(*sample, polKey, true);
+ auto sim = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, true);
EXPECT_TRUE(run("PolarizedQAngleReflectivity" + polKey + "_Q", *sim, 1e-10));
}
}
@@ -670,7 +669,7 @@ TEST_F(Std, MagneticRotationReflectivity)
std::unique_ptr<const MultiLayer> sample(
SimpleMagneticRotationBuilder().buildSampleWithRoughness(roughnessKey));
for (const std::string& polKey : {"PP", "PM", "MP", "MM"}) {
- auto sim = StdTestSimulations::BasicYPolarizedSpecular(*sample, polKey, false);
+ auto sim = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, false);
EXPECT_TRUE(
run("MagneticRotationReflectivity" + polKey + "_" + roughnessKey, *sim, 1e-10));
}
@@ -681,9 +680,9 @@ TEST_F(Std, PolarizedFeNiBilayer)
{
std::unique_ptr<const MultiLayer> sample(FeNiBilayerBuilder().buildSample());
for (const std::string& polKey : {"PP", "MM"}) {
- auto sim1 = StdTestSimulations::BasicYPolarizedSpecular(*sample, polKey, false);
+ auto sim1 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, false);
EXPECT_TRUE(run("PolarizedFeNiBilayer" + polKey, *sim1, 1e-7));
- auto sim2 = StdTestSimulations::BasicYPolarizedSpecular(*sample, polKey, true);
+ auto sim2 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, true);
EXPECT_TRUE(run("PolarizedFeNiBilayer" + polKey + "_Q", *sim2, 1e-7));
}
}
@@ -692,9 +691,9 @@ TEST_F(Std, PolarizedFeNiBilayerTanh)
{
std::unique_ptr<const MultiLayer> sample(FeNiBilayerTanhBuilder().buildSample());
for (const std::string& polKey : {"PP", "MM"}) {
- auto sim1 = StdTestSimulations::BasicYPolarizedSpecular(*sample, polKey, false);
+ auto sim1 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, false);
EXPECT_TRUE(run("PolarizedFeNiBilayerTanh" + polKey, *sim1, 1e-7));
- auto sim2 = StdTestSimulations::BasicYPolarizedSpecular(*sample, polKey, true);
+ auto sim2 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, true);
EXPECT_TRUE(run("PolarizedFeNiBilayerTanh" + polKey + "_Q", *sim2, 1e-7));
}
}
@@ -703,9 +702,9 @@ TEST_F(Std, PolarizedFeNiBilayerNC)
{
std::unique_ptr<const MultiLayer> sample(FeNiBilayerNCBuilder().buildSample());
for (const std::string& polKey : {"PP", "MM"}) {
- auto sim1 = StdTestSimulations::BasicYPolarizedSpecular(*sample, polKey, false);
+ auto sim1 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, false);
EXPECT_TRUE(run("PolarizedFeNiBilayerNC" + polKey, *sim1, 1e-7));
- auto sim2 = StdTestSimulations::BasicYPolarizedSpecular(*sample, polKey, true);
+ auto sim2 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, true);
EXPECT_TRUE(run("PolarizedFeNiBilayerNC" + polKey + "_Q", *sim2, 1e-7));
}
}
@@ -714,9 +713,9 @@ TEST_F(Std, PolarizedFeNiBilayerSpinFlip)
{
std::unique_ptr<const MultiLayer> sample(FeNiBilayerSpinFlipBuilder().buildSample());
for (const std::string& polKey : {"PP", "PM", "MP", "MM"}) {
- auto sim1 = StdTestSimulations::BasicYPolarizedSpecular(*sample, polKey, false);
+ auto sim1 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, false);
EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlip" + polKey, *sim1, 1e-7));
- auto sim2 = StdTestSimulations::BasicYPolarizedSpecular(*sample, polKey, true);
+ auto sim2 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, true);
EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlip" + polKey + "_Q", *sim2, 1e-7));
}
}
@@ -725,9 +724,9 @@ TEST_F(Std, PolarizedFeNiBilayerSpinFlipTanh)
{
std::unique_ptr<const MultiLayer> sample(FeNiBilayerSpinFlipTanhBuilder().buildSample());
for (const std::string& polKey : {"PP", "PM", "MP", "MM"}) {
- auto sim1 = StdTestSimulations::BasicYPolarizedSpecular(*sample, polKey, false);
+ auto sim1 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, false);
EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipTanh" + polKey, *sim1, 1e-7));
- auto sim2 = StdTestSimulations::BasicYPolarizedSpecular(*sample, polKey, true);
+ auto sim2 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, true);
EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipTanh" + polKey + "_Q", *sim2, 1e-7));
}
}
@@ -736,9 +735,9 @@ TEST_F(Std, PolarizedFeNiBilayerSpinFlipNC)
{
std::unique_ptr<const MultiLayer> sample(FeNiBilayerSpinFlipNCBuilder().buildSample());
for (const std::string& polKey : {"PP", "PM", "MP", "MM"}) {
- auto sim1 = StdTestSimulations::BasicYPolarizedSpecular(*sample, polKey, false);
+ auto sim1 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, false);
EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipNC" + polKey, *sim1, 1e-7));
- auto sim2 = StdTestSimulations::BasicYPolarizedSpecular(*sample, polKey, true);
+ auto sim2 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, true);
EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipNC" + polKey + "_Q", *sim2, 1e-7));
}
}
@@ -746,7 +745,7 @@ TEST_F(Std, PolarizedFeNiBilayerSpinFlipNC)
TEST_F(Std, DepthProbeTest)
{
auto sample = HomogeneousMultilayerBuilder().buildSample();
- auto sim = StdTestSimulations::BasicDepthProbe(*sample);
+ auto sim = test::makeSimulation::BasicDepthProbe(*sample);
EXPECT_TRUE(run("DepthProbeTest", *sim, 1e-10));
}
diff --git a/Tests/Performance/Core/Multilayer.cpp b/Tests/Performance/Core/Multilayer.cpp
index 43b4cd4028e..b5f38c94ce4 100644
--- a/Tests/Performance/Core/Multilayer.cpp
+++ b/Tests/Performance/Core/Multilayer.cpp
@@ -45,7 +45,7 @@ int main()
const auto start_time = now();
std::unique_ptr<MultiLayer> sample(PlainMultiLayerBySLDBuilder(layer_mult).buildSample());
std::unique_ptr<SpecularSimulation> simulation(
- StdTestSimulations::BasicSpecular(*sample, false));
+ test::makeSimulation::BasicSpecular(*sample, false));
simulation->runSimulation();
--
GitLab