initial commit

OpenFOAM-v2112/applications/test/hexRef8/Test-hexRef8.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2013-2016 OpenFOAM Foundation
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    Test-hexRef8
+
+Description
+    Test app for refinement and unrefinement. Runs a few iterations refining
+    and unrefining.
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "Time.H"
+#include "volFields.H"
+#include "surfaceFields.H"
+#include "pointFields.H"
+#include "hexRef8.H"
+#include "mapPolyMesh.H"
+#include "polyTopoChange.H"
+#include "Random.H"
+#include "zeroGradientFvPatchFields.H"
+#include "calculatedPointPatchFields.H"
+#include "pointConstraints.H"
+#include "fvCFD.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Main program:
+int main(int argc, char *argv[])
+{
+    #include "addTimeOptions.H"
+    argList::addArgument("inflate (true|false)");
+    #include "setRootCase.H"
+    #include "createTime.H"
+    #include "createMesh.H"
+
+
+    const pointConstraints& pc = pointConstraints::New(pointMesh::New(mesh));
+
+    const Switch inflate(args[1]);
+
+    if (inflate)
+    {
+        Info<< "Splitting/deleting cells using inflation/deflation" << nl
+            << endl;
+    }
+    else
+    {
+        Info<< "Splitting/deleting cells, introducing points at new position"
+            << nl << endl;
+    }
+
+
+    Random rndGen(0);
+
+
+    // Force generation of V()
+    (void)mesh.V();
+
+
+    // Test mapping
+    // ------------
+
+    // 1. uniform field stays uniform
+    volScalarField one
+    (
+        IOobject
+        (
+            "one",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh,
+        dimensionedScalar("one", dimless, 1.0),
+        zeroGradientFvPatchScalarField::typeName
+    );
+    Info<< "Writing one field "
+        << one.name() << " in " << runTime.timeName() << endl;
+    one.write();
+
+
+    // 2. linear profile gets preserved
+    volScalarField ccX
+    (
+        IOobject
+        (
+            "ccX",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh.C().component(0)
+    );
+    Info<< "Writing x component of cell centres to "
+        << ccX.name()
+        << " in " << runTime.timeName() << endl;
+    ccX.write();
+
+
+    // Uniform surface field
+    surfaceScalarField surfaceOne
+    (
+        IOobject
+        (
+            "surfaceOne",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh,
+        dimensionedScalar("one", dimless, 1.0),
+        calculatedFvsPatchScalarField::typeName
+    );
+    Info<< "Writing surface one field "
+        << surfaceOne.name() << " in " << runTime.timeName() << endl;
+    surfaceOne.write();
+
+
+    // Uniform point field
+    pointScalarField pointX
+    (
+        IOobject
+        (
+            "pointX",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        pointMesh::New(mesh),
+        dimensionedScalar("one", dimless, 1.0),
+        calculatedPointPatchScalarField::typeName
+    );
+    pointX.primitiveFieldRef() = mesh.points().component(0);
+    pointX.correctBoundaryConditions();
+    Info<< "Writing x-component field "
+        << pointX.name() << " in " << runTime.timeName() << endl;
+    pointX.write();
+
+
+
+    // Force allocation of V. Important for any mesh changes since otherwise
+    // old time volumes are not stored
+    const scalar totalVol = gSum(mesh.V());
+
+
+    // Construct refiner. Read initial cell and point levels.
+    hexRef8 meshCutter(mesh);
+
+    // Comparison for inequality
+    const auto isNotEqual = notEqualOp<scalar>(1e-10);
+
+    while (runTime.loop())
+    {
+        Info<< "Time = " << runTime.timeName() << nl << endl;
+
+        if (mesh.globalData().nTotalCells() == 0)
+        {
+            break;
+        }
+
+
+        mesh.moving(false);
+        mesh.topoChanging(false);
+
+        label action = rndGen.position<label>(0, 5);
+
+        if (action == 0)
+        {
+            Info<< nl << "-- moving only" << endl;
+            mesh.movePoints(pointField(mesh.points()));
+        }
+        else if (action == 1 || action == 2)
+        {
+            // Mesh changing engine.
+            polyTopoChange meshMod(mesh);
+
+            if (action == 1)
+            {
+                // Refine
+                label nRefine = mesh.nCells()/20;
+                DynamicList<label> refineCandidates(nRefine);
+
+                for (label i=0; i<nRefine; i++)
+                {
+                    refineCandidates.append
+                    (
+                        rndGen.position<label>(0, mesh.nCells()-1)
+                    );
+                }
+
+                labelList cellsToRefine
+                (
+                    meshCutter.consistentRefinement
+                    (
+                        refineCandidates,
+                        true                  // buffer layer
+                    )
+                );
+                Info<< nl << "-- selected "
+                    << returnReduce(cellsToRefine.size(), sumOp<label>())
+                    << " cells out of " << mesh.globalData().nTotalCells()
+                    << " for refinement" << endl;
+
+                // Play refinement commands into mesh changer.
+                meshCutter.setRefinement(cellsToRefine, meshMod);
+            }
+            else
+            {
+                // Unrefine
+                labelList allSplitPoints(meshCutter.getSplitPoints());
+
+                label nUnrefine = allSplitPoints.size()/20;
+                labelHashSet candidates(2*nUnrefine);
+
+                for (label i=0; i<nUnrefine; i++)
+                {
+                    const label index =
+                        rndGen.position<label>(0, allSplitPoints.size()-1);
+
+                    candidates.insert(allSplitPoints[index]);
+                }
+
+                labelList splitPoints = meshCutter.consistentUnrefinement
+                (
+                    candidates.toc(),
+                    false
+                );
+                Info<< nl << "-- selected "
+                    << returnReduce(splitPoints.size(), sumOp<label>())
+                    << " points out of "
+                    << returnReduce(allSplitPoints.size(), sumOp<label>())
+                    << " for unrefinement" << endl;
+
+                // Play refinement commands into mesh changer.
+                meshCutter.setUnrefinement(splitPoints, meshMod);
+            }
+
+
+
+
+            // Create mesh, return map from old to new mesh.
+            Info<< nl << "-- actually changing mesh" << endl;
+            autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh, inflate);
+
+            // Update fields
+            Info<< nl << "-- mapping mesh data" << endl;
+            mesh.updateMesh(map());
+
+            // Inflate mesh
+            if (map().hasMotionPoints())
+            {
+                Info<< nl << "-- moving mesh" << endl;
+                mesh.movePoints(map().preMotionPoints());
+            }
+
+            // Update numbering of cells/vertices.
+            Info<< nl << "-- mapping hexRef8 data" << endl;
+            meshCutter.updateMesh(map());
+        }
+
+
+        Info<< nl<< "-- Mesh : moving:" << mesh.moving()
+            << " topoChanging:" << mesh.topoChanging()
+            << " changing:" << mesh.changing()
+            << endl;
+
+
+
+        Info<< "Writing fields" << nl << endl;
+        runTime.write();
+
+
+
+        // Check mesh volume conservation
+        if (mesh.moving())
+        {
+            #include "volContinuity.H"
+        }
+        else
+        {
+            if (mesh.V().size() != mesh.nCells())
+            {
+                FatalErrorInFunction
+                    << "Volume not mapped. V:" << mesh.V().size()
+                    << " nCells:" << mesh.nCells()
+                    << exit(FatalError);
+            }
+
+            const scalar newVol = gSum(mesh.V());
+            Info<< "Initial volume = " << totalVol
+                << "  New volume = " << newVol
+                << endl;
+
+            if (mag(newVol-totalVol)/totalVol > 1e-10)
+            {
+                FatalErrorInFunction
+                    << "Volume loss: old volume:" << totalVol
+                    << "  new volume:" << newVol
+                    << exit(FatalError);
+            }
+            else
+            {
+                Info<< "Volume check OK" << nl << endl;
+            }
+        }
+
+
+        // Check constant profile
+        {
+            const scalar max = gMax(one);
+            const scalar min = gMin(one);
+
+            Info<< "Uniform one field min = " << min
+                << "  max = " << max << endl;
+
+            if (isNotEqual(min, 1) || isNotEqual(max, 1))
+            {
+                FatalErrorInFunction
+                    << "Uniform volVectorField not preserved."
+                    << " Min and max should both be 1.0. min:" << min
+                    << " max:" << max
+                    << exit(FatalError);
+            }
+            else
+            {
+                Info<< "Uniform field mapping check OK" << nl << endl;
+            }
+        }
+
+        // Check linear profile
+        {
+            const scalarField diff = ccX-mesh.C().component(0);
+
+            const scalar max = gMax(diff);
+            const scalar min = gMin(diff);
+
+            Info<< "Linear profile field min = " << min
+                << "  max = " << max << endl;
+
+            if (isNotEqual(min, 0) || isNotEqual(max, 0))
+            {
+                Info<< "Linear profile not preserved."
+                    << " Min and max should both be 0.0. min:" << min
+                    << " max:" << max << nl << endl;
+            }
+            else
+            {
+                Info<< "Linear profile mapping check OK" << nl << endl;
+            }
+        }
+
+        // Check face field mapping
+        if (surfaceOne.size())
+        {
+            const scalar max = gMax(surfaceOne.primitiveField());
+            const scalar min = gMin(surfaceOne.primitiveField());
+
+            Info<< "Uniform surface field min = " << min
+                << "  max = " << max << endl;
+
+            if (isNotEqual(min, 1) || isNotEqual(max, 1))
+            {
+                FatalErrorInFunction
+                    << "Uniform surfaceScalarField not preserved."
+                    << " Min and max should both be 1.0. min:" << min
+                    << " max:" << max
+                    << exit(FatalError);
+            }
+            else
+            {
+                Info<< "Uniform surfaceScalarField mapping check OK" << nl
+                    << endl;
+            }
+        }
+
+        runTime.printExecutionTime(Info);
+    }
+
+    Info<< "pc:" << pc.patchPatchPointConstraintPoints().size() << endl;
+
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

OpenFOAM-v2112/applications/test/hexRef8/block/Allrun

+#!/bin/sh
+cd "${0%/*}" || exit                                # Run from this directory
+. ${WM_PROJECT_DIR:?}/bin/tools/RunFunctions        # Tutorial run functions
+#------------------------------------------------------------------------------
+
+application=Test-hexRef8
+
+runApplication wmake ..
+
+runApplication blockMesh
+
+# Run with inflation
+runApplication $application true
+mv "log.$application" "log.$application-inflate"
+
+# Run without inflation
+runApplication $application false
+
+
+#------------------------------------------------------------------------------

OpenFOAM-v2112/applications/test/hexRef8/block/constant/manualDecomposition

+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v2112                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       labelList;
+    location    "constant";
+    object      cellDecomposition;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+400
+(
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+1
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+0
+)
+
+
+// ************************************************************************* //

OpenFOAM-v2112/applications/test/hexRef8/block/constant/transportProperties

+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v2112                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      transportProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+nu              nu [ 0 2 -1 0 0 0 0 ] 0.01;
+
+
+// ************************************************************************* //

OpenFOAM-v2112/applications/test/hexRef8/block/system/blockMeshDict

+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v2112                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      blockMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+scale   1;
+
+vertices
+(
+    (0 0 0)
+    (1 0 0)
+    (1 1 0)
+    (0 1 0)
+    (0 0 1)
+    (1 0 1)
+    (1 1 1)
+    (0 1 1)
+);
+
+blocks
+(
+    hex (0 1 2 3 4 5 6 7) (5 5 5) simpleGrading (1 1 1)
+);
+
+edges
+(
+);
+
+boundary
+(
+    allWalls
+    {
+        type wall;
+        faces
+        (
+            (3 7 6 2)
+            (0 4 7 3)
+            (2 6 5 1)
+            (1 5 4 0)
+            (0 3 2 1)
+            (4 5 6 7)
+        );
+    }
+);
+
+// ************************************************************************* //

OpenFOAM-v2112/applications/test/hexRef8/block/system/controlDict

+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v2112                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+DebugSwitches
+{
+    primitiveMesh       1;
+    polyMesh            1;
+    fvMesh              1;
+    polyTopoChange      1;
+    pointMesh           1;
+    pointConstraints    1;
+}
+
+application     icoFoam;
+
+startFrom       startTime;
+
+startTime       0;
+
+stopAt          endTime;
+
+endTime         30;
+
+deltaT          1;
+
+writeControl    timeStep;
+
+writeInterval   1;
+
+purgeWrite      0;
+
+writeFormat     ascii;
+
+writePrecision  10;
+
+writeCompression off;
+
+timeFormat      general;
+
+timePrecision   6;
+
+runTimeModifiable true;
+
+
+// ************************************************************************* //

OpenFOAM-v2112/applications/test/hexRef8/block/system/fvSchemes

+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v2112                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      fvSchemes;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+ddtSchemes
+{
+    default         Euler;
+}
+
+gradSchemes
+{
+    default         Gauss linear;
+    grad(p)         Gauss linear;
+}
+
+divSchemes
+{
+    default         none;
+    div(phi,U)      Gauss linear;
+}
+
+laplacianSchemes
+{
+    default         Gauss linear orthogonal;
+}
+
+interpolationSchemes
+{
+    default         linear;
+}
+
+snGradSchemes
+{
+    default         orthogonal;
+}
+
+// ************************************************************************* //

OpenFOAM-v2112/applications/test/hexRef8/block/system/fvSolution

+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v2112                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      fvSolution;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+solvers
+{
+    p
+    {
+        solver          PCG;
+        preconditioner  DIC;
+        tolerance       1e-06;
+        relTol          0;
+    }
+
+    U
+    {
+        solver          PBiCGStab;
+        preconditioner  DILU;
+        tolerance       1e-05;
+        relTol          0;
+    }
+}
+
+PISO
+{
+    nCorrectors     2;
+    nNonOrthogonalCorrectors 0;
+    pRefCell        0;
+    pRefValue       0;
+}
+
+
+// ************************************************************************* //

OpenFOAM-v2112/applications/test/instant/Make/files

+Test-instant.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-instant

OpenFOAM-v2112/applications/test/instant/Make/options

+/* EXE_INC = -I$(LIB_SRC)/finiteVolume/lnInclude */
+/* EXE_LIBS = -lfiniteVolume */

OpenFOAM-v2112/applications/test/instant/Test-instant.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2018 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Description
+    Test instant, fileNameInstant
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "instant.H"
+#include "fileNameInstant.H"
+#include "DynamicList.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Main program:
+
+int main(int argc, char *argv[])
+{
+    DynamicList<instant> times;
+
+    times.append(instant{});
+    times.append({12, "abc"});
+    times.append(instant{3.14159});
+    times.append({300.456, "def"});
+    times.append({454.456, "xyz"});
+    times.append({10, "ten"});
+
+    {
+        word timeName("twenty");
+
+        Info<<"move append: " << timeName << nl;
+        times.append({20, std::move(timeName)});
+        Info<<"after append: " << timeName << nl;
+    }
+
+    Info<< nl << "times:" << times << nl;
+    sort(times);
+    Info<< "Sorted:" << times << nl;
+
+
+    DynamicList<fileNameInstant> files;
+    files.append(fileNameInstant{});
+    files.append({12, "twelve"});
+    files.append({3.14, "/path/almost-pi"});
+    files.append({300, "/dev/value"});
+    files.append({454, "/tmp/xyz"});
+    files.append({10, "ten"});
+
+    Info<< nl << "files:" << files << nl;
+    sort(files);
+    Info<< "Sorted:" << files << nl;
+
+
+    Info<< "\nEnd\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

OpenFOAM-v2112/applications/test/io/Make/files

+Test-io.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-io

OpenFOAM-v2112/applications/test/io/Make/options

+/* EXE_INC = */
+/* EXE_LIBS = */

OpenFOAM-v2112/applications/test/io/Test-io.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2018 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    Test-io
+
+Description
+    Test basic stream functionality
+
+\*---------------------------------------------------------------------------*/
+
+#include "IOstreams.H"
+#include "IOmanip.H"
+#include "scalar.H"
+#include "List.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(void)
+{
+    string st("sfdsf  sdfs23df sdf32f .  sdfsdff23/2sf32");
+    Info<<"string: " << st << nl;
+    Info<<"word:   \"" << string::validate<word>(st) << "\"" << endl;
+
+    string st1("1234567");
+
+    Info<< label(st1.size()) << tab << string(word(st1)) << endl;
+
+    Info<< setw(20) << setprecision(3) << 1.234234 << endl;
+
+    Info<< hex << 255 << endl;
+
+
+    Info<< nl << "Formatted fields" << nl;
+
+    const char oldfill = static_cast<OSstream&>(Info).fill();
+
+    Info<< setfill('-');
+    Info<< "|" << setf(ios_base::left) << setw(32) << " foo " << "|" << nl;
+    Info<< "|" << setf(ios_base::left) << setw(10) << " bar " << "|" << nl;
+    Info<< "|" << setf(ios_base::left) << setw(10) << "" << "|" << nl;
+
+    Info<< "resetting fill from (0x" << hex << int(oldfill) << ")" << nl;
+    Info<< setfill(oldfill);
+    Info<< "|" << setf(ios_base::left) << setw(10) << " bar " << "|" << nl;
+
+    Info<< nl << nl;
+
+    Info.operator Foam::OSstream&() << "stop" << endl;
+
+    static_cast<OSstream&>(Info) << "\nEnd\n" << nl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

OpenFOAM-v2112/applications/test/labelRanges/Make/files

+Test-labelRanges.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-labelRanges

OpenFOAM-v2112/applications/test/labelRanges/Make/options

+/* EXE_INC = */
+/* EXE_LIBS = */

OpenFOAM-v2112/applications/test/labelRanges/Test-labelRanges.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2017-2021 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+
+Description
+    Test label ranges
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "labelRanges.H"
+
+using namespace Foam;
+
+void printInfo(const labelRange& range)
+{
+    Info<< "first   " << range.first() << nl
+        << "last    " << range.last() << nl
+        << "min     " << range.min() << nl
+        << "max     " << range.max() << nl
+        << "after   " << range.after() << nl
+        << "begin end " << *range.cbegin() << ' ' << *range.cend() << nl;
+
+    // Info<< "rbegin rend " << *range.rbegin() << ' ' << *range.rend() << nl;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+//  Main program:
+
+int main(int argc, char *argv[])
+{
+    argList::noParallel();
+    argList::noFunctionObjects();
+    argList::addArgument("start size .. startN sizeN");
+    argList::addVerbose("enable labelRange::debug");
+    argList::addNote
+    (
+        "The default is to add ranges, use 'add' and 'del' to toggle\n\n"
+        "Eg, 0 10 30 10 del 20 15"
+    );
+
+    argList args(argc, argv, false, true);
+
+    if (args.verbose())
+    {
+        labelRange::debug = 1;
+    }
+
+    {
+        labelRange range(5, 10);
+        Info<< "identity: " << identity(range) << nl;
+    }
+
+    {
+        Info<<"test sorting" << endl;
+        DynamicList<labelRange> list1(10);
+        list1.append(labelRange(25, 8));
+        list1.append(labelRange(8));
+        list1.append(labelRange(15, 5));
+        list1.append(labelRange(50, -10, true));
+
+        sort(list1);
+        Info<<"sorted" << list1 << endl;
+    }
+
+    {
+        Info<<"test intersections" << endl;
+        labelRange range1(-15, 25);
+        labelRange range2(7, 8);
+        labelRange range3(-20, 8);
+        labelRange range4(50, 8);
+
+        Info<<range1 << " & " << range2
+            << " = " << range1.subset(range2) << nl;
+
+        Info<< range1 << " & " << range3
+            << " = " << range1.subset(range3) << nl;
+
+        Info<< range2 << " & " << range4
+            << " = " << range2.subset(range4) << nl;
+    }
+
+    labelRange range;
+    labelRanges ranges;
+
+    bool removeMode = false;
+    for (label argI=1; argI < args.size()-1; ++argI)
+    {
+        if (args[argI] == "add")
+        {
+            removeMode = false;
+            continue;
+        }
+        else if (args[argI] == "del")
+        {
+            removeMode = true;
+            continue;
+        }
+
+        {
+            label start = args.get<label>(argI);
+            label size  = args.get<label>(argI+1);
+            ++argI;
+
+            range.reset(start, size);
+        }
+
+        Info<< "---------------" << nl;
+        if (removeMode)
+        {
+            Info<< "del " << range << " :";
+            for (auto i : range)
+            {
+                Info<< " " << i;
+            }
+            Info<< nl;
+
+            ranges.remove(range);
+        }
+        else
+        {
+            Info<< "add " << range  << " :";
+            for (auto i : range)
+            {
+                Info<< " " << i;
+            }
+            Info<< nl;
+
+            ranges.add(range);
+        }
+
+        Info<< "<list>" << ranges << "</list>" << nl
+            << "content:";
+        for (auto i : ranges)
+        {
+            Info<< " " << i;
+        }
+        Info<< nl;
+    }
+
+
+    {
+        range.reset(5, 5);
+        Info<< nl << "Tests on " << range << nl;
+
+        printInfo(range);
+
+        range += 3;
+        Info<< "increase size " << range << nl;
+
+        range -= 3;  // Probably not a great idea
+        Info<< "decrease size " << range << nl;
+
+        auto iter = range.begin();
+
+        Info<< "iter: " << *iter << nl;
+        ++iter;
+
+        Info<< "iter: " << *iter << nl;
+
+        iter += 3;
+        Info<< "iter: " << *iter << nl;
+
+        Info<< nl << "reversed:" << nl;
+        forAllConstReverseIters(range, iter)
+        {
+            Info<< ' ' << *iter;
+        }
+        Info<< nl;
+    }
+
+
+    Info<< "\nEnd\n" << endl;
+
+    return 0;
+}
+
+// ************************************************************************* //

OpenFOAM-v2112/applications/test/leastSquareGrad/Make/files

+Test-leastSquareGrad.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-leastSquareGrad

OpenFOAM-v2112/applications/test/leastSquareGrad/Make/options

+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -lmeshTools \
+    -lsampling

OpenFOAM-v2112/applications/test/leastSquareGrad/Test-leastSquareGrad.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2020 DLR
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    Test-leastSquareGrad
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "leastSquareGrad.H"
+#include "labelVector.H"
+#include "Field.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    labelVector geomDim(1,1,-1);
+
+    leastSquareGrad<scalar> lsGrad("polyDegree1", geomDim);
+
+    List<vector> pos
+    ({
+        {0,0,0},
+        {1,0,0},
+        {-1,0,0},
+        {0,1,0},
+        {0,-1,0},
+        // {1,1,0}
+    });
+
+    List<scalar> values
+    ({
+        0, 1, -1, 1, -1
+        //, 2
+    });
+
+
+    Map<List<vector>> posMap;
+
+    posMap.insert(0, pos);
+    posMap.insert(1, pos);
+    posMap.insert(2, pos);
+
+    Map<List<scalar>> valMap;
+
+    valMap.insert(0, values);
+    valMap.insert(1, values);
+    valMap.insert(2, values);
+
+    Info<< lsGrad.grad(posMap, valMap) << nl;
+
+
+    leastSquareGrad<vector> lsGradVec("polyDegree1", geomDim);
+
+    List<vector> valuesVec
+    ({
+        {0,0,0},
+        {1,0,0},
+        {-1,0,0},
+        {1,0,0},
+        {-1,0,0}
+    });
+
+    Map<List<vector>> valMapVec;
+
+    valMapVec.insert(0, valuesVec);
+    valMapVec.insert(1, valuesVec);
+    valMapVec.insert(2, valuesVec);
+
+    Info<< lsGradVec.grad(posMap,valMapVec) << nl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //