Merge branch 'master' into lagrangianDev

applications/solvers/combustion/dieselEngineFoam/createSpray.H

@@ -32,7 +32,5 @@ if (dieselSpray.twoD())
     gasMass0 *= 2.0*mathematicalConstant::pi/dieselSpray.angleOfWedge();
 }
 
-reduce(gasMass0, sumOp<scalar>());
-
 gasMass0 -=
     dieselSpray.injectedMass(runTime.value()) - dieselSpray.liquidMass();

applications/solvers/combustion/dieselEngineFoam/spraySummary.H

@@ -23,8 +23,6 @@
             gasMass *= 2.0*mathematicalConstant::pi/dieselSpray.angleOfWedge();
         }
 
-        reduce(gasMass, sumOp<scalar>());
-
         scalar addedMass = gasMass - gasMass0;
 
         Info<< "Added gas mass................. | " << 1e6*addedMass << " mg"

applications/solvers/discreteMethods/dsmc/dsmcFoam/Make/files

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

applications/solvers/discreteMethods/dsmc/dsmcFoam/Make/options

@@ -0,0 +1,12 @@
+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/lagrangian/basic/lnInclude \
+    -I$(LIB_SRC)/lagrangian/dsmc/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude
+
+EXE_LIBS = \
+    -lmeshTools \
+    -lfiniteVolume \
+    -llagrangian \
+    -ldsmc
+

applications/solvers/discreteMethods/dsmc/dsmcFoam/createFields.H

