BUG: integratedNonUniformTable: correct offsets (fixes #2614)

- with geometryOrder=1, calculate the edge normals from the adjacent
  faces (area-weighted, inverse distance squared) and also
  use that for the Le() calculation.

  Includes the contributions from processor edge neighbours, so it
  should be consistent on both sides.

  This new method (consider as 'beta') contrasts with the current
  standard method that first calculates area-weighted point normals
  and uses the average of them for the edge normal.

  Enable for testing either with a controlDict OptimisationSwitch entry
  "fa:geometryOrder", or on the command-line:

      solverName -opt-switch=fa:geometryOrder=1

CONTRIBUTORS.md

@@ -5,6 +5,8 @@ It is likely incomplete...
 
 ## Contributors (alphabetical by surname)
 
+- Tetsuo Aoyagi
+- Akira Azami
 - William Bainbridge
 - Gabriel Barajas
 - Kutalmis Bercin
@@ -19,6 +21,7 @@ It is likely incomplete...
 - Bernhard Gschaider
 - Andrew Heather
 - David Hill
+- Yoshiaki Inoue
 - Mattijs Janssens
 - Andrew Jackson
 - Hrvoje Jasak

applications/solvers/acoustic/acousticFoam/Make/options

@@ -11,4 +11,5 @@ EXE_LIBS = \
     -lfvOptions \
     -lmeshTools \
     -lsampling \
-    -lregionFaModels
+    -lregionFaModels \
+    -lfiniteArea

applications/solvers/combustion/PDRFoam/PDRFoamAutoRefine.C

@@ -116,7 +116,7 @@ int main(int argc, char *argv[])
             "normalisedGradP",
             tmagGradP()/max(tmagGradP())
         );
-        normalisedGradP.writeOpt() = IOobject::AUTO_WRITE;
+        normalisedGradP.writeOpt(IOobject::AUTO_WRITE);
         tmagGradP.clear();
 
         ++runTime;

applications/solvers/combustion/fireFoam/Make/options

@@ -1,8 +1,8 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/finiteArea/lnInclude \
-    -I${LIB_SRC}/meshTools/lnInclude \
-    -I${LIB_SRC}/sampling/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
     -I$(LIB_SRC)/lagrangian/distributionModels/lnInclude \

applications/solvers/compressible/rhoPimpleFoam/Make/options

@@ -26,4 +26,5 @@ EXE_LIBS = \
     -ltopoChangerFvMesh \
     -lsampling \
     -latmosphericModels \
-    -lregionFaModels
+    -lregionFaModels \
+    -lfiniteArea

applications/solvers/compressible/rhoSimpleFoam/Make/options

@@ -21,4 +21,5 @@ EXE_LIBS = \
     -lcompressibleTurbulenceModels \
     -lthermoTools \
     -latmosphericModels \
-    -lregionFaModels
+    -lregionFaModels \
+    -lfiniteArea

applications/solvers/heatTransfer/buoyantPimpleFoam/Make/options

@@ -28,4 +28,5 @@ EXE_LIBS = \
     -ldynamicMesh \
     -ldynamicFvMesh \
     -ltopoChangerFvMesh \
-    -lregionFaModels
+    -lregionFaModels \
+    -lfiniteArea

applications/solvers/heatTransfer/buoyantSimpleFoam/Make/options

@@ -22,4 +22,5 @@ EXE_LIBS = \
     -lcompressibleTurbulenceModels \
     -lthermoTools \
     -latmosphericModels \
-    -lregionFaModels
+    -lregionFaModels \
+    -lfiniteArea

applications/solvers/heatTransfer/chtMultiRegionFoam/Make/options

@@ -40,4 +40,5 @@ EXE_LIBS = \
     -lthermoTools \
     -lradiationModels \
     -lregionModels \
-    -lregionFaModels
+    -lregionFaModels \
+    -lfiniteArea

applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/Make/options

@@ -36,5 +36,5 @@ EXE_LIBS = \
     -lfaOptions \
     -lregionModels \
     -lsampling \
-    -lregionFaModels
-
+    -lregionFaModels \
+    -lfiniteArea

applications/solvers/incompressible/pimpleFoam/Make/options

@@ -22,4 +22,5 @@ EXE_LIBS = \
     -ldynamicFvMesh \
     -ltopoChangerFvMesh \
     -latmosphericModels \
-    -lregionFaModels
+    -lregionFaModels \
+    -lfiniteArea

applications/solvers/lagrangian/coalChemistryFoam/Make/options

@@ -1,7 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/finiteArea/lnInclude \
-    -I${LIB_SRC}/meshTools/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude \

applications/solvers/lagrangian/reactingParcelFoam/Make/options

@@ -2,10 +2,10 @@ EXE_INC = \
     -I../reactingParcelFoam \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/finiteArea/lnInclude \
-    -I${LIB_SRC}/meshTools/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/dynamicMesh/lnInclude \
     -I$(LIB_SRC)/dynamicFvMesh/lnInclude \
-    -I${LIB_SRC}/sampling/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
     -I$(LIB_SRC)/lagrangian/distributionModels/lnInclude \

applications/solvers/lagrangian/reactingParcelFoam/reactingHeterogenousParcelFoam/Make/options

@@ -2,8 +2,8 @@ EXE_INC = \
     -I.. \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/finiteArea/lnInclude \
-    -I${LIB_SRC}/sampling/lnInclude \
-    -I${LIB_SRC}/meshTools/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/dynamicMesh/lnInclude \
     -I$(LIB_SRC)/dynamicFvMesh/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \

applications/solvers/lagrangian/reactingParcelFoam/simpleReactingParcelFoam/Make/options

@@ -1,7 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/finiteArea/lnInclude \
-    -I${LIB_SRC}/meshTools/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/sampling/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \

applications/solvers/lagrangian/simpleCoalParcelFoam/Make/options

@@ -2,7 +2,7 @@ EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/finiteArea/lnInclude \
     -I$(LIB_SRC)/fvOptions/lnInclude \
-    -I${LIB_SRC}/meshTools/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude \

applications/solvers/lagrangian/sprayFoam/Make/options

@@ -2,8 +2,8 @@ EXE_INC = \
     -I../reactingParcelFoam \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/finiteArea/lnInclude \
-    -I${LIB_SRC}/meshTools/lnInclude \
-    -I${LIB_SRC}/sampling/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude \

applications/solvers/lagrangian/sprayFoam/engineFoam/Make/options

@@ -4,8 +4,8 @@ EXE_INC = \
     -I../../reactingParcelFoam \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/finiteArea/lnInclude \
-    -I${LIB_SRC}/meshTools/lnInclude \
-    -I${LIB_SRC}/sampling/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude \

applications/solvers/lagrangian/sprayFoam/simpleSprayFoam/Make/options

@@ -2,7 +2,7 @@ EXE_INC = \
     -I$(FOAM_SOLVERS)/lagrangian/reactingParcelFoam/simpleReactingParcelFoam \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/finiteArea/lnInclude \
-    -I${LIB_SRC}/meshTools/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/sampling/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \

applications/solvers/lagrangian/sprayFoam/sprayDyMFoam/Make/options

@@ -4,8 +4,8 @@ EXE_INC = \
     -I../../../compressible/rhoPimpleFoam \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/finiteArea/lnInclude \
-    -I${LIB_SRC}/meshTools/lnInclude \
-    -I${LIB_SRC}/sampling/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude \

applications/solvers/multiphase/MPPICInterFoam/Make/options

@@ -42,4 +42,5 @@ EXE_LIBS = \
     -lregionModels \
     -lregionFaModels \
     -lsurfaceFilmModels \
+    -lfiniteArea \
     -lcompressibleTwoPhaseMixtureTurbulenceModels

applications/solvers/multiphase/icoReactingMultiphaseInterFoam/laserDTRM/DTRMParticle/DTRMParticle.H

@@ -34,8 +34,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef DTRMParticle_H
-#define DTRMParticle_H
+#ifndef Foam_DTRMParticle_H
+#define Foam_DTRMParticle_H
 
 #include "particle.H"
 #include "IOstream.H"
@@ -50,12 +50,13 @@ SourceFiles
 namespace Foam
 {
 
+// Forward Declarations
 class DTRMParticle;
-using namespace Foam::radiation;
 
-// Forward declaration of friend functions
 Ostream& operator<<(Ostream&, const DTRMParticle&);
 
+using namespace Foam::radiation;
+
 /*---------------------------------------------------------------------------*\
                         Class DTRMParticle Declaration
 \*---------------------------------------------------------------------------*/
@@ -130,7 +131,7 @@ public:
             );
 
 
-        // Member functions
+        // Member Functions
 
             inline const interpolationCell<scalar>& aInterp() const;
             inline const interpolationCell<scalar>& eInterp() const;
@@ -232,37 +233,34 @@ public:
     // Access
 
         //- Return const access to the initial position
-        inline const point& p0() const;
+        const point& p0() const noexcept { return p0_; }
 
         //- Return const access to the target position
-        inline const point& p1() const;
+        const point& p1() const noexcept { return p1_; }
 
         //- Return const access to the initial intensity
-        inline scalar I0() const;
+        scalar I0() const noexcept { return I0_; }
 
         //- Return const access to the current intensity
-        inline scalar I() const;
+        scalar I() const noexcept { return I_; }
 
         //- Return const access dA
-        inline scalar dA() const;
+        scalar dA() const noexcept { return dA_; }
 
 
     // Edit
 
         //- Return access to the target position
-        inline point& p1();
+        point& p1() noexcept { return p1_; }
 
         //- Return access to the initial intensity
-        inline scalar& I0();
+        scalar& I0() noexcept { return I0_; }
 
         //- Return access to the current intensity
-        inline scalar& I();
+        scalar& I() noexcept { return I_; }
 
         //- Return access to dA
-        inline scalar& dA();
-
-        //- Return access to reflectedId
-        inline label& reflectedId();
+        scalar& dA() noexcept { return dA_; }
 
 
    // Tracking

applications/solvers/multiphase/icoReactingMultiphaseInterFoam/laserDTRM/DTRMParticle/DTRMParticleI.H

@@ -107,58 +107,4 @@ inline Foam::scalar& Foam::DTRMParticle::trackingData::Q(label celli)
 }
 
 
-inline const Foam::point& Foam::DTRMParticle::p0() const
-{
-    return p0_;
-}
-
-
-inline const Foam::point& Foam::DTRMParticle::p1() const
-{
-    return p1_;
-}
-
-
-inline Foam::scalar Foam::DTRMParticle::I0() const
-{
-    return I0_;
-}
-
-
-inline Foam::scalar Foam::DTRMParticle::I() const
-{
-    return I_;
-}
-
-
-inline Foam::scalar Foam::DTRMParticle::dA() const
-{
-    return dA_;
-}
-
-
-inline Foam::scalar& Foam::DTRMParticle::dA()
-{
-    return dA_;
-}
-
-
-inline Foam::point& Foam::DTRMParticle::p1()
-{
-    return p1_;
-}
-
-
-inline Foam::scalar& Foam::DTRMParticle::I0()
-{
-    return I0_;
-}
-
-
-inline Foam::scalar& Foam::DTRMParticle::I()
-{
-    return I_;
-}
-
-
 // ************************************************************************* //

