Merge commit 'bd947865f2881af1c52b458aa6b6b1b1844ce254' into nextRelease

Conflicts:
	ListOfContributors
	applications/solvers/compressible/sonicDyMFoam/eEqn.H
	applications/utilities/immersedBoundary/refineImmersedBoundaryMesh/Make/options
	src/coupledMatrix/coupledLduMatrix/coupledLduMatrix.C
	src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/dynamicTopoFvMeshCoupled.C
	src/finiteVolume/fields/fvPatchFields/basic/basicSymmetry/basicSymmetryFvPatchScalarField.C
	src/finiteVolume/finiteVolume/gradSchemes/leastSquaresGrad/leastSquaresVectors.C
	src/finiteVolume/finiteVolume/gradSchemes/leastSquaresGrad/leastSquaresVectors.H
	src/foam/fields/PointPatchFields/constraint/processor/ProcessorPointPatchField.C
	src/foam/interpolations/GGIInterpolation/GGIInterpolationQuickRejectTests.C
	src/foam/matrices/blockLduMatrix/BlockAmg/coarseBlockAmgLevel.C
	src/foam/meshes/polyMesh/globalMeshData/globalMeshData.H
	src/lduSolvers/amg/coarseAmgLevel.C
	src/mesh/cfMesh/meshLibrary/utilities/octrees/meshOctree/refinementControls/objectRefinement/objectRefinement.C

ListOfContributors

@@ -82,5 +82,3 @@ Contents:
     Niklas Wikstrom
     Vanja Skuric
     Alexander Vakhrushev
-    Inno Gatin
-    Alexey Matveichev

applications/solvers/compressible/sonicDyMFoam/eEqn.H

