2*M_PI -> M_TWOPI

Core/Aggregate/InterferenceFunction2DLattice.cpp

@@ -74,7 +74,7 @@ InterferenceFunction2DLattice* InterferenceFunction2DLattice::createHexagonal(
     Lattice2DParameters lattice_params;
     lattice_params.m_length_1 = lattice_length;
     lattice_params.m_length_2 = lattice_length;
-    lattice_params.m_angle = 2.0 * M_PI / 3.0;
+    lattice_params.m_angle = M_TWOPI / 3.0;
     lattice_params.m_xi = xi;
     return new InterferenceFunction2DLattice(lattice_params);
 }

Core/Aggregate/InterferenceFunction2DParaCrystal.cpp

@@ -140,7 +140,7 @@ InterferenceFunction2DParaCrystal* InterferenceFunction2DParaCrystal::createHexa
     double peak_distance, double damping_length, double domain_size_1, double domain_size_2)
 {
     auto p_new = new InterferenceFunction2DParaCrystal(
-        peak_distance, peak_distance, 2.0*M_PI/3.0, 0.0, damping_length);
+        peak_distance, peak_distance, M_TWOPI/3.0, 0.0, damping_length);
     p_new->setDomainSizes(domain_size_1, domain_size_2);
     p_new->setIntegrationOverXi(true);
     return p_new;

Core/StandardSamples/MesoCrystalBuilder.cpp

@@ -105,7 +105,7 @@ MultiLayer* MesoCrystalBuilder::buildSample() const
 //    double alpha_step = 5.0*Units::degree/n_alpha_rotation_steps;
 //    double alpha_start = - (n_alpha_rotation_steps/2.0)*alpha_step;
 