applications/solvers/multiphase/icoReactingMultiphaseInterFoam/laserDTRM/DTRMParticle/DTRMParticleIO.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2019 OpenCFD Ltd.
+    Copyright (C) 2017-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -59,7 +59,7 @@ Foam::DTRMParticle::DTRMParticle
 {
     if (readFields)
     {
-        if (is.format() == IOstream::ASCII)
+        if (is.format() == IOstreamOption::ASCII)
         {
             is >> p0_ >> p1_ >> I0_ >> I_ >> dA_ >> transmissiveId_;
         }
@@ -115,7 +115,7 @@ void Foam::DTRMParticle::writeProperties
 
 Foam::Ostream& Foam::operator<<(Ostream& os, const DTRMParticle& p)
 {
-    if (os.format() == IOstream::ASCII)
+    if (os.format() == IOstreamOption::ASCII)
     {
         os  << static_cast<const particle&>(p)
             << token::SPACE << p.p0_

applications/solvers/multiphase/icoReactingMultiphaseInterFoam/laserDTRM/laserDTRM.C

@@ -699,7 +699,7 @@ void Foam::radiation::laserDTRM::calculate()
 
             for (label pointi = 0; pointi < lines.size(); pointi += 2)
             {
-                os.write(linePointRef(lines[pointi], lines[pointi+1]));
+                os.writeLine(lines[pointi], lines[pointi+1]);
             }
         }
 

applications/test/CompactIOList/Test-CompactIOList.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2020 OpenCFD Ltd.
+    Copyright (C) 2020-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -49,8 +49,8 @@ int main(int argc, char *argv[])
     #include "setRootCase.H"
     #include "createTime.H"
 
-    IOstream::streamFormat format = IOstream::BINARY;
-    // IOstream::streamFormat format = IOstream::ASCII;
+    IOstreamOption streamOpt(IOstreamOption::BINARY);
+    // IOstreamOption streamOpt(IOstreamOption::ASCII);
 
     const label size = 20000000;
 
@@ -85,11 +85,7 @@ int main(int argc, char *argv[])
             << runTime.cpuTimeIncrement() << " s" << nl << endl;
 
 
-        faces2.writeObject
-        (
-            IOstreamOption(format),
-            true
-        );
+        faces2.writeObject(streamOpt, true);
 
         Info<< "Written old format faceList in = "
             << runTime.cpuTimeIncrement() << " s" << nl << endl;
@@ -145,11 +141,7 @@ int main(int argc, char *argv[])
             << runTime.cpuTimeIncrement() << " s" << nl << endl;
 
 
-        faces2.writeObject
-        (
-            IOstreamOption(format),
-            true
-        );
+        faces2.writeObject(streamOpt, true);
 
         Info<< "Written new format faceList in = "
             << runTime.cpuTimeIncrement() << " s" << nl << endl;

applications/test/DynamicList2/Test-DynamicList2.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021 OpenCFD Ltd.
+    Copyright (C) 2021-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -104,7 +104,7 @@ void readList
 {
     OTstream os;
     os << input;
-    ITstream is("input", os.tokens());
+    ITstream is(os.tokens());
 
     is >> output;
 }
@@ -118,7 +118,7 @@ void readList
 {
     OTstream os;
     os << input;
-    ITstream is("input", os.tokens());
+    ITstream is(os.tokens());
 
     is >> output;
 }

applications/test/FieldFields1/Make/files

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

applications/test/FieldFields1/Test-FieldFields1.C

@@ -0,0 +1,117 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2022 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-FieldFields1
+
+\*---------------------------------------------------------------------------*/
+
+#include "symmTensorField.H"
+#include "tensorField.H"
+#include "FieldFields.H"
+#include "Random.H"
+
+using namespace Foam;
+
+
+template<class Cmpt>
+void printFieldField(const FieldField<Field, Cmpt>& ff)
+{
+    forAll(ff, i)
+    {
+        Info<< i << ": " << flatOutput(ff[i]) << nl;
+    }
+    Info<< nl;
+}
+
+
+template<class Type>
+tmp<Field<Type>> randomField(Random& rnd, label dim)
+{
+    auto tfld = tmp<Field<Type>>::New(dim);
+    auto& fld = tfld.ref();
+
+    for (Type& val : fld)
+    {
+        for (direction cmpt=0; cmpt < pTraits<Type>::nComponents; ++cmpt)
+        {
+            setComponent(val, cmpt) = rnd.position<label>(0, 100);
+        }
+    }
+
+    return tfld;
+}
+
+
+template<class Type>
+tmp<Field<Type>> randomField(label dim)
+{
+    Random rnd;
+    return randomField<Type>(rnd, dim);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    // scalarField
+    {
+        Info<< nl << "scalarFieldField" << nl;
+
+        Random rnd;
+
+        FieldField<Field, scalar> sff1(6);
+        forAll(sff1, i)
+        {
+            sff1.set(i, randomField<scalar>(rnd, 8));
+        }
+
+        printFieldField(sff1);
+
+        Info<< nl << "indexing:" << nl;
+
+        {
+            labelPair index;
+            const label range1 = sff1.size()-1;
+            const label range2 = sff1[0].size()-1;
+
+            for (label iter = 0; iter < 10; ++iter)
+            {
+                index.first() = rnd.position<label>(0, range1);
+                index.second() = rnd.position<label>(0, range2);
+
+                Info<< index << " => " << sff1[index] << nl;
+            }
+        }
+    }
+
+    Info<< nl << "End\n" << nl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/test/FieldFields2/Make/files

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

applications/test/FieldFields2/Make/options

@@ -0,0 +1,2 @@
+/* EXE_INC = */
+/* EXE_LIBS = */

applications/test/FieldFields2/Test-FieldFields2.C

@@ -24,7 +24,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Application
-    Test-tensorFieldFields1
+    Test-FieldFields2
 
 \*---------------------------------------------------------------------------*/
 
@@ -73,21 +73,29 @@ void allocComponents
 }
 
 
-vectorField randomVectorField(label size)
+template<class Type>
+tmp<Field<Type>> randomField(Random& rnd, label dim)
 {
-    Random rnd;
+    auto tfld = tmp<Field<Type>>::New(dim);
+    auto& fld = tfld.ref();
 
-    vectorField vf(size);
-
-    forAll(vf, i)
+    for (Type& val : fld)
     {
-        for (direction cmpt=0; cmpt < vector::nComponents; ++cmpt)
+        for (direction cmpt=0; cmpt < pTraits<Type>::nComponents; ++cmpt)
         {
-            vf[i][cmpt] = rnd.position<label>(0, 100);
+            setComponent(val, cmpt) = rnd.position<label>(0, 100);
         }
     }
 
-    return vf;
+    return tfld;
+}
+
+
+template<class Type>
+tmp<Field<Type>> randomField(label dim)
+{
+    Random rnd;
+    return randomField<Type>(rnd, dim);
 }
 
 
@@ -191,7 +199,7 @@ int main(int argc, char *argv[])
         printFieldField(sf1);
 
         Info<< nl;
-        for (direction cmpt = 0; cmpt < vector::nComponents; ++cmpt)
+        for (direction cmpt = 0; cmpt < pTraits<vector>::nComponents; ++cmpt)
         {
             unzipRow(sf1, cmpt, slice[0]);
 
@@ -253,8 +261,9 @@ int main(int argc, char *argv[])
     {
         Info<< nl << "vectorField" << nl;
 
+        Random rnd;
         FieldField<Field, vector> vf1(1);
-        vf1.set(0, new vectorField(randomVectorField(4)));
+        vf1.set(0, randomField<vector>(rnd, 4));
 
         FixedList<FieldField<Field, scalar>, 3> cmpts;
         allocComponents(cmpts, 4);

applications/test/HashPtrTable/Test-HashPtrTable.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -31,7 +31,10 @@ Description
 #include <memory>
 #include <iostream>
 #include "autoPtr.H"
-#include "HashPtrTable.H"
+#include "refPtr.H"
+#include "tmp.H"
+#include "PtrMap.H"
+#include "primitiveFields.H"
 
 using namespace Foam;
 
@@ -250,6 +253,42 @@ int main()
         Info<< "Table: " << tbl << nl;
     }
 
+    {
+        PtrMap<scalarField> fields;
+
+        {
+            const label patchi = 2;
+
+            scalarField fld1(patchi, 5.0);
+            scalarField fld2(patchi, 8.0);
+
+            // assign from tmp<>
+            fields.set( patchi, (fld1 * fld2));
+        }
+
+        {
+            const label patchi = 3;
+
+            scalarField fld1(patchi, 6.0);
+
+            // From tmp (clone)
+            fields.set(patchi, tmp<scalarField>(fld1));
+        }
+
+        {
+            const label patchi = 4;
+
+            // From refPtr
+            fields.set(patchi, refPtr<scalarField>::New(patchi, 10.0));
+        }
+
+        Info<< nl
+            << "PtrMap:" << nl
+            << fields << endl;
+    }
+
+    Info<< "\nEnd" << nl;
+
     return 0;
 }
 

applications/test/Hashing1/Make/options

@@ -1,3 +1,3 @@
-EXE_INC = ${c++LESSWARN}
+EXE_INC = $(c++LESSWARN)
 
 /* EXE_LIBS = */

applications/test/Hashing2/Make/options

@@ -1,3 +1,3 @@
-EXE_INC = ${c++LESSWARN}
+EXE_INC = $(c++LESSWARN)
 
 /* EXE_LIBS = */

applications/test/HashingSpeed/Make/options

@@ -1,3 +1,3 @@
-EXE_INC = ${c++LESSWARN}
+EXE_INC = $(c++LESSWARN)
 
 /* EXE_LIBS = */

applications/test/IndirectList/Test-IndirectList.C

@@ -146,7 +146,7 @@ int main(int argc, char *argv[])
     {
         Info<<"Writing output to " << binaryOutput << endl;
 
-        OFstream os(binaryOutput, IOstream::BINARY);
+        OFstream os(binaryOutput, IOstreamOption::BINARY);
 
         os.writeEntry("idl1", idl1);
         os.writeEntry("idl2", idl2);

applications/test/Polynomial/Test-Polynomial.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
-    Copyright (C) 2020 OpenCFD Ltd.
+    Copyright (C) 2020-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -132,7 +132,7 @@ int main(int argc, char *argv[])
         OTstream os;
         os << poly;
 
-        ITstream is("input", std::move(os.tokens()));
+        ITstream is(std::move(os.tokens()));
         is >> polyfunc;
     }
 

applications/test/TestTools/TestTools.H

@@ -28,15 +28,14 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
-using namespace Foam;
-
-#include "floatScalar.H"
-#include "doubleScalar.H"
+#include "scalar.H"
 #include "complex.H"
 #include "Matrix.H"
 #include "Random.H"
 #include <chrono>
 
+using namespace Foam;
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 // Total number of unit tests

applications/test/autoPtr/Test-autoPtr.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2020 OpenCFD Ltd.
+    Copyright (C) 2018-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -27,7 +27,6 @@ License
 
 // #define Foam_autoPtr_deprecate_setMethod
 
-#include <memory>
 #include "autoPtr.H"
 #include "labelList.H"
 #include "ListOps.H"
@@ -77,6 +76,14 @@ autoPtr<T> testNullReturn2()
 }
 
 
+template<class T>
+struct DerivedList : public List<T>
+{
+    // Inherit constructors
+    using List<T>::List;
+};
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 //  Main program:
 
@@ -254,6 +261,16 @@ int main(int argc, char *argv[])
         // autoPtr<labelList> ptr2 = testNullReturn2<labelList>();
     }
 
+    {
+        auto input1 = autoPtr<DerivedList<label>>::New(label(10), 1);
+        auto input2 = autoPtr<DerivedList<scalar>>::New(label(10), 1.0);
+
+        autoPtr<labelList> ptr1(std::move(input1));
+
+        // Does not compile: ptr1 = std::move(input2);
+        // Does not compile: ptr1 = autoPtr<List<scalar>>::New(label(10), 2);
+    }
+
 
     return 0;
 }

applications/test/barycentric/Make/files

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

applications/test/barycentric/Make/options

@@ -0,0 +1,2 @@
+/* EXE_INC = */
+/* EXE_LIBS = */

applications/test/barycentric/Test-barycentric.C

@@ -0,0 +1,93 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2022 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-barycentric
+
+Description
+    Some simple tests for barycentric coordinates and transforms
+
+\*---------------------------------------------------------------------------*/
+
+#include "barycentricTensor.H"
+#include "tetrahedron.H"
+#include "vectorField.H"
+#include "IOstreams.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+//  Main program:
+
+int main(int argc, char *argv[])
+{
+    // Tets to test
+    tetPoints tetA
+    (
+        point(0, 0, 0),
+        point(1, 0, 0),
+        point(1, 1, 0),
+        point(1, 1, 1)
+    );
+
+    const barycentricTensor baryT(tetA[0], tetA[1], tetA[2], tetA[3]);
+
+    Info<< nl << "Tet: " << tetA << nl;
+    Info<< "tens:" << baryT << nl;
+
+    for
+    (
+        const barycentric& bary :
+        List<barycentric>
+        ({
+            {0.25, 0.25, 0.25, 0.25},
+            {1, 0, 0, 0},
+            {0, 1, 0, 0},
+            {0, 0, 1, 0},
+            {0, 0, 0, 1},
+            {0, 0, 0, 0}  // Not really valid
+        })
+    )
+    {
+        vector v(tetA.tet().barycentricToPoint(bary));
+        barycentric b(tetA.tet().pointToBarycentric(v));
+
+        Info<< nl
+            << "bary: " << bary << nl
+            << "vec:  " << v << nl
+            // << "Vec:  " << baryT.inner(bary) << nl
+            << "Vec:  " << (baryT & bary) << nl
+            << "bary: " << b << nl
+            // This won't work (needs a differently defined tensor)
+            // << "Bary: " << (v & baryT) << nl
+            ;
+    }
+
+    Info<< "\nEnd\n" << nl;
+
+    return 0;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

applications/test/decomposedBlockData/Test-decomposedBlockData.C

@@ -78,8 +78,8 @@ int main(int argc, char *argv[])
     OFstream os
     (
         objPath,
-        IOstream::BINARY,
-        IOstream::currentVersion,
+        IOstreamOption::BINARY,
+        IOstreamOption::currentVersion,
         runTime.writeCompression()
     );
     if (!os.good())

applications/test/dimField/Test-dimField.C

@@ -42,7 +42,7 @@ namespace Foam
     // Something like an internal state field. Probably only dimensionless
     typedef DimensionedField<uint8_t, volMesh> dimUint8Field;
 
-    defineTemplate2TypeNameAndDebug(dimUint8Field, 0);
+    defineTemplateTypeNameAndDebug(dimUint8Field, 0);
 
 } // End namespace Foam
 #endif

applications/test/dynamicLibrary/Test-dynamicLibrary.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2020-2021 OpenCFD Ltd.
+    Copyright (C) 2020-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -46,8 +46,8 @@ int main(int argc, char *argv[])
     profiling::disable(); // No profiling output
     argList::noBanner();
     argList::noParallel();
+    argList::noFunctionObjects();
     argList::removeOption("case");
-    argList::removeOption("noFunctionObjects");
     argList::addBoolOption("no-close", "Skip dlclose");
     argList::addBoolOption("quiet", "Disable verbosity");
 

applications/test/edges/Test-edges.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017 OpenCFD Ltd.
+    Copyright (C) 2017-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -82,8 +82,7 @@ int main(int argc, char *argv[])
 
     Info<< nl << "hash-like functionality" << nl;
 
-    // doesn't work e4 = -1;
-    e4.start() = e4.end() = -1;
+    e4.clear();
 
     printInfo(e4);
     for (label i : {2, -1, 2, 1, 4, 1, 2, 3})
@@ -93,24 +92,24 @@ int main(int argc, char *argv[])
         printInfo(e4);
     }
 
-    e4.start() = e4.end() = -1;
+    e4.clear();
     Info<< "insert from list\n";
     labelHashSet newIndices({2, -1, 2, 1, 4, 1, 2, 3});
     e4.insert(newIndices.toc());
     printInfo(e4);
 
-    e4.start() = e4.end() = -1;
+    e4.clear();
     Info<< "insert from list\n";
     e4.insert({0, 5, 2, -1, 2, 1, 4, 1, 2, 3});
     printInfo(e4);
 
     FixedList<label, 8> otherIndices{12, 2, -1, 1, 4, 1, 2, 3};
-    e4.start() = e4.end() = -1;
+    e4.clear();
     Info<< "insert from list: " << otherIndices << nl;
     e4.insert(otherIndices);
     printInfo(e4);
 
-    e4.start() = e4.end();
+    e4.a() = e4.b();
     Info<< "erase from list: " << otherIndices << nl;
     Info<< "removed " << e4.erase(otherIndices) << " values" << nl;
     printInfo(e4);

applications/test/faceHashing/Make/options

@@ -1,3 +1,3 @@
-EXE_INC = ${c++LESSWARN}
+EXE_INC = $(c++LESSWARN)
 
 /* EXE_LIBS = */

applications/test/fieldTypes/Make/options

@@ -1,7 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteArea/lnInclude \
-    -I${LIB_SRC}/finiteVolume/lnInclude \
-    -I${LIB_SRC}/meshTools/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude
 
 EXE_LIBS = \
     -lfiniteArea \

applications/test/foamToMetisGraph/foamToMetisGraph.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017 OpenCFD Ltd.
+    Copyright (C) 2017-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -56,7 +56,7 @@ int main(int argc, char *argv[])
     // No. of Nodes = nCells
     // No. of Edges connecting Nodes = nInternalFaces
 
-    OFstream os(args.caseName() + ".graph", IOstream::ASCII);
+    OFstream os(args.caseName() + ".graph", IOstreamOption::ASCII);
 
     os  << "%% metis graph file, of an OpenFOAM mesh %%" << nl
         << "%% nCells=" << mesh.nCells()

applications/test/fvc2D/Test-fvc2D.C

