IsGISAXS15 functional test is done, seems to be the last one..

Core/StandardSamples/IsGISAXS15Builder.cpp

+#include "IsGISAXS15Builder.h"
+#include "MultiLayer.h"
+#include "ParticleDecoration.h"
+#include "MaterialManager.h"
+#include "Units.h"
+#include "InterferenceFunction1DParaCrystal.h"
+#include "FormFactorCylinder.h"
+#include "StochasticGaussian.h"
+#include "StochasticSampledParameter.h"
+#include "ParticleBuilder.h"
+
+
+IsGISAXS15Builder::IsGISAXS15Builder()
+{
+}
+
+ISample *IsGISAXS15Builder::buildSample() const
+{
+    MultiLayer *multi_layer = new MultiLayer();
+
+    complex_t n_particle(1.0-6e-4, 2e-8);
+    const IMaterial *p_air_material =
+            MaterialManager::getHomogeneousMaterial("Air", 0.0, 0.0);
+    const IMaterial *particle_material =
+            MaterialManager::getHomogeneousMaterial("Particle", n_particle);
+
+    Layer air_layer;
+    air_layer.setMaterial(p_air_material);
+    InterferenceFunction1DParaCrystal *p_interference_function =
+            new InterferenceFunction1DParaCrystal(15.0*Units::nanometer,
+                    5*Units::nanometer, 1e3*Units::nanometer);
+    p_interference_function->setKappa(4.02698);
+    ParticleDecoration particle_decoration;
+    Particle particle_prototype(particle_material, new FormFactorCylinder(
+            5.0*Units::nanometer, 5.0*Units::nanometer));
+    StochasticDoubleGaussian sg(5.0*Units::nanometer, 1.25*Units::nanometer);
+    StochasticSampledParameter stochastic_radius(sg,30, 2);
+    ParticleBuilder particle_builder;
+    particle_builder.setPrototype(particle_prototype,
+            "/Particle/FormFactorCylinder/radius", stochastic_radius);
+    particle_builder.plantParticles(particle_decoration);
+
+    // Set height of each particle to its radius (H/R fixed)
+    ParameterPool *p_parameters = particle_decoration.createParameterTree();
+    p_parameters->fixRatioBetweenParameters("height", "radius", 1.0);
+
+    particle_decoration.addInterferenceFunction(p_interference_function);
+
+    air_layer.setDecoration(particle_decoration);
+
+    multi_layer->addLayer(air_layer);
+    return multi_layer;
+}
+

Core/StandardSamples/IsGISAXS15Builder.h

+#ifndef ISGISAXS15BUILDER_H
+#define ISGISAXS15BUILDER_H
+
+#include "ISampleBuilder.h"
+
+//! The IsGISAXS15Builder class to build sample: size spacing correlation approximation
+//! (IsGISAXS example #15)
+class IsGISAXS15Builder : public ISampleBuilder
+{
+public:
+    IsGISAXS15Builder();
+    ISample *buildSample() const;
+};
+
+#endif // ISGISAXS15BUILDER_H

Core/StandardSamples/SampleBuilderFactory.cpp

@@ -9,6 +9,7 @@
 #include "IsGISAXS09Builder.h"
 #include "IsGISAXS10Builder.h"
 #include "IsGISAXS11Builder.h"
+#include "IsGISAXS15Builder.h"
 #include "MesoCrystal01Builder.h"
 #include "PolarizedDWBAZeroMagBuilder.h"
 
@@ -99,6 +100,11 @@ SampleBuilderFactory::SampleBuilderFactory()
         IFactoryCreateFunction<IsGISAXS11Builder, ISampleBuilder>,
         "Core shell nanoparticles");
 
+    registerItem(
+        "isgisaxs15",
+        IFactoryCreateFunction<IsGISAXS15Builder, ISampleBuilder>,
+        "Size spacing correlation approximation");
+
     registerItem(
         "mesocrystal01",
         IFactoryCreateFunction<MesoCrystal01Builder, ISampleBuilder>,

Core/StandardSamples/SimulationRegistry.cpp

@@ -76,6 +76,11 @@ SimulationRegistry::SimulationRegistry()
         "isgisaxs11", StandardSimulations::IsGISAXS11,
         "IsGISAXS11 example, Core shell nanoparticles");
 
+    registerItem(
+        "isgisaxs15", StandardSimulations::IsGISAXS15,
+        "IsGISAXS15 example, Size spacing correlation approximation");
+
+
     registerItem(
         "mesocrystal01", StandardSimulations::MesoCrystal01,
         "mesocrystals of cylindrical shape composed by spherical nanoparticles");

Core/StandardSamples/StandardSimulations.cpp

@@ -340,6 +340,26 @@ Simulation *StandardSimulations::IsGISAXS11()
     return result;
 }
 
+Simulation *StandardSimulations::IsGISAXS15()
+{
+    SampleBuilderFactory factory;
+    ISampleBuilder *builder = factory.createBuilder("isgisaxs15");
+
+    Simulation *result = new Simulation();
+
+    result->setDetectorParameters(150, 0.05*Units::degree, 1.5*Units::degree,
+            150, 0.05*Units::degree, 1.5*Units::degree, true);
+    result->setBeamParameters(1.0*Units::angstrom, 0.2*Units::degree,
+            0.0*Units::degree);
+    SimulationParameters sim_params;
+    sim_params.me_if_approx = SimulationParameters::SSCA;
+    result->setSimulationParameters(sim_params);
+
+    result->setSampleBuilder( builder );
+
+    return result;
+}
+
 Simulation *StandardSimulations::MesoCrystal01()
 {
     SampleBuilderFactory factory;

Core/StandardSamples/StandardSimulations.h

@@ -26,7 +26,7 @@ Simulation *IsGISAXS09();
 Simulation *IsGISAXS09R();
 Simulation *IsGISAXS10();
 Simulation *IsGISAXS11();
-//Simulation *IsGISAXS15();
+Simulation *IsGISAXS15();
 Simulation *MesoCrystal01();
 Simulation *PolarizedDWBAZeroMag();
 

Tests/FunctionalTests/TestCore/IsGISAXS15/IsGISAXS15.cpp

@@ -12,7 +12,7 @@
 #include "OutputDataIOFactory.h"
 #include "Utils.h"
 #include "MathFunctions.h"
-
+#include "SimulationRegistry.h"
 #include <iostream>
 #include <cmath>
 
@@ -21,74 +21,33 @@ FunctionalTests::IsGISAXS15::IsGISAXS15()
     : m_name("IsGISAXS15")
     , m_description("Size spacing correlation approximation")
     , m_result(0)
+    , m_reference(0)
 { }
 
 
-void FunctionalTests::IsGISAXS15::run()
+void FunctionalTests::IsGISAXS15::run(const std::string &path_to_data)
 {
-    // building sample
-    MultiLayer multi_layer;
-    complex_t n_particle(1.0-6e-4, 2e-8);
-    const IMaterial *p_air_material =
-            MaterialManager::getHomogeneousMaterial("Air", 0.0, 0.0);
-    const IMaterial *particle_material =
-            MaterialManager::getHomogeneousMaterial("Particle", n_particle);
-
-    Layer air_layer;
-    air_layer.setMaterial(p_air_material);
-    InterferenceFunction1DParaCrystal *p_interference_function =
-            new InterferenceFunction1DParaCrystal(15.0*Units::nanometer,
-                    5*Units::nanometer, 1e3*Units::nanometer);
-    p_interference_function->setKappa(4.02698);
-    ParticleDecoration particle_decoration;
-    Particle particle_prototype(particle_material, new FormFactorCylinder(
-            5.0*Units::nanometer, 5.0*Units::nanometer));
-    StochasticDoubleGaussian sg(5.0*Units::nanometer, 1.25*Units::nanometer);
-    StochasticSampledParameter stochastic_radius(sg,30, 2);
-    ParticleBuilder particle_builder;
-    particle_builder.setPrototype(particle_prototype,
-            "/Particle/FormFactorCylinder/radius", stochastic_radius);
-    particle_builder.plantParticles(particle_decoration);
-
-    // Set height of each particle to its radius (H/R fixed)
-    ParameterPool *p_parameters = particle_decoration.createParameterTree();
-    p_parameters->fixRatioBetweenParameters("height", "radius", 1.0);
-
-    particle_decoration.addInterferenceFunction(p_interference_function);
-
-    air_layer.setDecoration(particle_decoration);
-
-    multi_layer.addLayer(air_layer);
-
-   // building simulation
-    Simulation simulation;
-    simulation.setDetectorParameters(150, 0.05*Units::degree, 1.5*Units::degree,
-            150, 0.05*Units::degree, 1.5*Units::degree, true);
-    simulation.setBeamParameters(1.0*Units::angstrom, 0.2*Units::degree,
-            0.0*Units::degree);
-    SimulationParameters sim_params;
-    sim_params.me_if_approx = SimulationParameters::SSCA;
-    simulation.setSimulationParameters(sim_params);
-    simulation.setSample(multi_layer);
-
-    // running simulation and copying the data
-    simulation.runSimulation();
-    m_result = simulation.getIntensityData();
+    SimulationRegistry sim_registry;
+    Simulation *simulation = sim_registry.createSimulation("isgisaxs15");
+
+    // loading reference data
+    std::string filename = path_to_data + "isgisaxs15_reference.ima.gz";
+    m_reference = OutputDataIOFactory::readIntensityData(filename);
+
+    simulation->runSimulation();
+
+    m_result = simulation->getIntensityData();
+    delete simulation;
 }
 
 
-int FunctionalTests::IsGISAXS15::analyseResults(const std::string &path_to_data)
+int FunctionalTests::IsGISAXS15::analyseResults()
 {
     const double threshold(2e-10);
 
-    // retrieving reference data
-    std::string filename = path_to_data + "isgisaxs15_reference.ima.gz";
-    OutputData<double > *reference = OutputDataIOFactory::readIntensityData(filename);
-
     // calculating average relative difference
-    *m_result -= *reference;
-    *m_result /= *reference;
-    delete reference;
+    *m_result -= *m_reference;
+    *m_result /= *m_reference;
 
     double diff(0);
     for(OutputData<double>::const_iterator it=m_result->begin();
@@ -116,8 +75,8 @@ std::string GetPathToData(int argc, char **argv)
 int main(int argc, char **argv)
 {
     FunctionalTests::IsGISAXS15 test;
-    test.run();
-    return test.analyseResults(GetPathToData(argc, argv));
+    test.run(GetPathToData(argc, argv));
+    return test.analyseResults();
 }
 #endif
 

Tests/FunctionalTests/TestCore/IsGISAXS15/IsGISAXS15.h

 #ifndef FUNCTIONALTESTS_ISGISAXS15_H
 #define FUNCTIONALTESTS_ISGISAXS15_H
 
-
+#include "ISampleBuilder.h"
 #include <string>
 #include "OutputData.h"
 
@@ -12,10 +12,10 @@ class IsGISAXS15
 {
 public :
     IsGISAXS15();
-    ~IsGISAXS15() { delete m_result; }
+    ~IsGISAXS15() { delete m_result; delete m_reference; }
 
-    void run();
-    int analyseResults(const std::string &path_to_data = std::string());
+    void run(const std::string &path_to_data = std::string());
+    int analyseResults();
 
     const OutputData<double> *getOutputData() { return m_result; }
 
@@ -23,6 +23,7 @@ public :
     std::string m_name;
     std::string m_description;
     OutputData<double> *m_result;
+    OutputData<double> *m_reference;
 };
 
 }