Merge branch 'trunccube' into develop

Core/FormFactors/inc/FormFactorTruncatedCube.h

@@ -48,7 +48,9 @@ protected:
     virtual complex_t evaluate_for_q(const cvector_t& q) const;
 
 private:
-    complex_t FormFactorVertex(const cvector_t& q) const;
+    complex_t ffVertex(const cvector_t& q) const;
+    complex_t ffVertexSymmetric(double t, complex_t a, complex_t b, complex_t c) const;
+    complex_t ffVertexDiagonal(double t, complex_t a, complex_t b) const;
 
     double m_length;
     double m_removed_length;

Core/FormFactors/src/FormFactorTruncatedCube.cpp

@@ -56,125 +56,6 @@ bool FormFactorTruncatedCube::check_initialization() const
     return result;
 }
 
-complex_t FormFactorTruncatedCube::FormFactorVertex(const cvector_t& q) const
-{
-    double L = m_length;
-    double t = m_removed_length;
-    const complex_t im(0.,1.);
-    complex_t ecke = 0.0;
-    complex_t qz = q.z();
-    complex_t qy = q.y();
-    complex_t qx = q.x();
-//    complex_t expiqyt = std::exp(im*qy*t);
-    complex_t expiqzt = std::exp(im*qz*t);
-    complex_t qxhL = 0.5*qx*L;
-    complex_t qyhL = 0.5*qy*L;
-    complex_t expiqxhL = std::exp(im*qxhL);
-    complex_t expiqyhL = std::exp(im*qyhL);
-
-
-    if (std::abs(qz) <= Numeric::double_epsilon)
-    {
-        if (std::abs(qx) <= Numeric::double_epsilon)
-        {
-            if (std::abs(qy) <= Numeric::double_epsilon)
-            {
-                // Volume
-                ecke = 1./6.*t*t*t;
-            }
-            else
-            {
-                ecke = -im* expiqyhL*(0.5*qy*qy*t*t + im*qy*t - 1. + std::exp(-im*qy*t))/(qy*qy*qy);
-            }
-        }
-        else
-        {
-            if (std::abs(qy) <= Numeric::double_epsilon)
-            {
-                ecke = -im*expiqxhL*(0.5*qx*qx*t*t + im*qx*t - 1. + std::exp(-im*qx*t))/(qx*qx*qx);
-            }
-            else
-            {
-                ecke = im*expiqxhL*expiqyhL*std::exp(-0.5*im*t*(qx + qy))*(
-                            std::exp(0.5*im*t*(qx + qy))*(im*qx*qy*t - qx - qy)
-                            + (qx + qy)*std::cos(0.5*t*(qx - qy))
-                            + 0.5*im*t*(qx*qx + qy*qy)*MathFunctions::Sinc(0.5*(qx - qy)*t)
-                            )/(qy*qy*qx*qx);
-            }
-        }
-    }
-    //qz!=0
-    else
-    {
-        if (std::abs(qy) <= Numeric::double_epsilon)
-        {
-            if (std::abs(qx) <= Numeric::double_epsilon)
-            {
-                ecke = im*(0.5*qz*t*qz*t - im*qz*t + expiqzt - 1.)/(qz*qz*qz);
-            }
-            else
-            {
-                ecke = -im*expiqxhL*(
-                            (qz - qx)*std::exp(-im*qx*t)
-                            + im*qx*qz*t + qx - qz
-                            - im*qx*qx*t*std::exp(0.5*t*im*(qz - qx))*MathFunctions::Sinc(0.5*(qx + qz)*t)
-                            )/(qz*qz*qx*qx);
-            }
-        }
-        // qy !=0
-        else
-        {
-            if (std::abs(qz+qy) <= Numeric::double_epsilon)
-            {
-                if (std::abs(qx-qy) <= Numeric::double_epsilon)
-                {
-                    ecke = im*expiqyhL*expiqyhL*(
-                                1. + (0.5*qy*t*qy*t - im*qy*t - 1.)*std::exp(-im*qy*t)
-                                )/(qy*qy*qy);
-                 }
-                else
-                {
-                    if (std::abs(qx) <= Numeric::double_epsilon)
-                   {
-                         ecke = - expiqyhL*(
-                                     qy*t + 2.*im + std::exp(-im*qy*t)*(qy*t - 2.*im)
-                                     )/(qy*qy*qy);
-                    }
-                    else
-                    {
-                        ecke = -im*expiqxhL*expiqyhL*(qx*std::exp(-im*qy*t)*(im*t*qy*(qx - qy) + qx - 2.*qy)
-                                    - (qx - qy)*(qx - qy) + std::exp(-im*qx*t)*qy*qy
-                                    )/((qx - qy)*(qx - qy)*qy*qy*qx);
-                    }
-                }
-            }
-            // qz!=qy
-            else {
-                   if (std::abs(qx) <= Numeric::double_epsilon)
-                   {
-                     ecke = im*expiqyhL*(
-                                 std::exp(im*.5*(qz - qy)*t)*(
-                                     (qy - qz)*std::cos(.5*t*(qy + qz))
-                                     + .5*im*t*(qy*qy + qz*qz)*MathFunctions::Sinc(.5*t*(qy + qz))
-                                     )
-                                 -im*qy*qz*t - qy + qz
-                                 )/(qy*qy*qz*qz);
-                   }
-                   else
-                   {
-                      // General case
-                     ecke = t/qz*expiqxhL*expiqyhL*std::exp(-im*qx*0.5*t)*(
-                                 MathFunctions::Sinc(0.5*qx*t)/qy
-                                 - qz/(qy*(qy + qz))*std::exp(-.5*im*qy*t)*MathFunctions::Sinc(.5*(qx - qy)*t)
-                                 - std::exp(.5*im*qz*t)*MathFunctions::Sinc(.5*(qx + qz)*t)/(qy + qz)
-                                 );
-                   }
-                 }
-        }
-    }
-    return ecke;
-}
-
 complex_t FormFactorTruncatedCube::evaluate_for_q(const cvector_t& q) const
 {
     FormFactorBox fffull(m_length, m_length, m_length);
@@ -193,16 +74,86 @@ complex_t FormFactorTruncatedCube::evaluate_for_q(const cvector_t& q) const
     cvector_t rotatq7(-qx, -qy, -qz);
     cvector_t rotatq8(-qy, qx, -qz);
 
-    complex_t ffE1 = FormFactorVertex(rotatq1);
-    complex_t ffE2 = FormFactorVertex(rotatq2);
-    complex_t ffE3 = FormFactorVertex(rotatq3);
-    complex_t ffE4 = FormFactorVertex(rotatq4);
-    complex_t ffE5 = FormFactorVertex(rotatq5);
-    complex_t ffE6 = FormFactorVertex(rotatq6);
-    complex_t ffE7 = FormFactorVertex(rotatq7);
-    complex_t ffE8 = FormFactorVertex(rotatq8);
+    complex_t ffE1 = ffVertex(rotatq1);
+    complex_t ffE2 = ffVertex(rotatq2);
+    complex_t ffE3 = ffVertex(rotatq3);
+    complex_t ffE4 = ffVertex(rotatq4);
+    complex_t ffE5 = ffVertex(rotatq5);
+    complex_t ffE6 = ffVertex(rotatq6);
+    complex_t ffE7 = ffVertex(rotatq7);
+    complex_t ffE8 = ffVertex(rotatq8);
 
-    complex_t result = ffcube - ffE1 - ffE2 - ffE3 - ffE4 + std::exp(im*qz*m_length)*(-ffE5 - ffE6 - ffE7 - ffE8);
+    complex_t result = ffcube - (ffE1 + ffE2 + ffE3 + ffE4)
+                              - std::exp(im*qz*m_length)*(ffE5 + ffE6 + ffE7 + ffE8);
 
     return result;
 }