@@ -39,7 +39,7 @@ namespace Foam
 {
     typedef GeometricField<vector2D, fvPatchField, volMesh> volVector2DField;
 
-    defineTemplate2TypeNameAndDebug(volVector2DField::Internal, 0);
+    defineTemplateTypeNameAndDebug(volVector2DField::Internal, 0);
     defineTemplateTypeNameAndDebug(volVector2DField, 0);
 
     typedef fvPatchField<vector2D> fvPatchVector2DField;

applications/test/instant/Test-instant.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018 OpenCFD Ltd.
+    Copyright (C) 2018-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -30,11 +30,31 @@ Description
 
 #include "argList.H"
 #include "instant.H"
+#include "Pair.H"
 #include "fileNameInstant.H"
 #include "DynamicList.H"
 
 using namespace Foam;
 
+template<class T>
+Ostream& printInstant(const UList<T>& times, const label i)
+{
+    if (i >= 0 && i < times.size())
+    {
+        Info<< " (" << times[i] << ")";
+    }
+    return Info;
+}
+
+template<class T>
+Ostream& printInstant(const UList<T>& times, const Pair<label>& range)
+{
+    printInstant(times, range.first());
+    printInstant(times, range.second());
+    return Info;
+}
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 // Main program:
 
@@ -48,6 +68,7 @@ int main(int argc, char *argv[])
     times.append({300.456, "def"});
     times.append({454.456, "xyz"});
     times.append({10, "ten"});
+    times.append({15, "fifteen"});
 
     {
         word timeName("twenty");
@@ -61,6 +82,19 @@ int main(int argc, char *argv[])
     sort(times);
     Info<< "Sorted:" << times << nl;
 
+    for (const scalar val : { -0.5, 5.0, 18.0, 25.0, 450.0, 480.0 })
+    {
+        label start = instant::findStart(times, val);
+        Pair<label> range = instant::findRange(times, val);
+
+        Info<< nl
+            << "time:" << val << nl;
+        Info<< "    start:" << start;
+        printInstant(times, start) << nl;
+
+        Info<< "    range:" << range;
+        printInstant(times, range) << nl;
+    }
 
     DynamicList<fileNameInstant> files;
     files.append(fileNameInstant{});

applications/test/limits/Test-limits.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018 OpenCFD Ltd.
+    Copyright (C) 2018-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -24,10 +24,11 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Description
-    Print max limits.
+    Print some numerical limits.
 
 \*---------------------------------------------------------------------------*/
 
+#include <cmath>
 #include <limits>
 #include "int.H"
 #include "uint.H"
@@ -37,21 +38,63 @@ Description
 
 using namespace Foam;
 
+std::ostream& print(const char* tag, float val)
+{
+    std::cout
+        << tag << val
+        << " 0x" << std::hex << *reinterpret_cast<const uint32_t*>(&val);
+    return std::cout;
+}
+
+
+std::ostream& print(const char* tag, double val)
+{
+    std::cout
+        << tag << val
+        << " 0x" << std::hex << *reinterpret_cast<const uint64_t*>(&val);
+    return std::cout;
+}
+
+
+// Have (float|double)Scalar(GREAT|SMALL|..)
+
+#define PrintFloatLimits(FloatType, NanFunction)                              \
+{                                                                             \
+    print("max:", std::numeric_limits<FloatType>::max());                     \
+    print(" VGREAT:", FloatType##ScalarVGREAT);                               \
+    print(" ROOTVGREAT:", FloatType##ScalarROOTVGREAT) << nl;                 \
+                                                                              \
+    print("min:", std::numeric_limits<FloatType>::min());                     \
+    print(" VSMALL:", FloatType##ScalarVSMALL);                               \
+    print(" ROOTVSMALL:", FloatType##ScalarROOTVSMALL) << nl;                 \
+                                                                              \
+    print("epsilon:", std::numeric_limits<FloatType>::epsilon());             \
+    print(" SMALL:", FloatType##ScalarSMALL);                                 \
+    print(" ROOTSMALL:", FloatType##ScalarROOTSMALL) << nl;                   \
+                                                                              \
+    print("1/epsilon:", 1/std::numeric_limits<FloatType>::epsilon());         \
+    print(" GREAT:", FloatType##ScalarGREAT);                                 \
+    print(" ROOTGREAT:", FloatType##ScalarROOTGREAT) << nl;                   \
+                                                                              \
+    print("nan:", std::NanFunction("nan")) << nl;                             \
+}
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 // Main program:
 
 int main(int argc, char *argv[])
 {
-    //NONE Info<<"int16:" << pTraits<int16_t>::max << nl;
-    Info<< "=max=" << nl;
-    Info<< "uint8:" << pTraits<uint8_t>::max << nl;
-    Info<< "int16:" << std::numeric_limits<int16_t>::max() << nl;
-    Info<< "int32:" << pTraits<int32_t>::max << nl;
-    Info<< "uint32:" << pTraits<uint32_t>::max << nl;
-    Info<< "int64:" << pTraits<int64_t>::max << nl;
-    Info<< "uint64:" << pTraits<uint64_t>::max << nl;
+    //NONE cout<<"int16:" << pTraits<int16_t>::max << nl;
+    cout<< "=max=" << nl;
+    cout<< "uint8:" << pTraits<uint8_t>::max << nl;
+    cout<< "int16:" << std::numeric_limits<int16_t>::max() << nl;
+    cout<< "int32:" << pTraits<int32_t>::max << nl;
+    cout<< "uint32:" << pTraits<uint32_t>::max << nl;
+    cout<< "int64:" << pTraits<int64_t>::max << nl;
+    cout<< "uint64:" << pTraits<uint64_t>::max << nl;
 
-    Info<< nl;
+    cout<< nl;
 
     cout<< "int16:" << std::numeric_limits<int16_t>::max() << nl;
     cout<< "int32:" << pTraits<int32_t>::max << nl;
@@ -59,7 +102,7 @@ int main(int argc, char *argv[])
     cout<< "int64:" << pTraits<int64_t>::max << nl;
     cout<< "uint64:" << pTraits<uint64_t>::max << nl;
 
-    Info<< nl << "=digits=" << nl;
+    cout<< nl << "=digits=" << nl;
 
     cout<< "int16:" << std::numeric_limits<int16_t>::digits << nl;
     cout<< "int32:" << std::numeric_limits<int32_t>::digits << nl;
@@ -70,29 +113,15 @@ int main(int argc, char *argv[])
     cout<< "double:" << std::numeric_limits<double>::digits << nl;
     cout<< "long double:" << std::numeric_limits<long double>::digits << nl;
 
-    Info<< nl << "=float=" << nl;
+    // std::nanl (long double)
+    cout<< nl;
+    cout<< nl << "=float=" << nl;
+    PrintFloatLimits(float, nanf);
 
-    cout<< "max:" << std::numeric_limits<float>::max()
-        << " VGREAT:" << floatScalarVGREAT << nl;
-    cout<< "min:" << std::numeric_limits<float>::min()
-        << " VSMALL:" << floatScalarVSMALL << nl;
-    cout<< "epsilon:" << std::numeric_limits<float>::epsilon()
-        << " SMALL:" << floatScalarSMALL << nl;
-    cout<< "1/epsilon:" << 1.0f/std::numeric_limits<float>::epsilon()
-        << " GREAT:" << floatScalarGREAT << nl;
+    cout<< nl << "=double=" << nl;
+    PrintFloatLimits(double, nan);
 
-    Info<< nl << "=double=" << nl;
-
-    cout<< "max:" << std::numeric_limits<double>::max()
-        << " VGREAT:" << doubleScalarVGREAT << nl;
-    cout<< "min:" << std::numeric_limits<double>::min()
-        << " VSMALL:" << doubleScalarVSMALL << nl;
-    cout<< "epsilon:" << std::numeric_limits<double>::epsilon()
-        << " SMALL:" << doubleScalarSMALL << nl;
-    cout<< "1/epsilon:" << 1.0f/std::numeric_limits<double>::epsilon()
-        << " GREAT:" << doubleScalarGREAT << nl;
-
-    Info << "---\nEnd\n" << endl;
+    cout<< "---\nEnd\n" << std::endl;
 
     return 0;
 }

applications/test/matrices/DiagonalMatrix/Test-DiagonalMatrix.C

@@ -38,8 +38,7 @@ Description
 
 #include "DiagonalMatrix.H"
 #include "RectangularMatrix.H"
-#include "floatScalar.H"
-#include "doubleScalar.H"
+#include "scalar.H"
 #include "complex.H"
 #include "TestTools.H"
 

applications/test/matrices/RectangularMatrix/Test-RectangularMatrix.C

@@ -44,8 +44,7 @@ Note
 
 #include "RectangularMatrix.H"
 #include "SquareMatrix.H"
-#include "floatScalar.H"
-#include "doubleScalar.H"
+#include "scalar.H"
 #include "complex.H"
 #include "IOmanip.H"
 #include "TestTools.H"

applications/test/matrices/SquareMatrix/Test-SquareMatrix.C

@@ -45,8 +45,7 @@ Note
 #include "scalarMatrices.H"
 #include "RectangularMatrix.H"
 #include "SquareMatrix.H"
-#include "floatScalar.H"
-#include "doubleScalar.H"
+#include "scalar.H"
 #include "complex.H"
 #include "IOmanip.H"
 #include "TestTools.H"

applications/test/matrices/SymmetricSquareMatrix/Test-SymmetricSquareMatrix.C

@@ -46,8 +46,7 @@ Note
 #include "RectangularMatrix.H"
 #include "SquareMatrix.H"
 #include "SymmetricSquareMatrix.H"
-#include "floatScalar.H"
-#include "doubleScalar.H"
+#include "scalar.H"
 #include "complex.H"
 #include "IOmanip.H"
 #include "Random.H"

applications/test/momentOfInertia/Test-momentOfInertia.C

@@ -38,7 +38,7 @@ Description
 #include "polyMesh.H"
 #include "ListOps.H"
 #include "face.H"
-#include "tetPointRef.H"
+#include "tetrahedron.H"
 #include "triFaceList.H"
 #include "OFstream.H"
 #include "meshTools.H"

applications/test/openmp/Make/options

@@ -1,4 +1,4 @@
-EXE_INC = ${COMP_OPENMP} /* -UUSE_OMP */
+EXE_INC = $(COMP_OPENMP) /* -UUSE_OMP */
 
 /* Mostly do not need to explicitly link openmp libraries */
-/* EXE_LIBS = ${LINK_OPENMP} */
+/* EXE_LIBS = $(LINK_OPENMP) */

applications/test/parallel-chunks/Test-parallel-chunks.C

@@ -55,7 +55,7 @@ void do_exchangeBuf
     const bool wait
 )
 {
-    const label startOfRequests = Pstream::nRequests();
+    const label startOfRequests = UPstream::nRequests();
 
     // Set up receives
     // ~~~~~~~~~~~~~~~
@@ -132,7 +132,7 @@ void do_exchangeContainer
     const bool wait
 )
 {
-    const label startOfRequests = Pstream::nRequests();
+    const label startOfRequests = UPstream::nRequests();
 
     // Set up receives
     // ~~~~~~~~~~~~~~~

applications/test/primitives/Test-primitives.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -334,7 +334,7 @@ int main(int argc, char *argv[])
 
         DynamicList<char> buf;
 
-        OListStream os(std::move(buf), IOstream::BINARY);
+        OListStream os(std::move(buf), IOstreamOption::BINARY);
         os << srcList;
 
         os.swap(buf); // Recover buffer
@@ -342,7 +342,7 @@ int main(int argc, char *argv[])
         // Read back
         List<scalar> dstList;
 
-        UIListStream is(buf, IOstream::BINARY);
+        UIListStream is(buf, IOstreamOption::BINARY);
         is.setScalarByteSize(sizeof(otherType));
 
         Info<< "Stream scalar-size ("

applications/test/refPtr/Test-refPtr.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2020-2021 OpenCFD Ltd.
+    Copyright (C) 2020-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
@@ -19,6 +19,9 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "primitiveFields.H"
+#include "autoPtr.H"
+#include "refPtr.H"
+#include "tmp.H"
 #include "Switch.H"
 
 using namespace Foam;
@@ -29,6 +32,36 @@ struct myScalarField : public scalarField
 };
 
 
+template<class T>
+void constructInfo()
+{
+    Info<< " move-constructible:"
+        << std::is_move_constructible<T>::value
+        << " move-assignable:"
+        << std::is_move_assignable<T>::value
+        << " nothrow:"
+        << std::is_nothrow_move_assignable<T>::value
+        << " trivially:"
+        << std::is_trivially_move_assignable<T>::value
+        << nl;
+}
+
+
+template<class T>
+void printInfo(const autoPtr<T>& item, const bool verbose = false)
+{
+    Info<< "autoPtr good:" << Switch::name(item.good())
+        << " addr: " << Foam::name(item.get());
+
+    constructInfo<autoPtr<T>>();
+
+    if (verbose && item)
+    {
+        Info<< "content: " << item() << nl;
+    }
+}
+
+
 template<class T>
 void printInfo(const refPtr<T>& item, const bool verbose = false)
 {
@@ -37,15 +70,24 @@ void printInfo(const refPtr<T>& item, const bool verbose = false)
         << " addr: " << Foam::name(item.get())
         << " movable:" << Switch(item.movable());
 
-    Info<< " move-constructible:"
-        << std::is_move_constructible<refPtr<T>>::value
-        << " move-assignable:"
-        << std::is_move_assignable<refPtr<T>>::value
-        << " nothrow:"
-        << std::is_nothrow_move_assignable<refPtr<T>>::value
-        << " trivially:"
-        << std::is_trivially_move_assignable<refPtr<T>>::value
-        << nl;
+    constructInfo<refPtr<T>>();
+
+    if (verbose && item)
+    {
+        Info<< "content: " << item() << nl;
+    }
+}
+
+
+template<class T>
+void printInfo(const tmp<T>& item, const bool verbose = false)
+{
+    Info<< "tmp good:" << Switch::name(item.good())
+        << " pointer:" << Switch::name(item.is_pointer())
+        << " addr: " << Foam::name(item.get())
+        << " movable:" << Switch(item.movable());
+
+    constructInfo<tmp<T>>();
 
     if (verbose && item)
     {
@@ -101,6 +143,62 @@ int main()
         printInfo(tfld3, true);
     }
 
+    {
+        refPtr<scalarField> tfld1;
+        auto aptr = autoPtr<scalarField>::New(2, scalar(2));
+
+        tmp<scalarField> tfld2;
+        printInfo(tfld2, true);
+
+        tfld2 = new scalarField(10, Zero);
+
+    /*
+        tfld2 = aptr.get();
+
+        // tfld1.reset(aptr);
+        // tfld1 = std::move(aptr);
+        // tfld1 = aptr;
+
+        Info<< nl << "From autoPtr" << nl;
+        printInfo(aptr, true);
+        //& Info<< nl << "Construct from autoPtr" << nl;
+        //& // refPtr<scalarField> tfld2(autoPtr<scalarField>::New(10, scalar(2)));
+        //& printInfo(tfld2, true);
+*/
+    }
+
+    {
+        auto aptr1 = autoPtr<labelField>::New(2, Zero);
+        //auto aptr1 = autoPtr<scalarField>::New(2, scalar(2));
+        auto aptr2 = autoPtr<scalarField>::New(2, scalar(2));
+
+        refPtr<scalarField> tfld2(std::move(aptr2));
+
+        // aptr2 = std::move(aptr1);
+    }
+
+    {
+        auto tptr1 = tmp<labelField>::New(2, Zero);
+        auto aptr1 = autoPtr<labelField>::New(2, Zero);
+        auto tfld2 = refPtr<labelField>::New(2, Zero);
+
+        // Deleted: refPtr<labelField> tfld1(aptr1);
+        refPtr<labelField> tfld1;
+
+        // refPtr<labelField> tfld1(std::move(tptr1));
+        // refPtr<labelField> tfld1(tptr1);
+
+        tfld1 = std::move(aptr1);
+
+        // tfld1.reset(aptr1);
+        // tfld1.reset(tfld2);
+
+        // tfld1 = std::move(tptr1);
+        // Does not compile: tfld1.ref(tptr1);
+        // Deleted: tfld1.cref(tptr1);
+        // Deleted: tfld1.ref(aptr1);
+    }
+
     Info<< "\nEnd" << endl;
 
     return 0;

applications/test/scalarOps/Test-scalarOps.C

@@ -126,6 +126,9 @@ int main(int argc, char *argv[])
     testDivide<vector>(vectors);
 
 
+    //(void) compareOp<vector>()(vector::zero, vector::one);
+
+
     Info<< "\nEnd\n" << endl;
 
     return 0;

applications/test/tensorFieldFields1/Make/files

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

applications/test/tensorFields1/Test-tensorFields1.C

@@ -34,21 +34,29 @@ Application
 
 using namespace Foam;
 
-vectorField randomVectorField(label size)
+template<class Type>
+tmp<Field<Type>> randomField(Random& rnd, label dim)
 {
-    Random rnd;
+    auto tfld = tmp<Field<Type>>::New(dim);
+    auto& fld = tfld.ref();
 
-    vectorField vf(size);
-
-    forAll(vf, i)
+    for (Type& val : fld)
     {
-        for (direction cmpt=0; cmpt < vector::nComponents; ++cmpt)
+        for (direction cmpt=0; cmpt < pTraits<Type>::nComponents; ++cmpt)
         {
-            vf[i][cmpt] = rnd.position<label>(0, 100);
+            setComponent(val, cmpt) = rnd.position<label>(0, 100);
         }
     }
 
-    return vf;
+    return tfld;
+}
+
+
+template<class Type>
+tmp<Field<Type>> randomField(label dim)
+{
+    Random rnd;
+    return randomField<Type>(rnd, dim);
 }
 
 
@@ -251,7 +259,7 @@ int main(int argc, char *argv[])
     {
         Info<< nl << "vectorField" << nl;
 
-        vectorField vf1(randomVectorField(4));
+        vectorField vf1(randomField<vector>(4));
         FixedList<scalarField, 3> cmpts(scalarField(vf1.size()));
 
         Info<< nl

applications/test/tetTetOverlap/Test-tetTetOverlap.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2012-2017 OpenFOAM Foundation
+    Copyright (C) 2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -31,7 +32,7 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
-#include "tetPointRef.H"
+#include "tetrahedron.H"
 #include "OFstream.H"
 #include "meshTools.H"
 #include "cut.H"
@@ -44,12 +45,12 @@ void writeOBJ
 (
     Ostream& os,
     label& vertI,
-    const FixedList<point, 4>& tet
+    const tetPoints& tet
 )
 {
-    forAll(tet, fp)
+    for (const point& p : tet)
     {
-        meshTools::writeOBJ(os, tet[fp]);
+        meshTools::writeOBJ(os, p);
     }
     os  << "l " << vertI+1 << ' ' << vertI+2 << nl
         << "l " << vertI+1 << ' ' << vertI+3 << nl
@@ -61,33 +62,27 @@ void writeOBJ
 }
 
 
-tetPointRef makeTetPointRef(const FixedList<point, 4>& p)
-{
-    return tetPointRef(p[0], p[1], p[2], p[3]);
-}
-
-
 int main(int argc, char *argv[])
 {
     // Tets to test
-    FixedList<point, 4> tetA
-    ({
+    tetPoints tetA
+    (
         point(0, 0, 0),
         point(1, 0, 0),
         point(1, 1, 0),
         point(1, 1, 1)
-    });
-    FixedList<point, 4> tetB
-    ({
+    );
+    tetPoints tetB
+    (
         point(0.1, 0.1, 0.1),
         point(1.1, 0.1, 0.1),
         point(1.1, 1.1, 0.1),
         point(1.1, 1.1, 1.1)
-    });
+    );
 
 
     // Do intersection
-    typedef DynamicList<FixedList<point, 4>> tetList;
+    typedef DynamicList<tetPoints> tetList;
     tetList tetsIn1, tetsIn2, tetsOut;
     cut::appendOp<tetList> tetOpIn1(tetsIn1);
     cut::appendOp<tetList> tetOpIn2(tetsIn2);
@@ -155,25 +150,25 @@ int main(int argc, char *argv[])
 
 
     // Check the volumes
-    Info<< "Vol A: " << makeTetPointRef(tetA).mag() << endl;
+    Info<< "Vol A: " << tetA.tet().mag() << endl;
 
     scalar volIn = 0;
-    forAll(tetsIn, i)
+    for (const auto& t : tetsIn)
     {
-        volIn += makeTetPointRef(tetsIn[i]).mag();
+        volIn += t.tet().mag();
     }
     Info<< "Vol A inside B: " << volIn << endl;
 
     scalar volOut = 0;
-    forAll(tetsOut, i)
+    for (const auto& t : tetsOut)
     {
-        volOut += makeTetPointRef(tetsOut[i]).mag();
+        volOut += t.tet().mag();
     }
     Info<< "Vol A outside B: " << volOut << endl;
 
     Info<< "Sum inside and outside: " << volIn + volOut << endl;
 
-    if (mag(volIn + volOut - makeTetPointRef(tetA).mag()) > SMALL)
+    if (mag(volIn + volOut - tetA.tet().mag()) > SMALL)
     {
         FatalErrorInFunction
             << "Tet volumes do not sum up to input tet."

applications/test/timeSelector/Test-timeSelector.C

@@ -63,7 +63,6 @@ int main(int argc, char *argv[])
     argList::addNote("Test timeSelector and TimePaths");
 
     timeSelector::addOptions(true, true);
-    argList::noLibs();
     argList::noFunctionObjects();
 
     argList::addOption("relative", "PATH", "Test relativePath");

applications/test/tmp/Test-tmp.C

@@ -19,6 +19,9 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "primitiveFields.H"
+#include "autoPtr.H"
+#include "refPtr.H"
+#include "tmp.H"
 #include "Switch.H"
 
 using namespace Foam;
@@ -126,6 +129,28 @@ int main()
         printInfo(tfld2);
     }
 
+    {
+        auto tptr1 = refPtr<labelField>::New(2, Zero);
+        auto aptr1 = autoPtr<labelField>::New(2, Zero);
+
+        // Deleted: tmp<labelField> tfld1(aptr1);
+        // tmp<labelField> tfld1(std::move(aptr1));
+        // tmp<labelField> tfld1(std::move(tptr1));
+        tmp<labelField> tfld1;
+        //tfld1.cref(tptr1);
+        //tfld1.cref(aptr1);
+
+        // refPtr<labelField> tfld1(std::move(tptr1));
+        // refPtr<labelField> tfld1(tptr1);
+
+        // tfld1 = std::move(aptr1);
+
+        // tfld1 = std::move(tptr1);
+        // Does not compile: tfld1.ref(tptr1);
+        // Deleted: tfld1.cref(tptr1);
+        // Deleted: tfld1.ref(aptr1);
+    }
+
     Info<< "\nEnd" << endl;
 
     return 0;

applications/test/volField/Test-volField.C

@@ -42,7 +42,7 @@ namespace Foam
     // - still needs some basic boundary conditions!!
     typedef GeometricField<uint8_t, fvPatchField, volMesh> volUint8Field;
 
-    defineTemplate2TypeNameAndDebug(volUint8Field, 0);
+    defineTemplateTypeNameAndDebug(volUint8Field, 0);
 
 } // End namespace Foam
 #endif

applications/utilities/finiteArea/checkFaMesh/printMeshSummary.H

@@ -116,12 +116,16 @@ Description
     {
         const faPatch& p = patches[patchi];
 
-         Info<< "  " << "patch " << p.index()
-             << " (size: " << returnReduce(p.size(), sumOp<label>())
-             << ") name: " << p.name()
-             << nl;
+        // Report physical size (nEdges) not virtual size
+        Info<< "  " << "patch " << p.index()
+            << " (size: " << returnReduce(p.nEdges(), sumOp<label>())
+            << ") name: " << p.name()
+            << nl;
     }
 
+    Info<< "----------------" << nl
+        << "Used polyPatches: " << flatOutput(aMesh.whichPolyPatches()) << nl;
+
 
     // Geometry information
     Info<< nl;

applications/utilities/finiteArea/makeFaMesh/printMeshSummary.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021 OpenCFD Ltd.
+    Copyright (C) 2021-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
@@ -36,12 +36,17 @@ Description
     {
         const faPatch& p = patches[patchi];
 
-         Info<< "  " << "patch " << p.index()
-             << " (size: " << returnReduce(p.size(), sumOp<label>())
-             << ") name: " << p.name()
-             << nl;
+        // Report physical size (nEdges) not virtual size
+        Info<< "  " << "patch " << p.index()
+            << " (size: " << returnReduce(p.nEdges(), sumOp<label>())
+            << ") name: " << p.name()
+            << nl;
     }
 
+    Info<< "----------------" << nl
+        << "Used polyPatches: " << flatOutput(aMesh.whichPolyPatches()) << nl;
+
+
     // Geometry information
     Info<< nl;
     {

applications/utilities/mesh/advanced/refinementLevel/refinementLevel.C

@@ -226,14 +226,18 @@ int main(int argc, char *argv[])
     // Add the boundary patches
     const polyBoundaryMesh& patches = mesh.boundaryMesh();
 
-    List<polyPatch*> p(patches.size());
+    polyPatchList newPatches(patches.size());
 
-    forAll(p, patchi)
+    forAll(newPatches, patchi)
     {
-        p[patchi] = patches[patchi].clone(fMesh.boundaryMesh()).ptr();
+        newPatches.set
+        (
+            patchi,
+            patches[patchi].clone(fMesh.boundaryMesh())
+        );
     }
 
-    fMesh.addFvPatches(p);
+    fMesh.addFvPatches(newPatches);
 
 
     // Refinement level

applications/utilities/mesh/advanced/snappyRefineMesh/snappyRefineMesh.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2019 OpenCFD Ltd.
+    Copyright (C) 2018-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -205,34 +205,43 @@ label addPatch(polyMesh& mesh, const word& patchName)
     {
         const polyBoundaryMesh& patches = mesh.boundaryMesh();
 
-        List<polyPatch*> newPatches(patches.size() + 1);
+        polyPatchList newPatches(patches.size() + 1);
+
+        label nPatches = 0;
 
         // Add empty patch as 0th entry (Note: only since subsetMesh wants this)
         patchi = 0;
-
-        newPatches[patchi] =
-            new emptyPolyPatch
-            (
-                Foam::word(patchName),
-                0,
-                mesh.nInternalFaces(),
-                patchi,
-                patches,
-                emptyPolyPatch::typeName
-            );
-
-        forAll(patches, i)
         {
-            const polyPatch& pp = patches[i];
+            newPatches.set
+            (
+                nPatches,
+                new emptyPolyPatch
+                (
+                    patchName,
+                    0,
+                    mesh.nInternalFaces(),
+                    nPatches,
+                    patches,
+                    emptyPolyPatch::typeName
+                )
+            );
+            ++nPatches;
+        }
 
-            newPatches[i+1] =
+        for (const polyPatch& pp : patches)
+        {
+            newPatches.set
+            (
+                nPatches,
                 pp.clone
                 (
                     patches,
-                    i+1,
+                    nPatches,
                     pp.size(),
                     pp.start()
-                ).ptr();
+                )
+            );
+            ++nPatches;
         }
 
         mesh.removeBoundary();

applications/utilities/mesh/conversion/gmshToFoam/gmshToFoam.C

@@ -1678,7 +1678,7 @@ int main(int argc, char *argv[])
     label defaultPatchID = mesh.boundaryMesh().findPatchID(defaultFacesName);
     if (mesh.boundaryMesh()[defaultPatchID].size() == 0)
     {
-        List<polyPatch*> newPatchPtrList((mesh.boundaryMesh().size() - 1));
+        polyPatchList newPatches((mesh.boundaryMesh().size() - 1));
         label newPatchi = 0;
         forAll(mesh.boundaryMesh(), patchi)
         {
@@ -1686,18 +1686,21 @@ int main(int argc, char *argv[])
             {
                 const polyPatch& patch = mesh.boundaryMesh()[patchi];
 
-                newPatchPtrList[newPatchi] = patch.clone
+                newPatches.set
                 (
-                    mesh.boundaryMesh(),
                     newPatchi,
-                    patch.size(),
-                    patch.start()
-                ).ptr();
-
-                newPatchi++;
+                    patch.clone
+                    (
+                        mesh.boundaryMesh(),
+                        newPatchi,
+                        patch.size(),
+                        patch.start()
+                    )
+                );
+                ++newPatchi;
             }
         }
-        repatcher.changePatches(newPatchPtrList);
+        repatcher.changePatches(newPatches);
     }
 
     // Set the precision of the points data to 10

applications/utilities/mesh/generation/blockMesh/mergePatchPairs.H

@@ -1,30 +1,56 @@
-// Handle merging of patch pairs
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2009 OpenFOAM Foundation
+    Copyright (C) 2017-2022 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
+
+Description
+    Handle merging of patch pairs
+
+\*---------------------------------------------------------------------------*/
+
 {
     wordPairList mergePatchPairs;
 
-    // Read in a list of dictionaries for the merge patch pairs
+    // Read in a list of merge patch pairs
     if
     (
         meshDict.readIfPresent("mergePatchPairs", mergePatchPairs)
      && mergePatchPairs.size()
     )
     {
-        Info<< "Creating merge patch pairs" << nl << endl;
+        Info<< "Merging " << mergePatchPairs.size() << " patch pairs" << nl;
 
-        Info<< "Adding point and face zones" << endl;
+        // Cleanup
+        wordHashSet cleanupPatches(4*mergePatchPairs.size());
+        wordHashSet cleanupPointZones(2*mergePatchPairs.size());
+        wordHashSet cleanupFaceZones(2*mergePatchPairs.size());
+
+        Info<< "    Adding point and face zones" << endl;
         {
-            auto& pzs = mesh.pointZones();
-            pzs.clearAddressing();
-            auto& fzs = mesh.faceZones();
-            fzs.clearAddressing();
+            const auto& pbm = mesh.boundaryMesh();
+
+            auto& pzs = mesh.pointZones(); pzs.clearAddressing();
+            auto& fzs = mesh.faceZones();  fzs.clearAddressing();
 
             forAll(mergePatchPairs, pairi)
             {
+                // Patch pairs
+                const polyPatch& patch0 = pbm[mergePatchPairs[pairi].first()];
+                const polyPatch& patch1 = pbm[mergePatchPairs[pairi].second()];
+
                 const word mergeName
                 (
                     mergePatchPairs[pairi].first()
                   + mergePatchPairs[pairi].second()
-                  + name(pairi)
+                  + Foam::name(pairi)
                 );
 
                 // An empty zone for cut points
@@ -37,40 +63,35 @@
                         pzs
                     )
                 );
+                cleanupPointZones.insert(pzs.last().name());
 
-                // Master patch
-                const word masterPatchName(mergePatchPairs[pairi].first());
-                const polyPatch& masterPatch =
-                    mesh.boundaryMesh()[masterPatchName];
-
+                // Coupling side 0 (master)
                 fzs.append
                 (
                     new faceZone
                     (
-                        mergeName + "MasterZone",
-                        identity(masterPatch.range()),
+                        mergeName + "Side0Zone",
+                        identity(patch0.range()),
                         false, // none are flipped
                         fzs.size(),
                         fzs
                     )
                 );
+                cleanupFaceZones.insert(fzs.last().name());
 
-                // Slave patch
-                const word slavePatchName(mergePatchPairs[pairi].second());
-                const polyPatch& slavePatch =
-                    mesh.boundaryMesh()[slavePatchName];
-
+                // Coupling side 1 (slave)
                 fzs.append
                 (
                     new faceZone
                     (
-                        mergeName + "SlaveZone",
-                        identity(slavePatch.range()),
+                        mergeName + "Side1Zone",
+                        identity(patch1.range()),
                         false, // none are flipped
                         fzs.size(),
                         fzs
                     )
                 );
+                cleanupFaceZones.insert(fzs.last().name());
 
                 // An empty zone for cut faces
                 fzs.append
@@ -82,35 +103,38 @@
                         fzs
                     )
                 );
-            }  // end of all merge pairs
+                cleanupFaceZones.insert(fzs.last().name());
+            }
         }
 
 
-
-        Info<< "Creating attachPolyTopoChanger" << endl;
+        Info<< "    Merging with attachPolyTopoChanger" << endl;
         attachPolyTopoChanger polyMeshAttacher(mesh);
-        polyMeshAttacher.setSize(mergePatchPairs.size());
+        polyMeshAttacher.resize(1);
 
         forAll(mergePatchPairs, pairi)
         {
+            cleanupPatches.insert(mergePatchPairs[pairi].first());
+            cleanupPatches.insert(mergePatchPairs[pairi].second());
+
             const word mergeName
             (
                 mergePatchPairs[pairi].first()
               + mergePatchPairs[pairi].second()
-              + name(pairi)
+              + Foam::name(pairi)
             );
 
             // Add the sliding interface mesh modifier
             polyMeshAttacher.set
             (
-                pairi,
+                0,
                 new slidingInterface
                 (
-                    "couple" + name(pairi),
+                    "couple" + Foam::name(pairi),
                     pairi,
                     polyMeshAttacher,
-                    mergeName + "MasterZone",
-                    mergeName + "SlaveZone",
+                    mergeName + "Side0Zone",
+                    mergeName + "Side1Zone",
                     mergeName + "CutPointZone",
                     mergeName + "CutFaceZone",
                     mergePatchPairs[pairi].first(),
@@ -120,12 +144,135 @@
                     intersection::VISIBLE
                 )
             );
+
+            polyMeshAttacher.attach(false);  // Do not yet remove empty patches
         }
 
-        polyMeshAttacher.attach(true);
+        // Re-do the boundary patches, removing empty merge patches
+        // but keeping any other empty patches
+        {
+            const polyBoundaryMesh& oldPatches = mesh.boundaryMesh();
+
+            polyPatchList newPatches(oldPatches.size());
+            label nNewPatches = 0;
+
+            wordHashSet removedPatches(cleanupPatches.capacity());
+
+            forAll(oldPatches, patchi)
+            {
+                const word& patchName = oldPatches[patchi].name();
+
+                if
+                (
+                    !cleanupPatches.found(patchName)
+                 || returnReduceOr(oldPatches[patchi].size())
+                )
+                {
+                    newPatches.set
+                    (
+                        nNewPatches,
+                        oldPatches[patchi].clone
+                        (
+                            mesh.boundaryMesh(),
+                            nNewPatches,
+                            oldPatches[patchi].size(),
+                            oldPatches[patchi].start()
+                        )
+                    );
+
+                    ++nNewPatches;
+                }
+                else
+                {
+                    removedPatches.insert(patchName);
+                }
+            }
+
+            newPatches.resize(nNewPatches);
+
+            mesh.removeBoundary();
+            mesh.addPatches(newPatches);
+
+            Info<< "Removed " << removedPatches.size()
+                << " empty merged patches:" << nl
+                << "    " << flatOutput(removedPatches.sortedToc()) << endl;
+        }
+
+        // Cleanup empty merged point zones
+        {
+            PtrList<pointZone>& zones = mesh.pointZones();
+            mesh.pointZones().clearAddressing();
+
+            wordHashSet removedZones(2*zones.size());
+
+            label nZones = 0;
+            forAll(zones, zonei)
+            {
+                if
+                (
+                    !cleanupPointZones.found(zones[zonei].name())
+                 || returnReduceOr(zones[zonei].size())
+                )
+                {
+                    zones.set(nZones, zones.release(zonei));
+                    zones[nZones].index() = nZones;  // re-index
+                    ++nZones;
+                }
+                else
+                {
+                    removedZones.insert(zones[zonei].name());
+                }
+            }
+            zones.resize(nZones);
+
+            if (removedZones.size())
+            {
+                Info<< "Removed " << removedZones.size()
+                    << " empty point zones:" << nl
+                    << "    " << flatOutput(removedZones.sortedToc()) << endl;
+            }
+        }
+
+        // Cleanup empty merged face zones
+        {
+            PtrList<faceZone>& zones = mesh.faceZones();
+            mesh.faceZones().clearAddressing();
+
+            wordHashSet removedZones(2*zones.size());
+
+            label nZones = 0;
+            forAll(zones, zonei)
+            {
+                if
+                (
+                    !cleanupFaceZones.found(zones[zonei].name())
+                 || returnReduceOr(zones[zonei].size())
+                )
+                {
+                    zones.set(nZones, zones.release(zonei));
+                    zones[nZones].index() = nZones;  // re-index
+                    ++nZones;
+                }
+                else
+                {
+                    removedZones.insert(zones[zonei].name());
+                }
+            }
+            zones.resize(nZones);
+
+            if (removedZones.size())
+            {
+                Info<< "Removed " << removedZones.size()
+                    << " empty merged face zones:" << nl
+                    << "    " << flatOutput(removedZones.sortedToc()) << endl;
+            }
+        }
     }
     else
     {
-        Info<< nl << "There are no merge patch pairs" << endl;
+        Info<< "No patch pairs to merge" << endl;
     }
 }
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/extrudeToRegionMesh.C

@@ -1397,26 +1397,20 @@ void extrudeGeometricProperties
         {
             Pout<< "Model     :" << faceCentres[facei] << endl
                 << "regionMesh:" << regionMesh.faceCentres()[facei] << endl;
-            faceStr.write
+            faceStr.writeLine
             (
-                linePointRef
-                (
-                    faceCentres[facei],
-                    regionMesh.faceCentres()[facei]
-                )
+                faceCentres[facei],
+                regionMesh.faceCentres()[facei]
             );
         }
         forAll(cellCentres, celli)
         {
             Pout<< "Model     :" << cellCentres[celli] << endl
                 << "regionMesh:" << regionMesh.cellCentres()[celli] << endl;
-            cellStr.write
+            cellStr.writeLine
             (
-                linePointRef
-                (
-                    cellCentres[celli],
-                    regionMesh.cellCentres()[celli]
-                )
+                cellCentres[celli],
+                regionMesh.cellCentres()[celli]
             );
         }
     }

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/PrintTable/PrintTable.C

@@ -152,7 +152,7 @@ void Foam::PrintTable<KeyType, DataType>::print
 
         os  << endl;
 
-        const List<KeyType>& sortedTable = combinedTable.sortedToc();
+        const List<KeyType> sortedTable(combinedTable.sortedToc());
 
         forAll(sortedTable, keyI)
         {

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControlMesh/cellShapeControlMesh.C

@@ -31,7 +31,7 @@ License
 #include "pointIOField.H"
 #include "scalarIOField.H"
 #include "triadIOField.H"
-#include "tetPointRef.H"
+#include "tetrahedron.H"
 #include "plane.H"
 #include "transform.H"
 #include "meshTools.H"

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/fileControl/fileControl.C

@@ -27,7 +27,6 @@ License
 
 #include "fileControl.H"
 #include "addToRunTimeSelectionTable.H"
-#include "tetPointRef.H"
 #include "scalarList.H"
 #include "vectorTools.H"
 #include "pointIOField.H"
@@ -50,9 +49,6 @@ addToRunTimeSelectionTable
 }
 
 
-// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
-
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::fileControl::fileControl

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/searchableSurfaceControl/searchableSurfaceControl.C

@@ -31,7 +31,6 @@ License
 #include "cellSizeFunction.H"
 #include "triSurfaceMesh.H"
 #include "searchableBox.H"
-#include "tetPointRef.H"
 #include "vectorTools.H"
 #include "quaternion.H"
 

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMesh.C

@@ -1687,7 +1687,7 @@ void Foam::conformalVoronoiMesh::move()
                     )
                 )
                 {
-                    multipleIntersections.write(linePointRef(ptA, ptB));
+                    multipleIntersections.writeLine(ptA, ptB);
                 }
             }
         }

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMesh.H

@@ -83,7 +83,7 @@ SourceFiles
 namespace Foam
 {
 
-// Forward declaration of classes
+// Forward Declarations
 class initialPointsMethod;
 class relaxationModel;
 class faceAreaWeightModel;

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C

@@ -1433,18 +1433,15 @@ void Foam::conformalVoronoiMesh::indexDualVertices
 //                         && (mag(snapDir & norm[0]) > 0.5)
 //                        )
 //                        {
-//                            snapping1.write
+//                            snapping1.writeLine
 //                            (
-//                                linePointRef(dual, nearestPointOnTet)
+//                                dual,
+//                                nearestPointOnTet
 //                            );
-//
-//                            snapping2.write
+//                            snapping2.writeLine
 //                            (
-//                                linePointRef
-//                                (
-//                                    nearestPointOnTet,
-//                                    hitInfo.hitPoint()
-//                                )
+//                                nearestPointOnTet,
+//                                hitInfo.hitPoint()
 //                            );
 //
 //                            pts[cit->cellIndex()] = hitInfo.hitPoint();
@@ -1764,9 +1761,10 @@ void Foam::conformalVoronoiMesh::createFacesOwnerNeighbourAndPatches
 
                     if ((*vcit)->real())
                     {
-                        featurePointDualsStr.write
+                        featurePointDualsStr.writeLine
                         (
-                            linePointRef(topoint(vit->point()), (*vcit)->dual())
+                            topoint(vit->point()),
+                            (*vcit)->dual()
                         );
                     }
                 }
@@ -1867,7 +1865,7 @@ void Foam::conformalVoronoiMesh::createFacesOwnerNeighbourAndPatches
                         << " " << vc2->dual()
                         << endl;
 
-                    startCellStr.write(linePointRef(vc1->dual(), vc2->dual()));
+                    startCellStr.writeLine(vc1->dual(), vc2->dual());
 
                     // Get patch by getting face between cells and the two
                     // points on the face that are not the feature vertex

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshIO.C

@@ -1395,10 +1395,7 @@ void Foam::conformalVoronoiMesh::writePointPairs
 
         if (ptPairs_.isPointPair(vA, vB))
         {
-            os.write
-            (
-                linePointRef(topoint(vA->point()), topoint(vB->point()))
-            );
+            os.writeLine(topoint(vA->point()), topoint(vB->point()));
         }
     }
 }

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/indexedCell/indexedCellChecks.C

