STYLE: fully scope some method names

src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/cyclicLduInterface.C

@@ -28,10 +28,8 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-namespace Foam
+defineTypeNameAndDebug(Foam::cyclicLduInterface, 0);
-{
+
-    defineTypeNameAndDebug(cyclicLduInterface, 0);
-}
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 

src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/lduInterface.C

@@ -25,23 +25,15 @@ License
 
 #include "lduInterface.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(lduInterface, 0);
+defineTypeNameAndDebug(Foam::lduInterface, 0);
+
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-lduInterface::~lduInterface()
+Foam::lduInterface::~lduInterface()
 {}
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterface/processorLduInterface.C

@@ -27,10 +27,7 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-namespace Foam
+defineTypeNameAndDebug(Foam::processorLduInterface, 0);
-{
-    defineTypeNameAndDebug(processorLduInterface, 0);
-}
 
 
 // * * * * * * * * * * * * * Private Member Functions *  * * * * * * * * * * //

src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/cyclicLduInterfaceField/cyclicLduInterfaceField.C

@@ -28,10 +28,7 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-namespace Foam
+defineTypeNameAndDebug(Foam::cyclicLduInterfaceField, 0);
-{
-    defineTypeNameAndDebug(cyclicLduInterfaceField, 0);
-}
 
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //

src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/lduInterfaceField/lduInterfaceField.C

@@ -25,23 +25,14 @@ License
 
 #include "lduInterfaceField.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(lduInterfaceField, 0);
+defineTypeNameAndDebug(Foam::lduInterfaceField, 0);
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-lduInterfaceField::~lduInterfaceField()
+Foam::lduInterfaceField::~lduInterfaceField()
 {}
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduInterfaceFields/processorLduInterfaceField/processorLduInterfaceField.C

@@ -28,10 +28,7 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-namespace Foam
+defineTypeNameAndDebug(Foam::processorLduInterfaceField, 0);
-{
-    defineTypeNameAndDebug(processorLduInterfaceField, 0);
-}
 
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //

src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrix.C

@@ -28,10 +28,7 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-namespace Foam
+defineTypeNameAndDebug(Foam::lduMatrix, 1);
-{
-    defineTypeNameAndDebug(lduMatrix, 1);
-}
 
 const Foam::scalar Foam::lduMatrix::great_ = 1.0e+20;
 const Foam::scalar Foam::lduMatrix::small_ = 1.0e-20;

src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGAgglomerations/pairGAMGAgglomeration/pairGAMGAgglomeration.C

@@ -27,10 +27,7 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-namespace Foam
+defineTypeNameAndDebug(Foam::pairGAMGAgglomeration, 0);
-{
-    defineTypeNameAndDebug(pairGAMGAgglomeration, 0);
-}
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //

src/OpenFOAM/matrices/lduMatrix/solvers/diagonalSolver/diagonalSolver.C

@@ -27,10 +27,7 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-namespace Foam
+defineTypeNameAndDebug(Foam::diagonalSolver, 0);
-{
-    defineTypeNameAndDebug(diagonalSolver, 0);
-}
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //

src/OpenFOAM/matrices/tolerances/tolerances.C

@@ -25,14 +25,9 @@ License
 
 #include "tolerances.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-tolerances::tolerances(const Time& t, const fileName& dictName)