+
+bool compareModulus(complex_t a, complex_t b) {
+    return (std::abs(a) < std::abs(b));
+}
+
+complex_t FormFactorTruncatedCube::ffVertex(const cvector_t& q) const
+{
+    double L = m_length;
+    double t = m_removed_length;
+    const complex_t im(0.,1.);
+    complex_t a = q.x();
+    complex_t b = q.y();
+    complex_t c = -q.z();
+
+    complex_t prefactor = std::exp(im*L*(a+b)/2.0);
+    std::vector<complex_t> qvector(3);
+    qvector[0] = a;
+    qvector[1] = b;
+    qvector[2] = c;
+    std::sort(qvector.begin(), qvector.end(), compareModulus);
+
+    return prefactor*ffVertexSymmetric(t, qvector[0], qvector[1], qvector[2]);
+}
+
+complex_t FormFactorTruncatedCube::ffVertexSymmetric(double t, complex_t a, complex_t b,
+                                                     complex_t c) const
+{
+    const complex_t im(0.,1.);
+    if (std::norm(a*t) <= Numeric::double_epsilon) {
+        if (std::norm(b*t) <= Numeric::double_epsilon) {
+            if (std::norm(c*t) <= Numeric::double_epsilon) {
+                return std::pow(t, 3)/6.0;
+            }
+            return -im*(std::exp(-im*c*t) - (1.0 - im*c*t - c*c*t*t/2.0))/(c*c*c);
+        }
+        if (std::norm((b-c)*t) <= Numeric::double_epsilon) {
+            return -im*(std::exp(-im*c*t)*(-2.0-im*c*t) + 2.0 - im*c*t)/(c*c*c);
+        }
+        complex_t numerator = -im * ( c*c*std::exp(-im*b*t) - b*b*std::exp(-im*c*t)
+                                    + b*b - c*c -im*t*b*c*(b-c) );
+        complex_t denominator = b*b*c*c*(b-c);
+        return numerator/denominator;
+    }
+    if (std::norm((a-b)*t) <= Numeric::double_epsilon) {
+        if (std::norm((b-c)*t) <= Numeric::double_epsilon) {
+            return im*(1.0 - std::exp(-im*b*t)*(1.0 + im*b*t - b*b*t*t/2.0))/std::pow(b,3);
+        } else {
+            return ffVertexDiagonal(t, a, c);
+        }
+    } else if (std::norm((b-c)*t) <= Numeric::double_epsilon) {
+        return ffVertexDiagonal(t, b, a);
+    }
+    complex_t t1 = 1.0;
+    complex_t t2 = -b*c*std::exp(-im*a*t)/((a-b)*(a-c));
+    complex_t t3 = -a*c*std::exp(-im*b*t)/((b-a)*(b-c));
+    complex_t t4 = -a*b*std::exp(-im*c*t)/((c-a)*(c-b));
+    return im*(t1+t2+t3+t4)/(a*b*c);
+}
+
+complex_t FormFactorTruncatedCube::ffVertexDiagonal(double t, complex_t a, complex_t b) const
+{
+    const complex_t im(0.,1.);
+    complex_t prefactor = im/(a*a*b*std::pow(a-b, 2));
+    complex_t t1 = (a-b)*(a-b);
+    complex_t t2 = -a*a*std::exp(-im*b*t);
+    complex_t t3 = std::exp(-im*a*t)*(2.0*a*b - b*b + im*a*b*(a-b)*t);
+    return prefactor*(t1 + t2 + t3);
+}
+

