CONFIG: bump patch level

- the generic constructor could be called twice in pointPatchField::New,
  which results in an attempt to transfer tokens twice.

META-INFO/api-info

@@ -1,2 +1,2 @@
 api=2012
-patch=0
+patch=210414

applications/solvers/compressible/rhoSimpleFoam/SRFrhoSimpleFoam/EEqn.H

@@ -1,26 +0,0 @@
-{
-    volScalarField& he = thermo.he();
-
-    fvScalarMatrix EEqn
-    (
-        fvm::div(phi, he)
-      + (
-            he.name() == "e"
-          ? fvc::div(phi, volScalarField("Ekp", 0.5*magSqr(U) + p/rho))
-          : fvc::div(phi, volScalarField("K", 0.5*magSqr(U)))
-        )
-      - fvm::laplacian(turbulence->alphaEff(), he)
-     ==
-        fvOptions(rho, he)
-    );
-
-    EEqn.relax();
-
-    fvOptions.constrain(EEqn);
-
-    EEqn.solve();
-
-    fvOptions.correct(he);
-
-    thermo.correct();
-}

applications/solvers/compressible/rhoSimpleFoam/SRFrhoSimpleFoam/Make/files

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

applications/solvers/compressible/rhoSimpleFoam/SRFrhoSimpleFoam/Make/options

@@ -1,21 +0,0 @@
-EXE_INC = \
-    -I$(LIB_SRC)/finiteVolume/cfdTools \
-    -I$(LIB_SRC)/finiteVolume/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude \
-    -I$(LIB_SRC)/sampling/lnInclude \
-    -I$(LIB_SRC)/transportModels/compressible/lnInclude \
-    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
-    -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
-    -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
-
-EXE_LIBS = \
-    -lfiniteVolume \
-    -lfvOptions \
-    -lmeshTools \
-    -lsampling \
-    -lcompressibleTransportModels \
-    -lfluidThermophysicalModels \
-    -lspecie \
-    -lturbulenceModels \
-    -lcompressibleTurbulenceModels \
-    -latmosphericModels

applications/solvers/compressible/rhoSimpleFoam/SRFrhoSimpleFoam/SRFrhoSimpleFoam.C

@@ -1,99 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2011-2017 OpenFOAM Foundation
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Application
-    SRFSimpleFoam
-
-Group
-    grpIncompressibleSolvers
-
-Description
-    Steady-state solver for incompressible, turbulent flow of non-Newtonian
-    fluids in a single rotating frame.
-
-\*---------------------------------------------------------------------------*/
-
-#include "fvCFD.H"
-#include "fluidThermo.H"
-#include "turbulentFluidThermoModel.H"
-#include "simpleControl.H"
-#include "pressureControl.H"
-#include "fvOptions.H"
-#include "SRFModel.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-int main(int argc, char *argv[])
-{
-    argList::addNote
-    (
-        "Steady-state solver for compressible, turbulent flow"
-        " of non-Newtonian fluids in a single rotating frame."
-    );
-
-    #include "postProcess.H"
-
-    #include "addCheckCaseOptions.H"
-    #include "setRootCaseLists.H"
-    #include "createTime.H"
-    #include "createMesh.H"
-    #include "createControl.H"
-    #include "createFields.H"
-    #include "createFieldRefs.H"
-    #include "initContinuityErrs.H"
-
-    turbulence->validate();
-
-    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-    Info<< "\nStarting time loop\n" << endl;
-
-    while (simple.loop())
-    {
-        Info<< "Time = " << runTime.timeName() << nl << endl;
-
-        // --- Pressure-velocity SIMPLE corrector
-        {
-            #include "UrelEqn.H"
-            #include "EEqn.H"
-            #include "pEqn.H"
-        }
-
-        U = Urel + SRF->U();
-
-        turbulence->correct();
-
-        runTime.write();
-
-        runTime.printExecutionTime(Info);
-    }
-
-    Info<< "End\n" << endl;
-
-    return 0;
-}
-
-
-// ************************************************************************* //

applications/solvers/compressible/rhoSimpleFoam/SRFrhoSimpleFoam/UrelEqn.H

@@ -1,22 +0,0 @@
-    // Relative momentum predictor
-
-    tmp<fvVectorMatrix> tUrelEqn
-    (
-        fvm::div(phi, Urel)
-      + turbulence->divDevRhoReff(Urel)
-      + rho*SRF->Su()
-     ==
-        fvOptions(rho, Urel)
-    );
-    fvVectorMatrix& UrelEqn = tUrelEqn.ref();
-
-    UrelEqn.relax();
-
-    fvOptions.constrain(UrelEqn);
-
-    if (simple.momentumPredictor())
-    {
-        solve(UrelEqn == -fvc::grad(p));
-
-        fvOptions.correct(Urel);
-    }

applications/solvers/compressible/rhoSimpleFoam/SRFrhoSimpleFoam/createFieldRefs.H

@@ -1 +0,0 @@
-const volScalarField& psi = thermo.psi();

applications/solvers/compressible/rhoSimpleFoam/SRFrhoSimpleFoam/createFields.H

@@ -1,89 +0,0 @@
-Info<< "Reading thermophysical properties\n" << endl;
-
-autoPtr<fluidThermo> pThermo
-(
-    fluidThermo::New(mesh)
-);
-fluidThermo& thermo = pThermo();
-thermo.validate(args.executable(), "h", "e");
-
-volScalarField& p = thermo.p();
-
-volScalarField rho
-(
-    IOobject
-    (
-        "rho",
-        runTime.timeName(),
-        mesh,
-        IOobject::READ_IF_PRESENT,
-        IOobject::AUTO_WRITE
-    ),
-    thermo.rho()
-);
-
-Info<< "Reading field Urel\n" << endl;
-volVectorField Urel
-(
-    IOobject
-    (
-        "Urel",
-        runTime.timeName(),
-        mesh,
-        IOobject::MUST_READ,
-        IOobject::AUTO_WRITE
-    ),
-    mesh
-);
-
-Info<< "Reading/calculating face flux field phi\n" << endl;
-surfaceScalarField phi
-(
-    IOobject
-    (
-        "phi",
-        runTime.timeName(),
-        mesh,
-        IOobject::READ_IF_PRESENT,
-        IOobject::AUTO_WRITE
-    ),
-    linearInterpolate(rho*Urel) & mesh.Sf()
-);
-
-pressureControl pressureControl(p, rho, simple.dict());
-
-mesh.setFluxRequired(p.name());
-
-Info<< "Creating SRF model\n" << endl;
-autoPtr<SRF::SRFModel> SRF(SRF::SRFModel::New(Urel));
-
-// Construct the absolute velocity
-volVectorField U
-(
-    IOobject
-    (
-        "U",
-        runTime.timeName(),
-        mesh,
-        IOobject::NO_READ,
-        IOobject::AUTO_WRITE
-    ),
-    Urel + SRF->U()
-);
-
-
-Info<< "Creating turbulence model\n" << endl;
-autoPtr<compressible::turbulenceModel> turbulence
-(
-    compressible::turbulenceModel::New
-    (
-        rho,
-        U,
-        phi,
-        thermo
-    )
-);
-
-dimensionedScalar initialMass = fvc::domainIntegrate(rho);
-
-#include "createFvOptions.H"

applications/solvers/compressible/rhoSimpleFoam/SRFrhoSimpleFoam/pEqn.H

@@ -1,109 +0,0 @@
-volScalarField rAUrel(1.0/UrelEqn.A());
-surfaceScalarField rhorAUrelf("rhorAUf", fvc::interpolate(rho*rAUrel));
-volVectorField HbyA(constrainHbyA(rAUrel*UrelEqn.H(), Urel, p));
-tUrelEqn.clear();
-
-bool closedVolume = false;
-
-surfaceScalarField phiHbyA("phiHbyA", fvc::interpolate(rho)*fvc::flux(HbyA));
-
-// Update the pressure BCs to ensure flux consistency
-constrainPressure(p, rho, Urel, phiHbyA, rhorAUrelf);
-
-if (simple.transonic())
-{
-    surfaceScalarField phid
-    (
-        "phid",
-        (fvc::interpolate(psi)/fvc::interpolate(rho))*phiHbyA
-    );
-
-    phiHbyA -= fvc::interpolate(psi*p)*phiHbyA/fvc::interpolate(rho);
-
-    while (simple.correctNonOrthogonal())
-    {
-        fvScalarMatrix pEqn
-        (
-            fvc::div(phiHbyA)
-          + fvm::div(phid, p)
-          - fvm::laplacian(rhorAUrelf, p)
-          ==
-            fvOptions(psi, p, rho.name())
-        );
-
-        // Relax the pressure equation to ensure diagonal-dominance
-        pEqn.relax();
-
-        pEqn.setReference
-        (
-            pressureControl.refCell(),
-            pressureControl.refValue()
-        );
-
-        pEqn.solve();
-
-        if (simple.finalNonOrthogonalIter())
-        {
-            phi = phiHbyA + pEqn.flux();
-        }
-    }
-}
-else
-{
-    closedVolume = adjustPhi(phiHbyA, Urel, p);
-
-    while (simple.correctNonOrthogonal())
-    {
-        fvScalarMatrix pEqn
-        (
-            fvc::div(phiHbyA)
-          - fvm::laplacian(rhorAUrelf, p)
-          ==
-            fvOptions(psi, p, rho.name())
-        );
-
-        pEqn.setReference
-        (
-            pressureControl.refCell(),
-            pressureControl.refValue()
-        );
-
-        pEqn.solve();
-
-        if (simple.finalNonOrthogonalIter())
-        {
-            phi = phiHbyA + pEqn.flux();
-        }
-    }
-}
-
-#include "incompressible/continuityErrs.H"
-
-// Explicitly relax pressure for momentum corrector
-p.relax();
-
-Urel = HbyA - rAUrel*fvc::grad(p);
-Urel.correctBoundaryConditions();
-fvOptions.correct(Urel);
-
-bool pLimited = pressureControl.limit(p);
-
-// For closed-volume cases adjust the pressure and density levels
-// to obey overall mass continuity
-if (closedVolume)
-{
-    p += (initialMass - fvc::domainIntegrate(psi*p))
-        /fvc::domainIntegrate(psi);
-}
-
-if (pLimited || closedVolume)
-{
-    p.correctBoundaryConditions();
-}
-
-rho = thermo.rho();
-
-if (!simple.transonic())
-{
-    rho.relax();
-}

applications/solvers/electromagnetics/magneticFoam/magnet.H

@@ -44,7 +44,11 @@ SourceFiles
 namespace Foam
 {
 
-// Forward Declarations
+// Forward declaration of classes
+class Istream;
+class Ostream;
+
+// Forward declaration of friend functions and operators
 class magnet;
 Istream& operator>>(Istream&, magnet&);
 Ostream& operator<<(Ostream&, const magnet&);

applications/test/syncTools/Test-syncTools.C

@@ -6,7 +6,6 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -38,8 +37,6 @@ Description
 #include "Time.H"
 #include "Random.H"
 #include "PackedList.H"
-#include "flipOp.H"
-#include "pointList.H"
 
 using namespace Foam;
 
@@ -226,6 +223,8 @@ void testSparseData(const polyMesh& mesh, Random& rndGen)
             fullData[meshPointi] = pt;
         }
 
+        //Pout<< "sparseData:" << sparseData << endl;
+
         syncTools::syncPointMap
         (
             mesh,
@@ -310,6 +309,8 @@ void testSparseData(const polyMesh& mesh, Random& rndGen)
             fullData[meshEdgeI] = pt;
         }
 
+        //Pout<< "sparseData:" << sparseData << endl;
+
         syncTools::syncEdgeMap
         (
             mesh,
@@ -407,7 +408,7 @@ void testPointSync(const polyMesh& mesh, Random& rndGen)
     {
         labelList nMasters(mesh.nPoints(), Zero);
 
-        const bitSet isMasterPoint(syncTools::getMasterPoints(mesh));
+        bitSet isMasterPoint(syncTools::getMasterPoints(mesh));
 
         forAll(isMasterPoint, pointi)
         {
@@ -483,7 +484,7 @@ void testEdgeSync(const polyMesh& mesh, Random& rndGen)
     {
         labelList nMasters(edges.size(), Zero);
 
-        const bitSet isMasterEdge(syncTools::getMasterEdges(mesh));
+        bitSet isMasterEdge(syncTools::getMasterEdges(mesh));
 
         forAll(isMasterEdge, edgeI)
         {
@@ -518,310 +519,6 @@ void testEdgeSync(const polyMesh& mesh, Random& rndGen)
 }
 
 
-typedef Pair<point> PointPair;
-class edgePointCombineOp
-{
-public:
-    void operator()(PointPair& x, const PointPair& y) const
-    {
-        if
-        (
-            (y[0] < x[0])
-         || (y[0] == x[0] && y[1] < x[1])
-        )
-        {
-            x = y;
-        }
-    }
-};
-class edgePointTransformOp
-{
-public:
-    void operator()
-    (
-        const vectorTensorTransform& vt,
-        const bool forward,
-        List<PointPair>& fld
-    ) const
-    {
-        pointField points0(fld.size());
-        pointField points1(fld.size());
-        forAll(fld, i)
-        {
-            points0[i] = fld[i].first();
-            points1[i] = fld[i].second();
-        }
-
-        pointField points0New;
-        pointField points1New;
-        if (forward)
-        {
-            points0New = vt.transformPosition(points0);
-            points1New = vt.transformPosition(points1);
-        }
-        else
-        {
-            points0New = vt.invTransformPosition(points0);
-            points1New = vt.invTransformPosition(points1);
-        }
-
-        forAll(fld, i)
-        {
-            fld[i] = PointPair(points0New[i], points1New[i]);
-        }
-    }
-};
-class edgePointFlipOp
-{
-public:
-    PointPair operator()(const PointPair& val) const
-    {
-        PointPair newVal(val);
-        newVal.flip();
-        return newVal;
-    }
-};
-void testEdgeFlip2(const polyMesh& mesh, Random& rndGen)
-{
-    Info<< nl << "Testing edge-wise (oriented) data synchronisation." << endl;
-
-    const edgeList& edges = mesh.edges();
-    const pointField& points = mesh.points();
-
-    // Test position.
-
-    List<PointPair> synEdgeEnds(edges.size());
-    {
-        forAll(synEdgeEnds, edgeI)
-        {
-            const edge& e = edges[edgeI];
-            synEdgeEnds[edgeI] = PointPair
-            (
-                points[e[0]],
-                points[e[1]]
-            );
-        }
-    }
-
-    // 1. Ignore flipping
-    {
-        List<PointPair> fld(synEdgeEnds);
-
-        syncTools::syncEdgeList
-        (
-            mesh,
-            fld,
-            edgePointCombineOp(),
-            PointPair(point::max, point::max),
-            edgePointTransformOp(),
-            noOp()
-        );
-
-        forAll(fld, edgeI)
-        {
-            const edge& e = edges[edgeI];
-            const PointPair edgeEnd
-            (
-                points[e[0]],
-                points[e[1]]
-            );
-
-            const PointPair& sync = fld[edgeI];
-
-            if
-            (
-                (mag(edgeEnd[0] - sync[0]) > SMALL)
-             || (mag(edgeEnd[1] - sync[1]) > SMALL)
-            )
-            {
-                WarningInFunction
-                    << "Edge " << edgeI
-                    << " original endpoints " << edgeEnd
-                    << " synced endpoints " << sync
-                    << endl;
-            }
-        }
-    }
-
-    // 2. Use flipping operator. Should produce no warnings
-    {
-        syncTools::syncEdgeList
-        (
-            mesh,
-            synEdgeEnds,
-            edgePointCombineOp(),
-            PointPair(point::max, point::max),
-            edgePointTransformOp(),
-            edgePointFlipOp()
-        );
-
-        forAll(synEdgeEnds, edgeI)
-        {
-            const edge& e = edges[edgeI];
-            const PointPair edgeEnd
-            (
-                points[e[0]],
-                points[e[1]]
-            );
-
-            const PointPair& sync = synEdgeEnds[edgeI];
-
-            if
-            (
-                (mag(edgeEnd[0] - sync[0]) > SMALL)
-             || (mag(edgeEnd[1] - sync[1]) > SMALL)
-            )
-            {
-                FatalErrorInFunction
-                    << "Edge " << edgeI
-                    << " original endpoints " << edgeEnd
-                    << " synced endpoints " << sync
-                    << exit(FatalError);
-            }
-        }
-    }
-}
-
-
-void testEdgeFlip(const polyMesh& mesh, Random& rndGen)
-{
-    Info<< nl << "Testing edge-wise (oriented) data synchronisation."
-        << endl;
-
-    const edgeList& edges = mesh.edges();
-    const pointField& points = mesh.points();
-
-    // Test vector.
-
-    vectorField synEdgeVecs(edges.size());
-    {
-        forAll(synEdgeVecs, edgeI)
-        {
-            synEdgeVecs[edgeI] = edges[edgeI].unitVec(points);
-        }
-    }
-
-    // Without flipping (should produce warnings)
-    {
-        vectorField fld(synEdgeVecs);
-        // Ignore flipping
-        syncTools::syncEdgeList
-        (
-            mesh,
-            fld,
-            minEqOp<vector>(),
-            point::max
-        );
-
-        forAll(fld, edgeI)
-        {
-            const edge& e = edges[edgeI];
-            const vector eVec(e.unitVec(points));
-
-            if ((eVec & fld[edgeI]) < (1-SMALL))
-            {
-                WarningInFunction
-                    << "Edge " << edgeI
-                    << " at " << e.line(points)
-                    << " original vector " << eVec
-                    << " synced vector " << fld[edgeI]
-                    << " diff:" << (eVec & fld[edgeI])
-                    << endl;
-            }
-        }
-    }
-
-
-    // With consistent flipping. Should never produce difference
-    {
-        syncTools::syncEdgeList
-        (
-            mesh,
-            synEdgeVecs,
-            minMagSqrEqOp<vector>(),
-            point::max,
-            mapDistribute::transform(),
-            flipOp()
-        );
-
-        forAll(synEdgeVecs, edgeI)
-        {
-            const edge& e = edges[edgeI];
-            const vector eVec(e.unitVec(points));
-
-            if ((eVec & synEdgeVecs[edgeI]) < (1-SMALL))
-            {
-                FatalErrorInFunction
-                    << "Edge " << edgeI
-                    << " at " << e.line(points)
-                    << " original vector " << eVec
-                    << " synced vector " << synEdgeVecs[edgeI]
-                    << " diff:" << (eVec & synEdgeVecs[edgeI])
-                    << exit(FatalError);
-            }
-        }
-    }
-}
-
-
-class pointListOps
-{
-public:
-
-    void operator()(pointList& lhs, const pointList& rhs) const
-    {
-        forAll(lhs, i)
-        {
-            point& l = lhs[i];
-            const point& r = rhs[i];
-            maxMagSqrEqOp<vector>()(l, r);
-        }
-    }
-
-    void operator()
-    (
-        const vectorTensorTransform& vt,
-        const bool forward,
-        List<pointList>& fld
-    ) const
-    {
-        if (forward)
-        {
-            for (auto& elems : fld)
-            {
-                for (auto& elem : elems)
-                {
-                    elem = vt.transformPosition(elem);
-                }
-            }
-        }
-        else
-        {
-            for (auto& elems : fld)
-            {
-                for (auto& elem : elems)
-                {
-                    elem = vt.invTransformPosition(elem);
-                }
-            }
-        }
-    }
-
-    //- Transform patch-based field
-    void operator()(const coupledPolyPatch& cpp, List<pointList>& fld) const
-    {
-        forAll(fld, facei)
-        {
-            pointList& pts = fld[facei];
-            for (auto& pt : pts)
-            {
-                cpp.transformPosition(pt, facei);
-            }
-        }
-    }
-};
-
-
 void testFaceSync(const polyMesh& mesh, Random& rndGen)
 {
     Info<< nl << "Testing face-wise data synchronisation." << endl;
@@ -851,58 +548,12 @@ void testFaceSync(const polyMesh& mesh, Random& rndGen)
         }
     }
 
-
-    // Test non-contiguous data (uses streaming)
-
-    {
-        List<pointList> syncedFc(mesh.nFaces());
-
-        const pointField& fcs = mesh.faceCentres();
-        forAll(fcs, facei)
-        {
-            const point& fc = fcs[facei];
-            syncedFc[facei].setSize(2, fc);
-        }
-
-        SubList<pointList> bndValues
-        (
-            syncedFc,
-            mesh.nBoundaryFaces(),
-            mesh.nInternalFaces()
-        );
-        syncTools::syncBoundaryFaceList
-        (
-            mesh,
-            bndValues,
-            pointListOps(), //does maxMagSqrEqOp<pointList>()
-            pointListOps()  //transforms all
-        );
-
-        forAll(syncedFc, facei)
-        {
-            const point& fc = fcs[facei];
-            const pointList& fld = syncedFc[facei];
-            forAll(fld, i)
-            {
-                if (mag(fld[i] - fc) > SMALL)
-                {
-                    FatalErrorInFunction
-                        << "Face " << facei
-                        << " original centre " << fc
-                        << " synced centre " << fld[i]
-                        << exit(FatalError);
-                }
-            }
-        }
-    }
-
-
     // Test masterFaces
 
     {
         labelList nMasters(mesh.nFaces(), Zero);
 
-        const bitSet isMasterFace(syncTools::getMasterFaces(mesh));
+        bitSet isMasterFace(syncTools::getMasterFaces(mesh));
 
         forAll(isMasterFace, facei)
         {
@@ -953,12 +604,6 @@ int main(int argc, char *argv[])
     // Edge sync
     testEdgeSync(mesh, rndGen);
 
-    // Edge sync and flip
-    testEdgeFlip(mesh, rndGen);
-
-    // Edge sync and flip of more complex structure
-    testEdgeFlip2(mesh, rndGen);
-
     // Point sync
     testPointSync(mesh, rndGen);
 

applications/test/syncTools/block_2x2x1/Allrun

@@ -1,17 +0,0 @@
-#!/bin/sh
-cd "${0%/*}" || exit                                # Run from this directory
-. ${WM_PROJECT_DIR:?}/bin/tools/RunFunctions        # Tutorial run functions
-#------------------------------------------------------------------------------
-
-runApplication blockMesh
-runApplication decomposePar
-
-# Swap point 2 and 6 in processor1
-(   cd processor1/constant/polyMesh && \
-    sed -i -e 's/(1 1 0)/point1/;s/(1 1 2)/(1 1 0)/;s/point1/(1 1 2)/' points && \
-    sed -i -e 's/^4\([^2]*\)2/4\1TWO/;s/^4\([^6]*\)6/4\12/;s/TWO/6/' faces \
-)
-
-runParallel Test-syncTools
-
-#------------------------------------------------------------------------------

applications/test/syncTools/block_2x2x1/README.txt

@@ -1,7 +0,0 @@
-- blockMesh
-- decomposePar
-- in processor1:
-    - swap points 2 (1 1 0) and 6 (1 1 2) in polyMesh/points
-    - swap indices 2 and 6 in polyMesh/faces
-
-so now we have the same mesh but different edge orientation on processor1

applications/test/syncTools/block_2x2x1/constant/transportProperties

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

applications/test/syncTools/block_2x2x1/system/blockMeshDict

@@ -1,103 +0,0 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v1812                                 |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-FoamFile
-{
-    version     2.0;
-    format      ascii;
-    class       dictionary;
-    object      blockMeshDict;
-}
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-scale   1;
-
-vertices
-(
-    //- Skewed hexes
-    //(0 0 0)
-    //(0.1 0 0)
-    //(0.2 1 0)
-    //(0.03 1 0)
-    //(0 0 0.1)
-    //(0.1 0 0.1)
-    //(0.2 1 0.1)
-    //(0.03 1 0.1)
-
-    ////- Single block
-    //(0 0 0)
-    //(4 0 0)
-    //(4.4 4 0)
-    //(0.2 4 0)
-    //(0 0 0.4)
-    //(4 0 0.4)
-    //(4.6 4 0.4)
-    //(0.7 4 0.4)
-
-    //- Single block
-    (0  0   0)
-    (2  0   0)
-    (2  2   0)
-    (0  2   0)
-    (0  0   2)
-    (2  0   2)
-    (2  2   2)
-    (0  2   2)
-);
-
-blocks
-(
-    hex (0 1 2 3 4 5 6 7) (2 2 1) simpleGrading (1 1 1)
-);
-
-edges
-(
-);
-
-boundary
-(
-    topWall
-    {
-        type wall;
-        faces
-        (
-            (3 7 6 2)
-        );
-    }
-    bottomWall
-    {
-        type wall;
-        faces
-        (
-            (1 5 4 0)
-        );
-    }
-    fixedWalls
-    {
-        type wall;
-        faces
-        (
-            (0 4 7 3)
-            (2 6 5 1)
-        );
-    }
-    frontAndBack
-    {
-        type patch;
-        faces
-        (
-            (0 3 2 1)
-            (4 5 6 7)
-        );
-    }
-);
-
-mergePatchPairs
-(
-);
-
-// ************************************************************************* //

applications/test/syncTools/block_2x2x1/system/controlDict

@@ -1,48 +0,0 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v1812                                 |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-FoamFile
-{
-    version     2.0;
-    format      ascii;
-    class       dictionary;
-    location    "system";
-    object      controlDict;
-}
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-application     icoFoam;
-
-startFrom       startTime;
-
-startTime       0;
-
-stopAt          endTime;
-
-endTime         0.5;
-
-deltaT          0.005;
-
-writeControl    timeStep;
-
-writeInterval   20;
-
-purgeWrite      0;
-
-writeFormat     ascii;
-
-writePrecision  16;
-
-writeCompression off;
-
-timeFormat      general;
-
-timePrecision   6;
-
-runTimeModifiable true;
-
-// ************************************************************************* //

applications/test/syncTools/block_2x2x1/system/decomposeParDict

@@ -1,26 +0,0 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v1806                                 |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-FoamFile
-{
-    version     2.0;
-    format      ascii;
-    class       dictionary;
-    note        "mesh decomposition control dictionary";
-    object      decomposeParDict;
-}
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-//- The total number of domains (mandatory)
-numberOfSubdomains  4;
-
-//- The decomposition method (mandatory)
-method              hierarchical;
-
-n                   (2 2 1);
-
-// ************************************************************************* //

applications/test/syncTools/block_2x2x1/system/fvSchemes

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

applications/test/syncTools/block_2x2x1/system/fvSolution

@@ -1,52 +0,0 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v1812                                 |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-FoamFile
-{
-    version     2.0;
-    format      ascii;
-    class       dictionary;
-    location    "system";
-    object      fvSolution;
-}
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-solvers
-{
-    p
-    {
-        solver          PCG;
-        preconditioner  DIC;
-        tolerance       1e-06;
-        relTol          0.05;
-    }
-
-    pFinal
-    {
-        $p;
-        relTol          0;
-    }
-
-    U
-    {
-        solver          smoothSolver;
-        smoother        symGaussSeidel;
-        tolerance       1e-05;
-        relTol          0;
-    }
-}
-
-PISO
-{
-    nCorrectors     2;
-    nNonOrthogonalCorrectors 0;
-    pRefCell        0;
-    pRefValue       0;
-}
-
-
-// ************************************************************************* //

applications/utilities/mesh/conversion/datToFoam/datToFoam.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2020-2021 OpenCFD Ltd.
+    Copyright (C) 2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -39,7 +39,7 @@ Description
 #include "argList.H"
 #include "Time.H"
 #include "Fstream.H"
-#include "polyMesh.H"
+#include "pointField.H"
 #include "unitConversion.H"
 
 using namespace Foam;
@@ -76,7 +76,8 @@ int main(int argc, char *argv[])
     word block;
     string zoneName;
     token punctuation;
-    label iPoints, jPoints;
+    label iPoints;
+    label jPoints;
 
     Istring >> block;
     Istring >> block;
@@ -116,11 +117,11 @@ int main(int argc, char *argv[])
     }
 
     // correct error in biconic meshes
-    for (point& p : points)
+    forAll(points, i)
     {
-        if (p.y() < 1e-07)
+        if (points[i][1] < 1e-07)
         {
-            p.y() = 0;
+            points[i][1] = 0.0;
         }
     }
 
@@ -145,30 +146,18 @@ int main(int argc, char *argv[])
             );
     }
 
-    // Write (overwrite) points
-    {
-        IOobject iopoints
-        (
-            "points",
-            runTime.constant(),     // instance
-            polyMesh::meshSubDir,   // local
-            runTime
-        );
+    const fileName polyMeshPath(runTime.constantPath()/"polyMesh");
+    const fileName pointsFile(polyMeshPath/"points");
+    OFstream pFile(pointsFile);
+    if (!exists(polyMeshPath)) mkDir(polyMeshPath);
 
-        if (!exists(iopoints.path()))
-        {
-            mkDir(iopoints.path());
-        }
+    Info<< "Writing points to: " << nl
+        << "    " << pointsFile << endl;
 
-        OFstream os(iopoints.objectPath(), runTime.writeStreamOption());
+    runTime.writeHeader(pFile, "vectorField");
+    pFile << pointsWedge;
+    runTime.writeEndDivider(pFile);
 
-        Info<< "Writing points to: " << nl
-            << "    " << os.name() << endl;
-
-        iopoints.writeHeader(os, vectorIOField::typeName);
-        os << pointsWedge;
-        IOobject::writeEndDivider(os);
-    }
 
     Info<< "End\n" << endl;
 

applications/utilities/preProcessing/setExprFields/setExprFields.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2019-2020 OpenCFD Ltd.
+    Copyright (C) 2019-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -771,7 +771,7 @@ int main(int argc, char *argv[])
             expressions::exprString
                 expression
                 (
-                    args[expression],
+                    args["expression"],
                     dictionary::null
                 );
 

bin/paraFoam

@@ -7,7 +7,7 @@
 #    \\/     M anipulation  |
 #------------------------------------------------------------------------------
 #     Copyright (C) 2011-2016 OpenFOAM Foundation
-#     Copyright (C) 2016-2020 OpenCFD Ltd.
+#     Copyright (C) 2016-2021 OpenCFD Ltd.
 #------------------------------------------------------------------------------
 # License
 #     This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
@@ -140,8 +140,8 @@ do
             esac
         else
             echo "Ignore bad/invalid plugin-path: $pluginPath" 1>&2
-            unset pluginPath
         fi
+        unset pluginPath
         ;;
 
     -block*)  # Silently accepts -blockMesh
@@ -238,8 +238,11 @@ then
             ;;
         esac
 
-        if [ -n "$pluginError" ]
+        if [ -z "$pluginError" ]
         then
+            # Ensure plugin is also in the lib-path
+            LD_LIBRARY_PATH="${PV_PLUGIN_PATH}:$LD_LIBRARY_PATH"
+        else
             cat<< NO_PLUGIN 1>&2
 $pluginError
     See '${0##*/} -help-build' for more information

bin/tools/foamPackRelease

@@ -6,7 +6,7 @@
 #   \\  /    A nd           | www.openfoam.com
 #    \\/     M anipulation  |
 #------------------------------------------------------------------------------
-#     Copyright (C) 2019-2021 OpenCFD Ltd.
+#     Copyright (C) 2019-2020 OpenCFD Ltd.
 #------------------------------------------------------------------------------
 # License
 #     This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
@@ -32,9 +32,8 @@
 #
 # Debian-style without OpenFOAM sub-directory
 #
-#     foamPackRelease -debian origin/develop
-#     foamPackRelease -debian=openfoam2002_200129 origin/develop
 #     foamPackRelease -name=openfoam2002_200129.orig -no-prefix origin/develop
+#     foamPackRelease -debian=openfoam2002_200129 origin/develop
 #
 #------------------------------------------------------------------------------
 Script="${0##*/}"
@@ -56,8 +55,7 @@ options:
   -sep=SEP          Change version/patch separator from '_' to SEP
   -gitbase=DIR      Alternative repository location
   -with-api=NUM     Specify alternative api value for packaging
-  -tgz, -xz, -zstd  Alias for -compress=tgz, -compress=xz, -compress=zstd
-  -debian           Auto (debian) naming with -no-prefix, -xz
+  -tgz, -xz         Alias for -compress=tgz, -compress=xz
   -debian=NAME      Short-cut for -name=NAME.orig, -no-prefix, -xz
   -help             Print help
 
@@ -118,11 +116,6 @@ do
     -h | -help*)
         printHelp
         ;;
-    -debian)
-        tarName="debian"     # Special placeholder
-        prefixDir=false      # No prefix directory
-        : "${compress:=xz}"  # Default 'xz' compression
-        ;;
     -debian=*)
         tarName="${1#*=}"
         cleanTarName
@@ -173,7 +166,7 @@ do
     -with-api=*)
         packageApi="${1#*=}"
         ;;
-    -tgz | -xz | -zst | -zstd)
+    -tgz | -xz)
         compress="${1#*-}"
         ;;
     --)
@@ -266,11 +259,10 @@ sha1=$(git --git-dir="$gitbase/.git" ls-tree "$head" META-INFO/api-info | \
 [ -n "$sha1" ] || die "Could locate git content for META-INFO/api-info"
 
 # The api and patch
-api="$(git --git-dir="$gitbase/.git" show "$sha1" | sed -ne s/^api=//p)"
-patch="$(git --git-dir="$gitbase/.git" show "$sha1" | sed -ne s/^patch=//p)"
+api="$(git --git-dir="$gitbase/.git" show "$sha1" | sed -ne s/api=//p)"
+patch="$(git --git-dir="$gitbase/.git" show "$sha1" | sed -ne s/patch=//p)"
 
 [ -n "$api" ] || die "Could resolve api value"
-: "${patch:=0}"  # Treat missing patch number as '0'
 
 # Determine the BUILD information from git, as per `wmake -build-info`
 build="$(git --git-dir="$gitbase/.git" log -1 --date=short --format='%h=%ad' 2>/dev/null|sed 's/-//g;s/=/-/')"
@@ -298,25 +290,8 @@ then
     unset prefixDir
 fi
 
-case "$tarName" in
-(debian)
-    tarName="openfoam${packageApi}"
-
-    if [ "$withPatchNum" = false ]
-    then
-        echo "Ignoring patch number for output name" 1>&2
-    else
-        # Start debian with patch=1, not patch=0
-        if [ "$patch" = 0 ]
-        then
-            patch=1
-        fi
-        tarName="${tarName}${versionSeparator}${patch}"
-    fi
-    tarName="${tarName}.orig"  # Append .orig
-    ;;
-
-('')
+if [ -z "$tarName" ]
+then
     tarName="OpenFOAM-v${packageApi}"
     if [ "$withSource" = false ]
     then
@@ -326,12 +301,11 @@ case "$tarName" in
     if [ "$withPatchNum" = false ]
     then
         echo "Ignoring patch number for output name" 1>&2
-    elif [ "${patch:-0}" != 0 ]
+    elif [ "${patch:-0}" -gt 0 ]
     then
         tarName="${tarName}${versionSeparator}${patch}"
     fi
-    ;;
-esac
+fi
 
 echo 1>&2
 echo "Tar-file name:   $tarName.tar" 1>&2
@@ -470,7 +444,7 @@ case "$compress" in
 
     (gz | gzip)
     echo "Using gzip compression" 1>&2
-    echo 'gzip -f -9 "$outputDir/$tarName.tar"'
+    echo 'gzip -f9 "$outputDir/$tarName.tar"'
     echo
     echo '# End of compression'
     ;;
@@ -485,21 +459,14 @@ case "$compress" in
 
     (bz | bzip | bzip2)
     echo "Using bzip2 compression" 1>&2
-    echo 'bzip2 -f -9 "$outputDir/$tarName.tar"'
+    echo 'bzip2 -f9 "$outputDir/$tarName.tar"'
     echo
     echo '# End of compression'
     ;;
 
     (xz)
     echo "Using xz compression" 1>&2
-    echo 'xz -f -9 "$outputDir/$tarName.tar"'
-    echo
-    echo '# End of compression'
-    ;;
-
-    (zst | zstd)
-    echo "Using zstd compression" 1>&2
-    echo 'zstd --rm -f -9 "$outputDir/$tarName.tar"'
+    echo 'xz -f9 "$outputDir/$tarName.tar"'
     echo
     echo '# End of compression'
     ;;

etc/bashrc

@@ -55,7 +55,7 @@
 
 # [WM_PROJECT_VERSION] - A human-readable version name
 # A development version is often named 'com' - as in www.openfoam.com
-export WM_PROJECT_VERSION=com
+export WM_PROJECT_VERSION=v2012
 
 #------------------------------------------------------------------------------
 # Configuration environment variables.

etc/colourTables

@@ -44,7 +44,7 @@ coldAndHot
 fire
 {
     // ParaView: Black-Body Radiation
-    interpolate rbg;
+    interpolate rgb;
 
     table
     (
@@ -70,7 +70,7 @@ rainbow
 greyscale
 {
     // ParaView: grayscale
-    interpolate rbg;
+    interpolate rgb;
 
     table
     (
@@ -82,7 +82,7 @@ greyscale
 xray
 {
     // ParaView: "X ray"
-    interpolate rbg;
+    interpolate rgb;
 
     table
     (

etc/cshrc

@@ -55,7 +55,7 @@
 
 # [WM_PROJECT_VERSION] - A human-readable version name
 # A development version is often named 'com' - as in www.openfoam.com
-setenv WM_PROJECT_VERSION com
+setenv WM_PROJECT_VERSION v2012
 
 #------------------------------------------------------------------------------
 # Configuration environment variables.

src/OpenFOAM/containers/Bits/PackedList/PackedList.H

@@ -161,7 +161,7 @@ public:
         //   + (numElem % elem_per_block) ? 1 : 0
         // \endcode
         // But avoiding the modulus operation
-        static constexpr label num_blocks(label numElem) noexcept
+        static constexpr label num_blocks(label numElem)
         {
             return ((numElem - 1 + elem_per_block) / elem_per_block);
         }
@@ -385,6 +385,10 @@ public:
 
     // Low-level access
 
+        //- The number of bytes used in the underlying storage
+        //- including any unused padding.
+        inline std::streamsize byteSize() const;
+
         //- The number of internal storage blocks
         inline label nBlocks() const;
 
@@ -395,16 +399,6 @@ public:
         //  Manipulate with utmost caution
         inline List<unsigned int>& storage();
 
-        //- A const pointer to the raw storage
-        inline const unsigned int* cdata() const noexcept;
-
-        //- A pointer to the raw storage
-        inline unsigned int* data() noexcept;
-
-        //- The number of bytes used in the raw storage
-        //- including any unused padding.
-        inline std::streamsize byteSize() const noexcept;
-
 
     // IO
 
@@ -525,7 +519,10 @@ public:
         void assign(const PackedList<Width>& rhs) { (*this) = rhs; }
 
         //- Alias for resize()
-        void setSize(const label n, unsigned int val = 0u) { resize(n, val); }
+        void setSize(const label len, unsigned int val = 0u)
+        {
+            resize(len, val);
+        }
 };
 
 

src/OpenFOAM/containers/Bits/PackedList/PackedListI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -548,21 +548,7 @@ inline Foam::label Foam::PackedList<Width>::nBlocks() const
 
 
 template<unsigned Width>
-inline const unsigned int* Foam::PackedList<Width>::cdata() const noexcept
-{
-    return blocks_.cdata();
-}
-
-
-template<unsigned Width>
-inline unsigned int* Foam::PackedList<Width>::data() noexcept
-{
-    return blocks_.data();
-}
-
-
-template<unsigned Width>
-inline std::streamsize Foam::PackedList<Width>::byteSize() const noexcept
+inline std::streamsize Foam::PackedList<Width>::byteSize() const
 {
     return num_blocks(size()) * sizeof(block_type);
 }
@@ -577,7 +563,7 @@ inline void Foam::PackedList<Width>::swap(PackedList<Width>& rhs)
     }
 
     blocks_.swap(rhs.blocks_);
-    std::swap(size_, rhs.size_);
+    Foam::Swap(size_, rhs.size_);
 }
 
 

src/OpenFOAM/containers/Bits/PackedList/PackedListIO.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018-2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -127,7 +127,7 @@ Foam::Istream& Foam::PackedList<Width>::read(Istream& is)
             {
                 is.read
                 (
-                    reinterpret_cast<char*>(list.data()),
+                    reinterpret_cast<char*>(list.storage().data()),
                     list.byteSize()
                 );
 
@@ -249,7 +249,7 @@ Foam::Ostream& Foam::PackedList<Width>::writeList
             // write(...) includes surrounding start/end delimiters
             os.write
             (
-                reinterpret_cast<const char*>(list.cdata()),
+                reinterpret_cast<const char*>(list.storage().cdata()),
                 list.byteSize()
             );
         }

src/OpenFOAM/containers/Bits/bitSet/bitSetIO.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018-2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -87,7 +87,7 @@ Foam::Ostream& Foam::bitSet::writeList
             // write(...) includes surrounding start/end delimiters
             os.write
             (
-                reinterpret_cast<const char*>(list.cdata()),
+                reinterpret_cast<const char*>(list.storage().cdata()),
                 list.byteSize()
             );
         }

src/OpenFOAM/containers/Dictionaries/PtrListDictionary/PtrListDictionary.C

@@ -34,7 +34,7 @@ Foam::PtrListDictionary<T>::PtrListDictionary(const label size)
 :
     DictionaryBase<PtrList<T>, T>(2*size)
 {
-    PtrList<T>::resize(size);
+    PtrList<T>::setSize(size);
 }
 
 

src/OpenFOAM/containers/Lists/CompactListList/CompactListList.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -201,17 +201,17 @@ void Foam::CompactListList<T, Container>::clear()
 template<class T, class Container>
 void Foam::CompactListList<T, Container>::swap
 (
-    CompactListList<T, Container>& other
+    CompactListList<T, Container>& lst
 )
 {
-    if (this == &other)
+    if (this == &lst)
     {
         return;  // Self-swap is a no-op
     }
 
-    std::swap(size_, other.size_);
-    offsets_.swap(other.offsets_);
-    m_.swap(other.m_);
+    Foam::Swap(size_, lst.size_);
+    offsets_.swap(lst.offsets_);
+    m_.swap(lst.m_);
 }
 
 

src/OpenFOAM/containers/Lists/CompactListList/CompactListList.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -103,7 +103,7 @@ public:
 
     // Constructors
 
-        //- Default construct
+        //- Null constructor.
         inline CompactListList();
 
         //- Construct by converting given List<List<T>>
@@ -197,7 +197,7 @@ public:
             labelList sizes() const;
 
             //- Swap contents
-            void swap(CompactListList<T, Container>& other);
+            void swap(CompactListList<T, Container>& lst);
 
             //- Transfer contents into this and annul the argument
             void transfer(CompactListList<T, Container>& list);
@@ -261,15 +261,13 @@ public:
 };
 
 
-// Note: uses default Foam::Swap (move construct/assignment)
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "CompactListListI.H"
+    #include "CompactListListI.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/OpenFOAM/containers/Lists/DynamicList/DynamicList.C

@@ -5,6 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
+    Copyright (C) 2011 OpenFOAM Foundation
     Copyright (C) 2017 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
@@ -38,7 +39,7 @@ Foam::label Foam::DynamicList<T, SizeMin>::removeElements
 {
     if (!slice.size())
     {
-        // No-op
+        // Noop
         return 0;
     }
     else if (slice.after() >= this->size())
@@ -88,4 +89,40 @@ Foam::label Foam::DynamicList<T, SizeMin>::subsetElements
 }
 
 
+// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+
+template<class T, int SizeMin>
+Foam::DynamicList<T, SizeMin>::DynamicList(Istream& is)
+:
+    List<T>(is),
+    capacity_(List<T>::size())
+{}
+
+
+template<class T, int SizeMin>
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const DynamicList<T, SizeMin>& lst
+)
+{
+    os << static_cast<const List<T>&>(lst);
+    return os;
+}
+
+
+template<class T, int SizeMin>
+Foam::Istream& Foam::operator>>
+(
+    Istream& is,
+    DynamicList<T, SizeMin>& lst
+)
+{
+    is >> static_cast<List<T>&>(lst);
+    lst.capacity_ = lst.List<T>::size();
+
+    return is;
+}
+
+
 // ************************************************************************* //

src/OpenFOAM/containers/Lists/DynamicList/DynamicList.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2021 OpenCFD Ltd.
+    Copyright (C) 2016-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -56,10 +56,18 @@ namespace Foam
 template<class T, int SizeMin> class DynamicList;
 
 template<class T, int SizeMin>
-inline Istream& operator>>(Istream&, DynamicList<T, SizeMin>&);
+Ostream& operator<<
+(
+    Ostream& os,
+    const DynamicList<T, SizeMin>& lst
+);
 
 template<class T, int SizeMin>
-inline Ostream& operator<<(Ostream&, const DynamicList<T, SizeMin>&);
+Istream& operator>>
+(
+    Istream& is,
+    DynamicList<T, SizeMin>& lst
+);
 
 
 /*---------------------------------------------------------------------------*\
@@ -87,25 +95,36 @@ class DynamicList
         //- Subset elements in range
         label subsetElements(const labelRange& slice);
 
+
+protected:
+
+    // Protected Member Functions
+
         //- Copy assignment from another list
         template<class ListType>
-        inline void assignDynList(const ListType& list);
+        inline void assignDynList(const ListType& lst);
 
 public:
 
+    // Related Types
+
+        //- Declare friendship with the List class
+        friend class List<T>;
+
+
     // Constructors
 
         //- Default construct, an empty list without allocation.
         inline constexpr DynamicList() noexcept;
 
         //- Construct an empty list with given reserve size.
-        inline explicit DynamicList(const label len);
+        inline explicit DynamicList(const label nElem);
 
         //- Construct with given size and value for all elements.
-        inline DynamicList(const label len, const T& val);
+        inline DynamicList(const label nElem, const T& val);
 
         //- Construct with given size initializing all elements to zero
-        inline DynamicList(const label len, const Foam::zero);
+        inline DynamicList(const label nElem, const Foam::zero);
 
         //- Copy construct.
         inline DynamicList(const DynamicList<T, SizeMin>& lst);
@@ -162,62 +181,64 @@ public:
         inline label capacity() const noexcept;
 
 
-    // Sizing
+        // Edit
 
-        //- Alter the size of the underlying storage.
-        //  The addressed size will be truncated if needed to fit, but will
-        //  remain otherwise untouched.
-        //  Use this or reserve() in combination with append().
-        inline void setCapacity(const label newCapacity);
+            //- Alter the size of the underlying storage.
+            //  The addressed size will be truncated if needed to fit, but will
+            //  remain otherwise untouched.
+            //  Use this or reserve() in combination with append().
+            inline void setCapacity(const label nElem);
 
-        //- Reserve allocation space for at least this size.
-        //  Never shrinks the allocated size, use setCapacity() for that.
-        inline void reserve(const label len);
+            //- Alter addressable list size.
+            //  New space will be allocated if required.
+            //  Use this to resize the list prior to using the operator[] for
+            //  setting values (as per List usage).
+            inline void setSize(const label nElem);
 
-        //- Alter addressable size.
-        //  New space will be allocated if required.
-        inline void resize(const label newLen);
+            //- Alter addressable list size and fill new space with constant.
+            inline void setSize(const label nElem, const T& val);
 
-        //- Alter addressable size and fill new space with constant value
-        inline void resize(const label newLen, const T& val);
+            //- Alter addressable list size.
+            //  New space will be allocated if required.
+            //  Use this to resize the list prior to using the operator[] for
+            //  setting values (as per List usage).
+            inline void resize(const label nElem);
 
-        //- Alias for resize()
-        void setSize(const label n) { this->resize(n); }
+            //- Alter addressable list size and fill new space with constant.
+            inline void resize(const label nElem, const T& val);
 
-        //- Alias for resize()
-        void setSize(const label n, const T& val) { this->resize(n, val); }
+            //- Reserve allocation space for at least this size.
+            //  Never shrinks the allocated size, use setCapacity() for that.
+            inline void reserve(const label nElem);
 
-        //- Clear the addressed list, i.e. set the size to zero.
-        //  Allocated size does not change
-        inline void clear() noexcept;
+            //- Clear the addressed list, i.e. set the size to zero.
+            //  Allocated size does not change
+            inline void clear();
 
-        //- Clear the list and delete storage.
-        inline void clearStorage();
+            //- Clear the list and delete storage.
+            inline void clearStorage();
 
-        //- Expand the addressable size to fit the allocated capacity.
-        //  Returns the previous addressable size.
-        inline label expandStorage() noexcept;
+            //- Expand the addressable size to fit the allocated capacity.
+            //  Returns the previous addressable size.
+            inline label expandStorage();
 
-        //- Shrink the allocated space to the number of elements used.
-        //  Returns a reference to the DynamicList.
-        inline DynamicList<T, SizeMin>& shrink();
+            //- Shrink the allocated space to the number of elements used.
+            //  Returns a reference to the DynamicList.
+            inline DynamicList<T, SizeMin>& shrink();
 
-
-    // Edit
-
-            //- Swap content, independent of sizing parameter
+            //- Swap content with any sized DynamicList
             template<int AnySizeMin>
-            inline void swap(DynamicList<T, AnySizeMin>& other);
+            inline void swap(DynamicList<T, AnySizeMin>& lst);
 
             //- Transfer contents of the argument List into this.
-            inline void transfer(List<T>& list);
+            inline void transfer(List<T>& lst);
 
             //- Transfer contents of any sized DynamicList into this.
             template<int AnySizeMin>
-            inline void transfer(DynamicList<T, AnySizeMin>& list);
+            inline void transfer(DynamicList<T, AnySizeMin>& lst);
 
             //- Transfer contents  of the argument SortableList into this.
-            inline void transfer(SortableList<T>& list);
+            inline void transfer(SortableList<T>& lst);
 
             //- Append an element to the end of this list.
             inline DynamicList<T, SizeMin>& append(const T& val);
@@ -290,7 +311,8 @@ public:
 
         // Member Operators
 
-            //- Return non-const access to an element, resizing list if needed
+            //- Return non-const access to an element,
+            //- resizing list if necessary
             inline T& operator()(const label i);
 
             //- Assignment of all addressed entries to the given value
@@ -334,32 +356,29 @@ public:
             inline void operator=(SortableList<T>&& lst);
 
 
-    // IOstream Operators
+        // IOstream operators
 
-        //- Read from Istream, discarding existing contents
-        friend Istream& operator>> <T, SizeMin>
-        (
-            Istream& is,
-            DynamicList<T, SizeMin>& rhs
-        );
+            // Write DynamicList to Ostream.
+            friend Ostream& operator<< <T, SizeMin>
+            (
+                Ostream& os,
+                const DynamicList<T, SizeMin>& lst
+            );
 
-        //- Write to Ostream
-        friend Ostream& operator<< <T, SizeMin>
-        (
-            Ostream& os,
-            const DynamicList<T, SizeMin>& rhs
-        );
+            //- Read from Istream, discarding contents of existing DynamicList.
+            friend Istream& operator>> <T, SizeMin>
+            (
+                Istream& is,
+                DynamicList<T, SizeMin>& lst
+            );
 };
 
 
-// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+// Global Functions
 
 // Exchange contents of lists - see DynamicList::swap().
-template<class T, int SizeMinA, int SizeMinB>
-inline void Swap(DynamicList<T, SizeMinA>& a, DynamicList<T, SizeMinB>& b)
-{
-    a.swap(b);
-}
+template<class T, int SizeMin1, int SizeMin2>
+inline void Swap(DynamicList<T, SizeMin1>& a, DynamicList<T, SizeMin2>& b);
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/OpenFOAM/containers/Lists/DynamicList/DynamicListI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2021 OpenCFD Ltd.
+    Copyright (C) 2016-2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -28,29 +28,29 @@ License
 
 #include "FixedList.H"
 
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
 template<class T, int SizeMin>
 template<class ListType>
 inline void Foam::DynamicList<T, SizeMin>::assignDynList
 (
-    const ListType& list
+    const ListType& lst
 )
 {
-    const label newLen = list.size();
+    const label newSize = lst.size();
 
-    if (newLen <= capacity_)
+    if (capacity_ >= newSize)
     {
         // Can copy w/o reallocating - adjust addressable size accordingly.
-        List<T>::setAddressableSize(newLen);
-        List<T>::operator=(list);
+        List<T>::size(newSize);
+        List<T>::operator=(lst);
     }
     else
     {
         // Ensure list size consistency prior to copying.
-        List<T>::setAddressableSize(capacity_);
+        List<T>::size(capacity_);
 
-        List<T>::operator=(list);
+        List<T>::operator=(lst);
         capacity_ = List<T>::size();
     }
 }
@@ -61,29 +61,27 @@ inline void Foam::DynamicList<T, SizeMin>::assignDynList
 template<class T, int SizeMin>
 inline constexpr Foam::DynamicList<T, SizeMin>::DynamicList() noexcept
 :
-    List<T>(),
     capacity_(0)
 {}
 
 
 template<class T, int SizeMin>
-inline Foam::DynamicList<T, SizeMin>::DynamicList(const label len)
+inline Foam::DynamicList<T, SizeMin>::DynamicList(const label nElem)
 :
-    List<T>(),
     capacity_(0)
 {
-    reserve(len);
+    reserve(nElem);
 }
 
 
 template<class T, int SizeMin>
 inline Foam::DynamicList<T, SizeMin>::DynamicList
 (
-    const label len,
+    const label nElem,
     const T& val
 )
 :
-    List<T>(len, val),
+    List<T>(nElem, val),
     capacity_(List<T>::size())
 {}
 
@@ -91,11 +89,11 @@ inline Foam::DynamicList<T, SizeMin>::DynamicList
 template<class T, int SizeMin>
 inline Foam::DynamicList<T, SizeMin>::DynamicList
 (
-    const label len,
+    const label nElem,
     const Foam::zero
 )
 :
-    List<T>(len, Zero),
+    List<T>(nElem, Zero),
     capacity_(List<T>::size())
 {}
 
@@ -103,10 +101,10 @@ inline Foam::DynamicList<T, SizeMin>::DynamicList
 template<class T, int SizeMin>
 inline Foam::DynamicList<T, SizeMin>::DynamicList
 (
-    const DynamicList<T, SizeMin>& list
+    const DynamicList<T, SizeMin>& lst
 )
 :
-    List<T>(list),
+    List<T>(lst),
     capacity_(List<T>::size())
 {}
 
@@ -115,10 +113,10 @@ template<class T, int SizeMin>
 template<int AnySizeMin>
 inline Foam::DynamicList<T, SizeMin>::DynamicList
 (
-    const DynamicList<T, AnySizeMin>& list
+    const DynamicList<T, AnySizeMin>& lst
 )
 :
-    List<T>(list),
+    List<T>(lst),
     capacity_(List<T>::size())
 {}
 
@@ -126,10 +124,10 @@ inline Foam::DynamicList<T, SizeMin>::DynamicList
 template<class T, int SizeMin>
 inline Foam::DynamicList<T, SizeMin>::DynamicList
 (
-    const UList<T>& list
+    const UList<T>& lst
 )
 :
-    List<T>(list),
+    List<T>(lst),
     capacity_(List<T>::size())
 {}
 
@@ -138,12 +136,12 @@ template<class T, int SizeMin>
 template<unsigned N>
 inline Foam::DynamicList<T, SizeMin>::DynamicList
 (
-    const FixedList<T, N>& list
+    const FixedList<T, N>& lst
 )
 :
     capacity_(0)
 {
-    this->operator=(list);
+    this->operator=(lst);
 }
 
 
@@ -220,14 +218,6 @@ inline Foam::DynamicList<T, SizeMin>::DynamicList
 }
 
 
-template<class T, int SizeMin>
-inline Foam::DynamicList<T, SizeMin>::DynamicList(Istream& is)
-:
-    List<T>(is),
-    capacity_(List<T>::size())
-{}
-
-
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class T, int SizeMin>
@@ -240,83 +230,124 @@ inline Foam::label Foam::DynamicList<T, SizeMin>::capacity() const noexcept
 template<class T, int SizeMin>
 inline void Foam::DynamicList<T, SizeMin>::setCapacity
 (
-    const label newCapacity
+    const label nElem
 )
 {
-    label currLen = List<T>::size();
-    capacity_ = newCapacity;
+    label nextFree = List<T>::size();
+    capacity_ = nElem;
 
-    if (currLen > capacity_)
+    if (nextFree > capacity_)
     {
         // Truncate addressed sizes too
-        currLen = capacity_;
+        nextFree = capacity_;
     }
 
-    List<T>::resize(capacity_);
-    List<T>::setAddressableSize(currLen);
+    // We could also enforce sizing granularity
+
+    List<T>::setSize(capacity_);
+    List<T>::size(nextFree);
 }
 
 
 template<class T, int SizeMin>
 inline void Foam::DynamicList<T, SizeMin>::reserve
 (
-    const label len
+    const label nElem
 )
 {
-    if (capacity_ < len)
+    // Allocate more capacity if necessary
+    if (nElem > capacity_)
     {
-        // Increase capacity (doubling)
-        capacity_ = max(SizeMin, max(len, label(2 * capacity_)));
+        capacity_ = max
+        (
+            SizeMin,
+            max
+            (
+                nElem,
+                // label(SizeInc + capacity_ * SizeMult / SizeDiv)
+                label(2 * capacity_)
+            )
+        );
 
         // Adjust allocated size, leave addressed size untouched
-        const label currLen = List<T>::size();
-        List<T>::resize(capacity_);
-        List<T>::setAddressableSize(currLen);
+        const label nextFree = List<T>::size();
+        List<T>::setSize(capacity_);
+        List<T>::size(nextFree);
     }
 }
 
 
 template<class T, int SizeMin>
-inline void Foam::DynamicList<T, SizeMin>::resize
+inline void Foam::DynamicList<T, SizeMin>::setSize
 (
-    const label newLen
+    const label nElem
 )
 {
-    if (capacity_ < newLen)
+    // Allocate more capacity if necessary
+    if (nElem > capacity_)
     {
-        // Increase capacity (doubling)
-        capacity_ = max(SizeMin, max(newLen, label(2 * capacity_)));
+        capacity_ = max
+        (
+            SizeMin,
+            max
+            (
+                nElem,
+                // label(SizeInc + capacity_ * SizeMult / SizeDiv)
+                label(2 * capacity_)
+            )
+        );
 
-        List<T>::resize(capacity_);
+        List<T>::setSize(capacity_);
     }
 
     // Adjust addressed size
-    List<T>::setAddressableSize(newLen);
+    List<T>::size(nElem);
+}
+
+
+template<class T, int SizeMin>
+inline void Foam::DynamicList<T, SizeMin>::setSize
+(
+    const label nElem,
+    const T& val
+)
+{
+    label nextFree = List<T>::size();
+    setSize(nElem);
+
+    // Set new elements to constant value
+    while (nextFree < nElem)
+    {
+        this->operator[](nextFree++) = val;
+    }
 }
 
 
 template<class T, int SizeMin>
 inline void Foam::DynamicList<T, SizeMin>::resize
 (
-    const label newLen,
-    const T& val
+    const label nElem
 )
 {
-    label currLen = List<T>::size();
-    resize(newLen);
-
-    // Fill newly exposed with constant value
-    while (currLen < newLen)
-    {
-        this->operator[](currLen++) = val;
-    }
+    this->setSize(nElem);
 }
 
 
 template<class T, int SizeMin>
-inline void Foam::DynamicList<T, SizeMin>::clear() noexcept
+inline void Foam::DynamicList<T, SizeMin>::resize
+(
+    const label nElem,
+    const T& val
+)
 {
-    List<T>::setAddressableSize(0);
+    this->setSize(nElem, val);
+}
+
+
+template<class T, int SizeMin>
+inline void Foam::DynamicList<T, SizeMin>::clear()
+{
+    List<T>::size(0);
 }
 
 
@@ -329,14 +360,14 @@ inline void Foam::DynamicList<T, SizeMin>::clearStorage()
 
 
 template<class T, int SizeMin>
-inline Foam::label Foam::DynamicList<T, SizeMin>::expandStorage() noexcept
+inline Foam::label Foam::DynamicList<T, SizeMin>::expandStorage()
 {
-    const label currLen = List<T>::size();
+    const label nextFree = List<T>::size();
 
     // Allow addressing into the entire list
-    List<T>::setAddressableSize(capacity_);
+    List<T>::size(capacity_);
 
-    return currLen;
+    return nextFree;
 }
 
 
@@ -344,16 +375,16 @@ template<class T, int SizeMin>
 inline Foam::DynamicList<T, SizeMin>&
 Foam::DynamicList<T, SizeMin>::shrink()
 {
-    const label currLen = List<T>::size();
-    if (currLen < capacity_)
+    const label nextFree = List<T>::size();
+    if (capacity_ > nextFree)
     {
         // Use the full list when resizing
-        List<T>::setAddressableSize(capacity_);
+        List<T>::size(capacity_);
 
-        // Capacity and size are identical
-        capacity_ = currLen;
-        List<T>::resize(currLen);
-        // Redundant: List<T>::setAddressableSize(currLen);
+        // The new size
+        capacity_ = nextFree;
+        List<T>::setSize(capacity_);
+        List<T>::size(nextFree);
     }
     return *this;
 }
@@ -363,30 +394,41 @@ template<class T, int SizeMin>
 template<int AnySizeMin>
 inline void Foam::DynamicList<T, SizeMin>::swap
 (
-    DynamicList<T, AnySizeMin>& other
+    DynamicList<T, AnySizeMin>& lst
 )
 {
     // Cannot compare 'this' for different types, so use cdata()
-    if (this->cdata() == other.cdata())
+    if (this->cdata() == lst.cdata())
     {
         return;  // Self-swap is a no-op
     }
 
-    // Swap storage and addressable size
-    UList<T>::swap(other);
+    DynamicList<T, SizeMin>& cur = *this;
 
-    // Swap capacity
-    std::swap(this->capacity_, other.capacity_);
+    // Make addressable size identical to the allocated capacity
+    const label oldSize1 = cur.expandStorage();
+    const label oldSize2 = lst.expandStorage();
+
+    // Swap storage
+    UList<T>::swap(lst);
+
+    // Match capacity to the underlying allocated list size
+    cur.setCapacity(cur.size());
+    lst.setCapacity(lst.size());
+
+    // Set addressable size
+    cur.setSize(oldSize2);
+    lst.setSize(oldSize1);
 }
 
 
 template<class T, int SizeMin>
 inline void
-Foam::DynamicList<T, SizeMin>::transfer(List<T>& list)
+Foam::DynamicList<T, SizeMin>::transfer(List<T>& lst)
 {
-    // Take over storage, clear addressing for list
-    capacity_ = list.size();
-    List<T>::transfer(list);
+    // Take over storage, clear addressing for lst.
+    capacity_ = lst.size();
+    List<T>::transfer(lst);
 }
 
 
@@ -395,21 +437,21 @@ template<int AnySizeMin>
 inline void
 Foam::DynamicList<T, SizeMin>::transfer
 (
-    DynamicList<T, AnySizeMin>& list
+    DynamicList<T, AnySizeMin>& lst
 )
 {
     // Cannot compare 'this' for different types, so use cdata()
-    if (this->cdata() == list.cdata())
+    if (this->cdata() == lst.cdata())
     {
         return;  // Self-assignment is a no-op
     }
 
     // Take over storage as-is (without shrink, without using SizeMin)
     // clear addressing and storage for old lst.
-    capacity_ = list.capacity();
+    capacity_ = lst.capacity();
 
-    List<T>::transfer(static_cast<List<T>&>(list));
-    list.clearStorage();  // Ensure capacity=0
+    List<T>::transfer(static_cast<List<T>&>(lst));
+    lst.clearStorage();  // Ensure capacity=0
 }
 
 
@@ -417,12 +459,12 @@ template<class T, int SizeMin>
 inline void
 Foam::DynamicList<T, SizeMin>::transfer
 (
-    SortableList<T>& list
+    SortableList<T>& lst
 )
 {
-    list.shrink();  // Shrink away sort indices
-    capacity_ = list.size(); // Capacity after transfer == list size
-    List<T>::transfer(list);
+    lst.shrink();  // Shrink away sort indices
+    capacity_ = lst.size(); // Capacity after transfer == list size
+    List<T>::transfer(lst);
 }
 
 
@@ -434,7 +476,7 @@ Foam::DynamicList<T, SizeMin>::append
 )
 {
     const label idx = List<T>::size();
-    resize(idx + 1);
+    setSize(idx + 1);
 
     this->operator[](idx) = val;  // copy element
     return *this;
@@ -449,7 +491,7 @@ Foam::DynamicList<T, SizeMin>::append
 )
 {
     const label idx = List<T>::size();
-    resize(idx + 1);
+    setSize(idx + 1);
 
     this->operator[](idx) = std::move(val);  // move assign element
     return *this;
@@ -466,12 +508,12 @@ Foam::DynamicList<T, SizeMin>::append
     if (this == &lst)
     {
         FatalErrorInFunction
-            << "Attempted appending to self"
-            << abort(FatalError);
+            << "Attempted appending to self" << abort(FatalError);
     }
 
     label idx = List<T>::size();
-    resize(idx + lst.size());
+
+    setSize(idx + lst.size());
 
     for (const T& val : lst)
     {
@@ -490,7 +532,7 @@ Foam::DynamicList<T, SizeMin>::append
 )
 {
     label idx = List<T>::size();
-    resize(idx + lst.size());
+    setSize(idx + lst.size());
 
     for (const T& val : lst)
     {
@@ -508,7 +550,8 @@ Foam::DynamicList<T, SizeMin>::append
 )
 {
     label idx = List<T>::size();
-    resize(idx + lst.size());
+
+    setSize(idx + lst.size());
 
     for (const T& val : lst)
     {
@@ -529,7 +572,7 @@ Foam::DynamicList<T, SizeMin>::append
     label idx = List<T>::size();
     const label n = lst.size();
 
-    resize(idx + n);
+    setSize(idx + n);
 
     for (label i=0; i<n; ++i)
     {
@@ -543,25 +586,25 @@ template<class T, int SizeMin>
 inline Foam::DynamicList<T, SizeMin>&
 Foam::DynamicList<T, SizeMin>::append
 (
-    List<T>&& list
+    List<T>&& lst
 )
 {
-    if (this == &list)
+    if (this == &lst)
     {
         FatalErrorInFunction
-            << "Attempted appending to self"
-            << abort(FatalError);
+            << "Attempted appending to self" << abort(FatalError);
     }
 
     label idx = List<T>::size();
-    resize(idx + list.size());
 
-    for (T& val : list)
+    setSize(idx + lst.size());
+
+    for (T& val : lst)
     {
         Foam::Swap(this->operator[](idx++), val);  // moved content
     }
 
-    list.clear();
+    lst.clear();
     return *this;
 }
 
@@ -620,7 +663,7 @@ inline T Foam::DynamicList<T, SizeMin>::remove()
 
     const T& val = List<T>::operator[](idx);
 
-    List<T>::setAddressableSize(idx);
+    List<T>::size(idx);
 
     return val;
 }
@@ -699,7 +742,7 @@ inline T& Foam::DynamicList<T, SizeMin>::operator()
 {
     if (i >= List<T>::size())
     {
-        resize(i + 1);
+        setSize(i + 1);
     }
 
     return this->operator[](i);
@@ -745,7 +788,7 @@ inline void Foam::DynamicList<T, SizeMin>::operator=
 {
     const label n = lst.size();
 
-    resize(n);
+    setSize(n);
 
     for (label i=0; i<n; ++i)
     {
@@ -863,34 +906,16 @@ inline void Foam::DynamicList<T, SizeMin>::operator=
 }
 
 
-// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
 
-template<class T, int SizeMin>
-inline Foam::Istream& Foam::operator>>
+template<class T, int SizeMin1, int SizeMin2>
+inline void Foam::Swap
 (
-    Istream& is,
-    DynamicList<T, SizeMin>& rhs
+    DynamicList<T, SizeMin1>& a,
+    DynamicList<T, SizeMin2>& b
 )
 {
-    // Use entire storage - ie, resize(capacity())
-    (void) rhs.expandStorage();
-
-    is >> static_cast<List<T>&>(rhs);
-    rhs.capacity_ = rhs.List<T>::size();
-
-    return is;
-}
-
-
-template<class T, int SizeMin>
-inline Foam::Ostream& Foam::operator<<
-(
-    Ostream& os,
-    const DynamicList<T, SizeMin>& rhs
-)
-{
-    os << static_cast<const List<T>&>(rhs);
-    return os;
+    a.swap(b);
 }
 
 

src/OpenFOAM/containers/Lists/FixedList/FixedList.C

@@ -31,20 +31,6 @@ License
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-template<class T, unsigned N>
-std::streamsize Foam::FixedList<T, N>::byteSize() const
-{
-    if (!is_contiguous<T>::value)
-    {
-        FatalErrorInFunction
-            << "Invalid for non-contiguous data types"
-            << abort(FatalError);
-    }
-
-    return N*sizeof(T);
-}
-
-
 template<class T, unsigned N>
 Foam::label Foam::FixedList<T, N>::find(const T& val, label pos) const
 {

src/OpenFOAM/containers/Lists/FixedList/FixedList.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -216,8 +216,6 @@ public:
         //- The last element of the list, position [N-1]
         inline const T& last() const noexcept;
 
-        //- The number of bytes stored by the list data for contiguous types
-        std::streamsize byteSize() const;
 
         //- Return the forward circular index, i.e. next index
         //- which returns to the first at the end of the list
@@ -281,7 +279,7 @@ public:
         inline void resize(const label n);
 
         //- Dummy function, to make FixedList consistent with List
-        void setSize(const label n) { this->resize(n); }
+        inline void setSize(const label n);
 
         //- Assign all entries to the given value
         inline void fill(const T& val);
@@ -342,25 +340,25 @@ public:
     // Random access iterator (non-const)
 
         //- Return an iterator to begin traversing the FixedList
-        inline iterator begin() noexcept;
+        inline iterator begin();
 
         //- Return an iterator to end traversing the FixedList
-        inline iterator end() noexcept;
+        inline iterator end();
 
 
     // Random access iterator (const)
 
         //- Return const_iterator to begin traversing the constant FixedList
-        inline const_iterator cbegin() const noexcept;
+        inline const_iterator cbegin() const;
 
         //- Return const_iterator to end traversing the constant FixedList
-        inline const_iterator cend() const noexcept;
+        inline const_iterator cend() const;
 
         //- Return const_iterator to begin traversing the constant FixedList
-        inline const_iterator begin() const noexcept;
+        inline const_iterator begin() const;
 
         //- Return const_iterator to end traversing the constant FixedList
-        inline const_iterator end() const noexcept;
+        inline const_iterator end() const;
 
 
     // Reverse iterator (non-const)
@@ -399,7 +397,7 @@ public:
         static constexpr unsigned max_size() noexcept { return N; }
 
         //- Swap lists by swapping the content of the individual list elements
-        inline void swap(FixedList<T, N>& other);
+        inline void swap(FixedList<T, N>& list);
 
 
     // STL Member Operators
@@ -491,12 +489,9 @@ struct is_contiguous_scalar<FixedList<T, N>> : is_contiguous_scalar<T> {};
 // * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * * //
 
 //- Swap FixedList contents - see FixedList::swap().
-//  Internally actually swaps the individual list elements
+//  Internally this actually swaps the individual list elements
 template<class T, unsigned N>
-inline void Swap(FixedList<T, N>& a, FixedList<T, N>& b)
-{
-    a.swap(b);
-}
+inline void Swap(FixedList<T, N>& lhs, FixedList<T, N>& rhs);
 
 
 //- Hashing for FixedList data, which uses Hasher for contiguous data and

src/OpenFOAM/containers/Lists/FixedList/FixedListI.H

@@ -327,6 +327,15 @@ inline void Foam::FixedList<T, N>::resize(const label n)
     #endif
 }
 
+template<class T, unsigned N>
+inline void Foam::FixedList<T, N>::setSize(const label n)
+{
+    #ifdef FULLDEBUG
+    checkSize(n);
+    #endif
+}
+
+
 template<class T, unsigned N>
 inline void Foam::FixedList<T, N>::fill(const T& val)
 {
@@ -348,16 +357,16 @@ inline void Foam::FixedList<T, N>::fill(const Foam::zero)
 
 
 template<class T, unsigned N>
-inline void Foam::FixedList<T, N>::swap(FixedList<T, N>& other)
+inline void Foam::FixedList<T, N>::swap(FixedList<T, N>& list)
 {
-    if (this == &other)
+    if (this == &list)
     {
         return;  // Self-swap is a no-op
     }
 
     for (unsigned i=0; i<N; ++i)
     {
-        Foam::Swap(v_[i], other.v_[i]);
+        Foam::Swap(v_[i], list.v_[i]);
     }
 }
 
@@ -481,6 +490,8 @@ inline void Foam::FixedList<T, N>::operator=(FixedList<T, N>&& list)
         return;  // Self-assignment is a no-op
     }
 
+    // No significant speedup observed for copy assignment on simple types,
+    // use move assignment for generality with more complex types
     for (unsigned i=0; i<N; ++i)
     {
         v_[i] = std::move(list.v_[i]);
@@ -492,7 +503,7 @@ inline void Foam::FixedList<T, N>::operator=(FixedList<T, N>&& list)
 
 template<class T, unsigned N>
 inline typename Foam::FixedList<T, N>::iterator
-Foam::FixedList<T, N>::begin() noexcept
+Foam::FixedList<T, N>::begin()
 {
     return v_;
 }
@@ -500,7 +511,7 @@ Foam::FixedList<T, N>::begin() noexcept
 
 template<class T, unsigned N>
 inline typename Foam::FixedList<T, N>::const_iterator
-Foam::FixedList<T, N>::begin() const noexcept
+Foam::FixedList<T, N>::begin() const
 {
     return v_;
 }
@@ -508,7 +519,7 @@ Foam::FixedList<T, N>::begin() const noexcept
 
 template<class T, unsigned N>
 inline typename Foam::FixedList<T, N>::const_iterator
-Foam::FixedList<T, N>::cbegin() const noexcept
+Foam::FixedList<T, N>::cbegin() const
 {
     return v_;
 }
@@ -516,7 +527,7 @@ Foam::FixedList<T, N>::cbegin() const noexcept
 
 template<class T, unsigned N>
 inline typename Foam::FixedList<T, N>::iterator
-Foam::FixedList<T, N>::end() noexcept
+Foam::FixedList<T, N>::end()
 {
     return (v_ + N);
 }
@@ -524,7 +535,7 @@ Foam::FixedList<T, N>::end() noexcept
 
 template<class T, unsigned N>
 inline typename Foam::FixedList<T, N>::const_iterator
-Foam::FixedList<T, N>::end() const noexcept
+Foam::FixedList<T, N>::end() const
 {
     return (v_ + N);
 }
@@ -532,7 +543,7 @@ Foam::FixedList<T, N>::end() const noexcept
 
 template<class T, unsigned N>
 inline typename Foam::FixedList<T, N>::const_iterator
-Foam::FixedList<T, N>::cend() const noexcept
+Foam::FixedList<T, N>::cend() const
 {
     return (v_ + N);
 }
@@ -586,4 +597,13 @@ Foam::FixedList<T, N>::crend() const
 }
 
 
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+
+template<class T, unsigned N>
+inline void Foam::Swap(FixedList<T, N>& lhs, FixedList<T, N>& rhs)
+{
+    lhs.swap(rhs);
+}
+
+
 // ************************************************************************* //

src/OpenFOAM/containers/Lists/List/List.H

@@ -93,7 +93,7 @@ class List
         template<class List2>
         inline void copyList(const List2& list);
 
-        //- Change allocation size - backend for resize.
+        //- Change allocation size of List. Backend for resize/setSize.
         void doResize(const label newSize);
 
         //- Construct given begin/end iterators and number of elements
@@ -123,7 +123,7 @@ public:
 
     // Constructors
 
-        //- Default construct
+        //- Null constructor
         inline constexpr List() noexcept;
 
         //- Construct with given size
@@ -208,27 +208,24 @@ public:
 
     // Member Functions
 
-    // Sizing
-
-        //- Clear the list, i.e. set size to zero
-        inline void clear();
-
-        //- Adjust allocated size of list.
-        //  The boolList version fills new memory with false.
-        inline void resize(const label newLen);
-
-        //- Adjust allocated size of list and set val for new elements
-        void resize(const label newLen, const T& val);
-
-        //- Alias for resize()
-        void setSize(const label n) { this->resize(n); }
-
-        //- Alias for resize()
-        void setSize(const label n, const T& val) { this->resize(n, val); }
-
-
         // Edit
 
+            //- Adjust allocated size of list.
+            //  The boolList version fills new memory with false.
+            inline void resize(const label newSize);
+
+            //- Adjust allocated size of list and set val for new elements
+            void resize(const label newSize, const T& val);
+
+            //- Alias for resize(const label)
+            inline void setSize(const label newSize);
+
+            //- Alias for resize(const label, const T&)
+            inline void setSize(const label newSize, const T& val);
+
+            //- Clear the list, i.e. set size to zero
+            inline void clear();
+
             //- Append an element at the end of the list
             inline void append(const T& val);
 

src/OpenFOAM/containers/Lists/List/ListI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -128,17 +128,31 @@ namespace Foam
 {
     // Template specialization for bool. Fills with false
     template<>
-    inline void List<bool>::resize(const label newLen)
+    inline void List<bool>::resize(const label newSize)
     {
-        this->resize(newLen, false);
+        this->resize(newSize, false);
     }
 }
 
 
 template<class T>
-inline void Foam::List<T>::resize(const label newLen)
+inline void Foam::List<T>::resize(const label len)
 {
-    this->doResize(newLen);
+    this->doResize(len);
+}
+
+
+template<class T>
+inline void Foam::List<T>::setSize(const label len)
+{
+    this->resize(len);
+}
+
+
+template<class T>
+inline void Foam::List<T>::setSize(const label len, const T& val)
+{
+    this->resize(len, val);
 }
 
 

src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C

@@ -213,8 +213,8 @@ Foam::PackedList<Width> Foam::reorder
     }
 
     // Verify addresses (for movable refs)
-    // Info<< "reordered in " << name(input.cdata()) << nl
-    //     << "reordered out " << name(output.cdata()) << nl;
+    // Info<< "reordered in " << name(input.storage().cdata()) << nl
+    //     << "reordered out " << name(output.storage().cdata()) << nl;
 
     return output;
 }
@@ -231,7 +231,7 @@ void Foam::inplaceReorder
     input = reorder(oldToNew, input, prune);
 
     // Verify address (for movable refs)
-    // Info<< "now have " << name(input.cdata()) << nl;
+    // Info<< "now have " << name(input.storage().cdata()) << nl;
 }
 
 

src/OpenFOAM/containers/Lists/SortableList/SortableList.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -195,15 +195,15 @@ void Foam::SortableList<T>::partialReverseSort(label n, label start)
 
 
 template<class T>
-void Foam::SortableList<T>::swap(SortableList<T>& other)
+void Foam::SortableList<T>::swap(SortableList<T>& lst)
 {
-    if (this == &other)
+    if (this == &lst)
     {
         return;  // Self-swap is a no-op
     }
 
-    List<T>::swap(other);
-    indices_.swap(other.indices_);
+    List<T>::swap(lst);
+    indices_.swap(lst.indices_);
 }
 
 
@@ -267,4 +267,13 @@ inline void Foam::SortableList<T>::operator=(std::initializer_list<T> lst)
 }
 
 
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+
+template<class T>
+inline void Foam::Swap(SortableList<T>& a, SortableList<T>& b)
+{
+    a.swap(b);
+}
+
+
 // ************************************************************************* //

src/OpenFOAM/containers/Lists/SortableList/SortableList.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -72,7 +72,7 @@ public:
 
     // Constructors
 
-        //- Default construct
+        //- Null constructor, sort later (eg, after assignment or transfer)
         inline constexpr SortableList() noexcept;
 
         //- Construct given size, sort later.
@@ -143,7 +143,7 @@ public:
         void partialReverseSort(label n, label start=0);
 
         //- Swap content with another SortableList in constant time
-        inline void swap(SortableList<T>& other);
+        inline void swap(SortableList<T>& lst);
 
 
     // Member Operators
@@ -160,22 +160,20 @@ public:
         //- Move assignment, removing indices. Takes linear time
         inline void operator=(List<T>&& lst);
 
-        //- Move operator (constant time)
+        //- Move operator. Takes linear time
         inline void operator=(SortableList<T>&& lst);
 
         //- Assignment to an initializer list
         void operator=(std::initializer_list<T> lst);
+
 };
 
 
-// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+// Global Functions
 
 // Exchange contents of lists - see SortableList::swap().
 template<class T>
-inline void Swap(SortableList<T>& a, SortableList<T>& b)
-{
-    a.swap(b);
-}
+inline void Swap(SortableList<T>& a, SortableList<T>& b);
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/OpenFOAM/containers/Lists/UList/UList.C

@@ -193,7 +193,7 @@ std::streamsize Foam::UList<T>::byteSize() const
     if (!is_contiguous<T>::value)
     {
         FatalErrorInFunction
-            << "Invalid for non-contiguous data types"
+            << "Cannot return binary size of a list with non-primitive elements"
             << abort(FatalError);
     }
 

src/OpenFOAM/containers/Lists/UList/UList.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -101,13 +101,9 @@ protected:
 
     // Protected Member Functions
 
-        //- Set addressed size to be inconsistent with allocated storage.
+        //- Override size to be inconsistent with allocated storage.
         //  Use with care
-        inline void setAddressableSize(const label n) noexcept;
-
-        //- Older name for setAddressableSize
-        FOAM_DEPRECATED_FOR(2021-01, "setAddressableSize(label) method")
-        void size(const label n) { this->setAddressableSize(n); }
+        inline void size(const label n) noexcept;
 
         //- Write the UList with its compound type
         void writeEntry(Ostream& os) const;
@@ -252,15 +248,22 @@ public:
             //- Return reverse circular value (ie, previous value in the list)
             inline T& rcValue(const label i);
 
+            //- Return the binary size in number of characters of the UList
+            //- if the element is a primitive type
+            //  i.e. is_contiguous<T>::value == true.
+            //  Note that is of type streamsize since used in stream ops
+            std::streamsize byteSize() const;
+
+
             //- Return a const pointer to the first data element.
             //  Similar to the STL front() method and the string::data() method
             //  This can be used (with caution) when interfacing with C code
-            inline const T* cdata() const noexcept;
+            inline const T* cdata() const;
 
             //- Return a pointer to the first data element.
             //  Similar to the STL front() method and the string::data() method
             //  This can be used (with caution) when interfacing with C code
-            inline T* data() noexcept;
+            inline T* data();
 
             //- Return the first element of the list
             inline T& first();
@@ -274,10 +277,6 @@ public:
             //- Return the last element of the list
             inline const T& last() const;
 
-            //- The number of bytes stored by the list data for contiguous types
-            //  \note is a std::streamsize since it is used in stream ops
-            std::streamsize byteSize() const;
-
 
     // Check
 
@@ -372,25 +371,25 @@ public:
     // Random access iterator (non-const)
 
         //- Return an iterator to begin traversing the UList
-        inline iterator begin() noexcept;
+        inline iterator begin();
 
         //- Return an iterator to end traversing the UList
-        inline iterator end() noexcept;
+        inline iterator end();
 
 
     // Random access iterator (const)
 
         //- Return const_iterator to begin traversing the constant UList
-        inline const_iterator cbegin() const noexcept;
+        inline const_iterator cbegin() const;
 
         //- Return const_iterator to end traversing the constant UList
-        inline const_iterator cend() const noexcept;
+        inline const_iterator cend() const;
 
         //- Return const_iterator to begin traversing the constant UList
-        inline const_iterator begin() const noexcept;
+        inline const_iterator begin() const;
 
         //- Return const_iterator to end traversing the constant UList
-        inline const_iterator end() const noexcept;
+        inline const_iterator end() const;
 
 
     // Reverse iterators (non-const)
@@ -583,12 +582,9 @@ inline void reverse(UList<T>& list, const label n);
 template<class T>
 inline void reverse(UList<T>& list);
 
-//- Exchange contents of lists - see UList::swap().
+// Exchange contents of lists - see UList::swap().
 template<class T>
-inline void Swap(UList<T>& a, UList<T>& b)
-{
-    a.swap(b);
-}
+inline void Swap(UList<T>& a, UList<T>& b);
 
 
 //- Hashing for UList data, which uses Hasher for contiguous data and

src/OpenFOAM/containers/Lists/UList/UListI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2015-2021 OpenCFD Ltd.
+    Copyright (C) 2015-2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -28,6 +28,7 @@ License
 
 #include "error.H"
 #include "pTraits.H"
+#include "Swap.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -194,14 +195,14 @@ inline const T& Foam::UList<T>::last() const
 
 
 template<class T>
-inline const T* Foam::UList<T>::cdata() const noexcept
+inline const T* Foam::UList<T>::cdata() const
 {
     return v_;
 }
 
 
 template<class T>
-inline T* Foam::UList<T>::data() noexcept
+inline T* Foam::UList<T>::data()
 {
     return v_;
 }
@@ -272,42 +273,42 @@ inline Foam::UList<T>::operator const Foam::List<T>&() const
 
 template<class T>
 inline typename Foam::UList<T>::iterator
-Foam::UList<T>::begin() noexcept
+Foam::UList<T>::begin()
 {
     return v_;
 }
 
 template<class T>
 inline typename Foam::UList<T>::const_iterator
-Foam::UList<T>::begin() const noexcept
+Foam::UList<T>::begin() const
 {
     return v_;
 }
 
 template<class T>
 inline typename Foam::UList<T>::const_iterator
-Foam::UList<T>::cbegin() const noexcept
+Foam::UList<T>::cbegin() const
 {
     return v_;
 }
 
 template<class T>
 inline typename Foam::UList<T>::iterator
-Foam::UList<T>::end() noexcept
+Foam::UList<T>::end()
 {
     return (v_ + size_);
 }
 
 template<class T>
 inline typename Foam::UList<T>::const_iterator
-Foam::UList<T>::end() const noexcept
+Foam::UList<T>::end() const
 {
     return (v_ + size_);
 }
 
 template<class T>
 inline typename Foam::UList<T>::const_iterator
-Foam::UList<T>::cend() const noexcept
+Foam::UList<T>::cend() const
 {
     return (v_ + size_);
 }
@@ -356,7 +357,7 @@ Foam::UList<T>::crend() const
 
 
 template<class T>
-inline void Foam::UList<T>::setAddressableSize(const label n) noexcept
+inline void Foam::UList<T>::size(const label n) noexcept
 {
     size_ = n;
 }
@@ -384,8 +385,8 @@ inline void Foam::UList<T>::swap(UList<T>& list)
         return;  // Self-swap is a no-op
     }
 
-    std::swap(size_, list.size_);
-    std::swap(v_, list.v_);
+    Foam::Swap(size_, list.size_);
+    Foam::Swap(v_, list.v_);
 }
 
 
@@ -408,4 +409,11 @@ inline void Foam::reverse(UList<T>& list)
 }
 
 
+template<class T>
+inline void Foam::Swap(UList<T>& a, UList<T>& b)
+{
+    a.swap(b);
+}
+
+
 // ************************************************************************* //

src/OpenFOAM/containers/PtrLists/PtrDynList/PtrDynList.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -71,11 +71,17 @@ class PtrDynList
         label capacity_;
 
 
+    // Private Member Functions
+
+        //- Adjust addressable size
+        void setAddressableSize(const label len);
+
+
 public:
 
     // Constructors
 
-        //- Default construct
+        //- Construct null
         inline constexpr PtrDynList() noexcept;
 
         //- Construct with given capacity.
@@ -112,20 +118,23 @@ public:
         const T* set(const label i) const { return this->get(i); }
 
 
-    // Sizing
+    // Edit
+
+        //- Delete the allocated entries, but retain the list size.
+        using PtrList<T>::free;
 
         //- Alter the size of the underlying storage.
-        inline void setCapacity(const label newCapacity);
-
-        //- Reserve allocation space for at least this size.
-        //  Never shrinks the allocated size, use setCapacity() for that.
-        inline void reserve(const label len);
+        inline void setCapacity(const label nElem);
 
         //- Alter the addressed list size.
         inline void resize(const label newLen);
 
         //- Same as resize()
-        void setSize(const label n) { this->resize(n); }
+        inline void setSize(const label newLen);
+
+        //- Reserve allocation space for at least this size.
+        //  Never shrinks the allocated size, use setCapacity() for that.
+        inline void reserve(const label nElem);
 
         //- Clear the addressed list, i.e. set the size to zero.
         //  Allocated size does not change
@@ -136,26 +145,16 @@ public:
 
         //- Expand the addressable size to fit the allocated capacity.
         //  Returns the previous addressable size.
-        inline label expandStorage() noexcept;
+        inline label expandStorage();
 
         //- Shrink the allocated space to the number of elements used.
         inline void shrink();
 
-
-    // Edit
-
-        //- Delete the allocated entries, but retain the list size.
-        using PtrList<T>::free;
-
         //- Squeeze out intermediate nullptr entries in the list of pointers
         //- and adjust the addressable size accordingly.
         //  \return the number of non-null entries
         inline label squeezeNull();
 
-        //- Swap content, independent of sizing parameter
-        template<int AnySizeMin>
-        inline void swap(PtrDynList<T, AnySizeMin>& other);
-
         //- Construct and append an element to the end of the list
         template<class... Args>
         inline void emplace_append(Args&&... args);
@@ -235,6 +234,7 @@ public:
         //- Move assignment with different sizing parameters
         template<int AnySizeMin>
         inline void operator=(PtrDynList<T, AnySizeMin>&& list);
+
 };
 
 

src/OpenFOAM/containers/PtrLists/PtrDynList/PtrDynListI.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,6 +29,15 @@ License
 #include "refPtr.H"
 #include "tmp.H"
 
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class T, int SizeMin>
+inline void Foam::PtrDynList<T, SizeMin>::setAddressableSize(const label len)
+{
+    (this->ptrs_).setAddressableSize(len);
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class T, int SizeMin>
@@ -45,7 +54,7 @@ inline Foam::PtrDynList<T, SizeMin>::PtrDynList(const label len)
     PtrList<T>(len),
     capacity_(len)
 {
-    PtrList<T>::setAddressableSize(0);
+    setAddressableSize(0);
 }
 
 
@@ -98,34 +107,35 @@ inline const T* Foam::PtrDynList<T, SizeMin>::get(const label i) const
 
 
 template<class T, int SizeMin>
-inline void Foam::PtrDynList<T, SizeMin>::setCapacity(const label newCapacity)
+inline void Foam::PtrDynList<T, SizeMin>::setCapacity(const label nElem)
 {
-    label currLen = PtrList<T>::size();
-    capacity_ = newCapacity;
+    label nextFree = PtrList<T>::size();
+    capacity_ = nElem;
 
-    if (currLen > capacity_)
+    if (nextFree > capacity_)
     {
         // Truncate addressed sizes too
-        currLen = capacity_;
+        nextFree = capacity_;
     }
 
     PtrList<T>::resize(capacity_);
-    PtrList<T>::setAddressableSize(currLen);
+    setAddressableSize(nextFree);
 }
 
 
 template<class T, int SizeMin>
-inline void Foam::PtrDynList<T, SizeMin>::reserve(const label len)
+inline void Foam::PtrDynList<T, SizeMin>::reserve(const label nElem)
 {
-    if (capacity_ < len)
+    if (nElem > capacity_)
     {
-        // Increase capacity (doubling)
-        capacity_ = max(SizeMin, max(len, label(2 * capacity_)));
+        // Allocate more capacity if necessary
+
+        capacity_ = max(SizeMin, max(nElem, label(2*capacity_)));
 
         // Adjust allocated size, leave addressed size untouched
-        const label currLen = PtrList<T>::size();
+        const label nextFree = PtrList<T>::size();
         PtrList<T>::resize(capacity_);
-        PtrList<T>::setAddressableSize(currLen);
+        setAddressableSize(nextFree);
     }
 }
 
@@ -137,25 +147,31 @@ inline void Foam::PtrDynList<T, SizeMin>::resize(const label newLen)
 
     const label oldLen = ptrs.size();
 
-    if (capacity_ < newLen)
+    if (newLen > capacity_)
     {
-        // Increase capacity (doubling)
-        capacity_ = max(SizeMin, max(newLen, label(2 * capacity_)));
+        // Allocate more capacity if necessary
+        capacity_ = max(SizeMin, max(newLen, label(2*capacity_)));
 
         PtrList<T>::resize(capacity_);
     }
     else if (newLen != oldLen)
     {
         // Truncation frees old pointers
-        for (label i = newLen; i < oldLen; ++i)
+        for (label i=newLen; i<oldLen; ++i)
         {
             delete ptrs[i];
             ptrs[i] = nullptr;
         }
     }
 
-    // Adjust addressed size
-    PtrList<T>::setAddressableSize(newLen);
+    setAddressableSize(newLen);
+}
+
+
+template<class T, int SizeMin>
+inline void Foam::PtrDynList<T, SizeMin>::setSize(const label newLen)
+{
+    this->resize(newLen);
 }
 
 
@@ -163,7 +179,7 @@ template<class T, int SizeMin>
 inline void Foam::PtrDynList<T, SizeMin>::clear()
 {
     (this->ptrs_).free(); // free old pointers
-    PtrList<T>::setAddressableSize(0);
+    setAddressableSize(0);
 }
 
 
@@ -176,30 +192,30 @@ inline void Foam::PtrDynList<T, SizeMin>::clearStorage()
 
 
 template<class T, int SizeMin>
-inline Foam::label Foam::PtrDynList<T, SizeMin>::expandStorage() noexcept
+inline Foam::label Foam::PtrDynList<T, SizeMin>::expandStorage()
 {
-    const label currLen = PtrList<T>::size();
+    const label nextFree = PtrList<T>::size();
 
     // Allow addressing into the entire list
-    PtrList<T>::setAddressableSize(capacity_);
+    setAddressableSize(capacity_);
 
-    return currLen;
+    return nextFree;
 }
 
 
 template<class T, int SizeMin>
 inline void Foam::PtrDynList<T, SizeMin>::shrink()
 {
-    const label currLen = PtrList<T>::size();
-    if (currLen < capacity_)
+    label nextFree = PtrList<T>::size();
+    if (capacity_ > nextFree)
     {
         // Use the full list when resizing
-        PtrList<T>::setAddressableSize(capacity_);
+        setAddressableSize(capacity_);
 
-        // Capacity and size are identical
-        capacity_ = currLen;
-        PtrList<T>::resize(currLen);
-        // Redundant: PtrList<T>::setAddressableSize(currLen);
+        // The new size
+        capacity_ = nextFree;
+        PtrList<T>::resize(capacity_);
+        setAddressableSize(nextFree);
     }
 }
 
@@ -213,27 +229,6 @@ inline Foam::label Foam::PtrDynList<T, SizeMin>::squeezeNull()
 }
 
 
-template<class T, int SizeMin>
-template<int AnySizeMin>
-inline void Foam::PtrDynList<T, SizeMin>::swap
-(
-    PtrDynList<T, AnySizeMin>& other
-)
-{
-    // Cannot compare 'this' for different types, so use cdata()
-    if (this->cdata() == other.cdata())
-    {
-        return;  // Self-swap is a no-op
-    }
-
-    // Swap storage and addressable size
-    UPtrList<T>::swap(other);
-
-    // Swap capacity
-    std::swap(this->capacity_, other.capacity_);
-}
-
-
 template<class T, int SizeMin>
 template<class... Args>
 inline void Foam::PtrDynList<T, SizeMin>::emplace_append(Args&&... args)
@@ -337,7 +332,7 @@ inline Foam::autoPtr<T> Foam::PtrDynList<T, SizeMin>::remove()
 
     autoPtr<T> old(this->ptrs_[idx]);
     this->ptrs_[idx] = nullptr;
-    PtrList<T>::setAddressableSize(idx);
+    setAddressableSize(idx);
 
     return old;
 }

src/OpenFOAM/containers/PtrLists/PtrList/PtrList.H

@@ -149,7 +149,7 @@ public:
         void resize(const label newLen);
 
         //- Same as resize()
-        void setSize(const label newLen) { this->resize(newLen); }
+        inline void setSize(const label newLen);
 
         //- Construct and append an element to the end of the list
         template<class... Args>

src/OpenFOAM/containers/PtrLists/PtrList/PtrListI.H

@@ -101,6 +101,13 @@ inline void Foam::PtrList<T>::clear()
 }
 
 
+template<class T>
+inline void Foam::PtrList<T>::setSize(const label newLen)
+{
+    this->resize(newLen);
+}
+
+
 template<class T>
 template<class... Args>
 inline void Foam::PtrList<T>::emplace_append(Args&&... args)

src/OpenFOAM/containers/PtrLists/PtrListDetail/PtrListDetail.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -106,9 +106,9 @@ public:
         //  New entries are initialized to nullptr.
         inline void resize(const label newLen);
 
-        //- Set addressed size to be inconsistent with allocated storage.
+        //- Override size to be inconsistent with allocated storage.
         //  Use with care
-        inline void setAddressableSize(const label n) noexcept;
+        inline void setAddressableSize(const label n);
 
         //- Write output, optionally silently trimming nullptrs
         Ostream& write(Ostream& os, const bool trimNull=false) const;

src/OpenFOAM/containers/PtrLists/PtrListDetail/PtrListDetailI.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -85,12 +85,9 @@ inline Foam::Detail::PtrListDetail<T>::PtrListDetail
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class T>
-inline void Foam::Detail::PtrListDetail<T>::setAddressableSize
-(
-    const label n
-) noexcept
+inline void Foam::Detail::PtrListDetail<T>::setAddressableSize(const label n)
 {
-    List<T*>::setAddressableSize(n);
+    List<T*>::size(n);
 }
 
 

src/OpenFOAM/containers/PtrLists/UPtrList/UPtrList.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -78,16 +78,10 @@ protected:
         Detail::PtrListDetail<T> ptrs_;
 
 
-    // Protected Member Functions
-
-        //- Adjust addressable size
-        inline void setAddressableSize(const label n) noexcept;
-
-
     // Constructors
 
         //- Low-level move construct
-        inline explicit UPtrList(Detail::PtrListDetail<T>&& ptrs);
+        inline UPtrList(Detail::PtrListDetail<T>&& ptrs);
 
 
 public:
@@ -164,15 +158,15 @@ public:
         inline const T& last() const;
 
         //- Return pointer to element (can be nullptr),
-        //- without bounds checking.
+        //  without bounds checking.
         inline T* get(const label i);
 
         //- Return const pointer to element (can be nullptr),
-        //- without bounds checking.
+        //  without bounds checking.
         inline const T* get(const label i) const;
 
         //- Return const pointer to element (can be nullptr),
-        //- without bounds checking - same as get().
+        //  without bounds checking - same as get().
         //  The return value can also be tested as a bool.
         const T* set(const label i) const { return this->get(i); }
 
@@ -182,12 +176,12 @@ public:
         //- Set list size to zero.
         inline void clear();
 
-        //- Change the size of the list.
+        //- Reset size of list.
         //  New entries are initialized to nullptr.
         inline void resize(const label newLen);
 
-        //- Alias for resize()
-        void setSize(const label n) { this->resize(n); }
+        //- Same as resize()
+        inline void setSize(const label newLen);
 
         //- Squeeze out intermediate nullptr entries in the list of pointers
         //  \return the number of non-null entries
@@ -241,7 +235,6 @@ public:
         //- Random-access iterator with non-const access
         class iterator
         {
-            // Pointer to parent
             T** ptr_;
 
         public:
@@ -254,52 +247,51 @@ public:
             friend class const_iterator;
 
             //- Construct for a given entry
-            inline iterator(T** ptr) noexcept;
+            inline iterator(T** ptr);
 
-            // Member Functions
+            // Member functions
 
             //- Return pointer, can be nullptr.
             inline pointer get() const;
 
-            // Member Operators
+            // Member operators
+
+            inline bool operator==(const iterator& iter) const;
+            inline bool operator!=(const iterator& iter) const;
 
             inline pointer operator->() const;
             inline reference operator*() const;
 
-            reference operator()() const { return this->operator*(); }
-            inline reference operator[](difference_type n) const;
+            inline reference operator()() const;
 
             // Forward iteration
-            inline iterator& operator++() noexcept;
-            inline iterator operator++(int) noexcept;
+            inline iterator& operator++();
+            inline iterator operator++(int);
 
-            inline iterator& operator--() noexcept;
-            inline iterator operator--(int) noexcept;
+            inline iterator& operator--();
+            inline iterator operator--(int);
 
             // Random-access
-            inline iterator& operator+=(difference_type n) noexcept;
-            inline iterator& operator-=(difference_type n) noexcept;
-            inline iterator operator+(difference_type n) const noexcept;
-            inline iterator operator-(difference_type n) const noexcept;
+            inline iterator& operator+=(difference_type n);
+            inline iterator& operator-=(difference_type n);
+            inline iterator operator+(difference_type n) const;
+            inline iterator operator-(difference_type n) const;
 
-            inline difference_type operator-(const iterator& iter)
-            const noexcept;
+            inline difference_type operator-(const iterator& iter) const;
 
-            inline bool operator==(const iterator& iter) const noexcept;
-            inline bool operator!=(const iterator& iter) const noexcept;
+            inline reference operator[](difference_type n) const;
 
-            inline bool operator<(const iterator& iter) const noexcept;
-            inline bool operator>(const iterator& iter) const noexcept;
+            inline bool operator<(const iterator& iter) const;
+            inline bool operator>(const iterator& iter) const;
 
-            inline bool operator<=(const iterator& iter) const noexcept;
-            inline bool operator>=(const iterator& iter) const noexcept;
+            inline bool operator<=(const iterator& iter) const;
+            inline bool operator>=(const iterator& iter) const;
         };
 
 
         //- Random-access iterator with const access
         class const_iterator
         {
-            // Pointer to parent
             const T* const* ptr_;
 
         public:
@@ -311,68 +303,68 @@ public:
             using reference = const T&;
 
             //- Construct for a given entry
-            inline const_iterator(const T* const* ptr) noexcept;
+            inline const_iterator(const T* const* ptr);
 
             //- Copy construct from non-const iterator
-            inline const_iterator(const iterator& iter) noexcept;
+            inline const_iterator(const iterator& iter);
 
-            // Member Functions
+            // Member functions
 
             //- Return pointer, can be nullptr.
             inline pointer get() const;
 
-            // Member Operators
+            // Member operators
+
+            inline bool operator==(const const_iterator& iter) const;
+            inline bool operator!=(const const_iterator& iter) const;
 
             inline pointer operator->() const;
             inline reference operator*() const;
 
-            reference operator()() const { return this->operator*(); }
-            inline reference operator[](difference_type n) const;
+            inline reference operator()() const;
 
             // Forward iteration
-            inline const_iterator& operator++() noexcept;
-            inline const_iterator operator++(int) noexcept;
+            inline const_iterator& operator++();
+            inline const_iterator operator++(int);
 
-            inline const_iterator& operator--() noexcept;
-            inline const_iterator operator--(int) noexcept;
+            inline const_iterator& operator--();
+            inline const_iterator operator--(int);
 
             // Random-access
-            inline const_iterator& operator+=(difference_type n) noexcept;
-            inline const_iterator& operator-=(difference_type n) noexcept;
-            inline const_iterator operator+(difference_type n) const noexcept;
-            inline const_iterator operator-(difference_type n) const noexcept;
+            inline const_iterator& operator+=(difference_type n);
+            inline const_iterator& operator-=(difference_type n);
+            inline const_iterator operator+(difference_type n) const;
+            inline const_iterator operator-(difference_type n) const;
 
-            inline difference_type operator-(const const_iterator& iter)
-            const noexcept;
+            inline difference_type operator-(const const_iterator& iter) const;
 
-            inline bool operator==(const const_iterator& iter) const noexcept;
-            inline bool operator!=(const const_iterator& iter) const noexcept;
+            inline reference operator[](difference_type n) const;
 
-            inline bool operator<(const const_iterator& iter) const noexcept;
-            inline bool operator>(const const_iterator& iter) const noexcept;
+            inline bool operator<(const const_iterator& iter) const;
+            inline bool operator>(const const_iterator& iter) const;
 
-            inline bool operator<=(const const_iterator& iter) const noexcept;
-            inline bool operator>=(const const_iterator& iter) const noexcept;
+            inline bool operator<=(const const_iterator& iter) const;
+            inline bool operator>=(const const_iterator& iter) const;
         };
 
 
         //- Return an iterator to begin traversing the UPtrList
-        inline iterator begin() noexcept;
+        inline iterator begin();
 
         //- Return an iterator to end traversing the UPtrList
-        inline iterator end() noexcept;
+        inline iterator end();
 
         //- Return an const_iterator to begin traversing the UPtrList
-        inline const_iterator cbegin() const noexcept;
+        inline const_iterator cbegin() const;
 
         //- Return an const_iterator to end traversing the UPtrList
-        inline const_iterator cend() const noexcept;
+        inline const_iterator cend() const;
 
         //- Return an const_iterator to begin traversing the UPtrList
-        inline const_iterator begin() const noexcept;
+        inline const_iterator begin() const;
 
         //- Return an const_iterator to end traversing the UPtrList
-        inline const_iterator end() const noexcept;
+        inline const_iterator end() const;
 
 
     // IOstream operator
@@ -383,6 +375,7 @@ public:
             Ostream& os,
             const UPtrList<T>& list
         );
+
 };
 
 

src/OpenFOAM/containers/PtrLists/UPtrList/UPtrListI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -26,15 +26,6 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
-
-template<class T>
-inline void Foam::UPtrList<T>::setAddressableSize(const label n) noexcept
-{
-    ptrs_.setAddressableSize(n);
-}
-
-
 // * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
 
 template<class T>
@@ -186,6 +177,13 @@ inline void Foam::UPtrList<T>::resize(const label newLen)
 }
 
 
+template<class T>
+inline void Foam::UPtrList<T>::setSize(const label newLen)
+{
+    ptrs_.resize(newLen);
+}
+
+
 template<class T>
 inline void Foam::UPtrList<T>::append(T* ptr)
 {
@@ -254,8 +252,7 @@ inline const T* Foam::UPtrList<T>::operator()(const label i) const
 // * * * * * * * * * * * * * * * * iterator  * * * * * * * * * * * * * * * * //
 
 template<class T>
-inline Foam::UPtrList<T>::iterator::
-iterator(T** ptr) noexcept
+inline Foam::UPtrList<T>::iterator::iterator(T** ptr)
 :
     ptr_(ptr)
 {}
@@ -268,6 +265,20 @@ inline T* Foam::UPtrList<T>::iterator::get() const
 }
 
 
+template<class T>
+inline bool Foam::UPtrList<T>::iterator::operator==(const iterator& iter) const
+{
+    return ptr_ == iter.ptr_;
+}
+
+
+template<class T>
+inline bool Foam::UPtrList<T>::iterator::operator!=(const iterator& iter) const
+{
+    return ptr_ != iter.ptr_;
+}
+
+
 template<class T>
 inline T* Foam::UPtrList<T>::iterator::operator->() const
 {
@@ -283,14 +294,15 @@ inline T& Foam::UPtrList<T>::iterator::operator*() const
 
 
 template<class T>
-inline T& Foam::UPtrList<T>::iterator::operator[](label n) const
+inline T& Foam::UPtrList<T>::iterator::operator()() const
 {
-    return **(ptr_ + n);
+    return **ptr_;
 }
 
+
 template<class T>
 inline typename Foam::UPtrList<T>::iterator&
-Foam::UPtrList<T>::iterator::operator++() noexcept
+Foam::UPtrList<T>::iterator::operator++()
 {
     ++ptr_;
     return *this;
@@ -299,7 +311,7 @@ Foam::UPtrList<T>::iterator::operator++() noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::iterator
-Foam::UPtrList<T>::iterator::operator++(int) noexcept
+Foam::UPtrList<T>::iterator::operator++(int)
 {
     iterator iter(*this);
     ++ptr_;
@@ -309,7 +321,7 @@ Foam::UPtrList<T>::iterator::operator++(int) noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::iterator&
-Foam::UPtrList<T>::iterator::operator--() noexcept
+Foam::UPtrList<T>::iterator::operator--()
 {
     --ptr_;
     return *this;
@@ -318,7 +330,7 @@ Foam::UPtrList<T>::iterator::operator--() noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::iterator
-Foam::UPtrList<T>::iterator::operator--(int) noexcept
+Foam::UPtrList<T>::iterator::operator--(int)
 {
     iterator iter(*this);
     --ptr_;
@@ -328,7 +340,7 @@ Foam::UPtrList<T>::iterator::operator--(int) noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::iterator&
-Foam::UPtrList<T>::iterator::operator+=(label n) noexcept
+Foam::UPtrList<T>::iterator::operator+=(label n)
 {
     ptr_ += n;
     return *this;
@@ -337,7 +349,7 @@ Foam::UPtrList<T>::iterator::operator+=(label n) noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::iterator&
-Foam::UPtrList<T>::iterator::operator-=(label n) noexcept
+Foam::UPtrList<T>::iterator::operator-=(label n)
 {
     ptr_ -= n;
     return *this;
@@ -346,7 +358,7 @@ Foam::UPtrList<T>::iterator::operator-=(label n) noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::iterator
-Foam::UPtrList<T>::iterator::operator+(label n) const noexcept
+Foam::UPtrList<T>::iterator::operator+(label n) const
 {
     return iterator(ptr_ + n);
 }
@@ -354,7 +366,7 @@ Foam::UPtrList<T>::iterator::operator+(label n) const noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::iterator
-Foam::UPtrList<T>::iterator::operator-(label n) const noexcept
+Foam::UPtrList<T>::iterator::operator-(label n) const
 {
     return iterator(ptr_ - n);
 }
@@ -362,56 +374,42 @@ Foam::UPtrList<T>::iterator::operator-(label n) const noexcept
 
 template<class T>
 inline Foam::label
-Foam::UPtrList<T>::iterator::
-operator-(const iterator& iter) const noexcept
+Foam::UPtrList<T>::iterator::operator-(const iterator& iter) const
 {
     return (ptr_ - iter.ptr_);
 }
 
 
 template<class T>
-inline bool Foam::UPtrList<T>::iterator::
-operator==(const iterator& iter) const noexcept
+inline T& Foam::UPtrList<T>::iterator::operator[](label n) const
 {
-    return ptr_ == iter.ptr_;
+    return *(*this + n);
 }
 
 
 template<class T>
-inline bool Foam::UPtrList<T>::iterator::
-operator!=(const iterator& iter) const noexcept
-{
-    return ptr_ != iter.ptr_;
-}
-
-
-template<class T>
-inline bool Foam::UPtrList<T>::iterator::
-operator<(const iterator& iter) const noexcept
+inline bool Foam::UPtrList<T>::iterator::operator<(const iterator& iter) const
 {
     return ptr_ < iter.ptr_;
 }
 
 
 template<class T>
-inline bool Foam::UPtrList<T>::iterator::
-operator>(const iterator& iter) const noexcept
+inline bool Foam::UPtrList<T>::iterator::operator>(const iterator& iter) const
 {
     return ptr_ > iter.ptr_;
 }
 
 
 template<class T>
-inline bool Foam::UPtrList<T>::iterator::
-operator<=(const iterator& iter) const noexcept
+inline bool Foam::UPtrList<T>::iterator::operator<=(const iterator& iter) const
 {
     return ptr_ <= iter.ptr_;
 }
 
 
 template<class T>
-inline bool Foam::UPtrList<T>::iterator::
-operator>=(const iterator& iter) const noexcept
+inline bool Foam::UPtrList<T>::iterator::operator>=(const iterator& iter) const
 {
     return ptr_ >= iter.ptr_;
 }
@@ -420,16 +418,14 @@ operator>=(const iterator& iter) const noexcept
 // * * * * * * * * * * * * * * * const_iterator  * * * * * * * * * * * * * * //
 
 template<class T>
-inline Foam::UPtrList<T>::const_iterator::
-const_iterator(const T* const* ptr) noexcept
+inline Foam::UPtrList<T>::const_iterator::const_iterator(const T* const* ptr)
 :
     ptr_(ptr)
 {}
 
 
 template<class T>
-inline Foam::UPtrList<T>::const_iterator::
-const_iterator(const iterator& iter) noexcept
+inline Foam::UPtrList<T>::const_iterator::const_iterator(const iterator& iter)
 :
     ptr_(iter.ptr_)
 {}
@@ -442,6 +438,26 @@ inline const T* Foam::UPtrList<T>::const_iterator::get() const
 }
 
 
+template<class T>
+inline bool Foam::UPtrList<T>::const_iterator::operator==
+(
+    const const_iterator& iter
+) const
+{
+    return ptr_ == iter.ptr_;
+}
+
+
+template<class T>
+inline bool Foam::UPtrList<T>::const_iterator::operator!=
+(
+    const const_iterator& iter
+) const
+{
+    return ptr_ != iter.ptr_;
+}
+
+
 template<class T>
 inline const T* Foam::UPtrList<T>::const_iterator::operator->() const
 {
@@ -457,16 +473,15 @@ inline const T& Foam::UPtrList<T>::const_iterator::operator*() const
 
 
 template<class T>
-inline const T&
-Foam::UPtrList<T>::const_iterator::operator[](label n) const
+inline const T& Foam::UPtrList<T>::const_iterator::operator()() const
 {
-    return **(ptr_ + n);
+    return **ptr_;
 }
 
 
 template<class T>
 inline typename Foam::UPtrList<T>::const_iterator&
-Foam::UPtrList<T>::const_iterator::operator++() noexcept
+Foam::UPtrList<T>::const_iterator::operator++()
 {
     ++ptr_;
     return *this;
@@ -475,7 +490,7 @@ Foam::UPtrList<T>::const_iterator::operator++() noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::const_iterator
-Foam::UPtrList<T>::const_iterator::operator++(int) noexcept
+Foam::UPtrList<T>::const_iterator::operator++(int)
 {
     const_iterator iter(*this);
     ++ptr_;
@@ -485,7 +500,7 @@ Foam::UPtrList<T>::const_iterator::operator++(int) noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::const_iterator&
-Foam::UPtrList<T>::const_iterator::operator--() noexcept
+Foam::UPtrList<T>::const_iterator::operator--()
 {
     --ptr_;
     return *this;
@@ -494,7 +509,7 @@ Foam::UPtrList<T>::const_iterator::operator--() noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::const_iterator
-Foam::UPtrList<T>::const_iterator::operator--(int) noexcept
+Foam::UPtrList<T>::const_iterator::operator--(int)
 {
     const_iterator iter(*this);
     --ptr_;
@@ -504,7 +519,7 @@ Foam::UPtrList<T>::const_iterator::operator--(int) noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::const_iterator&
-Foam::UPtrList<T>::const_iterator::operator+=(label n) noexcept
+Foam::UPtrList<T>::const_iterator::operator+=(label n)
 {
     ptr_ += n;
     return *this;
@@ -513,7 +528,7 @@ Foam::UPtrList<T>::const_iterator::operator+=(label n) noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::const_iterator&
-Foam::UPtrList<T>::const_iterator::operator-=(label n) noexcept
+Foam::UPtrList<T>::const_iterator::operator-=(label n)
 {
     ptr_ -= n;
     return *this;
@@ -522,7 +537,7 @@ Foam::UPtrList<T>::const_iterator::operator-=(label n) noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::const_iterator
-Foam::UPtrList<T>::const_iterator::operator+(label n) const noexcept
+Foam::UPtrList<T>::const_iterator::operator+(label n) const
 {
     return const_iterator(ptr_ + n);
 }
@@ -530,7 +545,7 @@ Foam::UPtrList<T>::const_iterator::operator+(label n) const noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::const_iterator
-Foam::UPtrList<T>::const_iterator::operator-(label n) const noexcept
+Foam::UPtrList<T>::const_iterator::operator-(label n) const
 {
     return const_iterator(ptr_ - n);
 }
@@ -538,56 +553,55 @@ Foam::UPtrList<T>::const_iterator::operator-(label n) const noexcept
 
 template<class T>
 inline Foam::label
-Foam::UPtrList<T>::const_iterator::
-operator-(const const_iterator& iter) const noexcept
+Foam::UPtrList<T>::const_iterator::operator-(const const_iterator& iter) const
 {
     return (ptr_ - iter.ptr_);
 }
 
 
 template<class T>
-inline bool Foam::UPtrList<T>::const_iterator::
-operator==(const const_iterator& iter) const noexcept
+inline const T&
+Foam::UPtrList<T>::const_iterator::operator[](label n) const
 {
-    return ptr_ == iter.ptr_;
+    return *(*this + n);
 }
 
 
 template<class T>
-inline bool Foam::UPtrList<T>::const_iterator::
-operator!=(const const_iterator& iter) const noexcept
-{
-    return ptr_ != iter.ptr_;
-}
-
-
-template<class T>
-inline bool Foam::UPtrList<T>::const_iterator::
-operator<(const const_iterator& iter) const noexcept
+inline bool Foam::UPtrList<T>::const_iterator::operator<
+(
+    const const_iterator& iter
+) const
 {
     return ptr_ < iter.ptr_;
 }
 
 
 template<class T>
-inline bool Foam::UPtrList<T>::const_iterator::
-operator>(const const_iterator& iter) const noexcept
+inline bool Foam::UPtrList<T>::const_iterator::operator>
+(
+    const const_iterator& iter
+) const
 {
     return ptr_ > iter.ptr_;
 }
 
 
 template<class T>
-inline bool Foam::UPtrList<T>::const_iterator::
-operator<=(const const_iterator& iter) const noexcept
+inline bool Foam::UPtrList<T>::const_iterator::operator<=
+(
+    const const_iterator& iter
+) const
 {
     return ptr_ <= iter.ptr_;
 }
 
 
 template<class T>
-inline bool Foam::UPtrList<T>::const_iterator::
-operator>=(const const_iterator& iter) const noexcept
+inline bool Foam::UPtrList<T>::const_iterator::operator>=
+(
+    const const_iterator& iter
+) const
 {
     return ptr_ >= iter.ptr_;
 }
@@ -597,7 +611,7 @@ operator>=(const const_iterator& iter) const noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::iterator
-Foam::UPtrList<T>::begin() noexcept
+Foam::UPtrList<T>::begin()
 {
     return ptrs_.begin();
 }
@@ -605,7 +619,7 @@ Foam::UPtrList<T>::begin() noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::iterator
-Foam::UPtrList<T>::end() noexcept
+Foam::UPtrList<T>::end()
 {
     return ptrs_.end();
 }
@@ -613,7 +627,7 @@ Foam::UPtrList<T>::end() noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::const_iterator
-Foam::UPtrList<T>::cbegin() const noexcept
+Foam::UPtrList<T>::cbegin() const
 {
     return ptrs_.cbegin();
 }
@@ -621,7 +635,7 @@ Foam::UPtrList<T>::cbegin() const noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::const_iterator
-Foam::UPtrList<T>::cend() const noexcept
+Foam::UPtrList<T>::cend() const
 {
     return ptrs_.cend();
 }
@@ -629,7 +643,7 @@ Foam::UPtrList<T>::cend() const noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::const_iterator
-Foam::UPtrList<T>::begin() const noexcept
+Foam::UPtrList<T>::begin() const
 {
     return ptrs_.begin();
 }
@@ -637,7 +651,7 @@ Foam::UPtrList<T>::begin() const noexcept
 
 template<class T>
 inline typename Foam::UPtrList<T>::const_iterator
-Foam::UPtrList<T>::end() const noexcept
+Foam::UPtrList<T>::end() const
 {
     return ptrs_.end();
 }

src/OpenFOAM/db/IOobject/IOobject.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2016-2021 OpenCFD Ltd.
+    Copyright (C) 2016-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -511,8 +511,8 @@ public:
     // Writing
 
         //- Write the standard OpenFOAM file/dictionary banner
-        //  Optionally without editor syntax hint (eg, for logs)
-        static Ostream& writeBanner(Ostream& os, const bool noSyntaxHint=false);
+        //  Optionally without -*- C++ -*- editor hint (eg, for logs)
+        static Ostream& writeBanner(Ostream& os, bool noHint=false);
 
         //- Write the standard file section divider
         static Ostream& writeDivider(Ostream& os);
@@ -520,17 +520,11 @@ public:
         //- Write the standard end file divider
         static Ostream& writeEndDivider(Ostream& os);
 
-        //- Write header with current type() and arch information
+        //- Write header
         bool writeHeader(Ostream& os) const;
 
-        //- Write header with override of type and optionally without
-        //- arch information in ASCII
-        bool writeHeader
-        (
-            Ostream& os,
-            const word& objectType,
-            const bool noArchAscii = false
-        ) const;
+        //- Write header. Allow override of type
+        bool writeHeader(Ostream& os, const word& objectType) const;
 
 
     // Error Handling

src/OpenFOAM/db/IOobject/IOobjectWriteHeader.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2016-2021 OpenCFD Ltd.
+    Copyright (C) 2016-2017 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -42,8 +42,7 @@ License
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 
-Foam::Ostream&
-Foam::IOobject::writeBanner(Ostream& os, const bool noSyntaxHint)
+Foam::Ostream& Foam::IOobject::writeBanner(Ostream& os, bool noHint)
 {
     // The version padded with spaces to fit after "Version:  "
     // - initialized with zero-length string to detect if it has been populated
@@ -67,7 +66,7 @@ Foam::IOobject::writeBanner(Ostream& os, const bool noSyntaxHint)
     os  <<
         "/*--------------------------------";
 
-    if (noSyntaxHint)
+    if (noHint)
     {
         // Without syntax hint
         os  << "---------";
@@ -117,12 +116,7 @@ Foam::Ostream& Foam::IOobject::writeEndDivider(Ostream& os)
 }
 
 
-bool Foam::IOobject::writeHeader
-(
-    Ostream& os,
-    const word& objectType,
-    const bool noArchAscii
-) const
+bool Foam::IOobject::writeHeader(Ostream& os, const word& type) const
 {
     if (!os.good())
     {
@@ -133,37 +127,25 @@ bool Foam::IOobject::writeHeader
         return false;
     }
 
-    IOobject::writeBanner(os)
-        << "FoamFile" << nl
-        << '{' << nl
-        << "    version     " << os.version() << ';' << nl
-        << "    format      " << os.format() << ';' << nl;
+    writeBanner(os)
+        << "FoamFile\n{\n"
+        << "    version     " << os.version() << ";\n"
+        << "    format      " << os.format() << ";\n"
+        << "    class       " << type << ";\n";
 
-    if (os.format() == IOstream::BINARY || !noArchAscii)
+    if (os.format() == IOstream::BINARY)
     {
-        // Arch information (BINARY: always, ASCII: can disable)
-        os  << "    arch        " << foamVersion::buildArch << ';' << nl;
+        os  << "    arch        " << foamVersion::buildArch << ";\n";
     }
+
     if (!note().empty())
     {
-        os  << "    note        " << note() << ';' << nl;
+        os  << "    note        " << note() << ";\n";
     }
 
-    os  << "    class       ";
-    if (objectType.empty())
-    {
-        // Empty type not allowed - use 'dictionary' fallback
-        os  << "dictionary";
-    }
-    else
-    {
-        os  << objectType;
-    }
-    os  << ';' << nl;
-
-    os  << "    location    " << instance()/db().dbDir()/local() << ';' << nl
-        << "    object      " << name() << ';' << nl
-        << '}' << nl;
+    os  << "    location    " << instance()/db().dbDir()/local() << ";\n"
+        << "    object      " << name() << ";\n"
+        << "}" << nl;
 
     writeDivider(os) << nl;
 

src/OpenFOAM/db/IOobjects/decomposedBlockData/decomposedBlockData.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2017-2018 OpenFOAM Foundation
-    Copyright (C) 2020-2021 OpenCFD Ltd.
+    Copyright (C) 2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -188,47 +188,41 @@ void Foam::decomposedBlockData::writeHeader
     Ostream& os,
     const IOstream::versionNumber version,
     const IOstream::streamFormat format,
-    const word& objectType,
+    const word& type,
     const string& note,
     const fileName& location,
-    const word& objectName
+    const word& name
 )
 {
     IOobject::writeBanner(os)
-        << "FoamFile" << nl
-        << '{' << nl
-        << "    version     " << version << ';' << nl
-        << "    format      " << format << ';' << nl
-        << "    arch        " << foamVersion::buildArch << ';' << nl;
+        << "FoamFile\n{\n"
+        << "    version     " << version << ";\n"
+        << "    format      " << format << ";\n"
+        << "    class       " << type << ";\n";
+
+    // This may be useful to have as well
+    if (os.format() == IOstream::BINARY)
+    {
+        os  << "    arch        " << foamVersion::buildArch << ";\n";
+    }
 
     if (Pstream::parRun())
     {
-        os  << "    blocks      " << Pstream::nProcs() << ';' << nl;
-    }
-    if (!note.empty())
-    {
-        os  << "    note        " << note << ';' << nl;
+        os  << "    blocks      " << Pstream::nProcs() << ";\n";
     }
 
-    os << "    class       ";
-    if (objectType.empty())
+    if (note.size())
     {
-        // Empty type not allowed - use 'dictionary' fallback
-        os  << "dictionary";
-    }
-    else
-    {
-        os  << objectType;
-    }
-    os  << ';' << nl;
-
-    if (!location.empty())
-    {
-        os  << "    location    " << location << ';' << nl;
+        os  << "    note        " << note << ";\n";
     }
 
-    os  << "    object      " << objectName << ';' << nl
-        << '}' << nl;
+    if (location.size())
+    {
+        os  << "    location    " << location << ";\n";
+    }
+
+    os  << "    object      " << name << ";\n"
+        << "}" << nl;
 
     IOobject::writeDivider(os) << nl;
 }
@@ -982,8 +976,9 @@ bool Foam::decomposedBlockData::writeData(Ostream& os) const
     // Scatter header information
 
     string versionString(os.version().str());
-    label formatValue(os.format());
     Pstream::scatter(versionString, Pstream::msgType(), comm_);
+
+    label formatValue(os.format());
     Pstream::scatter(formatValue, Pstream::msgType(), comm_);
 
     //word masterName(name());
@@ -1002,8 +997,8 @@ bool Foam::decomposedBlockData::writeData(Ostream& os) const
         writeHeader
         (
             os,
-            IOstreamOption::versionNumber(versionString),
-            IOstreamOption::streamFormat(formatValue),
+            IOstream::versionNumber(versionString),
+            IOstream::streamFormat(formatValue),
             io.headerClassName(),
             io.note(),
             masterLocation,

src/OpenFOAM/db/IOobjects/decomposedBlockData/decomposedBlockData.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2017-2018 OpenFOAM Foundation
-    Copyright (C) 2020-2021 OpenCFD Ltd.
+    Copyright (C) 2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -156,10 +156,10 @@ public:
             Ostream& os,
             const IOstream::versionNumber version,
             const IOstream::streamFormat format,
-            const word& objectType,
+            const word& type,
             const string& note,
             const fileName& location,
-            const word& objectName
+            const word& name
         );
 
         //- Read selected block (non-seeking) + header information

src/OpenFOAM/db/IOstreams/output/FlatOutput.H

@@ -54,8 +54,8 @@ template<class Container, class Delimiters> class OutputAdaptor;
 template<class Container, class Delimiters>
 inline Ostream& operator<<
 (
-    Ostream& os,
-    const FlatOutput::OutputAdaptor<Container, Delimiters>& adaptor
+    Ostream&,
+    const FlatOutput::OutputAdaptor<Container, Delimiters>&
 );
 
 
@@ -187,7 +187,8 @@ public:
     // Operators
 
         //- Ostream Operator
-        friend Ostream& operator<<
+        inline friend Ostream&
+        operator<<
         (
             Ostream& os,
             const OutputAdaptor<Container, Delimiters>& adaptor

src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedField.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2015-2021 OpenCFD Ltd.
+    Copyright (C) 2015-2018 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -304,13 +304,13 @@ public:
         inline dimensionSet& dimensions();
 
         //- Return oriented type
-        inline const orientedType& oriented() const noexcept;
+        inline const orientedType& oriented() const;
 
         //- Return non-const access to the oriented type
-        inline orientedType& oriented() noexcept;
+        inline orientedType& oriented();
 
         //- Set the oriented flag
-        inline void setOriented(const bool oriented = true) noexcept;
+        inline void setOriented(const bool oriented = true);
 
         //- Return field
         inline const Field<Type>& field() const;

src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -61,15 +61,14 @@ inline Foam::dimensionSet& Foam::DimensionedField<Type, GeoMesh>::dimensions()
 
 template<class Type, class GeoMesh>
 inline const Foam::orientedType&
-Foam::DimensionedField<Type, GeoMesh>::oriented() const noexcept
+Foam::DimensionedField<Type, GeoMesh>::oriented() const
 {
     return oriented_;
 }
 
 
 template<class Type, class GeoMesh>
-inline Foam::orientedType&
-Foam::DimensionedField<Type, GeoMesh>::oriented() noexcept
+inline Foam::orientedType& Foam::DimensionedField<Type, GeoMesh>::oriented()
 {
     return oriented_;
 }
@@ -79,7 +78,7 @@ template<class Type, class GeoMesh>
 inline void Foam::DimensionedField<Type, GeoMesh>::setOriented
 (
     const bool oriented
-) noexcept
+)
 {
     oriented_.setOriented(oriented);
 }

src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldIO.C

@@ -6,7 +6,6 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -121,12 +120,9 @@ bool Foam::DimensionedField<Type, GeoMesh>::writeData
 ) const
 {
     os.writeEntry("dimensions", dimensions());
-    os << nl;
+    oriented_.writeEntry(os);
 
-    if (oriented_.writeEntry(os))
-    {
-        os << nl;
-    }
+    os<< nl << nl;
 
     Field<Type>::writeEntry(fieldDictEntry, os);
 

src/OpenFOAM/fields/Fields/DynamicField/DynamicField.C

@@ -1 +1,77 @@
-#warning File removed - left for old dependency check only
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2017 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "DynamicField.H"
+
+// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+
+template<class T, int SizeMin>
+Foam::DynamicField<T, SizeMin>::DynamicField(Istream& is)
+:
+    Field<T>(is),
+    capacity_(Field<T>::size())
+{}
+
+
+template<class T, int SizeMin>
+Foam::tmp<Foam::DynamicField<T, SizeMin>>
+Foam::DynamicField<T, SizeMin>::clone() const
+{
+    return tmp<DynamicField<T, SizeMin>>::New(*this);
+}
+
+
+// * * * * * * * * * * * * * * * IOstream Operator * * * * * * * * * * * * * //
+
+template<class T, int SizeMin>
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const DynamicField<T, SizeMin>& lst
+)
+{
+    os << static_cast<const Field<T>&>(lst);
+    return os;
+}
+
+
+template<class T, int SizeMin>
+Foam::Istream& Foam::operator>>
+(
+    Istream& is,
+    DynamicField<T, SizeMin>& lst
+)
+{
+    is >> static_cast<Field<T>&>(lst);
+    lst.capacity_ = lst.Field<T>::size();
+
+    return is;
+}
+
+
+// ************************************************************************* //

src/OpenFOAM/fields/Fields/DynamicField/DynamicField.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2021 OpenCFD Ltd.
+    Copyright (C) 2016-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -32,6 +32,7 @@ Description
 
 SourceFiles
     DynamicFieldI.H
+    DynamicField.C
 
 \*---------------------------------------------------------------------------*/
 
@@ -46,14 +47,24 @@ SourceFiles
 namespace Foam
 {
 
-// Forward Declarations
+// Forward declarations
+
 template<class T, int SizeMin> class DynamicField;
 
 template<class T, int SizeMin>
-inline Istream& operator>>(Istream&, DynamicField<T, SizeMin>&);
+Ostream& operator<<
+(
+    Ostream& os,
+    const DynamicField<T, SizeMin>& fld
+);
 
 template<class T, int SizeMin>
-inline Ostream& operator<<(Ostream&, const DynamicField<T, SizeMin>&);
+Istream& operator>>
+(
+    Istream& is,
+    DynamicField<T, SizeMin>& fld
+);
+
 
 /*---------------------------------------------------------------------------*\
                         Class DynamicField Declaration
@@ -66,7 +77,7 @@ class DynamicField
 {
     static_assert(SizeMin > 0, "Invalid min size parameter");
 
-    // Private Data
+    // Private data
 
         //- The capacity (allocated size) of the underlying field.
         label capacity_;
@@ -76,7 +87,7 @@ class DynamicField
 
         //- Copy assignment from another list
         template<class ListType>
-        inline void assignDynList(const ListType& list);
+        inline void assignDynField(const ListType& list);
 
 public:
 
@@ -91,7 +102,7 @@ public:
 
     // Constructors
 
-        //- Default construct, an empty field without allocation.
+        //- Construct null
         inline constexpr DynamicField() noexcept;
 
         //- Construct empty field with given reserve size.
@@ -151,69 +162,69 @@ public:
         );
 
         //- Construct from Istream. Size set to size of list read.
-        inline explicit DynamicField(Istream& is);
+        explicit DynamicField(Istream& is);
 
         //- Clone
-        inline tmp<DynamicField<T, SizeMin>> clone() const;
+        tmp<DynamicField<T, SizeMin>> clone() const;
 
 
     // Member Functions
 
     // Access
 
-        //- Normal lower capacity limit - the SizeMin template parameter
-        static constexpr label min_size() noexcept { return SizeMin; }
-
         //- Size of the underlying storage.
         inline label capacity() const noexcept;
 
 
-    // Sizing
+    // Edit
 
         //- Alter the size of the underlying storage.
         //  The addressed size will be truncated if needed to fit, but will
         //  remain otherwise untouched.
         //  Use this or reserve() in combination with append().
-        inline void setCapacity(const label newCapacity);
+        inline void setCapacity(const label nElem);
+
+        //- Alter the addressed list size.
+        //  New space will be allocated if required.
+        //  Use this to resize the list prior to using the operator[] for
+        //  setting values (as per List usage).
+        inline void setSize(const label nElem);
+
+        //- Alter the addressed list size and fill new space with a constant.
+        inline void setSize(const label nElem, const T& val);
+
+        //- Alter the addressed list size.
+        //  New space will be allocated if required.
+        //  Use this to resize the list prior to using the operator[] for
+        //  setting values (as per List usage).
+        inline void resize(const label nElem);
+
+        //- Alter the addressed list size and fill new space with a
+        //  constant.
+        inline void resize(const label nElem, const T& val);
 
         //- Reserve allocation space for at least this size.
         //  Never shrinks the allocated size, use setCapacity() for that.
-        inline void reserve(const label len);
-
-        //- Alter addressable size.
-        //  New space will be allocated if required.
-        inline void resize(const label newLen);
-
-        //- Alter addressable size and fill new space with constant value
-        inline void resize(const label newLen, const T& val);
-
-        //- Alias for resize()
-        void setSize(const label n) { this->resize(n); }
-
-        //- Alias for resize()
-        void setSize(const label n, const T& val) { this->resize(n, val); }
+        inline void reserve(const label nElem);
 
         //- Clear the addressed list, i.e. set the size to zero.
         //  Allocated size does not change
-        inline void clear() noexcept;
+        inline void clear();
 
         //- Clear the list and delete storage.
         inline void clearStorage();
 
         //- Expand the addressable size to fit the allocated capacity.
         //  Returns the previous addressable size.
-        inline label expandStorage() noexcept;
+        inline label expandStorage();
 
         //- Shrink the allocated space to the number of elements used.
         //  Returns a reference to the DynamicField.
         inline DynamicField<T, SizeMin>& shrink();
 
-
-    // Edit
-
-        //- Swap content, independent of sizing parameter
+        //- Swap content with any sized DynamicField
         template<int AnySizeMin>
-        inline void swap(DynamicField<T, AnySizeMin>& other);
+        inline void swap(DynamicField<T, AnySizeMin>& list);
 
         //- Transfer the parameter contents into this
         inline void transfer(List<T>& list);
@@ -226,11 +237,10 @@ public:
         template<int AnySizeMin>
         inline void transfer(DynamicField<T, AnySizeMin>& list);
 
-        //- Append an element at the end of the list
-        inline DynamicField<T, SizeMin>& append(const T& val);
 
-        //- Move append an element
-        inline DynamicField<T, SizeMin>& append(T&& val);
+        //- Append an element at the end of the list
+        inline DynamicField<T, SizeMin>&
+        append(const T& val);
 
         //- Append a List at the end of this list
         inline DynamicField<T, SizeMin>&
@@ -242,15 +252,12 @@ public:
 
     // Member Operators
 
-        //- Return non-const access to an element, resizing list if needed
+        //- Return non-const access to an element, resizing list if necessary
         inline T& operator()(const label i);
 
         //- Assign addressed entries to the given value
         inline void operator=(const T& val);
 
-        //- Assign addressed entries to zero
-        inline void operator=(const Foam::zero);
-
         //- Copy assignment
         inline void operator=(const UList<T>& list);
 
@@ -267,22 +274,6 @@ public:
         template<int AnySizeMin>
         inline void operator=(DynamicField<T, AnySizeMin>&& list);
 
-
-    // IOstream Operators
-
-        //- Read from Istream, discarding existing contents
-        friend Istream& operator>> <T, SizeMin>
-        (
-            Istream& is,
-            DynamicField<T, SizeMin>& rhs
-        );
-
-        //- Write to Ostream
-        friend Ostream& operator<< <T, SizeMin>
-        (
-            Ostream& os,
-            const DynamicField<T, SizeMin>& rhs
-        );
 };
 
 
@@ -296,6 +287,12 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+    #include "DynamicField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 #endif
 
 // ************************************************************************* //

src/OpenFOAM/fields/Fields/DynamicField/DynamicFieldI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2021 OpenCFD Ltd.
+    Copyright (C) 2016-2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -30,26 +30,26 @@ License
 
 template<class T, int SizeMin>
 template<class ListType>
-inline void Foam::DynamicField<T, SizeMin>::assignDynList
+inline void Foam::DynamicField<T, SizeMin>::assignDynField
 (
     const ListType& list
 )
 {
-    const label newLen = list.size();
+    const label newSize = list.size();
 
-    if (newLen <= capacity_)
+    if (capacity_ >= newSize)
     {
         // Can copy w/o reallocating - adjust addressable size accordingly.
-        List<T>::setAddressableSize(newLen);
-        List<T>::operator=(list);
+        Field<T>::size(list.size());
+        Field<T>::operator=(list);
     }
     else
     {
         // Ensure list size consistency prior to copying.
-        List<T>::setAddressableSize(capacity_);
+        Field<T>::size(capacity_);
 
-        List<T>::operator=(list);
-        capacity_ = List<T>::size();
+        Field<T>::operator=(list);
+        capacity_ = Field<T>::size();
     }
 }
 
@@ -67,10 +67,10 @@ inline constexpr Foam::DynamicField<T, SizeMin>::DynamicField() noexcept
 template<class T, int SizeMin>
 inline Foam::DynamicField<T, SizeMin>::DynamicField(const label len)
 :
-    Field<T>(),
-    capacity_(0)
+    Field<T>(len),
+    capacity_(Field<T>::size())
 {
-    reserve(len);
+    Field<T>::size(0);
 }
 
 
@@ -207,6 +207,7 @@ inline Foam::DynamicField<T, SizeMin>::DynamicField
 {}
 
 
+//- Construct by mapping from the given field
 template<class T, int SizeMin>
 inline Foam::DynamicField<T, SizeMin>::DynamicField
 (
@@ -219,22 +220,6 @@ inline Foam::DynamicField<T, SizeMin>::DynamicField
 {}
 
 
-template<class T, int SizeMin>
-inline Foam::DynamicField<T, SizeMin>::DynamicField(Istream& is)
-:
-    Field<T>(is),
-    capacity_(Field<T>::size())
-{}
-
-
-template<class T, int SizeMin>
-inline Foam::tmp<Foam::DynamicField<T, SizeMin>>
-Foam::DynamicField<T, SizeMin>::clone() const
-{
-    return tmp<DynamicField<T, SizeMin>>::New(*this);
-}
-
-
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class T, int SizeMin>
@@ -247,103 +232,144 @@ inline Foam::label Foam::DynamicField<T, SizeMin>::capacity() const noexcept
 template<class T, int SizeMin>
 inline void Foam::DynamicField<T, SizeMin>::setCapacity
 (
-    const label newCapacity
+    const label nElem
 )
 {
-    label currLen = List<T>::size();
-    capacity_ = newCapacity;
+    label nextFree = Field<T>::size();
+    capacity_ = nElem;
 
-    if (currLen > capacity_)
+    if (nextFree > capacity_)
     {
-        // Truncate addressed sizes too
-        currLen = capacity_;
+        // truncate addressed sizes too
+        nextFree = capacity_;
     }
 
-    List<T>::resize(capacity_);
-    List<T>::setAddressableSize(currLen);
+    // We could also enforce sizing granularity
+
+    Field<T>::setSize(capacity_);
+    Field<T>::size(nextFree);
 }
 
 
 template<class T, int SizeMin>
 inline void Foam::DynamicField<T, SizeMin>::reserve
 (
-    const label len
+    const label nElem
 )
 {
-    if (capacity_ < len)
+    // Allocate more capacity if necessary
+    if (nElem > capacity_)
     {
-        // Increase capacity (doubling)
-        capacity_ = max(SizeMin, max(len, label(2 * capacity_)));
+        capacity_ = max
+        (
+            SizeMin,
+            max
+            (
+                nElem,
+                // label(SizeInc + capacity_ * SizeMult / SizeDiv)
+                label(2*capacity_)
+            )
+        );
 
         // Adjust allocated size, leave addressed size untouched
-        const label currLen = List<T>::size();
-        List<T>::resize(capacity_);
-        List<T>::setAddressableSize(currLen);
+        const label nextFree = Field<T>::size();
+        Field<T>::setSize(capacity_);
+        Field<T>::size(nextFree);
     }
 }
 
 
 template<class T, int SizeMin>
-inline void Foam::DynamicField<T, SizeMin>::resize
+inline void Foam::DynamicField<T, SizeMin>::setSize
 (
-    const label newLen
+    const label nElem
 )
 {
-    if (capacity_ < newLen)
+    // Allocate more capacity if necessary
+    if (nElem > capacity_)
     {
-        // Increase capacity (doubling)
-        capacity_ = max(SizeMin, max(newLen, label(2 * capacity_)));
+        capacity_ = max
+        (
+            SizeMin,
+            max
+            (
+                nElem,
+                // label(SizeInc + capacity_ * SizeMult / SizeDiv)
+                label(2*capacity_)
+            )
+        );
 
-        List<T>::resize(capacity_);
+        Field<T>::setSize(capacity_);
     }
 
     // Adjust addressed size
-    List<T>::setAddressableSize(newLen);
+    Field<T>::size(nElem);
+}
+
+
+template<class T, int SizeMin>
+inline void Foam::DynamicField<T, SizeMin>::setSize
+(
+    const label nElem,
+    const T& val
+)
+{
+    label nextFree = Field<T>::size();
+    setSize(nElem);
+
+    // Set new elements to constant value
+    while (nextFree < nElem)
+    {
+        this->operator[](nextFree++) = val;
+    }
 }
 
 
 template<class T, int SizeMin>
 inline void Foam::DynamicField<T, SizeMin>::resize
 (
-    const label newLen,
-    const T& val
+    const label nElem
 )
 {
-    label currLen = List<T>::size();
-    resize(newLen);
-
-    // Fill newly exposed with constant value
-    while (currLen < newLen)
-    {
-        this->operator[](currLen++) = val;
-    }
+    this->setSize(nElem);
 }
 
 
 template<class T, int SizeMin>
-inline void Foam::DynamicField<T, SizeMin>::clear() noexcept
+inline void Foam::DynamicField<T, SizeMin>::resize
+(
+    const label nElem,
+    const T& val
+)
 {
-    List<T>::setAddressableSize(0);
+    this->setSize(nElem, val);
+}
+
+
+template<class T, int SizeMin>
+inline void Foam::DynamicField<T, SizeMin>::clear()
+{
+    Field<T>::size(0);
 }
 
 
 template<class T, int SizeMin>
 inline void Foam::DynamicField<T, SizeMin>::clearStorage()
 {
-    List<T>::clear();
+    Field<T>::clear();
     capacity_ = 0;
 }
 
 
 template<class T, int SizeMin>
-inline Foam::label Foam::DynamicField<T, SizeMin>::expandStorage() noexcept
+inline Foam::label Foam::DynamicField<T, SizeMin>::expandStorage()
 {
-    const label currLen = List<T>::size();
+    const label nextFree = Field<T>::size();
 
     // Allow addressing into the entire list
-    List<T>::setAddressableSize(capacity_);
+    Field<T>::size(capacity_);
 
-    return currLen;
+    return nextFree;
 }
 
 
@@ -351,16 +377,16 @@ template<class T, int SizeMin>
 inline Foam::DynamicField<T, SizeMin>&
 Foam::DynamicField<T, SizeMin>::shrink()
 {
-    const label currLen = Field<T>::size();
-    if (currLen < capacity_)
+    label nextFree = Field<T>::size();
+    if (capacity_ > nextFree)
     {
         // Use the full list when resizing
-        List<T>::setAddressableSize(capacity_);
+        Field<T>::size(capacity_);
 
-        // Capacity and size are identical
-        capacity_ = currLen;
-        List<T>::resize(currLen);
-        // Redundant: List<T>::setAddressableSize(currLen);
+        // The new size
+        capacity_ = nextFree;
+        Field<T>::setSize(capacity_);
+        Field<T>::size(nextFree);
     }
     return *this;
 }
@@ -370,27 +396,38 @@ template<class T, int SizeMin>
 template<int AnySizeMin>
 inline void Foam::DynamicField<T, SizeMin>::swap
 (
-    DynamicField<T, AnySizeMin>& other
+    DynamicField<T, AnySizeMin>& lst
 )
 {
     // Cannot compare 'this' for different types, so use cdata()
-    if (this->cdata() == other.cdata())
+    if (this->cdata() == lst.cdata())
     {
         return;  // Self-swap is a no-op
     }
 
-    // Swap storage and addressable size
-    UList<T>::swap(other);
+    DynamicField<T, SizeMin>& cur = *this;
 
-    // Swap capacity
-    std::swap(this->capacity_, other.capacity_);
+    // Make addressable size identical to the allocated capacity
+    const label oldSize1 = cur.expandStorage();
+    const label oldSize2 = lst.expandStorage();
+
+    // Swap storage
+    Field<T>::swap(lst);
+
+    // Match capacity to the underlying allocated list size
+    cur.setCapacity(cur.size());
+    lst.setCapacity(lst.size());
+
+    // Set addressable size
+    cur.setSize(oldSize2);
+    lst.setSize(oldSize1);
 }
 
 
 template<class T, int SizeMin>
 inline void Foam::DynamicField<T, SizeMin>::transfer(List<T>& list)
 {
-    // Take over storage, clear addressing for list
+    // Take over storage, clear addressing for list.
     capacity_ = list.size();
     Field<T>::transfer(list);
 }
@@ -406,7 +443,7 @@ inline void Foam::DynamicField<T, SizeMin>::transfer
     // Cannot compare 'this' for different types, so use cdata()
     if (this->cdata() == list.cdata())
     {
-        return;  // Self-assignment is a no-op
+        return;  // Self-swap is a no-op
     }
 
     // Take over storage as-is (without shrink, without using SizeMin)
@@ -428,7 +465,7 @@ inline void Foam::DynamicField<T, SizeMin>::transfer
     // Cannot compare 'this' for different types, so use cdata()
     if (this->cdata() == list.cdata())
     {
-        return;  // Self-assignment is a no-op
+        return;  // Self-swap is a no-op
     }
 
     // Take over storage as-is (without shrink, without using SizeMin)
@@ -448,28 +485,13 @@ Foam::DynamicField<T, SizeMin>::append
 )
 {
     const label idx = List<T>::size();
-    resize(idx + 1);
+    setSize(idx + 1);
 
     this->operator[](idx) = val;  // copy element
     return *this;
 }
 
 
-template<class T, int SizeMin>
-inline Foam::DynamicField<T, SizeMin>&
-Foam::DynamicField<T, SizeMin>::append
-(
-    T&& val
-)
-{
-    const label idx = List<T>::size();
-    resize(idx + 1);
-
-    this->operator[](idx) = std::move(val);  // move assign element
-    return *this;
-}
-
-
 template<class T, int SizeMin>
 inline Foam::DynamicField<T, SizeMin>&
 Foam::DynamicField<T, SizeMin>::append
@@ -480,12 +502,11 @@ Foam::DynamicField<T, SizeMin>::append
     if (this == &list)
     {
         FatalErrorInFunction
-            << "Attempted appending to self"
-            << abort(FatalError);
+            << "Attempted appending to self" << abort(FatalError);
     }
 
     label idx = List<T>::size();
-    resize(idx + list.size());
+    setSize(idx + list.size());
 
     for (const T& val : list)
     {
@@ -509,7 +530,7 @@ inline T Foam::DynamicField<T, SizeMin>::remove()
 
     const T& val = List<T>::operator[](idx);
 
-    List<T>::setAddressableSize(idx);
+    List<T>::size(idx);
 
     return val;
 }
@@ -525,7 +546,7 @@ inline T& Foam::DynamicField<T, SizeMin>::operator()
 {
     if (i >= Field<T>::size())
     {
-        resize(i + 1);
+        setSize(i + 1);
     }
 
     return this->operator[](i);
@@ -542,23 +563,13 @@ inline void Foam::DynamicField<T, SizeMin>::operator=
 }
 
 
-template<class T, int SizeMin>
-inline void Foam::DynamicField<T, SizeMin>::operator=
-(
-    const Foam::zero
-)
-{
-    UList<T>::operator=(Zero);
-}
-
-
 template<class T, int SizeMin>
 inline void Foam::DynamicField<T, SizeMin>::operator=
 (
     const UList<T>& list
 )
 {
-    assignDynList(list);
+    assignDynField(list);
 }
 
 
@@ -573,7 +584,7 @@ inline void Foam::DynamicField<T, SizeMin>::operator=
         return;  // Self-assignment is a no-op
     }
 
-    assignDynList(list);
+    assignDynField(list);
 }
 
 
@@ -608,35 +619,4 @@ inline void Foam::DynamicField<T, SizeMin>::operator=
 }
 
 
-// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
-
-template<class T, int SizeMin>
-inline Foam::Istream& Foam::operator>>
-(
-    Istream& is,
-    DynamicField<T, SizeMin>& rhs
-)
-{
-    // Use entire storage - ie, resize(capacity())
-    (void) rhs.expandStorage();
-
-    is >> static_cast<Field<T>&>(rhs);
-    rhs.capacity_ = rhs.Field<T>::size();
-
-    return is;
-}
-
-
-template<class T, int SizeMin>
-inline Foam::Ostream& Foam::operator<<
-(
-    Ostream& os,
-    const DynamicField<T, SizeMin>& rhs
-)
-{
-    os << static_cast<const Field<T>&>(rhs);
-    return os;
-}
-
-
 // ************************************************************************* //

src/OpenFOAM/fields/pointPatchFields/pointPatchField/pointPatchFieldNew.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -26,7 +26,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
 
 template<class Type>
 Foam::autoPtr<Foam::pointPatchField<Type>> Foam::pointPatchField<Type>::New
@@ -55,20 +55,22 @@ Foam::autoPtr<Foam::pointPatchField<Type>> Foam::pointPatchField<Type>::New
 
     if
     (
-        actualPatchType == word::null
+        actualPatchType.empty()
      || actualPatchType != p.type()
     )
     {
         if (pfPtr().constraintType() != p.constraintType())
         {
-            // Use default constraint type
+            // Incompatible (constraint-wise) with the patch type
+            // - use default constraint type
+
             auto patchTypeCstrIter =
                 pointPatchConstructorTablePtr_->cfind(p.type());
 
             if (!patchTypeCstrIter.found())
             {
                 FatalErrorInFunction
-                    << "inconsistent patch and patchField types for \n"
+                    << "Inconsistent patch and patchField types for\n"
                     << "    patch type " << p.type()
                     << " and patchField type " << patchFieldType
                     << exit(FatalError);
@@ -138,20 +140,17 @@ Foam::autoPtr<Foam::pointPatchField<Type>> Foam::pointPatchField<Type>::New
 
     if
     (
-       !dict.found("patchType")
+        !dict.found("patchType")
      || dict.get<word>("patchType") != p.type()
     )
     {
-        if (pfPtr().constraintType() == p.constraintType())
+        if (pfPtr().constraintType() != p.constraintType())
         {
-            // Compatible (constraint-wise) with the patch type
-            return pfPtr;
-        }
-        else
-        {
-            // Use default constraint type
-            auto patchTypeCstrIter
-                = dictionaryConstructorTablePtr_->cfind(p.type());
+            // Incompatible (constraint-wise) with the patch type
+            // - use default constraint type
+
+            auto patchTypeCstrIter =
+                dictionaryConstructorTablePtr_->cfind(p.type());
 
             if (!patchTypeCstrIter.found())
             {
@@ -166,7 +165,7 @@ Foam::autoPtr<Foam::pointPatchField<Type>> Foam::pointPatchField<Type>::New
         }
     }
 
-    return cstrIter()(p, iF, dict);
+    return pfPtr;
 }
 
 

src/OpenFOAM/global/fileOperations/collatedFileOperation/OFstreamCollator.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2017-2018 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -94,15 +94,16 @@ bool Foam::OFstreamCollator::writeFile
         // We don't have IOobject so cannot use IOobject::writeHeader
         if (!append)
         {
+            OSstream& os = osPtr();
             decomposedBlockData::writeHeader
             (
-                *osPtr,
+                os,
                 ver,
                 fmt,
                 typeName,
-                "",          // note
-                fName,       // location
-                fName.name() // object name
+                "",
+                fName,
+                fName.name()
             );
         }
     }

src/OpenFOAM/matrices/Matrix/Matrix.C

@@ -460,20 +460,6 @@ Foam::scalar Foam::Matrix<Form, Type>::norm(const bool noSqrt) const
 }
 
 
-template<class Form, class Type>
-std::streamsize Foam::Matrix<Form, Type>::byteSize() const
-{
-    if (!is_contiguous<Type>::value)
-    {
-        FatalErrorInFunction
-            << "Invalid for non-contiguous data types"
-            << abort(FatalError);
-    }
-
-    return mRows_*nCols_*sizeof(Type);
-}
-
-
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 template<class Form, class Type>

src/OpenFOAM/matrices/Matrix/Matrix.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -123,8 +123,8 @@ public:
 
     // Constructors
 
-        //- Default construct (empty matrix)
-        inline Matrix() noexcept;
+        //- Construct null
+        inline Matrix();
 
         //- Construct given number of rows/columns
         Matrix(const label m, const label n);
@@ -204,9 +204,6 @@ public:
         //- be used to address into Matrix contents
         inline Type* data() noexcept;
 
-        //- The number of bytes stored by the Matrix data for contiguous types
-        std::streamsize byteSize() const;
-
         //- Return const pointer to data in the specified row
         //  Subscript checking only with FULLDEBUG
         inline const Type* rowData(const label irow) const;
@@ -447,25 +444,25 @@ public:
     // Random Access Iterator (non-const)
 
         //- Return an iterator to begin traversing a Matrix
-        inline iterator begin() noexcept;
+        inline iterator begin();
 
         //- Return an iterator to end traversing a Matrix
-        inline iterator end() noexcept;
+        inline iterator end();
 
 
     // Random Access Iterator (const)
 
         //- Return const_iterator to begin traversing a constant Matrix
-        inline const_iterator cbegin() const noexcept;
+        inline const_iterator cbegin() const;
 
         //- Return const_iterator to end traversing a constant Matrix
-        inline const_iterator cend() const noexcept;
+        inline const_iterator cend() const;
 
         //- Return const_iterator to begin traversing a constant Matrix
-        inline const_iterator begin() const noexcept;
+        inline const_iterator begin() const;
 
         //- Return const_iterator to end traversing a constant Matrix
-        inline const_iterator end() const noexcept;
+        inline const_iterator end() const;
 
 
     // IO

src/OpenFOAM/matrices/Matrix/MatrixI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -45,7 +45,7 @@ inline void Foam::Matrix<Form, Type>::doAlloc()
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class Form, class Type>
-inline Foam::Matrix<Form, Type>::Matrix() noexcept
+inline Foam::Matrix<Form, Type>::Matrix()
 :
     mRows_(0),
     nCols_(0),
@@ -510,7 +510,7 @@ inline Foam::tmp<Foam::Field<Type>> Foam::Matrix<Form, Type>::Tmul
 
 template<class Form, class Type>
 inline typename Foam::Matrix<Form, Type>::iterator
-Foam::Matrix<Form, Type>::begin() noexcept
+Foam::Matrix<Form, Type>::begin()
 {
     return v_;
 }
@@ -518,7 +518,7 @@ Foam::Matrix<Form, Type>::begin() noexcept
 
 template<class Form, class Type>
 inline typename Foam::Matrix<Form, Type>::iterator
-Foam::Matrix<Form, Type>::end() noexcept
+Foam::Matrix<Form, Type>::end()
 {
     return v_ + (mRows_ * nCols_);
 }
@@ -526,7 +526,7 @@ Foam::Matrix<Form, Type>::end() noexcept
 
 template<class Form, class Type>
 inline typename Foam::Matrix<Form, Type>::const_iterator
-Foam::Matrix<Form, Type>::cbegin() const noexcept
+Foam::Matrix<Form, Type>::cbegin() const
 {
     return v_;
 }
@@ -534,7 +534,7 @@ Foam::Matrix<Form, Type>::cbegin() const noexcept
 
 template<class Form, class Type>
 inline typename Foam::Matrix<Form, Type>::const_iterator
-Foam::Matrix<Form, Type>::cend() const noexcept
+Foam::Matrix<Form, Type>::cend() const
 {
     return v_ + (mRows_ * nCols_);
 }
@@ -542,7 +542,7 @@ Foam::Matrix<Form, Type>::cend() const noexcept
 
 template<class Form, class Type>
 inline typename Foam::Matrix<Form, Type>::const_iterator
-Foam::Matrix<Form, Type>::begin() const noexcept
+Foam::Matrix<Form, Type>::begin() const
 {
     return v_;
 }
@@ -550,7 +550,7 @@ Foam::Matrix<Form, Type>::begin() const noexcept
 
 template<class Form, class Type>
 inline typename Foam::Matrix<Form, Type>::const_iterator
-Foam::Matrix<Form, Type>::end() const noexcept
+Foam::Matrix<Form, Type>::end() const
 {
     return v_ + (mRows_ * nCols_);
 }

src/OpenFOAM/memory/tmpNrc/tmpNrcI.H

@@ -0,0 +1 @@
+#warning File removed - left for old dependency check only

src/OpenFOAM/meshes/meshShapes/labelledTri/labelledTri.H

@@ -48,8 +48,8 @@ namespace Foam
 
 // Forward Declarations
 class labelledTri;
-inline Istream& operator>>(Istream&, labelledTri&);
-inline Ostream& operator<<(Ostream&, const labelledTri&);
+Istream& operator>>(Istream&, labelledTri&);
+Ostream& operator<<(Ostream&, const labelledTri&);
 
 /*---------------------------------------------------------------------------*\
                            Class labelledTri Declaration
@@ -119,8 +119,8 @@ public:
 
     // IOstream Operators
 
-        friend Istream& operator>>(Istream&, labelledTri&);
-        friend Ostream& operator<<(Ostream&, const labelledTri&);
+        inline friend Istream& operator>>(Istream&, labelledTri&);
+        inline friend Ostream& operator<<(Ostream&, const labelledTri&);
 };
 
 

src/OpenFOAM/meshes/polyMesh/mapPolyMesh/objectMap/objectMap.H

@@ -45,7 +45,7 @@ SourceFiles
 namespace Foam
 {
 
-// Forward Declarations
+// Forward declarations
 
 class objectMap;
 inline bool operator==(const objectMap& a, const objectMap& b);

src/OpenFOAM/meshes/polyMesh/syncTools/syncTools.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2015-2021 OpenCFD Ltd.
+    Copyright (C) 2015-2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -138,19 +138,18 @@ public:
             );
 
             //- Synchronize values on all mesh edges.
-            template<class T, class CombineOp, class TransformOp, class FlipOp>
+            template<class T, class CombineOp, class TransformOp>
             static void syncEdgeList
             (
                 const polyMesh& mesh,
                 List<T>& edgeValues,
                 const CombineOp& cop,
                 const T& nullValue,
-                const TransformOp& top,
-                const FlipOp& fop
+                const TransformOp& top
             );
 
             //- Synchronize values on selected mesh edges.
-            template<class T, class CombineOp, class TransformOp, class FlipOp>
+            template<class T, class CombineOp, class TransformOp>
             static void syncEdgeList
             (
                 const polyMesh& mesh,
@@ -158,8 +157,7 @@ public:
                 List<T>& edgeValues,
                 const CombineOp& cop,
                 const T& nullValue,
-                const TransformOp& top,
-                const FlipOp& fop
+                const TransformOp& top
             );
 
             //- Synchronize values on boundary faces only.
@@ -279,8 +277,7 @@ public:
                     edgeValues,
                     cop,
                     nullValue,
-                    mapDistribute::transform(),
-                    noOp()
+                    mapDistribute::transform()
                 );
             }
 
@@ -300,8 +297,7 @@ public:
                     positions,
                     cop,
                     nullValue,
-                    mapDistribute::transformPosition(),
-                    noOp()
+                    mapDistribute::transformPosition()
                 );
             }
 
@@ -323,8 +319,7 @@ public:
                     edgeValues,
                     cop,
                     nullValue,
-                    mapDistribute::transform(),
-                    noOp()
+                    mapDistribute::transform()
                 );
             }
 
@@ -346,8 +341,7 @@ public:
                     positions,
                     cop,
                     nullValue,
-                    mapDistribute::transformPosition(),
-                    noOp()
+                    mapDistribute::transformPosition()
                 );
             }
 

src/OpenFOAM/meshes/polyMesh/syncTools/syncToolsTemplates.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2015-2021 OpenCFD Ltd.
+    Copyright (C) 2015-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -798,15 +798,14 @@ void Foam::syncTools::syncPointList
 }
 
 
-template<class T, class CombineOp, class TransformOp, class FlipOp>
+template<class T, class CombineOp, class TransformOp>
 void Foam::syncTools::syncEdgeList
 (
     const polyMesh& mesh,
     List<T>& edgeValues,
     const CombineOp& cop,
     const T& nullValue,
-    const TransformOp& top,
-    const FlipOp& fop
+    const TransformOp& top
 )
 {
     if (edgeValues.size() != mesh.nEdges())
@@ -817,47 +816,12 @@ void Foam::syncTools::syncEdgeList
             << mesh.nEdges() << abort(FatalError);
     }
 
-    const edgeList& edges = mesh.edges();
     const globalMeshData& gd = mesh.globalData();
     const labelList& meshEdges = gd.coupledPatchMeshEdges();
-    const indirectPrimitivePatch& cpp = gd.coupledPatch();
-    const edgeList& cppEdges = cpp.edges();
-    const labelList& mp = cpp.meshPoints();
     const globalIndexAndTransform& git = gd.globalTransforms();
     const mapDistribute& edgeMap = gd.globalEdgeSlavesMap();
-    const bitSet& orientation = gd.globalEdgeOrientation();
-
-    List<T> cppFld(meshEdges.size());
-    forAll(meshEdges, i)
-    {
-        const edge& cppE = cppEdges[i];
-        const label meshEdgei = meshEdges[i];
-        const edge& meshE = edges[meshEdgei];
-
-        // 1. is cpp edge oriented as mesh edge
-        // 2. is cpp edge oriented same as master edge
-
-        const int dir = edge::compare(meshE, edge(mp, cppE));
-        if (dir == 0)
-        {
-            FatalErrorInFunction<< "Problem:"
-                << " mesh edge:" << meshE.line(mesh.points())
-                << " coupled edge:" << cppE.line(cpp.localPoints())
-                << exit(FatalError);
-        }
-
-        const bool sameOrientation = ((dir == 1) == orientation[i]);
-
-        if (sameOrientation)
-        {
-            cppFld[i] = edgeValues[meshEdgei];
-        }
-        else
-        {
-            cppFld[i] = fop(edgeValues[meshEdgei]);
-        }
-    }
 
+    List<T> cppFld(UIndirectList<T>(edgeValues, meshEdges));
 
     globalMeshData::syncData
     (
@@ -873,29 +837,12 @@ void Foam::syncTools::syncEdgeList
     // Extract back onto mesh
     forAll(meshEdges, i)
     {
-        const edge& cppE = cppEdges[i];
-        const label meshEdgei = meshEdges[i];
-        const edge& meshE = edges[meshEdgei];
-
-        // 1. is cpp edge oriented as mesh edge
-        // 2. is cpp edge oriented same as master edge
-
-        const int dir = edge::compare(meshE, edge(mp, cppE));
-        const bool sameOrientation = ((dir == 1) == orientation[i]);
-
-        if (sameOrientation)
-        {
-            edgeValues[meshEdges[i]] = cppFld[i];
-        }
-        else
-        {
-            edgeValues[meshEdges[i]] =  fop(cppFld[i]);
-        }
+        edgeValues[meshEdges[i]] = cppFld[i];
     }
 }
 
 
-template<class T, class CombineOp, class TransformOp, class FlipOp>
+template<class T, class CombineOp, class TransformOp>
 void Foam::syncTools::syncEdgeList
 (
     const polyMesh& mesh,
@@ -903,8 +850,7 @@ void Foam::syncTools::syncEdgeList
     List<T>& edgeValues,
     const CombineOp& cop,
     const T& nullValue,
-    const TransformOp& top,
-    const FlipOp& fop
+    const TransformOp& top
 )
 {
     if (edgeValues.size() != meshEdges.size())
@@ -914,48 +860,19 @@ void Foam::syncTools::syncEdgeList
             << " is not equal to the number of meshEdges "
             << meshEdges.size() << abort(FatalError);
     }
-    const edgeList& edges = mesh.edges();
     const globalMeshData& gd = mesh.globalData();
     const indirectPrimitivePatch& cpp = gd.coupledPatch();
-    const edgeList& cppEdges = cpp.edges();
-    const labelList& mp = cpp.meshPoints();
     const Map<label>& mpm = gd.coupledPatchMeshEdgeMap();
-    const bitSet& orientation = gd.globalEdgeOrientation();
 
     List<T> cppFld(cpp.nEdges(), nullValue);
 
     forAll(meshEdges, i)
     {
-        const label meshEdgei = meshEdges[i];
-        const auto iter = mpm.cfind(meshEdgei);
+        const auto iter = mpm.cfind(meshEdges[i]);
+
         if (iter.found())
         {
-            const label cppEdgei = iter();
-            const edge& cppE = cppEdges[cppEdgei];
-            const edge& meshE = edges[meshEdgei];
-
-            // 1. is cpp edge oriented as mesh edge
-            // 2. is cpp edge oriented same as master edge
-
-            const int dir = edge::compare(meshE, edge(mp, cppE));
-            if (dir == 0)
-            {
-                FatalErrorInFunction<< "Problem:"
-                    << " mesh edge:" << meshE.line(mesh.points())
-                    << " coupled edge:" << cppE.line(cpp.localPoints())
-                    << exit(FatalError);
-            }
-
-            const bool sameOrientation = ((dir == 1) == orientation[i]);
-
-            if (sameOrientation)
-            {
-                cppFld[cppEdgei] = edgeValues[i];
-            }
-            else
-            {
-                cppFld[cppEdgei] = fop(edgeValues[i]);
-            }
+            cppFld[*iter] = edgeValues[i];
         }
     }
 
@@ -972,25 +889,11 @@ void Foam::syncTools::syncEdgeList
 
     forAll(meshEdges, i)
     {
-        label meshEdgei = meshEdges[i];
-        Map<label>::const_iterator iter = mpm.find(meshEdgei);
-        if (iter != mpm.end())
+        const auto iter = mpm.cfind(meshEdges[i]);
+
+        if (iter.found())
         {
-            label cppEdgei = iter();
-            const edge& cppE = cppEdges[cppEdgei];
-            const edge& meshE = edges[meshEdgei];
-
-            const int dir = edge::compare(meshE, edge(mp, cppE));
-            const bool sameOrientation = ((dir == 1) == orientation[i]);
-
-            if (sameOrientation)
-            {
-                edgeValues[i] = cppFld[cppEdgei];
-            }
-            else
-            {
-                edgeValues[i] = fop(cppFld[cppEdgei]);
-            }
+            edgeValues[i] = cppFld[*iter];
         }
     }
 }
@@ -1022,147 +925,50 @@ void Foam::syncTools::syncBoundaryFaceList
 
     if (parRun)
     {
-        if
-        (
-            is_contiguous<T>::value
-         && Pstream::defaultCommsType == Pstream::commsTypes::nonBlocking
-        )
+        PstreamBuffers pBufs(Pstream::commsTypes::nonBlocking);
+
+        // Send
+
+        for (const polyPatch& pp : patches)
         {
-            const label startRequest = UPstream::nRequests();
-
-            // Receive buffer
-            List<T> receivedValues(mesh.nBoundaryFaces());
-
-            // Set up reads
-            for (const polyPatch& pp : patches)
+            if (isA<processorPolyPatch>(pp) && pp.size() > 0)
             {
-                if (isA<processorPolyPatch>(pp) && pp.size() > 0)
-                {
-                    const processorPolyPatch& procPatch =
-                        refCast<const processorPolyPatch>(pp);
+                const processorPolyPatch& procPatch =
+                    refCast<const processorPolyPatch>(pp);
 
-                    SubList<T> fld
-                    (
-                        receivedValues,
-                        procPatch.size(),
-                        procPatch.offset()
-                    );
+                const label patchStart = procPatch.start()-boundaryOffset;
 
-                    IPstream::read
-                    (
-                        Pstream::commsTypes::nonBlocking,
-                        procPatch.neighbProcNo(),
-                        reinterpret_cast<char*>(fld.data()),
-                        fld.byteSize()
-                    );
-                }
-            }
-
-            // Set up writes
-            for (const polyPatch& pp : patches)
-            {
-                if (isA<processorPolyPatch>(pp) && pp.size() > 0)
-                {
-                    const processorPolyPatch& procPatch =
-                        refCast<const processorPolyPatch>(pp);
-
-                    const SubList<T> fld
-                    (
-                        faceValues,
-                        procPatch.size(),
-                        procPatch.offset()
-                    );
-
-                    OPstream::write
-                    (
-                        Pstream::commsTypes::nonBlocking,
-                        procPatch.neighbProcNo(),
-                        reinterpret_cast<const char*>(fld.cdata()),
-                        fld.byteSize()
-                    );
-                }
-            }
-
-            // Wait for all comms to finish
-            Pstream::waitRequests(startRequest);
-
-            // Combine with existing data
-            for (const polyPatch& pp : patches)
-            {
-                if (isA<processorPolyPatch>(pp) && pp.size() > 0)
-                {
-                    const processorPolyPatch& procPatch =
-                        refCast<const processorPolyPatch>(pp);
-                    SubList<T> recvFld
-                    (
-                        receivedValues,
-                        procPatch.size(),
-                        procPatch.offset()
-                    );
-                    const List<T>& fakeList = recvFld;
-                    top(procPatch, const_cast<List<T>&>(fakeList));
-
-                    SubList<T> patchValues
-                    (
-                        faceValues,
-                        procPatch.size(),
-                        procPatch.offset()
-                    );
-                    forAll(patchValues, i)
-                    {
-                        cop(patchValues[i], recvFld[i]);
-                    }
-                }
+                // Send slice of values on the patch
+                UOPstream toNbr(procPatch.neighbProcNo(), pBufs);
+                toNbr<< SubList<T>(faceValues, procPatch.size(), patchStart);
             }
         }
-        else
+
+
+        pBufs.finishedSends();
+
+
+        // Receive and combine.
+
+        for (const polyPatch& pp : patches)
         {
-            PstreamBuffers pBufs(Pstream::commsTypes::nonBlocking);
-
-            // Send
-
-            for (const polyPatch& pp : patches)
+            if (isA<processorPolyPatch>(pp) && pp.size() > 0)
             {
-                if (isA<processorPolyPatch>(pp) && pp.size() > 0)
+                const processorPolyPatch& procPatch =
+                    refCast<const processorPolyPatch>(pp);
+
+                Field<T> nbrVals(procPatch.size());
+
+                UIPstream fromNbr(procPatch.neighbProcNo(), pBufs);
+                fromNbr >> nbrVals;
+
+                top(procPatch, nbrVals);
+
+                label bFacei = procPatch.start()-boundaryOffset;
+
+                for (T& nbrVal : nbrVals)
                 {
-                    const processorPolyPatch& procPatch =
-                        refCast<const processorPolyPatch>(pp);
-
-                    const label patchStart = procPatch.start()-boundaryOffset;
-
-                    // Send slice of values on the patch
-                    UOPstream toNbr(procPatch.neighbProcNo(), pBufs);
-                    toNbr <<
-                        SubList<T>(faceValues, procPatch.size(), patchStart);
-                }
-            }
-
-
-            pBufs.finishedSends();
-
-
-            // Receive and combine.
-
-            for (const polyPatch& pp : patches)
-            {
-                if (isA<processorPolyPatch>(pp) && pp.size() > 0)
-                {
-                    const processorPolyPatch& procPatch =
-                        refCast<const processorPolyPatch>(pp);
-
-                    List<T> nbrVals(procPatch.size());
-
-                    UIPstream fromNbr(procPatch.neighbProcNo(), pBufs);
-                    fromNbr >> nbrVals;
-
-                    top(procPatch, nbrVals);
-
-                    label bFacei = procPatch.start()-boundaryOffset;
-
-                    for (const T& nbrVal : nbrVals)
-                    {
-                        cop(faceValues[bFacei++], nbrVal);
-                    }
+                    cop(faceValues[bFacei++], nbrVal);
                 }
             }
         }
@@ -1186,10 +992,10 @@ void Foam::syncTools::syncBoundaryFaceList
                 const label nbrStart = nbrPatch.start()-boundaryOffset;
 
                 // Transform (copy of) data on both sides
-                List<T> ownVals(SubList<T>(faceValues, patchSize, ownStart));
+                Field<T> ownVals(SubList<T>(faceValues, patchSize, ownStart));
                 top(nbrPatch, ownVals);
 
-                List<T> nbrVals(SubList<T>(faceValues, patchSize, nbrStart));
+                Field<T> nbrVals(SubList<T>(faceValues, patchSize, nbrStart));
                 top(cycPatch, nbrVals);
 
                 label bFacei = ownStart;
@@ -1242,39 +1048,10 @@ void Foam::syncTools::syncFaceList
 
     if (parRun)
     {
-        const label startRequest = UPstream::nRequests();
+        PstreamBuffers pBufs(Pstream::commsTypes::nonBlocking);
 
-        // Receive buffers
-        PtrList<PackedList<Width>> recvInfos(patches.size());
+        // Send
 
-        // Set up reads
-        for (const polyPatch& pp : patches)
-        {
-            if (isA<processorPolyPatch>(pp) && pp.size())
-            {
-                const processorPolyPatch& procPatch =
-                    refCast<const processorPolyPatch>(pp);
-
-                const label patchSize = procPatch.size();
-                const label patchi = procPatch.index();
-
-                recvInfos.set(patchi, new PackedList<Width>(patchSize));
-                PackedList<Width>& recvInfo = recvInfos[patchi];
-
-                IPstream::read
-                (
-                    Pstream::commsTypes::nonBlocking,
-                    procPatch.neighbProcNo(),
-                    reinterpret_cast<char*>(recvInfo.data()),
-                    recvInfo.byteSize()
-                );
-            }
-        }
-
-        // Send buffers
-        PtrList<PackedList<Width>> sendInfos(patches.size());
-
-        // Set up writes
         for (const polyPatch& pp : patches)
         {
             if (isA<processorPolyPatch>(pp) && pp.size())
@@ -1287,29 +1064,18 @@ void Foam::syncTools::syncFaceList
                     procPatch.start()-boundaryOffset,
                     procPatch.size()
                 );
-                const label patchi = procPatch.index();
 
-                sendInfos.set
-                (
-                    patchi,
-                    new PackedList<Width>(faceValues, range)
-                );
-                PackedList<Width>& sendInfo = sendInfos[patchi];
-
-                OPstream::write
-                (
-                    Pstream::commsTypes::nonBlocking,
-                    procPatch.neighbProcNo(),
-                    reinterpret_cast<const char*>(sendInfo.cdata()),
-                    sendInfo.byteSize()
-                );
+                // Send slice of values on the patch
+                UOPstream toNbr(procPatch.neighbProcNo(), pBufs);
+                toNbr<< PackedList<Width>(faceValues, range);
             }
         }
 
-        // Wait for all comms to finish
-        Pstream::waitRequests(startRequest);
+        pBufs.finishedSends();
+
+
+        // Receive and combine.
 
-        // Combine with existing data
         for (const polyPatch& pp : patches)
         {
             if (isA<processorPolyPatch>(pp) && pp.size())
@@ -1318,8 +1084,13 @@ void Foam::syncTools::syncFaceList
                     refCast<const processorPolyPatch>(pp);
 
                 const label patchSize = procPatch.size();
-                const label patchi = procPatch.index();
-                const PackedList<Width>& recvInfo = recvInfos[patchi];
+
+                // Recv slice of values on the patch
+                PackedList<Width> recvInfo(patchSize);
+                {
+                    UIPstream fromNbr(procPatch.neighbProcNo(), pBufs);
+                    fromNbr >> recvInfo;
+                }
 
                 // Combine (bitwise)
                 label bFacei = procPatch.start()-boundaryOffset;
@@ -1335,66 +1106,6 @@ void Foam::syncTools::syncFaceList
                 }
             }
         }
-
-
-        //PstreamBuffers pBufs(Pstream::commsTypes::nonBlocking);
-        //
-        //// Send
-        //
-        //for (const polyPatch& pp : patches)
-        //{
-        //    if (isA<processorPolyPatch>(pp) && pp.size())
-        //    {
-        //        const processorPolyPatch& procPatch =
-        //            refCast<const processorPolyPatch>(pp);
-        //
-        //        const labelRange range
-        //        (
-        //            procPatch.start()-boundaryOffset,
-        //            procPatch.size()
-        //        );
-        //
-        //        // Send slice of values on the patch
-        //        UOPstream toNbr(procPatch.neighbProcNo(), pBufs);
-        //        toNbr<< PackedList<Width>(faceValues, range);
-        //    }
-        //}
-        //
-        //pBufs.finishedSends();
-        //
-        //
-        //// Receive and combine.
-        //
-        //for (const polyPatch& pp : patches)
-        //{
-        //    if (isA<processorPolyPatch>(pp) && pp.size())
-        //    {
-        //        const processorPolyPatch& procPatch =
-        //            refCast<const processorPolyPatch>(pp);
-        //
-        //        const label patchSize = procPatch.size();
-        //
-        //        // Recv slice of values on the patch
-        //        PackedList<Width> recvInfo(patchSize);
-        //        {
-        //            UIPstream fromNbr(procPatch.neighbProcNo(), pBufs);
-        //            fromNbr >> recvInfo;
-        //        }
-        //
-        //        // Combine (bitwise)
-        //        label bFacei = procPatch.start()-boundaryOffset;
-        //        for (label i = 0; i < patchSize; ++i)
-        //        {
-        //            unsigned int recvVal = recvInfo[i];
-        //            unsigned int faceVal = faceValues[bFacei];
-        //
-        //            cop(faceVal, recvVal);
-        //            faceValues.set(bFacei, faceVal);
-        //
-        //            ++bFacei;
-        //        }
-        //    }
-        //}
     }
 
 

src/OpenFOAM/meshes/primitiveShapes/line/line.H

@@ -49,7 +49,13 @@ SourceFiles
 namespace Foam
 {
 
-// Forward Declarations
+// Forward declaration of classes
+
+class Istream;
+class Ostream;
+
+
+// Forward declaration of friend functions and operators
 
 template<class Point, class PointRef> class line;
 

src/OpenFOAM/meshes/primitiveShapes/objectHit/PointIndexHit.H

@@ -280,13 +280,13 @@ public:
         {
             if (is.format() == IOstream::ASCII)
             {
-                is >> pHit.hit_ >> pHit.point_ >> pHit.index_;
+                return is >> pHit.hit_ >> pHit.point_ >> pHit.index_;
             }
             else
             {
                 // TODO (2019-08-06):
                 // cannot properly handle mixed-precision reading
-                // owing to bool and Point type.
+                // owning to bool and Point type.
 
                 is.read
                 (

src/OpenFOAM/meshes/primitiveShapes/tetrahedron/tetrahedron.H

@@ -57,9 +57,11 @@ SourceFiles
 namespace Foam
 {
 
-// Forward Declarations
-class plane;
+// Forward declarations
+class Istream;
+class Ostream;
 class tetPoints;
+class plane;
 
 template<class Point, class PointRef> class tetrahedron;
 
@@ -308,7 +310,7 @@ public:
             boundBox bounds() const;
 
 
-    // IOstream Operators
+    // IOstream operators
 
         friend Istream& operator>> <Point, PointRef>
         (

src/OpenFOAM/meshes/primitiveShapes/triangle/triangle.H

@@ -54,6 +54,8 @@ namespace Foam
 {
 
 // Forward Declarations
+class Istream;
+class Ostream;
 class plane;
 class triPoints;
 
@@ -353,7 +355,7 @@ public:
             ) const;
 
 
-    // IOstream Operators
+    // IOstream operators
 
         friend Istream& operator>> <Point, PointRef>
         (

src/OpenFOAM/orientedType/orientedType.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -26,9 +26,6 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "orientedType.H"
-#include "dictionary.H"
-#include "Istream.H"
-#include "Ostream.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -38,14 +35,12 @@ const Foam::Enum
 >
 Foam::orientedType::orientedOptionNames
 ({
-    { orientedOption::UNKNOWN, "unknown" },
     { orientedOption::ORIENTED, "oriented" },
     { orientedOption::UNORIENTED, "unoriented" },
+    { orientedOption::UNKNOWN, "unknown" },
 });
 
 
-// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
-
 bool Foam::orientedType::checkType
 (
     const orientedType& ot1,
@@ -91,19 +86,19 @@ Foam::orientedType::orientedType(Istream& is)
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-Foam::orientedType::orientedOption& Foam::orientedType::oriented() noexcept
+Foam::orientedType::orientedOption& Foam::orientedType::oriented()
 {
     return oriented_;
 }
 
 
-Foam::orientedType::orientedOption Foam::orientedType::oriented() const noexcept
+Foam::orientedType::orientedOption Foam::orientedType::oriented() const
 {
     return oriented_;
 }
 
 
-void Foam::orientedType::setOriented(const bool oriented) noexcept
+void Foam::orientedType::setOriented(const bool oriented)
 {
     oriented_ = oriented ? ORIENTED : UNORIENTED;
 }
@@ -121,16 +116,12 @@ void Foam::orientedType::read(const dictionary& dict)
 }
 
 
-bool Foam::orientedType::writeEntry(Ostream& os) const
+void Foam::orientedType::writeEntry(Ostream& os) const
 {
-    const bool output = (oriented_ == ORIENTED);
-
-    if (output)
+    if (oriented_ == ORIENTED)
     {
         os.writeEntry("oriented", orientedOptionNames[oriented_]);
     }
-
-    return output;
 }
 
 

src/OpenFOAM/orientedType/orientedType.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017-2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -37,6 +37,9 @@ SourceFiles
 #ifndef orientedType_H
 #define orientedType_H
 
+#include "Istream.H"
+#include "Ostream.H"
+#include "dictionary.H"
 #include "Enum.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -44,10 +47,12 @@ SourceFiles
 namespace Foam
 {
 
-// Forward Declarations
+// Forward declaration of friend functions and operators
+
 class orientedType;
 
 Istream& operator>>(Istream& is, orientedType& ot);
+
 Ostream& operator<<(Ostream& os, const orientedType& ot);
 
 /*---------------------------------------------------------------------------*\
@@ -58,25 +63,24 @@ class orientedType
 {
 public:
 
-    // Public Data Types
+    // Public data types
 
-        //- Enumeration defining oriented flags
+        //- Enumeration defining the valid oriented flags
         enum orientedOption
         {
-            UNKNOWN = 0,
-            ORIENTED = 1,
-            UNORIENTED = 2
+            ORIENTED,
+            UNORIENTED,
+            UNKNOWN
         };
 
-        //- Named enumerations for oriented flags
         static const Enum<orientedOption> orientedOptionNames;
 
 
 private:
 
-    // Private Data
+    // Private data
 
-        //- Oriented type
+        //- Oriented flag
         orientedOption oriented_;
 
 
@@ -84,20 +88,20 @@ public:
 
     // Constructors
 
-        //- Default construct as "UNKNOWN"
+        //- Null constructor - flag initialised to false
         orientedType();
 
-        //- Copy construct
+        //- Copy constructor
         orientedType(const orientedType& ot);
 
         //- Construct from bool
-        explicit orientedType(const bool oriented);
+        orientedType(const bool oriented);
 
         //- Construct from Istream
-        explicit orientedType(Istream& is);
+        orientedType(Istream& is);
 
 
-    // Member Functions
+    // Member functions
 
         //- Return true if can operate on this pair of oriented types
         static bool checkType
@@ -107,23 +111,22 @@ public:
         );
 
         //- Return non-const reference to the oriented flag
-        orientedOption& oriented() noexcept;
+        orientedOption& oriented();
 
-        //- Return the oriented flag
-        orientedOption oriented() const noexcept;
+        //- Return const reference to the oriented flag
+        orientedOption oriented() const;
 
         //- Set the oriented flag
-        void setOriented(const bool oriented = true) noexcept;
+        void setOriented(const bool oriented = true);
 
-        //- Read the "oriented" state from dictionary
+        //- Read the oriented state from dictionary
         void read(const dictionary& dict);
 
-        //- Write the "oriented" flag entry (if ORIENTED)
-        //  \return True if entry was written
-        bool writeEntry(Ostream& os) const;
+        //- Write the oriented flag entry
+        void writeEntry(Ostream& os) const;
 
 
-    // Member Operators
+    // Member operators
 
         void operator=(const orientedType& ot);
 
@@ -136,9 +139,10 @@ public:
         bool operator()() const;
 
 
-    // IOstream Operators
+    // IOstream operators
 
         friend Istream& operator>>(Istream& is, orientedType& ot);
+
         friend Ostream& operator<<(Ostream& os, const orientedType& ot);
 };
 

src/OpenFOAM/primitives/VectorSpace/VectorSpace.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -224,25 +224,25 @@ public:
     // Random access iterator (non-const)
 
         //- Return an iterator to begin of VectorSpace
-        inline iterator begin() noexcept;
+        inline iterator begin();
 
         //- Return an iterator to end of VectorSpace
-        inline iterator end() noexcept;
+        inline iterator end();
 
 
     // Random access iterator (const)
 
         //- Return const_iterator to begin of VectorSpace
-        inline const_iterator cbegin() const noexcept;
+        inline const_iterator cbegin() const;
 
         //- Return const_iterator to end of VectorSpace
-        inline const_iterator cend() const noexcept;
+        inline const_iterator cend() const;
 
         //- Return const_iterator to begin of VectorSpace
-        inline const_iterator begin() const noexcept;
+        inline const_iterator begin() const;
 
         //- Return const_iterator to end of VectorSpace
-        inline const_iterator end() const noexcept;
+        inline const_iterator end() const;
 
 
     // IOstream Operators

src/OpenFOAM/primitives/VectorSpace/VectorSpaceI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -196,46 +196,42 @@ inline const Cmpt* Foam::VectorSpace<Form, Cmpt, Ncmpts>::cdata() const noexcept
 
 
 template<class Form, class Cmpt, Foam::direction Ncmpts>
-inline Cmpt* Foam::VectorSpace<Form, Cmpt, Ncmpts>::begin() noexcept
+inline Cmpt* Foam::VectorSpace<Form, Cmpt, Ncmpts>::begin()
 {
     return v_;
 }
 
 
 template<class Form, class Cmpt, Foam::direction Ncmpts>
-inline Cmpt* Foam::VectorSpace<Form, Cmpt, Ncmpts>::end() noexcept
+inline Cmpt* Foam::VectorSpace<Form, Cmpt, Ncmpts>::end()
 {
     return (v_ + Ncmpts);
 }
 
 
 template<class Form, class Cmpt, Foam::direction Ncmpts>
-inline const Cmpt* Foam::VectorSpace<Form, Cmpt, Ncmpts>::cbegin()
-const noexcept
+inline const Cmpt* Foam::VectorSpace<Form, Cmpt, Ncmpts>::cbegin() const
 {
     return v_;
 }
 
 
 template<class Form, class Cmpt, Foam::direction Ncmpts>
-inline const Cmpt* Foam::VectorSpace<Form, Cmpt, Ncmpts>::cend()
-const noexcept
+inline const Cmpt* Foam::VectorSpace<Form, Cmpt, Ncmpts>::cend() const
 {
     return (v_ + Ncmpts);
 }
 
 
 template<class Form, class Cmpt, Foam::direction Ncmpts>
-inline const Cmpt* Foam::VectorSpace<Form, Cmpt, Ncmpts>::begin()
-const noexcept
+inline const Cmpt* Foam::VectorSpace<Form, Cmpt, Ncmpts>::begin() const
 {
     return v_;
 }
 
 
 template<class Form, class Cmpt, Foam::direction Ncmpts>
-inline const Cmpt* Foam::VectorSpace<Form, Cmpt, Ncmpts>::end()
-const noexcept
+inline const Cmpt* Foam::VectorSpace<Form, Cmpt, Ncmpts>::end() const
 {
     return (v_ + Ncmpts);
 }

src/OpenFOAM/primitives/enums/Enum.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -295,11 +295,11 @@ public:
             inline bool operator!=(const const_iterator& iter) const noexcept;
         };
 
-        inline const_iterator cbegin() const noexcept;
-        inline const_iterator cend() const noexcept;
+        inline const_iterator cbegin() const;
+        inline const_iterator cend() const;
 
-        const_iterator begin() const noexcept { return cbegin(); }
-        const_iterator end() const noexcept { return cend(); }
+        const_iterator begin() const { return cbegin(); }
+        const_iterator end() const { return cend(); }
 
 
     // Housekeeping

src/OpenFOAM/primitives/enums/EnumI.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -230,7 +230,7 @@ inline bool Foam::Enum<EnumType>::const_iterator::operator!=
 
 template<class EnumType>
 inline typename Foam::Enum<EnumType>::const_iterator
-Foam::Enum<EnumType>::cbegin() const noexcept
+Foam::Enum<EnumType>::cbegin() const
 {
     return typename Enum<EnumType>::const_iterator(this);
 }
@@ -238,7 +238,7 @@ Foam::Enum<EnumType>::cbegin() const noexcept
 
 template<class EnumType>
 inline typename Foam::Enum<EnumType>::const_iterator
-Foam::Enum<EnumType>::cend() const noexcept
+Foam::Enum<EnumType>::cend() const
 {
     return typename Enum<EnumType>::const_iterator(this, this->size());
 }

src/OpenFOAM/primitives/ranges/IntRange/IntRange.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2020-2021 OpenCFD Ltd.
+    Copyright (C) 2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -167,7 +167,7 @@ public:
         inline void resize(const IntType n) noexcept;
 
         //- Enforce non-negative size
-        inline void clampSize() noexcept;
+        inline void clampSize();
 
 
     // Search
@@ -212,31 +212,31 @@ public:
         inline const_iterator at(const IntType i) const;
 
         //- A const_iterator set to the beginning of the range
-        inline const_iterator begin() const noexcept;
+        inline const_iterator begin() const;
 
         //- A const_iterator set to the beginning of the range
-        inline const_iterator cbegin() const noexcept;
+        inline const_iterator cbegin() const;
 
         //- A const_iterator set to 1 beyond the end of the range.
-        inline const_iterator cend() const noexcept;
+        inline const_iterator cend() const;
 
         //- A const_iterator set to 1 beyond the end of the range.
-        inline const_iterator end() const noexcept;
+        inline const_iterator end() const;
 
 
     // Bidirectional reverse input iterators (const)
 
         //- A const_reverse_iterator set to 1 before the end of range
-        inline const_reverse_iterator rbegin() const noexcept;
+        inline const_reverse_iterator rbegin() const;
 
         //- A const_reverse_iterator set to 1 before the end of range
-        inline const_reverse_iterator crbegin() const noexcept;
+        inline const_reverse_iterator crbegin() const;
 
         //- A const_reverse_iterator set to 1 before the begin of range
-        inline const_reverse_iterator rend() const noexcept;
+        inline const_reverse_iterator rend() const;
 
         //- A const_reverse_iterator set to 1 before the begin of range
-        inline const_reverse_iterator crend() const noexcept;
+        inline const_reverse_iterator crend() const;
 
 
     // Iterators
@@ -280,13 +280,13 @@ public:
             inline const_iterator& operator++() noexcept;
 
             //- Postfix increment
-            inline const_iterator operator++(int) noexcept;
+            inline const_iterator operator++(int);
 
             //- Prefix decrement
             inline const_iterator& operator--() noexcept;
 
             //- Postfix decrement
-            inline const_iterator operator--(int) noexcept;
+            inline const_iterator operator--(int);
 
             //- Arbitrary increment
             inline const_iterator& operator+=(const IntType n) noexcept;
@@ -391,13 +391,13 @@ public:
             inline const_reverse_iterator& operator++() noexcept;
 
             //- Postfix increment
-            inline const_reverse_iterator operator++(int) noexcept;
+            inline const_reverse_iterator operator++(int);
 
             //- Prefix decrement
             inline const_reverse_iterator& operator--() noexcept;
 
             //- Postfix decrement
-            inline const_reverse_iterator operator--(int) noexcept;
+            inline const_reverse_iterator operator--(int);
 
             //- Arbitrary increment
             inline const_reverse_iterator& operator+=(const IntType n) noexcept;

src/OpenFOAM/primitives/ranges/IntRange/IntRangeI.H

@@ -99,7 +99,7 @@ operator++() noexcept
 template<class IntType>
 inline typename Foam::IntRange<IntType>::const_iterator
 Foam::IntRange<IntType>::const_iterator::
-operator++(int) noexcept
+operator++(int)
 {
     const_iterator old(*this);
     ++value_;
@@ -120,7 +120,7 @@ operator--() noexcept
 template<class IntType>
 inline typename Foam::IntRange<IntType>::const_iterator
 Foam::IntRange<IntType>::const_iterator::
-operator--(int) noexcept
+operator--(int)
 {
     const_iterator old(*this);
     --value_;
@@ -234,7 +234,7 @@ operator++() noexcept
 template<class IntType>
 inline typename Foam::IntRange<IntType>::const_reverse_iterator
 Foam::IntRange<IntType>::const_reverse_iterator::
-operator++(int) noexcept
+operator++(int)
 {
     const_reverse_iterator old(*this);
     --value_;
@@ -255,7 +255,7 @@ operator--() noexcept
 template<class IntType>
 inline typename Foam::IntRange<IntType>::const_reverse_iterator
 Foam::IntRange<IntType>::const_reverse_iterator::
-operator--(int) noexcept
+operator--(int)
 {
     const_reverse_iterator old(*this);
     ++value_;
@@ -340,7 +340,7 @@ Foam::IntRange<IntType>::at(const IntType i) const
 
 template<class IntType>
 inline typename Foam::IntRange<IntType>::const_iterator
-Foam::IntRange<IntType>::begin() const noexcept
+Foam::IntRange<IntType>::begin() const
 {
     return const_iterator(start_);
 }
@@ -348,7 +348,7 @@ Foam::IntRange<IntType>::begin() const noexcept
 
 template<class IntType>
 inline typename Foam::IntRange<IntType>::const_iterator
-Foam::IntRange<IntType>::cbegin() const noexcept
+Foam::IntRange<IntType>::cbegin() const
 {
     return const_iterator(start_);
 }
@@ -356,7 +356,7 @@ Foam::IntRange<IntType>::cbegin() const noexcept
 
 template<class IntType>
 inline typename Foam::IntRange<IntType>::const_iterator
-Foam::IntRange<IntType>::end() const noexcept
+Foam::IntRange<IntType>::end() const
 {
     return const_iterator(start_ + size_);
 }
@@ -364,7 +364,7 @@ Foam::IntRange<IntType>::end() const noexcept
 
 template<class IntType>
 inline typename Foam::IntRange<IntType>::const_iterator
-Foam::IntRange<IntType>::cend() const noexcept
+Foam::IntRange<IntType>::cend() const
 {
     return const_iterator(start_ + size_);
 }
@@ -372,7 +372,7 @@ Foam::IntRange<IntType>::cend() const noexcept
 
 template<class IntType>
 inline typename Foam::IntRange<IntType>::const_reverse_iterator
-Foam::IntRange<IntType>::rbegin() const noexcept
+Foam::IntRange<IntType>::rbegin() const
 {
     return const_reverse_iterator(start_ + (size_-1));
 }
@@ -380,7 +380,7 @@ Foam::IntRange<IntType>::rbegin() const noexcept
 
 template<class IntType>
 inline typename Foam::IntRange<IntType>::const_reverse_iterator
-Foam::IntRange<IntType>::crbegin() const noexcept
+Foam::IntRange<IntType>::crbegin() const
 {
     return const_reverse_iterator(start_ + (size_-1));
 }
@@ -388,7 +388,7 @@ Foam::IntRange<IntType>::crbegin() const noexcept
 
 template<class IntType>
 inline typename Foam::IntRange<IntType>::const_reverse_iterator
-Foam::IntRange<IntType>::rend() const noexcept
+Foam::IntRange<IntType>::rend() const
 {
     return const_reverse_iterator(start_ - 1);
 }
@@ -396,7 +396,7 @@ Foam::IntRange<IntType>::rend() const noexcept
 
 template<class IntType>
 inline typename Foam::IntRange<IntType>::const_reverse_iterator
-Foam::IntRange<IntType>::crend() const noexcept
+Foam::IntRange<IntType>::crend() const
 {
     return const_reverse_iterator(start_ - 1);
 }
@@ -508,7 +508,7 @@ inline void Foam::IntRange<IntType>::resize(const IntType n) noexcept
 
 
 template<class IntType>
-inline void Foam::IntRange<IntType>::clampSize() noexcept
+inline void Foam::IntRange<IntType>::clampSize()
 {
     if (size_ < 0) size_ = 0;
 }

src/OpenFOAM/primitives/ranges/labelRange/labelRanges.H

@@ -155,16 +155,16 @@ public:
 
 
         //- A const_iterator set to the beginning of the list
-        inline const_iterator cbegin() const noexcept;
+        inline const_iterator cbegin() const;
 
         //- A const_iterator set to beyond the end of the list
-        inline const const_iterator cend() const noexcept;
+        inline const const_iterator cend() const;
 
         //- A const_iterator set to the beginning of the list
-        inline const_iterator begin() const noexcept;
+        inline const_iterator begin() const;
 
         //- A const_iterator set to beyond the end of the list
-        inline const const_iterator end() const noexcept;
+        inline const const_iterator end() const;
 
 
     // IOstream Operators

src/OpenFOAM/primitives/ranges/labelRange/labelRangesI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -110,28 +110,28 @@ operator!=
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 inline Foam::labelRanges::const_iterator
-Foam::labelRanges::cbegin() const noexcept
+Foam::labelRanges::cbegin() const
 {
     return const_iterator(this);
 }
 
 
 inline const Foam::labelRanges::const_iterator
-Foam::labelRanges::cend() const noexcept
+Foam::labelRanges::cend() const
 {
     return const_iterator(this, this->size());
 }
 
 
 inline Foam::labelRanges::const_iterator
-Foam::labelRanges::begin() const noexcept
+Foam::labelRanges::begin() const
 {
     return const_iterator(this);
 }
 
 
 inline const Foam::labelRanges::const_iterator
-Foam::labelRanges::end() const noexcept
+Foam::labelRanges::end() const
 {
     return const_iterator(this, this->size());
 }

src/OpenFOAM/primitives/ranges/sliceRange/sliceRange.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -179,28 +179,28 @@ public:
         inline const_iterator at(const label i) const;
 
         //- A const_iterator set to the beginning of the range
-        inline const_iterator begin() const noexcept;
+        inline const_iterator begin() const;
 
         //- A const_iterator set to the beginning of the range
-        inline const_iterator cbegin() const noexcept;
+        inline const_iterator cbegin() const;
 
         //- A const_iterator set to 1 beyond the end of the range.
-        inline const_iterator cend() const noexcept;
+        inline const_iterator cend() const;
 
         //- A const_iterator set to 1 beyond the end of the range.
-        inline const_iterator end() const noexcept;
+        inline const_iterator end() const;
 
         //- A const_reverse_iterator set to 1 before the end of range
-        inline const_reverse_iterator rbegin() const noexcept;
+        inline const_reverse_iterator rbegin() const;
 
         //- A const_reverse_iterator set to 1 before the end of range
-        inline const_reverse_iterator crbegin() const noexcept;
+        inline const_reverse_iterator crbegin() const;
 
         //- A const_reverse_iterator set to 1 before the begin of range
-        inline const_reverse_iterator rend() const noexcept;
+        inline const_reverse_iterator rend() const;
 
         //- A const_reverse_iterator set to 1 before the begin of range
-        inline const_reverse_iterator crend() const noexcept;
+        inline const_reverse_iterator crend() const;
 
 
     // Iterators

src/OpenFOAM/primitives/ranges/sliceRange/sliceRangeI.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -314,56 +314,56 @@ Foam::sliceRange::at(const label i) const
 
 
 inline Foam::sliceRange::const_iterator
-Foam::sliceRange::begin() const noexcept
+Foam::sliceRange::begin() const
 {
     return const_iterator(start_, stride_);
 }
 
 
 inline Foam::sliceRange::const_iterator
-Foam::sliceRange::cbegin() const noexcept
+Foam::sliceRange::cbegin() const
 {
     return const_iterator(start_, stride_);
 }
 
 
 inline Foam::sliceRange::const_iterator
-Foam::sliceRange::end() const noexcept
+Foam::sliceRange::end() const
 {
     return const_iterator(start_ + size_*stride_, stride_);
 }
 
 
 inline Foam::sliceRange::const_iterator
-Foam::sliceRange::cend() const noexcept
+Foam::sliceRange::cend() const
 {
     return const_iterator(start_ + size_*stride_, stride_);
 }
 
 
 inline Foam::sliceRange::const_reverse_iterator
-Foam::sliceRange::rbegin() const noexcept
+Foam::sliceRange::rbegin() const
 {
     return const_reverse_iterator(start_ + (size_-1)*stride_, stride_);
 }
 
 
 inline Foam::sliceRange::const_reverse_iterator
-Foam::sliceRange::crbegin() const noexcept
+Foam::sliceRange::crbegin() const
 {
     return const_reverse_iterator(start_ + (size_-1)*stride_, stride_);
 }
 
 
 inline Foam::sliceRange::const_reverse_iterator
-Foam::sliceRange::rend() const noexcept
+Foam::sliceRange::rend() const
 {
     return const_reverse_iterator(start_ - stride_, stride_);
 }
 
 
 inline Foam::sliceRange::const_reverse_iterator
-Foam::sliceRange::crend() const noexcept
+Foam::sliceRange::crend() const
 {
     return const_reverse_iterator(start_ - stride_, stride_);
 }

src/OpenFOAM/primitives/triad/triad.H

@@ -52,11 +52,13 @@ SourceFiles
 namespace Foam
 {
 
-// Forward Declarations
+// Forward declarations
 class triad;
 class quaternion;
-inline Istream& operator>>(Istream&, triad&);
-inline Ostream& operator<<(Ostream&, const triad&);
+class Istream;
+class Ostream;
+Istream& operator>>(Istream&, triad&);
+Ostream& operator<<(Ostream&, const triad&);
 
 /*---------------------------------------------------------------------------*\
                            Class triad Declaration
@@ -66,6 +68,7 @@ class triad
 :
     public Vector<vector>
 {
+
 public:
 
     // Constructors
@@ -157,8 +160,8 @@ public:
 
     // IOstream Operators
 
-        friend Istream& operator>>(Istream&, triad&);
-        friend Ostream& operator<<(Ostream&, const triad&);
+        inline friend Istream& operator>>(Istream&, triad&);
+        inline friend Ostream& operator<<(Ostream&, const triad&);
 };
 
 

src/dynamicFvMesh/dynamicRefineFvMesh/dynamicRefineFvMesh.C

@@ -243,12 +243,6 @@ void Foam::dynamicRefineFvMesh::mapFields(const mapPolyMesh& mpm)
         (
             lookupClass<surfaceScalarField>()
         );
-
-        // Remove surfaceInterpolation to allow re-calculation on demand
-        // This could be done in fvMesh::updateMesh but some dynamicFvMesh
-        // might need the old interpolation fields (weights, etc).
-        surfaceInterpolation::clearOut();
-
         forAllIters(fluxes, iter)
         {
             if (!correctFluxes_.found(iter.key()))

src/fileFormats/ensight/mesh/ensightMesh.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2020 OpenCFD Ltd.
+    Copyright (C) 2016-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -199,6 +199,9 @@ void Foam::ensightMesh::correct()
 
         if (returnReduce(!zn.empty(), orOp<bool>()))
         {
+            // Ensure full mesh coverage
+            cellSelection.resize(mesh_.nCells());
+
             cellSelection.set(zn);
 
             ensightCells& part = cellZoneParts_(zoneId);
@@ -267,6 +270,7 @@ void Foam::ensightMesh::correct()
 
     if (returnReduce(!cellSelection.empty(), orOp<bool>()))
     {
+        // Ensure full mesh coverage
         excludeFace.resize(mesh_.nFaces());
 
         const labelList& owner = mesh_.faceOwner();
@@ -288,6 +292,7 @@ void Foam::ensightMesh::correct()
 
     if (fzoneIds.size())
     {
+        // Ensure full mesh coverage
         excludeFace.resize(mesh_.nFaces());
 
         for (const polyPatch& p : mesh_.boundaryMesh())

src/fileFormats/stl/STLtriangle.H

@@ -47,9 +47,9 @@ SourceFiles
 namespace Foam
 {
 
-// Forward Declarations
+// Forward declaration of friend functions and operators
 class STLtriangle;
-inline Ostream& operator<<(Ostream& os, const STLtriangle& tri);
+Ostream& operator<<(Ostream& os, const STLtriangle& tri);
 
 /*---------------------------------------------------------------------------*\
                          Class STLtriangle Declaration
@@ -141,10 +141,10 @@ public:
             );
 
 
-    // Ostream Operator
+    // Ostream operator
 
         //- Print triangle contents
-        friend Ostream& operator<<(Ostream& os, const STLtriangle& tri);
+        inline friend Ostream& operator<<(Ostream& os, const STLtriangle& tri);
 };
 
 

src/finiteVolume/cfdTools/general/SRF/SRFModel/SRFModel/SRFModel.C

@@ -6,7 +6,6 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -64,7 +63,14 @@ Foam::SRF::SRFModel::SRFModel
     mesh_(Urel_.mesh()),
     origin_("origin", dimLength, get<vector>("origin")),
     axis_(normalised(get<vector>("axis"))),
-    SRFModelCoeffs_(optionalSubDict(type + "Coeffs"))
+    SRFModelCoeffs_(optionalSubDict(type + "Coeffs")),
+    omega_(dimensionedVector("omega", dimless/dimTime, Zero))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::SRF::SRFModel::~SRFModel()
 {}
 
 
@@ -103,20 +109,29 @@ const Foam::vector& Foam::SRF::SRFModel::axis() const
 }
 
 
+const Foam::dimensionedVector& Foam::SRF::SRFModel::omega() const
+{
+    return omega_;
+}
+
+
 Foam::tmp<Foam::DimensionedField<Foam::vector, Foam::volMesh>>
 Foam::SRF::SRFModel::Fcoriolis() const
 {
-    return tmp<DimensionedField<vector, Foam::volMesh>>::New
+    return tmp<volVectorField::Internal>
     (
-        IOobject
+        new volVectorField::Internal
         (
-            "Fcoriolis",
-            mesh_.time().timeName(),
-            mesh_,
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        2.0*omega() ^ Urel_
+            IOobject
+            (
+                "Fcoriolis",
+                mesh_.time().timeName(),
+                mesh_,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            2.0*omega_ ^ Urel_
+        )
     );
 }
 
@@ -124,19 +139,20 @@ Foam::SRF::SRFModel::Fcoriolis() const
 Foam::tmp<Foam::DimensionedField<Foam::vector, Foam::volMesh>>
 Foam::SRF::SRFModel::Fcentrifugal() const
 {
-    const dimensionedVector omega = this->omega();
-
-    return tmp<DimensionedField<vector, Foam::volMesh>>::New
+    return tmp<volVectorField::Internal>
     (
-        IOobject
+        new volVectorField::Internal
         (
-            "Fcentrifugal",
-            mesh_.time().timeName(),
-            mesh_,
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        omega ^ (omega ^ (mesh_.C() - origin_))
+            IOobject
+            (
+                "Fcentrifugal",
+                mesh_.time().timeName(),
+                mesh_,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            omega_ ^ (omega_ ^ (mesh_.C() - origin_))
+        )
     );
 }
 
@@ -154,7 +170,7 @@ Foam::vectorField Foam::SRF::SRFModel::velocity
 ) const
 {
     tmp<vectorField> tfld =
-        omega().value()
+        omega_.value()
       ^ (
             (positions - origin_.value())
           - axis_*(axis_ & (positions - origin_.value()))
@@ -166,18 +182,21 @@ Foam::vectorField Foam::SRF::SRFModel::velocity
 
 Foam::tmp<Foam::volVectorField> Foam::SRF::SRFModel::U() const
 {
-    return tmp<volVectorField>::New
+    return tmp<volVectorField>
     (
-        IOobject
+        new volVectorField
         (
-            "Usrf",
-            mesh_.time().timeName(),
-            mesh_,
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        omega()
-      ^ ((mesh_.C() - origin_) - axis_*(axis_ & (mesh_.C() - origin_)))
+            IOobject
+            (
+                "Usrf",
+                mesh_.time().timeName(),
+                mesh_,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            omega_
+          ^ ((mesh_.C() - origin_) - axis_*(axis_ & (mesh_.C() - origin_)))
+        )
     );
 }
 
@@ -186,18 +205,21 @@ Foam::tmp<Foam::volVectorField> Foam::SRF::SRFModel::Uabs() const
 {
     tmp<volVectorField> Usrf = U();
 
-    auto tUabs = tmp<volVectorField>::New
+    tmp<volVectorField> tUabs
     (
-        IOobject
+        new volVectorField
         (
-            "Uabs",
-            mesh_.time().timeName(),
-            mesh_,
-            IOobject::NO_READ,
-            IOobject::NO_WRITE,
-            false
-        ),
-        Usrf
+            IOobject
+            (
+                "Uabs",
+                mesh_.time().timeName(),
+                mesh_,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            Usrf
+        )
     );
 
     volVectorField& Uabs = tUabs.ref();

src/finiteVolume/cfdTools/general/SRF/SRFModel/SRFModel/SRFModel.H

@@ -6,7 +6,6 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -51,7 +50,6 @@ SourceFiles
 #include "fvMesh.H"
 #include "volFields.H"
 #include "vectorField.H"
-#include "Function1.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -88,6 +86,9 @@ protected:
         //- SRF model coefficients dictionary
         dictionary SRFModelCoeffs_;
 
+        //- Angular velocity of the frame (rad/s)
+        dimensionedVector omega_;
+
 
 private:
 
@@ -140,7 +141,7 @@ public:
 
 
     //- Destructor
-    virtual ~SRFModel() = default;
+    virtual ~SRFModel();
 
 
     // Member Functions
@@ -153,15 +154,15 @@ public:
 
         // Access
 
-            //- Return the angular velocity field [rad/s]
-            virtual dimensionedVector omega() const = 0;
-
             //- Return the origin of rotation
             const dimensionedVector& origin() const;
 
             //- Return the axis of rotation
             const vector& axis() const;
 
+            //- Return the angular velocity field [rad/s]
+            const dimensionedVector& omega() const;
+
             //- Return the coriolis force
             tmp<volVectorField::Internal> Fcoriolis() const;
 

src/finiteVolume/cfdTools/general/SRF/SRFModel/rpm/rpm.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -47,14 +47,16 @@ namespace Foam
     }
 }
 
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::SRF::rpm::rpm(const volVectorField& U)
 :
     SRFModel(typeName, U),
-    rpmPtr_(Function1<scalar>::New("rpm", SRFModelCoeffs_))
-{}
+    rpm_(SRFModelCoeffs_.get<scalar>("rpm"))
+{
+    // The angular velocity
+    omega_.value() = axis_*rpmToRads(rpm_);
+}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
@@ -63,7 +65,9 @@ bool Foam::SRF::rpm::read()
 {
     if (SRFModel::read())
     {
-        rpmPtr_.reset(Function1<scalar>::New("rpm", SRFModelCoeffs_));
+        SRFModelCoeffs_.readEntry("rpm", rpm_);
+
+        omega_.value() = axis_*rpmToRads(rpm_);
 
         return true;
     }
@@ -72,14 +76,4 @@ bool Foam::SRF::rpm::read()
 }
 
 
-Foam::dimensionedVector Foam::SRF::rpm::omega() const
-{
-    const scalar t = this->db().time().timeOutputValue();
-    const scalar rpm = rpmPtr_->value(t);
-
-    return dimensionedVector("omega", dimless/dimTime, axis_*rpmToRads(rpm));
-}
-
-
-
 // ************************************************************************* //

src/finiteVolume/cfdTools/general/SRF/SRFModel/rpm/rpm.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -40,7 +40,6 @@ SourceFiles
 #define SRF_rpm_H
 
 #include "SRFModel.H"
-#include "Function1.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -61,7 +60,7 @@ class rpm
     // Private data
 
         //- Revolutions per minute
-        autoPtr<Function1<scalar>> rpmPtr_;
+        scalar rpm_;
 
 
     // Private Member Functions
@@ -86,16 +85,13 @@ public:
 
 
     //- Destructor
-    virtual ~rpm() = default;
+    ~rpm() = default;
 
 
     // Member functions
 
         //- Read coefficients
         bool read();
-
-        //- Return the angular velocity field [rad/s]
-        virtual dimensionedVector omega() const;
 };