Merge commit 'bundle/olesenm' into home

applications/solvers/combustion/dieselEngineFoam/createSpray.H

@@ -30,7 +30,7 @@ scalar gasMass0 = fvc::domainIntegrate(rho).value();
 
 if (dieselSpray.twoD())
 {
-    gasMass0 *= constant::math::twoPi/dieselSpray.angleOfWedge();
+    gasMass0 *= constant::mathematical::twoPi/dieselSpray.angleOfWedge();
 }
 
 gasMass0 -=

applications/solvers/combustion/dieselEngineFoam/dieselEngineFoam.C

@@ -43,7 +43,7 @@ Description
 #include "OFstream.H"
 #include "volPointInterpolation.H"
 #include "thermoPhysicsTypes.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

applications/solvers/combustion/dieselEngineFoam/spraySummary.H

@@ -20,7 +20,7 @@
 
     if (dieselSpray.twoD())
     {
-        gasMass *= constant::math::twoPi/dieselSpray.angleOfWedge();
+        gasMass *= constant::mathematical::twoPi/dieselSpray.angleOfWedge();
     }
 
     scalar addedMass = gasMass - gasMass0;

applications/solvers/combustion/dieselFoam/dieselFoam.C

@@ -41,7 +41,7 @@ Description
 #include "IFstream.H"
 #include "OFstream.H"
 #include "Switch.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

applications/solvers/combustion/engineFoam/engineFoam.C

@@ -58,7 +58,7 @@ Description
 #include "ignition.H"
 #include "Switch.H"
 #include "OFstream.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

applications/solvers/compressible/rhoCentralFoam/BCs/T/smoluchowskiJumpTFvPatchScalarField.C

@@ -28,7 +28,7 @@ License
 #include "addToRunTimeSelectionTable.H"
 #include "fvPatchFieldMapper.H"
 #include "volFields.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -182,7 +182,7 @@ void smoluchowskiJumpTFvPatchScalarField::updateCoeffs()
     }
 
     Field<scalar> C2 = pmu/prho
-        *sqrt(ppsi*constant::math::piByTwo)
+        *sqrt(ppsi*constant::mathematical::piByTwo)
         *2.0*gamma_/Pr.value()/(gamma_ + 1.0)
         *(2.0 - accommodationCoeff_)/accommodationCoeff_;
 

applications/solvers/compressible/rhoCentralFoam/BCs/U/maxwellSlipUFvPatchVectorField.C

@@ -28,7 +28,7 @@ Description
 
 #include "maxwellSlipUFvPatchVectorField.H"
 #include "addToRunTimeSelectionTable.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "fvPatchFieldMapper.H"
 #include "volFields.H"
 #include "surfaceFields.H"
@@ -147,7 +147,7 @@ void maxwellSlipUFvPatchVectorField::updateCoeffs()
     const fvPatchField<scalar>& ppsi =
         patch().lookupPatchField<volScalarField, scalar>("psi");
 
-    Field<scalar> C1 = sqrt(ppsi*constant::math::piByTwo)
+    Field<scalar> C1 = sqrt(ppsi*constant::mathematical::piByTwo)
         *(2.0 - accommodationCoeff_)/accommodationCoeff_;
 
     Field<scalar> pnu = pmu/prho;

applications/solvers/heatTransfer/buoyantSimpleFoam/pEqn.H

@@ -21,7 +21,7 @@
             fvm::laplacian(rhorUAf, p) == fvc::div(phi)
         );
 
-        pEqn.setReference(pRefCell, p[pRefCell]);
+        pEqn.setReference(pRefCell, pRefValue);
 
         // retain the residual from the first iteration
         if (nonOrth == 0)

applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/SchnerrSauer/SchnerrSauer.C

