Merge branch 'ali' into unittests

Conflicts:
	App/App.pro
	App/inc/TestFormFactors.h
	App/src/StandardSamples.cpp
	App/src/TestFormFactors.cpp
	Core/Core.pro
	Core/FormFactors/inc/FormFactorCylinder.h
	Core/FormFactors/inc/FormFactorEllipsoid.h
	Core/FormFactors/inc/FormFactorFullSphere.h
	Core/FormFactors/inc/FormFactorPrism3.h
	Core/FormFactors/inc/FormFactorSphere.h
	Core/FormFactors/src/FormFactorBox.cpp
	Core/FormFactors/src/FormFactorCylinder.cpp
	Core/FormFactors/src/FormFactorEllipsoid.cpp
	Core/FormFactors/src/FormFactorFullSphere.cpp
	Core/FormFactors/src/FormFactorSphere.cpp
	shared.pri

App/App.pro

@@ -36,6 +36,7 @@ SOURCES += \
     src/TestFittingModule2.cpp \
     src/TestFittingModule3.cpp \
     src/TestFormFactor.cpp \
+    src/TestFormFactors.cpp \
     src/TestFourier.cpp \
     src/TestFresnelCoeff.cpp \
     src/TestFumiliLMA.cpp \
@@ -92,6 +93,7 @@ HEADERS += \
     inc/TestFittingModule2.h \
     inc/TestFittingModule3.h \
     inc/TestFormFactor.h \
+    inc/TestFormFactors.h \
     inc/TestFourier.h \
     inc/TestFresnelCoeff.h \
     inc/TestFumiliLMA.h \

App/inc/StandardSamples.h

@@ -32,9 +32,17 @@ ISample *IsGISAXS14_LayeredSpheresOnGradedInterface();
 ISample *IsGISAXS15_SSCA();
 ISample *MesoCrystal1();
 ISample *MesoCrystal2();
+ISample *FormFactor_Box();
+ISample *FormFactor_Cone();
+ISample *FormFactor_Sphere();
+ISample *FormFactor_Ellipsoid();
+ISample *FormFactor_FullSpheroid();
+ISample *FormFactor_HemiSpheroid();
+ISample *FormFactor_Parallelpiped();
+ISample *FormFactor_Cylinder();
+ISample *FormFactor_Pyramid();
+ISample *FormFactor_FullSphere();
+ISample *FormFactor_Prism3();
 
 }
-
-
-
 #endif // STANDARDSAMPLES_H

App/inc/TestFormFactors.h

@@ -9,44 +9,30 @@
 // * eget quam orci. Quisque  porta  varius  dui,  quis  posuere nibh *
 // * mollis quis. Mauris commodo rhoncus porttitor.                   *
 // ********************************************************************
-//! @file   TESTFORMFACTORS.h
-//! @brief  Definition of FormFactor class
+//! @file   TestFormFactors.h
+//! @brief  Definition of TestFormFactors class for FormFactors validation
 //! @author Scientific Computing Group at FRM II
-//! @date   Oct 1, 2012
+//! @date   Jun 28, 2012
 
 #include "IFunctionalTest.h"
+#include "OutputData.h"
+#include "ISample.h"
+
 
 //- -------------------------------------------------------------------
 //! @class TestFormFactors
-//! @brief Comparison with IsGISAXS ex-12:
+//! @brief Comparison with FormFactors ex-1: mean forfactor cylinder and prism
 //- -------------------------------------------------------------------
 class TestFormFactors : public IFunctionalTest
 {
 public:
- TestFormFactors(){}
- virtual ~TestFormFactors(){}
+    TestFormFactors(){}
+    virtual ~TestFormFactors(){}
 
     virtual void execute();
     virtual void finalise();
-
- //std::string m_results;
- //void clear();
-// private:
- //std::vector<OutputData<double> *> m_results;
-/*
 private:
-    // structure to holed info over several compare cases
-    struct CompareStruct
-    {
-        //CompareStruct(std::string _isginame, std::string _thisname, std::string _descr) : isginame(_isginame), thisname(_thisname), descr(_descr){}
-        //  std::string isginame;
-        //std::string thisname;
-        //std::string descr;
-
-    };
-
     std::string m_data_path;
-  */
 };
 
 #endif // TESTFORMFACTORS_H

App/src/FunctionalTestFactory.cpp

@@ -22,6 +22,9 @@
 #include "TestDetectorResolution.h"
 #include "TestMesoCrystal1.h"
 #include "TestMesoCrystal2.h"
+
+#include "TestFormFactors.h"
+
 #include "TestRootTree.h"
 #include "TestFittingModule1.h"
 #include "TestFittingModule2.h"
@@ -109,6 +112,9 @@ FunctionalTestFactory::FunctionalTestFactory() : m_benchmark(0)
     registerItem("toyexp",    IFactoryCreateFunction<TestToyExperiment, IFunctionalTest>,
                  "functional test: test fitting algorithms with toy experiment");
 
+    registerItem("FormFactors", IFactoryCreateFunction<TestFormFactors, IFunctionalTest>,
+                 "functional test: FormFactors");
+
     m_benchmark = new TBenchmark();
 }
 

App/src/ROOTMinimizerHelper.cpp

@@ -113,7 +113,7 @@ bool ROOTMinimizerHelper::processCommandGSLSimAn(ROOT::Patch::GSLSimAnMinimizer
 
 
 // ----------------------------------------------------------------------------
-// Printing minimizer options on the screen
+// Printing minimizer results on the screen
 // ----------------------------------------------------------------------------
 void ROOTMinimizerHelper::printResults(ROOT::Math::Minimizer *minimizer, const std::string &minimizer_name, const std::string &algo_type)
 {

App/src/SampleFactory.cpp

@@ -66,5 +66,16 @@ SampleFactory::SampleFactory()
     // mesocrystal's
     registerItem("MesoCrystal1", StandardSamples::MesoCrystal1);
     registerItem("MesoCrystal2", StandardSamples::MesoCrystal2);
-}
 
+    registerItem("FormFactor_Box", StandardSamples::FormFactor_Box);
+    registerItem("FormFactor_Cone", StandardSamples::FormFactor_Cone);
+    registerItem("FormFactor_Sphere", StandardSamples::FormFactor_Sphere);
+    registerItem("FormFactor_Ellipsoid", StandardSamples::FormFactor_Ellipsoid);
+    registerItem("FormFactor_FullSpheroid", StandardSamples::FormFactor_FullSpheroid);
+    registerItem("FormFactor_HemiSpheroid", StandardSamples::FormFactor_HemiSpheroid);
+    registerItem("FormFactor_Parallelpiped", StandardSamples::FormFactor_Parallelpiped);
+    registerItem("FormFactor_Cylinder", StandardSamples::FormFactor_Cylinder);
+    registerItem("FormFactor_Pyramid", StandardSamples::FormFactor_Pyramid);
+    registerItem("FormFactor_FullSphere", StandardSamples::FormFactor_FullSphere);
+    registerItem("FormFactor_Prism3", StandardSamples::FormFactor_Prism3);
+}

App/src/StandardSamples.cpp

@@ -21,6 +21,17 @@
 #include "ParticleBuilder.h"
 #include "StochasticSampledParameter.h"
 #include "ParticleCoreShell.h"
+#include "FormFactorBox.h"
+#include "FormFactorCone.h"
+#include "FormFactorSphere.h"
+#include "FormFactorEllipsoid.h"
+#include "FormFactorFullSpheroid.h"
+#include "FormFactorHemiSpheroid.h"
+#include "FormFactorFullSphere.h"
+#include "FormFactorPrism3.h"
+
+#include "Particle.h"
+
 #include "IsGISAXSMorphologyFileDecoration.h"
 
 
@@ -977,3 +988,274 @@ ISample *StandardSamples::MesoCrystal2()
     return p_multi_layer;
 
 }
+
+/* ************************************************************************* */
+// functional test: Box
+/* ************************************************************************* */
+ISample *StandardSamples::FormFactor_Box()
+{
+    MultiLayer *p_multi_layer = new MultiLayer();
+    complex_t n_air(1.0, 0.0);
+    complex_t n_substrate(1.0-6e-6, 2e-8);
+    complex_t n_particle(1.0-6e-4, 2e-8);
+    const IMaterial *p_air_material = MaterialManager::instance().addHomogeneousMaterial("Air", n_air);
+    const IMaterial *p_substrate_material = MaterialManager::instance().addHomogeneousMaterial("Substrate", n_substrate);
+    Layer air_layer;
+    air_layer.setMaterial(p_air_material);
+    Layer substrate_layer;
+    substrate_layer.setMaterial(p_substrate_material);
+    ParticleDecoration particle_decoration(new Particle(n_particle, new FormFactorBox(5*Units::nanometer, 5*Units::nanometer, 5*Units::nanometer)));
+    particle_decoration.addInterferenceFunction(new InterferenceFunctionNone());
+    LayerDecorator air_layer_decorator(air_layer, particle_decoration);
+
+    p_multi_layer->addLayer(air_layer_decorator);
+    p_multi_layer->addLayer(substrate_layer);
+    return p_multi_layer;
+}
+
+/* ************************************************************************* */
+//  functional test: Form Factor Cone
+/* ************************************************************************* */
+ISample *StandardSamples::FormFactor_Cone()
+{
+    MultiLayer *p_multi_layer = new MultiLayer();
+    complex_t n_air(1.0, 0.0);
+    complex_t n_substrate(1.0-6e-6, 2e-8);
+    complex_t n_particle(1.0-6e-4, 2e-8);
+    const IMaterial *p_air_material = MaterialManager::instance().addHomogeneousMaterial("Air", n_air);
+    const IMaterial *p_substrate_material = MaterialManager::instance().addHomogeneousMaterial("Substrate", n_substrate);
+    Layer air_layer;
+    air_layer.setMaterial(p_air_material);
+    Layer substrate_layer;
+    substrate_layer.setMaterial(p_substrate_material);
+    ParticleDecoration particle_decoration(new Particle(n_particle, new FormFactorCone(5*Units::nanometer, 5*Units::nanometer, Units::deg2rad(54.73 ))));
+    particle_decoration.addInterferenceFunction(new InterferenceFunctionNone());
+    LayerDecorator air_layer_decorator(air_layer, particle_decoration);
+
+    p_multi_layer->addLayer(air_layer_decorator);
+    p_multi_layer->addLayer(substrate_layer);
+    return p_multi_layer;
+}
+
+
+/* ************************************************************************* */
+//  functional test: Form Factor Sphere
+/* ************************************************************************* */
+ISample *StandardSamples::FormFactor_Sphere()
+{
+    MultiLayer *p_multi_layer = new MultiLayer();
+    complex_t n_air(1.0, 0.0);
+    complex_t n_substrate(1.0-6e-6, 2e-8);
+    complex_t n_particle(1.0-6e-4, 2e-8);
+    const IMaterial *p_air_material = MaterialManager::instance().addHomogeneousMaterial("Air", n_air);
+    const IMaterial *p_substrate_material = MaterialManager::instance().addHomogeneousMaterial("Substrate", n_substrate);
+    Layer air_layer;
+    air_layer.setMaterial(p_air_material);
+    Layer substrate_layer;
+    substrate_layer.setMaterial(p_substrate_material);
+    ParticleDecoration particle_decoration(new Particle(n_particle, new FormFactorSphere(5*Units::nanometer, 5*Units::nanometer)));
+    particle_decoration.addInterferenceFunction(new InterferenceFunctionNone());
+    LayerDecorator air_layer_decorator(air_layer, particle_decoration);
+
+    p_multi_layer->addLayer(air_layer_decorator);
+    p_multi_layer->addLayer(substrate_layer);
+    return p_multi_layer;
+}
+
+/* ************************************************************************* */
+//  functional test: Form Factor Ellipsoid
+/* ************************************************************************* */
+ISample *StandardSamples::FormFactor_Ellipsoid()
+{
+    MultiLayer *p_multi_layer = new MultiLayer();
+    complex_t n_air(1.0, 0.0);
+    complex_t n_substrate(1.0-6e-6, 2e-8);
+    complex_t n_particle(1.0-6e-4, 2e-8);
+    const IMaterial *p_air_material = MaterialManager::instance().addHomogeneousMaterial("Air", n_air);
+    const IMaterial *p_substrate_material = MaterialManager::instance().addHomogeneousMaterial("Substrate", n_substrate);
+    Layer air_layer;
+    air_layer.setMaterial(p_air_material);
+    Layer substrate_layer;
+    substrate_layer.setMaterial(p_substrate_material);
+    ParticleDecoration particle_decoration(new Particle(n_particle, new FormFactorEllipsoid(5*Units::nanometer, 5*Units::nanometer, 5*Units::nanometer, Units::deg2rad(54.73 ))));
+    particle_decoration.addInterferenceFunction(new InterferenceFunctionNone());
+    LayerDecorator air_layer_decorator(air_layer, particle_decoration);
+
+    p_multi_layer->addLayer(air_layer_decorator);
+    p_multi_layer->addLayer(substrate_layer);
+    return p_multi_layer;
+}
+
+
+/* ************************************************************************* */
+//  functional test: Form Factor Full Spheroid
+/* ************************************************************************* */
+ISample *StandardSamples::FormFactor_FullSpheroid()
+{
+    MultiLayer *p_multi_layer = new MultiLayer();
+    complex_t n_air(1.0, 0.0);
+    complex_t n_substrate(1.0-6e-5, 2e-8);
+    complex_t n_particle(1.0-6e-4, 2e-8);
+    const IMaterial *p_air_material = MaterialManager::instance().addHomogeneousMaterial("Air", n_air);
+    const IMaterial *p_substrate_material = MaterialManager::instance().addHomogeneousMaterial("Substrate", n_substrate);
+    Layer air_layer;
+    air_layer.setMaterial(p_air_material);
+    Layer substrate_layer;
+    substrate_layer.setMaterial(p_substrate_material);
+    ParticleDecoration particle_decoration(new Particle(n_particle, new FormFactorFullSpheroid(5*Units::nanometer, 7*Units::nanometer )));
+    particle_decoration.addInterferenceFunction(new InterferenceFunctionNone());
+    LayerDecorator air_layer_decorator(air_layer, particle_decoration);
+
+    p_multi_layer->addLayer(air_layer_decorator);
+    p_multi_layer->addLayer(substrate_layer);
+    return p_multi_layer;
+}
+
+
+/* ************************************************************************* */
+//  functional test: Form Factor Hemi Spheroid
+/* ************************************************************************* */
+ISample *StandardSamples::FormFactor_HemiSpheroid()
+{
+    MultiLayer *p_multi_layer = new MultiLayer();
+    complex_t n_air(1.0, 0.0);
+    complex_t n_substrate(1.0-6e-7, 2e-8);
+    complex_t n_particle(1.0-6e-5, 2e-8);
+    const IMaterial *p_air_material = MaterialManager::instance().addHomogeneousMaterial("Air", n_air);
+    const IMaterial *p_substrate_material = MaterialManager::instance().addHomogeneousMaterial("Substrate", n_substrate);
+    Layer air_layer;
+    air_layer.setMaterial(p_air_material);
+    Layer substrate_layer;
+    substrate_layer.setMaterial(p_substrate_material);
+    ParticleDecoration particle_decoration(new Particle(n_particle, new FormFactorHemiSpheroid(5*Units::nanometer, 4*Units::nanometer, 2*Units::nanometer)));
+    particle_decoration.addInterferenceFunction(new InterferenceFunctionNone());
+    LayerDecorator air_layer_decorator(air_layer, particle_decoration);
+
+    p_multi_layer->addLayer(air_layer_decorator);
+    p_multi_layer->addLayer(substrate_layer);
+    return p_multi_layer;
+}
+
+/* ************************************************************************* */
+// functional test: Form Factor parallelepiped
+/* ************************************************************************* */
+ISample *StandardSamples::FormFactor_Parallelpiped()
+{
+    MultiLayer *p_multi_layer = new MultiLayer();
+    complex_t n_air(1.0, 0.0);
+    complex_t n_particle_shell(1.0-1e-4, 2e-8);
+    complex_t n_particle_core(1.0-6e-5, 2e-8);
+    const IMaterial *p_air_material = MaterialManager::instance().addHomogeneousMaterial("Air11", n_air);
+    Layer air_layer;
+    air_layer.setMaterial(p_air_material);
+    Particle shell_particle(n_particle_shell, new FormFactorParallelepiped(8*Units::nanometer, 8*Units::nanometer));
+    Particle core_particle(n_particle_core, new FormFactorParallelepiped(7*Units::nanometer, 6*Units::nanometer));
+    kvector_t core_position(0.0, 0.0, 0.0);
+    ParticleCoreShell particle(shell_particle, core_particle, core_position);
+    ParticleDecoration particle_decoration(particle.clone());
+    particle_decoration.addInterferenceFunction(new InterferenceFunctionNone());
+    LayerDecorator air_layer_decorator(air_layer, particle_decoration);
+
+    p_multi_layer->addLayer(air_layer_decorator);
+    return p_multi_layer;
+}
+
+
+/* ************************************************************************* */
+// functional test: Form Factor Cylinder
+/* ************************************************************************* */
+ISample *StandardSamples::FormFactor_Cylinder()
+{
+    MultiLayer *p_multi_layer = new MultiLayer();
+    complex_t n_air(1.0, 0.0);
+    complex_t n_particle_shell(1.0-1e-4, 2e-8);
+    complex_t n_particle_core(1.0-6e-5, 2e-8);
+    const IMaterial *p_air_material = MaterialManager::instance().addHomogeneousMaterial("Air11", n_air);
+    Layer air_layer;
+    air_layer.setMaterial(p_air_material);
+    Particle shell_particle(n_particle_shell, new FormFactorCylinder(8*Units::nanometer, 8*Units::nanometer));
+    Particle core_particle(n_particle_core, new FormFactorCylinder(7*Units::nanometer, 6*Units::nanometer));
+    kvector_t core_position(0.0, 0.0, 0.0);
+    ParticleCoreShell particle(shell_particle, core_particle, core_position);
+    ParticleDecoration particle_decoration(particle.clone());
+    particle_decoration.addInterferenceFunction(new InterferenceFunctionNone());
+    LayerDecorator air_layer_decorator(air_layer, particle_decoration);
+
+    p_multi_layer->addLayer(air_layer_decorator);
+    return p_multi_layer;
+}
+
+/* ************************************************************************* */
+// Functional test: Pyramid
+/* ************************************************************************* */
+ISample *StandardSamples::FormFactor_Pyramid()
+{
+    MultiLayer *p_multi_layer = new MultiLayer();
+    complex_t n_air(1.0, 0.0);
+    complex_t n_substrate(1.0-6e-6, 2e-8);
+    complex_t n_particle(1.0-6e-4, 2e-8);
+    const IMaterial *p_air_material = MaterialManager::instance().addHomogeneousMaterial("Air", n_air);
+    const IMaterial *p_substrate_material = MaterialManager::instance().addHomogeneousMaterial("Substrate", n_substrate);
+    Layer air_layer;
+    air_layer.setMaterial(p_air_material);
+    Layer substrate_layer;
+    substrate_layer.setMaterial(p_substrate_material);
+    ParticleDecoration particle_decoration(
+                new Particle(n_particle, new FormFactorPyramid(5*Units::nanometer, 5*Units::nanometer, Units::deg2rad(54.73 ) ) ) );
+    particle_decoration.addInterferenceFunction(new InterferenceFunctionNone());
+    LayerDecorator air_layer_decorator(air_layer, particle_decoration);
+
+    p_multi_layer->addLayer(air_layer_decorator);
+    p_multi_layer->addLayer(substrate_layer);
+    return p_multi_layer;
+}
+
+
+/* ************************************************************************* */
+// functional test: Prism3
+/* ************************************************************************* */
+ISample *StandardSamples::FormFactor_Prism3()
+{
+    MultiLayer *p_multi_layer = new MultiLayer();
+    complex_t n_air(1.0, 0.0);
+    complex_t n_substrate(1.0-7e-6, 2e-8);
+    complex_t n_particle(1.0-8e-4, 2e-8);
+    const IMaterial *p_air_material = MaterialManager::instance().addHomogeneousMaterial("Air", n_air);
+    const IMaterial *p_substrate_material = MaterialManager::instance().addHomogeneousMaterial("Substrate", n_substrate);
+    Layer air_layer;
+    air_layer.setMaterial(p_air_material);
+    Layer substrate_layer;
+    substrate_layer.setMaterial(p_substrate_material);
+    ParticleDecoration particle_decoration(new Particle(n_particle, new FormFactorPrism3(5*Units::nanometer, 5*Units::nanometer)));
+    particle_decoration.addInterferenceFunction(new InterferenceFunctionNone());
+    LayerDecorator air_layer_decorator(air_layer, particle_decoration);
+
+    p_multi_layer->addLayer(air_layer_decorator);
+    p_multi_layer->addLayer(substrate_layer);
+    return p_multi_layer;
+}
+
+ /************************************************************************** */
+ // Functional test: Full Sphere
+ /************************************************************************** */
+    ISample *StandardSamples::FormFactor_FullSphere()
+     {
+     MultiLayer *p_multi_layer = new MultiLayer();
+     complex_t n_air(1.0, 0.0);
+     complex_t n_substrate(1.0-6e-6, 2e-8);
+     complex_t n_particle(1.0-6e-4, 2e-8);
+     const IMaterial *p_air_material = MaterialManager::instance().addHomogeneousMaterial("Air", n_air);
+     const IMaterial *p_substrate_material = MaterialManager::instance().addHomogeneousMaterial("Substrate", n_substrate);
+     Layer air_layer;
+     air_layer.setMaterial(p_air_material);
+     Layer substrate_layer;
+     substrate_layer.setMaterial(p_substrate_material);
+     ParticleDecoration particle_decoration(
+                 new Particle(n_particle, new FormFactorFullSphere(5*Units::nanometer ) ) );
+     particle_decoration.addInterferenceFunction(new InterferenceFunctionNone());
+     LayerDecorator air_layer_decorator(air_layer, particle_decoration);
+
+     p_multi_layer->addLayer(air_layer_decorator);
+     p_multi_layer->addLayer(substrate_layer);
+     return p_multi_layer;
+     }

