IsGISAXS10 functional test is done.

Core/StandardSamples/IsGISAXS10Builder.cpp

+#include "IsGISAXS10Builder.h"
+#include "MultiLayer.h"
+#include "ParticleDecoration.h"
+#include "MaterialManager.h"
+#include "FormFactorCylinder.h"
+#include "InterferenceFunction1DParaCrystal.h"
+#include "Units.h"
+
+IsGISAXS10Builder::IsGISAXS10Builder()
+    : m_cylinder_height(5*Units::nanometer)
+    , m_cylinder_radius(5*Units::nanometer)
+{
+    init_parameters();
+}
+
+
+void IsGISAXS10Builder::init_parameters()
+{
+    clearParameterPool();
+    registerParameter("cylinder_height", &m_cylinder_height);
+    registerParameter("cylinder_raduis", &m_cylinder_radius);
+}
+
+
+ISample *IsGISAXS10Builder::buildSample() const
+{
+    MultiLayer *multi_layer = new MultiLayer();
+
+	const IMaterial *p_air_material =
+            MaterialManager::getHomogeneousMaterial("Air10", 0.0, 0.0);
+    const IMaterial *p_substrate_material =
+            MaterialManager::getHomogeneousMaterial("Substrate10", 5e-6, 2e-8);
+    Layer air_layer;
+    air_layer.setMaterial(p_air_material);
+    Layer substrate_layer;
+    substrate_layer.setMaterial(p_substrate_material);
+
+    IInterferenceFunction *p_interference_function =
+            new InterferenceFunction1DParaCrystal(20.0*Units::nanometer,
+                    7*Units::nanometer, 1e7*Units::nanometer);
+    const IMaterial *particle_material = MaterialManager::getHomogeneousMaterial("Particle", 5e-5, 2e-8);
+
+    ParticleDecoration particle_decoration(new Particle(particle_material,
+            new FormFactorCylinder(m_cylinder_height, m_cylinder_radius)));
+    particle_decoration.addInterferenceFunction(p_interference_function);
+
+    air_layer.setDecoration(particle_decoration);
+
+    multi_layer->addLayer(air_layer);
+    multi_layer->addLayer(substrate_layer);
+    return multi_layer;
+}
+

Core/StandardSamples/IsGISAXS10Builder.h

+#ifndef ISGISAXS10BUILDER_H
+#define ISGISAXS10BUILDER_H
+
+#include "ISampleBuilder.h"
+
+//! The IsGISAXS10Builder class to build sample: cylinders on top of substrate
+//! with interference (IsGISAXS example #10)
+class IsGISAXS10Builder : public ISampleBuilder
+{
+public:
+    IsGISAXS10Builder();
+    ISample *buildSample() const;
+
+protected:
+    void init_parameters();
+
+private:
+    double m_cylinder_height;
+    double m_cylinder_radius;
+};
+
+#endif // ISGISAXS10BUILDER_H

Core/StandardSamples/SampleBuilderFactory.cpp

@@ -7,6 +7,7 @@
 #include "IsGISAXS07Builder.h"
 #include "IsGISAXS08Builder.h"
 #include "IsGISAXS09Builder.h"
+#include "IsGISAXS10Builder.h"
 #include "MesoCrystal01Builder.h"
 #include "PolarizedDWBAZeroMagBuilder.h"
 
@@ -87,6 +88,11 @@ SampleBuilderFactory::SampleBuilderFactory()
         IFactoryCreateFunction<IsGISAXS09RotatedBuilder, ISampleBuilder>,
         "Rotated pyramids on top of substrate");
 
+    registerItem(
+        "isgisaxs10",
+        IFactoryCreateFunction<IsGISAXS10Builder, ISampleBuilder>,
+        "Cylinders on top of substrate with interference");
+
     registerItem(
         "mesocrystal01",
         IFactoryCreateFunction<MesoCrystal01Builder, ISampleBuilder>,

Core/StandardSamples/SimulationRegistry.cpp

@@ -68,6 +68,10 @@ SimulationRegistry::SimulationRegistry()
         "isgisaxs09_rotated", StandardSimulations::IsGISAXS09R,
         "IsGISAXS09 example, Rotated pyramids on top of substrate");
 
+    registerItem(
+        "isgisaxs10", StandardSimulations::IsGISAXS10,
+        "IsGISAXS10 example, Cylinders on top of substrate with interference");
+
     registerItem(
         "mesocrystal01", StandardSimulations::MesoCrystal01,
         "mesocrystals of cylindrical shape composed by spherical nanoparticles");

Core/StandardSamples/StandardSimulations.cpp

@@ -306,6 +306,23 @@ Simulation *StandardSimulations::IsGISAXS09R()
     return result;
 }
 
+Simulation *StandardSimulations::IsGISAXS10()
+{
+    SampleBuilderFactory factory;
+    ISampleBuilder *builder = factory.createBuilder("isgisaxs10");
+
+    Simulation *result = new Simulation();
+
+    result->setDetectorParameters(100, 0.0*Units::degree, 2.0*Units::degree,
+            100, 0.0*Units::degree, 2.0*Units::degree, true);
+    result->setBeamParameters(1.0*Units::angstrom, 0.2*Units::degree,
+            0.0*Units::degree);
+
+    result->setSampleBuilder( builder );
+
+    return result;
+}
+
 Simulation *StandardSimulations::MesoCrystal01()
 {
     SampleBuilderFactory factory;

Core/StandardSamples/StandardSimulations.h

@@ -24,7 +24,7 @@ Simulation *IsGISAXS082DDL();
 Simulation *IsGISAXS082DDL2();
 Simulation *IsGISAXS09();
 Simulation *IsGISAXS09R();
-//Simulation *IsGISAXS10();
+Simulation *IsGISAXS10();
 //Simulation *IsGISAXS11();
 //Simulation *IsGISAXS15();
 Simulation *MesoCrystal01();

Tests/FunctionalTests/TestCore/IsGISAXS10/IsGISAXS10.cpp

@@ -9,6 +9,7 @@
 #include "Units.h"
 #include "Utils.h"
 #include "MathFunctions.h"
+#include "SimulationRegistry.h"
 
 #include <iostream>
 #include <cmath>
@@ -18,62 +19,33 @@ FunctionalTests::IsGISAXS10::IsGISAXS10()
     : m_name("IsGISAXS10")
     , m_description("Cylinders with interference on top of substrate")
     , m_result(0)
+    , m_reference(0)
 { }
 
 
-void FunctionalTests::IsGISAXS10::run()
+void FunctionalTests::IsGISAXS10::run(const std::string &path_to_data)
 {
-    // building sample
-    MultiLayer multi_layer;
-    const IMaterial *p_air_material =
-            MaterialManager::getHomogeneousMaterial("Air10", 0.0, 0.0);
-    const IMaterial *p_substrate_material =
-            MaterialManager::getHomogeneousMaterial("Substrate10", 5e-6, 2e-8);
-    Layer air_layer;
-    air_layer.setMaterial(p_air_material);
-    Layer substrate_layer;
-    substrate_layer.setMaterial(p_substrate_material);
-
-    IInterferenceFunction *p_interference_function =
-            new InterferenceFunction1DParaCrystal(20.0*Units::nanometer,
-                    7*Units::nanometer, 1e7*Units::nanometer);
-    const IMaterial *particle_material = MaterialManager::getHomogeneousMaterial("Particle", 5e-5, 2e-8);
-
-    ParticleDecoration particle_decoration(new Particle(particle_material,
-            new FormFactorCylinder(5*Units::nanometer, 5*Units::nanometer)));
-    particle_decoration.addInterferenceFunction(p_interference_function);
-
-    air_layer.setDecoration(particle_decoration);
-
-    multi_layer.addLayer(air_layer);
-    multi_layer.addLayer(substrate_layer);
-
-    // building simulation
-    Simulation simulation;
-    simulation.setDetectorParameters(100, 0.0*Units::degree, 2.0*Units::degree,
-            100, 0.0*Units::degree, 2.0*Units::degree, true);
-    simulation.setBeamParameters(1.0*Units::angstrom, 0.2*Units::degree,
-            0.0*Units::degree);
-    simulation.setSample(multi_layer);
-
-    // running simulation and copying data
-    simulation.runSimulation();
-    m_result = simulation.getIntensityData();
+    SimulationRegistry sim_registry;
+    Simulation *simulation = sim_registry.createSimulation("isgisaxs10");
+
+    // loading reference data
+    std::string filename = path_to_data + "isgisaxs10_reference.ima.gz";
+    m_reference = OutputDataIOFactory::readIntensityData(filename);
+
+    simulation->runSimulation();
+
+    m_result = simulation->getIntensityData();
+    delete simulation;
 }
 
 
-int FunctionalTests::IsGISAXS10::analyseResults(const std::string &path_to_data)
+int FunctionalTests::IsGISAXS10::analyseResults()
 {
     const double threshold(2e-10);
 
-    // retrieving reference data
-    std::string filename = path_to_data + "isgisaxs10_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();
@@ -101,8 +73,8 @@ std::string GetPathToData(int argc, char **argv)
 int main(int argc, char **argv)
 {
     FunctionalTests::IsGISAXS10 test;
-    test.run();
-    return test.analyseResults(GetPathToData(argc, argv));
+    test.run(GetPathToData(argc, argv));
+    return test.analyseResults();
 }
 #endif
 

Tests/FunctionalTests/TestCore/IsGISAXS10/IsGISAXS10.h

 #ifndef FUNCTIONALTESTS_ISGISAXS10_H
 #define FUNCTIONALTESTS_ISGISAXS10_H
 
-
+#include "ISampleBuilder.h"
 #include <string>
 #include "OutputData.h"
 
@@ -12,16 +12,17 @@ class IsGISAXS10
 {
 public :
     IsGISAXS10();
-    ~IsGISAXS10() { delete m_result; }
+    ~IsGISAXS10() { 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; }
  private:
     std::string m_name;
     std::string m_description;
     OutputData<double> *m_result;
+    OutputData<double> *m_reference;
 };
 
 }