@@ -26,7 +26,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "plane.H"
-#include "tetPointRef.H"
+#include "tetrahedron.H"
 #include "pointConversion.H"
 #include "CGALTriangulation3DKernel.H"
 

applications/utilities/mesh/generation/foamyMesh/foamyHexMeshBackgroundMesh/foamyHexMeshBackgroundMesh.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2012-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2021 OpenCFD Ltd.
+    Copyright (C) 2016-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -73,7 +73,7 @@ scalar getMergeDistance
     Info<< "Merge tolerance : " << mergeTol << nl
         << "Write tolerance : " << writeTol << endl;
 
-    if (runTime.writeFormat() == IOstream::ASCII && mergeTol < writeTol)
+    if (runTime.writeFormat() == IOstreamOption::ASCII && mergeTol < writeTol)
     {
         FatalErrorInFunction
             << "Your current settings specify ASCII writing with "

applications/utilities/mesh/generation/foamyMesh/foamyQuadMesh/foamyQuadMesh.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2013-2016 OpenFOAM Foundation
-    Copyright (C) 2021 OpenCFD Ltd.
+    Copyright (C) 2021-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -167,28 +167,32 @@ int main(int argc, char *argv[])
     );
 
     Info<< "Constructing patches." << endl;
-    List<polyPatch*> patches(poly2DMesh.patchNames().size());
-    label countPatches = 0;
+    polyPatchList newPatches(poly2DMesh.patchNames().size());
+    label nPatches = 0;
 