Core/FormFactors/inc/FormFactorCone.h

+#ifndef FORMFACTORCONE_H
+#define FORMFACTORCONE_H
+// ********************************************************************
+// * The BornAgain project                                            *
+// * Simulation of neutron and x-ray scattering at grazing incidence  *
+// *                                                                  *
+// * LICENSE AND DISCLAIMER                                           *
+// * Lorem ipsum dolor sit amet, consectetur adipiscing elit.  Mauris *
+// * eget quam orci. Quisque  porta  varius  dui,  quis  posuere nibh *
+// * mollis quis. Mauris commodo rhoncus porttitor.                   *
+// ********************************************************************
+//! @file   FormFactorCone.h
+//! @brief  Definition of FormFactorCone
+//! @author Scientific Computing Group at FRM II
+//! @date   03.07.2012
+
+#include "IFormFactor.h"
+#include "IStochasticParameter.h"
+//#include "ConeIntegralReal.h"
+
+//- -------------------------------------------------------------------
+//! @class FormFactorCone
+//! @brief Form factor of Cone
+//- -------------------------------------------------------------------
+class FormFactorCone : public IFormFactorBorn
+{
+public:
+    //! @brief Cone constructor
+    //! @param height of Conee
+    //! @param radius half of Cone's base
+    //! @param angle in radians between base and facet
+    FormFactorCone(double radius, double height,  double alpha);
+
+
+//    FormFactorCone(StochasticParameter<double> *p_height, StochasticParameter<double> *p_radius, StochasticParameter<double> *p_alpha);
+    ~FormFactorCone();
+    virtual FormFactorCone* clone() const;
+
+    virtual int getNumberOfStochasticParameters() const { return 3; }
+
+    virtual double getHeight() const { return m_height; }
+
+protected:
+    virtual complex_t evaluate_for_q (const cvector_t &q) const;
+
+private:
+    //! copy constructor and assignment operator are hidden since there is a clone method
+    FormFactorCone(const FormFactorCone &);
+    FormFactorCone &operator=(const FormFactorCone &);
+
+    //    double ConeIntegral(double Z, void* params) const;
+    double evaluate_for_q_real() const;
+    complex_t evaluate_for_q_imag() const;
+    double ConeIntegralReal(double Z, void* params) const;
+    double ConeIntegralImaginary(double Z, void* params) const;
+
+
+    //! initialize pool parameters, i.e. register some of class members for later access via parameter pool
+    virtual void init_parameters();
+
+    //! print class
+    void print(std::ostream &ostr) const;
+
+    double m_radius;
+    double m_height;
+    double m_alpha;
+    mutable cvector_t m_q;
+
+};
+
+#endif // FORMFACTORCONE_H