-    double phi_step = 2*M_PI/3.0/n_max_phi_rotation_steps;
+    double phi_step = M_TWOPI/3.0/n_max_phi_rotation_steps;
     double phi_start = 0.0;
     for (size_t i=0; i<n_max_phi_rotation_steps; ++i) {
         for (size_t j=0; j<n_alpha_rotation_steps; ++j) {

GUI/coregui/Models/TransformFromDomain.cpp

@@ -201,7 +201,7 @@ bool TransformFromDomain::isSquareLattice(double length1, double length2, double
 
 bool TransformFromDomain::isHexagonalLattice(double length1, double length2, double angle)
 {
-    return length1 == length2 && Numeric::areAlmostEqual(angle, 2*M_PI / 3.0);
+    return length1 == length2 && Numeric::areAlmostEqual(angle, M_TWOPI / 3.0);
 }
 
 void TransformFromDomain::setItemFromSample(BeamItem* beamItem, const GISASSimulation& simulation)

GUI/coregui/Models/TransformToDomain.cpp

@@ -200,7 +200,7 @@ TransformToDomain::createInterferenceFunction(const SessionItem& item)
             length_1 = latticeItem->getItemValue(
                                         HexagonalLatticeTypeItem::P_LATTICE_LENGTH).toDouble();
             length_2 = length_1;
-            alpha_lattice = 2 * M_PI / 3.0;
+            alpha_lattice = M_TWOPI / 3.0;
         } else {
             throw GUIHelpers::Error("TransformToDomain::createInterferenceFunction() -> Error");
         }
@@ -271,7 +271,7 @@ TransformToDomain::createInterferenceFunction(const SessionItem& item)
             length_1 = latticeItem->getItemValue(
                                         HexagonalLatticeTypeItem::P_LATTICE_LENGTH).toDouble();
             length_2 = length_1;
-            angle = 2 * M_PI / 3.0;
+            angle = M_TWOPI / 3.0;
         } else {
             throw GUIHelpers::Error("TransformToDomain::createInterferenceFunction() -> Error");
         }

Tests/UnitTests/Core/1/FormFactorBasicTest.h

@@ -107,7 +107,7 @@ TEST_F(FormFactorBasicTest, HemiEllipsoid)
     double radius_b = 7.;
     double height = 5.;
 
-    double volume = 2.*M_PI*radius_a*radius_b*height/3.;
+    double volume = M_TWOPI*radius_a*radius_b*height/3.;
 
     FormFactorHemiEllipsoid hemiellipsoid(radius_a, radius_b, height);
 

Tests/UnitTests/Core/4/BeamTest.h

@@ -19,7 +19,7 @@ protected:
 
 TEST_F(BeamTest, BeamInitialState)
 {
-    EXPECT_DOUBLE_EQ(2.0 * M_PI, m_empty_beam.getCentralK()[0]);
+    EXPECT_DOUBLE_EQ(M_TWOPI, m_empty_beam.getCentralK()[0]);
     EXPECT_EQ(0.0, m_empty_beam.getCentralK()[1]);
     EXPECT_EQ(0.0, m_empty_beam.getCentralK()[2]);
     EXPECT_EQ(0.0, m_empty_beam.getIntensity());

Tests/UnitTests/Core/4/InstrumentTest.h

@@ -35,7 +35,7 @@ TEST_F(InstrumentTest, InstrumentInitialState)
 TEST_F(InstrumentTest, BeamManipulation)
 {
     double lambda(1), alpha(-1), phi(1);
-    double k = 2.*M_PI/lambda;
+    double k = M_TWOPI/lambda;
     double x = k*std::cos(alpha) * std::cos(phi);
     double y = -k*std::cos(alpha) * std::sin(phi);
     double z = k*std::sin(alpha);

Tests/UnitTests/Core/5/DistributionsTest.h

@@ -103,7 +103,7 @@ TEST_F(DistributionsTest, DistributionLorentzDefaultConstructor)
     EXPECT_EQ(0.0, P_distr_lorentz->getMean());
     EXPECT_EQ(1.0, P_distr_lorentz->getHWHM());
     EXPECT_EQ(BornAgain::DistributionLorentzType, P_distr_lorentz->getName());
-    EXPECT_EQ(1/(2*M_PI), P_distr_lorentz->probabilityDensity(1.0));
+    EXPECT_EQ(1/(M_TWOPI), P_distr_lorentz->probabilityDensity(1.0));
 
     std::vector<double> list1 = P_distr_lorentz->generateValueList(1, 0.0);
     EXPECT_EQ(P_distr_lorentz->getMean(), list1[0]);
@@ -197,7 +197,7 @@ TEST_F(DistributionsTest, DistributionGaussianDefaultConstructor)
     std::unique_ptr<DistributionGaussian> P_distr_gauss { new DistributionGaussian() };
     EXPECT_EQ(0.0, P_distr_gauss->getMean());
     EXPECT_EQ(1.0, P_distr_gauss->getStdDev());
-    EXPECT_EQ(std::exp(-1.0/2.0)/std::sqrt(2.0*M_PI), P_distr_gauss->probabilityDensity(1.0));
+    EXPECT_EQ(std::exp(-1.0/2.0)/std::sqrt(M_TWOPI), P_distr_gauss->probabilityDensity(1.0));
     EXPECT_EQ(BornAgain::DistributionGaussianType, P_distr_gauss->getName());
 
     std::vector<double> list1 = P_distr_gauss->generateValueList(1, 0.0);
@@ -220,7 +220,7 @@ TEST_F(DistributionsTest, DistributionGaussianConstructor)
     DistributionGaussian distr2(1.0, 1.0);
     EXPECT_EQ(1.0, distr2.getMean());
     EXPECT_EQ(1.0, distr2.getStdDev());
-    EXPECT_EQ(1/std::sqrt(2.0*M_PI), distr2.probabilityDensity(1.0));
+    EXPECT_EQ(1/std::sqrt(M_TWOPI), distr2.probabilityDensity(1.0));
     EXPECT_EQ(BornAgain::DistributionGaussianType, distr2.getName());
 
     std::vector<double> list2 = distr2.generateValueList(1, 0.0);
@@ -248,7 +248,7 @@ TEST_F(DistributionsTest, DistributionGaussianClone)
     std::unique_ptr<DistributionGaussian> P_clone { P_distr_gauss->clone() };
     EXPECT_EQ(1.0, P_clone->getMean());
     EXPECT_EQ(1.0, P_clone->getStdDev());
-    EXPECT_EQ(1/std::sqrt(2.0*M_PI), P_clone->probabilityDensity(1.0));
+    EXPECT_EQ(1/std::sqrt(M_TWOPI), P_clone->probabilityDensity(1.0));
     EXPECT_EQ(BornAgain::DistributionGaussianType, P_clone->getName());
 
     std::vector<double> list1 = P_clone->generateValueList(1, 0.0);
@@ -274,7 +274,7 @@ TEST_F(DistributionsTest, DistributionLogNormalConstructorWithOneParameter)
     EXPECT_EQ(1.0, distr2.getMedian());
     EXPECT_EQ(1.0, distr2.getScalePar());
     EXPECT_EQ(std::exp(0.5), distr2.getMean());
-    EXPECT_EQ(1.0/std::sqrt(2.0*M_PI), distr2.probabilityDensity(1.0));
+    EXPECT_EQ(1.0/std::sqrt(M_TWOPI), distr2.probabilityDensity(1.0));
     EXPECT_EQ(BornAgain::DistributionLogNormalType, distr2.getName());
 
     std::vector<double> list2 = distr2.generateValueList(1, 0.0);
@@ -291,7 +291,7 @@ TEST_F(DistributionsTest, DistributionLogNormalConstructorWithTwoParameter)
     EXPECT_EQ(1.0, P_distr_lognormal->getMedian());
     EXPECT_EQ(1.0, P_distr_lognormal->getScalePar());
     EXPECT_EQ(std::exp(0.5), P_distr_lognormal->getMean());
-    EXPECT_EQ(1.0/std::sqrt(2.0*M_PI), P_distr_lognormal->probabilityDensity(1.0));
+    EXPECT_EQ(1.0/std::sqrt(M_TWOPI), P_distr_lognormal->probabilityDensity(1.0));
     EXPECT_EQ(BornAgain::DistributionLogNormalType, P_distr_lognormal->getName());
 
     std::vector<double> list1 = P_distr_lognormal->generateValueList(1, 0.0);
@@ -320,7 +320,7 @@ TEST_F(DistributionsTest, DistributionLogNormalClone)
     EXPECT_EQ(1.0, P_distr_lognormal->getMedian());
     EXPECT_EQ(1.0, P_distr_lognormal->getScalePar());
     EXPECT_EQ(std::exp(0.5), P_distr_lognormal->getMean());
-    EXPECT_EQ(1/std::sqrt(2.0*M_PI), P_distr_lognormal->probabilityDensity(1.0));
+    EXPECT_EQ(1/std::sqrt(M_TWOPI), P_distr_lognormal->probabilityDensity(1.0));
     EXPECT_EQ(BornAgain::DistributionLogNormalType, P_distr_lognormal->getName());
 
     std::vector<double> list1 = P_distr_lognormal->generateValueList(1, 0.0);
@@ -338,7 +338,7 @@ TEST_F(DistributionsTest, DistributionCosineDefaultConstructor)
     std::unique_ptr<DistributionCosine> P_distr_cosine { new DistributionCosine() };
     EXPECT_EQ(0.0, P_distr_cosine->getMean());
     EXPECT_EQ(1.0, P_distr_cosine->getSigma());
-    EXPECT_DOUBLE_EQ((1.0+std::cos(1.0))/(2.0*M_PI), P_distr_cosine->probabilityDensity(1.0));
+    EXPECT_DOUBLE_EQ((1.0+std::cos(1.0))/(M_TWOPI), P_distr_cosine->probabilityDensity(1.0));
     EXPECT_EQ(0, P_distr_cosine->probabilityDensity(100.0));
     EXPECT_EQ(BornAgain::DistributionCosineType, P_distr_cosine->getName());
 
@@ -362,7 +362,7 @@ TEST_F(DistributionsTest, DistributionCosineConstructor)
     DistributionCosine distr2(1.0,1.0);
     EXPECT_EQ(1.0, distr2.getMean());
     EXPECT_EQ(1.0, distr2.getSigma());
-    EXPECT_EQ(2.0/(2.0*M_PI), distr2.probabilityDensity(1.0));
+    EXPECT_EQ(2.0/(M_TWOPI), distr2.probabilityDensity(1.0));
     EXPECT_EQ(0, distr2.probabilityDensity(100.0));
     EXPECT_EQ(BornAgain::DistributionCosineType, distr2.getName());
 
@@ -389,7 +389,7 @@ TEST_F(DistributionsTest, DistributionCosineClone)
     std::unique_ptr<DistributionCosine> P_clone { P_distr_cosine->clone() };
     EXPECT_EQ(1.0, P_clone->getMean());
     EXPECT_EQ(1.0, P_clone->getSigma());
-    EXPECT_EQ(2.0/(2.0*M_PI), P_clone->probabilityDensity(1.0));
+    EXPECT_EQ(2.0/(M_TWOPI), P_clone->probabilityDensity(1.0));
     EXPECT_EQ(0, P_distr_cosine->probabilityDensity(100.0));
     EXPECT_EQ(BornAgain::DistributionCosineType, P_clone->getName());