Core/PythonAPI/src/PythonModule.cpp

@@ -10,150 +10,150 @@ GCC_DIAG_ON(missing-field-initializers)
 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
 #define PY_ARRAY_UNIQUE_SYMBOL BORNAGAIN_PYTHONAPI_ARRAY
 #include "numpy/arrayobject.h"
+#include "FormFactorFullSpheroid.pypp.h"
+#include "DistributionGate.pypp.h"
+#include "SimpleSelectionRule.pypp.h"
+#include "RealParameterWrapper.pypp.h"
+#include "vdouble1d_t.pypp.h"
+#include "SimulationParameters.pypp.h"
+#include "ThreadInfo.pypp.h"
+#include "InterferenceFunction2DLattice.pypp.h"
+#include "LayerInterface.pypp.h"
 #include "ILayout.pypp.h"
-#include "RotationZ.pypp.h"
-#include "FTDistribution1DCauchy.pypp.h"
-#include "ISampleBuilder.pypp.h"
-#include "Beam.pypp.h"
+#include "FormFactorCone6.pypp.h"
+#include "FormFactorTetrahedron.pypp.h"
+#include "FTDistribution1DCosine.pypp.h"
+#include "VerticalLine.pypp.h"
+#include "FTDistribution1DTriangle.pypp.h"
 #include "FormFactorWeighted.pypp.h"