Core/FormFactors/inc/FormFactorEllipsoid.h

@@ -20,7 +20,7 @@
 class FormFactorEllipsoid : public IFormFactorBorn
 {
 public:
-    FormFactorEllipsoid(double radius, double width, double height );
+    FormFactorEllipsoid( double radius, double width, double height, double alpha);
     ~FormFactorEllipsoid();
     virtual FormFactorEllipsoid *clone() const;
 
@@ -33,7 +33,7 @@ public:
     double getWidth() const { return m_width; }
 
     virtual double getVolume() const {
-        return 4.0*m_radius*m_width*m_height;
+        return 2.0*m_height*m_radius*m_width;
     }
 
     virtual double getHeight() const { return m_height; }
@@ -49,6 +49,7 @@ private:
     double m_radius;
     double m_width;
     double m_height;
+    double m_alpha;
 };
 
 #endif // FORMFACTORELLIPSOID_H

Core/FormFactors/inc/FormFactorFullSpheroid.h

+#ifndef FORMFACTORFULLSPHEROID_H
+#define FORMFACTORFULLSPHEROID_H
+// ********************************************************************
+// * The BornAgain project                                            *
+// * Simulation of neutron and x-ray scattering at grazing incidence  *
+// *                                                                  *
+// * LICENSE AND DISCLAIMER                                           *
+// * Lorem ipsum dolor sit amet, consectetur adipiscing elit.  Mauris *
+// * eget quam orci. Quisque  porta  varius  dui,  quis  posuere nibh *
+// * mollis quis. Mauris commodo rhoncus porttitor.                   *
+// ********************************************************************
+//! @file   FormFactorFullSpheroid.h
+//! @brief  Definition of FormFactorFullSpheroid
+//! @author Scientific Computing Group at FRM II
+//! @date   01.05.2012
+
+#include "IFormFactor.h"
+#include "IStochasticParameter.h"
+
+
+class FormFactorFullSpheroid : public IFormFactorBorn
+{
+public:
+    FormFactorFullSpheroid(double radius, double height);
+    double FullSpheroidIntegral(double Z, void* params) const;
+//    FormFactorFullSpheroid(StochasticParameter<double> *p_height, StochasticParameter<double> *p_radius);
+    ~FormFactorFullSpheroid();
+    virtual FormFactorFullSpheroid *clone() const;
+
+    virtual int getNumberOfStochasticParameters() const { return 2; }
+
+    virtual double getHeight() const { return m_height; }
+
+protected:
+    virtual complex_t evaluate_for_q(const cvector_t &q) const;
+
+private:
+    //! copy constructor and assignment operator are hidden since there is a clone method
+    FormFactorFullSpheroid(const FormFactorFullSpheroid &);
+    FormFactorFullSpheroid &operator=(const FormFactorFullSpheroid &);
+
+
+    double evaluate_for_q_real() const;
+    complex_t evaluate_for_q_imag() const;
+    double FullSpheroidIntegralReal(double Z, void* params) const;
+    double FullSpheroidIntegralImaginary(double Z, void* params) const;
+
+    //! initialize pool parameters, i.e. register some of class members for later access via parameter pool
+    virtual void init_parameters();
+
+    //! print class
+    void print(std::ostream &ostr) const;
+
+    double m_radius;
+    double m_height;
+    mutable cvector_t m_q;
+
+};
+
+
+#endif // FORMFACTORFULLSPHEROID_H

Core/FormFactors/inc/FormFactorHemiSpheroid.h

+#ifndef FORMFACTORHEMISPHEROID_H
+#define FORMFACTORHEMISPHEROID_H
+// ********************************************************************
+// * The BornAgain project                                            *
+// * Simulation of neutron and x-ray scattering at grazing incidence  *
+// *                                                                  *
+// * LICENSE AND DISCLAIMER                                           *
+// * Lorem ipsum dolor sit amet, consectetur adipiscing elit.  Mauris *
+// * eget quam orci. Quisque  porta  varius  dui,  quis  posuere nibh *
+// * mollis quis. Mauris commodo rhoncus porttitor.                   *
+// ********************************************************************
+//! @file   FormFactorHemiSpheroid.h
+//! @brief  Definition of FormFactorHemiSpheroid
+//! @author Scientific Computing Group at FRM II
+//! @date   03.07.2012
+
+#include "IFormFactor.h"
+#include "IStochasticParameter.h"
+
+//- -------------------------------------------------------------------
+//! @class FormFactorHemiSpheroid
+//! @brief Form factor of Cone
+//- -------------------------------------------------------------------
+class FormFactorHemiSpheroid : public IFormFactorBorn
+{
+public:
+    //! @brief Cone constructor
+    //! @param height of Conee
+    //! @param radius half of Cone's base
+    //! @param angle in radians between base and facet
+    FormFactorHemiSpheroid(double radius,  double width, double height);
+    double HemiSpheroidIntegral(double Z, void* params) const;
+
+    ~FormFactorHemiSpheroid();
+    virtual FormFactorHemiSpheroid* clone() const;
+
+    virtual int getNumberOfStochasticParameters() const { return 3; }
+
+    virtual double getHeight() const { return m_height; }
+
+protected:
+    virtual complex_t evaluate_for_q (const cvector_t &q) const;
+
+private:
+    //! copy constructor and assignment operator are hidden since there is a clone method
+    FormFactorHemiSpheroid(const FormFactorHemiSpheroid &);
+    FormFactorHemiSpheroid &operator=(const FormFactorHemiSpheroid &);
+
+    double evaluate_for_q_real() const;
+    complex_t evaluate_for_q_imag() const;
+    double HemiSpheroidIntegralReal(double Z, void* params) const;
+
+    double HemiSpheroidIntegralImaginary(double Z, void* params) const;
+
+    //! initialize pool parameters, i.e. register some of class members for later access via parameter pool
+    virtual void init_parameters();
+
+    //! print class
+    void print(std::ostream &ostr) const;
+
+    double m_radius;
+    double m_width;
+    double m_height;
+    mutable cvector_t m_q;
+
+};
+
+
+#endif // FormFactorHemiSpheroid_H

Core/FormFactors/inc/FormFactorPrism6.h

@@ -14,14 +14,12 @@
 //! @date   Jun 27, 2012
 
 #include "IFormFactorBorn.h"