-    forAll(patches, patchi)
+    forAll(newPatches, patchi)
     {
         if (poly2DMesh.patchSizes()[patchi] != 0)
         {
-            patches[countPatches] = new polyPatch
+            newPatches.set
             (
-                poly2DMesh.patchNames()[patchi],
-                poly2DMesh.patchSizes()[patchi],
-                poly2DMesh.patchStarts()[patchi],
-                countPatches,
-                pMesh.boundaryMesh(),
-                word::null
+                nPatches,
+                new polyPatch
+                (
+                    poly2DMesh.patchNames()[patchi],
+                    poly2DMesh.patchSizes()[patchi],
+                    poly2DMesh.patchStarts()[patchi],
+                    nPatches,
+                    pMesh.boundaryMesh(),
+                    word::null
+                )
             );
 
-            countPatches++;
+            ++nPatches;
         }
     }
-    patches.setSize(countPatches);
-    pMesh.addPatches(patches);
+    newPatches.resize(nPatches);
+    pMesh.addPatches(newPatches);
 
     if (extrude)
     {

applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C

@@ -616,7 +616,7 @@ scalar getMergeDistance
         << endl;
 
     // check writing tolerance
-    if (mesh.time().writeFormat() == IOstream::ASCII && !dryRun)
+    if (mesh.time().writeFormat() == IOstreamOption::ASCII && !dryRun)
     {
         const scalar writeTol = std::pow
         (
@@ -1342,6 +1342,17 @@ int main(int argc, char *argv[])
     const snapParameters snapParams(snapDict, dryRun);
 
 
+    Info<< "Setting refinement level of surface to be consistent"
+        << " with curvature." << endl;
+    surfaces.setCurvatureMinLevelFields
+    (
+        refineParams.curvature(),
+        meshRefiner.meshCutter().level0EdgeLength()
+    );
+    Info<< "Checked curvature refinement in = "
+        << mesh.time().cpuTimeIncrement() << " s" << nl << endl;
+
+
 
     // Add all the cellZones and faceZones
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

applications/utilities/mesh/manipulation/autoPatch/autoPatch.C

@@ -191,7 +191,7 @@ int main(int argc, char *argv[])
     const PtrList<boundaryPatch>& patches = bMesh.patches();
 
     // Create new list of patches with old ones first
-    List<polyPatch*> newPatchPtrList(patches.size());
+    polyPatchList newPatches(patches.size());
 
     newPatchi = 0;
 
@@ -200,34 +200,41 @@ int main(int argc, char *argv[])
     {
         const polyPatch& patch = mesh.boundaryMesh()[patchi];
 
-        newPatchPtrList[newPatchi] =
+        newPatches.set
+        (
+            newPatchi,
             patch.clone
             (
                 mesh.boundaryMesh(),
                 newPatchi,
                 patch.size(),
                 patch.start()
-            ).ptr();
+            )
+        );
 
-        newPatchi++;
+        ++newPatchi;
     }
 
     // Add new ones with empty size.
     for (label patchi = newPatchi; patchi < patches.size(); patchi++)
     {
-        const boundaryPatch& bp = patches[patchi];
+        const word& patchName = patches[patchi].name();
 
-        newPatchPtrList[newPatchi] = polyPatch::New
+        newPatches.set
         (
-            polyPatch::typeName,
-            bp.name(),
-            0,
-            mesh.nFaces(),
             newPatchi,
-            mesh.boundaryMesh()
-        ).ptr();
+            polyPatch::New
+            (
+                polyPatch::typeName,
+                patchName,
+                0,
+                mesh.nFaces(),
+                newPatchi,
+                mesh.boundaryMesh()
+            )
+        );
 
-        newPatchi++;
+        ++newPatchi;
     }
 
     if (!overwrite)
@@ -238,7 +245,7 @@ int main(int argc, char *argv[])
 
     // Change patches
     repatchPolyTopoChanger polyMeshRepatcher(mesh);
-    polyMeshRepatcher.changePatches(newPatchPtrList);
+    polyMeshRepatcher.changePatches(newPatches);
 
 
     // Change face ordering

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

@@ -40,6 +40,7 @@ License
 #include "vtkSurfaceWriter.H"
 #include "checkTools.H"
 #include "treeBoundBox.H"
+#include "syncTools.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -48,25 +49,113 @@ void Foam::checkPatch
 (
     const bool allGeometry,
     const word& name,
+    const polyMesh& mesh,
     const PatchType& pp,
+    const labelList& meshFaces,
+    const labelList& meshEdges,
     pointSet& points
 )
 {
+    typedef typename PatchType::surfaceTopo TopoType;
+
+    const label globalSize = returnReduce(pp.size(), sumOp<label>());
+
     Info<< "    "
         << setw(20) << name
-        << setw(9) << returnReduce(pp.size(), sumOp<label>())
+        << setw(9) << globalSize
         << setw(9) << returnReduce(pp.nPoints(), sumOp<label>());
 
-    if (!Pstream::parRun())
+    if (globalSize == 0)
+    {
+        Info<< setw(34) << "ok (empty)";
+    }
+    else if (Pstream::parRun())
+    {
+        // Parallel - use mesh edges
+        // - no check for point-pinch
+        // - no check for consistent orientation (if that is posible to
+        //   check?)
+
+        // (see addPatchCellLayer::globalEdgeFaces)
+        // From mesh edge to global face labels. Non-empty sublists only for
+        // pp edges.
+        labelListList globalEdgeFaces(mesh.nEdges());
+
+        const labelListList& edgeFaces = pp.edgeFaces();
+
+        // Global numbering
+        const globalIndex globalFaces(mesh.nFaces());
+
+        forAll(edgeFaces, edgei)
+        {
+            label meshEdgei = meshEdges[edgei];
+            const labelList& eFaces = edgeFaces[edgei];
+
+            // Store face and processor as unique tag.
+            labelList& globalEFaces = globalEdgeFaces[meshEdgei];
+            globalEFaces.setSize(eFaces.size());
+            forAll(eFaces, i)
+            {
+                globalEFaces[i] = globalFaces.toGlobal(meshFaces[eFaces[i]]);
+            }
+            //Pout<< "At edge:" << meshEdgei
+            //    << " ctr:" << mesh.edges()[meshEdgei].centre(mesh.points())
+            //    << " have eFaces:" << globalEdgeFaces[meshEdgei]
+            //    << endl;
+        }
+
+        //DebugVar(globalEdgeFaces);
+
+
+        // Synchronise across coupled edges.
+        syncTools::syncEdgeList
+        (
+            mesh,
+            globalEdgeFaces,
+            ListOps::uniqueEqOp<label>(),
+            labelList()             // null value
+        );
+
+        //DebugVar(globalEdgeFaces);
+        
+        label labelTyp = TopoType::MANIFOLD;
+        forAll(meshEdges, edgei)
+        {
+            const label meshEdgei = meshEdges[edgei];
+            const labelList& globalEFaces = globalEdgeFaces[meshEdgei];
+            if (globalEFaces.size() == 1)
+            {
+                //points.insert(mesh.edges()[meshEdgei]);
+                labelTyp = max(labelTyp, TopoType::OPEN);
+            }
+            else if (globalEFaces.size() == 0 || globalEFaces.size() > 2)
+            {
+                points.insert(mesh.edges()[meshEdgei]);
+                labelTyp = max(labelTyp, TopoType::ILLEGAL);
+            }
+        }
+        reduce(labelTyp, maxOp<label>());
+
+        if (labelTyp == TopoType::MANIFOLD)
+        {
+            Info<< setw(34) << "ok (closed singly connected)";
+        }
+        else if (labelTyp == TopoType::OPEN)
+        {
+            Info<< setw(34)
+                << "ok (non-closed singly connected)";
+        }
+        else
+        {
+            Info<< setw(34)
+                << "multiply connected (shared edge)";
+        }
+    }
+    else
     {
-        typedef typename PatchType::surfaceTopo TopoType;
         TopoType pTyp = pp.surfaceType();
 
-        if (pp.empty())
-        {
-            Info<< setw(34) << "ok (empty)";
-        }
-        else if (pTyp == TopoType::MANIFOLD)
+        if (pTyp == TopoType::MANIFOLD)
         {
             if (pp.checkPointManifold(true, &points))
             {
@@ -549,15 +638,8 @@ Foam::label Foam::checkTopology
     );
 
     {
-        if (!Pstream::parRun())
-        {
-            Info<< "\nChecking patch topology for multiply connected"
+        Info<< "\nChecking patch topology for multiply connected"
                 << " surfaces..." << endl;
-        }
-        else
-        {
-            Info<< "\nChecking basic patch addressing..." << endl;
-        }
 
         const polyBoundaryMesh& patches = mesh.boundaryMesh();
 
@@ -566,11 +648,8 @@ Foam::label Foam::checkTopology
         Info<< "    "
             << setw(20) << "Patch"
             << setw(9) << "Faces"
-            << setw(9) << "Points";
-        if (!Pstream::parRun())
-        {
-            Info<< setw(34) << "Surface topology";
-        }
+            << setw(9) << "Points"
+            << "Surface topology";
         if (allGeometry)
         {
             Info<< " Bounding box";
@@ -583,7 +662,16 @@ Foam::label Foam::checkTopology
 
             if (!isA<processorPolyPatch>(pp))
             {
-                checkPatch(allGeometry, pp.name(), pp, points);
+                checkPatch
+                (
+                    allGeometry,
+                    pp.name(),
+                    mesh,
+                    pp,
+                    identity(pp.size(), pp.start()),
+                    pp.meshEdges(),
+                    points
+                );
                 Info<< endl;
             }
         }
@@ -592,15 +680,8 @@ Foam::label Foam::checkTopology
     }
 
     {
-        if (!Pstream::parRun())
-        {
-            Info<< "\nChecking faceZone topology for multiply connected"
-                << " surfaces..." << endl;
-        }
-        else
-        {
-            Info<< "\nChecking basic faceZone addressing..." << endl;
-        }
+        Info<< "\nChecking faceZone topology for multiply connected"
+            << " surfaces..." << endl;
 
         Pout.setf(ios_base::left);
 
@@ -611,12 +692,8 @@ Foam::label Foam::checkTopology
             Info<< "    "
                 << setw(20) << "FaceZone"
                 << setw(9) << "Faces"
-                << setw(9) << "Points";
-
-            if (!Pstream::parRun())
-            {
-                Info<< setw(34) << "Surface topology";
-            }
+                << setw(9) << "Points"
+                << setw(34) << "Surface topology";
             if (allGeometry)
             {
                 Info<< " Bounding box";
@@ -625,7 +702,16 @@ Foam::label Foam::checkTopology
 
             for (const faceZone& fz : faceZones)
             {
-                checkPatch(allGeometry, fz.name(), fz(), points);
+                checkPatch
+                (
+                    allGeometry,
+                    fz.name(),
+                    mesh,
+                    fz(),           // patch
+                    fz,             // mesh face labels
+                    fz.meshEdges(), // mesh edge labels
+                    points
+                );
                 Info<< endl;
             }
         }

applications/utilities/mesh/manipulation/checkMesh/checkTopology.H

@@ -1,4 +1,4 @@
-#include "label.H"
+#include "labelList.H"
 #include "autoPtr.H"
 
 namespace Foam
@@ -14,7 +14,10 @@ namespace Foam
     (
         const bool allGeometry,
         const word& name,
+        const polyMesh& mesh,
         const PatchType& pp,
+        const labelList& meshFaces,
+        const labelList& meshEdges,
         pointSet& points
     );
 

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

@@ -4,7 +4,7 @@
 #include "polyMeshTools.H"
 #include "zeroGradientFvPatchFields.H"
 #include "syncTools.H"
-#include "tetPointRef.H"
+#include "tetrahedron.H"
 #include "regionSplit.H"
 #include "wallDist.H"
 #include "cellAspectRatio.H"

applications/utilities/mesh/manipulation/createPatch/createPatch.C

@@ -606,7 +606,7 @@ void syncPoints
                 pointField nbrPatchInfo(procPatch.nPoints());
                 {
                     // We do not know the number of points on the other side
-                    // so cannot use Pstream::read.
+                    // so cannot use UIPstream::read
                     IPstream fromNbr
                     (
                         Pstream::commsTypes::blocking,

applications/utilities/mesh/manipulation/mergeMeshes/mergePolyMesh.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2016 OpenCFD Ltd.
+    Copyright (C) 2016-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -136,46 +136,55 @@ void Foam::mergePolyMesh::sortProcessorPatches()
 
     const polyBoundaryMesh& oldPatches = boundaryMesh();
 
-    DynamicList<polyPatch*> newPatches(oldPatches.size());
+    polyPatchList newPatches(oldPatches.size());
 
     labelList oldToSorted(oldPatches.size());
 
+    label nPatches = 0;
+
     forAll(oldPatches, patchi)
     {
         const polyPatch& pp = oldPatches[patchi];
 
         if (!isA<processorPolyPatch>(pp))
         {
-            oldToSorted[patchi] = newPatches.size();
-            newPatches.append
+            newPatches.set
             (
+                nPatches,
                 pp.clone
                 (
                     oldPatches,
-                    oldToSorted[patchi],
+                    nPatches,
                     0,
                     nInternalFaces()
-                ).ptr()
+                )
             );
+
+            oldToSorted[patchi] = nPatches;
+            ++nPatches;
         }
     }
+
     forAll(oldPatches, patchi)
     {
         const polyPatch& pp = oldPatches[patchi];
 
         if (isA<processorPolyPatch>(pp))
         {
-            oldToSorted[patchi] = newPatches.size();
-            newPatches.append
+            newPatches.set
             (
+                nPatches,
                 pp.clone
                 (
                     oldPatches,
                     oldToSorted[patchi],
                     0,
                     nInternalFaces()
-                ).ptr()
+                )
             );
+
+            oldToSorted[patchi] = nPatches;
+            ++nPatches;
         }
     }
 
@@ -461,7 +470,7 @@ void Foam::mergePolyMesh::merge()
     {
         Info<< "Copying old patches" << endl;
 
-        List<polyPatch*> newPatches(patchNames_.size());
+        polyPatchList newPatches(patchNames_.size());
 
         const polyBoundaryMesh& oldPatches = boundaryMesh();
 
@@ -470,7 +479,11 @@ void Foam::mergePolyMesh::merge()
 
         for (patchi = 0; patchi < oldPatches.size(); patchi++)
         {
-            newPatches[patchi] = oldPatches[patchi].clone(oldPatches).ptr();
+            newPatches.set
+            (
+                patchi,
+                oldPatches[patchi].clone(oldPatches)
+            );
         }
 
         Info<< "Adding new patches. " << endl;
@@ -487,15 +500,18 @@ void Foam::mergePolyMesh::merge()
             dict.set("nFaces", 0);
             dict.set("startFace", endOfLastPatch);
 
-            newPatches[patchi] =
+            newPatches.set
             (
-                polyPatch::New
+                patchi,
                 (
-                    patchNames_[patchi],
-                    dict,
-                    patchi,
-                    oldPatches
-                ).ptr()
+                    polyPatch::New
+                    (
+                        patchNames_[patchi],
+                        dict,
+                        patchi,
+                        oldPatches
+                    )
+                )
             );
         }
 

applications/utilities/mesh/manipulation/mirrorMesh/mirrorFvMesh.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2017-2018 OpenCFD Ltd.
+    Copyright (C) 2017-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -404,20 +404,24 @@ Foam::mirrorFvMesh::mirrorFvMesh
     fvMesh& pMesh = mirrorMeshPtr_();
 
     // Add the boundary patches
-    List<polyPatch*> p(newPatchSizes.size());
+    polyPatchList newPatches(newPatchSizes.size());
 
-    forAll(p, patchi)
+    forAll(newPatches, patchi)
     {
-        p[patchi] = boundaryMesh()[patchi].clone
+        newPatches.set
         (
-            pMesh.boundaryMesh(),
             patchi,
-            newPatchSizes[patchi],
-            newPatchStarts[patchi]
-        ).ptr();
+            boundaryMesh()[patchi].clone
+            (
+                pMesh.boundaryMesh(),
+                patchi,
+                newPatchSizes[patchi],
+                newPatchStarts[patchi]
+            )
+        );
     }
 
-    pMesh.addPatches(p);
+    pMesh.addPatches(newPatches);
 }
 
 

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

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2020 OpenCFD Ltd.
+    Copyright (C) 2020-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -55,17 +55,30 @@ int main(int argc, char *argv[])
     (
         "deltaT",
         "time",
-        "Override deltaT for accelerated motion"
+        "Override deltaT (eg, for accelerated motion)"
+    );
+
+    argList::addOption
+    (
+        "endTime",
+        "time",
+        "Override endTime (eg, for shorter tests)"
     );
 
     #include "setRootCase.H"
     #include "createTime.H"
     #include "createNamedMesh.H"
 
-    scalar deltaT = 0;
-    if (args.readIfPresent("deltaT", deltaT))
+    scalar timeVal = 0;
+    if (args.readIfPresent("deltaT", timeVal))
     {
-        runTime.setDeltaT(deltaT);
+        runTime.setDeltaT(timeVal);
+    }
+
+    if (args.readIfPresent("endTime", timeVal))
+    {
+        runTime.stopAt(Time::stopAtControls::saEndTime);
+        runTime.setEndTime(timeVal);
     }
 
     autoPtr<motionSolver> motionPtr = motionSolver::New(mesh);

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

@@ -3,7 +3,7 @@
  */
 
 EXE_INC = \
-    ${COMP_FLAGS} \
+    $(COMP_FLAGS) \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/dynamicMesh/lnInclude \

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

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2017-2020 OpenCFD Ltd.
+    Copyright (C) 2017-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -564,7 +564,7 @@ int main(int argc, char *argv[])
 
             mesh.faceZones()
             (
-                mergePatchName + "MasterZone",
+                mergePatchName + "Side0Zone",
                 true // verbose
             ).resetAddressing(std::move(faceIds), false);
 
@@ -574,7 +574,7 @@ int main(int argc, char *argv[])
 
             mesh.faceZones()
             (
-                mergePatchName + "SlaveZone",
+                mergePatchName + "Side1Zone",
                 true // verbose
             ).resetAddressing(std::move(faceIds), false);
 
@@ -595,8 +595,8 @@ int main(int argc, char *argv[])
                     "couple" + Foam::name(actioni),
                     0,
                     stitcher,
-                    mergePatchName + "MasterZone",
-                    mergePatchName + "SlaveZone",
+                    mergePatchName + "Side0Zone",
+                    mergePatchName + "Side1Zone",
                     mergePatchName + "CutPointZone",
                     cutZoneName,
                     masterPatchName,

applications/utilities/miscellaneous/OSspecific/addr2line/addr2line.C

@@ -43,7 +43,7 @@ Description
 static void usage();
 static void version();
 static std::string getLine(const std::string&, const std::string&);
-static std::string pOpen(const std::string&, int line=0);
+static std::string pipeOpen(const std::string& cmd, const int lineNum = 0);
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -132,51 +132,50 @@ void version()
 }
 
 
-std::string pOpen(const std::string& cmd, int line)
+// Read up to and including lineNum from the piped command
+// Return the final line read
+std::string pipeOpen(const std::string& cmd, int lineNum)
 {
-    std::string res;
+    std::string str;
 
-    FILE* cmdPipe = popen(cmd.c_str(), "r");
-    if (!cmdPipe) return res;
+    FILE* handle = popen(cmd.c_str(), "r");
+    if (!handle) return str;
 
     char* buf = nullptr;
+    size_t len = 0;
+    ssize_t nread;
 
-    // Read line number of lines
-    for (int cnt = 0; cnt <= line; ++cnt)
+    // Read lineNum number of lines
+    for
+    (
+        int cnt = 0;
+        cnt <= lineNum && (nread = ::getline(&buf, &len, handle)) >= 0;
+        ++cnt
+    )
     {
-        size_t linecap = 0;
-        ssize_t linelen = ::getline(&buf, &linecap, cmdPipe);
-
-        if (linelen < 0)
+        if (cnt == lineNum)
         {
-            break;
-        }
+            // Retain the last line, trimming trailing newline
+            str.assign(buf);
 
-        if (cnt == line)
-        {
-            res = std::string(buf);
-
-            // Trim trailing newline
-            if (res.size())
+            if (str.size())
             {
-                res.resize(res.size()-1);
+                str.resize(str.size()-1);
             }
-            break;
         }
     }
 
-    if (buf) free(buf);
+    free(buf);
+    pclose(handle);
 
-    pclose(cmdPipe);
-
-    return res;
+    return str;
 }
 
 
 std::string getLine(const std::string& filename, const std::string& addr)
 {
     std::string line =
-        pOpen
+        pipeOpen
         (
             "echo 'image lookup -va " + addr
           + "'"