@@ -29,7 +29,7 @@
 
     // Bound the energy using TMin and TMax
     {
-        dimensionedScalar Tstd("Tstd", dimTemperature, specie::Tstd);
+        dimensionedScalar Tstd("Tstd", dimTemperature, specie::Tstd());
 
         volScalarField Cv = thermo.Cv();
         volScalarField R = thermo.Cp() - Cv;

applications/solvers/heatTransfer/chtMultiRegionFoam/derivedFvPatchFields/solidWallMixedTemperatureCoupled/solidWallMixedTemperatureCoupledFvPatchScalarField.C

@@ -173,7 +173,7 @@ void Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::updateCoeffs()
     scalarField nbrIntFld = nbrField.patchInternalField();
     mapDistribute::distribute
     (
-        Pstream::defaultCommsType,
+        static_cast<Pstream::commsTypes>(Pstream::defaultCommsType()),
         distMap.schedule(),
         distMap.constructSize(),
         distMap.subMap(),           // what to send
@@ -185,7 +185,7 @@ void Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::updateCoeffs()
     scalarField nbrKDelta = nbrField.K()*nbrPatch.deltaCoeffs();
     mapDistribute::distribute
     (
-        Pstream::defaultCommsType,
+        static_cast<Pstream::commsTypes>(Pstream::defaultCommsType()),
         distMap.schedule(),
         distMap.constructSize(),
         distMap.subMap(),           // what to send

applications/utilities/mesh/cfMesh/FMSToSurface/FMSToSurface.C

@@ -0,0 +1,166 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | cfMesh: A library for mesh generation
+   \\    /   O peration     |
+    \\  /    A nd           | Author: Franjo Juretic (franjo.juretic@c-fields.com)
+     \\/     M anipulation  | Copyright (C) Creative Fields, Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of cfMesh.
+
+    cfMesh 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.
+
+    cfMesh 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 cfMesh.  If not, see <http://www.gnu.org/licenses/>.
+
+Description
+    Creates surface patches from surface subsets
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "Time.H"
+#include "triSurf.H"
+#include "triSurfaceCopyParts.H"
+#include "demandDrivenData.H"
+#include "OFstream.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+void exportFeatureEdges
+(
+    const triSurf& origSurf,
+    const fileName& edgeFileName
+)
+{
+    OFstream file(edgeFileName);
+
+    const pointField& points = origSurf.points();
+    labelList newPointLabel(points.size(), -1);
+    label nPoints(0);
+
+    const edgeLongList& featureEdges = origSurf.featureEdges();
+    forAll(featureEdges, feI)
+    {
+        const edge& e = featureEdges[feI];
+
+        if( newPointLabel[e[0]] == -1 )
+            newPointLabel[e[0]] = nPoints++;
+        if( newPointLabel[e[1]] == -1 )
+            newPointLabel[e[1]] = nPoints++;
+    }
+
+    pointField pCopy(nPoints);
+    forAll(newPointLabel, pI)
+    {
+        if( newPointLabel[pI] < 0 )
+            continue;
+
+        pCopy[newPointLabel[pI]] = points[pI];
+    }
+
+    //- write the header
+    file << "# vtk DataFile Version 3.0\n";
+    file << "vtk output\n";
+    file << "ASCII\n";
+    file << "DATASET POLYDATA\n";
+
+    //- write points
+    file << "POINTS " << pCopy.size() << " float\n";
+    forAll(pCopy, pI)
+    {
+        const point& p = pCopy[pI];
+        file << p.x() << ' ' << p.y() << ' ' << p.z() << '\n';
+    }
+
+    file << "\nLINES " << featureEdges.size()
+         << ' ' << 3*featureEdges.size() << nl;
+    forAll(featureEdges, edgeI)
+    {
+        const edge& e = featureEdges[edgeI];
+        file << "2 " << newPointLabel[e[0]]
+             << token::SPACE << newPointLabel[e[1]] << nl;
+    }
+    file << nl;
+
+    if( !file )
+        FatalErrorIn
+        (
+            "void exportFeatureEdges(const triSurf&, const fileName&)"
+        ) << "Writting of feature edges failed!" << exit(FatalError);
+}
+
+int main(int argc, char *argv[])
+{
+    argList::noParallel();
+    argList::validArgs.clear();
+
+    argList::validArgs.append("input surface file");
+    argList::validArgs.append("output surface file");
+    argList::validOptions.insert("exportSubsets", "");
+    argList::validOptions.insert("exportFeatureEdges", "");
+    argList args(argc, argv);
+
+    fileName inFileName(args.args()[1]);
+    fileName outFileName(args.args()[2]);
+
+    fileName outFileNoExt = outFileName.lessExt();
+    fileName outExtension = outFileName.ext();
+
+    Info << "Out file no ext " << outFileNoExt << endl;
+    Info << "Extension " << outExtension << endl;
+
+    //- read the inout surface
+    triSurf origSurf(inFileName);
+
+    //- write the surface in the requated format
+    origSurf.writeSurface(outFileName);
+
+    //- export surface subsets as separate surface meshes
+    if( args.options().found("exportSubsets") )
+    {
+        DynList<label> subsetIDs;
+        origSurf.facetSubsetIndices(subsetIDs);
+
+        triSurfaceCopyParts copyParts(origSurf);
+
+        forAll(subsetIDs, subsetI)
+        {
+            //- get the name of the subset
+            triSurf copySurf;
+            wordList subsetName(1);
+            subsetName[0] = origSurf.facetSubsetName(subsetIDs[subsetI]);
+
+            //- create a surface mesh corresponding to the subset
+            copyParts.copySurface(subsetName, copySurf);
+
+            //- write the mesh on disk
+            fileName fName = outFileNoExt+"_facetSubset_"+subsetName[0];
+            fName += '.'+outExtension;
+
+            copySurf.writeSurface(fName);
+        }
+    }
+
+    if( args.options().found("exportFeatureEdges") )
+    {
+        fileName fName = outFileNoExt+"_featureEdges";
+        fName += ".vtk";
+        exportFeatureEdges(origSurf, fName);
+    }
+
+    Info << "End\n" << endl;
+    return 0;
+}
+
+// ************************************************************************* //

applications/utilities/mesh/cfMesh/FMSToSurface/Make/files

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

applications/utilities/mesh/cfMesh/FMSToSurface/Make/options

@@ -0,0 +1,9 @@
+EXE_INC = \
+    -I$(FOAM_SRC)/mesh/cfMesh/meshLibrary/lnInclude \
+    -I$(FOAM_SRC)/meshTools/lnInclude \
+    -I$(FOAM_SRC)/triSurface/lnInclude
+
+EXE_LIBS = \
+    -ltriSurface \
+    -lmeshTools \
+    -lmeshLibrary

applications/utilities/mesh/cfMesh/FMSToVTK/FMSToVTK.C

@@ -0,0 +1,545 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | cfMesh: A library for mesh generation
+   \\    /   O peration     |
+    \\  /    A nd           | Author: Franjo Juretic (franjo.juretic@c-fields.com)
+     \\/     M anipulation  | Copyright (C) Creative Fields, Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of cfMesh.
+
+    cfMesh 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.
+
+    cfMesh 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 cfMesh.  If not, see <http://www.gnu.org/licenses/>.
+
+Description
+    cfMesh utility to convert a surface file to VTK multiblock dataset
+    format, including the patches, feature edges and surface features.
+
+Author
+    Ivor Clifford <ivor.clifford@psi.ch>
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "autoPtr.H"
+#include "OFstream.H"
+#include "triSurf.H"
+#include "triSurfModifier.H"
+#include "xmlTag.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//- Write the supplied pointList in serial vtkPolyData format
+void writePointsToVTK
+(
+    const fileName& fn,
+    const string& title,
+    const UList<point>& points
+)
+{
+    xmlTag xmlRoot("VTKFile");
+    xmlRoot.addAttribute("type", "PolyData");
+    
+    xmlTag& xmlPolyData = xmlRoot.addChild("PolyData");
+    
+    xmlTag& xmlPiece = xmlPolyData.addChild("Piece");
+    xmlPiece.addAttribute("NumberOfPoints", points.size());
+    
+    xmlTag& xmlPoints = xmlPiece.addChild("Points");
+    
+    xmlTag& xmlPointData = xmlPoints.addChild("DataArray");
+    xmlPointData.addAttribute("type", "Float32");
+    xmlPointData.addAttribute("NumberOfComponents", 3);
+    xmlPointData.addAttribute("format", "ascii");
+    xmlPointData << points;
+    
+    OFstream os(fn);
+    os << xmlRoot << endl;
+    
+    Info << "Created " << fn << endl;
+}
+
+
+//- Write the supplied addressed pointList in serial vtkPolyData format
+void writePointsToVTK
+(
+    const fileName& fn,
+    const string& title,
+    const UList<point>& points,
+    unallocLabelList& addr
+)
+{
+    // Create subaddressed points
+    pointField newPoints(addr.size());
+    
+    forAll(addr, i)
+    {
+        newPoints[i] = points[addr[i]];
+    }
+    
+    writePointsToVTK
+    (
+        fn,
+        title,
+        newPoints
+    );
+}
+
+
+//- Write the supplied edgeList in serial vtkPolyData format
+void writeEdgesToVTK
+(
+    const fileName& fn,
+    const string& title,
+    const UList<point>& points,
+    const LongList<edge>& edges
+)
+{
+    labelList connectivity(edges.size());
+    
+    forAll(edges, edgeI)
+    {
+        connectivity[edgeI] = 2*(edgeI+1);
+    }
+    
+    xmlTag xmlRoot("VTKFile");
+    xmlRoot.addAttribute("type", "PolyData");
+    
+    xmlTag& xmlPolyData = xmlRoot.addChild("PolyData");
+    
+    xmlTag& xmlPiece = xmlPolyData.addChild("Piece");
+    xmlPiece.addAttribute("NumberOfPoints", points.size());
+    xmlPiece.addAttribute("NumberOfLines", edges.size());
+    
+    xmlTag& xmlPoints = xmlPiece.addChild("Points");
+    
+    xmlTag& xmlPointData = xmlPoints.addChild("DataArray");
+    xmlPointData.addAttribute("type", "Float32");
+    xmlPointData.addAttribute("NumberOfComponents", 3);
+    xmlPointData.addAttribute("format", "ascii");
+    xmlPointData << points;
+
+    xmlTag& xmlEdges = xmlPiece.addChild("Lines");
+
+    xmlTag& xmlEdgeData = xmlEdges.addChild("DataArray");
+    xmlEdgeData.addAttribute("type", "Int32");
+    xmlEdgeData.addAttribute("Name", "connectivity");
+    xmlEdgeData.addAttribute("format", "ascii");
+    xmlEdgeData << edges;
+
+    xmlTag& xmlConnectData = xmlEdges.addChild("DataArray");
+    xmlConnectData.addAttribute("type", "Int32");
+    xmlConnectData.addAttribute("Name", "offsets");
+    xmlConnectData.addAttribute("format", "ascii");
+    xmlConnectData << connectivity;
+    
+    OFstream os(fn);
+    os << xmlRoot << endl;
+
+    Info << "Created " << fn << endl;
+}
+
+//- Write the supplied edgeList subset in serial vtkPolyData format
+void writeEdgesToVTK
+(
+    const fileName& fn,
+    const string& title,
+    const UList<point>& points,
+    const LongList<edge>& edges,
+    const unallocLabelList& addr
+)
+{
+    // Remove unused points and create subaddressed edges
+    DynamicList<point> newPoints;
+    labelList newPointAddr(points.size(), -1);
+    LongList<edge> newEdges(addr.size());
+    
+    forAll(addr, addrI)
+    {
+        label edgeI = addr[addrI];
+        
+        const edge& curEdge = edges[edgeI];
+        edge& newEdge = newEdges[addrI];
+        
+        forAll(curEdge, i)
+        {
+            label pointId = curEdge[i];
+            
+            if (newPointAddr[pointId] == -1)
+            {
+                newPoints.append(points[pointId]);
+                newPointAddr[pointId] = newPoints.size()-1;
+            }
+            
+            newEdge[i] = newPointAddr[pointId];
+        }
+    }
+    
+    writeEdgesToVTK
+    (
+        fn,
+        title,
+        newPoints,
+        newEdges
+    );
+}
+
+
+//- Write the supplied facet list in serial vtkPolyData format
+void writeFacetsToVTK
+(
+    const fileName& fn,
+    const string& title,
+    const UList<point>& points,
+    const LongList<labelledTri>& facets
+)
+{
+    labelList connectivity(facets.size());
+    
+    forAll(facets, faceI)
+    {
+        connectivity[faceI] = 3*(faceI+1);
+    }
+    
+    labelList regionData(facets.size());
+    
+    forAll(facets, faceI)
+    {
+        regionData[faceI] =  facets[faceI].region();
+    }
+    
+    xmlTag xmlRoot("VTKFile");
+    xmlRoot.addAttribute("type", "PolyData");
+    
+    xmlTag& xmlPolyData = xmlRoot.addChild("PolyData");
+    
+    xmlTag& xmlPiece = xmlPolyData.addChild("Piece");
+    xmlPiece.addAttribute("NumberOfPoints", points.size());
+    xmlPiece.addAttribute("NumberOfPolys", facets.size());
+    
+    xmlTag& xmlPoints = xmlPiece.addChild("Points");
+    
+    xmlTag& xmlPointData = xmlPoints.addChild("DataArray");
+    xmlPointData.addAttribute("type", "Float32");
+    xmlPointData.addAttribute("NumberOfComponents", 3);
+    xmlPointData.addAttribute("format", "ascii");
+    xmlPointData << points;
+
+    xmlTag& xmlPolys = xmlPiece.addChild("Polys");
+
+    xmlTag& xmlPolyDataArray = xmlPolys.addChild("DataArray");
+    xmlPolyDataArray.addAttribute("type", "Int32");
+    xmlPolyDataArray.addAttribute("Name", "connectivity");
+    xmlPolyDataArray.addAttribute("format", "ascii");
+    xmlPolyDataArray << facets;
+
+    xmlTag& xmlConnectData = xmlPolys.addChild("DataArray");
+    xmlConnectData.addAttribute("type", "Int32");
+    xmlConnectData.addAttribute("Name", "offsets");
+    xmlConnectData.addAttribute("format", "ascii");
+    xmlConnectData << connectivity;
+    
+    xmlTag& xmlCellData = xmlPiece.addChild("CellData");
+    
+    xmlTag& xmlCellDataArray = xmlCellData.addChild("DataArray");
+    xmlCellDataArray.addAttribute("type", "Int32");
+    xmlCellDataArray.addAttribute("Name", "region");
+    xmlCellDataArray.addAttribute("format", "ascii");
+    xmlCellDataArray << regionData;
+    
+    OFstream os(fn);
+    os << xmlRoot << endl;
+    
+    Info << "Created " << fn << endl;
+}
+
+
+//- Write an addressed subset of the supplied facet list
+//-  in serial vtkPolyData format
+void writeFacetsToVTK
+(
+    const fileName& fn,
+    const string& title,
+    const pointField& points,
+    const LongList<labelledTri>& facets,
+    const unallocLabelList& addr
+)
+{        
+    // Remove unused points and create subaddressed facets
+    DynamicList<point> newPoints;
+    labelList newPointAddr(points.size(), -1);
+    LongList<labelledTri> newFacets(addr.size());
+    
+    forAll(addr, addrI)
+    {
+        label faceI = addr[addrI];
+        
+        const labelledTri& facet = facets[faceI];
+        const FixedList<label, 3>& pointIds = facet;
+        FixedList<label, 3> newPointIds;
+        
+        forAll(pointIds, i)
+        {
+            label pointId = pointIds[i];
+            
+            if (newPointAddr[pointId] == -1)
+            {
+                newPoints.append(points[pointId]);
+                newPointAddr[pointId] = newPoints.size()-1;
+            }
+            
+            newPointIds[i] = newPointAddr[pointId];
+        }
+        
+        newFacets[addrI] = labelledTri
+        (
+            newPointIds[0],
+            newPointIds[1],
+            newPointIds[2],
+            facet.region()
+        );
+    }
+    
+    writeFacetsToVTK
+    (
+        fn,
+        title,
+        newPoints,
+        newFacets
+    );
+}
+
+
+int main(int argc, char *argv[])
+{
+    argList::noParallel();
+    argList::validArgs.clear();
+
+    argList::validArgs.append("input surface file");
+    argList::validArgs.append("output prefix");
+    argList args(argc, argv);
+
+    // Process commandline arguments
+    fileName inFileName(args.args()[1]);
+    fileName outPrefix(args.args()[2]);
+    
+    // Read original surface
+    triSurf origSurf(inFileName);
+    
+    const pointField& points = origSurf.points();
+    const LongList<labelledTri>& facets = origSurf.facets();
+    const LongList<edge>& edges = origSurf.featureEdges();
+    const geometricSurfacePatchList& patches = origSurf.patches();
+    
+    label index = 0;
+    
+    // Create file structure for multiblock dataset
+    mkDir(outPrefix);
+    mkDir(outPrefix + "/patches");
+    mkDir(outPrefix + "/pointSubsets");
+    mkDir(outPrefix + "/edgeSubsets");
+    mkDir(outPrefix + "/faceSubsets");
+    
+    // Create VTK multiblock dataset file
+    xmlTag xmlRoot("VTKFile");
+    xmlRoot.addAttribute("type", "vtkMultiBlockDataSet");
+    xmlRoot.addAttribute("version", "1.0");
+    xmlRoot.addAttribute("byte_order", "LittleEndian");
+    
+    xmlTag& xmlDataSet = xmlRoot.addChild("vtkMultiBlockDataSet");
+        
+    // Write faces and feature edges
+    {
+        fileName fn = outPrefix / "facets.vtp";
+        
+        writeFacetsToVTK
+        (
+            outPrefix / "facets.vtp",
+            outPrefix,
+            points,
+            facets
+        );
+        
+        xmlTag& tag = xmlDataSet.addChild("DataSet");
+        tag.addAttribute("index", Foam::name(index++));
+        tag.addAttribute("name", "facets");
+        tag.addAttribute("file", fn);
+    }
+    
+    {
+        fileName fn = outPrefix / "featureEdges.vtp";
+        
+        writeEdgesToVTK
+        (
+            outPrefix / "featureEdges.vtp",
+            "featureEdges",
+            points,
+            edges
+        );
+    
+        xmlTag& tag = xmlDataSet.addChild("DataSet");
+        tag.addAttribute("index", Foam::name(index++));
+        tag.addAttribute("name", "featureEdges");
+        tag.addAttribute("file", fn);
+    }
+    
+    // Write patches
+    // Create patch addressing
+    List<DynamicList<label> > patchAddr(patches.size());
+    
+    forAll(facets, faceI)
+    {
+        patchAddr[facets[faceI].region()].append(faceI);
+    }
+    
+    {
+        xmlTag& xmlBlock = xmlDataSet.addChild("Block");
+        xmlBlock.addAttribute("index", Foam::name(index++));
+        xmlBlock.addAttribute("name", "patches");
+        
+        forAll(patches, patchI)
+        {            
+            word patchName = patches[patchI].name();
+            
+            fileName fn = outPrefix / "patches" / patchName + ".vtp";
+            
+            writeFacetsToVTK
+            (
+                fn,
+                patchName,
+                points,
+                facets,
+                patchAddr[patchI]
+            );
+            
+            xmlTag& tag = xmlBlock.addChild("DataSet");
+            tag.addAttribute("index", Foam::name(patchI));
+            tag.addAttribute("name", patchName);
+            tag.addAttribute("file", fn);
+        }
+    }
+    
+    // Write point subsets
+    {
+        xmlTag& xmlBlock = xmlDataSet.addChild("Block");
+        xmlBlock.addAttribute("index", Foam::name(index++));
+        xmlBlock.addAttribute("name", "pointSubsets");
+        
+        DynList<label> subsetIndices;
+        labelList subsetAddr;
+        
+        origSurf.pointSubsetIndices(subsetIndices);
+        
+        forAll(subsetIndices, id)
+        {
+            word subsetName = origSurf.pointSubsetName(id);
+            origSurf.pointsInSubset(id, subsetAddr);
+            
+            fileName fn = outPrefix / "pointSubsets" / subsetName + ".vtp";
+            
+            writePointsToVTK
+            (
+                fn,
+                subsetName,
+                points,
+                subsetAddr
+            );
+            
+            xmlTag& tag = xmlBlock.addChild("DataSet");
+            tag.addAttribute("index", Foam::name(id));
+            tag.addAttribute("name", subsetName);
+            tag.addAttribute("file", fn);
+        }
+    }
+    
+    // Write edge subsets
+    {
+        xmlTag& xmlBlock = xmlDataSet.addChild("Block");
+        xmlBlock.addAttribute("index", Foam::name(index++));
+        xmlBlock.addAttribute("name", "edgeSubsets");
+        
+        DynList<label> subsetIndices;
+        labelList subsetAddr;
+        
+        origSurf.edgeSubsetIndices(subsetIndices);
+        
+        forAll(subsetIndices, id)
+        {
+            word subsetName = origSurf.edgeSubsetName(id);
+            origSurf.edgesInSubset(id, subsetAddr);
+            
+            fileName fn = outPrefix / "edgeSubsets" / subsetName + ".vtp";
+            
+            writeEdgesToVTK
+            (
+                fn,
+                subsetName,
+                points,
+                edges,
+                subsetAddr
+            );
+            
+            xmlTag& tag = xmlBlock.addChild("DataSet");
+            tag.addAttribute("index", Foam::name(id));
+            tag.addAttribute("name", subsetName);
+            tag.addAttribute("file", fn);
+        }
+    }
+    
+    // Write facet subsets
+    {
+        xmlTag& xmlBlock = xmlDataSet.addChild("Block");
+        xmlBlock.addAttribute("index", Foam::name(index++));
+        xmlBlock.addAttribute("name", "faceSubsets");
+        
+        DynList<label> subsetIndices;
+        labelList subsetAddr;
+                
+        origSurf.facetSubsetIndices(subsetIndices);
+        
+        forAll(subsetIndices, id)
+        {            
+            word subsetName = origSurf.facetSubsetName(id);
+            origSurf.facetsInSubset(id, subsetAddr);
+            
+            fileName fn = outPrefix / "faceSubsets"  / subsetName + ".vtp";
+            
+            writeFacetsToVTK
+            (
+                fn,
+                subsetName,
+                points,
+                facets,
+                subsetAddr
+            );
+            
+            xmlTag& tag = xmlBlock.addChild("DataSet");
+            tag.addAttribute("index", Foam::name(id));
+            tag.addAttribute("name", subsetName);
+            tag.addAttribute("file", fn);
+        }
+    }    
+        
+    OFstream os(outPrefix + ".vtm");
+    os << xmlRoot << endl;
+    
+    Info << "Created " << outPrefix + ".vtm" << endl;
+    
+    Info << "End\n" << endl;
+    
+    return 0;
+}
+
+// ************************************************************************* //

applications/utilities/mesh/cfMesh/FMSToVTK/Make/files

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

applications/utilities/mesh/cfMesh/FMSToVTK/Make/options

@@ -0,0 +1,9 @@
+EXE_INC = \
+    -I$(FOAM_SRC)/mesh/cfMesh/meshLibrary/lnInclude \
+    -I$(FOAM_SRC)/meshTools/lnInclude \
+    -I$(FOAM_SRC)/triSurface/lnInclude
+
+EXE_LIBS = \
+    -ltriSurface \
+    -lmeshLibrary \
+    -lmeshTools

applications/utilities/mesh/cfMesh/FMSToVTK/xmlTag.H

@@ -0,0 +1,297 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     |
+    \\  /    A nd           | For copyright notice see file Copyright
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::xmlTag
+
+Description
+    Simple XML tag class allowing child tags and attributes. Specialized
+    output stream operators are provided to display or write the XML
+    structure.
+
+Author
+    Ivor Clifford <ivor.clifford@psi.ch>
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef XMLtag_H
+#define XMLtag_H
+
+#include "OStringStream.H"
+#include "HashTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class xmlTag Declaration
+\*---------------------------------------------------------------------------*/
+
+class xmlTag
+:
+    public OStringStream
+{
+    // Private data
+    
+        //- Tag name
+        word name_;
+        
+        //- Attributes
+        HashTable<string> attributes_;
+        
+        //- Child tags
+        DynamicList<xmlTag> children_;
+        
+public:
+
+    // Constructors
+
+        //- Null constructor
+        xmlTag()
+        :
+            OStringStream(),
+            name_("unknown"),
+            attributes_(),
+            children_()
+        {}
+        
+        //- Construct given tag name
+        xmlTag(const word& name)
+        :
+            OStringStream(),
+            name_(name),
+            attributes_(),
+            children_()
+        {}
+
+        //- Construct as copy
+        xmlTag(const xmlTag& tag)
+        :
+            OStringStream(tag),
+            name_(tag.name_),
+            attributes_(tag.attributes_),
+            children_(tag.children_)
+        {}
+
+    //- Destructor
+    ~xmlTag()
+    {}
+
+
+    // Member Functions
+    
+        //- Add an attribute
+        template<class T>
+        void addAttribute(const keyType& key, const T& value)
+        {
+            OStringStream os;
+            os << value;
+            attributes_.insert(key, os.str());
+        };
+        
+        //- Add a fileName attribute
+        void addAttribute(const keyType& key, const fileName& value)
+        {
+            attributes_.insert(key, value);
+        };
+        
+        //- Add a string attribute
+        void addAttribute(const keyType& key, const string& value)
+        {
+            attributes_.insert(key, value);
+        };
+
+        //- Add a word attribute
+        void addAttribute(const keyType& key, const word& value)
+        {
+            attributes_.insert(key, value);
+        };
+        
+        //- Add a child
+        xmlTag& addChild(const xmlTag& tag)
+        {
+            children_.append(tag);
+            
+            return children_[children_.size()-1];
+        };
+        
+        //- Create and add a new child
+        xmlTag& addChild(const word& name)
+        {
+            return addChild(xmlTag(name));
+        }
+
+    // Member Operators
+
+        void operator=(const xmlTag& tag)
+        {
+            name_ = tag.name_;
+            attributes_ = tag.attributes_;
+            children_ = tag.children_;            
+            OStringStream::rewind();
+            Foam::operator<<(*this, tag.str().c_str());
+        };
+        
+    // Friend IOstream Operators
+
+        friend Ostream& operator<<(Ostream&, const xmlTag&);
+        
+        template<class Form, class Cmpt, int nCmpt>
+        friend xmlTag& operator<<(xmlTag&, const VectorSpace<Form, Cmpt, nCmpt>&);
+        
+        friend xmlTag& operator<<(xmlTag&, const labelledTri&);
+        
+        template<class T, unsigned Size>
+        friend xmlTag& operator<<(xmlTag&, const FixedList<T, Size>&);
+
+        template<class T>
+        friend xmlTag& operator<<(xmlTag&, const LongList<T>&);
+        
+        template<class T>
+        friend xmlTag& operator<<(xmlTag&, const UList<T>&);
+};
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//- Write the tag in XML format to the supplied output stream
+Ostream& operator<<(Ostream& os, const xmlTag& tag)
+{
+    // Tag name
+    os << indent << '<' << tag.name_;
+    
+    // Attributes and text
+    for
+    (
+        HashTable<string>::const_iterator iter = tag.attributes_.cbegin();
+        iter != tag.attributes_.cend();
+        ++iter
+    )
+    {
+        os << token::SPACE << iter.key() << '=' << iter();
+    }
+    
+    if (tag.str().size() || tag.children_.size())
+    {
+        os << '>' << nl;
+                
+        // Children
+        os.incrIndent();
+        
+        forAll(tag.children_, i)
+        {
+            os << tag.children_[i];
+        }
+        
+        os.decrIndent();
+        
+        // Tag text
+        os << tag.str().c_str();
+        
+        // Close tag
+        os << indent << "</" << tag.name_ << '>' << endl;
+    }
+    else
+    {
+        // Empty element tag
+        os << "/>" << endl;
+    }
+    return os;
+}
+
+
+//- Append the supplied data to the tag text
+template<class T>
+xmlTag& operator<<(xmlTag& tag, const UList<T>& data)
+{
+    forAll(data, i)
+    {
+        tag << data[i] << token::SPACE;
+    }
+    
+    tag << nl;
+    
+    return tag;
+}
+
+//- Append the supplied data to the tag text
+template<class T>
+xmlTag& operator<<(xmlTag& tag, const LongList<T>& data)
+{
+    forAll(data, i)
+    {
+        tag << data[i] << token::SPACE;
+    }
+    
+    tag << nl;
+    
+    return tag;
+}
+
+
+//- Append the supplied data to the tag text
+template<class Form, class Cmpt, int nCmpt>
+xmlTag& operator<<(xmlTag& tag, const VectorSpace<Form, Cmpt, nCmpt>& data)
+{
+    forAll(data, i)
+    {
+        tag << data[i] << token::SPACE;
+    }
+    
+    tag << nl;
+    
+    return tag;
+}
+
+//- Append the supplied data to the tag text
+template<class T, unsigned Size>
+xmlTag& operator<<(xmlTag& tag, const FixedList<T, Size>& data)
+{
+    forAll(data, i)
+    {
+        tag << data[i] << token::SPACE;
+    }
+    
+    tag << nl;
+    
+    return tag;
+}
+
+//- Append the supplied data to the tag text
+xmlTag& operator<<(xmlTag& tag, const labelledTri& data)
+{
+    const triFace& tFace = data;
+    
+    return tag << tFace;
+}
+    
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/cfMesh/importSurfaceAsSubset/Make/files

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

applications/utilities/mesh/cfMesh/importSurfaceAsSubset/Make/options

@@ -0,0 +1,9 @@
+EXE_INC = \
+    -I$(FOAM_SRC)/mesh/cfMesh/meshLibrary/lnInclude \
+    -I$(LIB_SRC)/triSurface/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude
+
+EXE_LIBS = \
+    -ltriSurface \
+    -lmeshLibrary \
+    -lmeshTools

applications/utilities/mesh/cfMesh/importSurfaceAsSubset/importSurfaceAsSubset.C

@@ -0,0 +1,84 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | cfMesh: A library for mesh generation
+   \\    /   O peration     |
+    \\  /    A nd           | Author: Franjo Juretic (franjo.juretic@c-fields.com)
+     \\/     M anipulation  | Copyright (C) Creative Fields, Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of cfMesh.
+
+    cfMesh 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.
+
+    cfMesh 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 cfMesh.  If not, see <http://www.gnu.org/licenses/>.
+
+Description
+    Finds feature edges and corners of a triangulated surface
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "IFstream.H"
+#include "fileName.H"
+#include "triSurf.H"
+#include "OFstream.H"
+#include "OSspecific.H"
+#include "demandDrivenData.H"
+#include "triSurfaceImportSurfaceAsSubset.H"
+#include <cstdlib>
+#include <sstream>
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Main program:
+using namespace Foam;
+
+int main(int argc, char *argv[])
+{
+    argList::noParallel();
+    argList::validArgs.clear();
+    argList::validArgs.append("master surface file");
+    argList::validArgs.append("import surface file");
+
+    argList args(argc, argv);
+
+    fileName inFileName(args.args()[1]);
+    fileName importFileName(args.args()[2]);
+
+    triSurf originalSurface(inFileName);
+
+    triSurf importedSurface(importFileName);
+
+    triSurfaceImportSurfaceAsSubset importSurf(originalSurface);
+
+    importSurf.addSurfaceAsSubset(importedSurface, importFileName.lessExt());
+
+    if( inFileName.ext() == "fms" )
+    {
+        originalSurface.writeSurface(inFileName);
+    }
+    else
+    {
+        fileName newName = inFileName.lessExt();
+        newName.append(".fms");
+        Warning << "Writting surface as " << newName
+            << " to preserve the subset!!" << endl;
+
+        originalSurface.writeSurface(newName);
+    }
+
+    Info << "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/cfMesh/improveSymmetryPlanes/Make/files

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

applications/utilities/mesh/cfMesh/improveSymmetryPlanes/Make/options

@@ -0,0 +1,7 @@
+EXE_INC = \
+    -I$(FOAM_SRC)/mesh/cfMesh/meshLibrary/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude
+
+EXE_LIBS = \
+    -lmeshTools \
+    -lmeshLibrary

applications/utilities/mesh/cfMesh/improveSymmetryPlanes/improveSymmetryPlanes.C

@@ -0,0 +1,57 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | cfMesh: A library for mesh generation
+   \\    /   O peration     |
+    \\  /    A nd           | Author: Franjo Juretic (franjo.juretic@c-fields.com)
+     \\/     M anipulation  | Copyright (C) Creative Fields, Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of cfMesh.
+
+    cfMesh 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.
+
+    cfMesh 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 cfMesh.  If not, see <http://www.gnu.org/licenses/>.
+
+Description
+    Ensures that all mesh points belonging to a symmetryPlane are
+    in a plane.
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "Time.H"
+#include "polyMeshGenModifier.H"
+#include "symmetryPlaneOptimisation.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+#   include "setRootCase.H"
+#   include "createTime.H"
+
+    polyMeshGen pmg(runTime);
+    pmg.read();
+
+    Info << "Starting optimisation of symmetry planes" << endl;
+    symmetryPlaneOptimisation(pmg).optimizeSymmetryPlanes();
+
+    Info << "Writing mesh" << endl;
+    pmg.write();
+
+    Info << "End\n" << endl;
+    return 0;
+}
+
+// ************************************************************************* //

applications/utilities/mesh/cfMesh/mergeSurfacePatches/Make/files

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

applications/utilities/mesh/cfMesh/mergeSurfacePatches/Make/options

@@ -0,0 +1,9 @@
+EXE_INC = \
+    -I$(FOAM_SRC)/mesh/cfMesh/meshLibrary/lnInclude \
+    -I$(FOAM_SRC)/meshTools/lnInclude \
+    -I$(FOAM_SRC)/triSurface/lnInclude
+
+EXE_LIBS = \
+    -ltriSurface \
+    -lmeshLibrary \
+    -lmeshTools

applications/utilities/mesh/cfMesh/mergeSurfacePatches/mergeSurfacePatches.C

@@ -0,0 +1,403 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | cfMesh: A library for mesh generation
+   \\    /   O peration     |
+    \\  /    A nd           | Author: Franjo Juretic (franjo.juretic@c-fields.com)
+     \\/     M anipulation  | Copyright (C) Creative Fields, Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of cfMesh.
+
+    cfMesh 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.
+
+    cfMesh 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 cfMesh.  If not, see <http://www.gnu.org/licenses/>.
+
+Description
+    cfMesh utility to merge the supplied list of patches onto a single
+    patch.
+
+Author
+    Ivor Clifford <ivor.clifford@psi.ch>
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "autoPtr.H"
+#include "Time.H"
+#include "triSurf.H"
+#include "triSurfModifier.H"
+#include "demandDrivenData.H"
+#include "Pair.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Find the supplied list of patch names and return a list of patch Ids
+void getPatchIds
+(
+    const triSurf& origSurf,
+    const wordList& patchNames,
+    DynamicList<label>& patchIds
+)
+{
+    const geometricSurfacePatchList& origPatches = origSurf.patches();
+    
+    // Create patch name map
+    HashSet<word> patchNameHash(patchNames);
+        
+    // Find selected patches
+    label nFound = 0;
+    forAll(origPatches, patchI)
+    {
+        if (patchNameHash.found(origPatches[patchI].name()))
+        {
+            patchIds.append(patchI);
+            nFound++;
+        }
+    }
+    
+    if (nFound != patchNames.size())
+    {
+        WarningIn("getPatchIds")
+            << "Not all supplied patch names were found on the surface mesh" << endl;
+    }
+}
+
+
+// Copy all face subsets from one triSurf to another
+void copyFaceSubsets
+(
+    const triSurf& origSurf,
+    triSurf& newSurf
+)
+{
+    DynList<label> subsetIds;
+    origSurf.facetSubsetIndices(subsetIds);
+    
+    forAll(subsetIds, subsetI)
+    {
+        label newSubsetId = newSurf.addFacetSubset
+        (
+            origSurf.facetSubsetName(subsetI)
+        );
+        
+        labelList origFaces;        
+        origSurf.facetsInSubset(subsetI, origFaces);
+        
+        forAll(origFaces, faceI)
+        {
+            newSurf.addFacetToSubset
+            (
+                newSubsetId,
+                origFaces[faceI]
+            );
+        }
+    }
+}
+
+
+// Copy all edge subsets from one triSurf to another
+void copyEdgeSubsets
+(
+    const triSurf& origSurf,
+    triSurf& newSurf
+)
+{
+    DynList<label> subsetIds;
+    origSurf.edgeSubsetIndices(subsetIds);
+    
+    forAll(subsetIds, subsetI)
+    {
+        label newSubsetId = newSurf.addEdgeSubset
+        (
+            origSurf.edgeSubsetName(subsetI)
+        );
+        
+        labelList origEdges;        
+        origSurf.edgesInSubset(subsetI, origEdges);
+        
+        forAll(origEdges, faceI)
+        {
+            newSurf.addEdgeToSubset
+            (
+                newSubsetId,
+                origEdges[faceI]
+            );
+        }
+    }
+}
+
+
+// Copy all point subsets from one triSurf to another
+void copyPointSubsets
+(
+    const triSurf& origSurf,
+    triSurf& newSurf
+)
+{
+    DynList<label> subsetIds;
+    origSurf.pointSubsetIndices(subsetIds);
+    
+    forAll(subsetIds, subsetI)
+    {
+        label newSubsetId = newSurf.addPointSubset
+        (
+            origSurf.pointSubsetName(subsetI)
+        );
+        
+        labelList origPoints;        
+        origSurf.pointsInSubset(subsetI, origPoints);
+        
+        forAll(origPoints, faceI)
+        {
+            newSurf.addPointToSubset
+            (
+                newSubsetId,
+                origPoints[faceI]
+            );
+        }
+    }
+}
+
+
+// Merge the supplied list of patchIds onto a new patch
+autoPtr<triSurf> mergeSurfacePatches
+(
+    const triSurf& origSurf,        // Surface
+    const UList<label>& patchIds,   // Ids of patches to merge
+    const word& newPatchName,       // Name of new (merged) patch
+    bool keepPatches                // Keep the original patches - they will be emptied
+)
+{
+    const geometricSurfacePatchList& origPatches = origSurf.patches();
+    const LongList<labelledTri>& origFacets = origSurf.facets();
+    
+    label newPatchId = origPatches.size();
+    
+    // Determine new patch type
+    word newPatchType = origPatches[patchIds[0]].geometricType();
+    
+    // Create patch addressing
+    List<DynamicList<label> > patchAddr(origPatches.size()+1);
+    
+    forAll(origFacets, faceI)
+    {
+        patchAddr[origFacets[faceI].region()].append(faceI);
+    }
+    
+    // Move selected patches to new patch
+    forAll(patchIds, patchI)
+    {
+        patchAddr[newPatchId].append(patchAddr[patchIds[patchI]]);
+        patchAddr[patchIds[patchI]].clear();
+    }
+
+    // Create new facets list
+    LongList<labelledTri> newFacets(origFacets.size());
+    labelList newFaceAddr(origFacets.size(), -1);
+    
+    label patchCount = 0;
+    label faceI = 0;
+    forAll(patchAddr, patchI)
+    {
+        const unallocLabelList& addr = patchAddr[patchI];
+        
+        if(addr.size())
+        {
+            forAll(addr, i)
+            {
+                newFacets[faceI] = origFacets[addr[i]];
+                newFacets[faceI].region() = patchCount;
+                
+                newFaceAddr[addr[i]] = faceI;
+                
+                faceI++;
+            }
+        }
+        
+        if(addr.size() || keepPatches)
+        {
+            patchCount++;
+        }
+    }
+    
+    // Create new patch list
+    geometricSurfacePatchList newPatches(patchCount);
+    
+    patchCount = 0;
+    forAll(origPatches, patchI)
+    {
+        // Only add patches if they contain faces
+        if(patchAddr[patchI].size())
+        {
+            newPatches[patchCount] = origPatches[patchI];
+            newPatches[patchCount].index() = patchCount;
+        }
+        
+        if(patchAddr[patchI].size() || keepPatches)
+        {
+            patchCount++;
+        }
+    }
+        
+    // Add new patch if it contains faces
+    if(patchAddr[patchAddr.size()-1].size())
+    {
+        newPatches[patchCount] = geometricSurfacePatch
+        (
+            newPatchType,
+            newPatchName,
+            patchCount
+        );
+    }
+    if(patchAddr[patchAddr.size()-1].size() || keepPatches)
+    {
+        patchCount++;
+    }
+    
+    // Create new surface
+    autoPtr<triSurf> newSurf
+    (
+        new triSurf
+        (
+            newFacets,
+            newPatches,
+            origSurf.featureEdges(),
+            origSurf.points()
+        )
+    );
+    
+    // Transfer face subsets
+    copyFaceSubsets(origSurf, newSurf());
+    newSurf->updateFacetsSubsets(newFaceAddr);
+    
+    // Transfer feature edge subsets
+    copyEdgeSubsets(origSurf, newSurf());
+    
+    // Transfer point subsets
+    copyPointSubsets(origSurf, newSurf());
+    
+    // Done
+    return newSurf;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    argList::noParallel();
+    argList::validArgs.clear();
+
+    argList::validArgs.append("input surface file");
+    argList::validArgs.append("new patch");
+    argList::validOptions.insert("patchNames", "list of names");
+    argList::validOptions.insert("patchIds", "list of patchIds");
+    argList::validOptions.insert("patchIdRange", "( start end )");
+    argList::validOptions.insert("output", "file name (default overwrite)");
+    argList::validOptions.insert("keep", "");
+    argList args(argc, argv);
+
+    // Process commandline arguments
+    fileName inFileName(args.args()[1]);
+    
+    word newPatchName(args.args()[2]);
+
+    fileName outFileName(inFileName);
+    
+    if( args.options().found("output") )
+    {
+        outFileName = args.options()["output"];
+    }
+
+    bool keepPatches = false;
+    
+    if( args.options().found("keep") )
+    {
+        keepPatches = true;
+    }
+
+    // Read original surface
+    triSurf origSurf(inFileName);
+    
+    // Get patch ids
+    DynamicList<label> patchIds;
+    
+    if (args.options().found("patchNames"))
+    {
+        if (args.options().found("patchIds"))
+        {
+            FatalError() << "Cannot specify both patch names and ids"
+                << Foam::abort(FatalError);
+        }
+        
+        IStringStream is(args.options()["patchNames"]);
+        wordList patchNames(is);
+        
+        getPatchIds
+        (
+            origSurf,
+            patchNames,
+            patchIds
+        );
+    }
+    if (args.options().found("patchIds"))
+    {
+        IStringStream is(args.options()["patchIds"]);
+        
+        patchIds = labelList(is);
+    }
+    if (args.options().found("patchIds"))
+    {
+        IStringStream is(args.options()["patchIds"]);
+        
+        patchIds.append(labelList(is));
+    }
+    if (args.options().found("patchIdRange"))
+    {
+        IStringStream is(args.options()["patchIdRange"]);
+        
+        Pair<label> idRange(is);
+        
+        for(label id = idRange.first(); id <= idRange.second(); id++)
+        {
+            patchIds.append(id);
+        }
+    }    
+    if (!patchIds.size())
+    {
+        FatalError() << "No patches specified"
+            << Foam::abort(FatalError);
+    }
+    
+    // Merge patches
+    autoPtr<triSurf> newSurf = mergeSurfacePatches
+    (
+        origSurf,
+        patchIds,
+        newPatchName,
+        keepPatches
+    );
+    
+    // Write new surface mesh
+    newSurf->writeSurface(outFileName);
+    
+    Info << "Original surface patches: " << origSurf.patches().size() << endl;
+    Info << "Final surface patches: " << newSurf->patches().size() << endl;
+    Info << "Surface written to " << outFileName <<  endl;
+    
+    Info << "End\n" << endl;
+    
+    return 0;
+}
+
+// ************************************************************************* //

applications/utilities/mesh/cfMesh/python/Salome/extractFeatureEdges.py

@@ -0,0 +1,131 @@
+#!python
+# =============================================================================
+# Salome GEOM script to extract the feature edges from a body and add them
+# to the group named 'featureEdges'.
+# Tested on Salome 7.4.0 and python 2.7 on 64-bit Windows
+#
+# Author: Ivor Clifford <ivor.clifford@psi.ch>
+#
+# =============================================================================
+
+def extractFeatureEdges(body, minFeatureAngle = 5):
+    '''
+    Find all feature edges on the supplied body and return them as a list
+    of edge ids.
+
+        body - A Salome solid, compound, shell or face object to find all
+                feature edges on.
+        minFeatureAngle - the angle (in degrees) between adjacent surfaces
+                above which the edge will be considered a feature angle.
+    '''
+    import salome
+    salome.salome_init()
+
+    import GEOM
+    from salome.geom import geomBuilder
+    geompy = geomBuilder.New(salome.myStudy)
+    
+    # Check the body type
+    if not (body.GetShapeType() in [GEOM.SHELL, GEOM.SOLID, GEOM.FACE, GEOM.COMPOUND]):
+       raise RuntimeError('Supplied object is not a solid, shell or face.')
+    
+    print 'Extracting edges of %s with feature angle > %g.' % (body.GetName(), minFeatureAngle)
+    
+    # Extract basic info
+    faces = geompy.SubShapeAll(body, geompy.ShapeType["FACE"])
+    curves = geompy.SubShapeAll(body, geompy.ShapeType["EDGE"])
+    points = geompy.SubShapeAll(body, geompy.ShapeType["VERTEX"])
+    
+    faceIds = geompy.GetSubShapesIDs(body, faces)
+    curveIds = geompy.GetSubShapesIDs(body, curves)
+    nodeIds = geompy.GetSubShapesIDs(body, points)
+    
+    maxFaceId = max(faceIds)
+    maxCurveId = max(curveIds)
+    maxNodeId = max(nodeIds)
+    
+    # Reverse mapping from curve id to local curve arrays
+    faceMap = [-1 for i in xrange(maxFaceId+1)]
+    for localId, id in enumerate(faceIds):
+        faceMap[id] = localId
+    
+    curveMap = [-1 for i in xrange(maxCurveId+1)]
+    for localId, id in enumerate(curveIds):
+        curveMap[id] = localId
+    
+    nodeMap = [-1 for i in xrange(maxNodeId+1)]
+    for localId, id in enumerate(nodeIds):
+        nodeMap[id] = localId
+    
+    
+    # Get curves on each face
+    faceCurveIds = [[curveMap[id] for id in geompy.GetSubShapesIDs(
+            body,
+            geompy.SubShapeAll(face, geompy.ShapeType["EDGE"])
+        )] for face in faces]
+    
+    # Get faces attached to each curve
+    curveFaceIds = [[] for id in curveIds]
+    
+    for faceI, ids in enumerate(faceCurveIds):
+        for id in ids:
+            curveFaceIds[id].append(faceI)
+    
+    # Now that we have the connectivity for curves and faces find the
+    # feature edges
+    featureEdgeIds = []
+    for curveId, curve, adjFaceIds in zip(curveIds, curves, curveFaceIds):
+        if len(adjFaceIds) == 2:
+            # Curve with 2 adjacent faces - Test feature angle
+            # Determine break angle at each curve
+            # If greater than the feature edge angle, add the curve to group featureEdges
+            face1 = faces[adjFaceIds[0]]
+            face2 = faces[adjFaceIds[1]]
+            point = geompy.GetFirstVertex(curve)    # Test at the first vertex
+            n1 = geompy.GetNormal(face1, point)
+            n2 = geompy.GetNormal(face2, point)
+            angle = geompy.GetAngle(n1, n2)
+            if angle > minFeatureAngle:
+                featureEdgeIds.append(curveId)
+        
+        elif len(adjFaceIds) == 1:
+            # Curve on standalone face - Add by default
+            featureEdgeIds.append(curveId)
+        
+        elif len(adjFaceIds) == 0:
+            # Standalone curve - Ignore
+            None
+        
+        else:
+            raise RuntimeError('Curve found sharing %d faces. This is unexpected for fully enclosed bodies.' % len(adjFaceIds))
+    
+    # Done
+    print "%d feature edges found" % len(featureEdgeIds)
+    
+    return featureEdgeIds
+
+
+# If run as a standalone script, use the current Salome GUI selection
+# and add the feature edges to group named 'featureEdges'
+if __name__ == '__main__':
+    import salome
+    salome.salome_init()
+    
+    import GEOM
+    from salome.geom import geomBuilder
+    geompy = geomBuilder.New(salome.myStudy)
+    
+    # Get current GUI selection
+    selected = salome.sg.getAllSelected()
+    if len(selected) != 1:
+        raise RuntimeError('A single solid, shell or face object must be selected.')
+    
+    body = salome.myStudy.FindObjectID(selected[0]).GetObject()
+    
+    # Get feature edges and add to the group 'featureEdges'
+    featureEdges = geompy.CreateGroup(body, geompy.ShapeType["EDGE"])
+    geompy.UnionIDs(featureEdges, extractFeatureEdges(body))
+    geompy.addToStudyInFather(body, featureEdges, 'featureEdges')
+    
+    if salome.sg.hasDesktop():
+        salome.sg.updateObjBrowser(1)

applications/utilities/mesh/cfMesh/python/Salome/salomeTriSurf.py

@@ -0,0 +1,363 @@
+#!python
+# =============================================================================
+# Python module for writing OpenFOAM feature edge and triSurface files from
+# within Salome platform.
+# Tested on Salome 7.4.0 and python 2.7 on 64-bit Windows
+#
+# Author: Ivor Clifford <ivor.clifford@psi.ch>
+#
+# =============================================================================
+
+def foamHeader(className, objectName):
+    '''
+    Return the OpenFOAM file header block as a string.
+    '''
+    return '''/*--------------------------------*- C++ -*----------------------------------*\\
+| =========                 |                                                 |
+| \\\\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\\\    /   O peration     | Version:  2.2.1                                 |
+|   \\\\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\\\/     M anipulation  |                                                 |
+\\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       %s;
+    object      %s;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+''' % (className, objectName)
+
+
+class triSurf:
+    def __init__(self, object = None, allEdges = False):
+        '''
+        Construct from the supplied Salome mesh.
+
+            object - the mesh object (must be a triangular surface mesh). If no
+                    object is supplied, the current Salome selection is used.
+            allEdges - If true, all edges on the mesh are included as feature
+                    edges, otherwise only edges contained in groups are included
+
+        NOTE: All face groups are assumed to represent patches. No face subsets
+        are written. All edge groups are added as feature edge subsets. All point
+        groups are added as point subsets.
+        '''
+        # =============================================================================
+        # Initialize salome
+        import salome
+        import SMESH, SALOMEDS
+        from salome.smesh import smeshBuilder
+        from operator import itemgetter
+        from collections import OrderedDict
+        
+        import SMESH, SALOMEDS
+        
+        # =============================================================================
+        # Get the Salome mesh object
+        if object is None:
+            selected = salome.sg.getAllSelected()
+            if len(selected) != 1:
+                raise RuntimeError('A single Salome mesh object must be selected.')
+            
+            object = salome.myStudy.FindObjectID(selected[0]).GetObject()
+        
+        try:
+            object.GetMesh()
+        except:
+            raise RuntimeError('Supplied object is not a Salome SMESH mesh.')
+        
+        smesh = smeshBuilder.New(salome.myStudy)
+        mesh = smesh.Mesh(object)
+        
+        print "Converting SMESH Mesh '%s'" % mesh.GetName()
+        
+        # =============================================================================
+        # Get basic mesh info
+        nNodes = mesh.NbNodes()
+        nFaces = mesh.NbFaces()
+        nTris = mesh.NbTriangles()
+        nEdges = mesh.NbEdges()
+        nodeIds = mesh.GetNodesId()
+        faceIds = mesh.GetElementsByType(SMESH.FACE)
+        edgeIds = mesh.GetElementsByType(SMESH.EDGE)
+        
+        # Check that mesh is strictly triangular
+        if nFaces != nTris:
+            raise RuntimeError('Mesh is not strictly triangular')
+        
+        # Get patch and subset names & ids
+        # All SMESH.FACE groups are assumed to be patches
+        # All SMESH.EDGE groups are assumed to be feature subsets
+        # All SMESH.NODE groups are assumed to be point subsets
+        patches = OrderedDict()
+        pointSubsets = OrderedDict()
+        featureEdgeSubsets = OrderedDict()
+        
+        for group in mesh.GetGroups():
+            if group.GetType() == SMESH.FACE:
+                patches[group.GetName()] = group.GetIDs()
+            elif group.GetType() == SMESH.EDGE:
+                featureEdgeSubsets[group.GetName()] = group.GetIDs()
+            elif group.GetType() == SMESH.NODE:
+                pointSubsets[group.GetName()] = group.GetIDs()
+        
+        # =============================================================================
+        # Process faces and patches
+        # Get patchId for each face
+        lastPatchId = len(patches)
+        patchIds = [lastPatchId] * max(faceIds)
+        patchId = 0
+        for name, ids in patches.iteritems():
+            for faceId in ids:
+                if patchIds[faceId-1] == lastPatchId:
+                    patchIds[faceId-1] = patchId
+                else:
+                    print "Face %d is assigned to both groups %s and %s" % (faceId, name, patches.keys()[patchIds[faceId-1]])
+                    raise RuntimeError('Groups of faces are not unique, i.e. they overlap.')
+                
+            patchId += 1
+        
+        # Compact and reorder patchIds to match faceIds
+        patchIds = [patchIds[faceId-1] for faceId in faceIds]
+        
+        # Reorder faces by increasing group id
+        faceAndpatchIds = sorted(zip(faceIds, patchIds), key=itemgetter(1))
+        faceIds, patchIds = zip(*faceAndpatchIds)
+        
+        # Add unused faces to the default patch
+        defaultFaces = [faceId for faceId, patchId in faceAndpatchIds if patchId == lastPatchId]
+        if len(defaultFaces) > 0:
+            patches['defaultFaces'] = defaultFaces
+        
+        defaultFaces = None
+        
+        # =============================================================================
+        # Process feature edges
+        if not allEdges:
+            edgeIds = []
+            for name, ids in featureEdgeSubsets.iteritems():
+                edgeIds += ids
+            
+            edgeIds = list(set(edgeIds))
+            nEdges = len(edgeIds)
+        
+        # Reverse mapping of edge ids since they aren't necessarily numbered 1..nEdges
+        if len(edgeIds):
+            edgeMap = [-1] * max(edgeIds)
+        else:
+            edgeMap = []
+        
+        i=0
+        for edgeId in edgeIds:
+            edgeMap[edgeId-1] = i
+            i += 1
+        
+        # =============================================================================
+        # Process nodes
+        # Reverse mapping of node ids since nodes aren't necessarily numbered 1..nNodes
+        nodeMap = [-1] * max(nodeIds)
+        i=0
+        for nodeId in nodeIds:
+            nodeMap[nodeId-1] = i
+            i += 1
+        
+        # =============================================================================
+
+        self._mesh = mesh
+        
+        self._nodeIds = nodeIds
+        self._edgeIds = edgeIds
+        self._faceIds = faceIds
+        
+        self._nodeMap = nodeMap
+        self._edgeMap = edgeMap
+        self._faceMap = []
+        
+        self._patches = patches
+        self._pointSubsets = pointSubsets
+        self._featureEdgeSubsets = featureEdgeSubsets
+        self._faceSubsets = {}
+        
+        print 'Done'
+    
+    def nNodes(self):
+        '''
+        Return the number of nodes
+        '''
+        return len(self._nodeIds)
+    
+    def nEdges(self):
+        '''
+        Return the number of edges
+        '''
+        return len(self._edgeIds)
+    
+    def nFacets(self):
+        '''
+        Return the number of triangular facets
+        '''
+        return len(self._faceIds)
+    
+    def nPatches(self):
+        '''
+        Return the number of patches
+        '''
+        return len(self._patches)
+    
+    def _writePatchDefs(self, f, typeName = 'wall'):
+        '''
+        Write the patch definitions to file as an OpenFOAM geometricSurfacePatchList.
+        NOTE: All patches are assumed to be walls.
+        '''
+        patches = self._patches
+        
+        f.write('%d\n(\n' % len(patches))
+        for name in patches.iterkeys():
+            f.write('%s\t%s\n' % (name, typeName))
+        
+        f.write(')\n')
+    
+    def _writeNodes(self, f):
+        '''
+        Write the nodes to file as an OpenFOAM pointField.
+        '''
+        mesh = self._mesh
+        nodeIds = self._nodeIds
+        
+        f.write('%d\n(\n' % len(nodeIds))
+        
+        for x, y, z in [mesh.GetNodeXYZ(nodeId) for nodeId in nodeIds]:
+            f.write( '( %g %g %g )\n' % (x, y, z))
+        
+        f.write(')\n')
+    
+    def _writeFeatureEdges(self, f):
+        '''
+        Write the feature edges to file as an OpenFOAM edgeList.
+        '''
+        mesh = self._mesh
+        nodeMap = self._nodeMap
+        edgeIds = self._edgeIds
+        
+        f.write('%d\n(\n' % len(edgeIds))
+        
+        for edgeId in edgeIds:
+            nodes = mesh.GetElemNodes(edgeId)
+            f.write( '(' + ' '.join([str(nodeMap[nodeId-1]) for nodeId in nodes]) + ')\n')
+        
+        f.write(')\n')
+    
+    def _writeFacets(self, f):
+        '''
+        Write the facets to file as an OpenFOAM List of labelledTri.
+        '''
+        from itertools import chain
+        
+        mesh = self._mesh
+        nodeMap = self._nodeMap
+        patches = self._patches
+        
+        f.write('%d\n(\n' % sum([len(patch) for patch in patches.itervalues()]))
+        
+        patchId = 0
+        for patchId, (patchName, faceIds) in enumerate(patches.iteritems()):
+            for faceId in faceIds:
+                nodes = mesh.GetElemNodes(faceId)
+                f.write( '((' + ' '.join([str(nodeMap[nodeId-1]) for nodeId in nodes]) + ') %d)\n' % patchId)
+        
+        f.write(')\n')
+    
+    def _writeSubsets(self, f, subsets, map, typeId):
+        '''
+        General function to write a subset to file as an OpenFOAM Map<meshSubset>.
+        '''
+        f.write('%d\n(\n' % len(subsets))
+        for name, ids in subsets.iteritems():
+            f.write('%s %s %d ( %s )\n' % (name, typeId, len(ids), ' '.join([str(map[id-1]) for id in ids])))
+        
+        f.write(')\n')
+    
+    def _writePointSubsets(self, f):
+        '''
+        Write the point subsets to file as and OpenFOAM Map<meshSubset>.
+        '''
+        self._writeSubsets(f, self._pointSubsets, self._nodeMap, '2')
+    
+    def _writeFaceSubsets(self, f):
+        '''
+        Write the face subsets to file as and OpenFOAM Map<meshSubset>.
+        '''
+        self._writeSubsets(f, self._faceSubsets, self._faceMap, '4')
+        
+    def _writeFeatureEdgeSubsets(self, f):
+        '''
+        Write the feature edge subsets to file as and OpenFOAM Map<meshSubset>.
+        '''
+        self._writeSubsets(f, self._featureEdgeSubsets, self._edgeMap, '8')
+    
+    def writeEdgeMesh(self, fileName):
+        '''
+        Write to file as an OpenFOAM edgeMesh
+        
+            fileName - The file name to write
+        '''
+        # Create file
+        f = open(fileName, 'wb') # NOTE: file opened as binary to ensure unix-style line breaks
+        
+        # Write header
+        f.write(foamHeader('edgeMesh', self._mesh.GetName()))
+        
+        self._writeNodes(f)
+        self._writeFeatureEdges(f)
+        
+        f.close()
+        
+        print 'edgeMesh written to %s' % fileName
+    
+    def writeFtr(self, fileName):
+        '''
+        Write to file as an OpenFOAM cfMesh FTR file
+        
+            fileName - the file name to write
+        '''
+        # Create file
+        f = open(fileName, 'wb') # NOTE: file opened as binary to ensure unix-style line breaks
+        
+        self._writePatchDefs(f)
+        self._writeNodes(f)
+        self._writeFacets(f)
+        
+        f.close()
+        
+        print 'triSurf written to %s' % fileName
+        
+    def writeFms(self, fileName):
+        '''
+        Write to file as an OpenFOAM cfMesh FMS file
+        
+            fileName - the file name to write
+        '''
+        # Create file
+        f = open(fileName, 'wb') # NOTE: file opened as binary to ensure unix-style line breaks
+        
+        self._writePatchDefs(f)
+        self._writeNodes(f)
+        self._writeFacets(f)
+        self._writeFeatureEdges(f)
+        self._writePointSubsets(f)
+        self._writeFaceSubsets(f)
+        self._writeFeatureEdgeSubsets(f)
+        
+        f.close()
+        
+        print 'triSurf written to %s' % fileName
+
+
+if __name__ == '__main__':
+    import salome
+    salome.salome_init()
+    
+    import SMESH, SALOMEDS

applications/utilities/mesh/cfMesh/surfaceToFMS/Make/files

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

applications/utilities/mesh/cfMesh/surfaceToFMS/Make/options

@@ -0,0 +1,9 @@
+EXE_INC = \
+    -I$(FOAM_SRC)/mesh/cfMesh/meshLibrary/lnInclude \
+    -I$(LIB_SRC)/triSurface/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude
+
+EXE_LIBS = \
+    -ltriSurface \
+    -lmeshLibrary \
+    -lmeshTools

applications/utilities/mesh/cfMesh/surfaceToFMS/surfaceToFMS.C

@@ -0,0 +1,63 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | cfMesh: A library for mesh generation
+   \\    /   O peration     |
+    \\  /    A nd           | Author: Franjo Juretic (franjo.juretic@c-fields.com)
+     \\/     M anipulation  | Copyright (C) Creative Fields, Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of cfMesh.
+
+    cfMesh 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.
+
+    cfMesh 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 cfMesh.  If not, see <http://www.gnu.org/licenses/>.
+
+Description
+    Reads the specified surface and writes it in the fms format. 
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "IFstream.H"
+#include "fileName.H"
+#include "triSurf.H"
+#include "demandDrivenData.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Main program:
+using namespace Foam;
+
+int main(int argc, char *argv[])
+{
+    argList::noParallel();
+    argList::validArgs.clear();
+    argList::validArgs.append("input surface file");
+    argList args(argc, argv);
+
+    const fileName inFileName(args.args()[1]);
+    if( inFileName.ext() == "fms" )
+        FatalError << "trying to convert a fms file to itself"
+            << exit(FatalError);
+
+    fileName outFileName(inFileName.lessExt()+".fms");
+
+    const triSurf surface(inFileName);
+
+    surface.writeSurface(outFileName);
+
+    Info << "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/utilities/miscellaneous/foamDebugSwitches/Make/files

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

applications/utilities/miscellaneous/foamDebugSwitches/Make/options

@@ -1,46 +0,0 @@
-EXE_LIBS = \
-    -lbasicThermophysicalModels \
-    -lchemistryModel \
-    -lreactionThermophysicalModels \
-    -lcompressibleLESModels \
-    -ldecompositionMethods \
-    -ldieselSpray \
-    -ldynamicFvMesh \
-    -ldynamicMesh \
-    -ledgeMesh \
-    -lengine \
-    -lerrorEstimation \
-    -lfiniteVolume \
-    -lfiniteArea \
-    -lfoam \
-    -ltetFiniteElement \
-    -ltetMotionSolver \
-    -lforces \
-    -lfvMotionSolver \
-    -lincompressibleLESModels \
-    -lincompressibleTransportModels \
-    -lcompressibleRASModels \
-    -lincompressibleRASModels \
-    -linterfaceProperties \
-    -llagrangianIntermediate \
-    -llagrangian \
-    -llaminarFlameSpeedModels \
-    -lLESdeltas \
-    -lLESfilters \
-    -lliquidMixture \
-    -lliquids \
-    -lmeshTools \
-    -lODE \
-    -lpdf \
-    -lphaseModel \
-    -lradiation \
-    -lrandomProcesses \
-    -lsampling \
-    -lsolidMixture \
-    -lsolids \
-    -lspecie \
-    -lthermophysicalFunctions \
-    -ltopoChangerFvMesh \
-    -ltriSurface \
-    -lautoMesh \
-    -L$(MESQUITE_LIB_DIR) -lmesquite

applications/utilities/miscellaneous/foamDebugSwitches/foamDebugSwitches.C

@@ -1,152 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | foam-extend: Open Source CFD
-   \\    /   O peration     |
-    \\  /    A nd           | For copyright notice see file Copyright
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of foam-extend.
-
-    foam-extend 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.
-
-    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Write out all library debug switches
-
-\*---------------------------------------------------------------------------*/
-
-#include "argList.H"
-#include "dictionary.H"
-#include "IFstream.H"
-#include "IOobject.H"
-#include "HashSet.H"
-
-using namespace Foam;
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-// Main program:
-
-int main(int argc, char *argv[])
-{
-    argList::noParallel();
-    argList::validOptions.insert("new", "");
-    argList::validOptions.insert("old", "");
-
-    Foam::argList args(argc, argv);
-
-    wordList currDebug(debug::debugSwitches().toc());
-    wordList currInfo(debug::infoSwitches().toc());
-    wordList currOpt(debug::optimisationSwitches().toc());
-
-    if (args.optionFound("old") || args.optionFound("new"))
-    {
-        dictionary controlDict(IFstream(findEtcFile("controlDict", true))());
-
-        wordHashSet oldDebug
-        (
-            controlDict.subDict("DebugSwitches").toc()
-        );
-
-        wordHashSet oldInfo
-        (
-            controlDict.subDict("InfoSwitches").toc()
-        );
-
-        wordHashSet oldOpt
-        (
-            controlDict.subDict("OptimisationSwitches").toc()
-        );
-
-
-        wordHashSet hashset;
-        wordList listing;
-
-
-        // list old switches - but this can't work since the (old) inserted
-        // switches are in both sets
-        // Workaround:
-        //  1. run without any options (get complete list)
-        //  2. comment out DebugSwitches, run again with -new to find new ones
-        //     and do a diff
-        if (args.optionFound("old"))
-        {
-            IOobject::writeDivider(Info);
-
-            hashset = wordHashSet(oldDebug);
-            hashset -= wordHashSet(currDebug);
-            listing = hashset.toc();
-            sort(listing);
-            Info<< "old DebugSwitches: " << listing << endl;
-
-            hashset = wordHashSet(oldInfo);
-            hashset -= wordHashSet(currInfo);
-            listing = hashset.toc();
-            sort(listing);
-            Info<< "old InfoSwitches: " << listing << endl;
-
-            hashset = wordHashSet(oldOpt);
-            hashset -= wordHashSet(currOpt);
-            listing = hashset.toc();
-            sort(listing);
-            Info<< "old OptimisationSwitches: " << listing << endl;
-        }
-
-        // list new switches
-        if (args.optionFound("new"))
-        {
-            IOobject::writeDivider(Info);
-
-            hashset = wordHashSet(currDebug);
-            hashset -= wordHashSet(oldDebug);
-
-            listing = hashset.toc();
-            sort(listing);
-            Info<< "new DebugSwitches: " << listing << endl;
-
-            hashset = wordHashSet(currInfo);
-            hashset -= wordHashSet(oldInfo);
-            listing = hashset.toc();
-            sort(listing);
-            Info<< "new InfoSwitches: " << listing << endl;
-
-            hashset = wordHashSet(currOpt);
-            hashset -= wordHashSet(oldOpt);
-            listing = hashset.toc();
-            sort(listing);
-            Info<< "new OptimisationSwitches: " << listing << endl;
-        }
-    }
-    else
-    {
-        IOobject::writeDivider(Info);
-
-        sort(currDebug);
-        Info<< "DebugSwitches: " << currDebug << endl;
-
-        sort(currInfo);
-        Info<< "InfoSwitches: " << currInfo << endl;
-
-        sort(currOpt);
-        Info<< "OptimisationSwitches: " << currOpt << endl;
-    }
-
-
-
-    Info<< "done" << endl;
-
-    return 0;
-}
-
-
-// ************************************************************************* //

etc/controlDict-EXAMPLE

@@ -943,7 +943,7 @@ Tolerances
     slidingEdgeEndCutoffTol         0.0001;
     slidingEdgeCoPlanarTol          0.8;
 
-//     GGIAreaErrorTol                 1e-8;
+     GGIAreaErrorTol                 1e-8;
 }
 
 DimensionedConstants
@@ -960,7 +960,7 @@ DimensionedConstants
     Tstd        298.15;
 
     //- Stefan-Boltzmann constant [J/(K4 m2 s)]
-    sigmaSB     sigmaSB [1 0 -3 -4 0 0 0] 5.670e-08;
+    sigmaSB     5.670e-08;
 
     /* USCS units
 

src/Pstream/gamma/Pstream.C

@@ -320,7 +320,7 @@ bool Pstream::init(int& argc, char**& argv)
 
     Info<< "GAMMA Pstream initialized with:" << nl
         << "    floatTransfer         : " << floatTransfer << nl
-        << "    nProcsSimpleSum       : " << nProcsSimpleSum << nl
+        << "    nProcsSimpleSum       : " << nProcsSimpleSum() << nl
         << "    scheduledTransfer     : " << Pstream::scheduledTransfer << nl
         << Foam::endl;
 

src/Pstream/mpi/Pstream.C

@@ -156,7 +156,7 @@ void Foam::reduce(scalar& Value, const sumOp<scalar>& bop)
         return;
     }
 
-    if (Pstream::nProcs() <= Pstream::nProcsSimpleSum)
+    if (Pstream::nProcs() <= Pstream::nProcsSimpleSum())
     {
         if (Pstream::master())
         {

src/coupledMatrix/coupledLduMatrix/coupledLduMatrix.C

@@ -30,10 +30,9 @@ Description
 Author
     Hrvoje Jasak, Wikki Ltd.  All rights reserved
 
-\*---------------------------------------------------------------------------*/
+\*----------------------------------------------------------------------------*/
 
 #include "coupledLduMatrix.H"
-#include "processorLduInterfaceField.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -43,6 +42,9 @@ namespace Foam
 }
 
 
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 // Construct given size
@@ -288,7 +290,7 @@ void Foam::coupledLduMatrix::initMatrixInterfaces
                             matrices[rowI],
                             coupleCoeffs[rowI][interfaceI],
                             cmpt,
-                            Pstream::defaultCommsType,
+                            static_cast<const Pstream::commsTypes>(Pstream::defaultCommsType()),
                             false
                         );
                     }
@@ -324,4 +326,13 @@ void Foam::coupledLduMatrix::updateMatrixInterfaces
 }
 
 
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+
 // ************************************************************************* //

src/dbns/multigrid/mgMeshLevel/mgMeshLevel.C

@@ -42,14 +42,16 @@ extern "C"
 defineTypeNameAndDebug(Foam::mgMeshLevel, 0);
 
 
-Foam::label Foam::mgMeshLevel::mgMinClusterSize_
+const Foam::debug::optimisationSwitch Foam::mgMeshLevel::mgMinClusterSize_
 (
-    debug::optimisationSwitch("mgMinClusterSize", 2)
+    "mgMinClusterSize",
+    2
 );
 
-Foam::label Foam::mgMeshLevel::mgMaxClusterSize_
+const Foam::debug::optimisationSwitch Foam::mgMeshLevel::mgMaxClusterSize_
 (
-    debug::optimisationSwitch("mgMaxClusterSize", 8)
+    "mgMaxClusterSize",
+    8
 );
 
 
@@ -173,8 +175,8 @@ void Foam::mgMeshLevel::makeChild() const
         const_cast<scalar*>(boundaryAreas.begin()),
         cellCells.begin(),
         faceWeights.begin(),
-        mgMinClusterSize_,
+        mgMinClusterSize_(),
-        mgMaxClusterSize_,
+        mgMaxClusterSize_(),
         options.begin(),
         &nMoves,
         &nCoarseCells,

src/dbns/multigrid/mgMeshLevel/mgMeshLevel.H

@@ -90,10 +90,10 @@ public:
         // Coarsening parameters
 
             //- Minimum cluster size
-            static label mgMinClusterSize_;
+            static const Foam::debug::optimisationSwitch mgMinClusterSize_;
 
             //- Maximum cluster size
-            static label mgMaxClusterSize_;
+            static const Foam::debug::optimisationSwitch mgMaxClusterSize_;
 
 
     // Constructor

src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/dynamicTopoFvMeshCoupled.C

@@ -67,7 +67,11 @@ defineTypeNameAndDebug(coupleMap, 0);
 
 //! \cond fileScope
 // Geometric relative match tolerance
-static scalar geomMatchTol_ = 1e-4;
+static const Foam::debug::tolerancesSwitch geomMatchTol_
+(
+    "geomMatchTol",
+    1e-4
+);
 
 // Priority scheme enumerants
 enum priorityScheme
@@ -1789,7 +1793,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                             {
                                 scalar dist = mag(fC - pts[ptI]);
 
-                                if (dist < (geomMatchTol_ * tol))
+                                if (dist < (geomMatchTol_() * tol))
                                 {
                                     // Face was converted before
                                     if (debug > 3)
@@ -1938,7 +1942,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
     // Specify a merge tolerance for insertion points
     scalar mergeTol =
     (
-        is2D() ? 0.0 : geomMatchTol_ * magSqr(edges_[mIndex].vec(points_))
+        is2D() ? 0.0 : geomMatchTol_() * magSqr(edges_[mIndex].vec(points_))
     );
 
     // Check for point / edge processor connections
@@ -3228,7 +3232,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                 scalar tol = mag(mesh.points_[fCheck[0]] - fC);
                 scalar dist = mag(fC - newCentre);
 
-                if (dist < (geomMatchTol_ * tol))
+                if (dist < (geomMatchTol_() * tol))
                 {
                     replaceFace = faceI;
                     break;
@@ -5270,7 +5274,7 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
                                 scalar tol = mag(points_[fCheck[0]] - fC);
                                 scalar dist = mag(fC - newCentre);
 
-                                if (dist < (geomMatchTol_ * tol))
+                                if (dist < (1e-4 * tol))
                                 {
                                     localIndex = faceI;
                                     break;
@@ -5320,7 +5324,7 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
                         scalar dist = mag(fC - newCentre);
 
                         // Ensure a face-match
-                        if (dist > (geomMatchTol_ * tol))
+                        if (dist > (geomMatchTol_() * tol))
                         {
                             Pout<< " * * * Sync Operations * * * " << nl
                                 << " Convert patch Op failed." << nl
@@ -5330,7 +5334,7 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
                                 << " faceCentre: " << fC << nl
                                 << " Master processor: " << proc << nl
                                 << " procPatch: " << procPatch << nl
-                                << " tolerance: " << (geomMatchTol_ * tol) << nl
+                                << " tolerance: " << (geomMatchTol_() * tol) << nl
                                 << " distance: " << dist << nl
                                 << " pointCounter: " << pointCounter << nl
                                 << " newCentre: " << newCentre << nl
@@ -5695,7 +5699,7 @@ bool dynamicTopoFvMesh::checkCoupledBoundaries(bool report) const
                     scalar rMagSf = mag(half1Areas[faceI]);
                     scalar avSf = 0.5 * (fMagSf + rMagSf);
 
-                    if (mag(fMagSf - rMagSf)/avSf > geomMatchTol_)
+                    if (mag(fMagSf - rMagSf)/avSf > geomMatchTol_())
                     {
                         misMatchError = true;
 
@@ -5713,7 +5717,7 @@ bool dynamicTopoFvMesh::checkCoupledBoundaries(bool report) const
                         Foam::max
                         (
                             pTol,
-                            geomMatchTol_ * mag(lP[lF[faceI][0]] - lC[faceI])
+                            geomMatchTol_() * mag(lP[lF[faceI][0]] - lC[faceI])
                         )
                     );
                 }
@@ -5859,7 +5863,7 @@ bool dynamicTopoFvMesh::checkCoupledBoundaries(bool report) const
             scalar nbrMagSf = mag(fAreas[pI][faceI]);
             scalar avSf = 0.5 * (magSf + nbrMagSf);
 
-            if (mag(magSf - nbrMagSf)/avSf > geomMatchTol_)
+            if (mag(magSf - nbrMagSf)/avSf > geomMatchTol_())
             {
                 misMatchError = true;
 
@@ -5878,7 +5882,7 @@ bool dynamicTopoFvMesh::checkCoupledBoundaries(bool report) const
                 Foam::max
                 (
                     pTol,
-                    geomMatchTol_ *
+                    geomMatchTol_() *
                     mag
                     (
                         myPoints[myFaces[faceI][0]]
@@ -6739,7 +6743,7 @@ void dynamicTopoFvMesh::buildLocalCoupledMaps()
     const boundBox& box = polyMesh::bounds();
 
     // Compute tolerance
-    scalar tol = geomMatchTol_ * box.mag();
+    scalar tol = geomMatchTol_()*box.mag();
 
     const polyBoundaryMesh& boundary = boundaryMesh();
 
@@ -6801,7 +6805,7 @@ void dynamicTopoFvMesh::buildLocalCoupledMaps()
                 FatalErrorIn("void dynamicTopoFvMesh::buildLocalCoupledMaps()")
                     << " Failed to match all points"
                     << " within a tolerance of: " << tol << nl
-                    << " matchTol: " << geomMatchTol_ << nl
+                    << " matchTol: " << geomMatchTol_() << nl
                     << abort(FatalError);
             }
 
@@ -7464,7 +7468,7 @@ void dynamicTopoFvMesh::buildProcessorCoupledMaps()
             const Map<label>& pMap = cMap.entityMap(coupleMap::POINT);
 
             // Compute tolerance
-            scalar tol = geomMatchTol_ * box.mag();
+            scalar tol = geomMatchTol_()*box.mag();
 
             forAllConstIter(Map<label>, pMap, pIter)
             {
@@ -8761,7 +8765,7 @@ bool dynamicTopoFvMesh::syncCoupledBoundaryOrdering
                     maxLen = max(maxLen, mag(points_[sFace[fpI]] - sfc));
                 }
 
-                slaveTols[slavePatch][fI] = geomMatchTol_ * maxLen;
+                slaveTols[slavePatch][fI] = geomMatchTol_()*maxLen;
             }
 
             // For cyclics, additionally test for halves,
@@ -9115,7 +9119,7 @@ bool dynamicTopoFvMesh::syncCoupledBoundaryOrdering
                     maxLen = max(maxLen, mag(points_[checkFace[fpI]] - fc));
                 }
 
-                slaveTols[pI][fI] = geomMatchTol_ * maxLen;
+                slaveTols[pI][fI] = geomMatchTol_()*maxLen;
             }
 
             // Write out my centres to disk

src/dynamicMesh/dynamicMesh/polyMeshModifiers/slidingInterface/coupleSlidingInterface.C

@@ -47,12 +47,13 @@ Author
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-const Foam::scalar Foam::slidingInterface::edgeCoPlanarTol_
+const Foam::debug::tolerancesSwitch
+Foam::slidingInterface::edgeCoPlanarTol_
 (
-    debug::tolerances("slidingEdgeCoPlanarTol", 0.8)
+    "slidingEdgeCoPlanarTol",
+    0.8
 );
 
-
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 // Index of debug signs:
@@ -636,8 +637,8 @@ void Foam::slidingInterface::coupleInterface(polyTopoChange& ref) const
 
                     if
                     (
-                        cutOnMaster > edgeEndCutoffTol_
+                        cutOnMaster > edgeEndCutoffTol_()
-                     && cutOnMaster < 1.0 - edgeEndCutoffTol_
+		     && cutOnMaster < 1.0 - edgeEndCutoffTol_()
                     )
                     {
                         // Master is cut, check the slave
@@ -663,7 +664,7 @@ void Foam::slidingInterface::coupleInterface(polyTopoChange& ref) const
                             // Calculate merge tolerance from the
                             // target edge length
                             scalar mergeTol =
-                                edgeCoPlanarTol_*mag(b - a);
+                                edgeCoPlanarTol_()*mag(b - a);
 //                             Pout<< "cutOnMaster: " << cutOnMaster
 //                                 << " masterCutPoint: " << masterCutPoint
 //                                 << " slaveCutPoint: " << slaveCut.hitPoint()
@@ -676,8 +677,8 @@ void Foam::slidingInterface::coupleInterface(polyTopoChange& ref) const
 //                                 << endl;
                             if
                             (
-                                cutOnSlave > edgeEndCutoffTol_
+                                cutOnSlave > edgeEndCutoffTol_()
-                             && cutOnSlave < 1.0 - edgeEndCutoffTol_
+			     && cutOnSlave < 1.0 - edgeEndCutoffTol_()
                              && slaveCut.distance() < mergeTol
                             )
                             {

src/dynamicMesh/dynamicMesh/polyMeshModifiers/slidingInterface/slidingInterface.C

@@ -631,8 +631,8 @@ void Foam::slidingInterface::modifyMotionPoints(pointField& motionPoints) const
 
                     if
                     (
-                        cutOnMaster > edgeEndCutoffTol_
+                        cutOnMaster > edgeEndCutoffTol_()
-                     && cutOnMaster < 1.0 - edgeEndCutoffTol_
+		     && cutOnMaster < 1.0 - edgeEndCutoffTol_()
                     )
                     {
                         // Master is cut, check the slave
@@ -658,12 +658,12 @@ void Foam::slidingInterface::modifyMotionPoints(pointField& motionPoints) const
                             // Calculate merge tolerance from the
                             // target edge length
                             scalar mergeTol =
-                                edgeCoPlanarTol_*mag(b - a);
+                                edgeCoPlanarTol_()*mag(b - a);
 
                             if
                             (
-                                cutOnSlave > edgeEndCutoffTol_
+                                cutOnSlave > edgeEndCutoffTol_()
-                             && cutOnSlave < 1.0 - edgeEndCutoffTol_
+			     && cutOnSlave < 1.0 - edgeEndCutoffTol_()
                              && slaveCut.distance() < mergeTol
                             )
                             {

src/dynamicMesh/dynamicMesh/polyMeshModifiers/slidingInterface/slidingInterface.H

@@ -63,6 +63,7 @@ SourceFiles
 #include "ZoneIDs.H"
 #include "intersection.H"
 #include "Pair.H"
+#include "tolerancesSwitch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -261,28 +262,28 @@ private:
     // Static data members
 
         //- Point merge tolerance
-        static const scalar pointMergeTol_;
+        static const Foam::debug::tolerancesSwitch pointMergeTol_;
 
         //- Edge merge tolerance
-        static const scalar edgeMergeTol_;
+        static const Foam::debug::tolerancesSwitch edgeMergeTol_;
 
         //- Estimated number of faces an edge goes through
-        static const label nFacesPerSlaveEdge_;
+        static const Foam::label nFacesPerSlaveEdge_;
 
         //- Edge-face interaction escape limit
-        static const label edgeFaceEscapeLimit_;
+        static const Foam::label edgeFaceEscapeLimit_;
 
         //- Integral match point adjustment tolerance
-        static const scalar integralAdjTol_;
+        static const Foam::debug::tolerancesSwitch integralAdjTol_;
 
         //- Edge intersection master catch fraction
-        static const scalar edgeMasterCatchFraction_;
+        static const Foam::debug::tolerancesSwitch edgeMasterCatchFraction_;
 
         //- Edge intersection co-planar tolerance
-        static const scalar edgeCoPlanarTol_;
+        static const Foam::debug::tolerancesSwitch edgeCoPlanarTol_;
 
         //- Edge end cut-off tolerance
-        static const scalar edgeEndCutoffTol_;
+        static const Foam::debug::tolerancesSwitch edgeEndCutoffTol_;
 
 
 public:

src/dynamicMesh/dynamicMesh/polyMeshModifiers/slidingInterface/slidingInterfaceProjectPoints.C

@@ -44,31 +44,42 @@ Author
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-const Foam::scalar Foam::slidingInterface::pointMergeTol_
+const Foam::debug::tolerancesSwitch
+Foam::slidingInterface::pointMergeTol_
 (
-    debug::tolerances("slidingPointMergeTol", 0.2)
+    "slidingPointMergeTol",
+    0.2
 );
 
-const Foam::scalar Foam::slidingInterface::edgeMergeTol_
+const Foam::debug::tolerancesSwitch
+Foam::slidingInterface::edgeMergeTol_
 (
-    debug::tolerances("slidingEdgeMergeTol", 0.05)
+    "slidingEdgeMergeTol",
+    0.05
 );
 
-const Foam::scalar Foam::slidingInterface::integralAdjTol_
+const Foam::debug::tolerancesSwitch
+Foam::slidingInterface::integralAdjTol_
 (
-    debug::tolerances("slidingIntegralAdjTol", 0.15)
+    "slidingIntegralAdjTol",
+    0.15
 );
 
-const Foam::scalar Foam::slidingInterface::edgeMasterCatchFraction_
+const Foam::debug::tolerancesSwitch
+Foam::slidingInterface::edgeMasterCatchFraction_
 (
-    debug::tolerances("slidingEdgeMasterCatchFraction", 0.4)
+    "slidingEdgeMasterCatchFraction",
+    0.4
 );
 
-const Foam::scalar Foam::slidingInterface::edgeEndCutoffTol_
+const Foam::debug::tolerancesSwitch
+Foam::slidingInterface::edgeEndCutoffTol_
 (
-    debug::tolerances("slidingEdgeEndCutoffTol", 0.0001)
+    "slidingEdgeEndCutoffTol",
+    0.0001
 );
 
+
 const Foam::label Foam::slidingInterface::nFacesPerSlaveEdge_ = 5;
 
 // Increased limit for extreme 20-1 cutting.  HJ, 19/Dec/2008
@@ -105,7 +116,13 @@ bool Foam::slidingInterface::projectPoints() const
             << name() << " : "
             << "Projecting slave points onto master surface using ";
 
-        if (debug::optimisationSwitch("nSquaredProjection", 0) > 0)
+	const Foam::debug::optimisationSwitch nSquaredProjection
+	(
+	    "nSquaredProjection",
+	    0
+	);
+
+        if (nSquaredProjection() > 0)
         {
             Pout<< "N-squared point projection" << endl;
         }
@@ -361,7 +378,7 @@ bool Foam::slidingInterface::projectPoints() const
 
                     // Calculate the tolerance
                     const scalar mergeTol =
-                        integralAdjTol_*minSlavePointLength[pointI];
+                        integralAdjTol_()*minSlavePointLength[pointI];
 
                     // Adjust the hit
                     if (mag(nearPoint - missPoint) < mergeTol)
@@ -579,7 +596,7 @@ bool Foam::slidingInterface::projectPoints() const
 
                 // Calculate the tolerance
                 const scalar mergeTol =
-                    pointMergeTol_*
+                    pointMergeTol_()*
                     min
                     (
                         minSlavePointLength[pointI],
@@ -681,7 +698,7 @@ bool Foam::slidingInterface::projectPoints() const
                     minMasterFaceLength[slavePointFaceHits[pointI].hitObject()]
                 );
 
-            const scalar mergeTol = pointMergeTol_*mergeLength;
+            const scalar mergeTol = pointMergeTol_()*mergeLength;
 
             scalar minDistance = GREAT;
 
@@ -742,7 +759,7 @@ bool Foam::slidingInterface::projectPoints() const
 
                     // Calculate the tolerance
                     const scalar mergeTol =
-                        pointMergeTol_*
+                        pointMergeTol_()*
                         min
                         (
                             minSlavePointLength[pointI],
@@ -1054,7 +1071,7 @@ bool Foam::slidingInterface::projectPoints() const
             // Calculated as a combination of travel distance in projection and
             // edge length
             scalar slaveCatchDist =
-                edgeMasterCatchFraction_*edgeMag
+                edgeMasterCatchFraction_()*edgeMag
               + 0.5*
                 (
                     mag
@@ -1147,9 +1164,9 @@ bool Foam::slidingInterface::projectPoints() const
                     // Not a point hit, check for edge
                     if
                     (
-                        cutOnSlave > edgeEndCutoffTol_
+                        cutOnSlave > edgeEndCutoffTol_()
-                     && cutOnSlave < 1.0 - edgeEndCutoffTol_ // check edge cut
+		     && cutOnSlave < 1.0 - edgeEndCutoffTol_() // check edge cut
-                     && distInEdgePlane < edgeMergeTol_*edgeMag // merge plane
+		     && distInEdgePlane < edgeMergeTol_()*edgeMag // merge plane
                      && edgeLineHit.distance()
                       < min
                         (

src/dynamicMesh/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C

@@ -34,9 +34,11 @@ const Foam::label Foam::polyTopoChange::pointFraction = 10;
 const Foam::label Foam::polyTopoChange::faceFraction = 10;
 const Foam::label Foam::polyTopoChange::cellFraction = 10;
 
-int Foam::polyTopoChange::debug
+Foam::debug::debugSwitch
+Foam::polyTopoChange::debug
 (
-    Foam::debug::debugSwitch("polyTopoChange", 0)
+    "polyTopoChange",
+    0
 );
 
 

src/dynamicMesh/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.H

@@ -121,7 +121,7 @@ class polyTopoChange
 
 public:
 
-    static int debug;
+    static debug::debugSwitch debug;
 
 
     // Constructors

src/finiteArea/faMesh/faMesh.C

@@ -38,6 +38,7 @@ Description
 #include "wedgeFaPatch.H"
 #include "faPatchData.H"
 #include "SortableList.H"
+#include "controlSwitches.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -48,11 +49,14 @@ namespace Foam
 
 Foam::word Foam::faMesh::meshSubDir = "faMesh";
 
-const bool Foam::faMesh::quadricsFit_
+const Foam::debug::optimisationSwitch
+Foam::faMesh::quadricsFit_
 (
-    debug::optimisationSwitch("quadricsFit", 0) > 0
+    "quadricsFit",
+    0
 );
 
+
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 void Foam::faMesh::setPrimitiveMeshData()
@@ -1189,7 +1193,7 @@ const Foam::vectorField& Foam::faMesh::pointAreaNormals() const
     {
         calcPointAreaNormals();
 
-        if (quadricsFit_)
+        if (quadricsFit_() > 0)
         {
             calcPointAreaNormalsByQuadricsFit();
         }

src/finiteArea/faMesh/faMesh.H

@@ -174,7 +174,7 @@ class faMesh
 
     // Static Private Data
 
-        static const bool quadricsFit_;
+        static const Foam::debug::optimisationSwitch quadricsFit_;
 
 
     // Private Member Functions

src/finiteArea/faMesh/faPatches/constraint/cyclic/cyclicFaPatch.C

@@ -38,9 +38,10 @@ namespace Foam
 defineTypeNameAndDebug(cyclicFaPatch, 0);
 addToRunTimeSelectionTable(faPatch, cyclicFaPatch, dictionary);
 
-const scalar cyclicFaPatch::matchTol_
+const Foam::debug::tolerancesSwitch cyclicFaPatch::matchTol_
 (
-    debug::tolerances("patchFaceMatchTol", 1e-3)
+    "patchFaceMatchTol",
+    1e-3
 );
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
@@ -86,7 +87,7 @@ void Foam::cyclicFaPatch::calcTransforms()
             else if
             (
                 mag(magLe - nbrMagLe)/avLe
-              > matchTol_
+	      > matchTol_()
             )
             {
                 // Error in area matching.  Find largest error
@@ -102,7 +103,7 @@ void Foam::cyclicFaPatch::calcTransforms()
         }
 
         // Check for error in edge matching
-        if (maxMatchError > matchTol_)
+        if (maxMatchError > matchTol_())
         {
             label nbrEdgei = errorEdge + size()/2;
             scalar magLe = mag(half0Normals[errorEdge]);
@@ -120,7 +121,7 @@ void Foam::cyclicFaPatch::calcTransforms()
                 << "patch:" << name()
                 << " my area:" << magLe
                 << " neighbour area:" << nbrMagLe
-                << " matching tolerance:" << matchTol_
+                << " matching tolerance:" << matchTol_()
                 << endl
                 << "Mesh edge:" << start() + errorEdge
                 << endl
@@ -175,7 +176,7 @@ void cyclicFaPatch::makeWeights(scalarField& w) const
         if
         (
             mag(magL[edgei] - magL[edgei + sizeby2])/avL
-          > matchTol_
+	  > matchTol_()
         )
         {
             // Found error.  Look for largest matching error
@@ -197,7 +198,7 @@ void cyclicFaPatch::makeWeights(scalarField& w) const
     }
 
     // Check for error in matching
-    if (maxMatchError > polyPatch::matchTol_)
+    if (maxMatchError > polyPatch::matchTol_())
     {
         scalar avL = (magL[errorEdge] + magL[errorEdge + sizeby2])/2.0;
 
@@ -207,7 +208,7 @@ void cyclicFaPatch::makeWeights(scalarField& w) const
             << 100*mag(magL[errorEdge] - magL[errorEdge + sizeby2])/avL
             << "% -- possible edge ordering problem." << nl
             << "Cyclic area match tolerance = "
-            << polyPatch::matchTol_ << " patch: " << name()
+            << polyPatch::matchTol_() << " patch: " << name()
             << abort(FatalError);
     }
 }

src/finiteArea/faMesh/faPatches/constraint/cyclic/cyclicFaPatch.H

@@ -38,6 +38,7 @@ SourceFiles
 #include "coupledFaPatch.H"
 #include "cyclicLduInterface.H"
 #include "cyclicPolyPatch.H"
+#include "tolerancesSwitch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -65,7 +66,7 @@ protected:
 
         //- Relative tolerance (for geometric matching). Is factor of
         //  maximum edge length per face.
-        static const scalar matchTol_;
+        static const debug::tolerancesSwitch matchTol_;
 
     // Protected Member functions
 

src/finiteArea/fields/faPatchFields/faPatchField/faPatchField.H

@@ -43,6 +43,7 @@ SourceFiles
 
 #include "faPatch.H"
 #include "DimensionedField.H"
+#include "debugSwitch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -96,7 +97,7 @@ public:
     TypeName("faPatchField");
 
     //- Debug switch to disallow the use of
-    static int disallowDefaultFaPatchField;
+    static debug::debugSwitch disallowDefaultFaPatchField;
 
 
     // Declare run-time constructor selection tables

src/finiteArea/fields/faPatchFields/faPatchField/faPatchFields.C

@@ -36,9 +36,11 @@ namespace Foam
                                                                               \
 defineNamedTemplateTypeNameAndDebug(faPatchTypeField, 0);                     \
 template<>                                                                    \
-int faPatchTypeField::disallowDefaultFaPatchField                             \
+Foam::debug::debugSwitch                                                      \
+faPatchTypeField::disallowDefaultFaPatchField                                 \
 (                                                                             \
-    debug::debugSwitch("disallowDefaultFaPatchField", 0)                      \
+    "disallowDefaultFaPatchField",                                            \
+    0									      \
 );                                                                            \
 defineTemplateRunTimeSelectionTable(faPatchTypeField, patch);                 \
 defineTemplateRunTimeSelectionTable(faPatchTypeField, patchMapper);           \

src/finiteArea/fields/faePatchFields/faePatchField/faePatchField.H

@@ -43,6 +43,7 @@ SourceFiles
 
 #include "faPatch.H"
 #include "DimensionedField.H"
+#include "debugSwitch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -93,7 +94,7 @@ public:
     TypeName("faePatchField");
 
     //- Debug switch to disallow the use of
-    static int disallowDefaultFaePatchField;
+    static debug::debugSwitch disallowDefaultFaePatchField;
 
 
     // Declare run-time constructor selection tables

src/finiteArea/fields/faePatchFields/faePatchField/faePatchFields.C

@@ -39,9 +39,11 @@ namespace Foam
                                                                               \
 defineNamedTemplateTypeNameAndDebug(faePatchTypeField, 0);                    \
 template<>                                                                    \
-int faePatchTypeField::disallowDefaultFaePatchField                           \
+Foam::debug::debugSwitch                                                      \
+faePatchTypeField::disallowDefaultFaePatchField				      \
 (                                                                             \
-    debug::debugSwitch("disallowDefaultFaePatchField", 0)                     \
+    "disallowDefaultFaePatchField",                                           \
+    0									      \
 );                                                                            \
 defineTemplateRunTimeSelectionTable(faePatchTypeField, patch);                \
 defineTemplateRunTimeSelectionTable(faePatchTypeField, patchMapper);          \

src/finiteArea/finiteArea/faSchemes/faSchemes.C

@@ -35,7 +35,12 @@ Description
 namespace Foam
 {
 
-int faSchemes::debug(Foam::debug::debugSwitch("faSchemes", false));
+Foam::debug::debugSwitch
+faSchemes::debug
+(
+    "faSchemes",
+    false
+);
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //

src/finiteArea/finiteArea/faSchemes/faSchemes.H

@@ -38,6 +38,7 @@ SourceFiles
 #define faSchemes_H
 
 #include "IOdictionary.H"
+#include "debugSwitch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -90,7 +91,7 @@ private:
 public:
 
     //- Debug switch
-    static int debug;
+    static debug::debugSwitch debug;
 
 
     // Constructors

src/finiteVolume/cfdTools/general/adjustPhi/adjustPhi.C

@@ -29,6 +29,7 @@ License
 #include "processorFvsPatchFields.H"
 #include "inletOutletFvPatchFields.H"
 #include "fvc.H"
+#include "tolerancesSwitch.H"
 
 // * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
 
@@ -115,8 +116,11 @@ bool Foam::adjustPhi
 
         scalar massCorr = 1.0;
 
-        static const scalar closedDomainTol =
+        static const Foam::debug::tolerancesSwitch closedDomainTol
-            debug::tolerances("closedDomainTol", 1e-10);
+	(
+	    "closedDomainTol",
+	    1e-10
+	);
 
         if (mag(adjustableMassOut) > SMALL)
         {
@@ -125,7 +129,7 @@ bool Foam::adjustPhi
         else if
         (
             mag(fixedMassOut - massIn)
-          > closedDomainTol*Foam::max(1.0, mag(massIn))
+	  > closedDomainTol()*Foam::max(1.0, mag(massIn))
         )
         {
             phi.write();

src/finiteVolume/fields/fvPatchFields/basic/basicSymmetry/basicSymmetryFvPatchScalarField.C

@@ -213,7 +213,7 @@ void basicSymmetryFvPatchField<vector>::evaluate(const Pstream::commsTypes)
 {
     // Local typedefs
     typedef vector Type;
-    typedef outerProduct<vector, Type>::type gradType;
+    typedef typename outerProduct<vector, Type>::type gradType;
     typedef GeometricField<gradType, fvPatchField, volMesh> gradFieldType;
 
     if (!updated())

src/finiteVolume/fields/fvPatchFields/derived/directMappedFixedValue/directMappedFixedValueFvPatchField.C

@@ -77,7 +77,7 @@ void directMappedFixedValueFvPatchField<Type>::mapField()
             }
             mapDistribute::distribute
             (
-                Pstream::defaultCommsType,
+                static_cast<Pstream::commsTypes>(Pstream::defaultCommsType()),
                 distMap.schedule(),
                 distMap.constructSize(),
                 distMap.subMap(),
@@ -112,7 +112,7 @@ void directMappedFixedValueFvPatchField<Type>::mapField()
             newValues_ = nbrField.boundaryField()[nbrPatchID];
             mapDistribute::distribute
             (
-                Pstream::defaultCommsType,
+                static_cast<Pstream::commsTypes>(Pstream::defaultCommsType()),
                 distMap.schedule(),
                 distMap.constructSize(),
                 distMap.subMap(),
@@ -144,7 +144,7 @@ void directMappedFixedValueFvPatchField<Type>::mapField()
 
             mapDistribute::distribute
             (
-                Pstream::defaultCommsType,
+                static_cast<Pstream::commsTypes>(Pstream::defaultCommsType()),
                 distMap.schedule(),
                 distMap.constructSize(),
                 distMap.subMap(),

src/finiteVolume/fields/fvPatchFields/derived/directMappedVelocityFluxFixedValue/directMappedVelocityFluxFixedValueFvPatchField.C

@@ -198,7 +198,7 @@ void directMappedVelocityFluxFixedValueFvPatchField::updateCoeffs()
 
             mapDistribute::distribute
             (
-                Pstream::defaultCommsType,
+                static_cast<Pstream::commsTypes>(Pstream::defaultCommsType()),
                 distMap.schedule(),
                 distMap.constructSize(),
                 distMap.subMap(),
@@ -209,7 +209,7 @@ void directMappedVelocityFluxFixedValueFvPatchField::updateCoeffs()
 
             mapDistribute::distribute
             (
-                Pstream::defaultCommsType,
+                static_cast<Pstream::commsTypes>(Pstream::defaultCommsType()),
                 distMap.schedule(),
                 distMap.constructSize(),
                 distMap.subMap(),
@@ -231,7 +231,7 @@ void directMappedVelocityFluxFixedValueFvPatchField::updateCoeffs()
 
             mapDistribute::distribute
             (
-                Pstream::defaultCommsType,
+                static_cast<Pstream::commsTypes>(Pstream::defaultCommsType()),
                 distMap.schedule(),
                 distMap.constructSize(),
                 distMap.subMap(),
@@ -243,7 +243,7 @@ void directMappedVelocityFluxFixedValueFvPatchField::updateCoeffs()
 
             mapDistribute::distribute
             (
-                Pstream::defaultCommsType,
+                static_cast<Pstream::commsTypes>(Pstream::defaultCommsType()),
                 distMap.schedule(),
                 distMap.constructSize(),
                 distMap.subMap(),

src/finiteVolume/fields/fvPatchFields/fvPatchField/fvPatchField.H

@@ -46,6 +46,7 @@ SourceFiles
 
 #include "fvPatch.H"
 #include "DimensionedField.H"
+#include "debugSwitch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -114,7 +115,7 @@ public:
     TypeName("fvPatchField");
 
     //- Debug switch to disallow the use of genericFvPatchField
-    static int disallowGenericFvPatchField;
+    static debug::debugSwitch disallowGenericFvPatchField;
 
 
     // Declare run-time constructor selection tables

src/finiteVolume/fields/fvPatchFields/fvPatchField/fvPatchFields.C

@@ -36,9 +36,11 @@ namespace Foam
                                                                               \
 defineNamedTemplateTypeNameAndDebug(fvPatchTypeField, 0);                     \
 template<>                                                                    \
-int fvPatchTypeField::disallowGenericFvPatchField                             \
+Foam::debug::debugSwitch                                                      \
+fvPatchTypeField::disallowGenericFvPatchField                                 \
 (                                                                             \
-    debug::debugSwitch("disallowGenericFvPatchField", 0)                      \
+    "disallowGenericFvPatchField",                                            \
+    0									      \
 );                                                                            \
 defineTemplateRunTimeSelectionTable(fvPatchTypeField, patch);                 \
 defineTemplateRunTimeSelectionTable(fvPatchTypeField, patchMapper);           \

src/finiteVolume/fields/fvPatchFields/fvPatchVectorNFields/fvPatchVectorNFields.C

@@ -36,9 +36,11 @@ namespace Foam
                                                                               \
 defineNamedTemplateTypeNameAndDebug(fvPatchTypeField, 0);                     \
 template<>                                                                    \
-int fvPatchTypeField::disallowGenericFvPatchField                             \
+debug::debugSwitch                                                            \
+fvPatchTypeField::disallowGenericFvPatchField                                 \
 (                                                                             \
-    debug::debugSwitch("disallowGenericFvPatchField", 0)                      \
+    "disallowGenericFvPatchField",                                            \
+    0									      \
 );                                                                            \
 defineTemplateRunTimeSelectionTable(fvPatchTypeField, patch);                 \
 defineTemplateRunTimeSelectionTable(fvPatchTypeField, patchMapper);           \

src/finiteVolume/fields/fvsPatchFields/fvsPatchField/fvsPatchField.H

@@ -98,7 +98,7 @@ public:
     TypeName("fvsPatchField");
 
     //- Debug switch to disallow the use of
-    static int disallowDefaultFvsPatchField;
+    static debug::debugSwitch disallowDefaultFvsPatchField;
 
 
     // Declare run-time constructor selection tables

src/finiteVolume/fields/fvsPatchFields/fvsPatchField/fvsPatchFields.C

@@ -36,9 +36,11 @@ namespace Foam
                                                                               \
 defineNamedTemplateTypeNameAndDebug(fvsPatchTypeField, 0);                    \
 template<>                                                                    \
-int fvsPatchTypeField::disallowDefaultFvsPatchField                           \
+Foam::debug::debugSwitch                                                      \
+fvsPatchTypeField::disallowDefaultFvsPatchField                               \
 (                                                                             \
-    debug::debugSwitch("disallowDefaultFvsPatchField", 0)                     \
+    "disallowDefaultFvsPatchField",                                           \
+    0									      \
 );                                                                            \
 defineTemplateRunTimeSelectionTable(fvsPatchTypeField, patch);                \
 defineTemplateRunTimeSelectionTable(fvsPatchTypeField, patchMapper);          \

src/finiteVolume/fields/fvsPatchFields/fvsPatchVectorNFields/fvsPatchVectorNFields.C

@@ -36,9 +36,11 @@ namespace Foam
                                                                               \
 defineNamedTemplateTypeNameAndDebug(fvsPatchTypeField, 0);                    \
 template<>                                                                    \
-int fvsPatchTypeField::disallowDefaultFvsPatchField                           \
+Foam::debug::debugSwitch                                                      \
+fvsPatchTypeField::disallowDefaultFvsPatchField                               \
 (                                                                             \
-    debug::debugSwitch("disallowDefaultFvsPatchField", 0)                     \
+    "disallowDefaultFvsPatchField",                                           \
+    0									      \
 );                                                                            \
 defineTemplateRunTimeSelectionTable(fvsPatchTypeField, patch);                \
 defineTemplateRunTimeSelectionTable(fvsPatchTypeField, patchMapper);          \

src/finiteVolume/finiteVolume/fvSchemes/fvSchemes.C

@@ -29,7 +29,12 @@ License
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 
-int Foam::fvSchemes::debug(Foam::debug::debugSwitch("fvSchemes", false));
+Foam::debug::debugSwitch
+Foam::fvSchemes::debug
+(
+    "fvSchemes",
+    false
+);
 
 // * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
 

src/finiteVolume/finiteVolume/fvSchemes/fvSchemes.H

@@ -38,6 +38,7 @@ SourceFiles
 #define fvSchemes_H
 
 #include "IOdictionary.H"
+#include "debugSwitch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -96,7 +97,7 @@ class fvSchemes
 public:
 
     //- Debug switch
-    static int debug;
+        static debug::debugSwitch debug;
 
 
     // Constructors

src/finiteVolume/finiteVolume/gradSchemes/leastSquaresGrad/leastSquaresVectors.C

@@ -36,9 +36,11 @@ namespace Foam
 }
 
 
-const Foam::scalar Foam::leastSquaresVectors::smallDotProdTol_
+const Foam::debug::tolerancesSwitch
+Foam::leastSquaresVectors::smallDotProdTol_
 (
-    debug::tolerances("leastSquaresSmallDotProdTol", 0.1)
+    "leastSquaresSmallDotProdTol",
+    0.1
 );
 
 
@@ -112,7 +114,7 @@ void Foam::leastSquaresVectors::makeLeastSquaresVectors() const
     // Set up temporary storage for the dd tensor (before inversion)
     symmTensorField dd(mesh().nCells(), symmTensor::zero);
 
-    forAll (owner, faceI)
+    forAll(owner, faceI)
     {
         label own = owner[faceI];
         label nei = neighbour[faceI];
@@ -124,18 +126,18 @@ void Foam::leastSquaresVectors::makeLeastSquaresVectors() const
         dd[nei] += wdd;
     }
 
-    forAll (lsP.boundaryField(), patchI)
+    forAll(lsP.boundaryField(), patchI)
     {
         const fvPatch& p = mesh().boundary()[patchI];
-        const unallocLabelList& fc = p.patch().faceCells();
+        const unallocLabelList& faceCells = p.patch().faceCells();
 
         // Better version of d-vectors: Zeljko Tukovic, 25/Apr/2010
         const vectorField pd = p.delta();
 
-        forAll (pd, pFaceI)
+        forAll(pd, patchFaceI)
         {
-            const vector& d = pd[pFaceI];
+            const vector& d = pd[patchFaceI];
-            dd[fc[pFaceI]] += (1.0/magSqr(d))*sqr(d);
+            dd[faceCells[patchFaceI]] += (1.0/magSqr(d))*sqr(d);
         }
     }
 
@@ -153,25 +155,14 @@ void Foam::leastSquaresVectors::makeLeastSquaresVectors() const
         ),
         mesh(),
         dimensionedSymmTensor("zero", dimless, symmTensor::zero),
-        zeroGradientFvPatchScalarField::typeName
+        "zeroGradient"
     );
     symmTensorField& invDd = volInvDd.internalField();
-
-    // Invert least squares matrix using Householder transformations to avoid
-    // badly posed cells
 //    invDd = inv(dd);
     invDd = hinv(dd);
 
-    // Evaluate coupled to exchange coupled neighbour field data
-    // across coupled boundaries.  HJ, 18/Mar/2015
-    volInvDd.boundaryField().evaluateCoupled();
-
     // Revisit all faces and calculate the lsP and lsN vectors
-    vectorField& lsPIn = lsP.internalField();
+    forAll(owner, faceI)
-    vectorField& lsNIn = lsN.internalField();
-
-    // Least squares vectors on internal faces
-    forAll (owner, faceI)
     {
         label own = owner[faceI];
         label nei = neighbour[faceI];
@@ -179,17 +170,16 @@ void Foam::leastSquaresVectors::makeLeastSquaresVectors() const
         vector d = C[nei] - C[own];
         scalar magSfByMagSqrd = 1.0/magSqr(d);
 
-        lsPIn[faceI] = magSfByMagSqrd*(invDd[own] & d);
+        lsP[faceI] = magSfByMagSqrd*(invDd[own] & d);
-        lsNIn[faceI] = -magSfByMagSqrd*(invDd[nei] & d);
+        lsN[faceI] = -magSfByMagSqrd*(invDd[nei] & d);
     }
 
-    // Least squares vectors on boundary faces
+    forAll(lsP.boundaryField(), patchI)
-    forAll (lsP.boundaryField(), patchI)
     {
         fvsPatchVectorField& patchLsP = lsP.boundaryField()[patchI];
         fvsPatchVectorField& patchLsN = lsN.boundaryField()[patchI];
         const fvPatch& p = mesh().boundary()[patchI];
-        const unallocLabelList& fc = p.faceCells();
+        const unallocLabelList& faceCells = p.faceCells();
 
         // Better version of d-vectors: Zeljko Tukovic, 25/Apr/2010
         const vectorField pd = p.delta();
@@ -199,215 +189,29 @@ void Foam::leastSquaresVectors::makeLeastSquaresVectors() const
             const symmTensorField invDdNei =
                 volInvDd.boundaryField()[patchI].patchNeighbourField();
 
-            forAll (pd, pFaceI)
+            forAll(pd, patchFaceI)
             {
-                const vector& d = pd[pFaceI];
+                const vector& d = pd[patchFaceI];
 
-                patchLsP[pFaceI] = (1.0/magSqr(d))*(invDd[fc[pFaceI]] & d);
+                patchLsP[patchFaceI] = (1.0/magSqr(d))
+                   *(invDd[faceCells[patchFaceI]] & d);
 
-                patchLsN[pFaceI] = - (1.0/magSqr(d))*(invDdNei[pFaceI] & d);
+                patchLsN[patchFaceI] = - (1.0/magSqr(d))
+                   *(invDdNei[faceCells[patchFaceI]] & d);
             }
         }
         else
         {
-            forAll (pd, pFaceI)
+            forAll(pd, patchFaceI)
             {
-                const vector& d = pd[pFaceI];
+                const vector& d = pd[patchFaceI];
 
-                patchLsP[pFaceI] = (1.0/magSqr(d))*(invDd[fc[pFaceI]] & d);
+                patchLsP[patchFaceI] = (1.0/magSqr(d))
+                   *(invDd[faceCells[patchFaceI]] & d);
             }
         }
     }
 
-# if 0
-
-    // Coefficient sign correction on least squares vectors
-    // The sign of the coefficient must be positive to ensure correct
-    // behaviour in coupled systems.  This is checked by evaluating
-    // dot-product of the P/N vectors with the face area vector.
-    // If the dot-product is negative, cell is marked for use with the
-    // Gauss gradient, which is unconditionally positive
-    // HJ, 21/Apr/2015
-    
-    // First loop: detect cells with bad least squares vectors
-    Info<< "NEW LEAST SQUARES VECTORS" << endl;
-    // Use Gauss Gradient field: set to 1 if Gauss is needed
-    volScalarField useGaussGrad
-    (
-        IOobject
-        (
-            "useGaussGrad",
-            mesh().pointsInstance(),
-            mesh(),
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        mesh(),
-        dimensionedScalar("zero", dimVolume, 0),
-        zeroGradientFvPatchScalarField::typeName
-    );
-
-    const surfaceVectorField& Sf = mesh().Sf();
-    const surfaceScalarField& w = mesh().weights();
-
-    const vectorField& SfIn = Sf.internalField();
-    const scalarField& wIn = w.internalField();
-    scalarField& uggIn = useGaussGrad.internalField();
-
-    // Check internal faces
-    forAll (owner, faceI)
-    {
-        if
-        (
-            (lsPIn[faceI] & SfIn[faceI])/(mag(lsPIn[faceI])*mag(SfIn[faceI]))
-          < smallDotProdTol_
-        )
-        {
-            // Least square points in the wrong direction for owner
-            // Use Gauss gradient
-            uggIn[owner[faceI]] = 1;
-        }
-
-        if
-        (
-            (lsNIn[faceI] & SfIn[faceI])/(mag(lsNIn[faceI])*mag(SfIn[faceI]))
-          > -smallDotProdTol_
-        )
-        {
-            // Least square points in the wrong direction for owner.
-            // Note that Sf points into neighbour cell
-            // Use Gauss gradient
-            uggIn[neighbour[faceI]] = 1;
-        }
-    }
-
-    forAll (lsP.boundaryField(), patchI)
-    {
-        fvsPatchVectorField& patchLsP = lsP.boundaryField()[patchI];
-        const vectorField& pSf = Sf.boundaryField()[patchI];
-        const fvPatch& p = mesh().boundary()[patchI];
-        const unallocLabelList& fc = p.faceCells();
-
-        // Same check for coupled and uncoupled
-        forAll (patchLsP, pFaceI)
-        {
-            if
-            (
-                (patchLsP[pFaceI] & pSf[pFaceI])/
-                (mag(patchLsP[pFaceI])*mag(pSf[pFaceI]))
-              < smallDotProdTol_
-            )
-            {
-                uggIn[fc[pFaceI]] = 1;
-            }
-        }
-    }
-
-    // Update boundary conditions for coupled boundaries.  This synchronises
-    // the Gauss grad indication field
-    useGaussGrad.boundaryField().evaluateCoupled();
-
-    // Replace least square vectors with weighted Gauss gradient vectors
-    // for marked cells
-
-    // Prepare cell volumes with parallel communications
-    volScalarField cellV
-    (
-        IOobject
-        (
-            "cellV",
-            mesh().pointsInstance(),
-            mesh(),
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        mesh(),
-        dimensionedScalar("zero", dimVolume, 0),
-        zeroGradientFvPatchScalarField::typeName
-    );
-    cellV.internalField() = mesh().V();
-
-    // Evaluate coupled to exchange coupled neighbour field data
-    // across coupled boundaries.  HJ, 18/Mar/2015
-    cellV.boundaryField().evaluateCoupled();
-
-    const scalarField& cellVIn = cellV.internalField();
-
-    // Internal faces
-    forAll (owner, faceI)
-    {
-        label own = owner[faceI];
-        label nei = neighbour[faceI];
-
-        if (uggIn[own] > SMALL)
-        {
-            // Gauss gradient for owner cell
-            lsPIn[faceI] = (1 - wIn[faceI])*SfIn[faceI]/cellVIn[own];
-        }
-
-        if (uggIn[nei] > SMALL)
-        {
-            // Gauss gradient for neighbour cell
-            lsNIn[faceI] = -wIn[faceI]*SfIn[faceI]/cellVIn[nei];
-        }
-    }
-
-    // Boundary faces
-    forAll (lsP.boundaryField(), patchI)
-    {
-        fvsPatchVectorField& patchLsP = lsP.boundaryField()[patchI];
-        fvsPatchVectorField& patchLsN = lsN.boundaryField()[patchI];
-        const fvPatch& p = mesh().boundary()[patchI];
-        const unallocLabelList& fc = p.faceCells();
-
-        const fvsPatchScalarField& pw = w.boundaryField()[patchI];
-        const vectorField& pSf = Sf.boundaryField()[patchI];
-
-        // Get indicator for local side
-        const fvPatchScalarField& ugg = useGaussGrad.boundaryField()[patchI];
-        const scalarField pUgg = ugg.patchInternalField();
-
-        if (p.coupled())
-        {
-            const scalarField cellVInNei =
-                cellV.boundaryField()[patchI].patchNeighbourField();
-
-            // Get indicator for neighbour side
-            const scalarField nUgg = ugg.patchNeighbourField();
-
-            forAll (pUgg, pFaceI)
-            {
-                if (pUgg[pFaceI] > SMALL)
-                {
-                    // Gauss grad for owner cell
-                    patchLsP[pFaceI] =
-                        (1 - pw[pFaceI])*pSf[pFaceI]/cellVIn[fc[pFaceI]];
-                }
-
-                if (nUgg[pFaceI] > SMALL)
-                {
-                    // Gauss gradient for neighbour cell
-                    patchLsN[pFaceI] =
-                        -pw[pFaceI]*pSf[pFaceI]/cellVInNei[pFaceI];
-                }
-            }
-        }
-        else
-        {
-            forAll (pUgg, pFaceI)
-            {
-                if (pUgg[pFaceI] > SMALL)
-                {
-                    // Gauss grad for owner cell
-                    patchLsP[pFaceI] =
-                        (1 - pw[pFaceI])*pSf[pFaceI]/cellVIn[fc[pFaceI]];
-                }
-            }
-        }
-    }
-
-#endif
-
     if (debug)
     {
         Info<< "leastSquaresVectors::makeLeastSquaresVectors() :"
@@ -453,15 +257,12 @@ bool Foam::leastSquaresVectors::movePoints() const
     return true;
 }
 
-
 bool Foam::leastSquaresVectors::updateMesh(const mapPolyMesh& mpm) const
 {
     if (debug)
     {
-        InfoIn
+        InfoIn("bool leastSquaresVectors::updateMesh(const mapPolyMesh&) const")
-        (
+            << "Clearing least square data" << endl;
-            "bool leastSquaresVectors::updateMesh(const mapPolyMesh&) const"
-        )   << "Clearing least square data" << endl;
     }
 
     deleteDemandDrivenData(pVectorsPtr_);

src/finiteVolume/finiteVolume/gradSchemes/leastSquaresGrad/leastSquaresVectors.H

@@ -39,6 +39,7 @@ SourceFiles
 #include "fvMesh.H"
 #include "surfaceFieldsFwd.H"
 #include "labelPair.H"
+#include "tolerancesSwitch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -77,7 +78,7 @@ public:
     // Static data members
 
         //- Point merge tolerance
-        static const scalar smallDotProdTol_;
+        static const Foam::debug::tolerancesSwitch smallDotProdTol_;
 
 
     // Constructors

src/finiteVolume/fvMesh/fvPatches/constraint/cyclic/cyclicFvPatch.C

@@ -63,7 +63,7 @@ void cyclicFvPatch::makeWeights(scalarField& w) const
         if
         (
             mag(magFa[facei] - magFa[facei + sizeby2])/avFa
-          > polyPatch::matchTol_
+          > polyPatch::matchTol_()
         )
         {
             // Found error.  Look for largest matching error
@@ -85,7 +85,7 @@ void cyclicFvPatch::makeWeights(scalarField& w) const
     }
 
     // Check for error in matching
-    if (maxMatchError > polyPatch::matchTol_)
+    if (maxMatchError > polyPatch::matchTol_())
     {
         scalar avFa = (magFa[errorFace] + magFa[errorFace + sizeby2])/2.0;
 
@@ -95,7 +95,7 @@ void cyclicFvPatch::makeWeights(scalarField& w) const
             << 100*mag(magFa[errorFace] - magFa[errorFace + sizeby2])/avFa
             << "% -- possible face ordering problem." << nl
             << "Cyclic area match tolerance = "
-            << polyPatch::matchTol_ << " patch: " << name()
+            << polyPatch::matchTol_() << " patch: " << name()
             << abort(FatalError);
     }
 }

src/finiteVolume/interpolation/interpolation/interpolationCellPoint/cellPointWeight/cellPointWeight.C

@@ -28,7 +28,12 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-int Foam::cellPointWeight::debug(debug::debugSwitch("cellPointWeight", 0));
+Foam::debug::debugSwitch
+Foam::cellPointWeight::debug
+(
+    "cellPointWeight",
+    0
+);
 Foam::scalar Foam::cellPointWeight::tol(SMALL);
 
 // * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //

src/finiteVolume/interpolation/interpolation/interpolationCellPoint/cellPointWeight/cellPointWeight.H

@@ -84,7 +84,7 @@ protected:
 public:
 
     //- Debug switch
-    static int debug;
+    static debug::debugSwitch debug;
 
     //- Tolerance used in calculating barycentric co-ordinates
     //  (applied to normailised values)

src/foam/Make/files

@@ -3,6 +3,12 @@ global/dimensionedConstants/dimensionedConstants.C
 global/argList/argList.C
 global/clock/clock.C
 
+global/controlSwitches/debugSwitch.C
+global/controlSwitches/infoSwitch.C
+global/controlSwitches/optimisationSwitch.C
+global/controlSwitches/tolerancesSwitch.C
+global/controlSwitches/constantsSwitch.C
+
 global/profiling/profilingInfo.C
 global/profiling/profilingPool.C
 global/profiling/profilingStack.C

src/foam/algorithms/MeshWave/FaceCellWave.C

@@ -36,15 +36,17 @@ License
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 template <class Type>
-Foam::scalar Foam::FaceCellWave<Type>::geomTol_
+Foam::debug::tolerancesSwitch Foam::FaceCellWave<Type>::geomTol_
 (
-    debug::tolerances("FaceCellWaveGeomTol", 1e-6)
+    "FaceCellWaveGeomTol",
+    1e-6
 );
 
 template <class Type>
-Foam::scalar Foam::FaceCellWave<Type>::propagationTol_
+Foam::debug::tolerancesSwitch Foam::FaceCellWave<Type>::propagationTol_
 (
-    debug::tolerances("FaceCellWavePropagationTol", 0.01)
+    "FaceCellWavePropagationTol",
+    0.01
 );
 
 // Write to ostream
@@ -264,7 +266,7 @@ void Foam::FaceCellWave<Type>::checkCyclic(const polyPatch& patch) const
         label i1 = patch.start() + patchFaceI;
         label i2 = i1 + cycOffset;
 
-        if (!allFaceInfo_[i1].sameGeometry(mesh_, allFaceInfo_[i2], geomTol_))
+        if (!allFaceInfo_[i1].sameGeometry(mesh_, allFaceInfo_[i2], geomTol_()))
         {
             FatalErrorIn("FaceCellWave<Type>::checkCyclic(const polyPatch&)")
                 << "problem: i:" << i1 << "  otheri:" << i2
@@ -359,7 +361,7 @@ void Foam::FaceCellWave<Type>::mergeFaceInfo
             (
                 meshFaceI,
                 neighbourWallInfo,
-                propagationTol_,
+                propagationTol_(),
                 currentWallInfo
             );
         }
@@ -934,7 +936,7 @@ Foam::label Foam::FaceCellWave<Type>::faceToCell()
                 cellI,
                 faceI,
                 neighbourWallInfo,
-                propagationTol_,
+                propagationTol_(),
                 currentWallInfo
             );
         }
@@ -952,7 +954,7 @@ Foam::label Foam::FaceCellWave<Type>::faceToCell()
                     cellI,
                     faceI,
                     neighbourWallInfo,
-                    propagationTol_,
+                    propagationTol_(),
                     currentWallInfo2
                 );
             }
@@ -1018,7 +1020,7 @@ Foam::label Foam::FaceCellWave<Type>::cellToFace()
                     faceI,
                     cellI,
                     neighbourWallInfo,
-                    propagationTol_,
+                    propagationTol_(),
                     currentWallInfo
                 );
             }

src/foam/algorithms/MeshWave/FaceCellWave.H

@@ -50,6 +50,7 @@ SourceFiles
 #include "boolList.H"
 #include "labelList.H"
 #include "primitiveFieldsFwd.H"
+#include "tolerancesSwitch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -267,9 +268,8 @@ class FaceCellWave
 
       // Private static data
 
-            static scalar geomTol_;
+            static debug::tolerancesSwitch geomTol_;
-            static scalar propagationTol_;
+            static debug::tolerancesSwitch propagationTol_;
-
 
 public:
 
@@ -278,7 +278,7 @@ public:
         //- Access to tolerance
         static scalar propagationTol()
         {
-            return propagationTol_;
+            return propagationTol_();
         }
 
         //- Change tolerance

src/foam/algorithms/octree/octree/octreeDataBoundBox.C

@@ -35,12 +35,13 @@ License
 
 defineTypeNameAndDebug(Foam::octreeDataBoundBox, 0);
 
-Foam::scalar Foam::octreeDataBoundBox::tol
+const Foam::debug::tolerancesSwitch
+Foam::octreeDataBoundBox::tol
 (
-    debug::tolerances("octreeDataBoundBoxTol", 1e-6)
+    "octreeDataBoundBoxTol",
+    1e-6
 );
 
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::octreeDataBoundBox::octreeDataBoundBox

src/foam/algorithms/octree/octree/octreeDataBoundBox.H

@@ -49,6 +49,7 @@ Author
 #include "point.H"
 #include "className.H"
 #include "linePointRef.H"
+#include "tolerancesSwitch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -69,7 +70,7 @@ class octreeDataBoundBox
     // Static data
 
         //- Tolerance on linear dimensions
-        static scalar tol;
+        static const Foam::debug::tolerancesSwitch tol;
 
 
     // Private data

src/foam/containers/NamedEnum/NamedEnum.H

@@ -120,6 +120,13 @@ public:
             return names[e];
         }
 
+        //- Return the name of the given enumeration element
+        //  where e is specified as a int
+        const char* operator[](const int e) const
+        {
+            return names[e];
+        }
+
 
     // Friend operators
 

src/foam/db/IOstreams/IOstreams.C

@@ -36,8 +36,13 @@ namespace Foam
 
 const IOstream::versionNumber IOstream::originalVersion(0.5);
 const IOstream::versionNumber IOstream::currentVersion(2.0);
-unsigned int IOstream::precision_(debug::infoSwitch("writePrecision", 6));
 
+Foam::debug::infoSwitch
+IOstream::precision_
+(
+    "writePrecision",
+    6
+);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 // Global IO streams

src/foam/db/IOstreams/IOstreams/IOstream.H

@@ -49,9 +49,13 @@ SourceFiles
 #include "scalar.H"
 #include "fileName.H"
 #include "InfoProxy.H"
+#include "infoSwitch.H"
+
+#include "debug.H"
 
 #include <iostream>
 
+
 #if __GNUC__ < 3
 #   define ios_base ios
 #endif
@@ -211,8 +215,7 @@ public:
         static const versionNumber currentVersion;
 
         //- Default precision
-        static unsigned int precision_;
+        static Foam::debug::infoSwitch precision_;
-
 
 private:
 
@@ -466,13 +469,13 @@ public:
             //- Return the default precision
             static unsigned int defaultPrecision()
             {
-                return precision_;
+                return precision_();
             }
 
             //- Reset the default precision (and return old precision)
             static unsigned int defaultPrecision(unsigned int p)
             {
-                unsigned int precision0 = precision_;
+                unsigned int precision0 = precision_();
                 precision_ = p;
                 return precision0;
             }

src/foam/db/IOstreams/Pstreams/Pstream.C

@@ -227,23 +227,41 @@ Foam::List<Foam::Pstream::commsStruct> Foam::Pstream::treeCommunication_(0);
 // Should compact transfer be used in which floats replace doubles
 // reducing the bandwidth requirement at the expense of some loss
 // in accuracy
-bool Foam::Pstream::floatTransfer
+const Foam::debug::optimisationSwitch
+Foam::Pstream::floatTransfer
 (
-    debug::optimisationSwitch("floatTransfer", 0)
+    "floatTransfer",
+    0
 );
 
 // Number of processors at which the reduce algorithm changes from linear to
 // tree
-int Foam::Pstream::nProcsSimpleSum
+const Foam::debug::optimisationSwitch
+Foam::Pstream::nProcsSimpleSum
 (
-    debug::optimisationSwitch("nProcsSimpleSum", 16)
+    "nProcsSimpleSum",
+    16
 );
 
 // Default commsType
-Foam::Pstream::commsTypes Foam::Pstream::defaultCommsType
+Foam::Pstream::commsTypes Foam::Pstream::defaultCommsType_
 (
-    commsTypeNames.read(debug::optimisationSwitches().lookup("commsType"))
+    commsTypeNames
+    [
+	debug::optimisationSwitches().lookupOrAddDefault
+	(
+	    "commsType",
+	    word("blocking")
+	)
+    ]
 );
 
+const Foam::debug::optimisationSwitch
+Foam::Pstream::defaultCommsType
+(
+    "commsType",
+    "blocking",
+    "blocking, nonBlocking, scheduled"
+);
 
 // ************************************************************************* //

src/foam/db/IOstreams/Pstreams/Pstream.H

@@ -45,6 +45,7 @@ SourceFiles
 #include "HashTable.H"
 #include "string.H"
 #include "NamedEnum.H"
+#include "optimisationSwitch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -224,15 +225,16 @@ public:
         //- Should compact transfer be used in which floats replace doubles
         //  reducing the bandwidth requirement at the expense of some loss
         //  in accuracy
-        static bool floatTransfer;
+        static const Foam::debug::optimisationSwitch floatTransfer;
 
         //- Number of processors at which the sum algorithm changes from linear
         //  to tree
-        static int nProcsSimpleSum;
+        static const Foam::debug::optimisationSwitch nProcsSimpleSum;
 
         //- Default commsType
-        static commsTypes defaultCommsType;
+        static commsTypes defaultCommsType_;
 
+        static const Foam::debug::optimisationSwitch defaultCommsType;
 
     // Constructors
 

src/foam/db/IOstreams/Pstreams/PstreamCombineReduceOps.H

@@ -62,7 +62,7 @@ void combineReduce
 template <class T, class CombineOp>
 void combineReduce(T& Value, const CombineOp& cop)
 {
-    if (Pstream::nProcs() < Pstream::nProcsSimpleSum)
+    if (Pstream::nProcs() < Pstream::nProcsSimpleSum())
     {
         Pstream::combineGather(Pstream::linearCommunication(), Value, cop);
         Pstream::combineScatter(Pstream::linearCommunication(), Value);

src/foam/db/IOstreams/Pstreams/PstreamReduceOps.H

@@ -58,7 +58,7 @@ void reduce
     const BinaryOp& bop
 )
 {
-    if (Pstream::nProcs() < Pstream::nProcsSimpleSum)
+    if (Pstream::nProcs() < Pstream::nProcsSimpleSum())
     {
         reduce(Pstream::linearCommunication(), Value, bop);
     }
@@ -79,7 +79,7 @@ T returnReduce
 {
     T WorkValue(Value);
 
-    if (Pstream::nProcs() < Pstream::nProcsSimpleSum)
+    if (Pstream::nProcs() < Pstream::nProcsSimpleSum())
     {
         reduce(Pstream::linearCommunication(), WorkValue, bop);
     }

src/foam/db/IOstreams/Pstreams/combineGatherScatter.C

@@ -129,7 +129,7 @@ void Pstream::combineGather
 template <class T, class CombineOp>
 void Pstream::combineGather(T& Value, const CombineOp& cop)
 {
-    if (Pstream::nProcs() < Pstream::nProcsSimpleSum)
+    if (Pstream::nProcs() < Pstream::nProcsSimpleSum())
     {
         combineGather(Pstream::linearCommunication(), Value, cop);
     }
@@ -207,7 +207,7 @@ void Pstream::combineScatter(const List<Pstream::commsStruct>& comms, T& Value)
 template <class T>
 void Pstream::combineScatter(T& Value)
 {
-    if (Pstream::nProcs() < Pstream::nProcsSimpleSum)
+    if (Pstream::nProcs() < Pstream::nProcsSimpleSum())
     {
         combineScatter(Pstream::linearCommunication(), Value);
     }
@@ -313,7 +313,7 @@ void Pstream::listCombineGather
 template <class T, class CombineOp>
 void Pstream::listCombineGather(List<T>& Values, const CombineOp& cop)
 {
-    if (Pstream::nProcs() < Pstream::nProcsSimpleSum)
+    if (Pstream::nProcs() < Pstream::nProcsSimpleSum())
     {
         listCombineGather(Pstream::linearCommunication(), Values, cop);
     }
@@ -395,7 +395,7 @@ void Pstream::listCombineScatter
 template <class T>
 void Pstream::listCombineScatter(List<T>& Values)
 {
-    if (Pstream::nProcs() < Pstream::nProcsSimpleSum)
+    if (Pstream::nProcs() < Pstream::nProcsSimpleSum())
     {
         listCombineScatter(Pstream::linearCommunication(), Values);
     }
@@ -480,7 +480,7 @@ void Pstream::mapCombineGather
 template <class Container, class CombineOp>
 void Pstream::mapCombineGather(Container& Values, const CombineOp& cop)
 {
-    if (Pstream::nProcs() < Pstream::nProcsSimpleSum)
+    if (Pstream::nProcs() < Pstream::nProcsSimpleSum())
     {
         mapCombineGather(Pstream::linearCommunication(), Values, cop);
     }
@@ -536,7 +536,7 @@ void Pstream::mapCombineScatter
 template <class Container>
 void Pstream::mapCombineScatter(Container& Values)
 {
-    if (Pstream::nProcs() < Pstream::nProcsSimpleSum)
+    if (Pstream::nProcs() < Pstream::nProcsSimpleSum())
     {
         mapCombineScatter(Pstream::linearCommunication(), Values);
     }

src/foam/db/IOstreams/Pstreams/gatherScatter.C

@@ -103,7 +103,7 @@ void Pstream::gather
 template <class T, class BinaryOp>
 void Pstream::gather(T& Value, const BinaryOp& bop)
 {
-    if (Pstream::nProcs() < Pstream::nProcsSimpleSum)
+    if (Pstream::nProcs() < Pstream::nProcsSimpleSum())
     {
         gather(Pstream::linearCommunication(), Value, bop);
     }
@@ -168,7 +168,7 @@ void Pstream::scatter(const List<Pstream::commsStruct>& comms, T& Value)
 template <class T>
 void Pstream::scatter(T& Value)
 {
-    if (Pstream::nProcs() < Pstream::nProcsSimpleSum)
+    if (Pstream::nProcs() < Pstream::nProcsSimpleSum())
     {
         scatter(Pstream::linearCommunication(), Value);
     }

src/foam/db/IOstreams/Pstreams/gatherScatterList.C

@@ -180,7 +180,7 @@ void Pstream::gatherList
 template <class T>
 void Pstream::gatherList(List<T>& Values)
 {
-    if (Pstream::nProcs() < Pstream::nProcsSimpleSum)
+    if (Pstream::nProcs() < Pstream::nProcsSimpleSum())
     {
         gatherList(Pstream::linearCommunication(), Values);
     }
@@ -305,7 +305,7 @@ void Pstream::scatterList
 template <class T>
 void Pstream::scatterList(List<T>& Values)
 {
-    if (Pstream::nProcs() < Pstream::nProcsSimpleSum)
+    if (Pstream::nProcs() < Pstream::nProcsSimpleSum())
     {
         scatterList(Pstream::linearCommunication(), Values);
     }

src/foam/db/IOstreams/Sstreams/OSstreamI.H

@@ -44,7 +44,7 @@ inline Foam::OSstream::OSstream
     {
         setOpened();
         setGood();
-        os_.precision(precision_);
+        os_.precision(precision_());
     }
     else
     {

src/foam/db/Time/TimeIO.C

@@ -33,6 +33,9 @@ License
 
 void Foam::Time::readDict()
 {
+    if (debug)
+	Info << "Time::readDict(): reading " << controlDict_.name() << endl;
+
     if (!deltaTchanged_)
     {
         deltaT_ = readScalar(controlDict_.lookup("deltaT"));

src/foam/db/dictionary/functionEntries/includeEntry/includeEntry.C

@@ -37,7 +37,12 @@ const Foam::word Foam::functionEntries::includeEntry::typeName
 
 // Don't lookup the debug switch here as the debug switch dictionary
 // might include includeEntry
-int Foam::functionEntries::includeEntry::debug(0);
+Foam::debug::debugSwitch
+Foam::functionEntries::includeEntry::debug
+(
+    "includeEntry",
+    0
+);
 
 namespace Foam
 {

src/foam/db/dictionary/functionEntries/includeIfPresentEntry/includeIfPresentEntry.C

@@ -37,7 +37,12 @@ const Foam::word Foam::functionEntries::includeIfPresentEntry::typeName
 
 // Don't lookup the debug switch here as the debug switch dictionary
 // might include includeIfPresentEntry
-int Foam::functionEntries::includeIfPresentEntry::debug(0);
+Foam::debug::debugSwitch
+Foam::functionEntries::includeIfPresentEntry::debug
+(
+    "includeIfPresentEntry",
+    0
+);
 
 namespace Foam
 {

src/foam/db/dictionary/functionEntries/inputModeEntry/inputModeEntry.C

@@ -36,7 +36,12 @@ const Foam::word Foam::functionEntries::inputModeEntry::typeName
 
 // Don't lookup the debug switch here as the debug switch dictionary
 // might include inputModeEntries
-int Foam::functionEntries::inputModeEntry::debug(0);
+Foam::debug::debugSwitch
+Foam::functionEntries::inputModeEntry::debug
+(
+    "inputModeEntry",
+    0
+);
 
 Foam::functionEntries::inputModeEntry::inputMode
     Foam::functionEntries::inputModeEntry::mode_(MERGE);

src/foam/db/dictionary/functionEntries/removeEntry/removeEntry.C

@@ -39,7 +39,12 @@ const Foam::word Foam::functionEntries::removeEntry::typeName
 
 // Don't lookup the debug switch here as the debug switch dictionary
 // might include removeEntry
-int Foam::functionEntries::removeEntry::debug(0);
+Foam::debug::debugSwitch
+Foam::functionEntries::removeEntry::debug
+(
+    "removeEntry",
+    0
+);
 
 namespace Foam
 {

src/foam/db/error/messageStream.C

@@ -29,7 +29,12 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-int Foam::messageStream::level(Foam::debug::debugSwitch("level", 2));
+Foam::debug::debugSwitch
+Foam::messageStream::level
+(
+    "level",
+    2
+);
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/foam/db/error/messageStream.H

@@ -48,6 +48,7 @@ SourceFiles
 
 #include "label.H"
 #include "string.H"
+#include "debugSwitch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -93,7 +94,7 @@ public:
 
     // Debug switches
 
-        static int level;
+        static debug::debugSwitch level;
 
 
     // Constructors

src/foam/db/functionObjects/functionObject/functionObject.C

@@ -30,7 +30,13 @@ License
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 defineRunTimeSelectionTable(Foam::functionObject, dictionary);
-int Foam::functionObject::debug(Foam::debug::debugSwitch("functionObject", 0));
+
+Foam::debug::debugSwitch
+Foam::functionObject::debug
+(
+    "functionObject",
+    0
+);
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //

src/foam/db/functionObjects/functionObject/functionObject.H

@@ -41,6 +41,7 @@ SourceFiles
 #include "typeInfo.H"
 #include "autoPtr.H"
 #include "runTimeSelectionTables.H"
+#include "debugSwitch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -76,7 +77,7 @@ public:
     //- Runtime type information
     virtual const word& type() const = 0;
 
-    static int debug;
+    static debug::debugSwitch debug;
 
 
     // Declare run-time constructor selection tables

src/foam/db/regIOobject/regIOobject.C

@@ -31,12 +31,13 @@ License
 
 defineTypeNameAndDebug(Foam::regIOobject, 0);
 
-int Foam::regIOobject::fileModificationSkew
+const Foam::debug::optimisationSwitch
+Foam::regIOobject::fileModificationSkew
 (
-    Foam::debug::optimisationSwitch("fileModificationSkew", 30)
+    "fileModificationSkew",
+    30
 );
 
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 // Construct from IOobject

src/foam/db/regIOobject/regIOobject.H

@@ -41,6 +41,7 @@ SourceFiles
 #include "IOobject.H"
 #include "typeInfo.H"
 #include "OSspecific.H"
+#include "optimisationSwitch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -93,7 +94,7 @@ public:
         //- Runtime type information
         TypeName("regIOobject");
 
-        static int fileModificationSkew;
+        static const Foam::debug::optimisationSwitch fileModificationSkew;
 
 
     // Constructors

src/foam/db/regIOobject/regIOobjectRead.C

@@ -154,7 +154,7 @@ bool Foam::regIOobject::modified() const
     return
     (
         lastModified_
-     && lastModified(filePath()) > (lastModified_ + fileModificationSkew)
+     && lastModified(filePath()) > (lastModified_ + fileModificationSkew())
     );
 }
 
@@ -167,7 +167,7 @@ bool Foam::regIOobject::readIfModified()
 
         bool readFile = false;
 
-        if (newTimeStamp > (lastModified_ + fileModificationSkew))
+        if (newTimeStamp > (lastModified_ + fileModificationSkew()))
         {
             readFile = true;
         }

src/foam/db/scalarRange/scalarRange.C

@@ -28,7 +28,12 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-int Foam::scalarRange::debug(::Foam::debug::debugSwitch("scalarRange", 0));
+Foam::debug::debugSwitch
+Foam::scalarRange::debug
+(
+    "scalarRange",
+    0
+);
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //

src/foam/db/scalarRange/scalarRange.H

@@ -40,6 +40,7 @@ SourceFiles
 #define scalarRange_H
 
 #include "scalar.H"
+#include "debugSwitch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -82,7 +83,7 @@ class scalarRange
 
 public:
 
-        static int debug;
+        static debug::debugSwitch debug;
 
 
     // Constructors

src/foam/db/typeInfo/className.H

@@ -31,6 +31,7 @@ Description
 
 #include "word.H"
 #include "debug.H"
+#include "debugSwitch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -72,13 +73,13 @@ public:                                                                       \
 //  Also declares debug information.
 #define ClassName(TypeNameString)                                             \
     ClassNameNoDebug(TypeNameString);                                         \
-    static int debug
+    static Foam::debug::debugSwitch debug;
 
 //- Add typeName information from argument @a TypeNameString to a namespace.
 //  Also declares debug information.
 #define NamespaceName(TypeNameString)                                         \
     NamespaceNameNoDebug(TypeNameString);                                     \
-    extern int debug
+    extern Foam::debug::debugSwitch debug;
 
 //- Add typeName information from argument @a TypeNameString to a template class.
 //  Also declares debug information.
@@ -132,22 +133,24 @@ public:                                                                       \
 
 
 //- Define the debug information, lookup as @a Name
-#define defineDebugSwitchWithName(Type, Name, DebugSwitch)                    \
+#define defineDebugSwitchWithName(Type, Name, DebugSwitch, SwitchDescr)       \
-    int Type::debug(::Foam::debug::debugSwitch(Name, DebugSwitch))
+    ::Foam::debug::debugSwitch                                                \
+    Type::debug(std::string(Name), DebugSwitch, SwitchDescr)
 
 //- Define the debug information
-#define defineDebugSwitch(Type, DebugSwitch)                                  \
+#define defineDebugSwitch(Type, DebugSwitch, SwitchDescr)		      \
-    defineDebugSwitchWithName(Type, Type::typeName_(), DebugSwitch)
+    defineDebugSwitchWithName(Type, Type::typeName_(), DebugSwitch, SwitchDescr);
 
 #ifdef __INTEL_COMPILER
 //- Define the debug information for templates, lookup as @a Name
 # define defineTemplateDebugSwitchWithName(Type, Name, DebugSwitch)           \
-    defineDebugSwitchWithName(Type, Name, DebugSwitch)
+    defineDebugSwitchWithName(Type, Name, DebugSwitch, "");
+
 #else
 //- Define the debug information for templates, lookup as @a Name
 # define defineTemplateDebugSwitchWithName(Type, Name, DebugSwitch)           \
     template<>                                                                \
-    defineDebugSwitchWithName(Type, Name, DebugSwitch)
+    defineDebugSwitchWithName(Type, Name, DebugSwitch, "");
 #endif
 
 //- Define the debug information for templates
@@ -169,7 +172,12 @@ public:                                                                       \
 //- Define the typeName and debug information
 #define defineTypeNameAndDebug(Type, DebugSwitch)                             \
     defineTypeName(Type);                                                     \
-    defineDebugSwitch(Type, DebugSwitch)
+    defineDebugSwitch(Type, DebugSwitch, "")
+
+//- Define the typeName and debug information + description
+#define defineTypeNameAndDebugWithDescription(Type, DebugSwitch, SwitchDescr) \
+    defineTypeName(Type);                                                     \
+    defineDebugSwitch(Type, DebugSwitch, SwitchDescr)
 
 //- Define the typeName and debug information, lookup as @a Name
 #define defineTemplateTypeNameAndDebugWithName(Type, Name, DebugSwitch)       \

src/foam/fields/GeometricFields/GeometricField/GeometricBoundaryField.C

@@ -293,7 +293,10 @@ evaluate()
     {
         forAll(*this, patchi)
         {
-            this->operator[](patchi).initEvaluate(Pstream::defaultCommsType);
+            this->operator[](patchi).initEvaluate
+	    (
+		static_cast<Pstream::commsTypes>(Pstream::defaultCommsType())
+	    );
         }
 
         // Block for any outstanding requests
@@ -305,7 +308,10 @@ evaluate()
 
         forAll(*this, patchi)
         {
-            this->operator[](patchi).evaluate(Pstream::defaultCommsType);
+            this->operator[](patchi).evaluate
+	    (
+		static_cast<Pstream::commsTypes>(Pstream::defaultCommsType())
+	    );
         }
     }
     else if (Pstream::defaultCommsType == Pstream::scheduled)
@@ -331,7 +337,7 @@ evaluate()
     {
         FatalErrorIn("GeometricBoundaryField::evaluate()")
             << "Unsuported communications type "
-            << Pstream::commsTypeNames[Pstream::defaultCommsType]
+            << Pstream::commsTypeNames[Pstream::defaultCommsType()]
             << exit(FatalError);
     }
 }
@@ -360,7 +366,7 @@ evaluateCoupled()
             {
                 this->operator[](patchi).initEvaluate
                 (
-                    Pstream::defaultCommsType
+                    static_cast<Pstream::commsTypes>(Pstream::defaultCommsType())
                 );
             }
         }
@@ -376,7 +382,10 @@ evaluateCoupled()
         {
             if (this->operator[](patchi).coupled())
             {
-                this->operator[](patchi).evaluate(Pstream::defaultCommsType);
+                this->operator[](patchi).evaluate
+		(
+		    static_cast<Pstream::commsTypes>(Pstream::defaultCommsType())
+		);
             }
         }
     }
@@ -415,7 +424,7 @@ evaluateCoupled()
     {
         FatalErrorIn("GeometricBoundaryField::evaluateCoupled()")
             << "Unsuported communications type "
-            << Pstream::commsTypeNames[Pstream::defaultCommsType]
+            << Pstream::commsTypeNames[Pstream::defaultCommsType()]
             << exit(FatalError);
     }
 }

src/foam/global/JobInfo/JobInfo.C

@@ -31,7 +31,13 @@ License
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-bool Foam::JobInfo::writeJobInfo(Foam::debug::infoSwitch("writeJobInfo", 0));
+Foam::debug::infoSwitch
+Foam::JobInfo::writeJobInfo
+(
+    "writeJobInfo",
+    0
+);
+
 Foam::JobInfo Foam::jobInfo;