-#include "IStochasticParameter.h"
 
 
 class FormFactorPrism6 : public IFormFactorBorn
 {
 public:
     FormFactorPrism6(double height, double half_side);
-//    FormFactorPrism6(StochasticParameter<double> *p_height, StochasticParameter<double> *p_half_side);
     ~FormFactorPrism6();
     virtual FormFactorPrism6 *clone() const;
 

Core/FormFactors/inc/FormFactorSphere.h

 #ifndef FORMFACTORSPHERE_H
 #define FORMFACTORSPHERE_H
-//********************************************************************
+// ********************************************************************
 // * The BornAgain project                                            *
 // * Simulation of neutron and x-ray scattering at grazing incidence  *
 // *                                                                  *
@@ -12,41 +12,42 @@
 //! @file   FormFactorSphere.h
 //! @brief  Definition of FormFactorSphere
 //! @author Scientific Computing Group at FRM II
-//! @date   03.07.2012
+//! @date   01.05.2012
 
 #include "IFormFactorBorn.h"
 #include "IStochasticParameter.h"
 
 
-//- -------------------------------------------------------------------
-//! @class FormFactorSphere
-//! @brief Form factor of Sphere
-//- -------------------------------------------------------------------
 class FormFactorSphere : public IFormFactorBorn
 {
 public:
-    //! @brief Sphere constructor
-    //! @param height of Sphere
-    //! @param radius half of Sphere's base
-    //! @param angle in radians between base and facet
     FormFactorSphere(double radius, double height);
-//    FormFactorSphere(StochasticParameter<double> *p_height, StochasticParameter<double> *p_half_side, StochasticParameter<double> *p_alpha);
+    double SphereIntegral(double Z, void* params) const;
+
     ~FormFactorSphere();
     virtual FormFactorSphere *clone() const;
 
-    virtual int getNumberOfStochasticParameters() const { return 3; }
+    virtual int getNumberOfStochasticParameters() const { return 2; }
 
     virtual double getHeight() const { return m_height; }
 
+protected:
     virtual complex_t evaluate_for_q(const cvector_t &q) const;
 
-protected:
+private:
+
+    double evaluate_for_q_real() const;
+    complex_t evaluate_for_q_imag() const;
+    double SphereIntegralImaginary(double Z, void* params) const;
+    double SphereIntegralReal(double Z, void* params) const;
+
     //! initialize pool parameters, i.e. register some of class members for later access via parameter pool
     virtual void init_parameters();
 
-private:
-    double m_radius;
     double m_height;
+    double m_radius;
+    mutable cvector_t m_q;
 };
 
+
 #endif // FORMFACTORSPHERE_H

Core/FormFactors/src/FormFactorCone.cpp

+#include "FormFactorCone.h"
+#include "StochasticDiracDelta.h"
+#include "MathFunctions.h"
+#include "Numeric.h"
+#include "Units.h"
+#include "Exceptions.h"
+#include <iostream>
+#include "MemberFunctionIntegrator.h"
+
+FormFactorCone::FormFactorCone(double radius,double height,double alpha)
+{
+    setName("FormFactorCone");
+    m_radius = radius;
+    m_height = height;
+    m_alpha = alpha;
+    init_parameters();
+}
+
+
+FormFactorCone::~FormFactorCone()
+{
+}
+
+/* ************************************************************************* */
+// initialize pool parameters, i.e. register some of class members for later access via parameter pool
+/* ************************************************************************* */
+void FormFactorCone::init_parameters()
+{
+    getParameterPool()->clear();
+    getParameterPool()->registerParameter("radius", &m_radius);
+    getParameterPool()->registerParameter("height", &m_height);
+    getParameterPool()->registerParameter("alpha",  &m_alpha);
+}
+
+
+FormFactorCone* FormFactorCone::clone() const
+{
+   FormFactorCone* ffCone = new FormFactorCone(m_radius, m_height, m_alpha);
+   return ffCone;
+}
+
+
+//********************Real Part of the Integral*********************************//
+double FormFactorCone::evaluate_for_q_real() const
+
+{
+    double H = m_height;
+    MemberFunctionIntegrator<FormFactorCone>::mem_function p_mf = &FormFactorCone::ConeIntegralReal;
+    MemberFunctionIntegrator<FormFactorCone> integrator(p_mf,this);
+    double RealRadial = integrator.integrate(0, H, (void *)0);
+    return RealRadial;
+ }
+
+
+ double FormFactorCone::ConeIntegralReal(double Z, void* params) const
+ {
+    (void)params;
+    complex_t qz = m_q.z();
+    complex_t qx = m_q.x();
+    complex_t qy = m_q.y();
+    double R = m_radius;
+    double tan_alpha = std::tan(m_alpha);
+    double Rz  = R-(Z/tan_alpha);
+    double qrRz = std::abs(std::sqrt((qx)*(qx) + (qy)*(qy))*Rz);
+    double J1_qrRz_div_qrRz = std::abs(qrRz) > Numeric::double_epsilon ? MathFunctions::Bessel_J1(std::abs(qrRz))/qrRz : 0.5;
+    double exp_real = std::exp(complex_t(0.0, 1.0)*qz*Z).real();
+    return 2.0 * M_PI *Rz*Rz * J1_qrRz_div_qrRz * exp_real;
+      }
+
+
+ //*********************************Imaginary Part***************************//
+ complex_t FormFactorCone::evaluate_for_q_imag() const
+{
+    double H = m_height;
+    MemberFunctionIntegrator<FormFactorCone>::mem_function p_mf = &FormFactorCone::ConeIntegralImaginary;
+    MemberFunctionIntegrator<FormFactorCone> integrator(p_mf,this);
+    complex_t ImaginaryRadial = integrator.integrate(0, H, (void *)0);
+    return ImaginaryRadial;
+ }
+ double FormFactorCone::ConeIntegralImaginary(double Z, void* params) const
+ {
+    (void)params;
+    complex_t qz = m_q.z();
+    complex_t qx = m_q.x();
+    complex_t qy = m_q.y();
+
+    double R = m_radius;
+    double tan_alpha = std::tan(m_alpha);
+    double Rz  = R-(Z/tan_alpha);
+    double qrRz = std::abs(std::sqrt((qx)*(qx) + (qy)*(qy))*Rz);
+    double J1_qrRz_div_qrRz = std::abs(qrRz) > Numeric::double_epsilon ? MathFunctions::Bessel_J1(std::abs(qrRz))/qrRz : 0.5;
+    double exp_imag = std::exp(complex_t(0.0, 1.0)*qz*Z).imag();
+    return 2.0 * M_PI *Rz*Rz * J1_qrRz_div_qrRz * exp_imag;
+    }
+
+
+ //***************************Sum of Two Integrals*****************************//
+ complex_t FormFactorCone::evaluate_for_q(const cvector_t &q) const
+
+ {
+     m_q = q;
+     return complex_t(0.0, 1.0)*evaluate_for_q_imag() + evaluate_for_q_real();
+ }
+
+
+
+    void FormFactorCone::print(std::ostream &ostr) const
+    {
+        ISample::print(ostr);
+        //     ostr << " (height:"<< m_height << " radius:"<<m_radius << " " << "alpha: " << m_alpha << ")";
+    }

Core/FormFactors/src/FormFactorEllipsoid.cpp

 #include "FormFactorEllipsoid.h"
 #include "MathFunctions.h"
 
-FormFactorEllipsoid::FormFactorEllipsoid(double radius, double width, double height)
-
-    :m_radius(radius)
-    ,m_width(width)
-    ,m_height(height)
+FormFactorEllipsoid::FormFactorEllipsoid(double radius, double width , double height , double alpha)
 {
+    setName("FormFactorEllipsoid");
+    m_height = height;
+    m_radius = radius;
+    m_width  = width;
+    m_alpha = alpha;
+    init_parameters();
 }
 
 FormFactorEllipsoid::~FormFactorEllipsoid()
@@ -15,30 +17,32 @@ FormFactorEllipsoid::~FormFactorEllipsoid()
 
 FormFactorEllipsoid* FormFactorEllipsoid::clone() const
 {
-    return new FormFactorEllipsoid(m_radius, m_width ,m_height );
+    return new FormFactorEllipsoid(m_radius, m_width, m_height, m_alpha );
 }
 
 complex_t FormFactorEllipsoid::evaluate_for_q(const cvector_t& q) const
 {
-
-    complex_t qxR= q.x()*m_radius;
-    complex_t qyW= q.y()* m_width;
-
+    complex_t qxR = q.x()*m_radius;
+    complex_t qyW = q.y()*m_width;
     complex_t qzHdiv2 = q.z()*m_height/2.0;
-    complex_t gamma   = sqrt(pow(qxR,2)+pow(qyW,2));
-
-    complex_t J1_gamma_div_gamma = std::abs(gamma) > Numeric::double_epsilon ? MathFunctions::Bessel_J1(std::abs(gamma))/gamma : 0.5;
 
     complex_t phase_factor = std::exp(complex_t(0.0, 1.0)*qzHdiv2);
 
-    return 2*M_PI * getVolume() * phase_factor * J1_gamma_div_gamma * MathFunctions::Sinc(qzHdiv2);
+    complex_t gamma  = std::sqrt((qxR)*(qxR) + (qyW)*(qyW));
+    complex_t J1_gamma_div_gamma = std::abs(gamma) > Numeric::double_epsilon ? MathFunctions::Bessel_J1(std::abs(gamma))/gamma: 0.5;
+
+    return M_PI * getVolume() * phase_factor * J1_gamma_div_gamma *MathFunctions::Sinc(qzHdiv2);
 }
 
+
 void FormFactorEllipsoid::init_parameters()
 {
     getParameterPool()->clear();
     getParameterPool()->registerParameter("radius", &m_radius);
     getParameterPool()->registerParameter("width",  &m_width);
     getParameterPool()->registerParameter("height", &m_height);
+    getParameterPool()->registerParameter("alpha" , &m_alpha);
 }
 
+
+

Core/FormFactors/src/FormFactorFullSphere.cpp

@@ -12,7 +12,6 @@ FormFactorFullSphere::FormFactorFullSphere(double radius)
     init_parameters();
 }
 
-
 FormFactorFullSphere::~FormFactorFullSphere()
 {
 }

Core/FormFactors/src/FormFactorFullSpheroid.cpp

+#include "FormFactorFullSpheroid.h"
+#include "StochasticDiracDelta.h"
+#include "MathFunctions.h"
+#include "Numeric.h"
+#include "MemberFunctionIntegrator.h"
+
+FormFactorFullSpheroid::FormFactorFullSpheroid(double radius, double height )
+{
+    setName("FormFactorFullSpheroid");
+    m_radius = radius;
+    m_height = height;
+    init_parameters();
+ }
+
+FormFactorFullSpheroid::~FormFactorFullSpheroid()
+{
+}
+
+/* ************************************************************************* */
+// initialize pool parameters, i.e. register some of class members for later access via parameter pool
+/* ************************************************************************* */
+void FormFactorFullSpheroid::init_parameters()
+{
+    getParameterPool()->clear();
+    getParameterPool()->registerParameter("radius", &m_radius);
+    getParameterPool()->registerParameter("height", &m_height);
+
+}
+
+FormFactorFullSpheroid* FormFactorFullSpheroid::clone() const
+{
+   FormFactorFullSpheroid* ffFullSpheroid = new FormFactorFullSpheroid(m_radius, m_height);
+   return ffFullSpheroid;
+}
+complex_t FormFactorFullSpheroid::evaluate_for_q(const cvector_t &q) const
+
+{
+    double H = m_height;
+    double R = m_radius;
+    m_q = q;
+
+    complex_t qz = m_q.z();
+    complex_t qzH_half   = qz*H/2.0;
+    complex_t iqzH_half  = complex_t(0.0, 1.0)*qzH_half;
+    complex_t a_part     =  std::exp(iqzH_half);                          //a_part
+
+
+    MemberFunctionIntegrator<FormFactorFullSpheroid>::mem_function p_mf = &FormFactorFullSpheroid::FullSpheroidIntegral;
+    MemberFunctionIntegrator<FormFactorFullSpheroid> integrator(p_mf,this);
+    double radial = integrator.integrate(0.0, H/2.0, (void *)0);
+    return  a_part * radial;
+ }
+
+
+
+double FormFactorFullSpheroid::FullSpheroidIntegral(double Z, void* params) const
+{
+    (void)params;
+
+         double R = m_radius;
+         double H = m_height;
+         complex_t qz = m_q.z();
+         complex_t qx = m_q.x();
+         complex_t qy = m_q.y();
+
+         double Rz  = std::abs(R* std::sqrt(1-((4*Z*Z)/(H*H))));
+         double qrRz = std::abs(std::sqrt((qx)*(qx) + (qy)*(qy))*Rz);
+
+         double J1_qrRz_div_qrRz = std::abs(qrRz) > Numeric::double_epsilon ? MathFunctions::Bessel_J1(std::abs(qrRz))/qrRz : 0.5;
+         return   4.0* M_PI *Rz*Rz* J1_qrRz_div_qrRz * std::cos(qz.real()*Z);
+
+   }
+/* ************************************************************************* */
+// print class
+/* ************************************************************************* */
+void FormFactorFullSpheroid::print(std::ostream &ostr) const
+{
+    ISample::print(ostr);
+}

