IsGISAXS06 functional test is finally done.

Core/StandardSamples/SampleBuilderFactory.cpp

@@ -51,11 +51,16 @@ SampleBuilderFactory::SampleBuilderFactory()
     registerItem(
         "isgisaxs06_lattice2",
         IFactoryCreateFunction<IsGISAXS06Lattice2Builder, ISampleBuilder>,
-        "2D lattice with different disorder");
+        "2D lattice centered");
     registerItem(
         "isgisaxs06_lattice3",
         IFactoryCreateFunction<IsGISAXS06Lattice3Builder, ISampleBuilder>,
-        "2D lattice with different disorder");
+        "2D lattice rotated");
+    registerItem(
+        "isgisaxs06_lattice4",
+        IFactoryCreateFunction<IsGISAXS06Lattice4Builder, ISampleBuilder>,
+        "2D lattice variants");
+
 
     registerItem(
         "isgisaxs09",

Core/StandardSamples/SimulationRegistry.cpp

@@ -34,6 +34,19 @@ SimulationRegistry::SimulationRegistry()
         "isgisaxs04_2DDL", StandardSimulations::IsGISAXS042DDL,
         "IsGISAXS04 example, 2DDL structure factor");
 
+    registerItem(
+        "isgisaxs06_lattice1", StandardSimulations::IsGISAXS06L1,
+        "IsGISAXS06 example, 2D lattice with different disorders");
+    registerItem(
+        "isgisaxs06_lattice2", StandardSimulations::IsGISAXS06L2,
+        "IsGISAXS06 example, 2D lattice centered");
+    registerItem(
+        "isgisaxs06_lattice3", StandardSimulations::IsGISAXS06L3,
+        "IsGISAXS06 example, 2D lattice rotated");
+    registerItem(
+        "isgisaxs06_lattice4", StandardSimulations::IsGISAXS06L4,
+        "IsGISAXS06 example, 2D lattice variants");
+
     registerItem(
         "mesocrystal01", StandardSimulations::MesoCrystal01,
         "mesocrystals of cylindrical shape composed by spherical nanoparticles");

Core/StandardSamples/StandardSimulations.cpp

@@ -129,6 +129,93 @@ Simulation *StandardSimulations::IsGISAXS042DDL()
     return result;
 }
 