@@ -25,7 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "SchnerrSauer.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -77,7 +77,7 @@ Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer::rRb
 {
     return pow
     (
-        ((4*constant::math::pi*n_)/3)
+        ((4*constant::mathematical::pi*n_)/3)
        *limitedAlpha1/(1.0 + alphaNuc() - limitedAlpha1),
         1.0/3.0
     );
@@ -87,7 +87,7 @@ Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer::rRb
 Foam::dimensionedScalar
 Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer::alphaNuc() const
 {
-    dimensionedScalar Vnuc = n_*constant::math::pi*pow3(dNuc_)/6;
+    dimensionedScalar Vnuc = n_*constant::mathematical::pi*pow3(dNuc_)/6;
     return Vnuc/(1 + Vnuc);
 }
 

applications/solvers/multiphase/multiphaseInterFoam/multiphaseMixture/multiphaseMixture.C

@@ -29,12 +29,12 @@ License
 #include "Time.H"
 #include "subCycle.H"
 #include "fvCFD.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * Static Member Data  * * * * * * * * * * * * //
 
 const scalar Foam::multiphaseMixture::convertToRad =
-    Foam::constant::math::pi/180.0;
+    Foam::constant::mathematical::pi/180.0;
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/conductivityModel/Gidaspow/GidaspowConductivity.C

@@ -25,7 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "GidaspowConductivity.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -69,7 +69,7 @@ Foam::tmp<Foam::volScalarField> Foam::GidaspowConductivity::kappa
     const dimensionedScalar& e
 ) const
 {
-    const scalar sqrtPi = sqrt(constant::math::pi);
+    const scalar sqrtPi = sqrt(constant::mathematical::pi);
 
     return rhoa*da*sqrt(Theta)*
     (

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/conductivityModel/HrenyaSinclair/HrenyaSinclairConductivity.C

@@ -25,7 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "HrenyaSinclairConductivity.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -74,7 +74,7 @@ Foam::tmp<Foam::volScalarField> Foam::HrenyaSinclairConductivity::kappa
     const dimensionedScalar& e
 ) const
 {
-    const scalar sqrtPi = sqrt(constant::math::pi);
+    const scalar sqrtPi = sqrt(constant::mathematical::pi);
 
     volScalarField lamda =
         scalar(1) + da/(6.0*sqrt(2.0)*(alpha + scalar(1.0e-5)))/L_;

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/conductivityModel/Syamlal/SyamlalConductivity.C

@@ -25,7 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "SyamlalConductivity.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -69,7 +69,7 @@ Foam::tmp<Foam::volScalarField> Foam::SyamlalConductivity::kappa
     const dimensionedScalar& e
 ) const
 {
-    const scalar sqrtPi = sqrt(constant::math::pi);
+    const scalar sqrtPi = sqrt(constant::mathematical::pi);
 
     return rhoa*da*sqrt(Theta)*
     (

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.C

@@ -26,7 +26,7 @@ License
 
 #include "kineticTheoryModel.H"
 #include "surfaceInterpolate.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "fvCFD.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
@@ -204,7 +204,7 @@ void Foam::kineticTheoryModel::solve()
 
     volScalarField alpha = alpha_;
     alpha.max(1.0e-6);
-    const scalar sqrtPi = sqrt(constant::math::pi);
+    const scalar sqrtPi = sqrt(constant::mathematical::pi);
 
     surfaceScalarField phi = 1.5*rhoa_*phia_*fvc::interpolate(alpha_);
 

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/viscosityModel/Gidaspow/GidaspowViscosity.C

@@ -25,7 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "GidaspowViscosity.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -70,7 +70,7 @@ Foam::kineticTheoryModels::GidaspowViscosity::mua
     const dimensionedScalar& e
 ) const
 {
-    const scalar sqrtPi = sqrt(constant::math::pi);
+    const scalar sqrtPi = sqrt(constant::mathematical::pi);
 
     return rhoa*da*sqrt(Theta)*
     (

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/viscosityModel/HrenyaSinclair/HrenyaSinclairViscosity.C

@@ -25,7 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "HrenyaSinclairViscosity.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -77,7 +77,7 @@ Foam::kineticTheoryModels::HrenyaSinclairViscosity::mua
     const dimensionedScalar& e
 ) const
 {
-    const scalar sqrtPi = sqrt(constant::math::pi);
+    const scalar sqrtPi = sqrt(constant::mathematical::pi);
 
     volScalarField lamda =
         scalar(1) + da/(6.0*sqrt(2.0)*(alpha + scalar(1.0e-5)))/L_;

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/viscosityModel/Syamlal/SyamlalViscosity.C

@@ -25,7 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "SyamlalViscosity.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -69,7 +69,7 @@ Foam::tmp<Foam::volScalarField> Foam::kineticTheoryModels::SyamlalViscosity::mua
     const dimensionedScalar& e
 ) const
 {
-    const scalar sqrtPi = sqrt(constant::math::pi);
+    const scalar sqrtPi = sqrt(constant::mathematical::pi);
 
     return rhoa*da*sqrt(Theta)*
     (

applications/test/graphXi/graphXi.C

@@ -32,7 +32,7 @@ Description
 
 #include "graph.H"
 #include "OFstream.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 using namespace Foam;
 
@@ -50,7 +50,7 @@ int main()
 
     scalarField b = 0.5*(1.0 + erf(x));
     scalarField c = 1.0 - b;
-    scalarField gradb = (1/::sqrt(constant::math::pi))*exp(-sqr(x));
+    scalarField gradb = (1/::sqrt(constant::mathematical::pi))*exp(-sqr(x));
     scalarField lapb = -2*x*gradb;
 
     r = lapb*b*c/(gradb*gradb);

applications/utilities/mesh/advanced/collapseEdges/collapseEdges.C

@@ -47,7 +47,7 @@ Description
 #include "polyTopoChanger.H"
 #include "polyMesh.H"
 #include "mapPolyMesh.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "PackedBoolList.H"
 #include "SortableList.H"
 
@@ -467,7 +467,7 @@ int main(int argc, char *argv[])
     scalar angle(readScalar(IStringStream(args.additionalArgs()[1])()));
     bool overwrite = args.optionFound("overwrite");
 
-    scalar maxCos = Foam::cos(angle*180/constant::math::pi);
+    scalar maxCos = Foam::cos(angle*180/constant::mathematical::pi);
 
     Info<< "Merging:" << nl
         << "    edges with length less than " << minLen << " meters" << nl

applications/utilities/mesh/advanced/combinePatchFaces/combinePatchFaces.C

@@ -53,7 +53,7 @@ Description
 #include "removePoints.H"
 #include "polyMesh.H"
 #include "mapPolyMesh.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 using namespace Foam;
 
@@ -445,12 +445,12 @@ int main(int argc, char *argv[])
 
     scalar featureAngle(readScalar(IStringStream(args.additionalArgs()[0])()));
 
-    scalar minCos = Foam::cos(featureAngle*constant::math::pi/180.0);
+    scalar minCos = Foam::cos(degToRad(featureAngle));
 
     scalar concaveAngle = defaultConcaveAngle;
     args.optionReadIfPresent("concaveAngle", concaveAngle);
 
-    scalar concaveSin = Foam::sin(concaveAngle*constant::math::pi/180.0);
+    scalar concaveSin = Foam::sin(degToRad(concaveAngle));
 
     bool snapMeshDict = args.optionFound("snapMesh");
     bool overwrite = args.optionFound("overwrite");

applications/utilities/mesh/advanced/splitCells/splitCells.C

@@ -49,7 +49,7 @@ Description
 #include "cellSet.H"
 #include "cellModeller.H"
 #include "meshCutter.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "geomCellLooper.H"
 #include "plane.H"
 #include "edgeVertex.H"
@@ -539,9 +539,8 @@ int main(int argc, char *argv[])
 
     scalar featureAngle(readScalar(IStringStream(args.additionalArgs()[0])()));
 
-    scalar radAngle = featureAngle*constant::math::pi/180.0;
+    scalar minCos = Foam::cos(degToRad(featureAngle));
-    scalar minCos = Foam::cos(radAngle);
+    scalar minSin = Foam::sin(degToRad(featureAngle));
-    scalar minSin = Foam::sin(radAngle);
 
     bool readSet   = args.optionFound("set");
     bool geometry  = args.optionFound("geometry");

applications/utilities/mesh/conversion/kivaToFoam/kivaToFoam.C

@@ -43,7 +43,7 @@ Description
 #include "symmetryPolyPatch.H"
 #include "wedgePolyPatch.H"
 #include "cyclicPolyPatch.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 using namespace Foam;
 

applications/utilities/mesh/conversion/kivaToFoam/readKivaGrid.H

@@ -434,7 +434,7 @@ if (pFaces[WEDGE].size() && pFaces[WEDGE][0].size())
     {
         // Distribute the points to be +/- 2.5deg from the x-z plane
 
-        scalar tanTheta = Foam::tan(2.5*constant::math::pi/180.0);
+        scalar tanTheta = Foam::tan(degToRad(2.5));
 
         SLList<face>::iterator iterf = pFaces[WEDGE][0].begin();
         SLList<face>::iterator iterb = pFaces[WEDGE][1].begin();

applications/utilities/mesh/conversion/polyDualMesh/polyDualMeshApp.C

@@ -59,7 +59,7 @@ Usage
 #include "Time.H"
 #include "timeSelector.H"
 #include "fvMesh.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "polyTopoChange.H"
 #include "mapPolyMesh.H"
 #include "PackedBoolList.H"
@@ -91,7 +91,7 @@ void simpleMarkFeatures
     labelList& multiCellFeaturePoints
 )
 {
-    scalar minCos = Foam::cos(featureAngle*constant::math::pi/180.0);
+    scalar minCos = Foam::cos(degToRad(featureAngle));
 
     const polyBoundaryMesh& patches = mesh.boundaryMesh();
 
@@ -387,7 +387,7 @@ int main(int argc, char *argv[])
 
     scalar featureAngle(readScalar(IStringStream(args.additionalArgs()[0])()));
 
-    scalar minCos = Foam::cos(featureAngle*constant::math::pi/180.0);
+    scalar minCos = Foam::cos(degToRad(featureAngle));
 
     Info<< "Feature:" << featureAngle << endl
         << "minCos :" << minCos << endl

applications/utilities/mesh/conversion/starToFoam/createCoupleMatches.C

@@ -33,7 +33,7 @@ Description
 #include "IOmanip.H"
 #include "boundBox.H"
 #include "Map.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -99,7 +99,7 @@ void starMesh::createCoupleMatches()
                  << coupleI << ". STAR couple ID: "
                  << couples_[coupleI].coupleID() << endl
                  << "The angle between face normals is "
-                 << Foam::acos(faceAreaAngle)/constant::math::pi*180
+                 << radToDeg(Foam::acos(faceAreaAngle))
                  << " deg." << endl
                  << "master cell: " << fp.masterCell()
                  << " STAR number: " << starCellID_[fp.masterCell()]

applications/utilities/mesh/generation/extrudeMesh/extrudeModel/wedge/wedge.C

@@ -26,7 +26,7 @@ License
 
 #include "wedge.H"
 #include "addToRunTimeSelectionTable.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -51,8 +51,7 @@ wedge::wedge(const dictionary& dict)
     axis_(coeffDict_.lookup("axis")),
     angle_
     (
-        readScalar(coeffDict_.lookup("angle"))
+        degToRad(readScalar(coeffDict_.lookup("angle")))
-       *constant::math::pi/180.0
     )
 {}
 

applications/utilities/mesh/manipulation/autoPatch/autoPatch.C

@@ -33,7 +33,7 @@ Description
 #include "Time.H"
 #include "boundaryMesh.H"
 #include "repatchPolyTopoChanger.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "OFstream.H"
 #include "ListOps.H"
 
@@ -93,7 +93,7 @@ int main(int argc, char *argv[])
     scalar featureAngle(readScalar(IStringStream(args.additionalArgs()[0])()));
     bool overwrite = args.optionFound("overwrite");
 
-    scalar minCos = Foam::cos(featureAngle*constant::math::pi/180.0);
+    scalar minCos = Foam::cos(degToRad(featureAngle));
 
     Info<< "Feature:" << featureAngle << endl
         << "minCos :" << minCos << endl

applications/utilities/mesh/manipulation/transformPoints/transformPoints.C

@@ -67,10 +67,10 @@ Usage
 #include "transformField.H"
 #include "transformGeometricField.H"
 #include "IStringStream.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 using namespace Foam;
-using namespace Foam::constant::math;
+using namespace Foam::constant::mathematical;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

applications/utilities/preProcessing/engineSwirl/engineSwirl.C

@@ -31,7 +31,7 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "fvCFD.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -45,7 +45,7 @@ int main(int argc, char *argv[])
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-    scalar Vphi = (constant::math::pi*swirlRPMRatio*rpm/30).value();
+    scalar Vphi = (constant::mathematical::pi*swirlRPMRatio*rpm/30).value();
     scalar b1 = j1(swirlProfile).value();
     scalar b2 = 2.0*b1/swirlProfile.value() - j0(swirlProfile).value();
 

applications/utilities/surface/surfaceTransformPoints/surfaceTransformPoints.C

@@ -43,10 +43,10 @@ Description
 #include "transformField.H"
 #include "Pair.H"
 #include "quaternion.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 using namespace Foam;
-using namespace Foam::constant::math;
+using namespace Foam::constant::mathematical;
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/OpenFOAM/Make/files

@@ -1,6 +1,6 @@
 global/global.Cver
-global/dimensionedConstants/dimensionedConstants.C
+global/constants/constants.C
-global/dimensionedConstants/constants/constants.C
+global/constants/dimensionedConstants.C
 global/argList/argList.C
 global/clock/clock.C
 

src/OpenFOAM/global/constants/atomic/atomicConstants.C

@@ -24,7 +24,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "universalConstants.H"
 #include "electromagneticConstants.H"
 #include "atomicConstants.H"
@@ -83,7 +83,7 @@ const Foam::dimensionedScalar Foam::constant::atomic::a0
         (
             "a0",
             alpha
-           /(dimensionedScalar("C", dimless, 4.0*constant::math::pi)*Rinf)
+           /(dimensionedScalar("C", dimless, 4.0*constant::mathematical::pi)*Rinf)
         )
     )
 );
@@ -100,7 +100,7 @@ const Foam::dimensionedScalar Foam::constant::atomic::re
             "re",
             sqr(constant::electromagnetic::e)
            /(
-                dimensionedScalar("C", dimless, 4.0*constant::math::pi)
+                dimensionedScalar("C", dimless, 4.0*constant::mathematical::pi)
                *constant::electromagnetic::epsilon0
                *me
                *sqr(constant::universal::c)

src/OpenFOAM/global/constants/atomic/atomicConstants.H

@@ -23,7 +23,7 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Namespace
-    Foam::constant::atom
+    Foam::constant::atomic
 
 Description
     Atomic constants
@@ -68,7 +68,7 @@ namespace atomic
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace atomic
-} // end namespace constant
+} // End namespace constant
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/OpenFOAM/global/constants/constants.C

@@ -22,9 +22,6 @@ License
     along with OpenFOAM; if not, write to the Free Software Foundation,
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
-Description
-    Collection of dimensioned constants
-
 \*---------------------------------------------------------------------------*/
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/OpenFOAM/global/constants/constants.H

@@ -38,7 +38,7 @@ Description
 // Dimensionless coefficents
 
 // Mathematical constants
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 
 // Dimensioned constants

src/OpenFOAM/global/constants/dimensionedConstants.H

@@ -27,9 +27,10 @@ Global
 
 Description
     Dictionary reading and supplying the dimensioned constants used within
-    OpenFOAM particularly for thermodynamics.  The values are read from the
+    OpenFOAM, particularly for thermodynamics.
-    OpenFOAM controlDict and should be changed to run with a different set of
+
-    units from the default SI units.
+    The values are read from the OpenFOAM etc/controlDict and should be
+    changed to run with a different set of units from the default SI units.
 
 SourceFiles
     dimensionedConstants.C

src/OpenFOAM/global/constants/electromagnetic/electromagneticConstants.C

@@ -24,7 +24,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "universalConstants.H"
 #include "electromagneticConstants.H"
 #include "atomicConstants.H"
@@ -46,7 +46,7 @@ const Foam::dimensionedScalar Foam::constant::electromagnetic::mu0
         (
             "mu0",
             dimless,
-            4.0*constant::math::pi*1e-07
+            4.0*constant::mathematical::pi*1e-07
         )
     )
 );
@@ -92,7 +92,7 @@ const Foam::dimensionedScalar Foam::constant::electromagnetic::kappa
         dimensionedScalar
         (
             "kappa",
-            dimensionedScalar("C", dimless, 1.0/(4.0*constant::math::pi))
+            dimensionedScalar("C", dimless, 1.0/(4.0*constant::mathematical::pi))
            /epsilon0
         )
     )

src/OpenFOAM/global/constants/electromagnetic/electromagneticConstants.H

@@ -23,7 +23,7 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Namespace
-    Foam::constant::em
+    Foam::constant::electromagnetic
 
 Description
     Electromagnetic constants
@@ -77,7 +77,7 @@ namespace electromagnetic
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace electromagnetic
-} // end namespace constant
+} // End namespace constant
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/OpenFOAM/global/constants/math/mathematicalConstants.H

@@ -23,15 +23,15 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Namespace
-    Foam::constant::math
+    Foam::constant::mathematical
 
 Description
-    mathematical constants
+    mathematical constants and conversion functions
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef mathConstants_H
+#ifndef mathematicalConstants_H
-#define mathConstants_H
+#define mathematicalConstants_H
 
 #include "scalar.H"
 
@@ -41,12 +41,12 @@ namespace Foam
 {
 namespace constant
 {
-namespace math
+namespace mathematical
 {
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-    static word group = "math";
+    static word group = "mathematical";
 
     const scalar e(M_E);
     const scalar pi(M_PI);
@@ -55,8 +55,21 @@ namespace math
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace math
+} // End namespace mathematical
-} // end namespace constant
+} // End namespace constant
+
+    //- Conversion from degrees to radians
+    inline scalar degToRad(const scalar& deg)
+    {
+        return (deg * constant::mathematical::pi/180.0);
+    }
+
+    //- Conversion from radians to degrees
+    inline scalar radToDeg(const scalar& rad)
+    {
+        return (rad * 180.0/constant::mathematical::pi);
+    }
+
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -64,6 +77,3 @@ namespace math
 #endif
 
 // ************************************************************************* //
-
-
-

src/OpenFOAM/global/constants/physicoChemical/physicoChemicalConstants.C

@@ -24,7 +24,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "universalConstants.H"
 #include "electromagneticConstants.H"
 #include "physicoChemicalConstants.H"
@@ -75,7 +75,7 @@ const Foam::dimensionedScalar Foam::constant::physicoChemical::sigma
         dimensionedScalar
         (
             "sigma",
-            dimensionedScalar("C", dimless, sqr(constant::math::pi)/60.0)
+            dimensionedScalar("C", dimless, sqr(constant::mathematical::pi)/60.0)
            *pow4(k)/(pow3(constant::universal::hr)*sqr(constant::universal::c))
         )
     )
@@ -107,7 +107,7 @@ const Foam::dimensionedScalar Foam::constant::physicoChemical::c1
         dimensionedScalar
         (
             "c1",
-            dimensionedScalar("C", dimless, constant::math::twoPi)
+            dimensionedScalar("C", dimless, constant::mathematical::twoPi)
            *constant::universal::h*sqr(constant::universal::c)
         )
     )

src/OpenFOAM/global/constants/physicoChemical/physicoChemicalConstants.H

@@ -23,7 +23,7 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Namespace
-    Foam::constant::phys
+    Foam::constant::physicoChemical
 
 Description
     Physico-chemical constants
@@ -71,7 +71,7 @@ namespace physicoChemical
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace physicoChemical
-} // end namespace constant
+} // End namespace constant
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/OpenFOAM/global/constants/universal/universalConstants.C

@@ -25,7 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "universalConstants.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 #include "dimensionedConstants.H"
 
@@ -43,7 +43,7 @@ const Foam::dimensionedScalar Foam::constant::universal::hr
         dimensionedScalar
         (
             "hr",
-            h/(dimensionedScalar("C", dimless, constant::math::twoPi))
+            h/(dimensionedScalar("C", dimless, constant::mathematical::twoPi))
         )
     )
 );

src/OpenFOAM/global/constants/universal/universalConstants.H

@@ -23,7 +23,7 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Namespace
-    Foam::constant::uni
+    Foam::constant::universal
 
 Description
     Universal constants

src/OpenFOAM/meshes/meshShapes/face/face.C

@@ -27,7 +27,7 @@ License
 #include "face.H"
 #include "triFace.H"
 #include "triPointRef.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -99,13 +99,13 @@ Foam::label Foam::face::mostConcaveAngle
         if ((edgeNormal & n) > 0)
         {
             // Concave angle.
-            angle = constant::math::pi + edgeAngle;
+            angle = constant::mathematical::pi + edgeAngle;
         }
         else
         {
             // Convex angle. Note '-' to take into account that rightEdge
             // and leftEdge are head-to-tail connected.
-            angle = constant::math::pi - edgeAngle;
+            angle = constant::mathematical::pi - edgeAngle;
         }
 
         if (angle > maxAngle)
@@ -214,7 +214,7 @@ Foam::label Foam::face::split
         label index = fcIndex(fcIndex(startIndex));
 
         label minIndex = index;
-        scalar minDiff = constant::math::pi;
+        scalar minDiff = constant::mathematical::pi;
 
         for(label i = 0; i < size() - 3; i++)
         {

src/OpenFOAM/meshes/meshShapes/face/faceIntersection.C

@@ -159,9 +159,9 @@ Foam::pointHit Foam::face::intersection
 
         if (curHit.hit())
         {
-            if (Foam::mag(curHit.distance()) < nearestHitDist)
+            if (Foam::mag(curHit.distance()) < Foam::mag(nearestHitDist))
             {
-                nearestHitDist = Foam::mag(curHit.distance());
+                nearestHitDist = curHit.distance();
                 nearest.setHit();
                 nearest.setPoint(curHit.hitPoint());
             }

src/OpenFOAM/meshes/primitiveMesh/primitiveMeshCheck/primitiveMeshCheck.C

@@ -27,7 +27,7 @@ License
 #include "primitiveMesh.H"
 #include "pyramidPointFaceRef.H"
 #include "ListOps.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "SortableList.H"
 
 
@@ -410,7 +410,7 @@ bool Foam::primitiveMesh::checkFaceOrthogonality
 
     // Severe nonorthogonality threshold
     const scalar severeNonorthogonalityThreshold =
-        ::cos(nonOrthThreshold_/180.0*constant::math::pi);
+        ::cos(degToRad(nonOrthThreshold_));
 
     scalar minDDotS = GREAT;
 
@@ -472,9 +472,8 @@ bool Foam::primitiveMesh::checkFaceOrthogonality
             if (debug || report)
             {
                 Info<< "    Mesh non-orthogonality Max: "
-                    << ::acos(minDDotS)/constant::math::pi*180.0
+                    << radToDeg(::acos(minDDotS))
-                    << " average: " <<
+                    << " average: " << radToDeg(::acos(sumDDotS/neiSize))
-                    ::acos(sumDDotS/neiSize)/constant::math::pi*180.0
                     << endl;
             }
         }
@@ -839,7 +838,7 @@ bool Foam::primitiveMesh::checkFaceAngles
             << exit(FatalError);
     }
 
-    const scalar maxSin = Foam::sin(maxDeg/180.0*constant::math::pi);
+    const scalar maxSin = Foam::sin(degToRad(maxDeg));
 
     const pointField& p = points();
     const faceList& fcs = faces();
@@ -915,8 +914,7 @@ bool Foam::primitiveMesh::checkFaceAngles
     if (nConcave > 0)
     {
         scalar maxConcaveDegr =
-            Foam::asin(Foam::min(1.0, maxEdgeSin))
+            radToDeg(Foam::asin(Foam::min(1.0, maxEdgeSin)));
-           *180.0/constant::math::pi;
 
         if (debug || report)
         {

src/OpenFOAM/meshes/primitiveMesh/primitiveMeshCheck/primitiveMeshCheckMotion.C

@@ -31,7 +31,7 @@ Description
 #include "primitiveMesh.H"
 #include "pyramidPointFaceRef.H"
 #include "cell.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -200,7 +200,7 @@ bool Foam::primitiveMesh::checkMeshMotion
                 )   << "Severe non-orthogonality in mesh motion for face "
                     << faceI
                     << " between cells " << own[faceI] << " and " << nei[faceI]
-                    << ": Angle = " << ::acos(dDotS)/constant::math::pi*180.0
+                    << ": Angle = " << radToDeg(::acos(dDotS))
                     << " deg." << endl;
 
                 nDotProductErrors++;

src/OpenFOAM/meshes/primitiveShapes/triangle/triangleI.H

@@ -26,7 +26,7 @@ License
 
 #include "IOstreams.H"
 #include "pointHit.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -307,7 +307,7 @@ inline scalar triangle<Point, PointRef>::quality() const
     return
         mag()
       / (
-            constant::math::pi
+            constant::mathematical::pi
            *Foam::sqr(circumRadius())
            *0.413497
           + VSMALL

src/OpenFOAM/primitives/Tensor/tensor/tensor.C

@@ -25,7 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "tensor.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -150,8 +150,8 @@ vector eigenValues(const tensor& t)
                 scalar aBy3 = a/3;
 
                 i = m2SqrtQ*cos(theta/3) - aBy3;
-                ii = m2SqrtQ*cos((theta + constant::math::twoPi)/3) - aBy3;
+                ii = m2SqrtQ*cos((theta + constant::mathematical::twoPi)/3) - aBy3;
-                iii = m2SqrtQ*cos((theta - constant::math::twoPi)/3) - aBy3;
+                iii = m2SqrtQ*cos((theta - constant::mathematical::twoPi)/3) - aBy3;
             }
             else
             {
@@ -343,8 +343,8 @@ vector eigenValues(const symmTensor& t)
                 scalar aBy3 = a/3;
 
                 i = m2SqrtQ*cos(theta/3) - aBy3;
-                ii = m2SqrtQ*cos((theta + constant::math::twoPi)/3) - aBy3;
+                ii = m2SqrtQ*cos((theta + constant::mathematical::twoPi)/3) - aBy3;
-                iii = m2SqrtQ*cos((theta - constant::math::twoPi)/3) - aBy3;
+                iii = m2SqrtQ*cos((theta - constant::mathematical::twoPi)/3) - aBy3;
             }
             else
             {

src/OpenFOAM/primitives/transform/transform.H

@@ -34,7 +34,7 @@ Description
 #define transform_H
 
 #include "tensor.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -205,11 +205,11 @@ inline scalar pseudoAngle
 
     if (sin < -SMALL)
     {
-        return (3.0 + cos)*constant::math::piByTwo;
+        return (3.0 + cos)*constant::mathematical::piByTwo;
     }
     else
     {
-        return (1.0 - cos)*constant::math::piByTwo;
+        return (1.0 - cos)*constant::mathematical::piByTwo;
     }
 }
 

src/dynamicFvMesh/Make/files

@@ -10,9 +10,11 @@ solidBodyMotionFunctions = solidBodyMotionFvMesh/solidBodyMotionFunctions
 $(solidBodyMotionFunctions)/solidBodyMotionFunction/solidBodyMotionFunction.C
 $(solidBodyMotionFunctions)/solidBodyMotionFunction/newSolidBodyMotionFunction.C
 $(solidBodyMotionFunctions)/SDA/SDA.C
-$(solidBodyMotionFunctions)/SKA/SKA.C
+$(solidBodyMotionFunctions)/tabulated6DoFMotion/tabulated6DoFMotion.C
 $(solidBodyMotionFunctions)/linearMotion/linearMotion.C
-$(solidBodyMotionFunctions)/rotationMotion/rotationMotion.C
+$(solidBodyMotionFunctions)/rotatingMotion/rotatingMotion.C
 $(solidBodyMotionFunctions)/multiMotion/multiMotion.C
+$(solidBodyMotionFunctions)/oscillatingLinearMotion/oscillatingLinearMotion.C
+$(solidBodyMotionFunctions)/oscillatingRotatingMotion/oscillatingRotatingMotion.C
 
 LIB = $(FOAM_LIBBIN)/libdynamicFvMesh

src/dynamicFvMesh/dynamicInkJetFvMesh/dynamicInkJetFvMesh.C

@@ -27,7 +27,7 @@ License
 #include "dynamicInkJetFvMesh.H"
 #include "addToRunTimeSelectionTable.H"
 #include "volFields.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -90,7 +90,7 @@ Foam::dynamicInkJetFvMesh::~dynamicInkJetFvMesh()
 bool Foam::dynamicInkJetFvMesh::update()
 {
     scalar scalingFunction =
-        0.5*(::cos(constant::math::twoPi*frequency_*time().value()) - 1.0);
+        0.5*(::cos(constant::mathematical::twoPi*frequency_*time().value()) - 1.0);
 
     Info<< "Mesh scaling. Time = " << time().value() << " scaling: "
         << scalingFunction << endl;

src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFunctions/SDA/SDA.C

@@ -26,9 +26,9 @@ License
 
 #include "SDA.H"
 #include "addToRunTimeSelectionTable.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
-using namespace Foam::constant::math;
+using namespace Foam::constant::mathematical;
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 

src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFunctions/oscillatingLinearMotion/oscillatingLinearMotion.C

@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "oscillatingLinearMotion.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace solidBodyMotionFunctions
+{
+    defineTypeNameAndDebug(oscillatingLinearMotion, 0);
+    addToRunTimeSelectionTable
+    (
+        solidBodyMotionFunction,
+        oscillatingLinearMotion,
+        dictionary
+    );
+};
+};
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::solidBodyMotionFunctions::oscillatingLinearMotion::oscillatingLinearMotion
+(
+    const dictionary& SBMFCoeffs,
+    const Time& runTime
+)
+:
+    solidBodyMotionFunction(SBMFCoeffs, runTime)
+{
+    read(SBMFCoeffs);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
+
+Foam::solidBodyMotionFunctions::oscillatingLinearMotion::~oscillatingLinearMotion()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+Foam::septernion
+Foam::solidBodyMotionFunctions::oscillatingLinearMotion::transformation() const
+{
+    scalar t = time_.value();
+
+    const vector displacement = amplitude_*sin(omega_*t);
+
+    quaternion R(0, 0, 0);
+    septernion TR(septernion(displacement)*R);
+
+    Info<< "solidBodyMotionFunctions::oscillatingLinearMotion::transformation(): "
+        << "Time = " << t << " transformation: " << TR << endl;
+
+    return TR;
+}
+
+
+bool Foam::solidBodyMotionFunctions::oscillatingLinearMotion::read
+(
+    const dictionary& SBMFCoeffs
+)
+{
+    solidBodyMotionFunction::read(SBMFCoeffs);
+
+    SBMFCoeffs_.lookup("amplitude") >> amplitude_;
+    SBMFCoeffs_.lookup("omega") >> omega_;
+
+    return true;
+}
+
+// ************************************************************************* //

src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFunctions/oscillatingLinearMotion/oscillatingLinearMotion.H

@@ -0,0 +1,116 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::solidBodyMotionFunctions::oscillatingLinearMotion
+
+Description
+    SolidBodyMotionFvMesh 6DoF motion function. Oscillating displacement.
+
+SourceFiles
+    oscillatingLinearMotion.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef oscillatingLinearMotion_H
+#define oscillatingLinearMotion_H
+
+#include "solidBodyMotionFunction.H"
+#include "primitiveFields.H"
+#include "point.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace solidBodyMotionFunctions
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class oscillatingLinearMotion Declaration
+\*---------------------------------------------------------------------------*/
+
+class oscillatingLinearMotion
+:
+    public solidBodyMotionFunction
+{
+    // Private data
+
+        //- Amplitude
+        vector amplitude_;
+
+        //- Radial velocity
+        scalar omega_;
+
+
+    // Private Member Functions
+
+        //- Disallow copy construct
+        oscillatingLinearMotion(const oscillatingLinearMotion&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const oscillatingLinearMotion&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("oscillatingLinearMotion");
+
+
+    // Constructors
+
+        //- Construct from components
+        oscillatingLinearMotion
+        (
+            const dictionary& SBMFCoeffs,
+            const Time& runTime
+        );
+
+
+    // Destructor
+
+        virtual ~oscillatingLinearMotion();
+
+
+    // Member Functions
+
+        //- Return the solid-body motion transformation septernion
+        virtual septernion transformation() const;
+
+        //- Update properties from given dictionary
+        virtual bool read(const dictionary& SBMFCoeffs);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace solidBodyMotionFunctions
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFunctions/oscillatingRotatingMotion/oscillatingRotatingMotion.C

@@ -0,0 +1,106 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "oscillatingRotatingMotion.H"
+#include "addToRunTimeSelectionTable.H"
+#include "mathematicalConstants.H"
+
+using namespace Foam::constant::mathematical;
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace solidBodyMotionFunctions
+{
+    defineTypeNameAndDebug(oscillatingRotatingMotion, 0);
+    addToRunTimeSelectionTable
+    (
+        solidBodyMotionFunction,
+        oscillatingRotatingMotion,
+        dictionary
+    );
+};
+};
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::solidBodyMotionFunctions::oscillatingRotatingMotion::oscillatingRotatingMotion
+(
+    const dictionary& SBMFCoeffs,
+    const Time& runTime
+)
+:
+    solidBodyMotionFunction(SBMFCoeffs, runTime)
+{
+    read(SBMFCoeffs);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
+
+Foam::solidBodyMotionFunctions::oscillatingRotatingMotion::~oscillatingRotatingMotion()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+Foam::septernion
+Foam::solidBodyMotionFunctions::oscillatingRotatingMotion::transformation() const
+{
+    scalar t = time_.value();
+
+    vector eulerAngles = amplitude_*sin(omega_*t);
+
+    // Convert the rotational motion from deg to rad
+    eulerAngles *= pi/180.0;
+
+    quaternion R(eulerAngles.x(), eulerAngles.y(), eulerAngles.z());
+    septernion TR(septernion(CofG_)*R*septernion(-CofG_));
+
+    Info<< "solidBodyMotionFunctions::oscillatingRotatingMotion::transformation(): "
+        << "Time = " << t << " transformation: " << TR << endl;
+
+    return TR;
+}
+
+
+bool Foam::solidBodyMotionFunctions::oscillatingRotatingMotion::read
+(
+    const dictionary& SBMFCoeffs
+)
+{
+    solidBodyMotionFunction::read(SBMFCoeffs);
+
+    SBMFCoeffs_.lookup("CofG") >> CofG_;
+    SBMFCoeffs_.lookup("amplitude") >> amplitude_;
+    SBMFCoeffs_.lookup("omega") >> omega_;
+
+    return true;
+}
+
+// ************************************************************************* //

src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFunctions/oscillatingRotatingMotion/oscillatingRotatingMotion.H

@@ -0,0 +1,119 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::solidBodyMotionFunctions::oscillatingRotatingMotion
+
+Description
+    SolidBodyMotionFvMesh 6DoF motion function. Oscillating rotation.
+
+SourceFiles
+    oscillatingRotatingMotion.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef oscillatingRotatingMotion_H
+#define oscillatingRotatingMotion_H
+
+#include "solidBodyMotionFunction.H"
+#include "primitiveFields.H"
+#include "point.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace solidBodyMotionFunctions
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class oscillatingRotatingMotion Declaration
+\*---------------------------------------------------------------------------*/
+
+class oscillatingRotatingMotion
+:
+    public solidBodyMotionFunction
+{
+    // Private data
+
+        //- Centre of gravity
+        point CofG_;
+
+        //- Amplitude
+        vector amplitude_;
+
+        //- Radial velocity
+        scalar omega_;
+
+
+    // Private Member Functions
+
+        //- Disallow copy construct
+        oscillatingRotatingMotion(const oscillatingRotatingMotion&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const oscillatingRotatingMotion&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("oscillatingRotatingMotion");
+
+
+    // Constructors
+
+        //- Construct from components
+        oscillatingRotatingMotion
+        (
+            const dictionary& SBMFCoeffs,
+            const Time& runTime
+        );
+
+
+    // Destructor
+
+        virtual ~oscillatingRotatingMotion();
+
+
+    // Member Functions
+
+        //- Return the solid-body motion transformation septernion
+        virtual septernion transformation() const;
+
+        //- Update properties from given dictionary
+        virtual bool read(const dictionary& SBMFCoeffs);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace solidBodyMotionFunctions
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFunctions/rotatingMotion/rotatingMotion.C

@@ -24,11 +24,11 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "rotationMotion.H"
+#include "rotatingMotion.H"
 #include "addToRunTimeSelectionTable.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
-using namespace Foam::constant::math;
+using namespace Foam::constant::mathematical;
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -36,11 +36,11 @@ namespace Foam
 {
 namespace solidBodyMotionFunctions
 {
-    defineTypeNameAndDebug(rotationMotion, 0);
+    defineTypeNameAndDebug(rotatingMotion, 0);
     addToRunTimeSelectionTable
     (
         solidBodyMotionFunction,
-        rotationMotion,
+        rotatingMotion,
         dictionary
     );
 };
@@ -49,7 +49,7 @@ namespace solidBodyMotionFunctions
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::solidBodyMotionFunctions::rotationMotion::rotationMotion
+Foam::solidBodyMotionFunctions::rotatingMotion::rotatingMotion
 (
     const dictionary& SBMFCoeffs,
     const Time& runTime
@@ -63,14 +63,14 @@ Foam::solidBodyMotionFunctions::rotationMotion::rotationMotion
 
 // * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
 
-Foam::solidBodyMotionFunctions::rotationMotion::~rotationMotion()
+Foam::solidBodyMotionFunctions::rotatingMotion::~rotatingMotion()
 {}
 
 
 // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 
 Foam::septernion
-Foam::solidBodyMotionFunctions::rotationMotion::transformation() const
+Foam::solidBodyMotionFunctions::rotatingMotion::transformation() const
 {
     scalar t = time_.value();
 
@@ -85,14 +85,14 @@ Foam::solidBodyMotionFunctions::rotationMotion::transformation() const
     quaternion R(eulerAngles.x(), eulerAngles.y(), eulerAngles.z());
     septernion TR(septernion(CofG_)*R*septernion(-CofG_));
 
-    Info<< "solidBodyMotionFunctions::rotationMotion::transformation(): "
+    Info<< "solidBodyMotionFunctions::rotatingMotion::transformation(): "
         << "Time = " << t << " transformation: " << TR << endl;
 
     return TR;
 }
 
 
-bool Foam::solidBodyMotionFunctions::rotationMotion::read
+bool Foam::solidBodyMotionFunctions::rotatingMotion::read
 (
     const dictionary& SBMFCoeffs
 )

src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFunctions/rotatingMotion/rotatingMotion.H

@@ -23,19 +23,19 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::solidBodyMotionFunctions::rotationMotion
+    Foam::solidBodyMotionFunctions::rotatingMotion
 
 Description
     SolidBodyMotionFvMesh 6DoF motion function. Constant
     velocity rotation around CoG.
 
 SourceFiles
-    rotationMotion.C
+    rotatingMotion.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef rotationMotion_H
+#ifndef rotatingMotion_H
-#define rotationMotion_H
+#define rotatingMotion_H
 
 #include "solidBodyMotionFunction.H"
 #include "primitiveFields.H"
@@ -49,10 +49,10 @@ namespace solidBodyMotionFunctions
 {
 
 /*---------------------------------------------------------------------------*\
-                          Class rotationMotion Declaration
+                          Class rotatingMotion Declaration
 \*---------------------------------------------------------------------------*/
 
-class rotationMotion
+class rotatingMotion
 :
     public solidBodyMotionFunction
 {
@@ -68,22 +68,22 @@ class rotationMotion
     // Private Member Functions
 
         //- Disallow copy construct
-        rotationMotion(const rotationMotion&);
+        rotatingMotion(const rotatingMotion&);
 
         //- Disallow default bitwise assignment
-        void operator=(const rotationMotion&);
+        void operator=(const rotatingMotion&);
 
 
 public:
 
     //- Runtime type information
-    TypeName("rotationMotion");
+    TypeName("rotatingMotion");
 
 
     // Constructors
 
         //- Construct from components
-        rotationMotion
+        rotatingMotion
         (
             const dictionary& SBMFCoeffs,
             const Time& runTime
@@ -92,7 +92,7 @@ public:
 
     // Destructor
 
-        virtual ~rotationMotion();
+        virtual ~rotatingMotion();
 
 
     // Member Functions

src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFunctions/tabulated6DoFMotion/tabulated6DoFMotion.C

@@ -24,14 +24,14 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "SKA.H"
+#include "tabulated6DoFMotion.H"
 #include "addToRunTimeSelectionTable.H"
 #include "Tuple2.H"
 #include "IFstream.H"
 #include "interpolateXY.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
-using namespace Foam::constant::math;
+using namespace Foam::constant::mathematical;
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -39,15 +39,20 @@ namespace Foam
 {
 namespace solidBodyMotionFunctions
 {
-    defineTypeNameAndDebug(SKA, 0);
+    defineTypeNameAndDebug(tabulated6DoFMotion, 0);
-    addToRunTimeSelectionTable(solidBodyMotionFunction, SKA, dictionary);
+    addToRunTimeSelectionTable
+    (
+        solidBodyMotionFunction,
+        tabulated6DoFMotion,
+        dictionary
+    );
 };
 };
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::solidBodyMotionFunctions::SKA::SKA
+Foam::solidBodyMotionFunctions::tabulated6DoFMotion::tabulated6DoFMotion
 (
     const dictionary& SBMFCoeffs,
     const Time& runTime
@@ -61,13 +66,14 @@ Foam::solidBodyMotionFunctions::SKA::SKA
 
 // * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
 
-Foam::solidBodyMotionFunctions::SKA::~SKA()
+Foam::solidBodyMotionFunctions::tabulated6DoFMotion::~tabulated6DoFMotion()
 {}
 
 
 // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 
-Foam::septernion Foam::solidBodyMotionFunctions::SKA::transformation() const
+Foam::septernion
+Foam::solidBodyMotionFunctions::tabulated6DoFMotion::transformation() const
 {
     scalar t = time_.value();
 
@@ -75,7 +81,7 @@ Foam::septernion Foam::solidBodyMotionFunctions::SKA::transformation() const
     {
         FatalErrorIn
         (
-            "solidBodyMotionFunctions::SKA::transformation()"
+            "solidBodyMotionFunctions::tabulated6DoFMotion::transformation()"
         )   << "current time (" << t
             << ") is less than the minimum in the data table ("
             << times_[0] << ')'
@@ -86,7 +92,7 @@ Foam::septernion Foam::solidBodyMotionFunctions::SKA::transformation() const
     {
         FatalErrorIn
         (
-            "solidBodyMotionFunctions::SKA::transformation()"
+            "solidBodyMotionFunctions::tabulated6DoFMotion::transformation()"
         )   << "current time (" << t
             << ") is greater than the maximum in the data table ("
             << times_[times_.size()-1] << ')'
@@ -106,14 +112,17 @@ Foam::septernion Foam::solidBodyMotionFunctions::SKA::transformation() const
     quaternion R(TRV[1].x(), TRV[1].y(), TRV[1].z());
     septernion TR(septernion(CofG_ + TRV[0])*R*septernion(-CofG_));
 
-    Info<< "solidBodyMotionFunctions::SKA::transformation(): "
+    Info<< "solidBodyMotionFunctions::tabulated6DoFMotion::transformation(): "
         << "Time = " << t << " transformation: " << TR << endl;
 
     return TR;
 }
 
 
-bool Foam::solidBodyMotionFunctions::SKA::read(const dictionary& SBMFCoeffs)
+bool Foam::solidBodyMotionFunctions::tabulated6DoFMotion::read
+(
+    const dictionary& SBMFCoeffs
+)
 {
     solidBodyMotionFunction::read(SBMFCoeffs);
 
@@ -147,7 +156,8 @@ bool Foam::solidBodyMotionFunctions::SKA::read(const dictionary& SBMFCoeffs)
         {
             FatalErrorIn
             (
-                "solidBodyMotionFunctions::SKA::read(const dictionary&)"
+                "solidBodyMotionFunctions::tabulated6DoFMotion::read"
+                "(const dictionary&)"
             )   << "Cannot open time data file " << timeDataFileName_
                 << exit(FatalError);
         }

src/dynamicFvMesh/solidBodyMotionFvMesh/solidBodyMotionFunctions/tabulated6DoFMotion/tabulated6DoFMotion.H

@@ -23,25 +23,22 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::solidBodyMotionFunctions::SKA
+    Foam::solidBodyMotionFunctions::tabulated6DoFMotion
 
 Description
-    Sea Keeping Analysis (SKA) 6DoF motion function.
+    Tabulated 6DoF motion function.
 
     Obtained by interpolating tabulated data for surge (x-translation),
     sway (y-translation), heave (z-translation), roll (rotation about x),
     pitch (rotation about y) and yaw (rotation about z).
 
-See Also
-    SDA (Ship design analysis) for 3DoF motion.
-
 SourceFiles
-    SKA.C
+    tabulated6DoFMotion.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef SKA_H
+#ifndef tabulated6DoFMotion_H
-#define SKA_H
+#define tabulated6DoFMotion_H
 
 #include "solidBodyMotionFunction.H"
 #include "primitiveFields.H"
@@ -55,10 +52,10 @@ namespace solidBodyMotionFunctions
 {
 
 /*---------------------------------------------------------------------------*\
-                          Class SKA Declaration
+                          Class tabulated6DoFMotion Declaration
 \*---------------------------------------------------------------------------*/
 
-class SKA
+class tabulated6DoFMotion
 :
     public solidBodyMotionFunction
 {
@@ -83,22 +80,22 @@ class SKA
     // Private Member Functions
 
         //- Disallow copy construct
-        SKA(const SKA&);
+        tabulated6DoFMotion(const tabulated6DoFMotion&);
 
         //- Disallow default bitwise assignment
-        void operator=(const SKA&);
+        void operator=(const tabulated6DoFMotion&);
 
 
 public:
 
     //- Runtime type information
-    TypeName("SKA");
+    TypeName("tabulated6DoFMotion");
 
 
     // Constructors
 
         //- Construct from components
-        SKA
+        tabulated6DoFMotion
         (
             const dictionary& SBMFCoeffs,
             const Time& runTime
@@ -107,7 +104,7 @@ public:
 
     // Destructor
 
-        virtual ~SKA();
+        virtual ~tabulated6DoFMotion();
 
 
     // Member Functions

src/dynamicMesh/meshCut/cellLooper/topoCellLooper.C

@@ -27,7 +27,7 @@ License
 #include "topoCellLooper.H"
 #include "cellFeatures.H"
 #include "polyMesh.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "DynamicList.H"
 #include "ListOps.H"
 #include "meshTools.H"
@@ -44,8 +44,7 @@ namespace Foam
 }
 
 // Angle for polys to be considered splitHexes.
-const Foam::scalar Foam::topoCellLooper::featureCos =
+const Foam::scalar Foam::topoCellLooper::featureCos = Foam::cos(degToRad(10.0));
-    Foam::cos(10.0*constant::math::pi/180.0);
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //

src/dynamicMesh/meshCut/meshModifiers/undoableMeshCutter/undoableMeshCutter.C

@@ -32,7 +32,7 @@ License
 #include "cellCuts.H"
 #include "splitCell.H"
 #include "mapPolyMesh.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "meshTools.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -192,7 +192,7 @@ Foam::undoableMeshCutter::undoableMeshCutter
     faceRemover_
     (
         mesh,
-        Foam::cos(30.0/180.0*constant::math::pi)
+        Foam::cos(degToRad(30.0))
     )
 {}
 

src/dynamicMesh/motionSmoother/polyMeshGeometry/polyMeshGeometry.C

@@ -27,7 +27,7 @@ License
 #include "polyMeshGeometry.H"
 #include "pyramidPointFaceRef.H"
 #include "syncTools.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 namespace Foam
 {
@@ -248,7 +248,7 @@ Foam::scalar Foam::polyMeshGeometry::checkNonOrtho
                     << " between cells " << mesh.faceOwner()[faceI]
                     << " and " << nei
                     << ": Angle = "
-                    << ::acos(dDotS)/constant::math::pi*180.0
+                    << radToDeg(::acos(dDotS))
                     << " deg." << endl;
             }
 
@@ -269,7 +269,7 @@ Foam::scalar Foam::polyMeshGeometry::checkNonOrtho
                     << " between cells " << mesh.faceOwner()[faceI]
                     << " and " << nei
                     << ": Angle = "
-                    << ::acos(dDotS)/constant::math::pi*180.0
+                    << radToDeg(::acos(dDotS))
                     << " deg." << endl;
             }
 
@@ -368,8 +368,7 @@ bool Foam::polyMeshGeometry::checkFaceDotProduct
     const polyBoundaryMesh& patches = mesh.boundaryMesh();
 
     // Severe nonorthogonality threshold
-    const scalar severeNonorthogonalityThreshold =
+    const scalar severeNonorthogonalityThreshold = ::cos(degToRad(orthWarn));
-        ::cos(orthWarn/180.0*constant::math::pi);
 
 
     // Calculate coupled cell centre
@@ -504,9 +503,8 @@ bool Foam::polyMeshGeometry::checkFaceDotProduct
         if (nDDotS > 0)
         {
             Info<< "Mesh non-orthogonality Max: "
-                << ::acos(minDDotS)/constant::math::pi*180.0
+                << radToDeg(::acos(minDDotS))
-                << " average: " <<
+                << " average: " << radToDeg(::acos(sumDDotS/nDDotS))
-                   ::acos(sumDDotS/nDDotS)/constant::math::pi*180.0
                 << endl;
         }
     }
@@ -1258,7 +1256,7 @@ bool Foam::polyMeshGeometry::checkFaceAngles
             << abort(FatalError);
     }
 
-    const scalar maxSin = Foam::sin(maxDeg/180.0*constant::math::pi);
+    const scalar maxSin = Foam::sin(degToRad(maxDeg));
 
     const faceList& fcs = mesh.faces();
 
@@ -1338,8 +1336,7 @@ bool Foam::polyMeshGeometry::checkFaceAngles
         if (maxEdgeSin > SMALL)
         {
             scalar maxConcaveDegr =
-                Foam::asin(Foam::min(1.0, maxEdgeSin))
+                radToDeg(Foam::asin(Foam::min(1.0, maxEdgeSin)));
-              *180.0/constant::math::pi;
 
             Info<< "There are " << nConcave
                 << " faces with concave angles between consecutive"

src/engine/engineTime/engineTime.C

@@ -25,7 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "engineTime.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
@@ -123,12 +123,6 @@ bool Foam::engineTime::read()
 }
 
 
-Foam::scalar Foam::engineTime::degToRad(const scalar deg) const
-{
-    return constant::math::pi*deg/180.0;
-}
-
-
 Foam::scalar Foam::engineTime::degToTime(const scalar theta) const
 {
     // 6 * rpm => deg/s

src/engine/engineTime/engineTime.H

@@ -121,9 +121,6 @@ public:
 
         // Conversion
 
-            //- Convert degrees to radians
-            scalar degToRad(const scalar rad) const;
-
             //- Convert degrees to seconds (for given engine speed in RPM)
             scalar degToTime(const scalar theta) const;
 

src/engine/include/StCorr.H

@@ -27,11 +27,11 @@
                         )
                     );
 
-                    Ak = sphereFraction*4.0*constant::math::pi
+                    Ak = sphereFraction*4.0*constant::mathematical::pi
                        *pow
                         (
                             3.0*Vk
-                           /(sphereFraction*4.0*constant::math::pi),
+                           /(sphereFraction*4.0*constant::mathematical::pi),
                             2.0/3.0
                         );
                 }
@@ -56,11 +56,11 @@
                         )
                     );
 
-                    Ak = circleFraction*constant::math::pi*thickness
+                    Ak = circleFraction*constant::mathematical::pi*thickness
                        *sqrt
                         (
                             4.0*Vk
-                           /(circleFraction*thickness*constant::math::pi)
+                           /(circleFraction*thickness*constant::mathematical::pi)
                         );
                 }
                 break;

src/finiteVolume/cfdTools/general/SRF/SRFModel/rpm/rpm.C

@@ -26,7 +26,7 @@ License
 
 #include "rpm.H"
 #include "addToRunTimeSelectionTable.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -56,7 +56,7 @@ Foam::SRF::rpm::rpm
     rpm_(readScalar(SRFModelCoeffs_.lookup("rpm")))
 {
     // Initialise the angular velocity
-    omega_.value() = axis_*rpm_*constant::math::twoPi/60.0;
+    omega_.value() = axis_*rpm_*constant::mathematical::twoPi/60.0;
 }
 
 
@@ -76,7 +76,7 @@ bool Foam::SRF::rpm::read()
         SRFModelCoeffs_.lookup("rpm") >> rpm_;
 
         // Update angular velocity
-        omega_.value() = axis_*rpm_*(constant::math::twoPi/60.0);
+        omega_.value() = axis_*rpm_*(constant::mathematical::twoPi/60.0);
 
         return true;
     }

src/finiteVolume/fields/fvPatchFields/derived/oscillatingFixedValue/oscillatingFixedValueFvPatchField.C

@@ -25,7 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "oscillatingFixedValueFvPatchField.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -40,7 +40,7 @@ scalar oscillatingFixedValueFvPatchField<Type>::currentScale() const
     return
         1.0
       + amplitude_
-       *sin(constant::math::twoPi*frequency_*this->db().time().value());
+       *sin(constant::mathematical::twoPi*frequency_*this->db().time().value());
 }
 
 

src/finiteVolume/interpolation/surfaceInterpolation/surfaceInterpolation/surfaceInterpolation.C

@@ -32,7 +32,7 @@ Description
 #include "surfaceFields.H"
 #include "demandDrivenData.H"
 #include "coupledFvPatch.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -345,7 +345,8 @@ void surfaceInterpolation::makeCorrectionVectors() const
     // Calculate the non-orthogonality for meshes with 1 face or more
     if (returnReduce(magSf.size(), sumOp<label>()) > 0)
     {
-        NonOrthogCoeff =
+        NonOrthogCoeff = radToDeg
+        (
             asin
             (
                 min
@@ -353,7 +354,8 @@ void surfaceInterpolation::makeCorrectionVectors() const
                     (sum(magSf*mag(corrVecs))/sum(magSf)).value(),
                     1.0
                 )
-            )*180.0/constant::math::pi;
+            )
+        );
     }
 
     if (debug)

src/lagrangian/coalCombustion/submodels/surfaceReactionModel/COxidationDiffusionLimitedRate/COxidationDiffusionLimitedRate.C

@@ -25,7 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "COxidationDiffusionLimitedRate.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -124,7 +124,7 @@ Foam::scalar Foam::COxidationDiffusionLimitedRate<CloudType>::calculate
     const scalar YO2 = this->owner().mcCarrierThermo().Y(O2GlobalId_)[cellI];
 
     // Change in C mass [kg]
-    scalar dmC = 4.0*constant::math::pi*d*D_*YO2*Tc*rhoc/(Sb_*(T + Tc))*dt;
+    scalar dmC = 4.0*constant::mathematical::pi*d*D_*YO2*Tc*rhoc/(Sb_*(T + Tc))*dt;
 
     // Limit mass transfer by availability of C
     dmC = min(mass*fComb, dmC);

src/lagrangian/coalCombustion/submodels/surfaceReactionModel/COxidationKineticDiffusionLimitedRate/COxidationKineticDiffusionLimitedRate.C

@@ -25,7 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "COxidationKineticDiffusionLimitedRate.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -138,7 +138,7 @@ Foam::scalar Foam::COxidationKineticDiffusionLimitedRate<CloudType>::calculate
     const scalar Rk = C2_*exp(-E_/(specie::RR*Tc));
 
     // Particle surface area
-    const scalar Ap = constant::math::pi*sqr(d);
+    const scalar Ap = constant::mathematical::pi*sqr(d);
 
     // Change in C mass [kg]
     scalar dmC = Ap*rhoc*specie::RR*Tc*YO2/WO2_*D0*Rk/(D0 + Rk);

src/lagrangian/coalCombustion/submodels/surfaceReactionModel/COxidationMurphyShaddix/COxidationMurphyShaddix.C

@@ -25,7 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "COxidationMurphyShaddix.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -134,7 +134,7 @@ Foam::scalar Foam::COxidationMurphyShaddix<CloudType>::calculate
     }
 
     // Particle surface area [m^2]
-    const scalar Ap = constant::math::pi*sqr(d);
+    const scalar Ap = constant::mathematical::pi*sqr(d);
 
     // Calculate diffision constant at continuous phase temperature
     // and density [m^2/s]

src/lagrangian/dieselSpray/injector/commonRailInjector/commonRailInjector.C

@@ -27,7 +27,7 @@ License
 #include "commonRailInjector.H"
 #include "addToRunTimeSelectionTable.H"
 #include "Random.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 namespace Foam
@@ -244,7 +244,7 @@ Foam::vector Foam::commonRailInjector::position
     {
         // otherwise, disc injection
         scalar iRadius = d_*rndGen.scalar01();
-        scalar iAngle = constant::math::twoPi*rndGen.scalar01();
+        scalar iAngle = constant::mathematical::twoPi*rndGen.scalar01();
 
         return
         (
@@ -297,7 +297,7 @@ Foam::scalar Foam::commonRailInjector::mass
     // correct mass if calculation is 2D
     if (twoD)
     {
-        mInj *= 0.5*angleOfWedge/constant::math::pi;
+        mInj *= 0.5*angleOfWedge/constant::mathematical::pi;
     }
 
     return mInj;
@@ -404,7 +404,7 @@ void Foam::commonRailInjector::correctProfiles
     const scalar referencePressure
 )
 {
-    scalar A = 0.25*constant::math::pi*sqr(d_);
+    scalar A = 0.25*constant::mathematical::pi*sqr(d_);
     scalar pDummy = 1.0e+5;
     scalar rho = fuel.rho(pDummy, T_, X_);
 

src/lagrangian/dieselSpray/injector/definedInjector/definedInjector.C

@@ -27,7 +27,7 @@ License
 #include "definedInjector.H"
 #include "addToRunTimeSelectionTable.H"
 #include "Random.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 namespace Foam
@@ -226,7 +226,7 @@ Foam::vector Foam::definedInjector::position
     {
         // otherwise, disc injection
         scalar iRadius = d_*rndGen.scalar01();
-        scalar iAngle = constant::math::twoPi*rndGen.scalar01();
+        scalar iAngle = constant::mathematical::twoPi*rndGen.scalar01();
 
         return
         (
@@ -280,7 +280,7 @@ Foam::scalar Foam::definedInjector::mass
     // correct mass if calculation is 2D
     if (twoD)
     {
-        mInj *= 0.5*angleOfWedge/constant::math::pi;
+        mInj *= 0.5*angleOfWedge/constant::mathematical::pi;
     }
 
     return mInj;
@@ -374,7 +374,7 @@ void Foam::definedInjector::correctProfiles
     const scalar referencePressure
 )
 {
-    scalar A = 0.25*constant::math::pi*sqr(d_);
+    scalar A = 0.25*constant::mathematical::pi*sqr(d_);
     scalar pDummy = 1.0e+5;
     scalar rho = fuel.rho(pDummy, T_, X_);
 

src/lagrangian/dieselSpray/injector/multiHoleInjector/multiHoleInjector.C

@@ -27,7 +27,7 @@ License
 #include "multiHoleInjector.H"
 #include "addToRunTimeSelectionTable.H"
 #include "Random.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 namespace Foam
@@ -165,9 +165,8 @@ Foam::multiHoleInjector::~multiHoleInjector()
 
 void Foam::multiHoleInjector::setTangentialVectors()
 {
-    scalar pi180 = constant::math::pi/180.0;
+    scalar alpha = degToRad(xyAngle_);
-    scalar alpha = xyAngle_*pi180;
+    scalar phi = degToRad(zAngle_);
-    scalar phi = zAngle_*pi180;
 
     vector xp(cos(alpha), sin(alpha), 0.0);
     vector zp(cos(alpha)*sin(phi), sin(alpha)*sin(phi), cos(phi));
@@ -184,11 +183,11 @@ void Foam::multiHoleInjector::setTangentialVectors()
 //    Info << "zp = " << zp << endl;
 
     scalar angle = 0.0;
-    scalar u = umbrellaAngle_*pi180/2.0;
+    scalar u = degToRad(umbrellaAngle_/2.0);
     for (label i=0; i<nHoles_; i++)
     {
         angle += angleSpacing_[i];
-        scalar v = angle*pi180;
+        scalar v = degToRad(angle);
         direction_[i] = cos(v)*sin(u)*xp + sin(v)*sin(u)*yp + cos(u)*zp;
         vector dp = direction_[i] - (direction_[i] & zp)*direction_[i];
         if (mag(dp) > SMALL)
@@ -267,7 +266,7 @@ Foam::vector Foam::multiHoleInjector::position
     {
         // otherwise, disc injection
         scalar iRadius = d_*rndGen.scalar01();
-        scalar iAngle = constant::math::twoPi*rndGen.scalar01();
+        scalar iAngle = constant::mathematical::twoPi*rndGen.scalar01();
 
         return
         (
@@ -319,7 +318,7 @@ Foam::scalar Foam::multiHoleInjector::mass
     // correct mass if calculation is 2D
     if (twoD)
     {
-        mInj *= 0.5*angleOfWedge/constant::math::pi;
+        mInj *= 0.5*angleOfWedge/constant::mathematical::pi;
     }
 
     return mInj;
@@ -429,7 +428,7 @@ void Foam::multiHoleInjector::correctProfiles
     const scalar referencePressure
 )
 {
-    scalar A = nHoles_*0.25*constant::math::pi*sqr(d_);
+    scalar A = nHoles_*0.25*constant::mathematical::pi*sqr(d_);
 
     forAll(velocityProfile_, i)
     {

src/lagrangian/dieselSpray/injector/swirlInjector/swirlInjector.C

@@ -27,7 +27,7 @@ License
 #include "swirlInjector.H"
 #include "addToRunTimeSelectionTable.H"
 #include "Random.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -246,7 +246,7 @@ Foam::vector Foam::swirlInjector::position
     {
         // otherwise, disc injection
         scalar iRadius = d_*rndGen.scalar01();
-        scalar iAngle = constant::math::twoPi*rndGen.scalar01();
+        scalar iAngle = constant::mathematical::twoPi*rndGen.scalar01();
 
         return
         (
@@ -300,7 +300,7 @@ Foam::scalar Foam::swirlInjector::mass
     // correct mass if calculation is 2D
     if (twoD)
     {
-        mInj *= 0.5*angleOfWedge/constant::math::pi;
+        mInj *= 0.5*angleOfWedge/constant::mathematical::pi;
     }
 
     return mInj;
@@ -415,7 +415,7 @@ void Foam::swirlInjector::correctProfiles
     const scalar referencePressure
 )
 {
-    scalar A = 0.25*constant::math::pi*sqr(d_);
+    scalar A = 0.25*constant::mathematical::pi*sqr(d_);
     scalar pDummy = 1.0e+5;
     scalar rho = fuel.rho(pDummy, T_, X_);
 

src/lagrangian/dieselSpray/injector/unitInjector/unitInjector.C

@@ -27,7 +27,7 @@ License
 #include "unitInjector.H"
 #include "addToRunTimeSelectionTable.H"
 #include "Random.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -220,7 +220,7 @@ Foam::vector Foam::unitInjector::position
     {
         // otherwise, disc injection
         scalar iRadius = d_*rndGen.scalar01();
-        scalar iAngle = constant::math::twoPi*rndGen.scalar01();
+        scalar iAngle = constant::mathematical::twoPi*rndGen.scalar01();
 
         return
         (
@@ -273,7 +273,7 @@ Foam::scalar Foam::unitInjector::mass
     // correct mass if calculation is 2D
     if (twoD)
     {
-        mInj *= 0.5*angleOfWedge/constant::math::pi;
+        mInj *= 0.5*angleOfWedge/constant::mathematical::pi;
     }
 
     return mInj;
@@ -364,7 +364,7 @@ void Foam::unitInjector::correctProfiles
     const scalar referencePressure
 )
 {
-    scalar A = 0.25*constant::math::pi*sqr(d_);
+    scalar A = 0.25*constant::mathematical::pi*sqr(d_);
     scalar pDummy = 1.0e+5;
 
     forAll(velocityProfile_, i)

src/lagrangian/dieselSpray/parcel/parcelFunctions.C

@@ -25,7 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "parcel.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -102,13 +102,13 @@ scalar parcel::Pr
 
 scalar parcel::N(const scalar rho) const
 {
-    return 6.0*m_/(rho*pow3(d_)*constant::math::pi);
+    return 6.0*m_/(rho*pow3(d_)*constant::mathematical::pi);
 }
 
 
 scalar parcel::Vd() const
 {
-    return pow3(d_)*constant::math::pi/6.0;
+    return pow3(d_)*constant::mathematical::pi/6.0;
 }
 
 

src/lagrangian/dieselSpray/spray/spray.C

@@ -41,7 +41,7 @@ License
 #include "symmetryPolyPatch.H"
 #include "wedgePolyPatch.H"
 
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -290,17 +290,17 @@ Foam::spray::spray
         axisOfWedgeNormal_ /= mag(axisOfWedgeNormal_);
 
         scalar arcCos = (v1 & v2)/mag(v1);
-        angleOfWedge_ = constant::math::pi - acos(arcCos);
+        angleOfWedge_ = constant::mathematical::pi - acos(arcCos);
 
         Info<< "Calculated angle of wedge is "
-            << angleOfWedge_*180/constant::math::pi << " deg."
+            << radToDeg(angleOfWedge_) << " deg."
             << endl;
     }
     else
     {
         if (symPlaneExist)
         {
-            angleOfWedge_ = constant::math::pi;
+            angleOfWedge_ = constant::mathematical::pi;
             Info<< "Constructing 180 deg three dimensional spray injection."
                 << endl;
         }

src/lagrangian/dieselSpray/spray/sprayFunctions.C

@@ -25,7 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "spray.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -106,7 +106,7 @@ scalar spray::liquidMass() const
 
     if (twoD())
     {
-        sum *= constant::math::twoPi/angleOfWedge();
+        sum *= constant::mathematical::twoPi/angleOfWedge();
     }
 
     reduce(sum, sumOp<scalar>());
@@ -148,7 +148,7 @@ scalar spray::liquidEnthalpy() const
 
     if (twoD())
     {
-        sum *= constant::math::twoPi/angleOfWedge();
+        sum *= constant::mathematical::twoPi/angleOfWedge();
     }
 
     reduce(sum, sumOp<scalar>());
@@ -193,7 +193,7 @@ scalar spray::liquidTotalEnthalpy() const
 
     if (twoD())
     {
-        sum *= constant::math::twoPi/angleOfWedge();
+        sum *= constant::mathematical::twoPi/angleOfWedge();
     }
 
     reduce(sum, sumOp<scalar>());
@@ -218,7 +218,7 @@ scalar spray::liquidKineticEnergy() const
 
     if (twoD())
     {
-        sum *= constant::math::twoPi/angleOfWedge();
+        sum *= constant::mathematical::twoPi/angleOfWedge();
     }
 
     reduce(sum, sumOp<scalar>());

src/lagrangian/dieselSpray/spraySubModels/atomizationModel/LISA/LISA.C

@@ -27,7 +27,7 @@ License
 #include "LISA.H"
 #include "addToRunTimeSelectionTable.H"
 #include "basicMultiComponentMixture.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "RosinRammler.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -155,7 +155,7 @@ void LISA::atomizeParcel
 
     scalar massFlow = it.massFlowRate(max(0.0,elapsedTime-time));
 
-    scalar hSheet = massFlow/(constant::math::pi*d*rhoFuel*mag(p.U()));
+    scalar hSheet = massFlow/(constant::mathematical::pi*d*rhoFuel*mag(p.U()));
 
     p.d() = min(hSheet,p.d());
 
@@ -249,7 +249,7 @@ void LISA::atomizeParcel
 
     scalar kL = 1.0/(dL*sqrt(0.5 + 1.5*muFuel/sqrt(rhoFuel*sigma*dL)));
 
-    scalar dD = cbrt(3.0*constant::math::pi*sqr(dL)/kL);
+    scalar dD = cbrt(3.0*constant::mathematical::pi*sqr(dL)/kL);
 
     scalar lisaExp = 0.27;
     scalar ambientPressure = 1.0e+5;

src/lagrangian/dieselSpray/spraySubModels/atomizationModel/blobsSheetAtomization/blobsSheetAtomization.C

@@ -27,7 +27,7 @@ License
 #include "blobsSheetAtomization.H"
 #include "addToRunTimeSelectionTable.H"
 #include "basicMultiComponentMixture.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 #include "RosinRammler.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -127,7 +127,7 @@ void blobsSheetAtomization::atomizeParcel
     scalar lBU =
         B_*sqrt
         (
-            rhoFuel*sigma*p.d()*cos(angle_*constant::math::pi/360.0)
+            rhoFuel*sigma*p.d()*cos(angle_*constant::mathematical::pi/360.0)
            /sqr(rhoAverage*U)
         );
 

src/lagrangian/dieselSpray/spraySubModels/breakupModel/ETAB/ETAB.C

@@ -26,7 +26,7 @@ License
 
 #include "ETAB.H"
 #include "addToRunTimeSelectionTable.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -128,7 +128,7 @@ void ETAB::breakupParcel
             scalar quad = -y2/a;
             if (quad < 0)
             {
-                phi = constant::math::twoPi - phit;
+                phi = constant::mathematical::twoPi - phit;
             }
 
             scalar tb = 0;
@@ -139,11 +139,11 @@ void ETAB::breakupParcel
 
                 if (theta < phi)
                 {
-                    if (constant::math::twoPi - theta >= phi)
+                    if (constant::mathematical::twoPi - theta >= phi)
                     {
                         theta = -theta;
                     }
-                    theta += constant::math::twoPi;
+                    theta += constant::mathematical::twoPi;
                 }
                 tb = (theta-phi)*romega;
 

src/lagrangian/dieselSpray/spraySubModels/breakupModel/SHF/SHF.C

@@ -26,7 +26,7 @@ License
 
 #include "SHF.H"
 #include "addToRunTimeSelectionTable.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -196,7 +196,7 @@ void SHF::breakupParcel
 
                 px =
                     x
-                   /(2.0*sqrt(constant::math::twoPi)*sigma_)
+                   /(2.0*sqrt(constant::mathematical::twoPi)*sigma_)
                    *exp(-0.5*sqr((x-mu_)/sigma_));
 
             } while (y >= px);
@@ -227,7 +227,7 @@ void SHF::breakupParcel
 
                 px =
                     x
-                   /(2.0*sqrt(constant::math::twoPi)*sigma_)
+                   /(2.0*sqrt(constant::mathematical::twoPi)*sigma_)
                    *exp(-0.5*sqr((x-mu_)/sigma_));
             } while (y >= px);
 

src/lagrangian/dieselSpray/spraySubModels/breakupModel/TAB/TAB.C

@@ -26,7 +26,7 @@ License
 
 #include "TAB.H"
 #include "addToRunTimeSelectionTable.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -130,7 +130,7 @@ void TAB::breakupParcel
             scalar quad = -y2/a;
             if (quad < 0)
             {
-                phi = constant::math::twoPi - phit;
+                phi = constant::mathematical::twoPi - phit;
             }
 
             scalar tb = 0;
@@ -147,11 +147,11 @@ void TAB::breakupParcel
 
                 if (theta < phi)
                 {
-                    if (constant::math::twoPi - theta >= phi)
+                    if (constant::mathematical::twoPi - theta >= phi)
                     {
                         theta = -theta;
                     }
-                    theta += constant::math::twoPi;
+                    theta += constant::mathematical::twoPi;
                 }
                 tb = (theta - phi)/omega;
 

src/lagrangian/dieselSpray/spraySubModels/breakupModel/reitzKHRT/reitzKHRT.C

@@ -26,7 +26,7 @@ License
 
 #include "reitzKHRT.H"
 #include "addToRunTimeSelectionTable.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -137,7 +137,7 @@ void reitzKHRT::breakupParcel
     scalar KRT = sqrt(helpVariable/(3.0*sigma + VSMALL));
 
     // wavelength of the fastest growing RT frequency
-    scalar lambdaRT = constant::math::twoPi*cRT_/(KRT + VSMALL);
+    scalar lambdaRT = constant::mathematical::twoPi*cRT_/(KRT + VSMALL);
 
     // if lambdaRT < diameter, then RT waves are growing on the surface
     // and we start to keep track of how long they have been growing
@@ -170,7 +170,7 @@ void reitzKHRT::breakupParcel
             // reduce the diameter according to the rate-equation
             p.d() = (fraction*dc + p.d())/(1.0 + fraction);
 
-            scalar ms = rhoLiquid*Np*pow3(dc)*constant::math::pi/6.0;
+            scalar ms = rhoLiquid*Np*pow3(dc)*constant::mathematical::pi/6.0;
             p.ms() += ms;
 
             // Total number of parcels for the whole injection event

src/lagrangian/dieselSpray/spraySubModels/collisionModel/ORourke/ORourkeCollisionModel.C

@@ -26,7 +26,7 @@ License
 
 #include "ORourkeCollisionModel.H"
 #include "addToRunTimeSelectionTable.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/lagrangian/dieselSpray/spraySubModels/collisionModel/ORourke/sameCell.H

@@ -31,7 +31,7 @@ scalar nMin = pMin().N(rhoMin);
 
 scalar mdMin = mMin/nMin;
 
-scalar nu0 = 0.25*constant::math::pi*sumD*sumD*magVRel*dt/vols_[cell1];
+scalar nu0 = 0.25*constant::mathematical::pi*sumD*sumD*magVRel*dt/vols_[cell1];
 scalar nu = nMin*nu0;
 scalar collProb = exp(-nu);
 scalar xx = rndGen_.scalar01();

src/lagrangian/dieselSpray/spraySubModels/collisionModel/trajectoryModel/trajectoryCM.H

@@ -129,7 +129,7 @@ if (vAlign > 0)
                     pMax().d() =
                         pow
                         (
-                            6.0*newMaxMass/(rhoMax*constant::math::pi*nMax),
+                            6.0*newMaxMass/(rhoMax*constant::mathematical::pi*nMax),
                             1.0/3.0
                         );
 

src/lagrangian/dieselSpray/spraySubModels/collisionModel/trajectoryModel/trajectoryModel.C

@@ -26,7 +26,7 @@ License
 
 #include "trajectoryModel.H"
 #include "addToRunTimeSelectionTable.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/lagrangian/dieselSpray/spraySubModels/evaporationModel/RutlandFlashBoil/RutlandFlashBoil.C

@@ -28,7 +28,7 @@ License
 
 #include "RutlandFlashBoil.H"
 #include "addToRunTimeSelectionTable.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -229,7 +229,7 @@ scalar RutlandFlashBoil::boilingTime
 
             for (label k=0; k < Niter; k++)
             {
-                expSum += exp(sqr(-k*constant::math::pi*sqrt(F)/2.0));
+                expSum += exp(sqr(-k*constant::mathematical::pi*sqrt(F)/2.0));
                 if (mag(expSum-expSumOld)/expSum < 1.0e-3)
                 {
                     break;
@@ -257,7 +257,7 @@ scalar RutlandFlashBoil::boilingTime
         }
 
         scalar Gf =
-            4.0*alfaS*dTLB*constant::math::pi*sqr(diameter/2.0)/heatOfVapour;
+            4.0*alfaS*dTLB*constant::mathematical::pi*sqr(diameter/2.0)/heatOfVapour;
 
         // calculation of the heat transfer vapourization at superheated
         // conditions (temperature>tBoilingSurface)
@@ -269,7 +269,7 @@ scalar RutlandFlashBoil::boilingTime
                 mag((vapourFarEnthalpy-vapourSurfaceEnthalpy)/heatOfVapour);
 
             // 2.0? or 1.0? try 1!
-            scalar B = 1.0*constant::math::pi*kappa/cpGas*diameter*NusseltCorr;
+            scalar B = 1.0*constant::mathematical::pi*kappa/cpGas*diameter*NusseltCorr;
             scalar nPos = B*log(1.0 + A)/Gf + 1.0;
             scalar nNeg = (1.0/A)*(exp(Gf/B) - 1.0 - A) + 1.0;
 
@@ -342,7 +342,7 @@ scalar RutlandFlashBoil::boilingTime
             }
         }
 
-        time = (constant::math::pi*pow3(diameter)/6.0)*liquidDensity/(G + Gf);
+        time = (constant::mathematical::pi*pow3(diameter)/6.0)*liquidDensity/(G + Gf);
 
         time = max(VSMALL, time);
     }

src/lagrangian/dieselSpray/spraySubModels/injectorModel/Chomiak/Chomiak.C

@@ -26,7 +26,7 @@ License
 
 #include "Chomiak.H"
 #include "addToRunTimeSelectionTable.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -118,11 +118,11 @@ vector ChomiakInjector::direction
     scalar angle =
         (d - dMax)*maxSprayAngle_[n]
        /(dMin - dMax)
-       *constant::math::pi/360.0;
+       *constant::mathematical::pi/360.0;
     scalar alpha = sin(angle);
     scalar dcorr = cos(angle);
 
-    scalar beta = constant::math::twoPi*rndGen_.scalar01();
+    scalar beta = constant::mathematical::twoPi*rndGen_.scalar01();
 
     // randomly distributed vector normal to the injection vector
     vector normal = vector::zero;
@@ -132,7 +132,7 @@ vector ChomiakInjector::direction
         scalar reduce = 0.01;
         // correct beta if this is a 2D run
         // map it onto the 'angleOfWedge'
-        beta *= (1.0-2.0*reduce)*0.5*sm_.angleOfWedge()/constant::math::pi;
+        beta *= (1.0-2.0*reduce)*0.5*sm_.angleOfWedge()/constant::mathematical::pi;
         beta += reduce*sm_.angleOfWedge();
 
         normal =

src/lagrangian/dieselSpray/spraySubModels/injectorModel/blobsSwirl/blobsSwirlInjector.C

@@ -26,7 +26,7 @@ License
 
 #include "blobsSwirlInjector.H"
 #include "addToRunTimeSelectionTable.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -110,9 +110,7 @@ scalar blobsSwirlInjector::d0
 
     scalar c = rndGen_.scalar01();
 
-    angle_ = coneAngle_[n]/2.0 + c*coneInterval_[n];
+    angle_ = degToRad(coneAngle_[n]/2.0 + c*coneInterval_[n]);
-
-    angle_ *= constant::math::pi/180.0;
 
     scalar injectedMassFlow = it.massFlowRate(t);
 
@@ -144,7 +142,7 @@ vector blobsSwirlInjector::direction
 {
     scalar alpha = sin(angle_);
     scalar dcorr = cos(angle_);
-    scalar beta = constant::math::twoPi*rndGen_.scalar01();
+    scalar beta = constant::mathematical::twoPi*rndGen_.scalar01();
 
     // randomly distributed vector normal to the injection vector
     vector normal = vector::zero;
@@ -155,7 +153,7 @@ vector blobsSwirlInjector::direction
         // correct beta if this is a 2D run
         // map it onto the 'angleOfWedge'
 
-        beta *= (1.0 - 2.0*reduce)*sm_.angleOfWedge()/(constant::math::twoPi);
+        beta *= (1.0 - 2.0*reduce)*sm_.angleOfWedge()/(constant::mathematical::twoPi);
         beta += reduce*sm_.angleOfWedge();
         normal =
             alpha
@@ -240,7 +238,7 @@ void blobsSwirlInjector::calculateHX
         (
             (A_[inj]*cTau_[inj]*muFuel*massFlow*(1.0 + x_))
            /(
-                constant::math::pi
+                constant::mathematical::pi
                *injectorDiameter
                *rhoFuel
                *dPressure
@@ -260,7 +258,7 @@ void blobsSwirlInjector::calculateHX
             (
                 (A_[inj]*cTau_[inj]*muFuel*massFlow*(1.0 + x_))
                /(
-                    constant::math::pi
+                    constant::mathematical::pi
                    *injectorDiameter
                    *rhoFuel
                    *dPressure

src/lagrangian/dieselSpray/spraySubModels/injectorModel/constant/constInjector.C

@@ -26,7 +26,7 @@ License
 
 #include "constInjector.H"
 #include "addToRunTimeSelectionTable.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -133,11 +133,11 @@ vector constInjector::direction
                         v  (alpha)
     */
 
-    scalar angle = rndGen_.scalar01()*sprayAngle_[n]*constant::math::pi/360.0;
+    scalar angle = rndGen_.scalar01()*sprayAngle_[n]*constant::mathematical::pi/360.0;
     scalar alpha = sin(angle);
     scalar dcorr = cos(angle);
 
-    scalar beta = constant::math::twoPi*rndGen_.scalar01();
+    scalar beta = constant::mathematical::twoPi*rndGen_.scalar01();
 
     // randomly distributed vector normal to the injection vector
     vector normal = vector::zero;
@@ -147,7 +147,7 @@ vector constInjector::direction
         scalar reduce = 0.01;
         // correct beta if this is a 2D run
         // map it onto the 'angleOfWedge'
-        beta *= (1.0 - 2.0*reduce)*0.5*sm_.angleOfWedge()/constant::math::pi;
+        beta *= (1.0 - 2.0*reduce)*0.5*sm_.angleOfWedge()/constant::mathematical::pi;
         beta += reduce*sm_.angleOfWedge();
 
         normal =

src/lagrangian/dieselSpray/spraySubModels/injectorModel/definedHollowCone/definedHollowCone.C

@@ -26,7 +26,7 @@ License
 
 #include "definedHollowCone.H"
 #include "addToRunTimeSelectionTable.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -163,9 +163,9 @@ vector definedHollowConeInjector::direction
     // use random number to generate angle between inner/outer cone angles
     scalar angle = angleInner + rndGen_.scalar01()*(angleOuter - angleInner);
 
-    scalar alpha = sin(angle*constant::math::pi/360.0);
+    scalar alpha = sin(angle*constant::mathematical::pi/360.0);
-    scalar dcorr = cos(angle*constant::math::pi/360.0);
+    scalar dcorr = cos(angle*constant::mathematical::pi/360.0);
-    scalar beta = constant::math::twoPi*rndGen_.scalar01();
+    scalar beta = constant::mathematical::twoPi*rndGen_.scalar01();
 
     // randomly distributed vector normal to the injection vector
     vector normal = vector::zero;
@@ -176,7 +176,7 @@ vector definedHollowConeInjector::direction
         // correct beta if this is a 2D run
         // map it onto the 'angleOfWedge'
 
-        beta *= (1.0 - 2.0*reduce)*sm_.angleOfWedge()/(constant::math::twoPi);
+        beta *= (1.0 - 2.0*reduce)*sm_.angleOfWedge()/(constant::mathematical::twoPi);
         beta += reduce*sm_.angleOfWedge();
         normal =
             alpha

src/lagrangian/dieselSpray/spraySubModels/injectorModel/definedPressureSwirl/definedPressureSwirl.C

@@ -26,7 +26,7 @@ License
 
 #include "definedPressureSwirl.H"
 #include "addToRunTimeSelectionTable.H"
-#include "mathConstants.H"
+#include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -174,7 +174,7 @@ scalar definedPressureSwirlInjector::d0
 
     // end modifications
 
-    angle_ *= constant::math::pi/360.0;
+    angle_ *= constant::mathematical::pi/360.0;
 
     scalar injectedMassFlow = it.massFlowRate(t);
 
@@ -191,7 +191,7 @@ scalar definedPressureSwirlInjector::d0
 
     u_ = v*cosAngle;
 
-    scalar A = injectedMassFlow/(constant::math::pi*rhoFuel*u_);
+    scalar A = injectedMassFlow/(constant::mathematical::pi*rhoFuel*u_);
 
     // Not using the authors definition for sheet thickness
     // modified by multiplying the sheet tickness for the cone angle cosinus.
@@ -216,7 +216,7 @@ vector definedPressureSwirlInjector::direction
 {
     scalar alpha = sin(angle_);
     scalar dcorr = cos(angle_);
-    scalar beta = constant::math::twoPi*rndGen_.scalar01();
+    scalar beta = constant::mathematical::twoPi*rndGen_.scalar01();
 
     // randomly distributed vector normal to the injection vector
     vector normal = vector::zero;
@@ -227,7 +227,7 @@ vector definedPressureSwirlInjector::direction
         // correct beta if this is a 2D run
         // map it onto the 'angleOfWedge'
 
-        beta *= (1.0 - 2.0*reduce)*sm_.angleOfWedge()/(constant::math::twoPi);
+        beta *= (1.0 - 2.0*reduce)*sm_.angleOfWedge()/(constant::mathematical::twoPi);
         beta += reduce*sm_.angleOfWedge();
         normal =
             alpha
@@ -296,7 +296,7 @@ scalar definedPressureSwirlInjector::kv
 
     scalar coneAngle = it.getTableValue(coneAngle_, t);
 
-    coneAngle *= constant::math::pi/360.0;
+    coneAngle *= constant::mathematical::pi/360.0;
 
     scalar cosAngle = cos(coneAngle);
     scalar Tav = it.integrateTable(it.T())/(it.teoi() - it.tsoi());
@@ -309,7 +309,7 @@ scalar definedPressureSwirlInjector::kv
         it.getTableValue(maxKv_, t),
         4.0*massFlow
        *sqrt(rhoFuel/2.0/dPressure)
-       /(constant::math::pi*sqr(injectorDiameter)*rhoFuel*cosAngle)
+       /(constant::mathematical::pi*sqr(injectorDiameter)*rhoFuel*cosAngle)
     );
 
     return min(1.0, kv);