-#include "HomogeneousMagneticMaterial.pypp.h"
-#include "DistributionLorentz.pypp.h"
-#include "RotationX.pypp.h"
+#include "InterferenceFunctionRadialParaCrystal.pypp.h"
+#include "DistributionGaussian.pypp.h"
+#include "IDetectorResolution.pypp.h"
+#include "FormFactorCylinder.pypp.h"
 #include "Crystal.pypp.h"
+#include "FTDistribution1DCauchy.pypp.h"
+#include "IFormFactorBorn.pypp.h"
+#include "FormFactorEllipsoidalCylinder.pypp.h"
 #include "InterferenceFunctionNone.pypp.h"
-#include "FTDistribution2DGate.pypp.h"
-#include "FormFactorPrism6.pypp.h"
-#include "vdouble2d_t.pypp.h"
-#include "FormFactorTruncatedCube.pypp.h"
-#include "VerticalLine.pypp.h"
-#include "IFTDistribution2D.pypp.h"
-#include "FormFactorLorentz.pypp.h"
-#include "FixedBinAxis.pypp.h"
-#include "ISample.pypp.h"
-#include "ConstKBinAxis.pypp.h"
-#include "LayerInterface.pypp.h"
-#include "IDetectorResolution.pypp.h"
-#include "Lattice2DIFParameters.pypp.h"
+#include "Histogram1D.pypp.h"
+#include "vector_less__const_ISample_ptr___greater_.pypp.h"
+#include "WavevectorInfo.pypp.h"
 #include "HorizontalLine.pypp.h"
-#include "IntensityData.pypp.h"
-#include "LayerRoughness.pypp.h"
-#include "vector_integer_t.pypp.h"
-#include "FormFactorTruncatedSphere.pypp.h"
-#include "FormFactorCylinder.pypp.h"
-#include "FormFactorFullSphere.pypp.h"
-#include "IAxis.pypp.h"
-#include "Simulation.pypp.h"
-#include "IDetector2D.pypp.h"
-#include "InterferenceFunction2DParaCrystal.pypp.h"
-#include "DistributionLogNormal.pypp.h"
-#include "FTDistribution1DCosine.pypp.h"
-#include "OffSpecSimulation.pypp.h"
-#include "RotationEuler.pypp.h"
-#include "FTDistribution1DTriangle.pypp.h"
-#include "FormFactorSphereUniformRadius.pypp.h"
-#include "IntensityDataFunctions.pypp.h"
-#include "Instrument.pypp.h"
-#include "FormFactorTrivial.pypp.h"
-#include "FormFactorSphereLogNormalRadius.pypp.h"
-#include "RotationY.pypp.h"
-#include "vector_realparameter_t.pypp.h"
-#include "IInterferenceFunction.pypp.h"
-#include "FTDistribution2DCauchy.pypp.h"
-#include "IFormFactor.pypp.h"
-#include "IObserver.pypp.h"
-#include "ParticleComposition.pypp.h"
-#include "Particle.pypp.h"
-#include "MultiLayer.pypp.h"
-#include "ParameterPool.pypp.h"
-#include "FormFactorTetrahedron.pypp.h"
-#include "FormFactorFullSpheroid.pypp.h"
-#include "IParameterized.pypp.h"
-#include "FormFactorAnisoPyramid.pypp.h"
-#include "IObservable.pypp.h"
-#include "ParticleCoreShell.pypp.h"
-#include "Histogram2D.pypp.h"
+#include "FTDistribution2DGate.pypp.h"
+#include "vector_kvector_t.pypp.h"
+#include "FormFactorTruncatedSpheroid.pypp.h"
 #include "IShape2D.pypp.h"
-#include "FormFactorCone.pypp.h"
+#include "Particle.pypp.h"
 #include "vector_string_t.pypp.h"