+Foam::tolerances::tolerances(const Time& t, const fileName& dictName)
 :
     IOdictionary
     (
@@ -58,7 +53,7 @@ tolerances::tolerances(const Time& t, const fileName& dictName)
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-bool tolerances::read()
+bool Foam::tolerances::read()
 {
     if (regIOobject::read())
     {
@@ -90,34 +85,34 @@ bool tolerances::read()
 }
 
 
-bool tolerances::relax(const word& name) const
+bool Foam::tolerances::relax(const word& name) const
 {
     return relaxationFactors_.found(name);
 }
 
-scalar tolerances::relaxationFactor(const word& name) const
+
+Foam::scalar Foam::tolerances::relaxationFactor(const word& name) const
 {
     return readScalar(relaxationFactors_.lookup(name));
 }
 
-scalar tolerances::solverTolerance(const word& name) const
+
+Foam::scalar Foam::tolerances::solverTolerance(const word& name) const
 {
     return readScalar(solverTolerances_.lookup(name));
 }
 
-bool tolerances::solverRelativeTolerances() const
+
+bool Foam::tolerances::solverRelativeTolerances() const
 {
     return solverRelativeTolerances_.size();
 }
 
-scalar tolerances::solverRelativeTolerance(const word& name) const
+
+Foam::scalar Foam::tolerances::solverRelativeTolerance(const word& name) const
 {
     return readScalar(solverRelativeTolerances_.lookup(name));
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/OpenFOAM/meshes/pointMesh/pointPatches/basic/generic/genericPointPatch.C

@@ -26,26 +26,20 @@ License
 #include "genericPointPatch.H"
 #include "addToRunTimeSelectionTable.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
+    defineTypeNameAndDebug(genericPointPatch, 0);
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+    // Add the patch constructor functions to the hash tables
-
+    addToRunTimeSelectionTable
-defineTypeNameAndDebug(genericPointPatch, 0);
+    (
-
-// Add the patch constructor functions to the hash tables
-addToRunTimeSelectionTable
-(
         facePointPatch,
         genericPointPatch,
         polyPatch
-);
+    );
+}
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/cyclic/cyclicPointPatch.C

@@ -31,20 +31,18 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-namespace Foam
-{
-
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(cyclicPointPatch, 0);
+namespace Foam
-
+{
-addToRunTimeSelectionTable
+    defineTypeNameAndDebug(cyclicPointPatch, 0);
-(
+    addToRunTimeSelectionTable
+    (
         facePointPatch,
         cyclicPointPatch,
         polyPatch
-);
+    );
-
+}
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
@@ -77,22 +75,22 @@ void Foam::cyclicPointPatch::calcGeometry(PstreamBuffers&)
 }
 
 
-void cyclicPointPatch::initMovePoints(PstreamBuffers&, const pointField&)
+void Foam::cyclicPointPatch::initMovePoints(PstreamBuffers&, const pointField&)
 {}
 
 
-void cyclicPointPatch::movePoints(PstreamBuffers&, const pointField&)
+void Foam::cyclicPointPatch::movePoints(PstreamBuffers&, const pointField&)
 {}
 
 
-void cyclicPointPatch::initUpdateMesh(PstreamBuffers& pBufs)
+void Foam::cyclicPointPatch::initUpdateMesh(PstreamBuffers& pBufs)
 {
     facePointPatch::initUpdateMesh(pBufs);
     cyclicPointPatch::initGeometry(pBufs);
 }
 
 
-void cyclicPointPatch::updateMesh(PstreamBuffers& pBufs)
+void Foam::cyclicPointPatch::updateMesh(PstreamBuffers& pBufs)
 {
     facePointPatch::updateMesh(pBufs);
     cyclicPointPatch::calcGeometry(pBufs);
@@ -101,7 +99,7 @@ void cyclicPointPatch::updateMesh(PstreamBuffers& pBufs)
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-cyclicPointPatch::cyclicPointPatch
+Foam::cyclicPointPatch::cyclicPointPatch
 (
     const polyPatch& patch,
     const pointBoundaryMesh& bm
@@ -114,26 +112,22 @@ cyclicPointPatch::cyclicPointPatch
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-cyclicPointPatch::~cyclicPointPatch()
+Foam::cyclicPointPatch::~cyclicPointPatch()
 {}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-const edgeList& cyclicPointPatch::transformPairs() const
+const Foam::edgeList& Foam::cyclicPointPatch::transformPairs() const
 {
     return cyclicPolyPatch_.coupledPoints();
 }
 
 
-const labelList& cyclicPointPatch::separatedPoints() const
+const Foam::labelList& Foam::cyclicPointPatch::separatedPoints() const
 {
     return separatedPoints_;
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/empty/emptyPointPatch.C

@@ -31,22 +31,19 @@ License
 
 namespace Foam
 {
-
+    defineTypeNameAndDebug(emptyPointPatch, 0);
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+    addToRunTimeSelectionTable
-
+    (
-defineTypeNameAndDebug(emptyPointPatch, 0);
-
-addToRunTimeSelectionTable
-(
         facePointPatch,
         emptyPointPatch,
         polyPatch
-);
+    );
+}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void emptyPointPatch::applyConstraint
+void Foam::emptyPointPatch::applyConstraint
 (
     const label pointi,
     pointConstraint& pc
@@ -56,8 +53,4 @@ void emptyPointPatch::applyConstraint
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processor/processorPointPatch.C

@@ -31,21 +31,18 @@ License
 #include "primitiveFacePatch.H"
 #include "emptyPolyPatch.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
-
+    defineTypeNameAndDebug(processorPointPatch, 0);
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+    addToRunTimeSelectionTable
-
+    (
-defineTypeNameAndDebug(processorPointPatch, 0);
-
-addToRunTimeSelectionTable
-(
         facePointPatch,
         processorPointPatch,
         polyPatch
-);
+    );
+}
 
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
@@ -123,22 +120,26 @@ void Foam::processorPointPatch::calcGeometry(PstreamBuffers& pBufs)
 }
 
 
-void processorPointPatch::initMovePoints(PstreamBuffers&, const pointField&)
+void Foam::processorPointPatch::initMovePoints
+(
+    PstreamBuffers&,
+    const pointField&
+)
 {}
 
 
-void processorPointPatch::movePoints(PstreamBuffers&, const pointField&)
+void Foam::processorPointPatch::movePoints(PstreamBuffers&, const pointField&)
 {}
 
 
-void processorPointPatch::initUpdateMesh(PstreamBuffers& pBufs)
+void Foam::processorPointPatch::initUpdateMesh(PstreamBuffers& pBufs)
 {
     facePointPatch::initUpdateMesh(pBufs);
     processorPointPatch::initGeometry(pBufs);
 }
 
 
-void processorPointPatch::updateMesh(PstreamBuffers& pBufs)
+void Foam::processorPointPatch::updateMesh(PstreamBuffers& pBufs)
 {
     facePointPatch::updateMesh(pBufs);
     processorPointPatch::calcGeometry(pBufs);
@@ -147,7 +148,7 @@ void processorPointPatch::updateMesh(PstreamBuffers& pBufs)
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-processorPointPatch::processorPointPatch
+Foam::processorPointPatch::processorPointPatch
 (
     const polyPatch& patch,
     const pointBoundaryMesh& bm
@@ -160,26 +161,22 @@ processorPointPatch::processorPointPatch
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-processorPointPatch::~processorPointPatch()
+Foam::processorPointPatch::~processorPointPatch()
 {}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-const labelList& processorPointPatch::reverseMeshPoints() const
+const Foam::labelList& Foam::processorPointPatch::reverseMeshPoints() const
 {
     return reverseMeshPoints_;
 }
 
 
-const labelList& processorPointPatch::separatedPoints() const
+const Foam::labelList& Foam::processorPointPatch::separatedPoints() const
 {
     return separatedPoints_;
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/symmetry/symmetryPointPatch.C

@@ -29,25 +29,25 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-namespace Foam
-{
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(symmetryPointPatch, 0);
+namespace Foam
+{
+    defineTypeNameAndDebug(symmetryPointPatch, 0);
 
-// Add the patch constructor functions to the hash tables
+    // Add the patch constructor functions to the hash tables
-addToRunTimeSelectionTable
+    addToRunTimeSelectionTable
-(
+    (
         facePointPatch,
         symmetryPointPatch,
         polyPatch
-);
+    );
+}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void symmetryPointPatch::applyConstraint
+void Foam::symmetryPointPatch::applyConstraint
 (
     const label pointi,
     pointConstraint& pc
@@ -57,8 +57,4 @@ void symmetryPointPatch::applyConstraint
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/wedge/wedgePointPatch.C

@@ -34,23 +34,21 @@ Description
 
 namespace Foam
 {
+    defineTypeNameAndDebug(wedgePointPatch, 0);
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+    // Add the patch constructor functions to the hash tables
-
+    addToRunTimeSelectionTable
-defineTypeNameAndDebug(wedgePointPatch, 0);
+    (
-
-// Add the patch constructor functions to the hash tables
-addToRunTimeSelectionTable
-(
         facePointPatch,
         wedgePointPatch,
         polyPatch
-);
+    );
+}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void wedgePointPatch::applyConstraint
+void Foam::wedgePointPatch::applyConstraint
 (
     const label pointi,
     pointConstraint& pc
@@ -60,8 +58,4 @@ void wedgePointPatch::applyConstraint
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/OpenFOAM/meshes/pointMesh/pointPatches/derived/coupled/coupledFacePointPatch.C

@@ -26,19 +26,14 @@ License
 #include "coupledFacePointPatch.H"
 #include "pointBoundaryMesh.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(coupledFacePointPatch, 0);
+defineTypeNameAndDebug(Foam::coupledFacePointPatch, 0);
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-coupledFacePointPatch::coupledFacePointPatch
+Foam::coupledFacePointPatch::coupledFacePointPatch
 (
     const polyPatch& patch,
     const pointBoundaryMesh& bm
@@ -52,12 +47,8 @@ coupledFacePointPatch::coupledFacePointPatch
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-coupledFacePointPatch::~coupledFacePointPatch()
+Foam::coupledFacePointPatch::~coupledFacePointPatch()
 {}
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/OpenFOAM/meshes/polyMesh/zones/zone/zone.C

@@ -29,10 +29,8 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-namespace Foam
+defineTypeNameAndDebug(Foam::zone, 0);
-{
+
-    defineTypeNameAndDebug(zone, 0);
-}
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 

src/dynamicFvMesh/dynamicMotionSolverFvMesh/dynamicMotionSolverFvMesh.C

@@ -28,20 +28,23 @@ License
 #include "motionSolver.H"
 #include "volFields.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
+    defineTypeNameAndDebug(dynamicMotionSolverFvMesh, 0);
+    addToRunTimeSelectionTable
+    (
+        dynamicFvMesh,
+        dynamicMotionSolverFvMesh,
+        IOobject
+    );
+}
 
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-defineTypeNameAndDebug(dynamicMotionSolverFvMesh, 0);
-
-addToRunTimeSelectionTable(dynamicFvMesh, dynamicMotionSolverFvMesh, IOobject);
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-dynamicMotionSolverFvMesh::dynamicMotionSolverFvMesh(const IOobject& io)
+Foam::dynamicMotionSolverFvMesh::dynamicMotionSolverFvMesh(const IOobject& io)
 :
     dynamicFvMesh(io),
     motionPtr_(motionSolver::New(*this))
@@ -50,13 +53,13 @@ dynamicMotionSolverFvMesh::dynamicMotionSolverFvMesh(const IOobject& io)
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-dynamicMotionSolverFvMesh::~dynamicMotionSolverFvMesh()
+Foam::dynamicMotionSolverFvMesh::~dynamicMotionSolverFvMesh()
 {}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-bool dynamicMotionSolverFvMesh::update()
+bool Foam::dynamicMotionSolverFvMesh::update()
 {
     fvMesh::movePoints(motionPtr_->newPoints());
 
@@ -71,8 +74,4 @@ bool dynamicMotionSolverFvMesh::update()
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/dynamicFvMesh/staticFvMesh/staticFvMesh.C

@@ -28,19 +28,18 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-namespace Foam
-{
-
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(staticFvMesh, 0);
+namespace Foam
+{
+    defineTypeNameAndDebug(staticFvMesh, 0);
+    addToRunTimeSelectionTable(dynamicFvMesh, staticFvMesh, IOobject);
+}
 
-addToRunTimeSelectionTable(dynamicFvMesh, staticFvMesh, IOobject);
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-//- Construct from objectRegistry, and read/write options
+Foam::staticFvMesh::staticFvMesh(const IOobject& io)
-staticFvMesh::staticFvMesh(const IOobject& io)
 :
     dynamicFvMesh(io)
 {}
@@ -48,20 +47,16 @@ staticFvMesh::staticFvMesh(const IOobject& io)
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-staticFvMesh::~staticFvMesh()
+Foam::staticFvMesh::~staticFvMesh()
 {}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-bool staticFvMesh::update()
+bool Foam::staticFvMesh::update()
 {
     return false;
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/dynamicMesh/setUpdater/setUpdaterTemplates.C

@@ -29,15 +29,10 @@ License
 #include "mapPolyMesh.H"
 #include "IOobjectList.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class Type>
-void setUpdater::updateSets(const mapPolyMesh& morphMap) const
+void Foam::setUpdater::updateSets(const mapPolyMesh& morphMap) const
 {
     //
     // Update all sets in memory.
@@ -106,8 +101,4 @@ void setUpdater::updateSets(const mapPolyMesh& morphMap) const
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/engine/engineMesh/fvMotionSolverEngineMesh/fvMotionSolverEngineMesh.C

@@ -28,20 +28,18 @@ License
 #include "fvcMeshPhi.H"
 #include "surfaceInterpolate.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
+    defineTypeNameAndDebug(fvMotionSolverEngineMesh, 0);
+    addToRunTimeSelectionTable(engineMesh, fvMotionSolverEngineMesh, IOobject);
+}
 
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-defineTypeNameAndDebug(fvMotionSolverEngineMesh, 0);
-
-addToRunTimeSelectionTable(engineMesh, fvMotionSolverEngineMesh, IOobject);
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-fvMotionSolverEngineMesh::fvMotionSolverEngineMesh(const IOobject& io)
+Foam::fvMotionSolverEngineMesh::fvMotionSolverEngineMesh(const IOobject& io)
 :
     engineMesh(io),
     pistonLayers_("pistonLayers", dimLength, 0.0),
@@ -56,13 +54,13 @@ fvMotionSolverEngineMesh::fvMotionSolverEngineMesh(const IOobject& io)
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-fvMotionSolverEngineMesh::~fvMotionSolverEngineMesh()
+Foam::fvMotionSolverEngineMesh::~fvMotionSolverEngineMesh()
 {}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void fvMotionSolverEngineMesh::move()
+void Foam::fvMotionSolverEngineMesh::move()
 {
     scalar deltaZ = engineDB_.pistonDisplacement().value();
     Info<< "deltaZ = " << deltaZ << endl;
@@ -125,8 +123,4 @@ void fvMotionSolverEngineMesh::move()
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/engine/engineMesh/staticEngineMesh/staticEngineMesh.C

@@ -26,21 +26,17 @@ License
 #include "staticEngineMesh.H"
 #include "addToRunTimeSelectionTable.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
 namespace Foam
 {
+    defineTypeNameAndDebug(staticEngineMesh, 0);
+    addToRunTimeSelectionTable(engineMesh, staticEngineMesh, IOobject);
+}
 
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-defineTypeNameAndDebug(staticEngineMesh, 0);
-
-addToRunTimeSelectionTable(engineMesh, staticEngineMesh, IOobject);
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-//- Construct from objectRegistry, and read/write options
+Foam::staticEngineMesh::staticEngineMesh(const IOobject& io)
-staticEngineMesh::staticEngineMesh(const IOobject& io)
 :
     engineMesh(io)
 {}
@@ -48,18 +44,14 @@ staticEngineMesh::staticEngineMesh(const IOobject& io)
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-staticEngineMesh::~staticEngineMesh()
+Foam::staticEngineMesh::~staticEngineMesh()
 {}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void staticEngineMesh::move()
+void Foam::staticEngineMesh::move()
 {}
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/engine/ignition/ignition.C

@@ -26,14 +26,10 @@ License
 #include "ignition.H"
 #include "fvMesh.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-bool ignition::igniting() const
+bool Foam::ignition::igniting() const
 {
     if (!ignite())
     {
@@ -54,7 +50,7 @@ bool ignition::igniting() const
 }
 
 
-bool ignition::ignited() const
+bool Foam::ignition::ignited() const
 {
     if (!ignite())
     {
@@ -75,8 +71,4 @@ bool ignition::ignited() const
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/engine/ignition/ignitionIO.C

@@ -26,14 +26,9 @@ License
 #include "engineTime.H"
 #include "ignition.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-ignition::ignition
+Foam::ignition::ignition
 (
     const dictionary& combustionProperties,
     const Time& db,
@@ -59,7 +54,7 @@ ignition::ignition
 }
 
 
-ignition::ignition
+Foam::ignition::ignition
 (
     const dictionary& combustionProperties,
     const engineTime& edb,
@@ -85,8 +80,4 @@ ignition::ignition
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/engine/ignition/ignitionSite.C

@@ -27,14 +27,9 @@ License
 #include "Time.H"
 #include "volFields.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void ignitionSite::findIgnitionCells(const fvMesh& mesh)
+void Foam::ignitionSite::findIgnitionCells(const fvMesh& mesh)
 {
     // Bit tricky: generate C and V before shortcutting if cannot find
     // cell locally. mesh.C generation uses parallel communication.
@@ -90,7 +85,7 @@ void ignitionSite::findIgnitionCells(const fvMesh& mesh)
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-const labelList& ignitionSite::cells() const
+const Foam::labelList& Foam::ignitionSite::cells() const
 {
     if (mesh_.changing() && timeIndex_ != db_.timeIndex())
     {
@@ -102,7 +97,7 @@ const labelList& ignitionSite::cells() const
 }
 
 
-bool ignitionSite::igniting() const
+bool Foam::ignitionSite::igniting() const
 {
     scalar curTime = db_.value();
     scalar deltaT = db_.deltaTValue();
@@ -116,7 +111,7 @@ bool ignitionSite::igniting() const
 }
 
 
-bool ignitionSite::ignited() const
+bool Foam::ignitionSite::ignited() const
 {
     scalar curTime = db_.value();
     scalar deltaT = db_.deltaTValue();
@@ -127,7 +122,7 @@ bool ignitionSite::ignited() const
 
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
-void ignitionSite::operator=(const ignitionSite& is)
+void Foam::ignitionSite::operator=(const ignitionSite& is)
 {
     location_ = is.location_;
     diameter_ = is.diameter_;
@@ -139,8 +134,4 @@ void ignitionSite::operator=(const ignitionSite& is)
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/engine/ignition/ignitionSiteIO.C

@@ -26,14 +26,14 @@ License
 #include "ignitionSite.H"
 #include "engineTime.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-ignitionSite::ignitionSite(Istream& is, const Time& db, const fvMesh& mesh)
+Foam::ignitionSite::ignitionSite
+(
+    Istream& is,
+    const Time& db,
+    const fvMesh& mesh
+)
 :
     db_(db),
     mesh_(mesh),
@@ -64,7 +64,7 @@ ignitionSite::ignitionSite(Istream& is, const Time& db, const fvMesh& mesh)
 }
 
 
-ignitionSite::ignitionSite
+Foam::ignitionSite::ignitionSite
 (
     Istream& is,
     const engineTime& edb,
@@ -100,8 +100,4 @@ ignitionSite::ignitionSite
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/lagrangian/basic/indexedParticle/indexedParticleCloud.C

@@ -25,19 +25,14 @@ License
 
 #include "indexedParticleCloud.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
+    defineParticleTypeNameAndDebug(indexedParticle, 0);
+    defineTemplateTypeNameAndDebug(Cloud<indexedParticle>, 0);
+}
 
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-defineParticleTypeNameAndDebug(indexedParticle, 0);
-defineTemplateTypeNameAndDebug(Cloud<indexedParticle>, 0);
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 

src/lagrangian/dieselSpray/injector/injector/injectorIO.C

@@ -26,14 +26,10 @@ License
 #include "injector.H"
 #include "dictionary.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-injector::injector(const Time& t, Istream& is)
+Foam::injector::injector(const Time& t, Istream& is)
 :
     injectorDict_(is),
     properties_(injectorType::New(t, injectorDict_))
@@ -46,7 +42,7 @@ injector::injector(const Time& t, Istream& is)
 
 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 
-Ostream& operator<<(Ostream& os, const injector& injector)
+Foam::Ostream& Foam::operator<<(Ostream& os, const injector& injector)
 {
     // Check state of Ostream
     os.check("Ostream& operator<<(Ostream&, const injector&)");
@@ -57,8 +53,4 @@ Ostream& operator<<(Ostream& os, const injector& injector)
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/lagrangian/dieselSpray/parcel/parcelFunctions.C

@@ -26,15 +26,10 @@ License
 #include "parcel.H"
 #include "mathematicalConstants.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 // The diameter based Reynolds number
-scalar parcel::Re
+Foam::scalar Foam::parcel::Re
 (
     const vector& U,
     const scalar nu
@@ -44,7 +39,7 @@ scalar parcel::Re
 }
 
 // The diameter based Reynolds number
-scalar parcel::Re
+Foam::scalar Foam::parcel::Re
 (
     const scalar rho,
     const vector& U,
@@ -56,7 +51,7 @@ scalar parcel::Re
 }
 
 // The diameter based Weber number
-scalar parcel::We
+Foam::scalar Foam::parcel::We
 (
     const vector& U,
     const scalar rho,
@@ -67,7 +62,7 @@ scalar parcel::We
 }
 
 
-scalar parcel::Sc
+Foam::scalar Foam::parcel::Sc
 (
     const scalar mu,
     const scalar rho,
@@ -78,7 +73,7 @@ scalar parcel::Sc
 }
 
 
-scalar parcel::Sc
+Foam::scalar Foam::parcel::Sc
 (
     const scalar nu,
     const scalar massDiffusion
@@ -88,7 +83,7 @@ scalar parcel::Sc
 }
 
 
-scalar parcel::Pr
+Foam::scalar Foam::parcel::Pr
 (
     const scalar cp,
     const scalar mu,
@@ -99,26 +94,22 @@ scalar parcel::Pr
 }
 
 
-scalar parcel::N(const scalar rho) const
+Foam::scalar Foam::parcel::N(const scalar rho) const
 {
     return 6.0*m_/(rho*pow3(d_)*constant::mathematical::pi);
 }
 
 
-scalar parcel::Vd() const
+Foam::scalar Foam::parcel::Vd() const
 {
     return pow3(d_)*constant::mathematical::pi/6.0;
 }
 
 
-scalar parcel::V(const scalar rho) const
+Foam::scalar Foam::parcel::V(const scalar rho) const
 {
     return m_/rho;
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/lagrangian/dieselSpray/parcel/setRelaxationTimes.C

@@ -31,14 +31,10 @@ License
 #include "heatTransferModel.H"
 #include "basicMultiComponentMixture.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void parcel::setRelaxationTimes
+void Foam::parcel::setRelaxationTimes
 (
     label celli,
     scalar& tauMomentum,
@@ -55,7 +51,6 @@ void parcel::setRelaxationTimes
     const scalar dt
 )
 {
-
     const liquidMixture& fuels = sDB.fuels();
 
     scalar mCell = rho*sDB.mesh().V()[cell()];
@@ -292,8 +287,4 @@ void parcel::setRelaxationTimes
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/lagrangian/dieselSpray/spray/sprayFunctions.C

@@ -26,14 +26,10 @@ License
 #include "spray.H"
 #include "mathematicalConstants.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-scalar spray::injectedMass(const scalar t) const
+Foam::scalar Foam::spray::injectedMass(const scalar t) const
 {
     scalar sum = 0.0;
 
@@ -46,7 +42,7 @@ scalar spray::injectedMass(const scalar t) const
 }
 
 
-scalar spray::totalMassToInject() const
+Foam::scalar Foam::spray::totalMassToInject() const
 {
     scalar sum = 0.0;
 
@@ -59,7 +55,7 @@ scalar spray::totalMassToInject() const
 }
 
 
-scalar spray::injectedEnthalpy
+Foam::scalar Foam::spray::injectedEnthalpy
 (
     const scalar time
 ) const
@@ -89,7 +85,7 @@ scalar spray::injectedEnthalpy
 }
 
 
-scalar spray::liquidMass() const
+Foam::scalar Foam::spray::liquidMass() const
 {
     scalar sum = 0.0;
 
@@ -109,7 +105,7 @@ scalar spray::liquidMass() const
 }
 
 
-scalar spray::liquidEnthalpy() const
+Foam::scalar Foam::spray::liquidEnthalpy() const
 {
     scalar sum = 0.0;
     label Nf = fuels().components().size();
@@ -146,7 +142,7 @@ scalar spray::liquidEnthalpy() const
 }
 
 
-scalar spray::liquidTotalEnthalpy() const
+Foam::scalar Foam::spray::liquidTotalEnthalpy() const
 {
     scalar sum = 0.0;
     label Nf = fuels().components().size();
@@ -186,7 +182,7 @@ scalar spray::liquidTotalEnthalpy() const
 }
 
 
-scalar spray::liquidKineticEnergy() const
+Foam::scalar Foam::spray::liquidKineticEnergy() const
 {
     scalar sum = 0.0;
 
@@ -208,19 +204,19 @@ scalar spray::liquidKineticEnergy() const
 }
 
 
-scalar spray::injectedLiquidKineticEnergy() const
+Foam::scalar Foam::spray::injectedLiquidKineticEnergy() const
 {
     return injectedLiquidKE_;
 }
 
 
-scalar spray::liquidPenetration(const scalar prc) const
+Foam::scalar Foam::spray::liquidPenetration(const scalar prc) const
 {
     return liquidPenetration(0, prc);
 }
 
 
-scalar spray::liquidPenetration
+Foam::scalar Foam::spray::liquidPenetration
 (
     const label nozzlei,
     const scalar prc
@@ -349,7 +345,7 @@ scalar spray::liquidPenetration
 }
 
 
-scalar spray::smd() const
+Foam::scalar Foam::spray::smd() const
 {
     scalar numerator = 0.0, denominator = VSMALL;
 
@@ -372,7 +368,7 @@ scalar spray::smd() const
 }
 
 
-scalar spray::maxD() const
+Foam::scalar Foam::spray::maxD() const
 {
     scalar maxD = 0.0;
 
@@ -387,20 +383,16 @@ scalar spray::maxD() const
 }
 
 
-void spray::calculateAmbientPressure()
+void Foam::spray::calculateAmbientPressure()
 {
     ambientPressure_ = p_.average().value();
 }
 
 
-void spray::calculateAmbientTemperature()
+void Foam::spray::calculateAmbientTemperature()
 {
     ambientTemperature_ = T_.average().value();
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/lagrangian/dieselSpray/spray/sprayInject.C

@@ -31,12 +31,7 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-namespace Foam
+void Foam::spray::inject()
-{
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void spray::inject()
 {
     scalar time = runTime_.value();
     scalar time0 = time0_;
@@ -172,8 +167,4 @@ void spray::inject()
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/lagrangian/molecularDynamics/molecule/interactionLists/referredCell/referredCell.C

@@ -26,12 +26,10 @@ License
 #include "referredCell.H"
 #include "interactionLists.H"
 
-namespace Foam
-{
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void referredCell::setConstructionData
+void Foam::referredCell::setConstructionData
 (
     const polyMesh& mesh,
     const label sourceCell
@@ -92,7 +90,7 @@ void referredCell::setConstructionData
 }
 
 
-void referredCell::locallyMapEdgeList
+void Foam::referredCell::locallyMapEdgeList
 (
     const labelList& points,
     const edgeList& sourceCellEdges
@@ -125,7 +123,7 @@ void referredCell::locallyMapEdgeList
 }
 
 
-void referredCell::locallyMapFaceList
+void Foam::referredCell::locallyMapFaceList
 (
     const labelList& points,
     const labelListList& sourceCellFaces
@@ -159,25 +157,31 @@ void referredCell::locallyMapFaceList
 }
 
 
-vector referredCell::referPosition(const vector& positionToRefer)
+Foam::vector Foam::referredCell::referPosition(const vector& positionToRefer)
 {
     return offset_ + (rotation_ & positionToRefer);
 }
 
 
-vectorList referredCell::referPositions(const vectorList& positionsToRefer)
+Foam::vectorList Foam::referredCell::referPositions
+(
+    const vectorList& positionsToRefer
+)
 {
     return offset_ + (rotation_ & positionsToRefer);
 }
 
 
-vector referredCell::rotateVector(const vector& vectorToRotate)
+Foam::vector Foam::referredCell::rotateVector(const vector& vectorToRotate)
 {
     return rotation_ & vectorToRotate;
 }
 
 
-vectorList referredCell::rotateVectors(const vectorList& vectorsToRotate)
+Foam::vectorList Foam::referredCell::rotateVectors
+(
+    const vectorList& vectorsToRotate
+)
 {
     return rotation_ & vectorsToRotate;
 }
@@ -185,7 +189,7 @@ vectorList referredCell::rotateVectors(const vectorList& vectorsToRotate)
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-referredCell::referredCell()
+Foam::referredCell::referredCell()
 :
     DynamicList<referredMolecule>(),
     sourceProc_(-1),
@@ -196,7 +200,7 @@ referredCell::referredCell()
 {}
 
 
-referredCell::referredCell
+Foam::referredCell::referredCell
 (
     const polyMesh& mesh,
     const label sourceProc,
@@ -215,7 +219,7 @@ referredCell::referredCell
 }
 
 
-referredCell::referredCell
+Foam::referredCell::referredCell
 (
     const label sourceProc,
     const label sourceCell,
@@ -248,7 +252,7 @@ referredCell::referredCell
 }
 
 
-referredCell::referredCell
+Foam::referredCell::referredCell
 (
     const polyMesh& mesh,
     const label sourceProc,
@@ -285,13 +289,13 @@ referredCell::referredCell
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-referredCell::~referredCell()
+Foam::referredCell::~referredCell()
 {}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-referredCell referredCell::reRefer
+Foam::referredCell Foam::referredCell::reRefer
 (
     const vector& cS,
     const vector& cD,
@@ -325,13 +329,16 @@ referredCell referredCell::reRefer
 }
 
 
-vector referredCell::referPosition(const vector& positionToRefer) const
+Foam::vector Foam::referredCell::referPosition
+(
+    const vector& positionToRefer
+) const
 {
     return offset_ + (rotation_ & positionToRefer);
 }
 
 
-vectorList referredCell::referPosition
+Foam::vectorList Foam::referredCell::referPosition
 (
     const vectorList& positionsToRefer
 ) const
@@ -340,19 +347,25 @@ vectorList referredCell::referPosition
 }
 
 
-vector referredCell::rotateVector(const vector& vectorToRotate) const
+Foam::vector Foam::referredCell::rotateVector
+(
+    const vector& vectorToRotate
+) const
 {
     return rotation_ & vectorToRotate;
 }
 
 
-vectorList referredCell::rotateVectors(const vectorList& vectorsToRotate) const
+Foam::vectorList Foam::referredCell::rotateVectors
+(
+    const vectorList& vectorsToRotate
+) const
 {
     return rotation_ & vectorsToRotate;
 }
 
 
-void referredCell::referInMols(const List<referredMolecule>& incomingMols)
+void Foam::referredCell::referInMols(const List<referredMolecule>& incomingMols)
 {
     clear();
 
@@ -379,7 +392,7 @@ void referredCell::referInMols(const List<referredMolecule>& incomingMols)
 }
 
 
-bool referredCell::duplicate(const referredCell& refCellDupl) const
+bool Foam::referredCell::duplicate(const referredCell& refCellDupl) const
 {
     return
     (
@@ -390,7 +403,7 @@ bool referredCell::duplicate(const referredCell& refCellDupl) const
 }
 
 
-bool referredCell::duplicate(const label procNo,const label nCells) const
+bool Foam::referredCell::duplicate(const label procNo,const label nCells) const
 {
     return
     (
@@ -403,9 +416,8 @@ bool referredCell::duplicate(const label procNo,const label nCells) const
 
 // * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
 
-Istream& operator>>(Istream& is, referredCell& rC)
+Foam::Istream& Foam::operator>>(Istream& is, referredCell& rC)
 {
-
     is  >> rC.sourceProc_
         >> rC.sourceCell_
         >> rC.vertexPositions_
@@ -422,9 +434,8 @@ Istream& operator>>(Istream& is, referredCell& rC)
 }
 
 
-Ostream& operator<<(Ostream& os, const referredCell& rC)
+Foam::Ostream& Foam::operator<<(Ostream& os, const referredCell& rC)
 {
-
     os  << rC.sourceProc()
         << token::SPACE << rC.sourceCell()
         << token::SPACE << rC.vertexPositions()
@@ -441,8 +452,4 @@ Ostream& operator<<(Ostream& os, const referredCell& rC)
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-}  // End namespace Foam
-
 // ************************************************************************* //

src/lagrangian/molecularDynamics/potential/energyScalingFunction/basic/energyScalingFunction.C

@@ -25,15 +25,14 @@ License
 
 #include "energyScalingFunction.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
+    defineTypeNameAndDebug(energyScalingFunction, 0);
+    defineRunTimeSelectionTable(energyScalingFunction, dictionary);
+}
 
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-defineTypeNameAndDebug(energyScalingFunction, 0);
-defineRunTimeSelectionTable(energyScalingFunction, dictionary);
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -64,8 +63,4 @@ bool Foam::energyScalingFunction::read
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/transportModels/incompressible/incompressibleTwoPhaseMixture/twoPhaseMixture.C

@@ -28,15 +28,11 @@ License
 #include "surfaceFields.H"
 #include "fvc.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
 
 // * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
 
 //- Calculate and return the laminar viscosity
-void twoPhaseMixture::calcNu()
+void Foam::twoPhaseMixture::calcNu()
 {
     nuModel1_->correct();
     nuModel2_->correct();
@@ -54,7 +50,7 @@ void twoPhaseMixture::calcNu()
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-twoPhaseMixture::twoPhaseMixture
+Foam::twoPhaseMixture::twoPhaseMixture
 (
     const volVectorField& U,
     const surfaceScalarField& phi,
@@ -114,7 +110,7 @@ twoPhaseMixture::twoPhaseMixture
 
 // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 
-tmp<volScalarField> twoPhaseMixture::mu() const
+Foam::tmp<Foam::volScalarField> Foam::twoPhaseMixture::mu() const
 {
     volScalarField limitedAlpha1 = min(max(alpha1_, scalar(0)), scalar(1));
 
@@ -130,7 +126,7 @@ tmp<volScalarField> twoPhaseMixture::mu() const
 }
 
 
-tmp<surfaceScalarField> twoPhaseMixture::muf() const
+Foam::tmp<Foam::surfaceScalarField> Foam::twoPhaseMixture::muf() const
 {
     surfaceScalarField alpha1f =
         min(max(fvc::interpolate(alpha1_), scalar(0)), scalar(1));
@@ -147,7 +143,7 @@ tmp<surfaceScalarField> twoPhaseMixture::muf() const
 }
 
 
-tmp<surfaceScalarField> twoPhaseMixture::nuf() const
+Foam::tmp<Foam::surfaceScalarField> Foam::twoPhaseMixture::nuf() const
 {
     surfaceScalarField alpha1f =
         min(max(fvc::interpolate(alpha1_), scalar(0)), scalar(1));
@@ -166,7 +162,7 @@ tmp<surfaceScalarField> twoPhaseMixture::nuf() const
 }
 
 
-bool twoPhaseMixture::read()
+bool Foam::twoPhaseMixture::read()
 {
     if (transportModel::read())
     {
@@ -193,8 +189,4 @@ bool twoPhaseMixture::read()
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/transportModels/incompressible/singlePhaseTransportModel/singlePhaseTransportModel.C

@@ -27,15 +27,10 @@ License
 #include "viscosityModel.H"
 #include "volFields.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-singlePhaseTransportModel::singlePhaseTransportModel
+Foam::singlePhaseTransportModel::singlePhaseTransportModel
 (
     const volVectorField& U,
     const surfaceScalarField& phi
@@ -48,25 +43,25 @@ singlePhaseTransportModel::singlePhaseTransportModel
 
 // * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
 
-singlePhaseTransportModel::~singlePhaseTransportModel()
+Foam::singlePhaseTransportModel::~singlePhaseTransportModel()
 {}
 
 
 // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 
-tmp<volScalarField> singlePhaseTransportModel::nu() const
+Foam::tmp<Foam::volScalarField> Foam::singlePhaseTransportModel::nu() const
 {
     return viscosityModelPtr_->nu();
 }
 
 
-void singlePhaseTransportModel::correct()
+void Foam::singlePhaseTransportModel::correct()
 {
     viscosityModelPtr_->correct();
 }
 
 
-bool singlePhaseTransportModel::read()
+bool Foam::singlePhaseTransportModel::read()
 {
     if (regIOobject::read())
     {
@@ -79,8 +74,4 @@ bool singlePhaseTransportModel::read()
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //