Merge commit 'origin/master' into splitCyclic

applications/solvers/basic/laplacianFoam/laplacianFoam.C

@@ -31,19 +31,17 @@ Description
 
 #include "fvCFD.H"
 
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 int main(int argc, char *argv[])
 {
-
     #include "setRootCase.H"
 
     #include "createTime.H"
     #include "createMesh.H"
     #include "createFields.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
     Info<< "\nCalculating temperature distribution\n" << endl;
 

applications/solvers/basic/potentialFoam/potentialFoam.C

@@ -45,7 +45,7 @@ int main(int argc, char *argv[])
     #include "createFields.H"
     #include "readSIMPLEControls.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
     Info<< nl << "Calculating potential flow" << endl;
 

applications/solvers/combustion/PDRFoam/Make/files

@@ -1,25 +1,25 @@
 XiModels/XiModel/XiModel.C
-XiModels/XiModel/newXiModel.C
+XiModels/XiModel/XiModelNew.C
 XiModels/fixed/fixed.C
 XiModels/algebraic/algebraic.C
 XiModels/transport/transport.C
 
 XiModels/XiEqModels/XiEqModel/XiEqModel.C
-XiModels/XiEqModels/XiEqModel/newXiEqModel.C
+XiModels/XiEqModels/XiEqModel/XiEqModelNew.C
 XiModels/XiEqModels/Gulder/Gulder.C
 XiModels/XiEqModels/instabilityXiEq/instabilityXiEq.C
 XiModels/XiEqModels/SCOPEBlendXiEq/SCOPEBlendXiEq.C
 XiModels/XiEqModels/SCOPEXiEq/SCOPEXiEq.C
 
 XiModels/XiGModels/XiGModel/XiGModel.C
-XiModels/XiGModels/XiGModel/newXiGModel.C
+XiModels/XiGModels/XiGModel/XiGModelNew.C
 XiModels/XiGModels/KTS/KTS.C
 XiModels/XiGModels/instabilityG/instabilityG.C
 
 PDRModels/turbulence/PDRkEpsilon/PDRkEpsilon.C
 
 PDRModels/dragModels/PDRDragModel/PDRDragModel.C
-PDRModels/dragModels/PDRDragModel/newPDRDragModel.C
+PDRModels/dragModels/PDRDragModel/PDRDragModelNew.C
 PDRModels/dragModels/basic/basic.C
 
 PDRModels/XiEqModels/basicXiSubXiEq/basicXiSubXiEq.C

applications/solvers/combustion/PDRFoam/PDRModels/dragModels/PDRDragModel/PDRDragModelNew.C

@@ -36,12 +36,12 @@ Foam::autoPtr<Foam::PDRDragModel> Foam::PDRDragModel::New
     const surfaceScalarField& phi
 )
 {
-    word PDRDragModelTypeName = PDRProperties.lookup("PDRDragModel");
+    const word modelType(PDRProperties.lookup("PDRDragModel"));
 
-    Info<< "Selecting flame-wrinkling model " << PDRDragModelTypeName << endl;
+    Info<< "Selecting flame-wrinkling model " << modelType << endl;
 
     dictionaryConstructorTable::iterator cstrIter =
-        dictionaryConstructorTablePtr_->find(PDRDragModelTypeName);
+        dictionaryConstructorTablePtr_->find(modelType);
 
     if (cstrIter == dictionaryConstructorTablePtr_->end())
     {
@@ -49,7 +49,7 @@ Foam::autoPtr<Foam::PDRDragModel> Foam::PDRDragModel::New
         (
             "PDRDragModel::New"
         )   << "Unknown PDRDragModel type "
-            << PDRDragModelTypeName << endl << endl
+            << modelType << nl << nl
             << "Valid  PDRDragModels are : " << endl
             << dictionaryConstructorTablePtr_->sortedToc()
             << exit(FatalError);

applications/solvers/combustion/PDRFoam/XiModels/XiEqModels/XiEqModel/XiEqModelNew.C

@@ -29,18 +29,18 @@ License
 
 Foam::autoPtr<Foam::XiEqModel> Foam::XiEqModel::New
 (
-    const dictionary& XiEqProperties,
+    const dictionary& propDict,
     const hhuCombustionThermo& thermo,
     const compressible::RASModel& turbulence,
     const volScalarField& Su
 )
 {
-    word XiEqModelTypeName = XiEqProperties.lookup("XiEqModel");
+    const word modelType(propDict.lookup("XiEqModel"));
 
-    Info<< "Selecting flame-wrinkling model " << XiEqModelTypeName << endl;
+    Info<< "Selecting flame-wrinkling model " << modelType << endl;
 
     dictionaryConstructorTable::iterator cstrIter =
-        dictionaryConstructorTablePtr_->find(XiEqModelTypeName);
+        dictionaryConstructorTablePtr_->find(modelType);
 
     if (cstrIter == dictionaryConstructorTablePtr_->end())
     {
@@ -53,14 +53,13 @@ Foam::autoPtr<Foam::XiEqModel> Foam::XiEqModel::New
             "    const volScalarField& Su"
             ")"
         )   << "Unknown XiEqModel type "
-            << XiEqModelTypeName << endl << endl
+            << modelType << nl << nl
             << "Valid XiEqModels are : " << endl
             << dictionaryConstructorTablePtr_->sortedToc()
             << exit(FatalError);
     }
 
-    return autoPtr<XiEqModel>
-        (cstrIter()(XiEqProperties, thermo, turbulence, Su));
+    return autoPtr<XiEqModel>(cstrIter()(propDict, thermo, turbulence, Su));
 }
 
 

applications/solvers/combustion/PDRFoam/XiModels/XiGModels/XiGModel/XiGModelNew.C

@@ -29,18 +29,18 @@ License
 
 Foam::autoPtr<Foam::XiGModel> Foam::XiGModel::New
 (
-    const dictionary& XiGProperties,
+    const dictionary& propDict,
     const hhuCombustionThermo& thermo,
     const compressible::RASModel& turbulence,
     const volScalarField& Su
 )
 {
-    word XiGModelTypeName = XiGProperties.lookup("XiGModel");
+    const word modelType(propDict.lookup("XiGModel"));
 
-    Info<< "Selecting flame-wrinkling model " << XiGModelTypeName << endl;
+    Info<< "Selecting flame-wrinkling model " << modelType << endl;
 
     dictionaryConstructorTable::iterator cstrIter =
-        dictionaryConstructorTablePtr_->find(XiGModelTypeName);
+        dictionaryConstructorTablePtr_->find(modelType);
 
     if (cstrIter == dictionaryConstructorTablePtr_->end())
     {
@@ -53,14 +53,13 @@ Foam::autoPtr<Foam::XiGModel> Foam::XiGModel::New
             "    const volScalarField& Su"
             ")"
         )   << "Unknown XiGModel type "
-            << XiGModelTypeName << endl << endl
+            << modelType << nl << nl
             << "Valid XiGModels are : " << endl
             << dictionaryConstructorTablePtr_->sortedToc()
             << exit(FatalError);
     }
 
-    return autoPtr<XiGModel>
-        (cstrIter()(XiGProperties, thermo, turbulence, Su));
+    return autoPtr<XiGModel>(cstrIter()(propDict, thermo, turbulence, Su));
 }
 
 

applications/solvers/combustion/PDRFoam/XiModels/XiModel/XiModelNew.C

@@ -29,7 +29,7 @@ License
 
 Foam::autoPtr<Foam::XiModel> Foam::XiModel::New
 (
-    const dictionary& XiProperties,
+    const dictionary& propDict,
     const hhuCombustionThermo& thermo,
     const compressible::RASModel& turbulence,
     const volScalarField& Su,
@@ -38,12 +38,12 @@ Foam::autoPtr<Foam::XiModel> Foam::XiModel::New
     const surfaceScalarField& phi
 )
 {
-    word XiModelTypeName = XiProperties.lookup("XiModel");
+    const word modelType(propDict.lookup("XiModel"));
 
-    Info<< "Selecting flame-wrinkling model " << XiModelTypeName << endl;
+    Info<< "Selecting flame-wrinkling model " << modelType << endl;
 
     dictionaryConstructorTable::iterator cstrIter =
-        dictionaryConstructorTablePtr_->find(XiModelTypeName);
+        dictionaryConstructorTablePtr_->find(modelType);
 
     if (cstrIter == dictionaryConstructorTablePtr_->end())
     {
@@ -51,14 +51,14 @@ Foam::autoPtr<Foam::XiModel> Foam::XiModel::New
         (
             "XiModel::New"
         )   << "Unknown XiModel type "
-            << XiModelTypeName << endl << endl
+            << modelType << nl << nl
             << "Valid XiModels are : " << endl
             << dictionaryConstructorTablePtr_->sortedToc()
             << exit(FatalError);
     }
 
     return autoPtr<XiModel>
-        (cstrIter()(XiProperties, thermo, turbulence, Su, rho, b, phi));
+        (cstrIter()(propDict, thermo, turbulence, Su, rho, b, phi));
 }
 
 

applications/solvers/combustion/fireFoam/combustionModels/Make/files

@@ -1,5 +1,5 @@
 combustionModel/combustionModel.C
-combustionModel/newCombustionModel.C
+combustionModel/combustionModelNew.C
 
 infinitelyFastChemistry/infinitelyFastChemistry.C
 

applications/solvers/combustion/fireFoam/combustionModels/combustionModel/combustionModelNew.C

@@ -29,22 +29,19 @@ License
 
 Foam::autoPtr<Foam::combustionModel> Foam::combustionModel::New
 (
-    const dictionary& combustionProperties,
+    const dictionary& propDict,
     const hsCombustionThermo& thermo,
     const compressible::turbulenceModel& turbulence,
     const surfaceScalarField& phi,
     const volScalarField& rho
 )
 {
-    word combustionModelTypeName = combustionProperties.lookup
-    (
-        "combustionModel"
-    );
+    const word modelType(propDict.lookup("combustionModel"));
 
-    Info<< "Selecting combustion model " << combustionModelTypeName << endl;
+    Info<< "Selecting combustion model " << modelType << endl;
 
     dictionaryConstructorTable::iterator cstrIter =
-        dictionaryConstructorTablePtr_->find(combustionModelTypeName);
+        dictionaryConstructorTablePtr_->find(modelType);
 
     if (cstrIter == dictionaryConstructorTablePtr_->end())
     {
@@ -52,14 +49,14 @@ Foam::autoPtr<Foam::combustionModel> Foam::combustionModel::New
         (
             "combustionModel::New"
         )   << "Unknown combustionModel type "
-            << combustionModelTypeName << endl << endl
+            << modelType << nl << nl
             << "Valid combustionModels are : " << endl
             << dictionaryConstructorTablePtr_->toc()
             << exit(FatalError);
     }
 
     return autoPtr<combustionModel>
-        (cstrIter()(combustionProperties, thermo, turbulence, phi, rho));
+        (cstrIter()(propDict, thermo, turbulence, phi, rho));
 }
 
 

applications/solvers/combustion/fireFoam/createFields.H

@@ -71,9 +71,9 @@ IOdictionary combustionProperties
 );
 
 Info<< "Creating combustion model\n" << endl;
-autoPtr<combustionModel::combustionModel> combustion
+autoPtr<combustionModel> combustion
 (
-    combustionModel::combustionModel::New
+    combustionModel::New
     (
         combustionProperties,
         thermo,

applications/solvers/compressible/rhoCentralFoam/Allwclean

@@ -4,5 +4,6 @@ set -x
 
 wclean libso BCs
 wclean
+wclean rhoCentralDyMFoam
 
 # ----------------------------------------------------------------- end-of-file

applications/solvers/compressible/rhoCentralFoam/Allwmake

@@ -4,5 +4,6 @@ set -x
 
 wmake libso BCs
 wmake
+wmake rhoCentralDyMFoam
 
 # ----------------------------------------------------------------- end-of-file

applications/solvers/compressible/rhoCentralFoam/rhoCentralDyMFoam/Make/files

@@ -0,0 +1,3 @@
+rhoCentralDyMFoam.C
+
+EXE = $(FOAM_APPBIN)/rhoCentralDyMFoam

applications/solvers/compressible/rhoCentralFoam/rhoCentralDyMFoam/Make/options

@@ -0,0 +1,17 @@
+EXE_INC = \
+    -I.. \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
+    -I../BCs/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -lbasicThermophysicalModels \
+    -lspecie \
+    -lrhoCentralFoam \
+    -ldynamicMesh \
+    -lmeshTools

applications/solvers/compressible/rhoCentralFoam/rhoCentralDyMFoam/rhoCentralDyMFoam.C

@@ -0,0 +1,245 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 3 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, see <http://www.gnu.org/licenses/>.
+
+Application
+    rhoCentralFoam
+
+Description
+    Density-based compressible flow solver based on central-upwind schemes of
+    Kurganov and Tadmor
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "basicPsiThermo.H"
+#include "zeroGradientFvPatchFields.H"
+#include "fixedRhoFvPatchScalarField.H"
+#include "motionSolver.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    #include "setRootCase.H"
+
+    #include "createTime.H"
+    #include "createMesh.H"
+    #include "createFields.H"
+    #include "readThermophysicalProperties.H"
+    #include "readTimeControls.H"
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    #include "readFluxScheme.H"
+
+    dimensionedScalar v_zero("v_zero", dimVolume/dimTime, 0.0);
+
+    Info<< "\nStarting time loop\n" << endl;
+
+    autoPtr<Foam::motionSolver> motionPtr = motionSolver::New(mesh);
+
+    while (runTime.run())
+    {
+        // --- upwind interpolation of primitive fields on faces
+
+        surfaceScalarField rho_pos =
+            fvc::interpolate(rho, pos, "reconstruct(rho)");
+        surfaceScalarField rho_neg =
+            fvc::interpolate(rho, neg, "reconstruct(rho)");
+
+        surfaceVectorField rhoU_pos =
+            fvc::interpolate(rhoU, pos, "reconstruct(U)");
+        surfaceVectorField rhoU_neg =
+            fvc::interpolate(rhoU, neg, "reconstruct(U)");
+
+        volScalarField rPsi = 1.0/psi;
+        surfaceScalarField rPsi_pos =
+            fvc::interpolate(rPsi, pos, "reconstruct(T)");
+        surfaceScalarField rPsi_neg =
+            fvc::interpolate(rPsi, neg, "reconstruct(T)");
+
+        surfaceScalarField e_pos =
+            fvc::interpolate(e, pos, "reconstruct(T)");
+        surfaceScalarField e_neg =
+            fvc::interpolate(e, neg, "reconstruct(T)");
+
+        surfaceVectorField U_pos = rhoU_pos/rho_pos;
+        surfaceVectorField U_neg = rhoU_neg/rho_neg;
+
+        surfaceScalarField p_pos = rho_pos*rPsi_pos;
+        surfaceScalarField p_neg = rho_neg*rPsi_neg;
+
+        surfaceScalarField phiv_pos = U_pos & mesh.Sf();
+        surfaceScalarField phiv_neg = U_neg & mesh.Sf();
+
+        volScalarField c = sqrt(thermo.Cp()/thermo.Cv()*rPsi);
+        surfaceScalarField cSf_pos =
+            fvc::interpolate(c, pos, "reconstruct(T)")*mesh.magSf();
+        surfaceScalarField cSf_neg =
+            fvc::interpolate(c, neg, "reconstruct(T)")*mesh.magSf();
+
+        surfaceScalarField ap =
+            max(max(phiv_pos + cSf_pos, phiv_neg + cSf_neg), v_zero);
+        surfaceScalarField am =
+            min(min(phiv_pos - cSf_pos, phiv_neg - cSf_neg), v_zero);
+
+        surfaceScalarField a_pos = ap/(ap - am);
+
+        surfaceScalarField amaxSf("amaxSf", max(mag(am), mag(ap)));
+
+        surfaceScalarField aSf = am*a_pos;
+
+        if (fluxScheme == "Tadmor")
+        {
+            aSf = -0.5*amaxSf;
+            a_pos = 0.5;
+        }
+
+        surfaceScalarField a_neg = (1.0 - a_pos);
+
+        phiv_pos *= a_pos;
+        phiv_neg *= a_neg;
+
+        surfaceScalarField aphiv_pos = phiv_pos - aSf;
+        surfaceScalarField aphiv_neg = phiv_neg + aSf;
+
+        // Reuse amaxSf for the maximum positive and negative fluxes
+        // estimated by the central scheme
+        amaxSf = max(mag(aphiv_pos), mag(aphiv_neg));
+
+        #include "compressibleCourantNo.H"
+        #include "readTimeControls.H"
+        #include "setDeltaT.H"
+
+        runTime++;
+
+        Info<< "Time = " << runTime.timeName() << nl << endl;
+
+        mesh.movePoints(motionPtr->newPoints());
+        phiv_pos = U_pos & mesh.Sf();
+        phiv_neg = U_neg & mesh.Sf();
+        fvc::makeRelative(phiv_pos, U);
+        fvc::makeRelative(phiv_neg, U);
+        phiv_neg -= mesh.phi();
+        phiv_pos *= a_pos;
+        phiv_neg *= a_neg;
+        aphiv_pos = phiv_pos - aSf;
+        aphiv_neg = phiv_neg + aSf;
+
+        surfaceScalarField phi("phi", aphiv_pos*rho_pos + aphiv_neg*rho_neg);
+
+        surfaceVectorField phiUp =
+            (aphiv_pos*rhoU_pos + aphiv_neg*rhoU_neg)
+          + (a_pos*p_pos + a_neg*p_neg)*mesh.Sf();
+
+        surfaceScalarField phiEp =
+            aphiv_pos*(rho_pos*(e_pos + 0.5*magSqr(U_pos)) + p_pos)
+          + aphiv_neg*(rho_neg*(e_neg + 0.5*magSqr(U_neg)) + p_neg)
+          + aSf*p_pos - aSf*p_neg;
+
+        volTensorField tauMC("tauMC", mu*dev2(fvc::grad(U)().T()));
+
+        // --- Solve density
+        Info<< max(rho) << " " << min(rho) << endl;
+        solve(fvm::ddt(rho) + fvc::div(phi));
+        Info<< max(rho) << " " << min(rho) << endl;
+
+        // --- Solve momentum
+        solve(fvm::ddt(rhoU) + fvc::div(phiUp));
+
+        U.dimensionedInternalField() =
+            rhoU.dimensionedInternalField()
+           /rho.dimensionedInternalField();
+        U.correctBoundaryConditions();
+        rhoU.boundaryField() = rho.boundaryField()*U.boundaryField();
+
+        if (!inviscid)
+        {
+            solve
+            (
+                fvm::ddt(rho, U) - fvc::ddt(rho, U)
+              - fvm::laplacian(mu, U)
+              - fvc::div(tauMC)
+            );
+            rhoU = rho*U;
+        }
+
+        // --- Solve energy
+        surfaceScalarField sigmaDotU =
+        (
+            (
+                fvc::interpolate(mu)*mesh.magSf()*fvc::snGrad(U)
+              + (mesh.Sf() & fvc::interpolate(tauMC))
+            )
+            & (a_pos*U_pos + a_neg*U_neg)
+        );
+
+        solve
+        (
+            fvm::ddt(rhoE)
+          + fvc::div(phiEp)
+          - fvc::div(sigmaDotU)
+        );
+
+        e = rhoE/rho - 0.5*magSqr(U);
+        e.correctBoundaryConditions();
+        thermo.correct();
+        rhoE.boundaryField() =
+            rho.boundaryField()*
+            (
+                e.boundaryField() + 0.5*magSqr(U.boundaryField())
+            );
+
+        if (!inviscid)
+        {
+            volScalarField k("k", thermo.Cp()*mu/Pr);
+            solve
+            (
+                fvm::ddt(rho, e) - fvc::ddt(rho, e)
+              - fvm::laplacian(thermo.alpha(), e)
+              + fvc::laplacian(thermo.alpha(), e)
+              - fvc::laplacian(k, T)
+            );
+            thermo.correct();
+            rhoE = rho*(e + 0.5*magSqr(U));
+        }
+
+        p.dimensionedInternalField() =
+            rho.dimensionedInternalField()
+           /psi.dimensionedInternalField();
+        p.correctBoundaryConditions();
+        rho.boundaryField() = psi.boundaryField()*p.boundaryField();
+
+        runTime.write();
+
+        Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
+            << "  ClockTime = " << runTime.elapsedClockTime() << " s"
+            << nl << endl;
+    }
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+// ************************************************************************* //

applications/solvers/compressible/sonicDyMFoam/sonicDyMFoam.C

@@ -49,7 +49,7 @@ int main(int argc, char *argv[])
 
     Info<< "\nStarting time loop\n" << endl;
 
-    autoPtr<Foam::motionSolver> motionPtr = motionSolver::New(mesh);
+    autoPtr<motionSolver> motionPtr = motionSolver::New(mesh);
 
     while (runTime.loop())
     {

applications/solvers/discreteMethods/molecularDynamics/mdEquilibrationFoam/mdEquilibrationFoam.C

@@ -39,6 +39,20 @@ int main(int argc, char *argv[])
 #   include "createTime.H"
 #   include "createMesh.H"
 
+    Info<< "\nReading field U\n" << endl;
+    volVectorField U
+    (
+        IOobject
+        (
+            "U",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
     potential pot(mesh);
 
     moleculeCloud molecules(mesh, pot);

applications/solvers/discreteMethods/molecularDynamics/mdFoam/mdFoam.C

@@ -39,6 +39,20 @@ int main(int argc, char *argv[])
 #   include "createTime.H"
 #   include "createMesh.H"
 
+    Info<< "\nReading field U\n" << endl;
+    volVectorField U
+    (
+        IOobject
+        (
+            "U",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
     potential pot(mesh);
 
     moleculeCloud molecules(mesh, pot);

applications/solvers/electromagnetics/magneticFoam/Make/files

@@ -0,0 +1,3 @@
+magneticFoam.C
+
+EXE = $(FOAM_APPBIN)/magneticFoam

applications/solvers/electromagnetics/magneticFoam/Make/options

@@ -0,0 +1,4 @@
+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude
+
+EXE_LIBS = -lfiniteVolume

applications/solvers/electromagnetics/magneticFoam/createFields.H

@@ -0,0 +1,81 @@
+    Info<< "Reading field psi\n" << endl;
+    volScalarField psi
+    (
+        IOobject
+        (
+            "psi",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+    Info<< "Reading transportProperties\n" << endl;
+
+    IOdictionary transportProperties
+    (
+        IOobject
+        (
+            "transportProperties",
+            runTime.constant(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        )
+    );
+
+    List<magnet> magnets(transportProperties.lookup("magnets"));
+
+    surfaceScalarField murf
+    (
+        IOobject
+        (
+            "murf",
+            runTime.timeName(),
+            mesh
+        ),
+        mesh,
+        1
+    );
+
+    surfaceScalarField Mrf
+    (
+        IOobject
+        (
+            "Mrf",
+            runTime.timeName(),
+            mesh
+        ),
+        mesh,
+        dimensionedScalar("Mr", dimensionSet(0, 1, 0, 0, 0, 1, 0), 0)
+    );
+
+    forAll(magnets, i)
+    {
+        label magnetZonei = mesh.faceZones().findZoneID(magnets[i].name());
+
+        if (magnetZonei == -1)
+        {
+            FatalIOErrorIn(args.executable().c_str(), transportProperties)
+                << "Cannot find faceZone for magnet " << magnets[i].name()
+                << exit(FatalIOError);
+        }
+
+        const labelList& faces =
+            mesh.faceZones()[magnetZonei];
+
+        const scalar muri = magnets[i].mur();
+        const scalar Mri = magnets[i].Mr().value();
+        const vector& orientationi = magnets[i].orientation();
+
+        const surfaceVectorField& Sf = mesh.Sf();
+
+        forAll(faces, i)
+        {
+            label facei = faces[i];
+            murf[facei] = muri;
+            Mrf[facei] = Mri*(orientationi & Sf[facei]);
+        }
+    }

applications/solvers/electromagnetics/magneticFoam/magnet.H

@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2010-2010 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 3 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, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::magnet
+
+Description
+    Class to hold the defining data for a permanent magnet, in particular
+    the name, relative permeability and remanence.
+
+SourceFiles
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef magnet_H
+#define magnet_H
+
+#include "dimensionedVector.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class Istream;
+class Ostream;
+
+// Forward declaration of friend functions and operators
+class magnet;
+Istream& operator>>(Istream&, magnet&);
+Ostream& operator<<(Ostream&, const magnet&);
+
+/*---------------------------------------------------------------------------*\
+                         Class magnet Declaration
+\*---------------------------------------------------------------------------*/
+
+class magnet
+{
+    // Private data
+
+        word name_;
+        scalar relativePermeability_;
+        dimensionedScalar remanence_;
+        vector orientation_;
+
+public:
+
+    // Constructors
+
+        //- Null constructor for lists
+        inline magnet()
+        :
+            remanence_("Mr", dimensionSet(0, -1, 0, 0, 0, 1, 0), 0),
+            orientation_(vector::zero)
+        {}
+
+        //- Construct from components
+        inline magnet
+        (
+            const word& name,
+            const scalar mur,
+            const scalar Mr,
+            const vector& orientation
+        )
+        :
+            name_(name),
+            relativePermeability_(mur),
+            remanence_("Mr", dimensionSet(0, -1, 0, 0, 0, 1, 0), Mr),
+            orientation_(orientation)
+        {}
+
+        //- Construct from Istream
+        inline magnet(Istream& is)
+        :
+            remanence_("Mr", dimensionSet(0, -1, 0, 0, 0, 1, 0), 0),
+            orientation_(vector::zero)
+        {
+            is >> *this;
+        }
+
+
+    // Member Functions
+
+        //- Return name
+        inline const word& name() const
+        {
+            return name_;
+        }
+
+        //- Return relative permeability
+        inline scalar mur() const
+        {
+            return relativePermeability_;
+        }
+
+        //- Return remenance
+        inline const dimensionedScalar& Mr() const
+        {
+            return remanence_;
+        }
+
+        //- Return orientation
+        inline const vector& orientation() const
+        {
+            return orientation_;
+        }
+
+
+    // IOstream operators
+
+        inline friend Istream& operator>>(Istream& is, magnet& m)
+        {
+            is.readBegin("magnet");
+            is  >> m.name_
+                >> m.relativePermeability_
+                >> m.remanence_.value()
+                >> m.orientation_;
+            is.readEnd("magnet");
+
+            // Check state of Istream
+            is.check("operator>>(Istream&, magnet&)");
+
+            return is;
+        }
+
+        inline friend Ostream& operator<<(Ostream& os, const magnet& m)
+        {
+            os  << token::BEGIN_LIST
+                << m.name_ << token::SPACE
+                << m.relativePermeability_ << token::SPACE
+                << m.remanence_.value()
+                << m.orientation_
+                << token::END_LIST;
+
+            return os;
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/electromagnetics/magneticFoam/magneticFoam.C

@@ -0,0 +1,153 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2010-2010 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 3 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, see <http://www.gnu.org/licenses/>.
+
+Application
+    magneticFoam
+
+Description
+    Solver for the magnetic field generated by permanent magnets.
+
+    A Poisson's equation for the magnetic scalar potential psi is solved
+    from which the magnetic field intensity H and magnetic flux density B
+    are obtained.  The paramagnetic particle force field (H dot grad(H))
+    is optionally available.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "OSspecific.H"
+#include "magnet.H"
+#include "electromagneticConstants.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    argList::addBoolOption
+    (
+        "noH",
+        "do not write the magnetic field intensity field"
+    );
+
+    argList::addBoolOption
+    (
+        "noB",
+        "do not write the magnetic flux density field"
+    );
+
+    argList::addBoolOption
+    (
+        "HdotGradH",
+        "write the paramagnetic particle force field"
+    );
+
+    #include "setRootCase.H"
+    #include "createTime.H"
+    #include "createMesh.H"
+    #include "createFields.H"
+    #include "readSIMPLEControls.H"
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    Info<< "Calculating the magnetic field potential" << endl;
+
+    runTime++;
+
+    for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
+    {
+        solve(fvm::laplacian(murf, psi) + fvc::div(murf*Mrf));
+    }
+
+    psi.write();
+
+    if (!args.optionFound("noH") || args.optionFound("HdotGradH"))
+    {
+        volVectorField H
+        (
+            IOobject
+            (
+                "H",
+                runTime.timeName(),
+                mesh
+            ),
+            fvc::reconstruct(fvc::snGrad(psi)*mesh.magSf())
+        );
+
+        if (!args.optionFound("noH"))
+        {
+            Info<< nl
+                << "Creating field H for time "
+                << runTime.timeName() << endl;
+
+            H.write();
+        }
+
+        if (args.optionFound("HdotGradH"))
+        {
+            Info<< nl
+                << "Creating field HdotGradH for time "
+                << runTime.timeName() << endl;
+
+            volVectorField HdotGradH
+            (
+                IOobject
+                (
+                    "HdotGradH",
+                    runTime.timeName(),
+                    mesh
+                ),
+                H & fvc::grad(H)
+            );
+
+            HdotGradH.write();
+        }
+    }
+
+    if (!args.optionFound("noB"))
+    {
+        Info<< nl
+            << "Creating field B for time "
+            << runTime.timeName() << endl;
+
+        volVectorField B
+        (
+            IOobject
+            (
+                "B",
+                runTime.timeName(),
+                mesh
+            ),
+            constant::electromagnetic::mu0
+           *fvc::reconstruct(murf*fvc::snGrad(psi)*mesh.magSf() + murf*Mrf)
+        );
+
+        B.write();
+    }
+
+    Info<< "\nEnd\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/derivedFvPatchFields/solidWallHeatFluxTemperature/solidWallHeatFluxTemperatureFvPatchScalarField.C

@@ -169,6 +169,21 @@ void Foam::solidWallHeatFluxTemperatureFvPatchScalarField::updateCoeffs()
     gradient() = q_/K();
 
     fixedGradientFvPatchScalarField::updateCoeffs();
+
+    if (debug)
+    {
+        scalar Q = gSum(K()*patch().magSf()*snGrad());
+
+        Info<< patch().boundaryMesh().mesh().name() << ':'
+            << patch().name() << ':'
+            << this->dimensionedInternalField().name() << " :"
+            << " heatFlux:" << Q
+            << " walltemperature "
+            << " min:" << gMin(*this)
+            << " max:" << gMax(*this)
+            << " avg:" << gAverage(*this)
+            << endl;
+    }
 }
 
 

applications/solvers/lagrangian/coalChemistryFoam/createFields.H

@@ -11,7 +11,7 @@
     basicMultiComponentMixture& composition = thermo.composition();
     PtrList<volScalarField>& Y = composition.Y();
 
-    word inertSpecie(thermo.lookup("inertSpecie"));
+    const word inertSpecie(thermo.lookup("inertSpecie"));
 
     if (!composition.contains(inertSpecie))
     {

applications/solvers/lagrangian/incompressibleUncoupledKinematicParcelFoam/Make/files

@@ -0,0 +1,3 @@
+incompressibleUncoupledKinematicParcelFoam.C
+
+EXE = $(FOAM_APPBIN)/incompressibleUncoupledKinematicParcelFoam

applications/solvers/lagrangian/incompressibleUncoupledKinematicParcelFoam/Make/options

@@ -0,0 +1,27 @@
+EXE_INC = \
+    -I$(LIB_SRC)/lagrangian/basic/lnInclude \
+    -I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/radiation/lnInclude \
+    -I$(LIB_SRC)/turbulenceModels/incompressible/turbulenceModel \
+    -I$(LIB_SRC)/transportModels \
+    -I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/surfaceFilmModels/lnInclude
+
+EXE_LIBS = \
+    -llagrangian \
+    -llagrangianIntermediate \
+    -lthermophysicalFunctions \
+    -lbasicThermophysicalModels \
+    -lspecie \
+    -lradiation \
+    -lincompressibleRASModels \
+    -lincompressibleLESModels \
+    -lincompressibleTransportModels \
+    -lfiniteVolume \
+    -lmeshTools \
+    -lsurfaceFilmModels

applications/solvers/lagrangian/incompressibleUncoupledKinematicParcelFoam/createFields.H

@@ -0,0 +1,147 @@
+    Info<< "Reading transportProperties\n" << endl;
+
+    IOdictionary transportProperties
+    (
+        IOobject
+        (
+            "transportProperties",
+            runTime.constant(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        )
+    );
+
+    dimensionedScalar rhoInfValue
+    (
+        transportProperties.lookup("rhoInf")
+    );
+
+    volScalarField rhoInf
+    (
+        IOobject
+        (
+            "rho",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh,
+        rhoInfValue
+    );
+
+    Info<< "\nReading field U\n" << endl;
+    volVectorField U
+    (
+        IOobject
+        (
+            "U",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+    #include "createPhi.H"
+
+    Info<< "Creating turbulence model\n" << endl;
+
+    singlePhaseTransportModel laminarTransport(U, phi);
+
+    const volScalarField nu = laminarTransport.nu();
+
+    autoPtr<incompressible::turbulenceModel> turbulence
+    (
+        incompressible::turbulenceModel::New(U, phi, laminarTransport)
+    );
+
+    volScalarField mu
+    (
+        IOobject
+        (
+            "mu",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        nu*rhoInfValue
+    );
+
+    word kinematicCloudName("kinematicCloud");
+    args.optionReadIfPresent("cloudName", kinematicCloudName);
+
+    Info<< "Constructing kinematicCloud " << kinematicCloudName << endl;
+    basicKinematicCloud kinematicCloud
+    (
+        kinematicCloudName,
+        rhoInf,
+        U,
+        mu,
+        g
+    );
+
+    IOobject Hheader
+    (
+        "H",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ
+    );
+
+    autoPtr<volVectorField> HPtr_;
+
+    if (Hheader.headerOk())
+    {
+        Info<< "\nReading field H\n" << endl;
+
+        HPtr_.reset
+        (
+            new volVectorField
+            (
+                IOobject
+                (
+                    "H",
+                    runTime.timeName(),
+                    mesh,
+                    IOobject::MUST_READ,
+                    IOobject::AUTO_WRITE
+                ),
+                mesh
+            )
+        );
+    }
+
+    IOobject HdotGradHheader
+    (
+        "HdotGradH",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ
+    );
+
+    autoPtr<volVectorField> HdotGradHPtr_;
+
+    if (HdotGradHheader.headerOk())
+    {
+        Info<< "\nReading field HdotGradH\n" << endl;
+
+        HdotGradHPtr_.reset
+        (
+            new volVectorField
+            (
+                IOobject
+                (
+                    "HdotGradH",
+                    runTime.timeName(),
+                    mesh,
+                    IOobject::MUST_READ,
+                    IOobject::AUTO_WRITE
+                ),
+                mesh
+            )
+        );
+    }

applications/solvers/lagrangian/incompressibleUncoupledKinematicParcelFoam/incompressibleUncoupledKinematicParcelFoam.C

@@ -0,0 +1,81 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2008-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 3 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, see <http://www.gnu.org/licenses/>.
+
+Application
+    uncoupledKinematicParcelFoam
+
+Description
+    Transient solver for the passive transport of a single kinematic
+    particle could.
+
+    Uses a pre-calculated velocity field to evolve the cloud.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "singlePhaseTransportModel.H"
+#include "turbulenceModel.H"
+#include "basicKinematicCloud.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    argList::addOption("cloudName", "cloud name");
+
+    #include "setRootCase.H"
+    #include "createTime.H"
+    #include "createMesh.H"
+    #include "readGravitationalAcceleration.H"
+    #include "createFields.H"
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    Info<< "\nStarting time loop\n" << endl;
+
+    while (runTime.loop())
+    {
+        Info<< "Time = " << runTime.timeName() << nl << endl;
+
+        Info<< "Evolving " << kinematicCloud.name() << endl;
+
+        laminarTransport.correct();
+
+        mu = nu*rhoInfValue;
+
+        kinematicCloud.evolve();
+
+        runTime.write();
+
+        Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
+            << "  ClockTime = " << runTime.elapsedClockTime() << " s"
+            << nl << endl;
+    }
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/createFields.H

@@ -11,7 +11,7 @@
     basicMultiComponentMixture& composition = thermo.composition();
     PtrList<volScalarField>& Y = composition.Y();
 
-    word inertSpecie(thermo.lookup("inertSpecie"));
+    const word inertSpecie(thermo.lookup("inertSpecie"));
 
     if (!composition.contains(inertSpecie))
     {

applications/solvers/lagrangian/reactingParcelFilmFoam/createFields.H

@@ -11,7 +11,7 @@
     basicMultiComponentMixture& composition = thermo.composition();
     PtrList<volScalarField>& Y = composition.Y();
 
-    word inertSpecie(thermo.lookup("inertSpecie"));
+    const word inertSpecie(thermo.lookup("inertSpecie"));
 
     volScalarField& p = thermo.p();
     volScalarField& hs = thermo.hs();

applications/solvers/lagrangian/reactingParcelFoam/createFields.H

@@ -11,7 +11,7 @@
     basicMultiComponentMixture& composition = thermo.composition();
     PtrList<volScalarField>& Y = composition.Y();
 
-    word inertSpecie(thermo.lookup("inertSpecie"));
+    const word inertSpecie(thermo.lookup("inertSpecie"));
 
     if (!composition.contains(inertSpecie))
     {

applications/solvers/multiphase/interPhaseChangeFoam/Make/files

@@ -1,6 +1,6 @@
 interPhaseChangeFoam.C
 phaseChangeTwoPhaseMixtures/phaseChangeTwoPhaseMixture/phaseChangeTwoPhaseMixture.C
-phaseChangeTwoPhaseMixtures/phaseChangeTwoPhaseMixture/newPhaseChangeTwoPhaseMixture.C
+phaseChangeTwoPhaseMixtures/phaseChangeTwoPhaseMixture/phaseChangeTwoPhaseMixtureNew.C
 phaseChangeTwoPhaseMixtures/Kunz/Kunz.C
 phaseChangeTwoPhaseMixtures/Merkle/Merkle.C
 phaseChangeTwoPhaseMixtures/SchnerrSauer/SchnerrSauer.C

applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/phaseChangeTwoPhaseMixture/phaseChangeTwoPhaseMixture.H

@@ -28,7 +28,7 @@ Description
 
 SourceFiles
     phaseChangeTwoPhaseMixture.C
-    newPhaseChangeModel.C
+    phaseChangeModelNew.C
 
 \*---------------------------------------------------------------------------*/
 

applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/phaseChangeTwoPhaseMixture/phaseChangeTwoPhaseMixtureNew.C

@@ -36,7 +36,10 @@ Foam::phaseChangeTwoPhaseMixture::New
     const word& alpha1Name
 )
 {
-    IOdictionary transportPropertiesDict
+    // get model name, but do not register the dictionary
+    const word mixtureType
+    (
+        IOdictionary
         (
             IOobject
             (
@@ -47,19 +50,13 @@ Foam::phaseChangeTwoPhaseMixture::New
                 IOobject::NO_WRITE,
                 false
             )
+        ).lookup("phaseChangeTwoPhaseMixture")
     );
 
-    word phaseChangeTwoPhaseMixtureTypeName
-    (
-        transportPropertiesDict.lookup("phaseChangeTwoPhaseMixture")
-    );
-
-    Info<< "Selecting phaseChange model "
-        << phaseChangeTwoPhaseMixtureTypeName << endl;
+    Info<< "Selecting phaseChange model " << mixtureType << endl;
 
     componentsConstructorTable::iterator cstrIter =
-        componentsConstructorTablePtr_
-            ->find(phaseChangeTwoPhaseMixtureTypeName);
+        componentsConstructorTablePtr_->find(mixtureType);
 
     if (cstrIter == componentsConstructorTablePtr_->end())
     {
@@ -67,8 +64,8 @@ Foam::phaseChangeTwoPhaseMixture::New
         (
             "phaseChangeTwoPhaseMixture::New"
         )   << "Unknown phaseChangeTwoPhaseMixture type "
-            << phaseChangeTwoPhaseMixtureTypeName << endl << endl
-            << "Valid  phaseChangeTwoPhaseMixtures are : " << endl
+            << mixtureType << nl << nl
+            << "Valid phaseChangeTwoPhaseMixture types are : " << endl
             << componentsConstructorTablePtr_->sortedToc()
             << exit(FatalError);
     }

applications/solvers/multiphase/settlingFoam/createFields.H

@@ -159,7 +159,7 @@
 
     Info<< "Selecting Drift-Flux model " << endl;
 
-    word VdjModel(transportProperties.lookup("VdjModel"));
+    const word VdjModel(transportProperties.lookup("VdjModel"));
 
     Info<< tab << VdjModel << " selected\n" << endl;
 

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/Make/files

@@ -1,5 +1,5 @@
 dragModels/dragModel/dragModel.C
-dragModels/dragModel/newDragModel.C
+dragModels/dragModel/dragModelNew.C
 dragModels/Ergun/Ergun.C
 dragModels/GidaspowErgunWenYu/GidaspowErgunWenYu.C
 dragModels/GidaspowSchillerNaumann/GidaspowSchillerNaumann.C

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/dragModel/dragModel.H

@@ -28,7 +28,7 @@ Description
 
 SourceFiles
     dragModel.C
-    newDragModel.C
+    dragModelNew.C
 
 \*---------------------------------------------------------------------------*/
 

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/dragModel/dragModelNew.C

@@ -35,28 +35,24 @@ Foam::autoPtr<Foam::dragModel> Foam::dragModel::New
     const phaseModel& phaseb
 )
 {
-    word dragModelType
-    (
-        interfaceDict.lookup("dragModel" + phasea.name())
-    );
+    const word modelType(interfaceDict.lookup("dragModel" + phasea.name()));
 
-    Info<< "Selecting dragModel for phase "
-        << phasea.name()
-        << ": "
-        << dragModelType << endl;
+    Info<< "Selecting dragModel for phase " << phasea.name()
+        << ": " << modelType << endl;
 
     dictionaryConstructorTable::iterator cstrIter =
-        dictionaryConstructorTablePtr_->find(dragModelType);
+        dictionaryConstructorTablePtr_->find(modelType);
 
     if (cstrIter == dictionaryConstructorTablePtr_->end())
     {
-        FatalError
-            << "dragModel::New : " << endl
-                << "    unknown dragModelType type "
-                << dragModelType
-                << ", constructor not in hash table" << endl << endl
-                << "    Valid dragModel types are : " << endl;
-        Info<< dictionaryConstructorTablePtr_->sortedToc() << abort(FatalError);
+        FatalErrorIn
+        (
+            "dragModel::New(...)"
+        )   << "Unknown dragModel type "
+            << modelType << nl << nl
+            << "Valid dragModel types are : " << endl
+            << dictionaryConstructorTablePtr_->sortedToc()
+            << abort(FatalError);
     }
 
     return cstrIter()(interfaceDict, alpha, phasea, phaseb);

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/Make/files

@@ -1,32 +1,32 @@
 kineticTheoryModel/kineticTheoryModel.C
 
 viscosityModel/viscosityModel/viscosityModel.C
-viscosityModel/viscosityModel/newViscosityModel.C
+viscosityModel/viscosityModel/viscosityModelNew.C
 viscosityModel/Gidaspow/GidaspowViscosity.C
 viscosityModel/Syamlal/SyamlalViscosity.C
 viscosityModel/HrenyaSinclair/HrenyaSinclairViscosity.C
 viscosityModel/none/noneViscosity.C
 
 conductivityModel/conductivityModel/conductivityModel.C
-conductivityModel/conductivityModel/newConductivityModel.C
+conductivityModel/conductivityModel/conductivityModelNew.C
 conductivityModel/Gidaspow/GidaspowConductivity.C
 conductivityModel/Syamlal/SyamlalConductivity.C
 conductivityModel/HrenyaSinclair/HrenyaSinclairConductivity.C
 
 radialModel/radialModel/radialModel.C
-radialModel/radialModel/newRadialModel.C
+radialModel/radialModel/radialModelNew.C
 radialModel/CarnahanStarling/CarnahanStarlingRadial.C
 radialModel/Gidaspow/GidaspowRadial.C
 radialModel/LunSavage/LunSavageRadial.C
 radialModel/SinclairJackson/SinclairJacksonRadial.C
 
 granularPressureModel/granularPressureModel/granularPressureModel.C
-granularPressureModel/granularPressureModel/newGranularPressureModel.C
+granularPressureModel/granularPressureModel/granularPressureModelNew.C
 granularPressureModel/Lun/LunPressure.C
 granularPressureModel/SyamlalRogersOBrien/SyamlalRogersOBrienPressure.C
 
 frictionalStressModel/frictionalStressModel/frictionalStressModel.C
-frictionalStressModel/frictionalStressModel/newFrictionalStressModel.C
+frictionalStressModel/frictionalStressModel/frictionalStressModelNew.C
 frictionalStressModel/JohnsonJackson/JohnsonJacksonFrictionalStress.C
 frictionalStressModel/Schaeffer/SchaefferFrictionalStress.C
 

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/conductivityModel/conductivityModel/conductivityModelNew.C

@@ -32,23 +32,23 @@ Foam::autoPtr<Foam::conductivityModel> Foam::conductivityModel::New
     const dictionary& dict
 )
 {
-    word conductivityModelType(dict.lookup("conductivityModel"));
+    const word modelType(dict.lookup("conductivityModel"));
 
-    Info<< "Selecting conductivityModel "
-        << conductivityModelType << endl;
+    Info<< "Selecting conductivityModel " << modelType << endl;
 
     dictionaryConstructorTable::iterator cstrIter =
-        dictionaryConstructorTablePtr_->find(conductivityModelType);
+        dictionaryConstructorTablePtr_->find(modelType);
 
     if (cstrIter == dictionaryConstructorTablePtr_->end())
     {
-        FatalError
-            << "conductivityModel::New(const dictionary&) : " << endl
-            << "    unknown conductivityModelType type "
-            << conductivityModelType
-            << ", constructor not in hash table" << endl << endl
-            << "    Valid conductivityModelType types are :" << endl;
-        Info<< dictionaryConstructorTablePtr_->sortedToc() << abort(FatalError);
+        FatalErrorIn
+        (
+            "conductivityModel::New(const dictionary&)"
+        )   << "Unknown conductivityModel type "
+            << modelType << nl << nl
+            << "Valid conductivityModel types are :" << endl
+            << dictionaryConstructorTablePtr_->sortedToc()
+            << abort(FatalError);
     }
 
     return autoPtr<conductivityModel>(cstrIter()(dict));

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/frictionalStressModel/frictionalStressModel/frictionalStressModelNew.C

@@ -32,23 +32,24 @@ Foam::autoPtr<Foam::frictionalStressModel> Foam::frictionalStressModel::New
     const dictionary& dict
 )
 {
-    word frictionalStressModelType(dict.lookup("frictionalStressModel"));
+    const word modelType(dict.lookup("frictionalStressModel"));
 
-    Info<< "Selecting frictionalStressModel "
-        << frictionalStressModelType << endl;
+    Info<< "Selecting frictionalStressModel " << modelType << endl;
 
     dictionaryConstructorTable::iterator cstrIter =
-        dictionaryConstructorTablePtr_->find(frictionalStressModelType);
+        dictionaryConstructorTablePtr_->find(modelType);
 
     if (cstrIter == dictionaryConstructorTablePtr_->end())
     {
-        FatalError
-            << "frictionalStressModel::New(const dictionary&) : " << endl
-            << "    unknown frictionalStressModelType type "
-            << frictionalStressModelType
-            << ", constructor not in hash table" << endl << endl
-            << "    Valid frictionalStressModelType types are :" << endl;
-        Info<< dictionaryConstructorTablePtr_->sortedToc() << abort(FatalError);
+        FatalErrorIn
+        (
+            "frictionalStressModel::New(const dictionary&)"
+        )
+            << "Unknown frictionalStressModel type "
+            << modelType << nl << nl
+            << "Valid frictionalStressModel types are :" << endl
+            << dictionaryConstructorTablePtr_->sortedToc()
+            << abort(FatalError);
     }
 
     return autoPtr<frictionalStressModel>(cstrIter()(dict));

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/granularPressureModel/granularPressureModel/granularPressureModelNew.C

@@ -32,23 +32,23 @@ Foam::autoPtr<Foam::granularPressureModel> Foam::granularPressureModel::New
     const dictionary& dict
 )
 {
-    word granularPressureModelType(dict.lookup("granularPressureModel"));
+    const word modelType(dict.lookup("granularPressureModel"));
 
-    Info<< "Selecting granularPressureModel "
-        << granularPressureModelType << endl;
+    Info<< "Selecting granularPressureModel " << modelType << endl;
 
     dictionaryConstructorTable::iterator cstrIter =
-        dictionaryConstructorTablePtr_->find(granularPressureModelType);
+        dictionaryConstructorTablePtr_->find(modelType);
 
     if (cstrIter == dictionaryConstructorTablePtr_->end())
     {
-        FatalError
-            << "granularPressureModel::New(const dictionary&) : " << endl
-            << "    unknown granularPressureModelType type "
-            << granularPressureModelType
-            << ", constructor not in hash table" << endl << endl
-            << "    Valid granularPressureModelType types are :" << endl;
-        Info<< dictionaryConstructorTablePtr_->sortedToc() << abort(FatalError);
+        FatalErrorIn
+        (
+            "granularPressureModel::New(const dictionary&)"
+        )   << "Unknown granularPressureModel type "
+            << modelType << nl << nl
+            << "Valid granularPressureModel types are :" << endl
+            << dictionaryConstructorTablePtr_->sortedToc()
+            << abort(FatalError);
     }
 
     return autoPtr<granularPressureModel>(cstrIter()(dict));

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/radialModel/radialModelNew.C

@@ -32,23 +32,24 @@ Foam::autoPtr<Foam::radialModel> Foam::radialModel::New
     const dictionary& dict
 )
 {
-    word radialModelType(dict.lookup("radialModel"));
+    const word modelType(dict.lookup("radialModel"));
 
-    Info<< "Selecting radialModel "
-        << radialModelType << endl;
+    Info<< "Selecting radialModel " << modelType << endl;
 
     dictionaryConstructorTable::iterator cstrIter =
-        dictionaryConstructorTablePtr_->find(radialModelType);
+        dictionaryConstructorTablePtr_->find(modelType);
 
     if (cstrIter == dictionaryConstructorTablePtr_->end())
     {
-        FatalError
-            << "radialModel::New(const dictionary&) : " << endl
-            << "    unknown radialModelType type "
-            << radialModelType
-            << ", constructor not in hash table" << endl << endl
-            << "    Valid radialModelType types are :" << endl;
-        Info<< dictionaryConstructorTablePtr_->sortedToc() << abort(FatalError);
+        FatalErrorIn
+        (
+            "radialModel::New(const dictionary&)"
+        )
+            << "Unknown radialModel type "
+            << modelType << nl << nl
+            << "Valid radialModel types are :" << endl
+            << dictionaryConstructorTablePtr_->sortedToc()
+            << abort(FatalError);
     }
 
     return autoPtr<radialModel>(cstrIter()(dict));

applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/viscosityModel/viscosityModel/viscosityModelNew.C

@@ -33,23 +33,23 @@ Foam::kineticTheoryModels::viscosityModel::New
     const dictionary& dict
 )
 {
-    word viscosityModelType(dict.lookup("viscosityModel"));
+    const word modelType(dict.lookup("viscosityModel"));
 
-    Info<< "Selecting viscosityModel "
-        << viscosityModelType << endl;
+    Info<< "Selecting viscosityModel " << modelType << endl;
 
     dictionaryConstructorTable::iterator cstrIter =
-        dictionaryConstructorTablePtr_->find(viscosityModelType);
+        dictionaryConstructorTablePtr_->find(modelType);
 
     if (cstrIter == dictionaryConstructorTablePtr_->end())
     {
-        FatalError
-            << "viscosityModel::New(const dictionary&) : " << endl
-            << "    unknown viscosityModelType type "
-            << viscosityModelType
-            << ", constructor not in hash table" << endl << endl
-            << "    Valid viscosityModelType types are :" << endl;
-        Info<< dictionaryConstructorTablePtr_->sortedToc() << abort(FatalError);
+        FatalErrorIn
+        (
+            "viscosityModel::New(const dictionary&)"
+        )   << "Unknown viscosityModel type "
+            << modelType << nl << nl
+            << "Valid viscosityModel types are :" << endl
+            << dictionaryConstructorTablePtr_->sortedToc()
+            << abort(FatalError);
     }
 
     return autoPtr<viscosityModel>(cstrIter()(dict));

applications/test/globalIndex/Make/files

@@ -1,4 +1,3 @@
-globalIndex.C
 globalIndexTest.C
 
 EXE = $(FOAM_USER_APPBIN)/globalIndexTest

applications/test/nearWallDist-wave/testWallDist2.C

@@ -108,12 +108,16 @@ int main(int argc, char *argv[])
         }
     }
 
+    List<wallPoint> allFaceInfo(mesh.nFaces());
+    List<wallPoint> allCellInfo(mesh.nCells());
 
-    MeshWave<wallPoint> wallDistCalc
+    FaceCellWave<wallPoint> wallDistCalc
     (
         mesh,
         changedFaces,
         faceDist,
+        allFaceInfo,
+        allCellInfo,
         0             // max iterations
     );
 
@@ -148,16 +152,13 @@ int main(int argc, char *argv[])
         // Copy face and cell values into field
         //
 
-        const List<wallPoint>& cellInfo = wallDistCalc.allCellInfo();
-        const List<wallPoint>& faceInfo = wallDistCalc.allFaceInfo();
-
         label nIllegal = 0;
 
         // Copy cell values
-        forAll(cellInfo, cellI)
+        forAll(allCellInfo, cellI)
         {
-            scalar dist = cellInfo[cellI].distSqr();
-            if (cellInfo[cellI].valid())
+            scalar dist = allCellInfo[cellI].distSqr();
+            if (allCellInfo[cellI].valid())
             {
                 wallDistUncorrected[cellI] = Foam::sqrt(dist);
             }
@@ -176,11 +177,10 @@ int main(int argc, char *argv[])
 
             forAll(patchField, patchFaceI)
             {
-                label meshFaceI =
-                    patchField.patch().patch().start() + patchFaceI;
+                const label meshFaceI = patchField.patch().start() + patchFaceI;
 
-                scalar dist = faceInfo[meshFaceI].distSqr();
-                if (faceInfo[meshFaceI].valid())
+                scalar dist = allFaceInfo[meshFaceI].distSqr();
+                if (allFaceInfo[meshFaceI].valid())
                 {
                     patchField[patchFaceI] = Foam::sqrt(dist);
                 }

applications/test/primitivePatch/testPrimitivePatch.C

@@ -47,8 +47,7 @@ void writeObj(Ostream& os,const pointField& points)
     {
         const point& pt = points[pointI];
 
-        os << "v " << pt.x() << ' ' << pt.y()
-            << ' ' << pt.z() << endl;
+        os  << "v " << pt.x() << ' ' << pt.y() << ' ' << pt.z() << endl;
     }
 }
 

applications/utilities/mesh/conversion/star3ToFoam/createBoundaryFaces.C

@@ -166,7 +166,9 @@ void starMesh::markBoundaryFaces()
                     }
                 }
 
-                FatalError << " $ bset,add,vset,all" << abort(FatalError);
+                FatalError
+                    << " $ bset,add,vset,all"
+                    << abort(FatalError);
             }
         }
     }

applications/utilities/mesh/generation/extrudeMesh/extrudeModel/Make/files

@@ -1,5 +1,5 @@
 extrudeModel/extrudeModel.C
-extrudeModel/newExtrudeModel.C
+extrudeModel/extrudeModelNew.C
 linearNormal/linearNormal.C
 linearDirection/linearDirection.C
 linearRadial/linearRadial.C

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

@@ -32,19 +32,20 @@ Foam::autoPtr<Foam::extrudeModel> Foam::extrudeModel::New
     const dictionary& dict
 )
 {
-    word extrudeModelType(dict.lookup("extrudeModel"));
+    const word modelType(dict.lookup("extrudeModel"));
 
-    Info<< "Selecting extrudeModel " << extrudeModelType << endl;
+    Info<< "Selecting extrudeModel " << modelType << endl;
 
     dictionaryConstructorTable::iterator cstrIter =
-        dictionaryConstructorTablePtr_->find(extrudeModelType);
+        dictionaryConstructorTablePtr_->find(modelType);
 
     if (cstrIter == dictionaryConstructorTablePtr_->end())
     {
-        FatalErrorIn("extrudeModel::New(const dictionary&)")
-            << "Unknown extrudeModelType type "
-            << extrudeModelType
-            << ", constructor not in hash table" << nl << nl
+        FatalErrorIn
+        (
+            "extrudeModel::New(const dictionary&)"
+        )   << "Unknown extrudeModel type "
+            << modelType << nl << nl
             << "Valid extrudeModel types are :" << nl
             << dictionaryConstructorTablePtr_->sortedToc() << nl
             << exit(FatalError);
@@ -55,4 +56,3 @@ Foam::autoPtr<Foam::extrudeModel> Foam::extrudeModel::New
 
 
 // ************************************************************************* //
-

applications/utilities/mesh/generation/extrudeToRegionMesh/patchPointEdgeCirculatorI.H

@@ -233,7 +233,7 @@ void Foam::patchPointEdgeCirculator::setCanonical()
 
 
 //- Step to next edge.
-Foam::patchPointEdgeCirculator::patchPointEdgeCirculator&
+Foam::patchPointEdgeCirculator&
 Foam::patchPointEdgeCirculator::operator++()
 {
     if (index_ == -1)

applications/utilities/mesh/manipulation/cellSet/cellSet.C

@@ -59,9 +59,8 @@ int main(int argc, char *argv[])
     );
 
 
-    word setName(cellSetDict.lookup("name"));
-
-    word actionName(cellSetDict.lookup("action"));
+    const word setName(cellSetDict.lookup("name"));
+    const word actionName(cellSetDict.lookup("action"));
 
     topoSetSource::setAction action = topoSetSource::toAction(actionName);
 

applications/utilities/mesh/manipulation/faceSet/faceSet.C

@@ -59,9 +59,8 @@ int main(int argc, char *argv[])
     );
 
 
-    word setName(faceSetDict.lookup("name"));
-
-    word actionName(faceSetDict.lookup("action"));
+    const word setName(faceSetDict.lookup("name"));
+    const word actionName(faceSetDict.lookup("action"));
 
     topoSetSource::setAction action = topoSetSource::toAction(actionName);
 

applications/utilities/mesh/manipulation/moveMesh/moveMesh.C

@@ -43,7 +43,7 @@ int main(int argc, char *argv[])
 #   include "createTime.H"
 #   include "createMesh.H"
 
-    autoPtr<Foam::motionSolver> motionPtr = motionSolver::New(mesh);
+    autoPtr<motionSolver> motionPtr = motionSolver::New(mesh);
 
     while (runTime.loop())
     {

applications/utilities/mesh/manipulation/objToVTK/objToVTK.C

@@ -113,7 +113,7 @@ int main(int argc, char *argv[])
     argList::validArgs.clear();
     argList::validArgs.append("OBJ file");
     argList::validArgs.append("output VTK file");
-    argList::argList args(argc, argv);
+    argList args(argc, argv);
 
     const fileName objName = args[1];
     const fileName outName = args[2];

applications/utilities/mesh/manipulation/pointSet/pointSet.C

@@ -59,9 +59,8 @@ int main(int argc, char *argv[])
     );
 
 
-    word setName(pointSetDict.lookup("name"));
-
-    word actionName(pointSetDict.lookup("action"));
+    const word setName(pointSetDict.lookup("name"));
+    const word actionName(pointSetDict.lookup("action"));
 
     topoSetSource::setAction action = topoSetSource::toAction(actionName);
 

applications/utilities/mesh/manipulation/refineMesh/refineMesh.C

@@ -331,7 +331,7 @@ int main(int argc, char *argv[])
             )
         );
 
-        word setName(refineDict.lookup("set"));
+        const word setName(refineDict.lookup("set"));
 
         cellSet cells(mesh, setName);
 

applications/utilities/miscellaneous/foamFormatConvert/foamFormatConvert.C

@@ -64,13 +64,13 @@ namespace Foam
 
 
 // Hack to do zones which have Lists in them. See above.
-bool writeZones(const word& name, Time& runTime)
+bool writeZones(const word& name, const fileName& meshDir, Time& runTime)
 {
     IOobject io
     (
         name,
         runTime.timeName(),
-        polyMesh::meshSubDir,
+        meshDir,
         runTime,
         IOobject::MUST_READ,
         IOobject::NO_WRITE,
@@ -144,8 +144,20 @@ bool writeZones(const word& name, Time& runTime)
 int main(int argc, char *argv[])
 {
     timeSelector::addOptions();
+#   include "addRegionOption.H"
 #   include "setRootCase.H"
 #   include "createTime.H"
+
+    fileName meshDir = polyMesh::meshSubDir;
+    fileName regionPrefix = "";
+    word regionName = polyMesh::defaultRegion;
+    if (args.optionReadIfPresent("region", regionName))
+    {
+        Info<< "Using region " << regionName << nl << endl;
+        regionPrefix = regionName;
+        meshDir = regionName/polyMesh::meshSubDir;
+    }
+
     Foam::instantList timeDirs = Foam::timeSelector::select0(runTime, args);
 
     forAll(timeDirs, timeI)
@@ -154,27 +166,32 @@ int main(int argc, char *argv[])
         Info<< "Time = " << runTime.timeName() << endl;
 
         // Convert all the standard mesh files
-        writeMeshObject<cellIOList>("cells", runTime);
-        writeMeshObject<labelIOList>("owner", runTime);
-        writeMeshObject<labelIOList>("neighbour", runTime);
-        writeMeshObject<faceIOList>("faces", runTime);
-        writeMeshObject<pointIOField>("points", runTime);
-        writeMeshObject<labelIOList>("pointProcAddressing", runTime);
-        writeMeshObject<labelIOList>("faceProcAddressing", runTime);
-        writeMeshObject<labelIOList>("cellProcAddressing", runTime);
-        writeMeshObject<labelIOList>("boundaryProcAddressing", runTime);
+        writeMeshObject<cellIOList>("cells", meshDir, runTime);
+        writeMeshObject<labelIOList>("owner", meshDir, runTime);
+        writeMeshObject<labelIOList>("neighbour", meshDir, runTime);
+        writeMeshObject<faceIOList>("faces", meshDir, runTime);
+        writeMeshObject<pointIOField>("points", meshDir, runTime);
+        writeMeshObject<labelIOList>("pointProcAddressing", meshDir, runTime);
+        writeMeshObject<labelIOList>("faceProcAddressing", meshDir, runTime);
+        writeMeshObject<labelIOList>("cellProcAddressing", meshDir, runTime);
+        writeMeshObject<labelIOList>
+        (
+            "boundaryProcAddressing",
+            meshDir,
+            runTime
+        );
 
         if (runTime.writeFormat() == IOstream::ASCII)
         {
             // Only do zones when converting from binary to ascii
             // The other way gives problems since working on dictionary level.
-            writeZones("cellZones", runTime);
-            writeZones("faceZones", runTime);
-            writeZones("pointZones", runTime);
+            writeZones("cellZones", meshDir, runTime);
+            writeZones("faceZones", meshDir, runTime);
+            writeZones("pointZones", meshDir, runTime);
         }
 
         // Get list of objects from the database
-        IOobjectList objects(runTime, runTime.timeName());
+        IOobjectList objects(runTime, runTime.timeName(), regionPrefix);
 
         forAllConstIter(IOobjectList, objects, iter)
         {

applications/utilities/miscellaneous/foamFormatConvert/writeMeshObject.H

@@ -40,13 +40,18 @@ namespace Foam
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 template<class T>
-inline bool writeMeshObject(const word& name, Time& runTime)
+inline bool writeMeshObject
+(
+    const word& name,
+    const fileName& meshDir,
+    Time& runTime
+)
 {
     IOobject io
     (
         name,
         runTime.timeName(),
-        polyMesh::meshSubDir,
+        meshDir,
         runTime,
         IOobject::MUST_READ,
         IOobject::NO_WRITE,

applications/utilities/parallelProcessing/decomposePar/decomposePar.C

@@ -153,9 +153,9 @@ int main(int argc, char *argv[])
     }
 
     // get requested numberOfSubdomains
-    label nDomains = 0;
-    {
-        IOdictionary decompDict
+    const label nDomains = readLabel
+    (
+        IOdictionary
         (
             IOobject
             (
@@ -167,11 +167,9 @@ int main(int argc, char *argv[])
                 IOobject::NO_WRITE,
                 false
             )
+        ).lookup("numberOfSubdomains")
     );
 
-        decompDict.lookup("numberOfSubdomains") >> nDomains;
-    }
-
     if (decomposeFieldsOnly)
     {
         // Sanity check on previously decomposed case

applications/utilities/postProcessing/dataConversion/foamToFieldview9/calcFaceAddressing.C

@@ -72,14 +72,17 @@ labelList calcFaceAddressing
                 << "    face labels:" << faces << endl
                 << "    cellI:" << cellI << endl;
 
-            FatalError << "Faces consist of vertices:" << endl;
+            FatalError
+                << "Faces consist of vertices:" << endl;
+
             forAll(faces, faceI)
             {
                 FatalError
                     << "    face:" << faces[faceI]
                     << allFaces[faces[faceI]] << endl;
             }
-            FatalError << exit(FatalError);
+            FatalError
+                << exit(FatalError);
         }
     }
     return shapeToMesh;

applications/utilities/postProcessing/dataConversion/foamToFieldview9/writeFunctions.C

@@ -88,7 +88,7 @@ void writeWallFlags(Ostream& os, label cellI, const labelList& wallFlags)
     os  << "cell " << cellI << " wallsFlags:";
     forAll(wallFlags, wallFaceI)
     {
-        os << wallFlags[wallFaceI] << " ";
+        os  << wallFlags[wallFaceI] << ' ';
     }
     os  << endl;
 }

applications/utilities/postProcessing/dataConversion/foamToGMV/readConversionProperties.H

@@ -28,7 +28,8 @@ word format
 
 if ((format != "ascii") && (format != "ieeei4r8"))
 {
-    FatalError << "format type: " << format << " unknown."
+    FatalError
+        << "format type: " << format << " unknown."
         << " Valid options are: ascii ieeei4r8"
         << abort(FatalError);
 
@@ -44,6 +45,7 @@ if
     (cells != "hex")
 )
 {
-    FatalError << "cells type: " << cells << " unknown."
+    FatalError
+        << "cells type: " << cells << " unknown."
         << abort(FatalError);
 }

applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/PV3FoamReader/vtkPV3FoamReader.cxx

@@ -508,9 +508,8 @@ void vtkPV3FoamReader::PrintSelf(ostream& os, vtkIndent indent)
     foamData_->PrintSelf(os, indent);
 
     os  << indent << "Time step range: "
-      << this->TimeStepRange[0] << " - " << this->TimeStepRange[1]
-      << "\n";
-    os<< indent << "Time step: " << this->GetTimeStep() << endl;
+        << this->TimeStepRange[0] << " - " << this->TimeStepRange[1] << "\n"
+        << indent << "Time step: " << this->GetTimeStep() << endl;
 }
 
 

applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/Make/files

@@ -1,5 +1,5 @@
 tabulatedWallFunction/tabulatedWallFunction.C
-tabulatedWallFunction/newTabulatedWallFunction.C
+tabulatedWallFunction/tabulatedWallFunctionNew.C
 
 SpaldingsLaw/SpaldingsLaw.C
 general/general.C

applications/utilities/surface/surfaceClean/surfaceClean.C

@@ -51,7 +51,7 @@ int main(int argc, char *argv[])
     argList::validArgs.append("surface file");
     argList::validArgs.append("min length");
     argList::validArgs.append("output surface file");
-    argList::argList args(argc, argv);
+    argList args(argc, argv);
 
     const fileName inFileName = args[1];
     const scalar minLen = args.argRead<scalar>(2);

applications/utilities/surface/surfaceRefineRedGreen/surfaceRefineRedGreen.C

@@ -50,7 +50,7 @@ int main(int argc, char *argv[])
     argList::validArgs.clear();
     argList::validArgs.append("surface file");
     argList::validArgs.append("output surface file");
-    argList::argList args(argc, argv);
+    argList args(argc, argv);
 
     const fileName surfFileName = args[1];
     const fileName outFileName  = args[2];

applications/utilities/surface/surfaceSplitByPatch/surfaceSplitByPatch.C

@@ -39,7 +39,7 @@ int main(int argc, char *argv[])
     argList::noParallel();
     argList::validArgs.clear();
     argList::validArgs.append("input file");
-    argList::argList args(argc, argv);
+    argList args(argc, argv);
 
     const fileName surfName = args[1];
 

applications/utilities/thermophysical/adiabaticFlameT/adiabaticFlameT.C

@@ -70,7 +70,7 @@ int main(int argc, char *argv[])
 
 
     scalar T0(readScalar(control.lookup("T0")));
-    word fuelName(control.lookup("fuel"));
+    const word fuelName(control.lookup("fuel"));
     scalar n(readScalar(control.lookup("n")));
     scalar m(readScalar(control.lookup("m")));
 

applications/utilities/thermophysical/equilibriumFlameT/equilibriumFlameT.C

@@ -71,7 +71,7 @@ int main(int argc, char *argv[])
 
 
     scalar P(readScalar(control.lookup("P")));
-    word fuel(control.lookup("fuel"));
+    const word fuelName(control.lookup("fuel"));
     scalar n(readScalar(control.lookup("n")));
     scalar m(readScalar(control.lookup("m")));
 
@@ -97,7 +97,7 @@ int main(int argc, char *argv[])
     Info<< nl << "Reading Burcat data for relevant species" << nl << endl;
 
     // Reactants
-    thermo FUEL(thermoData.lookup(fuel));
+    thermo FUEL(thermoData.lookup(fuelName));
     thermo O2(thermoData.lookup("O2"));
     thermo N2(thermoData.lookup("N2"));
 

doc/Allwmake

@@ -2,9 +2,8 @@
 cd ${0%/*} || exit 1    # run from this directory
 set -x
 
-chmod a+rX $WM_PROJECT_DIR
-chmod a+rX $WM_PROJECT_DIR/doc
-chmod -R a+rX Doxygen
+# fix permissions (NB: '+X' and not '+x'!)
+chmod a+rX $WM_PROJECT_DIR $WM_PROJECT_DIR/doc Doxygen
 
 Doxygen/Allwmake
 

doc/Doxygen/Allwmake

@@ -2,11 +2,21 @@
 cd ${0%/*} || exit 1    # run from this directory
 set -x
 
+rm -rf latex man
+
+# remove html directory in background
+mv html html-stagedRemove$$ 2> /dev/null
+rm -rf html-stagedRemove$$ >/dev/null 2>&1 &
+
+# ensure that created files are readable by everyone
 umask 22
-rm -rf html latex man
 doxygen
 
 # fix permissions (NB: '+X' and not '+x'!)
-chmod -R a+rX ./
+chmod -R a+rX html latex man 2>/dev/null
+
+echo
+echo "Done doxygen"
+echo
 
 # ----------------------------------------------------------------- end-of-file

doc/Doxygen/FoamHeader.html

@@ -14,7 +14,9 @@
 <body>
 <a id="openfoam"> </a>
 <!-- Top banner -->
-<table style="border-width: 0px; width: 800px; background: #ddddff;" cellspacing=0 cellpadding=0>
+<table
+    style="border-width: 0px; width: 800px; background: #ddddff;"
+    cellspacing="0" cellpadding="0">
 <tr>
 <td style="width: 9px; height:54px"></td>
 <td style="width: 250px; height:54px; vertical-align:middle;
@@ -38,23 +40,23 @@ horizontal-align: left; ">
 <td valign="top">
     <table width="801" border="0" cellspacing="1" cellpadding="0" bgcolor="#ffffff">
     <tr>
-    <td class=leftmenu>&nbsp;
+    <td class="leftmenu">&nbsp;
         <a href="http://foam.sourceforge.net/doc/Doxygen/html"
             class="menuLefton">Source Guide</a>
     </td>
-    <td class=topmenu>
+    <td class="topmenu">
         <a href="http://www.openfoam.com/about/"
             class="menuTopoff">OpenCFD</a>
     </td>
-    <td class=topmenu>
+    <td class="topmenu">
         <a href="http://www.openfoam.com/features/"
             class="menuTopoff">Features</a>
     </td>
-    <td class=topmenu>
+    <td class="topmenu">
         <a href="http://www.openfoam.com/contact/"
             class="menuTopoff">Contact</a>
     </td>
-    <td class=topmenu>
+    <td class="topmenu">
         <a href="http://www.openfoam.com/"
             class="menuTopoff">OpenFOAM</a>
     </td>
@@ -64,6 +66,8 @@ horizontal-align: left; ">
 </td>
 </tr>
 </table>
-<table style="border-width: 0px; width: 800px; background: #ffffff;" cellspacing=5 cellpadding=0>
+<table
+    style="border-width: 0px; width: 800px; background: #ffffff;"
+    cellspacing="5" cellpadding="0">
 <tr>
 <td>

doc/Doxygen/tabs.css

@@ -1,6 +1,6 @@
 /* tabs styles, based on http://www.alistapart.com/articles/slidingdoors */
 
-DIV.tabs
+div.tabs
 {
     float           : left;
     width           : 100%;
@@ -8,7 +8,7 @@ DIV.tabs
     padding-bottom  : 6px;
 }
 
-DIV.tabs UL
+div.tabs ul
 {
     margin          : 0px;
     padding-left    : 0px;
@@ -16,20 +16,20 @@ DIV.tabs UL
     list-style      : none;
 }
 
-DIV.tabs LI, DIV.tabs FORM
+div.tabs li, div.tabs form
 {
     display         : inline;
     margin          : 0px;
     padding         : 0px;
 }
 
-DIV.tabs FORM
+div.tabs form
 {
     float           : left;
     padding         : 0px 9px;
 }
 
-DIV.tabs A
+div.tabs a
 {
     float           : left;
     font-size       : 12px;
@@ -38,18 +38,17 @@ DIV.tabs A
     border-right    : 1px solid #000000;
 }
 
-DIV.tabs A:hover
+div.tabs a:hover
 {
     background-position: 100% -150px;
 }
 
-DIV.tabs A:link, DIV.tabs A:visited,
-DIV.tabs A:active, DIV.tabs A:hover
+div.tabs a:link, div.tabs a:visited, div.tabs a:active, div.tabs a:hover
 {
     color           : #000000;
 }
 
-DIV.tabs SPAN
+div.tabs span
 {
     float           : left;
     display         : block;
@@ -57,42 +56,42 @@ DIV.tabs SPAN
     white-space     : nowrap;
 }
 
-DIV.tabs INPUT
+div.tabs input
 {
     float           : right;
     display         : inline;
     font-size       : 12px;
 }
 
-DIV.tabs TD
+div.tabs td
 {
     font-size       : 12px;
     font-weight     : bold;
     text-decoration : none;
 }
 
-/* Commented Backslash Hack hides rule from IE5-Mac \*/
-DIV.tabs SPAN {float : none;}
+/* Commented backslash hack hides rule from IE5-Mac \*/
+div.tabs span { float : none; }
 /* End IE5-Mac hack */
 
-DIV.tabs A:hover SPAN
+div.tabs a:hover span
 {
     background-position: 0% -150px;
 }
 
-DIV.tabs LI#current A
+div.tabs li#current a
 {
     border-width    : 0px;
     border-right    : 1px solid #000000;
     color           : #0000ff;
 }
 
-DIV.tabs LI#current SPAN
+div.tabs li#current span
 {
     padding-bottom  : 0px;
 }
 
-DIV.nav
+div.nav
 {
     background      : none;
     border          : none;

doc/Doxygen/tools/find-its

@@ -1,48 +0,0 @@
-#!/usr/bin/perl -w
-use strict;
-use File::Find ();
-
-# -----------------------------------------------------------------------------
-#
-# Script
-#     find-its
-#
-# Description
-#     Search for *.[CH] files with "it's"
-#     This contraction (== "it is") looks too much like "its" (possesive)
-#     and confuses non-native (and some native) English speakers.
-#
-#     - print filename and lineNumber
-#
-# -----------------------------------------------------------------------------
-
-my $re_filespec = qr{^.+\.[CH]$};
-
-# for the convenience of &wanted calls, including -eval statements:
-## use vars qw( *name *dir *prune );
-## *name   = *File::Find::name;
-## *dir    = *File::Find::dir;
-## *prune  = *File::Find::prune;
-
-sub wanted {
-    unless ( lstat($_) and -f _ and -r _ and not -l _ and /$re_filespec/ ) {
-        return;
-    }
-
-    local @ARGV = $_;
-    while (<>) {
-        if (m{it\'s}) {
-            print "$File::Find::name  line=$.\n";
-        }
-    }
-
-    close ARGV;
-}
-
-## Traverse desired filesystems
-for my $dir (@ARGV) {
-    no warnings 'File::Find';
-    warn "(**) checking '$dir' ...\n";
-    File::Find::find( { wanted => \&wanted }, $dir );
-}
-

doc/tools/find-its

@@ -0,0 +1,17 @@
+#!/bin/sh
+# -----------------------------------------------------------------------------
+# Script
+#     find-its
+#
+# Description
+#     Search for files with "it's"
+#     This contraction (== "it is") looks too much like "its" (possesive)
+#     and confuses non-native (and some native) English speakers.
+#
+# -----------------------------------------------------------------------------
+set -x
+cd $WM_PROJECT_DIR || exit 1
+
+git grep -e "it's"
+
+#------------------------------------------------------------------ end-of-file

etc/codeTemplates/source/_Template.C

@@ -64,7 +64,8 @@ Foam::CLASSNAME::CLASSNAME(const CLASSNAME&)
 
 // * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
 
-Foam::autoPtr<Foam::CLASSNAME> Foam::CLASSNAME::New()
+Foam::autoPtr<Foam::CLASSNAME>
+Foam::CLASSNAME::New()
 {
     return autoPtr<CLASSNAME>(new CLASSNAME);
 }

etc/settings.csh

@@ -75,7 +75,7 @@ _foamAddLib  ${FOAM_USER_LIBBIN}:${FOAM_SITE_LIBBIN}:${FOAM_LIBBIN}:${FOAM_LIBBI
 
 # Compiler settings
 # ~~~~~~~~~~~~~~~~~
-unset gcc_version gmp_version mpfr_version
+unset gcc_version gmp_version mpfr_version mpc_version
 unsetenv MPFR_ARCH_PATH
 
 
@@ -92,25 +92,22 @@ case OpenFOAM:
         set gmp_version=gmp-5.0.1
         set mpfr_version=mpfr-2.4.2
         breaksw
-
-    case Gcc442:
-        set gcc_version=gcc-4.4.2
-        set gmp_version=gmp-4.2.4
-        set mpfr_version=mpfr-2.4.1
+    case Gcc45:
+        set gcc_version=gcc-4.5.0
+        set gmp_version=gmp-5.0.1
+        set mpfr_version=mpfr-2.4.2
+        set mpc_version=mpc-0.8.1
         breaksw
-
     case Gcc44:
-        set gcc_version=gcc-4.4.2
-        set gmp_version=gmp-4.2.4
-        set mpfr_version=mpfr-2.4.1
+        set gcc_version=gcc-4.4.3
+        set gmp_version=gmp-5.0.1
+        set mpfr_version=mpfr-2.4.2
         breaksw
-
     case Gcc43:
         set gcc_version=gcc-4.3.3
         set gmp_version=gmp-4.2.4
         set mpfr_version=mpfr-2.4.1
         breaksw
-
     default:
         echo
         echo "Warning in $WM_PROJECT_DIR/etc/settings.csh:"
@@ -118,7 +115,6 @@ case OpenFOAM:
         echo "    Please check your settings"
         echo
         breaksw
-
     endsw
 
     if ( $?gcc_version ) then
@@ -126,6 +122,10 @@ case OpenFOAM:
         set gmpDir=$WM_THIRD_PARTY_DIR/platforms/$WM_ARCH$WM_COMPILER_ARCH/$gmp_version
         set mpfrDir=$WM_THIRD_PARTY_DIR/platforms/$WM_ARCH$WM_COMPILER_ARCH/$mpfr_version
 
+        if ( $?mpc_version ) then
+            set mpcDir=$WM_THIRD_PARTY_DIR/platforms/$WM_ARCH$WM_COMPILER_ARCH/$mpc_version
+        endif
+
         # Check that the compiler directory can be found
         if ( ! -d "$gccDir" ) then
             echo
@@ -138,17 +138,28 @@ case OpenFOAM:
 
         _foamAddMan     $gccDir/man
         _foamAddPath    $gccDir/bin
-        _foamAddLib     $gccDir/lib${WM_COMPILER_LIB_ARCH}:$gccDir/lib
+
+        # 64-bit needs lib64, but 32-bit needs lib (not lib32)
+        if ($WM_ARCH_OPTION == 64) then
+            _foamAddLib     $gccDir/lib$WM_COMPILER_LIB_ARCH
+        else
+            _foamAddLib     $gccDir/lib
+        endif
 
         # add in gmp/mpfr libraries
         _foamAddLib     $gmpDir/lib
         _foamAddLib     $mpfrDir/lib
 
+        # add in mpc libraries (not need for older gcc)
+        if ( $?mpc_version ) then
+            _foamAddLib     $mpcDir/lib
+        endif
+
         # used by boost/CGAL:
         setenv MPFR_ARCH_PATH $mpfrDir
     endif
-    unset gcc_version gccDir  gmp_version gmpDir  mpfr_version mpfrDir
-
+    unset gcc_version gccDir
+    unset gmp_version gmpDir  mpfr_version mpfrDir  mpc_version mpcDir
     breaksw
 endsw
 
@@ -199,18 +210,14 @@ case OPENMPI:
     breaksw
 
 case SYSTEMOPENMPI:
-    # This uses the installed openmpi. It needs mpicc installed!
+    # use the system installed openmpi, get library directory via mpicc
     set mpi_version=openmpi-system
-
-    # Set compilation flags here instead of in wmake/rules/../mplibSYSTEMOPENMPI
-    setenv PINC `mpicc --showme:compile`
-    setenv PLIBS `mpicc --showme:link`
-    set libDir=`echo "$PLIBS" | sed -e 's/.*-L\([^ ]*\).*/\1/'`
+    set libDir=`mpicc --showme:link | sed -e 's/.*-L\([^ ]*\).*/\1/'`
 
     if ($?FOAM_VERBOSE && $?prompt) then
-        echo "Using system installed MPI:"
-        echo "    compile flags : $PINC"
-        echo "    link flags    : $PLIBS"
+        echo "Using system installed OpenMPI:"
+        echo "    compile flags : `mpicc --showme:compile`"
+        echo "    link flags    : `mpicc --showme:link`"
         echo "    libmpi dir    : $libDir"
     endif
 

etc/settings.sh

@@ -99,7 +99,8 @@ _foamAddLib  $FOAM_USER_LIBBIN:$FOAM_SITE_LIBBIN:$FOAM_LIBBIN:$FOAM_LIBBIN/dummy
 
 # Compiler settings
 # ~~~~~~~~~~~~~~~~~
-unset gcc_version gmp_version mpfr_version MPFR_ARCH_PATH
+unset gcc_version gmp_version mpfr_version mpc_version
+unset MPFR_ARCH_PATH
 
 # Select compiler installation
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -114,15 +115,16 @@ OpenFOAM)
         gmp_version=gmp-5.0.1
         mpfr_version=mpfr-2.4.2
         ;;
-    Gcc442)
-        gcc_version=gcc-4.4.2
-        gmp_version=gmp-4.2.4
-        mpfr_version=mpfr-2.4.1
+    Gcc45)
+        gcc_version=gcc-4.5.0
+        gmp_version=gmp-5.0.1
+        mpfr_version=mpfr-2.4.2
+        mpc_version=mpc-0.8.1
         ;;
     Gcc44)
-        gcc_version=gcc-4.4.2
-        gmp_version=gmp-4.2.4
-        mpfr_version=mpfr-2.4.1
+        gcc_version=gcc-4.4.3
+        gmp_version=gmp-5.0.1
+        mpfr_version=mpfr-2.4.2
         ;;
     Gcc43)
         gcc_version=gcc-4.3.3
@@ -143,6 +145,7 @@ OpenFOAM)
         gccDir=$WM_THIRD_PARTY_DIR/platforms/$WM_ARCH$WM_COMPILER_ARCH/$gcc_version
         gmpDir=$WM_THIRD_PARTY_DIR/platforms/$WM_ARCH$WM_COMPILER_ARCH/$gmp_version
         mpfrDir=$WM_THIRD_PARTY_DIR/platforms/$WM_ARCH$WM_COMPILER_ARCH/$mpfr_version
+        mpcDir=$WM_THIRD_PARTY_DIR/platforms/$WM_ARCH$WM_COMPILER_ARCH/$mpc_version
 
         # Check that the compiler directory can be found
         [ -d "$gccDir" ] || {
@@ -156,22 +159,30 @@ OpenFOAM)
 
         _foamAddMan     $gccDir/man
         _foamAddPath    $gccDir/bin
-        _foamAddLib     $gccDir/lib
 
         # 64-bit needs lib64, but 32-bit needs lib (not lib32)
         if [ "$WM_ARCH_OPTION" = 64 ]
         then
             _foamAddLib     $gccDir/lib$WM_COMPILER_LIB_ARCH
+        else
+            _foamAddLib     $gccDir/lib
         fi
 
         # add in gmp/mpfr libraries
         _foamAddLib     $gmpDir/lib
         _foamAddLib     $mpfrDir/lib
 
+        # add in mpc libraries (not need for older gcc)
+        if [ -n "$mpc_version" ]
+        then
+            _foamAddLib     $mpcDir/lib
+        fi
+
         # used by boost/CGAL:
         export MPFR_ARCH_PATH=$mpfrDir
     fi
-    unset gcc_version gccDir  gmp_version gmpDir  mpfr_version mpfrDir
+    unset gcc_version gccDir
+    unset gmp_version gmpDir  mpfr_version mpfrDir  mpc_version mpcDir
     ;;
 esac
 
@@ -224,19 +235,15 @@ OPENMPI)
     ;;
 
 SYSTEMOPENMPI)
-    # This uses the installed openmpi. It needs mpicc installed!
+    # use the system installed openmpi, get library directory via mpicc
     mpi_version=openmpi-system
-
-    # Set compilation flags here instead of in wmake/rules/../mplibSYSTEMOPENMPI
-    export PINC=`mpicc --showme:compile`
-    export PLIBS=`mpicc --showme:link`
-    libDir=`echo "$PLIBS" | sed -e 's/.*-L\([^ ]*\).*/\1/'`
+    libDir=`mpicc --showme:link | sed -e 's/.*-L\([^ ]*\).*/\1/'`
 
     if [ "$FOAM_VERBOSE" -a "$PS1" ]
     then
-        echo "Using system installed MPI:"
-        echo "    compile flags : $PINC"
-        echo "    link flags    : $PLIBS"
+        echo "Using system installed OpenMPI:"
+        echo "    compile flags : `mpicc --showme:compile`"
+        echo "    link flags    : `mpicc --showme:link`"
         echo "    libmpi dir    : $libDir"
     fi
 

src/ODE/Make/files

@@ -6,7 +6,7 @@ ODESolversRK  =  ODESolvers/RK
 ODESolversSIBS  =  ODESolvers/SIBS
 
 $(ODESolversODESolver)/ODESolver.C
-$(ODESolversODESolver)/newODESolver.C
+$(ODESolversODESolver)/ODESolverNew.C
 
 $(ODESolversRK)/RK.C
 

src/ODE/ODESolvers/ODESolver/ODESolverNew.C

@@ -44,7 +44,7 @@ Foam::autoPtr<Foam::ODESolver> Foam::ODESolver::New
         (
             "ODESolver::New(const word& ODESolverTypeName, const ODE& ode)"
         )   << "Unknown ODESolver type "
-            << ODESolverTypeName << endl << endl
+            << ODESolverTypeName << nl << nl
             << "Valid ODESolvers are : " << endl
             << ODEConstructorTablePtr_->sortedToc()
             << exit(FatalError);

src/OSspecific/POSIX/printStack.C

@@ -131,7 +131,6 @@ void printSourceFileAndLine
         else
         {
             string cwdLine(line.replaceAll(cwd() + '/', ""));
-
             string homeLine(cwdLine.replaceAll(home(), '~'));
 
             os  << " at " << homeLine.c_str();

src/OpenFOAM/Make/files

@@ -258,14 +258,14 @@ $(GAMG)/GAMGSolverSolve.C
 
 GAMGInterfaces = $(GAMG)/interfaces
 $(GAMGInterfaces)/GAMGInterface/GAMGInterface.C
-$(GAMGInterfaces)/GAMGInterface/newGAMGInterface.C
+$(GAMGInterfaces)/GAMGInterface/GAMGInterfaceNew.C
 $(GAMGInterfaces)/processorGAMGInterface/processorGAMGInterface.C
 $(GAMGInterfaces)/processorCyclicGAMGInterface/processorCyclicGAMGInterface.C
 $(GAMGInterfaces)/cyclicGAMGInterface/cyclicGAMGInterface.C
 
 GAMGInterfaceFields = $(GAMG)/interfaceFields
 $(GAMGInterfaceFields)/GAMGInterfaceField/GAMGInterfaceField.C
-$(GAMGInterfaceFields)/GAMGInterfaceField/newGAMGInterfaceField.C
+$(GAMGInterfaceFields)/GAMGInterfaceField/GAMGInterfaceFieldNew.C
 $(GAMGInterfaceFields)/processorGAMGInterfaceField/processorGAMGInterfaceField.C
 $(GAMGInterfaceFields)/processorCyclicGAMGInterfaceField/processorCyclicGAMGInterfaceField.C
 $(GAMGInterfaceFields)/cyclicGAMGInterfaceField/cyclicGAMGInterfaceField.C
@@ -330,7 +330,7 @@ polyMesh = meshes/polyMesh
 
 polyPatches = $(polyMesh)/polyPatches
 $(polyPatches)/polyPatch/polyPatch.C
-$(polyPatches)/polyPatch/newPolyPatch.C
+$(polyPatches)/polyPatch/polyPatchNew.C
 
 basicPolyPatches = $(polyPatches)/basic
 $(basicPolyPatches)/coupled/coupledPolyPatch.C
@@ -365,15 +365,15 @@ $(zone)/zone.C
 
 cellZone = $(polyMesh)/zones/cellZone
 $(cellZone)/cellZone.C
-$(cellZone)/newCellZone.C
+$(cellZone)/cellZoneNew.C
 
 faceZone = $(polyMesh)/zones/faceZone
 $(faceZone)/faceZone.C
-$(faceZone)/newFaceZone.C
+$(faceZone)/faceZoneNew.C
 
 pointZone = $(polyMesh)/zones/pointZone
 $(pointZone)/pointZone.C
-$(pointZone)/newPointZone.C
+$(pointZone)/pointZoneNew.C
 
 $(polyMesh)/polyMesh.C
 $(polyMesh)/polyMeshFromShapeMesh.C
@@ -441,7 +441,7 @@ $(pointMeshMapper)/pointPatchMapper.C
 pointPatches = $(pointMesh)/pointPatches
 $(pointPatches)/pointPatch/pointPatch.C
 $(pointPatches)/facePointPatch/facePointPatch.C
-$(pointPatches)/facePointPatch/newFacePointPatch.C
+$(pointPatches)/facePointPatch/facePointPatchNew.C
 
 basicPointPatches = $(pointPatches)/basic
 $(basicPointPatches)/coupled/coupledPointPatch.C

src/OpenFOAM/db/IOobject/IOobjectReadHeader.C

@@ -72,7 +72,7 @@ bool Foam::IOobject::readHeader(Istream& is)
         is.format(headerDict.lookup("format"));
         headerClassName_ = word(headerDict.lookup("class"));
 
-        word headerObject(headerDict.lookup("object"));
+        const word headerObject(headerDict.lookup("object"));
         if (IOobject::debug && headerObject != name())
         {
             IOWarningIn("IOobject::readHeader(Istream&)", is)

src/OpenFOAM/db/IOstreams/IOstreams/IOstream.C

@@ -61,9 +61,9 @@ Foam::IOstream::compressionType
 Foam::IOstream::compressionEnum(const word& compression)
 {
     // get Switch (bool) value, but allow it to fail
-    Switch::switchType sw = Switch::asEnum(compression, true);
+    Switch sw(compression, true);
 
-    if (sw != Switch::INVALID)
+    if (sw.valid())
     {
         return sw ? IOstream::COMPRESSED : IOstream::UNCOMPRESSED;
     }

src/OpenFOAM/db/Time/Time.C

@@ -95,7 +95,7 @@ void Foam::Time::adjustDeltaT()
 void Foam::Time::setControls()
 {
     // default is to resume calculation from "latestTime"
-    word startFrom = controlDict_.lookupOrDefault<word>
+    const word startFrom = controlDict_.lookupOrDefault<word>
     (
         "startFrom",
         "latestTime"

src/OpenFOAM/db/Time/TimeIO.C

@@ -94,7 +94,7 @@ void Foam::Time::readDict()
 
     if (controlDict_.found("timeFormat"))
     {
-        word formatName(controlDict_.lookup("timeFormat"));
+        const word formatName(controlDict_.lookup("timeFormat"));
 
         if (formatName == "general")
         {

src/OpenFOAM/db/dictionary/functionEntries/functionEntry/functionEntry.C

@@ -82,7 +82,7 @@ bool Foam::functionEntry::execute
             "(const word& functionName, dictionary& parentDict, Istream&)"
         )   << "Unknown functionEntry '" << functionName
             << "' in " << is.name() << " near line " << is.lineNumber()
-            << endl << endl
+            << nl << nl
             << "Valid functionEntries are :" << endl
             << executedictionaryIstreamMemberFunctionTablePtr_->toc()
             << exit(FatalError);
@@ -128,7 +128,7 @@ bool Foam::functionEntry::execute
             "(const word&, const dictionary&, primitiveEntry&, Istream&)"
         )   << "Unknown functionEntry '" << functionName
             << "' in " << is.name() << " near line " << is.lineNumber()
-            << endl << endl
+            << nl << nl
             << "Valid functionEntries are :" << endl
             << executeprimitiveEntryIstreamMemberFunctionTablePtr_->toc()
             << exit(FatalError);

src/OpenFOAM/db/functionObjects/functionObject/functionObject.C

@@ -50,7 +50,7 @@ Foam::autoPtr<Foam::functionObject> Foam::functionObject::New
     const dictionary& functionDict
 )
 {
-    word functionType(functionDict.lookup("type"));
+    const word functionType(functionDict.lookup("type"));
 
     if (debug)
     {