-#include "Polygon.pypp.h"
-#include "RectangularDetector.pypp.h"
-#include "IDistribution1D.pypp.h"
-#include "MesoCrystal.pypp.h"
-#include "FTDistribution2DVoigt.pypp.h"
-#include "InterferenceFunctionRadialParaCrystal.pypp.h"
-#include "IMaterial.pypp.h"
-#include "IsGISAXSDetector.pypp.h"
-#include "SimulationParameters.pypp.h"
-#include "IResolutionFunction2D.pypp.h"
-#include "FormFactorTruncatedSpheroid.pypp.h"
-#include "FormFactorCone6.pypp.h"
-#include "FormFactorSphereGaussianRadius.pypp.h"
-#include "VariableBinAxis.pypp.h"
+#include "FormFactorTrivial.pypp.h"
+#include "ConstKBinAxis.pypp.h"
+#include "FTDistribution2DCauchy.pypp.h"
+#include "FormFactorCrystal.pypp.h"
+#include "ParticleDistribution.pypp.h"
 #include "vector_longinteger_t.pypp.h"
 #include "ResolutionFunction2DGaussian.pypp.h"
-#include "cvector_t.pypp.h"
-#include "FormFactorDecoratorDebyeWaller.pypp.h"
-#include "IClusteredParticles.pypp.h"
-#include "FTDistribution1DVoigt.pypp.h"
-#include "vector_complex_t.pypp.h"
-#include "FTDistribution2DCone.pypp.h"
-#include "ParticleDistribution.pypp.h"
-#include "vector_kvector_t.pypp.h"
-#include "FormFactorRipple1.pypp.h"
-#include "Bin1D.pypp.h"
-#include "FormFactorRipple2.pypp.h"
-#include "InterferenceFunction2DLattice.pypp.h"
-#include "ThreadInfo.pypp.h"
-#include "DistributionCosine.pypp.h"
+#include "RectangularDetector.pypp.h"
 #include "FTDistribution1DGauss.pypp.h"
 #include "FTDistribution1DGate.pypp.h"
-#include "FormFactorCuboctahedron.pypp.h"
-#include "Layer.pypp.h"
-#include "RealParameterWrapper.pypp.h"
-#include "Histogram1D.pypp.h"
+#include "FormFactorAnisoPyramid.pypp.h"
+#include "FixedBinAxis.pypp.h"
+#include "MultiLayer.pypp.h"
+#include "IFormFactor.pypp.h"
+#include "kvector_t.pypp.h"
+#include "Ellipse.pypp.h"
+#include "FormFactorSphereUniformRadius.pypp.h"
+#include "IHistogram.pypp.h"
+#include "Polygon.pypp.h"
+#include "OffSpecSimulation.pypp.h"
+#include "FormFactorRipple1.pypp.h"
+#include "Simulation.pypp.h"
+#include "IObservable.pypp.h"
+#include "FormFactorLorentz.pypp.h"
 #include "SpecularSimulation.pypp.h"
-#include "FormFactorCrystal.pypp.h"
+#include "GISASSimulation.pypp.h"
+#include "ISelectionRule.pypp.h"
+#include "FormFactorRipple2.pypp.h"
+#include "RotationZ.pypp.h"
+#include "LayerRoughness.pypp.h"
+#include "Bin1DCVector.pypp.h"
+#include "FormFactorSphereGaussianRadius.pypp.h"
+#include "ParameterPool.pypp.h"
+#include "IsGISAXSDetector.pypp.h"
 #include "FormFactorPrism3.pypp.h"
-#include "PythonInterface_global_variables.pypp.h"
-#include "FTDistribution2DGauss.pypp.h"
-#include "Line.pypp.h"
-#include "FormFactorGauss.pypp.h"
-#include "vector_less__const_ISample_ptr___greater_.pypp.h"
-#include "FormFactorHemiEllipsoid.pypp.h"
-#include "PythonInterface_free_functions.pypp.h"
+#include "IMaterial.pypp.h"
+#include "FTDistribution1DVoigt.pypp.h"
+#include "IntensityDataFunctions.pypp.h"
+#include "FormFactorPrism6.pypp.h"
+#include "IClusteredParticles.pypp.h"
+#include "VariableBinAxis.pypp.h"
 #include "IParticle.pypp.h"
-#include "vdouble1d_t.pypp.h"
-#include "AttLimits.pypp.h"
-#include "DistributionGaussian.pypp.h"
-#include "FormFactorBox.pypp.h"
+#include "DistributionCosine.pypp.h"
+#include "FormFactorHemiEllipsoid.pypp.h"
+#include "IAxis.pypp.h"
+#include "vector_integer_t.pypp.h"
+#include "IntensityDataIOFactory.pypp.h"
+#include "ParameterDistribution.pypp.h"
+#include "Layer.pypp.h"
 #include "FormFactorPyramid.pypp.h"
-#include "Lattice.pypp.h"
+#include "RotationY.pypp.h"
+#include "CustomBinAxis.pypp.h"
+#include "FTDistribution2DCone.pypp.h"
 #include "IFTDistribution1D.pypp.h"
-#include "IFormFactorBorn.pypp.h"
-#include "FormFactorEllipsoidalCylinder.pypp.h"
+#include "DistributionLorentz.pypp.h"
+#include "IDistribution1D.pypp.h"
+#include "vdouble2d_t.pypp.h"
+#include "Line.pypp.h"
+#include "HomogeneousMagneticMaterial.pypp.h"
+#include "vector_realparameter_t.pypp.h"
+#include "IAbstractParticle.pypp.h"
+#include "FormFactorTruncatedCube.pypp.h"
+#include "FormFactorCuboctahedron.pypp.h"
+#include "IDetector2D.pypp.h"
+#include "cvector_t.pypp.h"
+#include "PythonInterface_free_functions.pypp.h"
+#include "FormFactorSphereLogNormalRadius.pypp.h"
+#include "IResolutionFunction2D.pypp.h"
+#include "FormFactorFullSphere.pypp.h"
 #include "ParticleLayout.pypp.h"
-#include "WavevectorInfo.pypp.h"
+#include "FormFactorBox.pypp.h"
+#include "IParameterized.pypp.h"
+#include "Lattice2DIFParameters.pypp.h"
 #include "IFormFactorDecorator.pypp.h"
-#include "HomogeneousMaterial.pypp.h"
-#include "DistributionGate.pypp.h"
-#include "kvector_t.pypp.h"
-#include "IAbstractParticle.pypp.h"
-#include "ISelectionRule.pypp.h"
-#include "IntensityDataIOFactory.pypp.h"
-#include "IHistogram.pypp.h"
-#include "ParameterDistribution.pypp.h"
-#include "SimpleSelectionRule.pypp.h"
 #include "InterferenceFunction1DLattice.pypp.h"
-#include "Ellipse.pypp.h"
+#include "RotationEuler.pypp.h"
+#include "ISample.pypp.h"
+#include "ISampleBuilder.pypp.h"
+#include "IRotation.pypp.h"
+#include "PythonInterface_global_variables.pypp.h"
+#include "Beam.pypp.h"
+#include "HomogeneousMaterial.pypp.h"
 #include "Rectangle.pypp.h"
-#include "Bin1DCVector.pypp.h"
-#include "CustomBinAxis.pypp.h"
 #include "ICloneable.pypp.h"
-#include "IRotation.pypp.h"
+#include "Histogram2D.pypp.h"
+#include "ParticleCoreShell.pypp.h"
+#include "FormFactorDecoratorDebyeWaller.pypp.h"
+#include "MesoCrystal.pypp.h"
 #include "Lattice1DIFParameters.pypp.h"
-#include "ICompositeSample.pypp.h"
-#include "GISASSimulation.pypp.h"
+#include "IObserver.pypp.h"
+#include "IntensityData.pypp.h"
+#include "Lattice.pypp.h"
+#include "AttLimits.pypp.h"
+#include "IInterferenceFunction.pypp.h"
+#include "Instrument.pypp.h"
+#include "FormFactorCone.pypp.h"
+#include "ParticleComposition.pypp.h"
+#include "RotationX.pypp.h"
+#include "FTDistribution2DGauss.pypp.h"
+#include "FormFactorTruncatedSphere.pypp.h"
+#include "FTDistribution2DVoigt.pypp.h"
+#include "FormFactorGauss.pypp.h"
+#include "InterferenceFunction2DParaCrystal.pypp.h"
 #include "SphericalDetector.pypp.h"
+#include "ICompositeSample.pypp.h"
+#include "Bin1D.pypp.h"
+#include "vector_complex_t.pypp.h"
+#include "DistributionLogNormal.pypp.h"
+#include "IFTDistribution2D.pypp.h"
 #include "__call_policies.pypp.hpp"
 #include "__convenience.pypp.hpp"
 #include "__call_policies.pypp.hpp"

Core/Tools/inc/Numeric.h

@@ -31,9 +31,6 @@ static const double double_epsilon = std::numeric_limits<double>::epsilon();
 
 static const double double_min = std::numeric_limits<double>::min();
 
-//! threshold on probability value during calculation of weighted form factor
-static const double probthreshold = 0.0000000001;
-
 //! compare two doubles
 bool BA_CORE_API_ areAlmostEqual(double a, double b, double tolerance_factor=1.0);
 

Fit/PythonAPI/src/PythonModule.cpp

@@ -5,37 +5,37 @@ GCC_DIAG_OFF(missing-field-initializers)
 #include "boost/python.hpp"
 GCC_DIAG_ON(unused-parameter)
 GCC_DIAG_ON(missing-field-initializers)
-#include "FitSuiteObjects.pypp.h"
-#include "IChiSquaredModule.pypp.h"
-#include "FitStrategyDefault.pypp.h"
-#include "IntensityFunctionLog.pypp.h"
-#include "IntensityNormalizer.pypp.h"
-#include "FitStrategyFixParameters.pypp.h"
-#include "FitStrategyAdjustParameters.pypp.h"
-#include "SquaredFunctionGaussianError.pypp.h"
-#include "IFitStrategy.pypp.h"
+#include "IntensityFunctionSqrt.pypp.h"
 #include "MinimizerFactory.pypp.h"
-#include "FitSuite.pypp.h"
 #include "IMinimizer.pypp.h"
+#include "SquaredFunctionSystematicError.pypp.h"
+#include "IntensityNormalizer.pypp.h"
+#include "IIntensityFunction.pypp.h"
+#include "INamed.pypp.h"
+#include "IntensityFunctionLog.pypp.h"
+#include "FitSuiteParameters.pypp.h"
+#include "AttFitting.pypp.h"
+#include "FitParameter.pypp.h"
 #include "IntensityScaleAndShiftNormalizer.pypp.h"
-#include "ISquaredFunction.pypp.h"
-#include "SquaredFunctionSimError.pypp.h"
+#include "IChiSquaredModule.pypp.h"
 #include "FitStrategyAdjustMinimizer.pypp.h"
-#include "FitParameter.pypp.h"
+#include "IFitStrategy.pypp.h"
+#include "FitStrategyFixParameters.pypp.h"
+#include "SquaredFunctionGaussianError.pypp.h"
 #include "IFitObserver.pypp.h"
-#include "SquaredFunctionDefault.pypp.h"
-#include "ChiSquaredModule.pypp.h"
-#include "SquaredFunctionMeanSquaredError.pypp.h"
 #include "IIntensityNormalizer.pypp.h"
-#include "FitSuiteParameters.pypp.h"
-#include "FitStrategyReleaseParameters.pypp.h"
+#include "FitSuite.pypp.h"
+#include "FitStrategyAdjustParameters.pypp.h"
+#include "ChiSquaredModule.pypp.h"
 #include "MinimizerOptions.pypp.h"
-#include "IIntensityFunction.pypp.h"
-#include "IntensityFunctionSqrt.pypp.h"
+#include "SquaredFunctionDefault.pypp.h"
+#include "SquaredFunctionMeanSquaredError.pypp.h"
+#include "ISquaredFunction.pypp.h"
+#include "FitStrategyDefault.pypp.h"
 #include "FitObject.pypp.h"
-#include "SquaredFunctionSystematicError.pypp.h"
-#include "AttFitting.pypp.h"
-#include "INamed.pypp.h"
+#include "FitSuiteObjects.pypp.h"
+#include "SquaredFunctionSimError.pypp.h"
+#include "FitStrategyReleaseParameters.pypp.h"
 
 BOOST_PYTHON_MODULE(libBornAgainFit){
     boost::python::docstring_options doc_options(true, true, false);