+Simulation *StandardSimulations::IsGISAXS06L1()
+{
+    SampleBuilderFactory factory;
+    ISampleBuilder *builder = factory.createBuilder("isgisaxs06_lattice1");
+
+    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);
+
+    SimulationParameters sim_params;
+    sim_params.me_framework = SimulationParameters::DWBA;
+    sim_params.me_if_approx = SimulationParameters::LMA;
+    sim_params.me_lattice_type = SimulationParameters::LATTICE;
+    result->setSimulationParameters(sim_params);
+
+    result->setSampleBuilder( builder );
+
+    return result;
+}
+
+Simulation *StandardSimulations::IsGISAXS06L2()
+{
+    SampleBuilderFactory factory;
+    ISampleBuilder *builder = factory.createBuilder("isgisaxs06_lattice2");
+
+    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);
+
+    SimulationParameters sim_params;
+    sim_params.me_framework = SimulationParameters::DWBA;
+    sim_params.me_if_approx = SimulationParameters::LMA;
+    sim_params.me_lattice_type = SimulationParameters::LATTICE;
+    result->setSimulationParameters(sim_params);
+
+    result->setSampleBuilder( builder );
+
+    return result;
+}
+
+Simulation *StandardSimulations::IsGISAXS06L3()
+{
+    SampleBuilderFactory factory;
+    ISampleBuilder *builder = factory.createBuilder("isgisaxs06_lattice3");
+
+    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);
+
+    SimulationParameters sim_params;
+    sim_params.me_framework = SimulationParameters::DWBA;
+    sim_params.me_if_approx = SimulationParameters::LMA;
+    sim_params.me_lattice_type = SimulationParameters::LATTICE;
+    result->setSimulationParameters(sim_params);
+
+    result->setSampleBuilder( builder );
+
+    return result;
+}
+
+Simulation *StandardSimulations::IsGISAXS06L4()
+{
+    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);
+
+    SimulationParameters sim_params;
+    sim_params.me_framework = SimulationParameters::DWBA;
+    sim_params.me_if_approx = SimulationParameters::LMA;
+    sim_params.me_lattice_type = SimulationParameters::LATTICE;
+    result->setSimulationParameters(sim_params);
+
+    return result;
+}
+
 Simulation *StandardSimulations::MesoCrystal01()
 {
     SampleBuilderFactory factory;

Core/StandardSamples/StandardSimulations.h

@@ -15,7 +15,10 @@ Simulation *IsGISAXS03DWBA();
 Simulation *IsGISAXS03BAsize();
 Simulation *IsGISAXS041DDL();
 Simulation *IsGISAXS042DDL();
-//Simulation *IsGISAXS06();
+Simulation *IsGISAXS06L1();
+Simulation *IsGISAXS06L2();
+Simulation *IsGISAXS06L3();
+Simulation *IsGISAXS06L4();
 //Simulation *IsGISAXS07();
 //Simulation *IsGISAXS08();
 //Simulation *IsGISAXS09();

Tests/FunctionalTests/TestCore/CMakeLists.txt

@@ -12,7 +12,10 @@ set(list_of_tests
     "IsGISAXS03BAsize"
     "IsGISAXS041DDL"
     "IsGISAXS042DDL"
-    "IsGISAXS06"
+    "IsGISAXS06L1"
+    "IsGISAXS06L2"
+    "IsGISAXS06L3"
+    "IsGISAXS06L4"
     "IsGISAXS07"
     "IsGISAXS08"
     "IsGISAXS09"

Tests/FunctionalTests/TestCore/IsGISAXS06L1/IsGISAXS06L1.cpp

+#include "IsGISAXS06L1.h"
+#include "MultiLayer.h"
+#include "ParticleDecoration.h"
+#include "FormFactorCylinder.h"
+#include "Simulation.h"
+#include "Units.h"
+#include "MaterialManager.h"
+#include "InterferenceFunction2DLattice.h"
+#include "PositionParticleInfo.h"
+#include "OutputDataIOFactory.h"
+#include "StochasticSampledParameter.h"
+#include "StochasticDoubleGate.h"
+#include "Utils.h"
+#include "SampleBuilderFactory.h"
+#include "IsGISAXS06Builder.h"
+#include "MathFunctions.h"
+#include "SimulationRegistry.h"
+
+#include <iostream>
+#include <cmath>
+
+FunctionalTests::IsGISAXS06L1::IsGISAXS06L1()
+    : m_name("IsGISAXS06L1")
+    , m_description("2D lattice with different disorder")
+    , m_result(0)
+	, m_reference(0)
+{ }
+
+
+void FunctionalTests::IsGISAXS06L1::run(const std::string &path_to_data)
+{
+
+    SimulationRegistry sim_registry;
+    Simulation *simulation = sim_registry.createSimulation("isgisaxs06_lattice1");
+
+    // loading reference data
+    std::string filename = path_to_data + "isgisaxs06_reference_lattice.ima.gz";
+    m_reference = OutputDataIOFactory::readIntensityData(filename);
+
+    simulation->runSimulation();
+
+    m_result = simulation->getIntensityData();
+    delete simulation;
+}
+
+
+int FunctionalTests::IsGISAXS06L1::analyseResults()
+{
+    const double threshold(2e-10);
+
+    // Calculating average relative difference.
+    *m_result -= *m_reference;
+    *m_result /= *m_reference;
+
+    double diff(0);
+    for(OutputData<double>::const_iterator it =
+            m_result->begin(); it!=m_result->end(); ++it) {
+        diff+= std::fabs(*it);
+    }
+    diff /= m_result->getAllocatedSize();
+
+    // Assess result.
+	bool status_ok(true);
+    if( diff > threshold || std::isnan(diff)) status_ok=false;
+
+    std::cout << " diff " << diff << std::endl;
+    std::cout << m_name << " " << m_description << " " <<
+            (status_ok ? "[OK]" : "[FAILED]") << std::endl;
+    return (status_ok ? 0 : 1);
+}
+
+
+#ifdef STANDALONE
+std::string GetPathToData(int argc, char **argv)
+{
+    if(argc == 2) return argv[1];
+    return Utils::FileSystem::GetPathToData("../../../ReferenceData/BornAgain/", argv[0]);
+}
+
+int main(int argc, char **argv)
+{
+    FunctionalTests::IsGISAXS06L1 test;
+    test.run(GetPathToData(argc, argv));
+    return test.analyseResults();
+}
+#endif
+

Tests/FunctionalTests/TestCore/IsGISAXS06L1/IsGISAXS06L1.h

+#ifndef FUNCTIONALTESTS_ISGISAXS06L1_H
+#define FUNCTIONALTESTS_ISGISAXS06L1_H
+
+#include <string>
+#include "OutputData.h"
+#include "ISampleBuilder.h"
+
+namespace FunctionalTests {
+
+class IsGISAXS06L1
+{
+ public:
+    IsGISAXS06L1();
+    ~IsGISAXS06L1() { delete m_result; delete m_reference; }
+    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;
+};
+
+}
+
+#endif

Tests/FunctionalTests/TestCore/IsGISAXS06L2/IsGISAXS06L2.cpp

+#include "IsGISAXS06L2.h"
+#include "MultiLayer.h"
+#include "ParticleDecoration.h"
+#include "FormFactorCylinder.h"
+#include "Simulation.h"
+#include "Units.h"
+#include "MaterialManager.h"
+#include "InterferenceFunction2DLattice.h"
+#include "PositionParticleInfo.h"
+#include "OutputDataIOFactory.h"
+#include "StochasticSampledParameter.h"
+#include "StochasticDoubleGate.h"
+#include "Utils.h"
+#include "SampleBuilderFactory.h"
+#include "IsGISAXS06Builder.h"
+#include "MathFunctions.h"
+#include "SimulationRegistry.h"
+
+#include <iostream>
+#include <cmath>
+
+FunctionalTests::IsGISAXS06L2::IsGISAXS06L2()
+    : m_name("IsGISAXS06L2")
+    , m_description("2D lattice centered")
+    , m_result(0)
+	, m_reference(0)
+{ }
+
+
+void FunctionalTests::IsGISAXS06L2::run(const std::string &path_to_data)
+{
+
+    SimulationRegistry sim_registry;
+    Simulation *simulation = sim_registry.createSimulation("isgisaxs06_lattice2");
+
+    // loading reference data
+    std::string filename = path_to_data + "isgisaxs06_reference_centered.ima.gz";
+    m_reference = OutputDataIOFactory::readIntensityData(filename);
+
+    simulation->runSimulation();
+
+    m_result = simulation->getIntensityData();
+    delete simulation;
+}
+
+
+int FunctionalTests::IsGISAXS06L2::analyseResults()
+{
+    const double threshold(2e-10);
+
+    // Calculating average relative difference.
+    *m_result -= *m_reference;
+    *m_result /= *m_reference;
+
+    double diff(0);
+    for(OutputData<double>::const_iterator it =
+            m_result->begin(); it!=m_result->end(); ++it) {
+        diff+= std::fabs(*it);
+    }
+    diff /= m_result->getAllocatedSize();
+
+    // Assess result.
+	bool status_ok(true);
+    if( diff > threshold || std::isnan(diff)) status_ok=false;
+
+    std::cout << " diff " << diff << std::endl;
+    std::cout << m_name << " " << m_description << " " <<
+            (status_ok ? "[OK]" : "[FAILED]") << std::endl;
+    return (status_ok ? 0 : 1);
+}
+
+
+#ifdef STANDALONE
+std::string GetPathToData(int argc, char **argv)
+{
+    if(argc == 2) return argv[1];
+    return Utils::FileSystem::GetPathToData("../../../ReferenceData/BornAgain/", argv[0]);
+}
+
+int main(int argc, char **argv)
+{
+    FunctionalTests::IsGISAXS06L2 test;
+    test.run(GetPathToData(argc, argv));
+    return test.analyseResults();
+}
+#endif
+

Tests/FunctionalTests/TestCore/IsGISAXS06L2/IsGISAXS06L2.h

+#ifndef FUNCTIONALTESTS_ISGISAXS06L2_H
+#define FUNCTIONALTESTS_ISGISAXS06L2_H
+
+#include <string>
+#include "OutputData.h"
+#include "ISampleBuilder.h"
+
+namespace FunctionalTests {
+
+class IsGISAXS06L2
+{
+ public:
+    IsGISAXS06L2();
+    ~IsGISAXS06L2() { delete m_result; delete m_reference; }
+    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;
+};
+
+}
+
+#endif

Tests/FunctionalTests/TestCore/IsGISAXS06L3/IsGISAXS06L3.cpp

+#include "IsGISAXS06L3.h"
+#include "MultiLayer.h"
+#include "ParticleDecoration.h"
+#include "FormFactorCylinder.h"
+#include "Simulation.h"
+#include "Units.h"
+#include "MaterialManager.h"
+#include "InterferenceFunction2DLattice.h"
+#include "PositionParticleInfo.h"
+#include "OutputDataIOFactory.h"
+#include "StochasticSampledParameter.h"
+#include "StochasticDoubleGate.h"
+#include "Utils.h"
+#include "SampleBuilderFactory.h"
+#include "IsGISAXS06Builder.h"
+#include "MathFunctions.h"
+#include "SimulationRegistry.h"
+
+#include <iostream>
+#include <cmath>
+
+FunctionalTests::IsGISAXS06L3::IsGISAXS06L3()
+    : m_name("IsGISAXS06L3")
+    , m_description("2D lattice rotated")
+    , m_result(0)
+	, m_reference(0)
+{ }
+
+
+void FunctionalTests::IsGISAXS06L3::run(const std::string &path_to_data)
+{
+
+    SimulationRegistry sim_registry;
+    Simulation *simulation = sim_registry.createSimulation("isgisaxs06_lattice3");
+
+    // loading reference data
+    std::string filename = path_to_data + "isgisaxs06_reference_rotated.ima.gz";
+    m_reference = OutputDataIOFactory::readIntensityData(filename);
+
+    simulation->runSimulation();
+
+    m_result = simulation->getIntensityData();
+    delete simulation;
+}
+
+
+int FunctionalTests::IsGISAXS06L3::analyseResults()
+{
+    const double threshold(2e-10);
+
+    // Calculating average relative difference.
+    *m_result -= *m_reference;
+    *m_result /= *m_reference;
+
+    double diff(0);
+    for(OutputData<double>::const_iterator it =
+            m_result->begin(); it!=m_result->end(); ++it) {
+        diff+= std::fabs(*it);
+    }
+    diff /= m_result->getAllocatedSize();
+
+    // Assess result.
+	bool status_ok(true);
+    if( diff > threshold || std::isnan(diff)) status_ok=false;
+
+    std::cout << " diff " << diff << std::endl;
+    std::cout << m_name << " " << m_description << " " <<
+            (status_ok ? "[OK]" : "[FAILED]") << std::endl;
+    return (status_ok ? 0 : 1);
+}
+
+
+#ifdef STANDALONE
+std::string GetPathToData(int argc, char **argv)
+{
+    if(argc == 2) return argv[1];
+    return Utils::FileSystem::GetPathToData("../../../ReferenceData/BornAgain/", argv[0]);
+}
+
+int main(int argc, char **argv)
+{
+    FunctionalTests::IsGISAXS06L3 test;
+    test.run(GetPathToData(argc, argv));
+    return test.analyseResults();
+}
+#endif
+

Tests/FunctionalTests/TestCore/IsGISAXS06L3/IsGISAXS06L3.h

+#ifndef FUNCTIONALTESTS_ISGISAXS06L3_H
+#define FUNCTIONALTESTS_ISGISAXS06L3_H
+
+#include <string>
+#include "OutputData.h"
+#include "ISampleBuilder.h"
+
+namespace FunctionalTests {
+
+class IsGISAXS06L3
+{
+ public:
+    IsGISAXS06L3();
+    ~IsGISAXS06L3() { delete m_result; delete m_reference; }
+    void run(const std::string &path_to_data = std::string());
+    int analyseResults();
+ private:
+    std::string m_name;
+    std::string m_description;
+    OutputData<double> *m_result;
+    OutputData<double> *m_reference;
+};
+
+}
+
+#endif

Tests/FunctionalTests/TestCore/IsGISAXS06L4/IsGISAXS06L4.cpp

+#include "IsGISAXS06L4.h"
+#include "MultiLayer.h"
+#include "ParticleDecoration.h"
+#include "FormFactorCylinder.h"
+#include "Simulation.h"
+#include "Units.h"
+#include "MaterialManager.h"
+#include "InterferenceFunction2DLattice.h"
+#include "PositionParticleInfo.h"
+#include "OutputDataIOFactory.h"
+#include "StochasticSampledParameter.h"
+#include "StochasticDoubleGate.h"
+#include "Utils.h"
+#include "SampleBuilderFactory.h"
+#include "IsGISAXS06Builder.h"
+#include "MathFunctions.h"
+#include "SimulationRegistry.h"
+
+#include <iostream>
+#include <cmath>
+
+FunctionalTests::IsGISAXS06L4::IsGISAXS06L4()
+    : m_name("IsGISAXS06L4")
+    , m_description("2D lattice variants")
+    , m_result(0)
+	, m_reference(0)
+{ }
+
+
+void FunctionalTests::IsGISAXS06L4::run(const std::string &path_to_data)
+{
+	IsGISAXS06Lattice4Builder builder;
+    SimulationRegistry sim_registry;
+    Simulation* simulation = sim_registry.createSimulation("isgisaxs06_lattice4");
+
+    // loading reference data
+    std::string filename = path_to_data + "isgisaxs06_reference_variants.ima.gz";
+    m_reference = OutputDataIOFactory::readIntensityData(filename);
+
+    // running simulation and copying data
+    OutputData<double> *p_total = simulation->getIntensityData();
+    p_total->setAllTo(0.0);
+    int nbins = 3;
+    double xi_min = 0.0*Units::degree;
+    double xi_max = 240.0*Units::degree;
+    StochasticDoubleGate xg(xi_min, xi_max);
+    StochasticSampledParameter xi(xg, nbins, xi_min, xi_max);
+    for (size_t i=0; i<xi.getNbins(); ++i) {
+        double xi_value = xi.getBinValue(i);
+        double probability = xi.getNormalizedProbability(i);
+        builder.setMatchedParametersValue("*xi",xi_value);
+        MultiLayer *p_sample = dynamic_cast<MultiLayer *>(builder.buildSample());
+        simulation->setSample(*p_sample);
+        simulation->runSimulation();
+        delete p_sample;
+        OutputData<double> *p_single_output = simulation->getIntensityData();
+        p_single_output->scaleAll(probability);
+        *p_total += *p_single_output;
+        delete p_single_output;
+	}
+
+    m_result = p_total;
+    delete simulation;
+}
+
+
+int FunctionalTests::IsGISAXS06L4::analyseResults()
+{
+    const double threshold(2e-10);
+
+    // Calculating average relative difference.
+    *m_result -= *m_reference;
+    *m_result /= *m_reference;
+
+    double diff(0);
+    for(OutputData<double>::const_iterator it =
+            m_result->begin(); it!=m_result->end(); ++it) {
+        diff+= std::fabs(*it);
+    }
+    diff /= m_result->getAllocatedSize();
+
+    // Assess result.
+	bool status_ok(true);
+    if( diff > threshold || std::isnan(diff)) status_ok=false;
+
+    std::cout << " diff " << diff << std::endl;
+    std::cout << m_name << " " << m_description << " " <<
+            (status_ok ? "[OK]" : "[FAILED]") << std::endl;
+    return (status_ok ? 0 : 1);
+}
+
+
+#ifdef STANDALONE
+std::string GetPathToData(int argc, char **argv)
+{
+    if(argc == 2) return argv[1];
+    return Utils::FileSystem::GetPathToData("../../../ReferenceData/BornAgain/", argv[0]);
+}
+
+int main(int argc, char **argv)
+{
+    FunctionalTests::IsGISAXS06L4 test;
+    test.run(GetPathToData(argc, argv));
+    return test.analyseResults();
+}
+#endif
+

Tests/FunctionalTests/TestCore/IsGISAXS06L4/IsGISAXS06L4.h

+#ifndef FUNCTIONALTESTS_ISGISAXS06L4_H
+#define FUNCTIONALTESTS_ISGISAXS06L4_H
+
+#include <string>
+#include "OutputData.h"
+#include "ISampleBuilder.h"
+
+namespace FunctionalTests {
+
+class IsGISAXS06L4
+{
+ public:
+    IsGISAXS06L4();
+    ~IsGISAXS06L4() { delete m_result; delete m_reference; }
+    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;
+};
+
+}
+
+#endif