@@ -0,0 +1,162 @@
+
+    Info<< nl << "Reading field boundaryT" << endl;
+    volScalarField boundaryT
+    (
+        IOobject
+        (
+            "boundaryT",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+    Info<< nl << "Reading field boundaryU" << endl;
+    volVectorField boundaryU
+    (
+        IOobject
+        (
+            "boundaryU",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+    Info<< nl << "Reading field rhoN (number density)" << endl;
+    volScalarField rhoN
+    (
+        IOobject
+        (
+            "rhoN",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+    Info<< nl << "Reading field rhoM (mass density)" << endl;
+    volScalarField rhoM
+    (
+        IOobject
+        (
+            "rhoM",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+    Info<< nl << "Reading field rhoNdsmc (dsmc particle density)" << endl;
+    volScalarField dsmcRhoN
+    (
+        IOobject
+        (
+            "dsmcRhoN",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+    Info<< nl << "Reading field momentum (momentum density)" << endl;
+    volVectorField momentum
+    (
+        IOobject
+        (
+            "momentum",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+    Info<< nl << "Reading field linearKE (linear kinetic energy density)"
+        << endl;
+
+    volScalarField linearKE
+    (
+        IOobject
+        (
+            "linearKE",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+    Info<< nl << "Reading field internalE (internal energy density)" << endl;
+    volScalarField internalE
+    (
+        IOobject
+        (
+            "internalE",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+    Info<< nl << "Reading field iDof (internal degree of freedom density)"
+        << endl;
+
+    volScalarField iDof
+    (
+        IOobject
+        (
+            "iDof",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+    Info<< nl << "Reading field q (surface heat transfer)" << endl;
+    volScalarField q
+    (
+        IOobject
+        (
+            "q",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+    Info<< nl << "Reading field fD (surface force density)" << endl;
+    volVectorField fD
+    (
+        IOobject
+        (
+            "fD",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+    Info<< nl << "Constructing dsmcCloud " << endl;
+
+    dsmcCloud dsmc("dsmc", boundaryT, boundaryU);

applications/solvers/discreteMethods/dsmc/dsmcFoam/dsmcFoam.C

@@ -0,0 +1,105 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Application
+    dsmcFoam
+
+Description
+    Direct Simulation Monte Carlo Solver for 3D, transient, multi-species flows
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "dsmcCloud.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    #include "setRootCase.H"
+    #include "createTime.H"
+    #include "createMesh.H"
+    #include "createFields.H"
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    Info<< "\nStarting time loop\n" << endl;
+
+    while (runTime.run())
+    {
+        runTime++;
+
+        Info<< "Time = " << runTime.timeName() << nl << endl;
+
+        // Carry out dsmcCloud timestep
+
+        dsmc.evolve();
+
+        // Retrieve flow field data from dsmcCloud
+
+        rhoN = dsmc.rhoN();
+        rhoN.correctBoundaryConditions();
+
+        rhoM = dsmc.rhoM();
+        rhoM.correctBoundaryConditions();
+
+        dsmcRhoN = dsmc.dsmcRhoN();
+        dsmcRhoN.correctBoundaryConditions();
+
+        momentum = dsmc.momentum();
+        momentum.correctBoundaryConditions();
+
+        linearKE = dsmc.linearKE();
+        linearKE.correctBoundaryConditions();
+
+        internalE = dsmc.internalE();
+        internalE.correctBoundaryConditions();
+
+        iDof = dsmc.iDof();
+        iDof.correctBoundaryConditions();
+
+        // Retrieve surface field data from dsmcCloud
+
+        q = dsmc.q();
+
+        fD = dsmc.fD();
+
+        // Print status of dsmcCloud
+
+        dsmc.info();
+
+        runTime.write();
+
+        Info<< nl << "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
+            << "  ClockTime = " << runTime.elapsedClockTime() << " s"
+            << nl << endl;
+    }
+
+    Info<< "End\n" << endl;
+
+    return(0);
+}
+
+
+// ************************************************************************* //

applications/solvers/heatTransfer/buoyantPisoFoam/Make/options

@@ -1,7 +1,6 @@
 EXE_INC = \
     -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
-    -I../XiFoam \
     -I$(LIB_SRC)/finiteVolume/lnInclude
 
 EXE_LIBS = \

applications/solvers/heatTransfer/buoyantPisoFoam/buoyantPisoFoam.C

@@ -70,11 +70,12 @@ int main(int argc, char *argv[])
 
         #include "UEqn.H"
 
+        #include "hEqn.H"
+
         // --- PISO loop
 
         for (int corr=0; corr<nCorr; corr++)
         {
-            #include "hEqn.H"
             #include "pEqn.H"
         }
 

applications/solvers/heatTransfer/buoyantPisoFoam/createFields.H

@@ -53,12 +53,15 @@
     );
 
     Info<< "Creating field DpDt\n" << endl;
-    volScalarField DpDt =
-        fvc::DDt(surfaceScalarField("phiU", phi/fvc::interpolate(rho)), p);
+    volScalarField DpDt
+    (
+        "DpDt",
+        fvc::DDt(surfaceScalarField("phiU", phi/fvc::interpolate(rho)), p)
+    );
 
     Info<< "Calculating field g.h\n" << endl;
     volScalarField gh("gh", g & mesh.C());
-    surfaceScalarField ghf("gh", g & mesh.Cf());
+    surfaceScalarField ghf("ghf", g & mesh.Cf());
 
     dimensionedScalar pRef("pRef", p.dimensions(), thermo->lookup("pRef"));
 

applications/solvers/heatTransfer/buoyantPisoFoam/pEqn.H

@@ -12,8 +12,8 @@
     (
         fvc::interpolate(rho)
        *(
-           (fvc::interpolate(U) & mesh.Sf())
-         + fvc::ddtPhiCorr(rUA, rho, U, phi)
+            (fvc::interpolate(U) & mesh.Sf())
+          + fvc::ddtPhiCorr(rUA, rho, U, phi)
         )
     );
 

applications/solvers/heatTransfer/buoyantSimpleFoam/createFields.H

@@ -53,7 +53,7 @@
 
     Info<< "Calculating field g.h\n" << endl;
     volScalarField gh("gh", g & mesh.C());
-    surfaceScalarField ghf("gh", g & mesh.Cf());
+    surfaceScalarField ghf("ghf", g & mesh.Cf());
 
     dimensionedScalar pRef("pRef", p.dimensions(), thermo->lookup("pRef"));
 

applications/solvers/heatTransfer/buoyantSimpleFoam/pEqn.H

@@ -59,7 +59,8 @@
 
     rho = thermo->rho();
     rho.relax();
-    Info<< "rho max/min : " << max(rho).value() << " " << min(rho).value() << endl;
+    Info<< "rho max/min : " << max(rho).value() << " " << min(rho).value()
+        << endl;
 
     pd == p - (rho*gh + pRef);
 }

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

@@ -103,8 +103,8 @@ public:
             const dictionary&
         );
 
-        //- Construct by mapping given solidWallMixedTemperatureCoupledFvPatchScalarField
-        //  onto a new patch
+        //- Construct by mapping given
+        //  solidWallMixedTemperatureCoupledFvPatchScalarField onto a new patch
         solidWallMixedTemperatureCoupledFvPatchScalarField
         (
             const solidWallMixedTemperatureCoupledFvPatchScalarField&,

applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/setRegionFluidFields.H

@@ -4,7 +4,7 @@
     volScalarField& rho = rhoFluid[i];
     volScalarField& K = KFluid[i];
     volVectorField& U = UFluid[i];
-    surfaceScalarField phi = phiFluid[i];
+    surfaceScalarField& phi = phiFluid[i];
     compressible::turbulenceModel& turb = turbulence[i];
     volScalarField& DpDt = DpDtFluid[i];
     const volScalarField& gh = ghFluid[i];

applications/solvers/incompressible/pimpleDyMFoam/createFields.H

@@ -1,4 +1,3 @@
-
     Info<< "Reading field p\n" << endl;
     volScalarField p
     (
@@ -33,7 +32,7 @@
 
     label pRefCell = 0;
     scalar pRefValue = 0.0;
-    setRefCell(p, mesh.solutionDict().subDict("PISO"), pRefCell, pRefValue);
+    setRefCell(p, mesh.solutionDict().subDict("PIMPLE"), pRefCell, pRefValue);
 
     singlePhaseTransportModel laminarTransport(U, phi);
 

applications/solvers/incompressible/pimpleDyMFoam/pimpleDyMFoam.C

@@ -23,7 +23,7 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Application
-    turbDyMFoam
+    pimpleDyMFoam.C
 
 Description
     Transient solver for incompressible, flow of Newtonian fluids
@@ -47,7 +47,7 @@ int main(int argc, char *argv[])
 
 #   include "createTime.H"
 #   include "createDynamicFvMesh.H"
-#   include "readPISOControls.H"
+#   include "readPIMPLEControls.H"
 #   include "initContinuityErrs.H"
 #   include "createFields.H"
 #   include "readTimeControls.H"

applications/solvers/incompressible/pimpleDyMFoam/readControls.H

@@ -1,14 +1,14 @@
 #   include "readTimeControls.H"
-#   include "readPISOControls.H"
+#   include "readPIMPLEControls.H"
 
     bool correctPhi = false;
-    if (piso.found("correctPhi"))
+    if (pimple.found("correctPhi"))
     {
-        correctPhi = Switch(piso.lookup("correctPhi"));
+        correctPhi = Switch(pimple.lookup("correctPhi"));
     }
 
     bool checkMeshCourantNo = false;
-    if (piso.found("checkMeshCourantNo"))
+    if (pimple.found("checkMeshCourantNo"))
     {
-        checkMeshCourantNo = Switch(piso.lookup("checkMeshCourantNo"));
+        checkMeshCourantNo = Switch(pimple.lookup("checkMeshCourantNo"));
     }

applications/solvers/multiphase/interFoam/createFields.H

@@ -85,7 +85,7 @@
 
     Info<< "Calculating field g.h\n" << endl;
     volScalarField gh("gh", g & mesh.C());
-    surfaceScalarField ghf("gh", g & mesh.Cf());
+    surfaceScalarField ghf("ghf", g & mesh.Cf());
 
 
     volScalarField p

applications/solvers/multiphase/multiphaseInterFoam/createFields.H

@@ -47,7 +47,7 @@
 
     Info<< "Calculating field g.h\n" << endl;
     volScalarField gh("gh", g & mesh.C());
-    surfaceScalarField ghf("gh", g & mesh.Cf());
+    surfaceScalarField ghf("ghf", g & mesh.Cf());
 
 
     volScalarField p

applications/solvers/multiphase/settlingFoam/createFields.H

@@ -339,4 +339,4 @@
     );
 
     Info<< "Calculating field (g.h)f\n" << endl;
-    surfaceScalarField ghf = surfaceScalarField("gh", g & mesh.Cf());
+    surfaceScalarField ghf = surfaceScalarField("ghf", g & mesh.Cf());

applications/test/List/ListTest.C

@@ -43,24 +43,33 @@ using namespace Foam;
 
 int main(int argc, char *argv[])
 {
-    List<vector> list(IStringStream("1 ((0 1 2))")());
-    Info<< list << endl;
+    List<vector> list1(IStringStream("1 ((0 1 2))")());
+    Info<< "list1: " << list1 << endl;
 
-    List<vector> list2(IStringStream("((0 1 2) (3 4 5) (3 4 5))")());
-    Info<< list2 << endl;
+    List<vector> list2(IStringStream("((0 1 2) (3 4 5) (6 7 8))")());
+    Info<< "list2: " << list2 << endl;
+
+    list1.append(list2);
+    Info<< "list1.append(list2): " << list1 << endl;
 
     Info<< findIndex(list2, vector(3, 4, 5)) << endl;
 
     list2.setSize(10, vector(1, 2, 3));
-    Info<< list2 << endl;
+    Info<< "list2: " << list2 << endl;
 
     List<vector> list3(list2.xfer());
     Info<< "Transferred via the xfer() method" << endl;
-    Info<< list2 << nl
-        << list3 << endl;
+    Info<< "list2: " << list2 << nl
+        << "list3: " << list3 << endl;
+
+
+    // Subset
+    const labelList map(IStringStream("2 (0 2)")());
+    List<vector> subList3(list3, map);
+    Info<< "Elements " << map << " out of " << list3
+        << " => " << subList3 << endl;
 
     return 0;
 }
 
-
 // ************************************************************************* //

applications/test/UIndirectListTest/Make/files

@@ -0,0 +1,3 @@
+UIndirectListTest.C
+
+EXE = $(FOAM_USER_APPBIN)/UIndirectListTest

applications/test/UIndirectListTest/UIndirectListTest.C

@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#include "UIndirectList.H"
+#include "IOstreams.H"
+#include "ListOps.H"
+#include "OFstream.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Main program:
+
+int main(int argc, char *argv[])
+{
+    List<double> completeList(10);
+
+    forAll(completeList, i)
+    {
+        completeList[i] = 0.1*i;
+    }
+
+    List<label> addresses(5);
+    addresses[0] = 1;
+    addresses[1] = 0;
+    addresses[2] = 7;
+    addresses[3] = 8;
+    addresses[4] = 5;
+
+    UIndirectList<double> idl(completeList, addresses);
+
+    Info<< idl << "\n";
+
+    idl[1] = -666;
+
+    Info<< "idl[1] changed:" << idl << endl;
+
+    idl = -999;
+
+    Info<< "idl changed:" << idl << endl;
+
+    UIndirectList<double> idl2(idl);
+
+    Info<< "idl2: " << idl2 << endl;
+
+
+    {
+        List<double> ident(idl.size());
+
+        forAll(ident, i)
+        {
+            ident[i] = ident.size() - i;
+        }
+        idl = ident;
+    }
+
+    Info<< "idl assigned from UList:" << idl << endl;
+
+    List<double> realList = UIndirectList<double>(completeList, addresses);
+
+    Info<< "realList:" << realList << endl;
+
+    List<double> realList2(UIndirectList<double>(completeList, addresses));
+
+    Info<< "realList2:" << realList2 << endl;
+
+
+    Info << "\nEnd\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/test/string/stringTest.C

@@ -70,6 +70,28 @@ int main(int argc, char *argv[])
     string test2("~OpenFOAM/controlDict");
     Info<< test2 << " => " << test2.expand() << endl;
 
+    // replace controlDict with "newName"
+    {
+        string::size_type i = test2.rfind('/');
+
+        if (i == string::npos)
+        {
+            test2 = "newName";
+        }
+        else
+        {
+            // this uses the std::string::replace
+            test2.replace(i+1, string::npos, "newName");
+        }
+        Info<< "after replace: " << test2 << endl;
+
+        // do another replace
+        // this uses the Foam::string::replace
+        test2.replace("OpenFOAM", "openfoam");
+
+        Info<< "after replace: " << test2 << endl;
+    }
+
     string s;
     Sin.getLine(s);
 
@@ -78,8 +100,7 @@ int main(int argc, char *argv[])
     cout<< "output string with " << s2.length() << " characters\n";
     cout<< "ostream<<  >" << s2 << "<\n";
     Info<< "Ostream<<  >" << s2 << "<\n";
-    Info<< "hash:" << unsigned(string::hash()(s2)) << endl;
-
+    Info<< "hash:" << hex << string::hash()(s2) << endl;
 
     Info << "End\n" << endl;
 

applications/test/volPointInterpolation/volPointInterpolationTest.C

@@ -68,8 +68,7 @@ int main(int argc, char *argv[])
         mesh
     );
 
-    pointMesh pMesh(mesh);
-    volPointInterpolation pInterp(mesh, pMesh);
+    const volPointInterpolation& pInterp = volPointInterpolation::New(mesh);
 
     pointScalarField pp(pInterp.interpolate(p));
     pp.write();

applications/utilities/errorEstimation/estimateScalarError/estimateScalarError.C

@@ -39,24 +39,17 @@ Description
 
 int main(int argc, char *argv[])
 {
+    timeSelector::addOptions();
 
-#   include "addTimeOptions.H"
 #   include "setRootCase.H"
-
-    Info<< "\nEstimating error in scalar transport equation\n" << endl;
-
 #   include "createTime.H"
 
-    // Get times list
-    instantList Times = runTime.times();
-
-#   include "checkTimeOptions.H"
-
-    runTime.setTime(Times[startTime], startTime);
+    instantList timeDirs = timeSelector::select0(runTime, args);
 
 #   include "createMesh.H"
 
-    Info<< "Reading transportProperties\n" << endl;
+    Info<< "\nEstimating error in scalar transport equation\n"
+        << "Reading transportProperties\n" << endl;
 
     IOdictionary transportProperties
     (
@@ -79,9 +72,9 @@ int main(int argc, char *argv[])
     );
 
 
-    for (label i=startTime; i<endTime; i++)
+    forAll(timeDirs, timeI)
     {
-        runTime.setTime(Times[i], i);
+        runTime.setTime(timeDirs[timeI], timeI);
 
         Info<< "Time = " << runTime.timeName() << endl;
 

applications/utilities/errorEstimation/icoErrorEstimate/icoErrorEstimate.C

@@ -38,25 +38,17 @@ Description
 
 int main(int argc, char *argv[])
 {
+    timeSelector::addOptions();
 
-#   include "addTimeOptions.H"
 #   include "setRootCase.H"
-
-    Info<< "\nEstimating error in the incompressible momentum equation\n"
-        << endl;
-
 #   include "createTime.H"
 
-    // Get times list
-    instantList Times = runTime.times();
-
-#   include "checkTimeOptions.H"
-
-    runTime.setTime(Times[startTime], startTime);
+    instantList timeDirs = timeSelector::select0(runTime, args);
 
 #   include "createMesh.H"
 
-    Info<< "Reading transportProperties\n" << endl;
+    Info<< "\nEstimating error in the incompressible momentum equation\n"
+        << "Reading transportProperties\n" << endl;
 
     IOdictionary transportProperties
     (
@@ -75,9 +67,9 @@ int main(int argc, char *argv[])
         transportProperties.lookup("nu")
     );
 
-    for (label i=startTime; i<endTime; i++)
+    forAll(timeDirs, timeI)
     {
-        runTime.setTime(Times[i], i);
+        runTime.setTime(timeDirs[timeI], timeI);
 
         Info<< "Time = " << runTime.timeName() << endl;
 

applications/utilities/errorEstimation/icoMomentError/icoMomentError.C

@@ -39,25 +39,17 @@ Description
 
 int main(int argc, char *argv[])
 {
+    timeSelector::addOptions();
 
-#   include "addTimeOptions.H"
 #   include "setRootCase.H"
-
-    Info<< "\nEstimating error in the incompressible momentum equation\n"
-        << endl;
-
 #   include "createTime.H"
 
-    // Get times list
-    instantList Times = runTime.times();
-
-#   include "checkTimeOptions.H"
-
-    runTime.setTime(Times[startTime], startTime);
+    instantList timeDirs = timeSelector::select0(runTime, args);
 
 #   include "createMesh.H"
 
-    Info<< "Reading transportProperties\n" << endl;
+    Info<< "\nEstimating error in the incompressible momentum equation\n"
+        << "Reading transportProperties\n" << endl;
 
     IOdictionary transportProperties
     (
@@ -76,9 +68,9 @@ int main(int argc, char *argv[])
         transportProperties.lookup("nu")
     );
 
-    for (label i=startTime; i<endTime; i++)
+    forAll(timeDirs, timeI)
     {
-        runTime.setTime(Times[i], i);
+        runTime.setTime(timeDirs[timeI], timeI);
 
         Info<< "Time = " << runTime.timeName() << endl;
 

applications/utilities/errorEstimation/momentScalarError/momentScalarError.C

@@ -40,24 +40,17 @@ Description
 
 int main(int argc, char *argv[])
 {
+    timeSelector::addOptions();
 
-#   include "addTimeOptions.H"
 #   include "setRootCase.H"
-
-    Info<< "\nEstimating error in scalar transport equation\n" << endl;
-
 #   include "createTime.H"
 
-    // Get times list
-    instantList Times = runTime.times();
-
-#   include "checkTimeOptions.H"
-
-    runTime.setTime(Times[startTime], startTime);
+    instantList timeDirs = timeSelector::select0(runTime, args);
 
 #   include "createMesh.H"
 
-    Info<< "Reading transportProperties\n" << endl;
+    Info<< "\nEstimating error in scalar transport equation\n"
+        << "Reading transportProperties\n" << endl;
 
     IOdictionary transportProperties
     (
@@ -80,9 +73,9 @@ int main(int argc, char *argv[])
     );
 
 
-    for (label i=startTime; i<endTime; i++)
+    forAll(timeDirs, timeI)
     {
-        runTime.setTime(Times[i], i);
+        runTime.setTime(timeDirs[timeI], timeI);
 
         Info<< "Time = " << runTime.timeName() << endl;
 

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

@@ -177,7 +177,7 @@ label mergePatchFaces
         List<faceList> allFaceSetsFaces(allFaceSets.size());
         forAll(allFaceSets, setI)
         {
-            allFaceSetsFaces[setI] = IndirectList<face>
+            allFaceSetsFaces[setI] = UIndirectList<face>
             (
                 mesh.faces(),
                 allFaceSets[setI]

applications/utilities/mesh/advanced/refineHexMesh/refineHexMesh.C

@@ -182,6 +182,7 @@ int main(int argc, char *argv[])
     if (overwrite)
     {
         mesh.setInstance(oldInstance);
+        meshCutter.setInstance(oldInstance);
     }
     Info<< "Writing mesh to " << runTime.timeName() << endl;
 

applications/utilities/mesh/conversion/foamToStarMesh/foamToStarMesh.C

@@ -61,6 +61,7 @@ See Also
 \*---------------------------------------------------------------------------*/
 
 #include "argList.H"
+#include "timeSelector.H"
 #include "Time.H"
 #include "polyMesh.H"
 #include "STARCDMeshWriter.H"
@@ -73,20 +74,17 @@ using namespace Foam;
 int main(int argc, char *argv[])
 {
     argList::noParallel();
+    timeSelector::addOptions();
+
     argList::validOptions.insert("scale", "scale");
     argList::validOptions.insert("noBnd", "");
     argList::validOptions.insert("tri", "");
     argList::validOptions.insert("surface", "");
 
-#   include "addTimeOptions.H"
 #   include "setRootCase.H"
 #   include "createTime.H"
-    // Get times list
-    instantList Times = runTime.times();
 
-    // set startTime and endTime depending on -time and -latestTime options
-#   include "checkTimeOptions.H"
-    runTime.setTime(Times[startTime], startTime);
+    instantList timeDirs = timeSelector::select0(runTime, args);
 
     bool surfaceOnly = false;
     if (args.options().found("surface") or args.options().found("tri"))
@@ -118,17 +116,16 @@ int main(int argc, char *argv[])
 
 #   include "createPolyMesh.H"
 
-    // bool firstCheck = true;
 
-    for (label timeI = startTime; timeI < endTime; ++timeI)
+    forAll(timeDirs, timeI)
     {
-        runTime.setTime(Times[timeI], timeI);
+        runTime.setTime(timeDirs[timeI], timeI);
 
 #       include "getTimeIndex.H"
 
         polyMesh::readUpdateState state = mesh.readUpdate();
 
-        if (timeI == startTime || state != polyMesh::UNCHANGED)
+        if (!timeI || state != polyMesh::UNCHANGED)
         {
             meshWriters::STARCD writer(mesh, scaleFactor);
 

applications/utilities/mesh/conversion/polyDualMesh/Make/files

@@ -1,4 +1,4 @@
 meshDualiser.C
-makePolyDualMesh.C
+polyDualMeshApp.C
 
 EXE = $(FOAM_APPBIN)/polyDualMesh

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

@@ -76,7 +76,7 @@ void Foam::meshDualiser::checkPolyTopoChange(const polyTopoChange& meshMod)
                     "meshDualiser::checkPolyTopoChange(const polyTopoChange&)"
                 )   << "duplicate verts:" << newToOld[newI]
                     << " coords:"
-                    << IndirectList<point>(points, newToOld[newI])()
+                    << UIndirectList<point>(points, newToOld[newI])()
                     << abort(FatalError);
             }
         }
@@ -226,10 +226,7 @@ Foam::label Foam::meshDualiser::addInternalFace
 
     if (debug)
     {
-        pointField facePoints
-        (
-            IndirectList<point>(meshMod.points(), newFace)()
-        );
+        pointField facePoints(meshMod.points(), newFace);
 
         labelList oldToNew;
         pointField newPoints;
@@ -289,7 +286,7 @@ Foam::label Foam::meshDualiser::addInternalFace
         //n /= mag(n);
         //Pout<< "Generated internal dualFace:" << dualFaceI
         //    << " verts:" << newFace
-        //    << " points:" << IndirectList<point>(meshMod.points(), newFace)()
+        //    << " points:" << UIndirectList<point>(meshMod.points(), newFace)()
         //    << " n:" << n
         //    << " between dualowner:" << dualCell0
         //    << " dualneigbour:" << dualCell1
@@ -316,7 +313,7 @@ Foam::label Foam::meshDualiser::addInternalFace
         //n /= mag(n);
         //Pout<< "Generated internal dualFace:" << dualFaceI
         //    << " verts:" << newFace
-        //    << " points:" << IndirectList<point>(meshMod.points(), newFace)()
+        //    << " points:" << UIndirectList<point>(meshMod.points(), newFace)()
         //    << " n:" << n
         //    << " between dualowner:" << dualCell1
         //    << " dualneigbour:" << dualCell0
@@ -373,7 +370,7 @@ Foam::label Foam::meshDualiser::addBoundaryFace
     //n /= mag(n);
     //Pout<< "Generated boundary dualFace:" << dualFaceI
     //    << " verts:" << newFace
-    //    << " points:" << IndirectList<point>(meshMod.points(), newFace)()
+    //    << " points:" << UIndirectList<point>(meshMod.points(), newFace)()
     //    << " n:" << n
     //    << " on dualowner:" << dualCellI
     //    << endl;
@@ -568,7 +565,7 @@ void Foam::meshDualiser::createFaceFromInternalFace
 
     //Pout<< "createFaceFromInternalFace : At face:" << faceI
     //    << " verts:" << f
-    //    << " points:" << IndirectList<point>(mesh_.points(), f)()
+    //    << " points:" << UIndirectList<point>(mesh_.points(), f)()
     //    << " started walking at edge:" << fEdges[fp]
     //    << " verts:" << mesh_.edges()[fEdges[fp]]
     //    << endl;
@@ -617,7 +614,7 @@ void Foam::meshDualiser::createFaceFromInternalFace
             {
                 FatalErrorIn("createFacesFromInternalFace(..)")
                     << "face:" << faceI << " verts:" << f
-                    << " points:" << IndirectList<point>(mesh_.points(), f)()
+                    << " points:" << UIndirectList<point>(mesh_.points(), f)()
                     << " no feature edge between " << f[fp]
                     << " and " << f[nextFp] << " although have different"
                     << " dual cells." << endl

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

@@ -348,8 +348,10 @@ int main(int argc, char *argv[])
 
 #   include "setRootCase.H"
 #   include "createTime.H"
+
     // Get times list
     instantList Times = runTime.times();
+
 #   include "checkTimeOptions.H"
     runTime.setTime(Times[startTime], startTime);
 
@@ -509,7 +511,7 @@ int main(int argc, char *argv[])
     Info<< "Writing dual mesh to " << runTime.timeName() << endl;
 
     mesh.write();
- 
+
     Info<< "End\n" << endl;
 
     return 0;

applications/utilities/mesh/conversion/writeMeshObj/writeMeshObj.C

@@ -37,6 +37,7 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "argList.H"
+#include "timeSelector.H"
 #include "Time.H"
 #include "polyMesh.H"
 #include "OFstream.H"
@@ -336,14 +337,15 @@ void writePointCells
 
 int main(int argc, char *argv[])
 {
+    timeSelector::addOptions();
     argList::validOptions.insert("patchFaces", "");
     argList::validOptions.insert("cell", "cellI");
     argList::validOptions.insert("face", "faceI");
     argList::validOptions.insert("point", "pointI");
     argList::validOptions.insert("cellSet", "setName");
     argList::validOptions.insert("faceSet", "setName");
+#   include "addRegionOption.H"
 
-#   include "addTimeOptions.H"
 #   include "setRootCase.H"
 #   include "createTime.H"
     runTime.functionObjects().off();
@@ -361,31 +363,23 @@ int main(int argc, char *argv[])
         << "(for points, faces, cells) is consistent with"
         << " Foam numbering (starting from 0)." << endl << endl;
 
-    // Get times list
-    instantList Times = runTime.times();
+    instantList timeDirs = timeSelector::select0(runTime, args);
 
-#   include "checkTimeOptions.H"
+#   include "createNamedPolyMesh.H"
 
-    runTime.setTime(Times[startTime], startTime);
-
-#   include "createPolyMesh.H"
-
-    bool firstCheck = true;
-
-    for (label i=startTime; i<endTime; i++)
+    forAll(timeDirs, timeI)
     {
-        runTime.setTime(Times[i], i);
+        runTime.setTime(timeDirs[timeI], timeI);
 
         Info<< "Time = " << runTime.timeName() << endl;
 
         polyMesh::readUpdateState state = mesh.readUpdate();
 
-        if (firstCheck || state != polyMesh::UNCHANGED)
+        if (!timeI || state != polyMesh::UNCHANGED)
         {
             if (patchFaces)
             {
                 writePatchFaces(mesh, runTime.timeName());
-
             }
             else if (doCell)
             {
@@ -487,9 +481,7 @@ int main(int argc, char *argv[])
             Info << "No mesh." << endl;
         }
 
-        firstCheck = false;
-
-        Info << endl << endl;
+        Info << nl << endl;
     }
 
 

applications/utilities/mesh/generation/blockMesh/curvedEdges/arcEdge.C

@@ -30,8 +30,7 @@ Description
 
 #include "arcEdge.H"
 #include "mathematicalConstants.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+#include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -40,8 +39,7 @@ namespace Foam
     defineTypeNameAndDebug(arcEdge, 0);
 
     // Add the curvedEdge constructor functions to the hash tables
-    curvedEdge::addIstreamConstructorToTable<arcEdge>
-        addArcEdgeIstreamConstructorToTable_;
+    addToRunTimeSelectionTable(curvedEdge, arcEdge, Istream);
 }
 
 

applications/utilities/mesh/generation/blockMesh/curvedEdges/curvedEdge.C

@@ -41,26 +41,7 @@ namespace Foam
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 defineTypeNameAndDebug(curvedEdge, 0);
-
-// Define the constructor function hash tables
-HashTable<curvedEdge::IstreamConstructorPtr_>*
-    curvedEdge::IstreamConstructorTablePtr_;
-
-
-// Hash table Constructor called from the table add functions.
-
-void curvedEdge::constructTables()
-{
-    static bool constructed = false;
-
-    if (!constructed)
-    {
-        curvedEdge::IstreamConstructorTablePtr_
-            = new HashTable<curvedEdge::IstreamConstructorPtr_>;
-
-        constructed = true;
-    }
-}
+defineRunTimeSelectionTable(curvedEdge, Istream);
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
@@ -117,10 +98,11 @@ autoPtr<curvedEdge> curvedEdge::New(const pointField& points, Istream& is)
 
     word curvedEdgeType(is);
 
-    HashTable<IstreamConstructorPtr_>::iterator curvedEdgeConstructorIter =
-        IstreamConstructorTablePtr_->find(curvedEdgeType);
+    IstreamConstructorTable::iterator cstrIter =
+        IstreamConstructorTablePtr_
+            ->find(curvedEdgeType);
 
-    if (curvedEdgeConstructorIter == IstreamConstructorTablePtr_->end())
+    if (cstrIter == IstreamConstructorTablePtr_->end())
     {
         FatalErrorIn("curvedEdge::New(const pointField&, Istream&)")
             << "Unknown curvedEdge type " << curvedEdgeType << endl << endl
@@ -129,7 +111,7 @@ autoPtr<curvedEdge> curvedEdge::New(const pointField& points, Istream& is)
             << abort(FatalError);
     }
 
-    return autoPtr<curvedEdge>(curvedEdgeConstructorIter()(points, is));
+    return autoPtr<curvedEdge>(cstrIter()(points, is));
 }
 
 
@@ -177,7 +159,6 @@ Ostream& operator<<(Ostream& os, const curvedEdge& p)
 }
 
 
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

applications/utilities/mesh/generation/blockMesh/curvedEdges/curvedEdge.H

@@ -63,51 +63,23 @@ protected:
 
 public:
 
-    // Constructor Hash tables
-
-        //- Construct from Istream function pointer type
-        typedef autoPtr<curvedEdge> (*IstreamConstructorPtr_)
-            (const pointField&, Istream&);
-
-        //- Construct from Istream function pointer table pointer
-        static HashTable<IstreamConstructorPtr_>*
-            IstreamConstructorTablePtr_;
+    //- Runtime type information
+    TypeName("curvedEdge");
 
 
-    // Hash table constructor classes and functions
+    // Declare run-time constructor selection tables
 
-        //- Hash table Constructor.
-        //  Must be called from the table add functions below.
-        static void constructTables();
-
-
-        //- Class to add constructor from Istream to Hash table
-        template<class curvedEdgeType>
-        class addIstreamConstructorToTable
-        {
-        public:
-
-            static autoPtr<curvedEdge> New
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            curvedEdge,
+            Istream,
             (
                 const pointField& points,
                 Istream& is
-            )
-            {
-                return autoPtr<curvedEdge>(new curvedEdgeType(points, is));
-            }
-
-            addIstreamConstructorToTable()
-            {
-                curvedEdge::constructTables();
-
-                curvedEdge::IstreamConstructorTablePtr_
-                    ->insert(curvedEdgeType::typeName, New);
-            }
-        };
-
-
-    //- Runtime type information
-    TypeName("curvedEdge");
+            ),
+            (points, is)
+        );
 
 
     // Constructors

applications/utilities/mesh/generation/blockMesh/curvedEdges/polySplineEdge.C

@@ -26,6 +26,7 @@ License
 
 #include "polySplineEdge.H"
 #include "BSpline.H"
+#include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -34,8 +35,7 @@ namespace Foam
     defineTypeNameAndDebug(polySplineEdge, 0);
 
     // Add the curvedEdge constructor functions to the hash tables
-    curvedEdge::addIstreamConstructorToTable<polySplineEdge>
-        addPolySplineEdgeIstreamConstructorToTable_;
+    addToRunTimeSelectionTable(curvedEdge, polySplineEdge, Istream);
 }
 
 

applications/utilities/mesh/generation/blockMesh/curvedEdges/polySplineEdge.H

@@ -92,7 +92,7 @@ public:
         );
 
         //- Construct from Istream setting pointsList
-        polySplineEdge(const pointField& points,Istream& is);
+        polySplineEdge(const pointField& points, Istream& is);
 
 
     // Destructor

applications/utilities/mesh/generation/blockMesh/curvedEdges/simpleSplineEdge.C

@@ -27,9 +27,8 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
-#include "error.H"
-
 #include "simpleSplineEdge.H"
+#include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -39,10 +38,8 @@ namespace Foam
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 defineTypeNameAndDebug(simpleSplineEdge, 0);
+addToRunTimeSelectionTable(curvedEdge, simpleSplineEdge, Istream);
 
-// Add the curvedEdge constructor functions to the hash tables
-curvedEdge::addIstreamConstructorToTable<simpleSplineEdge>
-    addSimpleSplineEdgeIstreamConstructorToTable_;
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 

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

@@ -52,19 +52,18 @@ using namespace Foam;
 
 int main(int argc, char *argv[])
 {
-#   include "setRoots.H"
-#   include "createTimeExtruded.H"
+    #include "setRoots.H"
+    #include "createTimeExtruded.H"
 
-
-    if (args.options().found("sourceRoot") == args.options().found("surface"))
+    if (args.options().found("sourceCase") == args.options().found("surface"))
     {
         FatalErrorIn(args.executable())
-            << "Need to specify either -sourceRoot/Case/Patch or -surface"
-            << " option to specify the source of the patch to extrude"
+            << "Specify either -sourceCase and -sourcePatch"
+               " or -surface options\n"
+               "    to specify the source of the patch to extrude"
             << exit(FatalError);
     }
 
-
     autoPtr<extrudedMesh> meshPtr(NULL);
 
     autoPtr<extrudeModel> model
@@ -84,23 +83,24 @@ int main(int argc, char *argv[])
         )
     );
 
-    if (args.options().found("sourceRoot"))
+    if (args.options().found("sourceCase"))
     {
-        fileName rootDirSource(args.options()["sourceRoot"]);
-        fileName caseDirSource(args.options()["sourceCase"]);
-        fileName patchName(args.options()["sourcePatch"]);
+        fileName sourceCasePath(args.options()["sourceCase"]);
+        fileName sourceRootDir = sourceCasePath.path();
+        fileName sourceCaseDir = sourceCasePath.name();
+        word patchName(args.options()["sourcePatch"]);
 
         Info<< "Extruding patch " << patchName
-            << " on mesh " << rootDirSource << ' ' << caseDirSource << nl
+            << " on mesh " << sourceCasePath << nl
             << endl;
 
         Time runTime
         (
             Time::controlDictName,
-            rootDirSource,
-            caseDirSource
+            sourceRootDir,
+            sourceCaseDir
         );
-#       include "createPolyMesh.H"
+        #include "createPolyMesh.H"
 
         label patchID = mesh.boundaryMesh().findPatchID(patchName);
 
@@ -171,7 +171,7 @@ int main(int argc, char *argv[])
                 fMesh,
                 model()
             )
-        );        
+        );
     }
     extrudedMesh& mesh = meshPtr();
 
@@ -180,7 +180,7 @@ int main(int argc, char *argv[])
     const vector span = bb.span();
     const scalar mergeDim = 1E-4 * bb.minDim();
 
-    Pout<< "Mesh bounding box:" << bb << nl
+    Info<< "Mesh bounding box:" << bb << nl
         << "        with span:" << span << nl
         << "Merge distance   :" << mergeDim << nl
         << endl;
@@ -201,7 +201,7 @@ int main(int argc, char *argv[])
     // ~~~~~~~~~~~~~~
 
     {
-        Pout<< "Collapsing edges < " << mergeDim << " ..." << nl << endl;
+        Info<< "Collapsing edges < " << mergeDim << " ..." << nl << endl;
 
         // Edge collapsing engine
         edgeCollapser collapser(mesh);
@@ -217,7 +217,7 @@ int main(int argc, char *argv[])
 
             if (d < mergeDim)
             {
-                Pout<< "Merging edge " << e << " since length " << d
+                Info<< "Merging edge " << e << " since length " << d
                     << " << " << mergeDim << nl;
 
                 // Collapse edge to e[0]
@@ -252,8 +252,8 @@ int main(int argc, char *argv[])
 
     if (args.options().found("mergeFaces"))
     {
-        Pout<< "Assuming full 360 degree axisymmetric case;"
-            << " stitching faces on patches " 
+        Info<< "Assuming full 360 degree axisymmetric case;"
+            << " stitching faces on patches "
             << patches[origPatchID].name() << " and "
             << patches[otherPatchID].name() << " together ..." << nl << endl;
 

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

@@ -48,7 +48,7 @@ wedge::wedge(const dictionary& dict)
 :
     extrudeModel(typeName, dict),
     axisPt_(coeffDict_.lookup("axisPt")),
-    axisNormal_(coeffDict_.lookup("axisNormal")),
+    axis_(coeffDict_.lookup("axis")),
     angle_
     (
         readScalar(coeffDict_.lookup("angle"))
@@ -96,7 +96,7 @@ point wedge::operator()
     // of surface point and surface normal.
     point d = surfacePoint - axisPt_;
 
-    d -= (axisNormal_ & d)*axisNormal_;
+    d -= (axis_ & d)*axis_;
 
     scalar dMag = mag(d);
 
@@ -107,7 +107,7 @@ point wedge::operator()
 
     if (dMag > VSMALL)
     {
-        vector n = (d/dMag) ^ axisNormal_;
+        vector n = (d/dMag) ^ axis_;
 
         rotatedPoint +=
           + cos(sliceAngle)*d
@@ -124,4 +124,3 @@ point wedge::operator()
 } // End namespace Foam
 
 // ************************************************************************* //
-

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

@@ -60,13 +60,13 @@ class wedge
 {
     // Private data
 
-        //- point on axis
+        //- Point on axis
         const point axisPt_;
 
-        //- normalized direction of axis
-        const vector axisNormal_;
+        //- Normalized direction of axis
+        const vector axis_;
 
-        //- overall angle (radians)
+        //- Overall angle (radians)
         const scalar angle_;
 
 
@@ -80,6 +80,7 @@ public:
         //- Construct from components
         wedge(const dictionary& dict);
 
+
     //- Destrcuctor
     ~wedge();
 

applications/utilities/mesh/generation/extrudeMesh/extrudeProperties

@@ -24,7 +24,7 @@ nLayers             1;
 wedgeCoeffs
 {
     axisPt          (0 0 0);
-    axisNormal      (0 -1 0);
+    axis            (0 -1 0);
     angle           2.0;
 }
 
@@ -47,4 +47,3 @@ sigmaRadialCoeffs
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-

applications/utilities/mesh/generation/extrudeMesh/setRoots.H

@@ -1,7 +1,6 @@
     argList::validArgs.clear();
     argList::noParallel();
 
-    argList::validOptions.insert("sourceRoot", "source root");
     argList::validOptions.insert("sourceCase", "source case");
     argList::validOptions.insert("sourcePatch", "source patch");
 
@@ -15,4 +14,3 @@
     {
          FatalError.exit();
     }
-

applications/utilities/mesh/generation/snappyHexMesh/Make/options

@@ -1,6 +1,6 @@
 EXE_INC = \
     /* -g -DFULLDEBUG -O0 */ \
-    -I$(LIB_SRC)/decompositionAgglomeration/decompositionMethods/lnInclude \
+    -I$(LIB_SRC)/decompositionMethods/decompositionMethods/lnInclude \
     -I$(LIB_SRC)/autoMesh/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/triSurface/lnInclude \
@@ -9,7 +9,6 @@ EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude
 
 EXE_LIBS = \
-    -L$(FOAM_MPI_LIBBIN) -lparMetisDecompositionMethod \
     -lfiniteVolume \
     -ldecompositionMethods \
     -lmeshTools \

applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict

@@ -274,6 +274,14 @@ addLayersControls
 
     // Create buffer region for new layer terminations
     nBufferCellsNoExtrude 0;
+
+
+    // Overall max number of layer addition iterations
+    nLayerIter 50;
+
+    // Max number of iterations after which relaxed meshQuality controls
+    // get used.
+    nRelaxedIter 20;
 }
 
 
@@ -335,6 +343,16 @@ meshQualityControls
     nSmoothScale 4;
     //- amount to scale back displacement at error points
     errorReduction 0.75;
+
+
+
+    // Optional : some meshing phases allow usage of relaxed rules.
+    // See e.g. addLayersControls::nRelaxedIter.
+    relaxed
+    {
+        //- Maximum non-orthogonality allowed. Set to 180 to disable.
+        maxNonOrtho 75;
+    }
 }
 
 

applications/utilities/mesh/manipulation/checkMesh/checkMesh.C

@@ -31,7 +31,9 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "argList.H"
+#include "timeSelector.H"
 #include "Time.H"
+
 #include "polyMesh.H"
 #include "globalMeshData.H"
 
@@ -45,48 +47,34 @@ using namespace Foam;
 
 int main(int argc, char *argv[])
 {
+    timeSelector::addOptions(false);   // no constant
 #   include "addRegionOption.H"
-
-#   include "addTimeOptionsNoConstant.H"
-
     argList::validOptions.insert("noTopology", "");
     argList::validOptions.insert("allGeometry", "");
     argList::validOptions.insert("allTopology", "");
 
 #   include "setRootCase.H"
+#   include "createTime.H"
+    instantList timeDirs = timeSelector::select0(runTime, args);
+#   include "createNamedPolyMesh.H"
 
-    const bool noTopology = args.options().found("noTopology");
+    const bool noTopology  = args.options().found("noTopology");
     const bool allGeometry = args.options().found("allGeometry");
     const bool allTopology = args.options().found("allTopology");
 
-#   include "createTime.H"
-
-    // Get times list
-    instantList Times = runTime.times();
-
-#   include "checkTimeOptionsNoConstant.H"
-
-    runTime.setTime(Times[startTime], startTime);
-
-#   include "createNamedPolyMesh.H"
-
-    bool firstCheck = true;
-
-    for (label i=startTime; i<endTime; i++)
+    forAll(timeDirs, timeI)
     {
-        runTime.setTime(Times[i], i);
+        runTime.setTime(timeDirs[timeI], timeI);
 
         polyMesh::readUpdateState state = mesh.readUpdate();
 
         if
         (
-            firstCheck
+            !timeI
          || state == polyMesh::TOPO_CHANGE
          || state == polyMesh::TOPO_PATCH_CHANGE
         )
         {
-            firstCheck = false;
-
             Info<< "Time = " << runTime.timeName() << nl << endl;
 
             // Clear mesh before checking
@@ -110,32 +98,30 @@ int main(int argc, char *argv[])
 
             if (noFailedChecks == 0)
             {
-                Info<< "\nMesh OK."
-                    << nl << endl;
+                Info<< "\nMesh OK.\n" << endl;
             }
             else
             {
-                Info<< "\nFailed " << noFailedChecks << " mesh checks."
-                    << nl << endl;
+                Info<< "\nFailed " << noFailedChecks << " mesh checks.\n"
+                    << endl;
             }
         }
         else if (state == polyMesh::POINTS_MOVED)
         {
             Info<< "Time = " << runTime.timeName() << nl << endl;
 
-            label noFailedChecks = checkGeometry(mesh, allGeometry);
+            label nFailedChecks = checkGeometry(mesh, allGeometry);
 
-            reduce(noFailedChecks, sumOp<label>());
+            reduce(nFailedChecks, sumOp<label>());
 
-            if (noFailedChecks == 0)
+            if (nFailedChecks)
             {
-                Info << "\nMesh OK."
-                    << nl << endl;
+                Info<< "\nFailed " << nFailedChecks << " mesh checks.\n"
+                    << endl;
             }
             else
             {
-                Info<< "\nFailed " << noFailedChecks << " mesh checks."
-                    << nl << endl;
+                Info << "\nMesh OK.\n" << endl;
             }
         }
     }

applications/utilities/mesh/manipulation/createBaffles/createBaffles.C

@@ -54,6 +54,7 @@ int main(int argc, char *argv[])
 {
     argList::validArgs.append("set");
     argList::validArgs.append("patch");
+    argList::validOptions.insert("additionalPatches", "(patch2 .. patchN)");
     argList::validOptions.insert("overwrite", "");
 
 #   include "setRootCase.H"
@@ -67,25 +68,61 @@ int main(int argc, char *argv[])
 
     // Faces to baffle
     word setName(args.additionalArgs()[0]);
-    Pout<< "Reading faceSet from " << setName << nl << endl;
+    Info<< "Reading faceSet from " << setName << nl << endl;
     faceSet facesToSplit(mesh, setName);
-    Pout<< "Read " << facesToSplit.size() << " faces from " << setName
-        << nl << endl;
+    // Make sure set is synchronised across couples
+    facesToSplit.sync(mesh);
+    Info<< "Read " << returnReduce(facesToSplit.size(), sumOp<label>())
+        << " faces from " << setName << nl << endl;
+
+
+    // Patches to put baffles into
+    labelList newPatches(1);
 
-    // Patch to put them into
     word patchName(args.additionalArgs()[1]);
-    label wantedPatchI = patches.findPatchID(patchName);
+    newPatches[0] = patches.findPatchID(patchName);
+    Info<< "Using patch " << patchName
+        << " at index " << newPatches[0] << endl;
 
-    Pout<< "Using patch " << patchName << " at index " << wantedPatchI << endl;
-
-    if (wantedPatchI == -1)
+    if (newPatches[0] == -1)
     {
         FatalErrorIn(args.executable())
-            << "Cannot find patch " << patchName << exit(FatalError);
+            << "Cannot find patch " << patchName << endl
+            << "Valid patches are " << patches.names() << exit(FatalError);
     }
 
+
+    // Additional patches
+    if (args.options().found("additionalPatches"))
+    {
+        const wordList patchNames
+        (
+            IStringStream(args.options()["additionalPatches"])()
+        );
+
+        forAll(patchNames, i)
+        {
+            label patchI = patches.findPatchID(patchNames[i]);
+            Info<< "Using additional patch " << patchNames[i]
+                << " at index " << patchI << endl;
+
+            if (patchI == -1)
+            {
+                FatalErrorIn(args.executable())
+                    << "Cannot find patch " << patchNames[i] << endl
+                    << "Valid patches are " << patches.names()
+                    << exit(FatalError);
+            }
+
+            newPatches.append(patchI);
+        }
+    }
+
+
     bool overwrite = args.options().found("overwrite");
 
+
+
     // Read objects in time directory
     IOobjectList objects(mesh, runTime.timeName());
 
@@ -128,107 +165,186 @@ int main(int argc, char *argv[])
     polyTopoChange meshMod(mesh);
 
 
-    // Creating baffles:
-    // - coupled boundary faces : become the patch specified
-    // - non-coupled ,,         : illegal
-    // - internal faces         : converted into boundary faces.
-
-    labelList newPatch(mesh.nFaces(), -1);
-
-    forAllConstIter(faceSet, facesToSplit, iter)
-    {
-        label faceI = iter.key();
-
-        label patchI = patches.whichPatch(faceI);
-
-        if (patchI == -1)
-        {
-            newPatch[faceI] = wantedPatchI;
-        }
-        else
-        {
-            if (patches[patchI].coupled())
-            {
-                if (patchI != wantedPatchI)
-                {
-                    newPatch[faceI] = wantedPatchI;
-                }
-            }
-            else
-            {
-                FatalErrorIn(args.executable())
-                    << "Can only create baffles from internal faces"
-                    << " or coupled boundary faces." << endl
-                    << "Face " << faceI << " is a boundary face on patch "
-                    << patches[patchI].name() << exit(FatalError);
-            }
-        }
-    }
-
-
-    // If one side of a coupled boundary is marked for baffling, make sure to
-    // also do the other side.
-
-    syncTools::syncFaceList(mesh, newPatch, maxEqOp<label>(), false);
-
+    // Do the actual changes
+    // Note order in which faces are modified/added is so they end up correctly
+    // for cyclic patches (original faces first and then reversed faces)
+    // since otherwise it will have trouble matching baffles.
 
     label nBaffled = 0;
-
-    forAll(newPatch, faceI)
+ 
+    forAll(newPatches, i)
     {
-        if (newPatch[faceI] != -1)
+        label newPatchI = newPatches[i];
+
+        for (label faceI = 0; faceI < mesh.nInternalFaces(); faceI++)
         {
-            const face& f = mesh.faces()[faceI];
-            label zoneID = faceZones.whichZone(faceI);
-            bool zoneFlip = false;
-            if (zoneID >= 0)
+            if (facesToSplit.found(faceI))
             {
-                const faceZone& fZone = faceZones[zoneID];
-                zoneFlip = fZone.flipMap()[fZone.whichFace(faceI)];
+                const face& f = mesh.faces()[faceI];
+                label zoneID = faceZones.whichZone(faceI);
+                bool zoneFlip = false;
+                if (zoneID >= 0)
+                {
+                    const faceZone& fZone = faceZones[zoneID];
+                    zoneFlip = fZone.flipMap()[fZone.whichFace(faceI)];
+                }
+
+                if (i == 0)
+                {
+                    // First usage of face. Modify.
+                    meshMod.setAction
+                    (
+                        polyModifyFace
+                        (
+                            f,                          // modified face
+                            faceI,                      // label of face
+                            mesh.faceOwner()[faceI],    // owner
+                            -1,                         // neighbour
+                            false,                      // face flip
+                            newPatchI,                  // patch for face
+                            false,                      // remove from zone
+                            zoneID,                     // zone for face
+                            zoneFlip                    // face flip in zone
+                        )
+                    );
+                }
+                else
+                {
+                    // Second or more usage of face. Add.
+                    meshMod.setAction
+                    (
+                        polyAddFace
+                        (
+                            f,                          // modified face
+                            mesh.faceOwner()[faceI],    // owner
+                            -1,                         // neighbour
+                            -1,                         // master point
+                            -1,                         // master edge
+                            faceI,                      // master face
+                            false,                      // face flip
+                            newPatchI,                  // patch for face
+                            zoneID,                     // zone for face
+                            zoneFlip                    // face flip in zone
+                        )
+                    );
+                }
+
+                nBaffled++;
             }
+        }
 
-            meshMod.setAction
-            (
-                polyModifyFace
-                (
-                    f,                          // modified face
-                    faceI,                      // label of face
-                    mesh.faceOwner()[faceI],    // owner
-                    -1,                         // neighbour
-                    false,                      // face flip
-                    newPatch[faceI],            // patch for face
-                    false,                      // remove from zone
-                    zoneID,                     // zone for face
-                    zoneFlip                    // face flip in zone
-                )
-            );
-
-            if (mesh.isInternalFace(faceI))
+        // Add the reversed face.
+        for (label faceI = 0; faceI < mesh.nInternalFaces(); faceI++)
+        {
+            if (facesToSplit.found(faceI))
             {
+                const face& f = mesh.faces()[faceI];
+                label zoneID = faceZones.whichZone(faceI);
+                bool zoneFlip = false;
+                if (zoneID >= 0)
+                {
+                    const faceZone& fZone = faceZones[zoneID];
+                    zoneFlip = fZone.flipMap()[fZone.whichFace(faceI)];
+                }
+                label nei = mesh.faceNeighbour()[faceI];
+
                 meshMod.setAction
                 (
                     polyAddFace
                     (
                         f.reverseFace(),            // modified face
-                        mesh.faceNeighbour()[faceI],// owner
+                        nei,                        // owner
                         -1,                         // neighbour
                         -1,                         // masterPointID
                         -1,                         // masterEdgeID
                         faceI,                      // masterFaceID,
-                        false,                      // face flip
-                        newPatch[faceI],            // patch for face
+                        true,                       // face flip
+                        newPatchI,                  // patch for face
                         zoneID,                     // zone for face
                         zoneFlip                    // face flip in zone
                     )
                 );
-            }
 
-            nBaffled++;
+                nBaffled++;
+            }
+        }
+
+        // Modify any boundary faces
+        forAll(patches, patchI)
+        {
+            const polyPatch& pp = patches[patchI];
+
+            if (patches[newPatchI].coupled() && pp.coupled())
+            {
+                // Do not allow coupled faces to be moved to different coupled
+                // patches.
+            }
+            else
+            {
+                forAll(pp, i)
+                {
+                    label faceI = pp.start()+i;
+
+                    if (facesToSplit.found(faceI))
+                    {
+                        const face& f = mesh.faces()[faceI];
+                        label zoneID = faceZones.whichZone(faceI);
+                        bool zoneFlip = false;
+                        if (zoneID >= 0)
+                        {
+                            const faceZone& fZone = faceZones[zoneID];
+                            zoneFlip = fZone.flipMap()[fZone.whichFace(faceI)];
+                        }
+
+                        if (i == 0)
+                        {
+                            // First usage of face. Modify.
+                            meshMod.setAction
+                            (
+                                polyModifyFace
+                                (
+                                    f,                      // modified face
+                                    faceI,                  // label of face
+                                    mesh.faceOwner()[faceI],// owner
+                                    -1,                     // neighbour
+                                    false,                  // face flip
+                                    newPatchI,              // patch for face
+                                    false,                  // remove from zone
+                                    zoneID,                 // zone for face
+                                    zoneFlip                // face flip in zone
+                                )
+                            );
+                        }
+                        else
+                        {
+                            // Second or more usage of face. Add.
+                            meshMod.setAction
+                            (
+                                polyAddFace
+                                (
+                                    f,                      // modified face
+                                    mesh.faceOwner()[faceI],// owner
+                                    -1,                     // neighbour
+                                    -1,                     // master point
+                                    -1,                     // master edge
+                                    faceI,                  // master face
+                                    false,                  // face flip
+                                    newPatchI,              // patch for face
+                                    zoneID,                 // zone for face
+                                    zoneFlip                // face flip in zone
+                                )
+                            );
+                        }
+
+                        nBaffled++;
+                    }
+                }
+            }
         }
     }
 
 
-    Pout<< "Converted locally " << nBaffled
+    Info<< "Converted " << returnReduce(nBaffled, sumOp<label>())
         << " faces into boundary faces on patch " << patchName << nl << endl;
 
     if (!overwrite)
@@ -252,7 +368,7 @@ int main(int argc, char *argv[])
     {
         mesh.setInstance(oldInstance);
     }
-    Pout<< "Writing mesh to " << runTime.timeName() << endl;
+    Info<< "Writing mesh to " << runTime.timeName() << endl;
 
     mesh.write();
 

applications/utilities/mesh/manipulation/renumberMesh/Make/options

@@ -2,7 +2,7 @@ EXE_INC = \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/dynamicMesh/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
-    -I$(LIB_SRC)/decompositionAgglomeration/decompositionMethods/lnInclude
+    -I$(LIB_SRC)/decompositionMethods/decompositionMethods/lnInclude
 
 EXE_LIBS = \
     -lmeshTools \

applications/utilities/mesh/manipulation/rotateMesh/rotateMesh.C

@@ -31,6 +31,7 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "argList.H"
+#include "timeSelector.H"
 #include "Time.H"
 #include "fvMesh.H"
 #include "volFields.H"
@@ -66,7 +67,8 @@ void RotateFields
 
 int main(int argc, char *argv[])
 {
-#   include "addTimeOptions.H"
+    timeSelector::addOptions();
+
     argList::validArgs.append("n1");
     argList::validArgs.append("n2");
 
@@ -105,19 +107,15 @@ int main(int argc, char *argv[])
         points.write();
     }
 
-    // Get times list
-    instantList Times = runTime.times();
 
-    // set startTime and endTime depending on -time and -latestTime options
-#   include "checkTimeOptions.H"
-
-    runTime.setTime(Times[startTime], startTime);
+    instantList timeDirs = timeSelector::select0(runTime, args);
 
 #   include "createMesh.H"
 
-    for (label i=startTime; i<endTime; i++)
+
+    forAll(timeDirs, timeI)
     {
-        runTime.setTime(Times[i], i);
+        runTime.setTime(timeDirs[timeI], timeI);
 
         Info<< "Time = " << runTime.timeName() << endl;
 

applications/utilities/mesh/manipulation/setSet/setSet.C

@@ -48,8 +48,8 @@ Description
 
 
 #if READLINE != 0
-#include <readline/readline.h>
-#include <readline/history.h>
+# include <readline/readline.h>
+# include <readline/history.h>
 #endif
 
 using namespace Foam;

applications/utilities/mesh/manipulation/setSet/writePointSet.C

@@ -70,7 +70,7 @@ void writePointSet
 
     labelList pointLabels(set.toc());
 
-    pointField setPoints(IndirectList<point>(mesh.points(), pointLabels)());
+    pointField setPoints(mesh.points(), pointLabels);
 
     // Write points
 

applications/utilities/mesh/manipulation/setsToZones/setsToZones.C

@@ -48,6 +48,7 @@ Description
 #include "OFstream.H"
 #include "IFstream.H"
 #include "IOobjectList.H"
+#include "SortableList.H"
 
 using namespace Foam;
 
@@ -107,6 +108,7 @@ int main(int argc, char *argv[])
     {
         // Not in memory. Load it.
         pointSet set(*iter());
+        SortableList<label> pointLabels(set.toc());
 
         label zoneID = mesh.pointZones().findZoneID(set.name());
         if (zoneID == -1)
@@ -120,7 +122,7 @@ int main(int argc, char *argv[])
                 new pointZone
                 (
                     set.name(),             //name
-                    set.toc(),              //addressing
+                    pointLabels,            //addressing
                     sz,                     //index
                     mesh.pointZones()       //pointZoneMesh
                 )
@@ -131,7 +133,7 @@ int main(int argc, char *argv[])
         {
             Info<< "Overwriting contents of existing pointZone " << zoneID
                 << " with that of set " << set.name() << "." << endl;
-            mesh.pointZones()[zoneID] = set.toc();
+            mesh.pointZones()[zoneID] = pointLabels;
             mesh.pointZones().writeOpt() = IOobject::AUTO_WRITE;
         }
     }
@@ -150,6 +152,7 @@ int main(int argc, char *argv[])
     {
         // Not in memory. Load it.
         cellSet set(*iter());
+        SortableList<label> cellLabels(set.toc());
 
         label zoneID = mesh.cellZones().findZoneID(set.name());
         if (zoneID == -1)
@@ -163,7 +166,7 @@ int main(int argc, char *argv[])
                 new cellZone
                 (
                     set.name(),             //name
-                    set.toc(),              //addressing
+                    cellLabels,             //addressing
                     sz,                     //index
                     mesh.cellZones()        //pointZoneMesh
                 )
@@ -174,7 +177,7 @@ int main(int argc, char *argv[])
         {
             Info<< "Overwriting contents of existing cellZone " << zoneID
                 << " with that of set " << set.name() << "." << endl;
-            mesh.cellZones()[zoneID] = set.toc();
+            mesh.cellZones()[zoneID] = cellLabels;
             mesh.cellZones().writeOpt() = IOobject::AUTO_WRITE;
         }
     }
@@ -193,6 +196,7 @@ int main(int argc, char *argv[])
     {
         // Not in memory. Load it.
         faceSet set(*iter());
+        SortableList<label> faceLabels(set.toc());
 
         DynamicList<label> addressing(set.size());
         DynamicList<bool> flipMap(set.size());
@@ -214,9 +218,9 @@ int main(int argc, char *argv[])
             // Load corresponding cells
             cellSet cells(mesh, setName);
 
-            forAllConstIter(faceSet, set, iter)
+            forAll(faceLabels, i)
             {
-                label faceI = iter.key();
+                label faceI = faceLabels[i];
 
                 bool flip = false;
 
@@ -273,9 +277,10 @@ int main(int argc, char *argv[])
         else
         {
             // No flip map.
-            forAllConstIter(faceSet, set, iter)
+            forAll(faceLabels, i)
             {
-                addressing.append(iter.key());
+                label faceI = faceLabels[i];
+                addressing.append(faceI);
                 flipMap.append(false);
             }
         }

applications/utilities/mesh/manipulation/splitMesh/regionSide.C

@@ -22,14 +22,11 @@ License
     along with OpenFOAM; if not, write to the Free Software Foundation,
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
-Description
-
 \*---------------------------------------------------------------------------*/
 
 #include "regionSide.H"
 #include "meshTools.H"
 #include "primitiveMesh.H"
-#include "IndirectList.H"
 
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -113,7 +110,7 @@ Foam::label Foam::regionSide::otherEdge
     )   << "Cannot find other edge on face " << faceI << " that uses point "
         << pointI << " but not point " << freePointI << endl
         << "Edges on face:" << fEdges
-        << " verts:" << IndirectList<edge>(mesh.edges(), fEdges)()
+        << " verts:" << UIndirectList<edge>(mesh.edges(), fEdges)()
         << " Vertices on face:"
         << mesh.faces()[faceI]
         << " Vertices on original edge:" << e << abort(FatalError);

applications/utilities/mesh/manipulation/splitMesh/splitMesh.C

@@ -50,15 +50,12 @@ Description
 #include "attachDetach.H"
 #include "attachPolyTopoChanger.H"
 #include "regionSide.H"
+#include "primitiveFacePatch.H"
 
 using namespace Foam;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-// Calculation engine for set of faces in a mesh
-typedef PrimitivePatch<face, List, const pointField&> facePatch;
-
-
 // Find edge between points v0 and v1.
 label findEdge(const primitiveMesh& mesh, const label v0, const label v1)
 {
@@ -163,10 +160,16 @@ int main(int argc, char *argv[])
     // set of edges on side of this region. Use PrimitivePatch to find these.
     //
 
-    IndirectList<face> zoneFaces(mesh.faces(), faces);
-
     // Addressing on faces only in mesh vertices.
-    facePatch fPatch(zoneFaces(), mesh.points());
+    primitiveFacePatch fPatch
+    (
+        UIndirectList<face>
+        (
+            mesh.faces(),
+            faces
+        ),
+        mesh.points()
+    );
 
     const labelList& meshPoints = fPatch.meshPoints();
 

applications/utilities/mesh/manipulation/splitMeshRegions/splitMeshRegions.C

@@ -57,6 +57,7 @@ Description
 #include "EdgeMap.H"
 #include "syncTools.H"
 #include "ReadFields.H"
+#include "directMappedWallPolyPatch.H"
 
 using namespace Foam;
 
@@ -1022,13 +1023,13 @@ EdgeMap<label> addRegionPatches
             (
                 mesh,
                 regionNames[e[0]] + "_to_" + regionNames[e[1]],
-                polyPatch::typeName
+                directMappedWallPolyPatch::typeName
             );
             addPatch
             (
                 mesh,
                 regionNames[e[1]] + "_to_" + regionNames[e[0]],
-                polyPatch::typeName
+                directMappedWallPolyPatch::typeName
             );
 
             Info<< "For interface between region " << e[0]
@@ -1100,7 +1101,6 @@ EdgeMap<label> addRegionPatches
 //}
 
 
-//XXXXXXXXX
 // Find region that covers most of cell zone
 label findCorrespondingRegion
 (
@@ -1152,7 +1152,6 @@ label findCorrespondingRegion
 
     return regionI;
 }
-//XXXXXXXXX
 
 
 //// Checks if cellZone has corresponding cellRegion.

applications/utilities/mesh/manipulation/stitchMesh/stitchMesh.C

@@ -60,7 +60,6 @@ Description
 #include "polyTopoChanger.H"
 #include "mapPolyMesh.H"
 #include "ListOps.H"
-#include "IndirectList.H"
 #include "slidingInterface.H"
 #include "perfectInterface.H"
 #include "IOobjectList.H"

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

@@ -35,14 +35,22 @@ Description
     -rotate (vector vector)
         Rotates the points from the first vector to the second,
 
+     or -yawPitchRoll (yawdegrees pitchdegrees rolldegrees)
+     or -rollPitchYaw (rolldegrees pitchdegrees yawdegrees)
+
     -scale vector
         Scales the points by the given vector.
 
     The any or all of the three options may be specified and are processed
     in the above order.
 
-    With -rotateFields (in combination with -rotate) it will also
-    read & transform vector & tensor fields.
+    With -rotateFields (in combination with -rotate/yawPitchRoll/rollPitchYaw)
+    it will also read & transform vector & tensor fields.
+
+    Note:
+    yaw (rotation about z)
+    pitch (rotation about y)
+    roll (rotation about x)
 
 \*---------------------------------------------------------------------------*/
 
@@ -58,6 +66,7 @@ Description
 #include "IStringStream.H"
 
 using namespace Foam;
+using namespace Foam::mathematicalConstant;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -131,6 +140,8 @@ int main(int argc, char *argv[])
 {
     argList::validOptions.insert("translate", "vector");
     argList::validOptions.insert("rotate", "(vector vector)");
+    argList::validOptions.insert("rollPitchYaw", "(roll pitch yaw)");
+    argList::validOptions.insert("yawPitchRoll", "(yaw pitch roll)");
     argList::validOptions.insert("rotateFields", "");
     argList::validOptions.insert("scale", "vector");
  
@@ -185,6 +196,58 @@ int main(int argc, char *argv[])
             rotateFields(runTime, T);
         }
     }
+    else if (args.options().found("rollPitchYaw"))
+    {
+        vector v(IStringStream(args.options()["rollPitchYaw"])());
+
+        Info<< "Rotating points by" << nl
+            << "    roll  " << v.x() << nl
+            << "    pitch " << v.y() << nl
+            << "    yaw   " << v.z() << endl;
+
+
+        // Convert to radians
+        v *= pi/180.0;
+
+        quaternion R(v.x(), v.y(), v.z());
+
+        Info<< "Rotating points by quaternion " << R << endl;
+        points = transform(R, points);
+
+        if (args.options().found("rotateFields"))
+        {
+            rotateFields(runTime, R.R());
+        }
+    }
+    else if (args.options().found("yawPitchRoll"))
+    {
+        vector v(IStringStream(args.options()["yawPitchRoll"])());
+
+        Info<< "Rotating points by" << nl
+            << "    yaw   " << v.x() << nl
+            << "    pitch " << v.y() << nl
+            << "    roll  " << v.z() << endl;
+
+
+        // Convert to radians
+        v *= pi/180.0;
+
+        scalar yaw = v.x();
+        scalar pitch = v.y();
+        scalar roll = v.z();
+
+        quaternion R = quaternion(vector(0, 0, 1), yaw);
+        R *= quaternion(vector(0, 1, 0), pitch);
+        R *= quaternion(vector(1, 0, 0), roll);
+
+        Info<< "Rotating points by quaternion " << R << endl;
+        points = transform(R, points);
+
+        if (args.options().found("rotateFields"))
+        {
+            rotateFields(runTime, R.R());
+        }
+    }
 
     if (args.options().found("scale"))
     {

applications/utilities/miscellaneous/foamDebugSwitches/foamDebugSwitches.C

@@ -29,6 +29,9 @@ Description
 
 #include "argList.H"
 #include "dictionary.H"
+#include "IFstream.H"
+#include "IOobject.H"
+#include "HashSet.H"
 
 using namespace Foam;
 
@@ -38,18 +41,108 @@ using namespace Foam;
 int main(int argc, char *argv[])
 {
     argList::noParallel();
+    argList::validOptions.insert("new", "");
+    argList::validOptions.insert("old", "");
 
-    wordList ds(debug::debugSwitches().toc());
-    sort(ds);
-    Info<< "debug switches: " << ds << endl;
+    Foam::argList args(argc, argv);
+
+    wordList currDebug(debug::debugSwitches().toc());
+    wordList currInfo(debug::infoSwitches().toc());
+    wordList currOpt(debug::optimisationSwitches().toc());
+
+    if (args.options().found("old") || args.options().found("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.options().found("old"))
+        {
+            IOobject::writeDivider(Info);
+
+            hashset = oldDebug;
+            hashset -= currDebug;
+            listing = hashset.toc();
+            sort(listing);
+            Info<< "old DebugSwitches: " << listing << endl;
+
+            hashset = oldInfo;
+            hashset -= currInfo;
+            listing = hashset.toc();
+            sort(listing);
+            Info<< "old InfoSwitches: " << listing << endl;
+
+            hashset = oldOpt;
+            hashset -= currOpt;
+            listing = hashset.toc();
+            sort(listing);
+            Info<< "old OptimisationSwitches: " << listing << endl;
+        }
+
+        // list new switches
+        if (args.options().found("new"))
+        {
+            IOobject::writeDivider(Info);
+
+            hashset = currDebug;
+            hashset -= oldDebug;
+
+            listing = hashset.toc();
+            sort(listing);
+            Info<< "new DebugSwitches: " << listing << endl;
+
+            hashset = currInfo;
+            hashset -= oldInfo;
+            listing = hashset.toc();
+            sort(listing);
+            Info<< "new InfoSwitches: " << listing << endl;
+
+            hashset = currOpt;
+            hashset -= 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;
+    }
 
-    wordList is(debug::infoSwitches().toc());
-    sort(is);
-    Info<< "info switches: " << is << endl;
 
-    wordList os(debug::optimisationSwitches().toc());
-    sort(os);
-    Info<< "optimisation switches: " << os << endl;
 
     Info<< "done" << endl;
 

applications/utilities/miscellaneous/patchSummary/patchSummary.C

@@ -40,25 +40,19 @@ Description
 
 int main(int argc, char *argv[])
 {
+    timeSelector::addOptions();
 
-#   include "addTimeOptions.H"
 #   include "addRegionOption.H"
 #   include "setRootCase.H"
 #   include "createTime.H"
 
-    // Get times list
-    instantList Times = runTime.times();
-
-    // set startTime and endTime depending on -time and -latestTime options
-#   include "checkTimeOptions.H"
-
-    runTime.setTime(Times[startTime], startTime);
+    instantList timeDirs = timeSelector::select0(runTime, args);
 
 #   include "createNamedMesh.H"
 
-    for (label i=startTime; i<endTime; i++)
+    forAll(timeDirs, timeI)
     {
-        runTime.setTime(Times[i], i);
+        runTime.setTime(timeDirs[timeI], timeI);
 
         Info<< "Time = " << runTime.timeName() << nl << endl;
 

applications/utilities/parallelProcessing/decomposePar/Make/options

@@ -1,5 +1,5 @@
 EXE_INC = \
-    -I$(LIB_SRC)/decompositionAgglomeration/decompositionMethods/lnInclude \
+    -I$(LIB_SRC)/decompositionMethods/decompositionMethods/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude

applications/utilities/parallelProcessing/decomposePar/decomposePar.C

@@ -37,6 +37,9 @@ Usage
     Write the cell distribution as a labelList for use with 'manual'
     decomposition method and as a volScalarField for post-processing.
 
+    @param -region regionName \n
+    Decompose named region. Does not check for existence of processor*.
+
     @param -copyUniform \n
     Copy any @a uniform directories too.
 
@@ -83,6 +86,7 @@ Usage
 int main(int argc, char *argv[])
 {
     argList::noParallel();
+#   include "addRegionOption.H"
     argList::validOptions.insert("cellDist", "");
     argList::validOptions.insert("copyUniform", "");
     argList::validOptions.insert("fields", "");
@@ -92,6 +96,17 @@ int main(int argc, char *argv[])
 
 #   include "setRootCase.H"
 
+    word regionName = fvMesh::defaultRegion;
+    word regionDir = word::null;
+
+    if (args.options().found("region"))
+    {
+        regionName = args.options()["region"];
+        regionDir = regionName;
+        Info<< "Decomposing mesh " << regionName << nl << endl;
+    }
+
+
     bool writeCellDist(args.options().found("cellDist"));
     bool copyUniform(args.options().found("copyUniform"));
     bool decomposeFieldsOnly(args.options().found("fields"));
@@ -105,7 +120,17 @@ int main(int argc, char *argv[])
 
     // determine the existing processor count directly
     label nProcs = 0;
-    while (isDir(runTime.path()/(word("processor") + name(nProcs))))
+    while
+    (
+        isDir
+        (
+            runTime.path()
+           /(word("processor") + name(nProcs))
+           /runTime.constant()
+           /regionDir
+           /polyMesh::meshSubDir
+        )
+    )
     {
         ++nProcs;
     }
@@ -119,6 +144,7 @@ int main(int argc, char *argv[])
             (
                 "decomposeParDict",
                 runTime.time().system(),
+                regionDir,          // use region if non-standard
                 runTime,
                 IOobject::MUST_READ,
                 IOobject::NO_WRITE,
@@ -196,7 +222,7 @@ int main(int argc, char *argv[])
     (
         IOobject
         (
-            domainDecomposition::defaultRegion,
+            regionName,
             runTime.timeName(),
             runTime
         )
@@ -219,7 +245,7 @@ int main(int argc, char *argv[])
             (
                 runTime.path()
               / mesh.facesInstance()
-              / polyMesh::defaultRegion
+              / regionName
               / "cellDecomposition"
             );
 
@@ -312,7 +338,7 @@ int main(int argc, char *argv[])
 
     fileNameList cloudDirs
     (
-        readDir(runTime.timePath()/"lagrangian", fileName::DIRECTORY)
+        readDir(runTime.timePath()/cloud::prefix, fileName::DIRECTORY)
     );
 
     // Particles
@@ -344,7 +370,7 @@ int main(int argc, char *argv[])
         (
             mesh,
             runTime.timeName(),
-            "lagrangian"/cloudDirs[i]
+            cloud::prefix/cloudDirs[i]
         );
 
         IOobject* positionsPtr = sprayObjs.lookup("positions");
@@ -383,7 +409,12 @@ int main(int argc, char *argv[])
 
             label i = 0;
 
-            forAllIter(Cloud<indexedParticle>, lagrangianPositions[cloudI], iter)
+            forAllIter
+            (
+                Cloud<indexedParticle>,
+                lagrangianPositions[cloudI],
+                iter
+            )
             {
                 iter().index() = i++;
 
@@ -405,7 +436,8 @@ int main(int argc, char *argv[])
 
                 if (!cellParticles[cloudI][celli])
                 {
-                    cellParticles[cloudI][celli] = new SLList<indexedParticle*>();
+                    cellParticles[cloudI][celli] = new SLList<indexedParticle*>
+                    ();
                 }
 
                 cellParticles[cloudI][celli]->append(&iter());
@@ -418,7 +450,7 @@ int main(int argc, char *argv[])
             (
                 mesh,
                 runTime.timeName(),
-                "lagrangian"/cloudDirs[cloudI]
+                cloud::prefix/cloudDirs[cloudI]
             );
 
             lagrangianFieldDecomposer::readFields
@@ -513,7 +545,7 @@ int main(int argc, char *argv[])
         (
             IOobject
             (
-                fvMesh::defaultRegion,
+                regionName,
                 processorDb.timeName(),
                 processorDb
             )

applications/utilities/parallelProcessing/decomposePar/decomposeParDict

@@ -19,11 +19,12 @@ FoamFile
 
 numberOfSubdomains  4;
 
-// preservePatches (inlet);
+//- Keep owner and neighbour on same processor for faces in zones:
 // preserveFaceZones (heater solid1 solid3);
 
-method          simple;
+method          scotch;
 // method          hierarchical;
+// method          simple;
 // method          metis;
 // method          manual;
 
@@ -53,6 +54,9 @@ metisCoeffs
   */
 }
 
+scotchCoeffs
+{}
+
 manualCoeffs
 {
     dataFile    "decompositionData";

applications/utilities/parallelProcessing/decomposePar/distributeCells.C

@@ -45,35 +45,6 @@ void domainDecomposition::distributeCells()
 
     labelHashSet sameProcFaces;
 
-    if (decompositionDict_.found("preservePatches"))
-    {
-        wordList pNames(decompositionDict_.lookup("preservePatches"));
-
-        Info<< "Keeping owner and neighbour of faces in patches " << pNames
-            << " on same processor" << endl;
-
-        const polyBoundaryMesh& patches = boundaryMesh();
-
-        forAll(pNames, i)
-        {
-            label patchI = patches.findPatchID(pNames[i]);
-
-            if (patchI == -1)
-            {
-                FatalErrorIn("domainDecomposition::distributeCells()")
-                    << "Unknown preservePatch " << pNames[i]
-                    << endl << "Valid patches are " << patches.names()
-                    << exit(FatalError);
-            }
-
-            const polyPatch& pp = patches[patchI];
-
-            forAll(pp, i)
-            {
-                sameProcFaces.insert(pp.start() + i);
-            }
-        }
-    }
     if (decompositionDict_.found("preserveFaceZones"))
     {
         wordList zNames(decompositionDict_.lookup("preserveFaceZones"));
@@ -104,14 +75,6 @@ void domainDecomposition::distributeCells()
         }
     }
 
-    if (sameProcFaces.size())
-    {
-        Info<< "Selected " << sameProcFaces.size()
-            << " faces whose owner and neighbour cell should be kept on the"
-            << " same processor" << endl;
-    }
-
-
 
     // Construct decomposition method and either do decomposition on
     // cell centres or on agglomeration
@@ -129,6 +92,10 @@ void domainDecomposition::distributeCells()
     }
     else
     {
+        Info<< "Selected " << sameProcFaces.size()
+            << " faces whose owner and neighbour cell should be kept on the"
+            << " same processor" << endl;
+
         // Faces where owner and neighbour are not 'connected' (= all except
         // sameProcFaces)
         boolList blockedFace(nFaces(), true);

applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C

@@ -268,7 +268,7 @@ bool domainDecomposition::writeDecomposition()
         (
             IOobject
             (
-                polyMesh::defaultRegion,
+                this->polyMesh::name(),  // region name of undecomposed mesh
                 "constant",
                 processorDb
             ),

applications/utilities/parallelProcessing/decomposePar/lagrangianFieldDecomposerDecomposeFields.C

@@ -88,7 +88,7 @@ tmp<IOField<Type> > lagrangianFieldDecomposer::decomposeField
             (
                 field.name(),
                 procMesh_.time().timeName(),
-                "lagrangian"/cloudName,
+                cloud::prefix/cloudName,
                 procMesh_,
                 IOobject::NO_READ,
                 IOobject::NO_WRITE

applications/utilities/parallelProcessing/reconstructPar/processorMeshes.C

@@ -200,12 +200,6 @@ void Foam::processorMeshes::reconstructPoints(fvMesh& mesh)
     // Read the field for all the processors
     PtrList<pointIOField> procsPoints(meshes_.size());
 
-    fileName regionPrefix = "";
-    if (meshName_ != fvMesh::defaultRegion)
-    {
-        regionPrefix = meshName_;
-    }
-
     forAll (meshes_, procI)
     {
         procsPoints.set
@@ -217,7 +211,7 @@ void Foam::processorMeshes::reconstructPoints(fvMesh& mesh)
                 (
                     "points",
                     meshes_[procI].time().timeName(),
-                    regionPrefix/polyMesh::meshSubDir,
+                    polyMesh::meshSubDir,
                     meshes_[procI],
                     IOobject::MUST_READ,
                     IOobject::NO_WRITE

applications/utilities/parallelProcessing/reconstructPar/reconstructLagrangian.H

@@ -36,6 +36,7 @@ SourceFiles
 #ifndef reconstructLagrangian_H
 #define reconstructLagrangian_H
 
+#include "cloud.H"
 #include "polyMesh.H"
 #include "IOobjectList.H"
 #include "fvMesh.H"

applications/utilities/parallelProcessing/reconstructPar/reconstructLagrangianFields.C

@@ -47,7 +47,7 @@ Foam::tmp<Foam::IOField<Type> > Foam::reconstructLagrangianField
             (
                 fieldName,
                 mesh.time().timeName(),
-                "lagrangian"/cloudName,
+                cloud::prefix/cloudName,
                 mesh,
                 IOobject::NO_READ,
                 IOobject::NO_WRITE
@@ -61,10 +61,10 @@ Foam::tmp<Foam::IOField<Type> > Foam::reconstructLagrangianField
     {
         // Check object on local mesh
         IOobject localIOobject
-        ( 
+        (
             fieldName,
             meshes[i].time().timeName(),
-            "lagrangian"/cloudName,
+            cloud::prefix/cloudName,
             meshes[i],
             IOobject::MUST_READ,
             IOobject::NO_WRITE

applications/utilities/parallelProcessing/reconstructPar/reconstructPar.C

@@ -51,6 +51,7 @@ int main(int argc, char *argv[])
     argList::noParallel();
 #   include "addRegionOption.H"
     argList::validOptions.insert("fields", "\"(list of fields)\"");
+    argList::validOptions.insert("noLagrangian", "");
 
 #   include "setRootCase.H"
 #   include "createTime.H"
@@ -61,6 +62,8 @@ int main(int argc, char *argv[])
         IStringStream(args.options()["fields"])() >> selectedFields;
     }
 
+    bool noLagrangian = args.options().found("noLagrangian");
+
     // determine the processor count directly
     label nProcs = 0;
     while (isDir(args.path()/(word("processor") + name(nProcs))))
@@ -113,6 +116,13 @@ int main(int argc, char *argv[])
     {
         regionPrefix = regionName;
     }
+
+    // Set all times on processor meshes equal to reconstructed mesh
+    forAll (databases, procI)
+    {
+        databases[procI].setTime(runTime.timeName(), runTime.timeIndex());
+    }
+
     // Read all meshes and addressing to reconstructed mesh
     processorMeshes procMeshes(databases, regionName);
 
@@ -269,118 +279,121 @@ int main(int argc, char *argv[])
         // the first processor that has them. They are in pass2 only used
         // for name and type (scalar, vector etc).
 
-        HashTable<IOobjectList> cloudObjects;
-
-        forAll (databases, procI)
+        if (!noLagrangian)
         {
-            fileNameList cloudDirs
-            (
-                readDir
-                (
-                    databases[procI].timePath()/regionPrefix/"lagrangian",
-                    fileName::DIRECTORY
-                )
-            );
+            HashTable<IOobjectList> cloudObjects;
 
-            forAll (cloudDirs, i)
+            forAll (databases, procI)
             {
-                // Check if we already have cloud objects for this cloudname.
-                HashTable<IOobjectList>::const_iterator iter =
-                    cloudObjects.find(cloudDirs[i]);
-
-                if (iter == cloudObjects.end())
-                {
-                    // Do local scan for valid cloud objects.
-                    IOobjectList sprayObjs
+                fileNameList cloudDirs
+                (
+                    readDir
                     (
-                        procMeshes.meshes()[procI],
-                        databases[procI].timeName(),
-                        "lagrangian"/cloudDirs[i]
-                    );
+                        databases[procI].timePath()/regionPrefix/cloud::prefix,
+                        fileName::DIRECTORY
+                    )
+                );
 
-                    IOobject* positionsPtr = sprayObjs.lookup("positions");
+                forAll (cloudDirs, i)
+                {
+                    // Check if we already have cloud objects for this cloudname
+                    HashTable<IOobjectList>::const_iterator iter =
+                        cloudObjects.find(cloudDirs[i]);
 
-                    if (positionsPtr)
+                    if (iter == cloudObjects.end())
                     {
-                        cloudObjects.insert(cloudDirs[i], sprayObjs);
+                        // Do local scan for valid cloud objects
+                        IOobjectList sprayObjs
+                        (
+                            procMeshes.meshes()[procI],
+                            databases[procI].timeName(),
+                            cloud::prefix/cloudDirs[i]
+                        );
+
+                        IOobject* positionsPtr = sprayObjs.lookup("positions");
+
+                        if (positionsPtr)
+                        {
+                            cloudObjects.insert(cloudDirs[i], sprayObjs);
+                        }
                     }
                 }
             }
-        }
 
 
-        if (cloudObjects.size())
-        {
-            // Pass2: reconstruct the cloud
-            forAllConstIter(HashTable<IOobjectList>, cloudObjects, iter)
+            if (cloudObjects.size())
             {
-                const word cloudName = string::validate<word>(iter.key());
+                // Pass2: reconstruct the cloud
+                forAllConstIter(HashTable<IOobjectList>, cloudObjects, iter)
+                {
+                    const word cloudName = string::validate<word>(iter.key());
 
-                // Objects (on arbitrary processor)
-                const IOobjectList& sprayObjs = iter();
+                    // Objects (on arbitrary processor)
+                    const IOobjectList& sprayObjs = iter();
 
-                Info<< "Reconstructing lagrangian fields for cloud "
-                    << cloudName << nl << endl;
+                    Info<< "Reconstructing lagrangian fields for cloud "
+                        << cloudName << nl << endl;
 
-                reconstructLagrangianPositions
-                (
-                    mesh,
-                    cloudName,
-                    procMeshes.meshes(),
-                    procMeshes.faceProcAddressing(),
-                    procMeshes.cellProcAddressing()
-                );
-                reconstructLagrangianFields<label>
-                (
-                    cloudName,
-                    mesh,
-                    procMeshes.meshes(),
-                    sprayObjs
-                );
-                reconstructLagrangianFields<scalar>
-                (
-                    cloudName,
-                    mesh,
-                    procMeshes.meshes(),
-                    sprayObjs
-                );
-                reconstructLagrangianFields<vector>
-                (
-                    cloudName,
-                    mesh,
-                    procMeshes.meshes(),
-                    sprayObjs
-                );
-                reconstructLagrangianFields<sphericalTensor>
-                (
-                    cloudName,
-                    mesh,
-                    procMeshes.meshes(),
-                    sprayObjs
-                );
-                reconstructLagrangianFields<symmTensor>
-                (
-                    cloudName,
-                    mesh,
-                    procMeshes.meshes(),
-                    sprayObjs
-                );
-                reconstructLagrangianFields<tensor>
-                (
-                    cloudName,
-                    mesh,
-                    procMeshes.meshes(),
-                    sprayObjs
-                );
+                    reconstructLagrangianPositions
+                    (
+                        mesh,
+                        cloudName,
+                        procMeshes.meshes(),
+                        procMeshes.faceProcAddressing(),
+                        procMeshes.cellProcAddressing()
+                    );
+                    reconstructLagrangianFields<label>
+                    (
+                        cloudName,
+                        mesh,
+                        procMeshes.meshes(),
+                        sprayObjs
+                    );
+                    reconstructLagrangianFields<scalar>
+                    (
+                        cloudName,
+                        mesh,
+                        procMeshes.meshes(),
+                        sprayObjs
+                    );
+                    reconstructLagrangianFields<vector>
+                    (
+                        cloudName,
+                        mesh,
+                        procMeshes.meshes(),
+                        sprayObjs
+                    );
+                    reconstructLagrangianFields<sphericalTensor>
+                    (
+                        cloudName,
+                        mesh,
+                        procMeshes.meshes(),
+                        sprayObjs
+                    );
+                    reconstructLagrangianFields<symmTensor>
+                    (
+                        cloudName,
+                        mesh,
+                        procMeshes.meshes(),
+                        sprayObjs
+                    );
+                    reconstructLagrangianFields<tensor>
+                    (
+                        cloudName,
+                        mesh,
+                        procMeshes.meshes(),
+                        sprayObjs
+                    );
+                }
+            }
+            else
+            {
+                Info << "No lagrangian fields" << nl << endl;
             }
-        }
-        else
-        {
-            Info << "No lagrangian fields" << nl << endl;
         }
 
         // If there are any "uniform" directories copy them from
-        // the master processor.
+        // the master processor
 
         fileName uniformDir0 = databases[0].timePath()/"uniform";
         if (isDir(uniformDir0))

applications/utilities/parallelProcessing/redistributeMeshPar/Make/options

@@ -1,5 +1,5 @@
 EXE_INC = \
-    -I$(LIB_SRC)/decompositionAgglomeration/decompositionMethods/lnInclude \
+    -I$(LIB_SRC)/decompositionMethods/decompositionMethods/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/dynamicMesh/lnInclude

applications/utilities/postProcessing/dataConversion/foamDataToFluent/foamDataToFluent.C

@@ -38,26 +38,22 @@ Description
 int main(int argc, char *argv[])
 {
     argList::noParallel();
-#   include "addTimeOptions.H"
+    timeSelector::addOptions(false);   // no constant
 
 #   include "setRootCase.H"
 #   include "createTime.H"
 
-    instantList Times = runTime.times();
-
-    // set startTime and endTime depending on -time and -latestTime options
-#   include "checkTimeOptionsNoConstant.H"
-
-    runTime.setTime(Times[startTime], startTime);
+    instantList timeDirs = timeSelector::select0(runTime, args);
 
 #   include "createMesh.H"
 
     // make a directory called proInterface in the case
     mkDir(runTime.rootPath()/runTime.caseName()/"fluentInterface");
 
-    for (label timeI = startTime; timeI < endTime; timeI++)
+    forAll(timeDirs, timeI)
     {
-        runTime.setTime(Times[timeI], timeI);
+        runTime.setTime(timeDirs[timeI], timeI);
+
         Info<< "Time = " << runTime.timeName() << endl;
 
         if (mesh.readUpdate())

applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightCloudField.H

@@ -35,6 +35,7 @@ SourceFiles
 #ifndef ensightCloudField_H
 #define ensightCloudField_H
 
+#include "Cloud.H"
 #include "IOobject.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

applications/utilities/postProcessing/dataConversion/foamToEnsight/foamToEnsight.C

@@ -211,7 +211,7 @@ int main(int argc, char *argv[])
 
         fileNameList cloudDirs = readDir
         (
-            runTime.timePath()/regionPrefix/"lagrangian",
+            runTime.timePath()/regionPrefix/cloud::prefix,
             fileName::DIRECTORY
         );
 
@@ -221,7 +221,7 @@ int main(int argc, char *argv[])
             (
                 mesh,
                 runTime.timeName(),
-                "lagrangian"/cloudDirs[cloudI]
+                cloud::prefix/cloudDirs[cloudI]
             );
 
             IOobject* positionsPtr = cloudObjs.lookup("positions");
@@ -266,7 +266,7 @@ int main(int argc, char *argv[])
             (
                 mesh,
                 runTime.timeName(),
-                "lagrangian"/cloudIter.key()
+                cloud::prefix/cloudIter.key()
             );
 
             forAllConstIter(IOobjectList, cloudObjs, fieldIter)
@@ -426,7 +426,7 @@ int main(int argc, char *argv[])
 
             fileNameList currentCloudDirs = readDir
             (
-                runTime.timePath()/regionPrefix/"lagrangian",
+                runTime.timePath()/regionPrefix/cloud::prefix,
                 fileName::DIRECTORY
             );
 
@@ -449,7 +449,7 @@ int main(int argc, char *argv[])
                 (
                     fieldName,
                     mesh.time().timeName(),
-                    "lagrangian"/cloudName,
+                    cloud::prefix/cloudName,
                     mesh,
                     IOobject::MUST_READ
                 );

applications/utilities/postProcessing/dataConversion/foamToEnsightParts/ensightOutputCase.H

@@ -42,7 +42,7 @@ forAllConstIter(HashTable<HashTable<word> >, cloudFields, cloudIter)
 
     caseFile
         << setw(16) << "measured: 2"
-        << fileName(dataMask/"lagrangian"/cloudName/"positions").c_str()
+        << fileName(dataMask/cloud::prefix/cloudName/"positions").c_str()
             << nl;
 }
 caseFile
@@ -122,7 +122,7 @@ forAllConstIter(HashTable<HashTable<word> >, cloudFields, cloudIter)
                 ensightType,
                 fieldName,
                 dataMask,
-                "lagrangian"/cloudName,
+                cloud::prefix/cloudName,
                 cloudNo,
                 2
             );

applications/utilities/postProcessing/dataConversion/foamToEnsightParts/ensightOutputFunctions.C

@@ -27,7 +27,6 @@ License
 #include "ensightOutputFunctions.H"
 
 #include "passiveParticle.H"
-#include "Cloud.H"
 #include "IOField.H"
 #include "volFields.H"
 #include "surfaceFields.H"
@@ -101,7 +100,7 @@ void ensightParticlePositions
 {
     Cloud<passiveParticle> parcels(mesh, cloudName, false);
 
-    fileName cloudDir = subDir/"lagrangian"/cloudName;
+    fileName cloudDir = subDir/cloud::prefix/cloudName;
     fileName postFileName = cloudDir/"positions";
 
     // the ITER/lagrangian subdirectory must exist
@@ -165,7 +164,7 @@ void ensightLagrangianField
 {
     Info<< " " << fieldObject.name() << flush;
 
-    fileName cloudDir = subDir/"lagrangian"/cloudName;
+    fileName cloudDir = subDir/cloud::prefix/cloudName;
     fileName postFileName = cloudDir/fieldObject.name();
 
     string title =

applications/utilities/postProcessing/dataConversion/foamToEnsightParts/ensightOutputFunctions.H

@@ -23,9 +23,7 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Description
-
-    miscellaneous collection of functions and template related
-    to Ensight data
+    Miscellaneous collection of functions and template related to Ensight data
 
 SourceFiles
     ensightOutputFunctions.C
@@ -36,6 +34,7 @@ SourceFiles
 #define ensightOutputFunctions_H
 
 #include "ensightFile.H"
+#include "Cloud.H"
 #include "polyMesh.H"
 #include "IOobject.H"
 

applications/utilities/postProcessing/dataConversion/foamToEnsightParts/findFields.H

@@ -36,7 +36,7 @@ if (timeDirs.size() > 1)
         runTime.path()
       / timeDirs[timeDirs.size() - 1].name()
       / regionPrefix
-      / "lagrangian",
+      / cloud::prefix,
         fileName::DIRECTORY
     );
 
@@ -55,7 +55,7 @@ if (timeDirs.size() > 1)
         (
             mesh,
             timeDirs[timeDirs.size() - 1].name(),
-            "lagrangian"/cloudName
+            cloud::prefix/cloudName
         );
 
         bool hasPositions = false;

applications/utilities/postProcessing/dataConversion/foamToEnsightParts/foamToEnsightParts.C

@@ -324,7 +324,14 @@ int main(int argc, char *argv[])
         {
             const word& cloudName = cloudIter.key();
 
-            if (!isDir(runTime.timePath()/regionPrefix/"lagrangian"/cloudName))
+            if
+            (
+                !isDir
+                (
+                    runTime.timePath()/regionPrefix/
+                    cloud::prefix/cloudName
+                )
+            )
             {
                 continue;
             }
@@ -333,7 +340,7 @@ int main(int argc, char *argv[])
             (
                 mesh,
                 runTime.timeName(),
-                "lagrangian"/cloudName
+                cloud::prefix/cloudName
             );
 
             // check that the positions field is present for this time
@@ -365,7 +372,8 @@ int main(int argc, char *argv[])
                 if (!fieldObject)
                 {
                     Info<< "missing "
-                        << runTime.timeName()/"lagrangian"/cloudName/fieldName
+                        << runTime.timeName()/cloud::prefix/cloudName
+                        / fieldName
                         << endl;
                     continue;
                 }

applications/utilities/postProcessing/dataConversion/foamToFieldview9/createSprayFields.H

@@ -21,7 +21,7 @@ List<IOField<vector>* > sprayVectorFieldPtrs
         (
             sprayScalarNames[fieldI],
             runTime.timeName(),
-            "lagrangian",
+            cloud::prefix,
             mesh,
             IOobject::MUST_READ,
             IOobject::NO_WRITE
@@ -53,7 +53,7 @@ List<IOField<vector>* > sprayVectorFieldPtrs
         (
             sprayVectorNames[fieldI],
             runTime.timeName(),
-            "lagrangian",
+            cloud::prefix,
             mesh,
             IOobject::MUST_READ,
             IOobject::NO_WRITE

applications/utilities/postProcessing/dataConversion/foamToFieldview9/getFieldNames.H

@@ -42,7 +42,7 @@ forAll(Times, timeI)
 
 
     // Same for spray
-    IOobjectList sprayObjects(mesh, runTime.timeName(), "lagrangian");
+    IOobjectList sprayObjects(mesh, runTime.timeName(), cloud::prefix);
     {
         wordList fieldNames(sprayObjects.names(scalarIOField::typeName));
         forAll(fieldNames, fieldI)

applications/utilities/postProcessing/dataConversion/foamToGMV/foamToGMV.C

@@ -44,21 +44,21 @@ Description
 int main(int argc, char *argv[])
 {
     const label nTypes = 4;
-    const word fieldTypes[] = 
-    { 
-        "volScalarField", 
-        "volVectorField", 
+    const word fieldTypes[] =
+    {
+        "volScalarField",
+        "volVectorField",
         "surfaceScalarField",
-        "lagrangian"
+        cloud::prefix
     };
 
 #   include "setRootCase.H"
-    
+
 #   include "createTime.H"
 #   include "createMesh.H"
 
 #   include "readConversionProperties.H"
- 
+
     // get the available time-steps
     instantList TimeList = runTime.times();
     Info << TimeList << endl;
@@ -73,7 +73,7 @@ int main(int argc, char *argv[])
             // Set Time
             runTime.setTime(TimeList[n], n);
             word CurTime = runTime.timeName();
-            
+
             IOobjectList objects(mesh, runTime.timeName());
 
 #           include "moveMesh.H"
@@ -81,7 +81,7 @@ int main(int argc, char *argv[])
             // set the filename of the GMV file
             fileName gmvFileName = "plotGMV." + itoa(n);
             OFstream gmvFile(args.rootPath()/args.caseName()/gmvFileName);
-            
+
 #           include "gmvOutputHeader.H"
 #           include "gmvOutput.H"
 #           include "gmvOutputTail.H"

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

@@ -1,14 +1,14 @@
-for(label i=0; i < nTypes; i++)
+for (label i=0; i < nTypes; i++)
 {
     wordList fieldNames = objects.names(fieldTypes[i]);
 
-    if ( fieldTypes[i] == "volScalarField" ) 
+    if (fieldTypes[i] == "volScalarField")
     {
         gmvFile << "variable" << nl;
     }
-    for(label j=0; j < fieldNames.size(); j++)
+    for (label j=0; j < fieldNames.size(); j++)
     {
-        
+
         word fieldName = fieldNames[j];
 
         IOobject fieldObject
@@ -19,8 +19,8 @@ for(label i=0; i < nTypes; i++)
             IOobject::MUST_READ,
             IOobject::NO_WRITE
         );
-        
-        if ( fieldTypes[i] == "volScalarField" ) 
+
+        if (fieldTypes[i] == "volScalarField")
         {
             volScalarField gmvScalarField(fieldObject, mesh);
             gmvFile << fieldName << " 0" << nl;
@@ -30,43 +30,43 @@ for(label i=0; i < nTypes; i++)
             }
             gmvFile << nl;
         }
-        
-        if ( fieldTypes[i] == "volVectorField" ) 
+
+        if (fieldTypes[i] == "volVectorField")
         {
             if (fieldName == vComp)
             {
                 volVectorField gmvVectorField(fieldObject, mesh);
                 gmvFile << "velocity 0" << nl;
-                for(label indx=0;indx<mesh.nCells();indx++)
+                for (label indx=0;indx<mesh.nCells();indx++)
                 {
                     gmvFile << gmvVectorField[indx].x() << " ";
                 }
-                for(label indx=0;indx<mesh.nCells();indx++)
+                for (label indx=0;indx<mesh.nCells();indx++)
                 {
                     gmvFile << gmvVectorField[indx].y() << " ";
                 }
-                for(label indx=0;indx<mesh.nCells();indx++)
+                for (label indx=0;indx<mesh.nCells();indx++)
                 {
                     gmvFile << gmvVectorField[indx].z() << " ";
                 }
                 gmvFile << nl;
             }
         }
-                
-        if ( fieldTypes[i] == "surfaceScalarField" ) 
+
+        if (fieldTypes[i] == "surfaceScalarField")
         {
             // ...
         }
-        
+
     }
 
-    if ( fieldTypes[i] == "lagrangian") 
+    if (fieldTypes[i] == cloud::prefix)
     {
         IOobject lagrangianHeader
         (
             "positions",
             runTime.timeName(),
-            "lagrangian",
+            cloud::prefix,
             mesh,
             IOobject::NO_READ
         );
@@ -74,9 +74,9 @@ for(label i=0; i < nTypes; i++)
         if (lagrangianHeader.headerOk())
         {
             Cloud<passiveParticle> particles(mesh);
-            
-            IOobjectList objects(mesh, runTime.timeName(), "lagrangian");
-            
+
+            IOobjectList objects(mesh, runTime.timeName(), cloud::prefix);
+
             wordList lagrangianScalarNames = objects.names("scalarField");
             wordList lagrangianVectorNames = objects.names("vectorField");
 
@@ -87,7 +87,7 @@ for(label i=0; i < nTypes; i++)
         }
     }
 
-    if ( fieldTypes[i] == "volScalarField" ) 
+    if (fieldTypes[i] == "volScalarField")
     {
         gmvFile << "endvars" << nl;
     }

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

@@ -42,7 +42,7 @@ forAll(lagrangianScalarNames, i)
         (
             name,
             runTime.timeName(),
-            "lagrangian",
+            cloud::prefix,
             mesh,
             IOobject::MUST_READ,
             IOobject::NO_WRITE
@@ -73,7 +73,7 @@ forAll(lagrangianVectorNames, i)
         (
             name,
             runTime.timeName(),
-            "lagrangian",
+            cloud::prefix,
             mesh,
             IOobject::MUST_READ,
             IOobject::NO_WRITE

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

@@ -40,7 +40,7 @@ forAll(lagrangianScalarNames, i)
         (
             name,
             runTime.timeName(),
-            "lagrangian",
+            cloud::prefix,
             mesh,
             IOobject::MUST_READ,
             IOobject::NO_WRITE

applications/utilities/postProcessing/dataConversion/foamToVTK/foamToVTK.C

@@ -225,8 +225,10 @@ labelList getSelectedPatches
 
 int main(int argc, char *argv[])
 {
-#   include "addTimeOptions.H"
+    timeSelector::addOptions();
+
 #   include "addRegionOption.H"
+
     argList::validOptions.insert("fields", "fields");
     argList::validOptions.insert("cellSet", "cellSet name");
     argList::validOptions.insert("faceSet", "faceSet name");
@@ -244,7 +246,6 @@ int main(int argc, char *argv[])
 #   include "setRootCase.H"
 #   include "createTime.H"
 
-
     bool doWriteInternal = !args.options().found("noInternal");
     bool doFaceZones = !args.options().found("noFaceZones");
     bool doLinks = !args.options().found("noLinks");
@@ -312,14 +313,8 @@ int main(int argc, char *argv[])
     }
 
 
-    instantList Times = runTime.times();
+    instantList timeDirs = timeSelector::select0(runTime, args);
 
-    // set startTime and endTime depending on -time and -latestTime options
-#   include "checkTimeOptions.H"
-
-    runTime.setTime(Times[startTime], startTime);
-
-    // Current mesh.
 #   include "createNamedMesh.H"
 
     // VTK/ directory in the case
@@ -359,11 +354,11 @@ int main(int argc, char *argv[])
     // mesh wrapper; does subsetting and decomposition
     vtkMesh vMesh(mesh, cellSetName);
 
-    for (label timeI = startTime; timeI < endTime; timeI++)
+    forAll(timeDirs, timeI)
     {
-        runTime.setTime(Times[timeI], timeI);
+        runTime.setTime(timeDirs[timeI], timeI);
 
-        Info<< "Time " << Times[timeI].name() << endl;
+        Info<< "Time: " << runTime.timeName() << endl;
 
         // Check for new polyMesh/ and update mesh, fvMeshSubset and cell
         // decomposition.
@@ -914,7 +909,7 @@ int main(int argc, char *argv[])
         (
             readDir
             (
-                runTime.timePath()/regionPrefix/"lagrangian",
+                runTime.timePath()/regionPrefix/cloud::prefix,
                 fileName::DIRECTORY
             )
         );
@@ -925,18 +920,18 @@ int main(int argc, char *argv[])
             (
                 mesh,
                 runTime.timeName(),
-                "lagrangian"/cloudDirs[i]
+                cloud::prefix/cloudDirs[i]
             );
 
             IOobject* positionsPtr = sprayObjs.lookup("positions");
 
             if (positionsPtr)
             {
-                mkDir(fvPath/"lagrangian"/cloudDirs[i]);
+                mkDir(fvPath/cloud::prefix/cloudDirs[i]);
 
                 fileName lagrFileName
                 (
-                    fvPath/"lagrangian"/cloudDirs[i]/cloudDirs[i]
+                    fvPath/cloud::prefix/cloudDirs[i]/cloudDirs[i]
                   + "_" + name(timeI) + ".vtk"
                 );
 

applications/utilities/postProcessing/dataConversion/foamToVTK/lagrangianWriter.H

@@ -39,6 +39,7 @@ SourceFiles
 
 #include "globalPointPatch.H"
 #include "OFstream.H"
+#include "Cloud.H"
 #include "volFields.H"
 #include "pointFields.H"
 #include "vtkMesh.H"

applications/utilities/postProcessing/dataConversion/foamToVTK/lagrangianWriterTemplates.C

@@ -41,7 +41,7 @@ void Foam::lagrangianWriter::writeIOField(const wordList& objects)
         (
             object,
             vMesh_.mesh().time().timeName(),
-            "lagrangian"/cloudName_,
+            cloud::prefix/cloudName_,
             vMesh_.mesh(),
             IOobject::MUST_READ,
             IOobject::NO_WRITE,

applications/utilities/postProcessing/dataConversion/foamToVTK/writePointSet.C

@@ -22,8 +22,6 @@ License
     along with OpenFOAM; if not, write to the Free Software Foundation,
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
-Description
-
 \*---------------------------------------------------------------------------*/
 
 #include "writePointSet.H"
@@ -76,7 +74,7 @@ void writePointSet
 
     writeFuns::insert
     (
-        IndirectList<point>(vMesh.mesh().points(), set.toc())(),
+        UIndirectList<point>(vMesh.mesh().points(), set.toc())(),
         ptField
     );