Core/FormFactors/src/FormFactorHemiSpheroid.cpp

+#include "FormFactorHemiSpheroid.h"
+#include "StochasticDiracDelta.h"
+#include "MathFunctions.h"
+#include "Numeric.h"
+#include "Units.h"
+#include "Exceptions.h"
+#include <iostream>
+#include "MemberFunctionIntegrator.h"
+
+FormFactorHemiSpheroid::FormFactorHemiSpheroid(double radius, double width, double height)
+{
+    setName("FormFactorHemiSpheroid");
+    m_radius = radius;
+    m_width  = width;
+    m_height = height;
+    init_parameters();
+}
+
+
+FormFactorHemiSpheroid::~FormFactorHemiSpheroid()
+{
+}
+
+/* ************************************************************************* */
+// initialize pool parameters, i.e. register some of class members for later access via parameter pool
+/* ************************************************************************* */
+void FormFactorHemiSpheroid::init_parameters()
+{
+    getParameterPool()->clear();
+    getParameterPool()->registerParameter("radius", &m_radius);
+    getParameterPool()->registerParameter("width",  &m_width);
+    getParameterPool()->registerParameter("height", &m_height);
+}
+
+FormFactorHemiSpheroid* FormFactorHemiSpheroid::clone() const
+{
+   FormFactorHemiSpheroid* ffSpheroid = new FormFactorHemiSpheroid(m_radius,  m_width, m_height);
+   return ffSpheroid;
+}
+
+
+//********************Real Part of the Integral*********************************/
+double FormFactorHemiSpheroid::evaluate_for_q_real() const
+
+{
+    double H = m_height;
+    MemberFunctionIntegrator<FormFactorHemiSpheroid>::mem_function p_mf = &FormFactorHemiSpheroid::HemiSpheroidIntegralReal;
+    MemberFunctionIntegrator<FormFactorHemiSpheroid> integrator(p_mf,this);
+    double RealRadial = integrator.integrate(0, H, (void *)0);
+    return RealRadial;
+ }
+
+ double FormFactorHemiSpheroid::HemiSpheroidIntegralReal(double Z, void* params) const
+ {
+
+    (void)params;
+     double R = m_radius;
+     double W = m_height;
+     double H = m_height;
+
+
+     complex_t qz = m_q.z();
+     complex_t qx = m_q.x();
+     complex_t qy = m_q.y();
+
+     double Wz    =  W * std::sqrt(1-((Z*Z)/(H*H)));
+     double Rz    =  R * std::sqrt(1-((Z*Z)/(H*H)));
+     double gamma = (std::sqrt ((( qx*Rz)*(qx*Rz)) + ((qy*Wz)*(qy*Wz)))).real();
+     double J1_gamma_div_gamma = std::abs(gamma) > Numeric::double_epsilon ? MathFunctions::Bessel_J1(std::abs(gamma))/gamma: 0.5;
+     double exp_real = std::exp(complex_t(0.0, 1.0)*qz*Z).real();
+     return  Rz *Wz * J1_gamma_div_gamma * exp_real;
+
+ }
+
+
+ //*********************************Imaginary Part***************************//
+ complex_t FormFactorHemiSpheroid::evaluate_for_q_imag() const
+{
+    double H = m_height;
+    MemberFunctionIntegrator<FormFactorHemiSpheroid>::mem_function p_mf = &FormFactorHemiSpheroid::HemiSpheroidIntegralImaginary;
+    MemberFunctionIntegrator<FormFactorHemiSpheroid> integrator(p_mf,this);
+    double ImaginaryRadial = integrator.integrate(0, H, (void *)0);
+    return ImaginaryRadial;
+ }
+ double FormFactorHemiSpheroid::HemiSpheroidIntegralImaginary(double Z, void* params) const
+ {
+     (void)params;
+      double R = m_radius;
+      double W = m_height;
+      double H = m_height;
+
+
+       complex_t qx = m_q.x();
+       complex_t qy = m_q.y();
+       complex_t qz = m_q.z();
+
+      double Wz    =  W * std::sqrt(1-((Z*Z)/(H*H)));
+      double Rz    =  R * std::sqrt(1-((Z*Z)/(H*H)));
+      double gamma = (std::sqrt ((( qx*Rz)*(qx*Rz)) + ((qy*Wz)*(qy*Wz)))).real();
+      double J1_gamma_div_gamma = std::abs(gamma) > Numeric::double_epsilon ? MathFunctions::Bessel_J1(std::abs(gamma))/gamma: 0.5;
+      double exp_imag = std::exp(complex_t(0.0,-1.0)*qz*Z).imag();
+      return  Rz *Wz * J1_gamma_div_gamma * exp_imag;
+    }
+
+
+ //***************************Sum of Two Integrals*****************************//
+ complex_t FormFactorHemiSpheroid::evaluate_for_q(const cvector_t &q) const
+
+ {
+     m_q = q;
+     return 2.0* M_PI* complex_t(0.0, 1.0)*evaluate_for_q_imag() + evaluate_for_q_real();
+ }
+
+
+
+    void FormFactorHemiSpheroid::print(std::ostream &ostr) const
+    {
+        ISample::print(ostr);
+            }

Core/FormFactors/src/FormFactorPyramid.cpp

 #include "FormFactorPyramid.h"
 #include "StochasticDiracDelta.h"
 #include "MathFunctions.h"
-//#include "Numeric.h"
-//#include "Units.h"
-//#include "Exceptions.h"
-//#include <iostream>
 
 
 FormFactorPyramid::FormFactorPyramid(double height, double half_side, double alpha)
@@ -19,9 +15,6 @@ FormFactorPyramid::FormFactorPyramid(double height, double half_side, double alp
 
 FormFactorPyramid::~FormFactorPyramid()
 {
-//    delete mp_height;
-//    delete mp_half_side;
-//    delete mp_alpha;
 }