WIP: fv fields

- this are to be used for bookkeeping purposes, not to solve on

applications/solvers/compressible/rhoCentralFoam/BCs/T/smoluchowskiJumpTFvPatchScalarField.C

@@ -103,14 +103,7 @@ Foam::smoluchowskiJumpTFvPatchScalarField::smoluchowskiJumpTFvPatchScalarField
             << exit(FatalIOError);
     }
 
-    if (dict.found("value"))
-    {
-        fvPatchField<scalar>::operator=
-        (
-            scalarField("value", dict, p.size())
-        );
-    }
-    else
+    if (!this->readValueEntry(dict))
     {
         fvPatchField<scalar>::operator=(patchInternalField());
     }

applications/solvers/compressible/rhoCentralFoam/BCs/U/maxwellSlipUFvPatchVectorField.C

@@ -105,18 +105,15 @@ Foam::maxwellSlipUFvPatchVectorField::maxwellSlipUFvPatchVectorField
             << exit(FatalIOError);
     }
 
-    if (dict.found("value"))
+    if (this->readValueEntry(dict))
     {
-        fvPatchField<vector>::operator=
-        (
-            vectorField("value", dict, p.size())
-        );
+        const auto* hasRefValue = dict.findEntry("refValue", keyType::LITERAL);
+        const auto* hasFrac = dict.findEntry("valueFraction", keyType::LITERAL);
 
-        if (dict.found("refValue") && dict.found("valueFraction"))
+        if (hasRefValue && hasFrac)
         {
-            this->refValue() = vectorField("refValue", dict, p.size());
-            this->valueFraction() =
-                scalarField("valueFraction", dict, p.size());
+            this->refValue().assign(*hasRefValue, p.size());
+            this->valueFraction().assign(*hasFrac, p.size());
         }
         else
         {

applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionTwoPhaseEulerFoam/derivedFvPatchFields/turbulentTemperatureTwoPhaseRadCoupledMixed/turbulentTemperatureTwoPhaseRadCoupledMixedFvPatchScalarField.C

@@ -243,14 +243,12 @@ turbulentTemperatureTwoPhaseRadCoupledMixedFvPatchScalarField
             << exit(FatalError);
     }
 
-    fvPatchScalarField::operator=(scalarField("value", dict, p.size()));
 
-    if (dict.found("refValue"))
+    this->readValueEntry(dict, IOobjectOption::MUST_READ);
+
+    if (this->readMixedEntries(dict))
     {
         // Full restart
-        refValue() = scalarField("refValue", dict, p.size());
-        refGrad() = scalarField("refGradient", dict, p.size());
-        valueFraction() = scalarField("valueFraction", dict, p.size());
     }
     else
     {

applications/test/boundBox2/Test-boundBox2.C

@@ -143,7 +143,7 @@ int main(int argc, char *argv[])
 {
     #include "setRootCase.H"
 
-    treeBoundBox bb(cube(0, 1));
+    treeBoundBox bb(zero_one{});
     treeBoundBox sub(cube(0.1, 0.8));
 
     Info<< nl

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

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2022 OpenCFD Ltd.
+    Copyright (C) 2022-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -51,7 +51,7 @@ void printInfo(const label comm)
         << " sub:" << UPstream::subProcs(comm) << nl;
 
 
-    if (UPstream::selfComm == comm)
+    if (UPstream::commSelf() == comm)
     {
         Pout<< "self all:" << UPstream::allProcs(comm)
             << " sub:" << UPstream::subProcs(comm) << nl;
@@ -86,32 +86,32 @@ int main(int argc, char *argv[])
         << "nProcs = " << UPstream::nProcs()
         << " with " << UPstream::nComms() << " predefined comm(s)" << nl;
 
-    Info<< "worldComm : ";
-    printInfo(UPstream::worldComm);
+    Info<< "comm-world : ";
+    printInfo(UPstream::commWorld());
 
-    Info<< "selfComm  : ";
-    printInfo(UPstream::selfComm);
+    Info<< "comm-self  : ";
+    printInfo(UPstream::commSelf());
 
     Info<< nl;
 
     // Reductions (using MPI intrinsics)
     {
-        label val = Pstream::myProcNo(UPstream::worldComm);
+        label val = Pstream::myProcNo(UPstream::commWorld());
 
         label worldVal = returnReduce
         (
             val,
             sumOp<label>(),
-            Pstream::msgType(),
-            UPstream::worldComm
+            UPstream::msgType(),
+            UPstream::commWorld()
         );
 
         label selfVal = returnReduce
         (
             val,
             sumOp<label>(),
-            Pstream::msgType(),
-            UPstream::selfComm
+            UPstream::msgType(),
+            UPstream::commSelf()
         );
 
         Pout<< "value " << val
@@ -123,8 +123,8 @@ int main(int argc, char *argv[])
     {
         Pair<label> val
         (
-            Pstream::myProcNo(UPstream::worldComm),
-            Pstream::myProcNo(UPstream::worldComm)
+            Pstream::myProcNo(UPstream::commWorld()),
+            Pstream::myProcNo(UPstream::commWorld())
         );
 
         Pair<label> worldVal = val;
@@ -133,8 +133,8 @@ int main(int argc, char *argv[])
         (
             worldVal,
             minFirstEqOp<label>(),
-            Pstream::msgType(),
-            UPstream::worldComm
+            UPstream::msgType(),
+            UPstream::commWorld()
         );
 
         Pair<label> selfVal = val;
@@ -143,8 +143,8 @@ int main(int argc, char *argv[])
         (
             worldVal,
             minFirstEqOp<label>(),
-            Pstream::msgType(),
-            UPstream::selfComm
+            UPstream::msgType(),
+            UPstream::commSelf()
         );
 
         Pout<< "value " << val

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

@@ -150,11 +150,7 @@ int main(int argc, char *argv[])
     Pout<< "localValue      :" << localValue << endl;
 
 
-    label comm = Pstream::allocateCommunicator
-    (
-        UPstream::worldComm,
-        top
-    );
+    label comm = UPstream::allocateCommunicator(UPstream::worldComm, top);
 
     Pout<< "allocated comm  :" << comm << endl;
     Pout<< "comm myproc     :" << Pstream::myProcNo(comm)
@@ -173,7 +169,7 @@ int main(int argc, char *argv[])
         Pout<< "sum             :" << sum << endl;
     }
 
-    Pstream::freeCommunicator(comm);
+    UPstream::freeCommunicator(comm);
 
 
     Pout<< "End\n" << endl;

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

@@ -88,12 +88,12 @@ int main(int argc, char *argv[])
 
     //- Process IDs within a given communicator
     Info<< "procIDs: "
-        << flatOutput(UPstream::procID(UPstream::worldComm)) << endl;
+        << flatOutput(UPstream::procID(UPstream::commWorld())) << endl;
 
-    rankInfo(UPstream::worldComm);
+    rankInfo(UPstream::commWorld());
     Pout<< endl;
 
-    const int myProci = UPstream::myProcNo(UPstream::worldComm);
+    const int myProci = UPstream::myProcNo(UPstream::commWorld());
     int localRanki = myProci;
 
     labelList subRanks;
@@ -101,9 +101,9 @@ int main(int argc, char *argv[])
 
     #if 1
     // With first ranks
-    subRanks = identity(UPstream::nProcs(UPstream::worldComm) / 2);
+    subRanks = identity(UPstream::nProcs(UPstream::commWorld()) / 2);
 
-    newComm.reset(UPstream::worldComm, subRanks);
+    newComm.reset(UPstream::commWorld(), subRanks);
     localRanki = UPstream::myProcNo(newComm);
 
     Pout.prefix() =
@@ -120,14 +120,14 @@ int main(int argc, char *argv[])
 
     #if 1
     // With every other rank
-    subRanks = identity(UPstream::nProcs(UPstream::worldComm));
+    subRanks = identity(UPstream::nProcs(UPstream::commWorld()));
 
     for (label& val : subRanks)
     {
         if (val % 2) val = -1;
     }
 
-    newComm.reset(UPstream::worldComm, subRanks);
+    newComm.reset(UPstream::commWorld(), subRanks);
     localRanki = UPstream::myProcNo(newComm);
 
     Pout.prefix() =
@@ -165,19 +165,19 @@ int main(int argc, char *argv[])
     }
     if (Pstream::parRun() && args.found("host-comm"))
     {
-        // Host communicator, based on the current worldComm
+        // Host communicator, based on the current world communicator
         // Use hostname
         // Lowest rank per hostname is the IO rank
 
-        label numprocs = UPstream::nProcs(UPstream::globalComm);
+        label numprocs = UPstream::nProcs(UPstream::commGlobal());
 
         stringList hosts(numprocs);
-        hosts[Pstream::myProcNo(UPstream::globalComm)] = hostName();
+        hosts[Pstream::myProcNo(UPstream::commGlobal())] = hostName();
 
         labelList hostIDs_;
 
         // Compact
-        if (Pstream::master(UPstream::globalComm))
+        if (Pstream::master(UPstream::commGlobal()))
         {
             DynamicList<word> hostNames(numprocs);
             hostIDs_.resize_nocopy(numprocs);
@@ -196,10 +196,10 @@ int main(int argc, char *argv[])
             }
         }
 
-        Pstream::broadcasts(UPstream::globalComm, hostIDs_);
+        Pstream::broadcasts(UPstream::commGlobal(), hostIDs_);
 
         const label myHostId =
-            hostIDs_[Pstream::myProcNo(UPstream::globalComm)];
+            hostIDs_[Pstream::myProcNo(UPstream::commGlobal())];
 
         DynamicList<label> subRanks;
         forAll(hostIDs_, proci)
@@ -210,11 +210,11 @@ int main(int argc, char *argv[])
             }
         }
 
-        // Allocate new communicator with globalComm as its parent
+        // Allocate new communicator with global communicator as its parent
         const label hostComm =
             UPstream::allocateCommunicator
             (
-                UPstream::globalComm,  // parent
+                UPstream::commGlobal(),
                 subRanks,
                 true
             );

applications/test/pointField/Test-PointField.C

@@ -39,7 +39,6 @@ Description
 
 int main(int argc, char *argv[])
 {
-
     #include "setRootCase.H"
 
     #include "createTime.H"
@@ -47,11 +46,42 @@ int main(int argc, char *argv[])
 
     const pointMesh& pMesh = pointMesh::New(mesh);
 
+    #if 1
+    pointLabelField state
+    (
+        IOobject
+        (
+            "test-state",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        pMesh
+    );
+    #else
+    pointLabelField state
+    (
+        IOobject
+        (
+            "test-state",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        pMesh,
+        dimensioned<label>(dimLength, 1),
+        pointPatchLabelField::calculatedType()
+    );
+    state.write();
+    #endif
+
     pointVectorField U
     (
         IOobject
         (
-            "U",
+            "test-U",
             runTime.timeName(),
             mesh,
             IOobject::NO_READ,
@@ -62,6 +92,8 @@ int main(int argc, char *argv[])
         pointPatchVectorField::calculatedType()
     );
 
+    U.write();
+
     pointVectorField V(U + 2*U);
 
     Info<< "End\n" << endl;

applications/test/polyMeshGeom-speed1/Make/files

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

applications/test/polyMeshGeom-speed1/Make/options

@@ -0,0 +1,5 @@
+EXE_INC = \
+    -I$(LIB_SRC)/mesh/blockMesh/lnInclude
+
+EXE_LIBS = \
+    -lblockMesh

applications/test/polyMeshGeom-speed1/Test-polyMeshGeom-speed1.C

@@ -0,0 +1,804 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2023 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Description
+    Simple timing tests for some polyMesh primitives
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "clockTime.H"
+#include "Time.H"
+#include "PDRblock.H"
+#include "polyMesh.H"
+#include "ListOps.H"
+
+using namespace Foam;
+
+void printAlloc(const polyMesh& mesh)
+{
+    Info<< "memory"
+        << " hasCellPoints:" << mesh.hasCellPoints()
+        << " hasPointCells:" << mesh.hasPointCells() << endl;
+}
+
+
+void printInfo(const polyMesh& mesh)
+{
+    Info<< "polyMesh"
+        << " nPoints:" << mesh.nPoints()
+        << " nInternalFaces:" << mesh.nInternalFaces()
+        << " nFaces:" << mesh.nFaces()
+        << " nCells:" << mesh.nCells() << endl;
+}
+
+
+// How point cells are calculated in OpenFOAM-v2212 and earlier
+autoPtr<labelListList> pointCells_2212(const polyMesh& mesh)
+{
+    const cellList& cf = mesh.cells();
+
+    // Count number of cells per point
+
+    labelList npc(mesh.nPoints(), Zero);
+
+    forAll(cf, celli)
+    {
+        const labelList curPoints = cf[celli].labels(mesh.faces());
+
+        for (const label pointi : curPoints)
+        {
+            ++npc[pointi];
+        }
+    }
+
+
+    // Size and fill cells per point
+
+    auto pcPtr_ = autoPtr<labelListList>::New(npc.size());
+    labelListList& pointCellAddr = *pcPtr_;
+
+    forAll(pointCellAddr, pointi)
+    {
+        pointCellAddr[pointi].setSize(npc[pointi]);
+        npc[pointi] = 0;
+    }
+
+
+    forAll(cf, celli)
+    {
+        const labelList curPoints = cf[celli].labels(mesh.faces());
+
+        for (const label pointi : curPoints)
+        {
+            pointCellAddr[pointi][npc[pointi]++] = celli;
+        }
+    }
+
+    return pcPtr_;
+}
+
+
+// Line cell::labels but with persistent storage
+void cell_labels
+(
+    const cell& cFaces,
+    const faceUList& meshFaces,
+    DynamicList<label>& pointLabels
+)
+{
+    // const labelList& cFaces = *this;
+
+    label nVerts = 0;
+    for (const label facei : cFaces)
+    {
+        nVerts += meshFaces[facei].size();
+    }
+
+    // pointLabels.clear();
+    pointLabels.expandStorage();
+
+    // The first face has no duplicates, can copy in values
+    const labelList& firstFace = meshFaces[cFaces[0]];
+
+    std::copy(firstFace.cbegin(), firstFace.cend(), pointLabels.begin());
+
+    // Now already contains some vertices
+    nVerts = firstFace.size();
+
+    // For the rest of the faces. For each vertex, check if the point is
+    // already inserted (up to nVerts, which now carries the number of real
+    // points. If not, add it at the end of the list.
+
+    for (label facei = 1; facei < cFaces.size(); ++facei)
+    {
+        for (const label curPoint : meshFaces[cFaces[facei]])
+        {
+            bool pointFound = false;
+
+            for (label checki = 0; checki < nVerts; ++checki)
+            {
+                if (curPoint == pointLabels[checki])
+                {
+                    pointFound = true;
+                    break;
+                }
+            }
+
+            if (!pointFound)
+            {
+                pointLabels[nVerts] = curPoint;
+                ++nVerts;
+            }
+        }
+    }
+
+    pointLabels.resize(nVerts);
+}
+
+
+
+// Like OpenFOAM-v2212, but with cell::labels unrolled to avoid allocations
+autoPtr<labelListList> pointCells_2212mod(const polyMesh& mesh)
+{
+    const cellList& cf = mesh.cells();
+
+    // Vertex labels for the current cell
+    DynamicList<label> vertices(256);
+
+    // Count number of cells per point
+
+    labelList npc(mesh.nPoints(), Zero);
+
+    for (const cell& c : cf)
+    {
+        cell_labels(c, mesh.faces(), vertices);
+
+        for (const label pointi : vertices)
+        {
+            ++npc[pointi];
+        }
+    }
+
+
+    // Size and fill cells per point
+
+    auto pcPtr_ = autoPtr<labelListList>::New(npc.size());
+    labelListList& pointCellAddr = *pcPtr_;
+
+    forAll(pointCellAddr, pointi)
+    {
+        pointCellAddr[pointi].resize(npc[pointi]);
+        npc[pointi] = 0;
+    }
+
+
+    forAll(cf, celli)
+    {
+        cell_labels(cf[celli], mesh.faces(), vertices);
+
+        for (const label pointi : vertices)
+        {
+            pointCellAddr[pointi][npc[pointi]++] = celli;
+        }
+    }
+
+    return pcPtr_;
+}
+
+
+// How cells points are calculated in OpenFOAM-v2212 and earlier
+autoPtr<labelListList> cellPoints_2212(const polyMesh& mesh)
+{
+    autoPtr<labelListList> pointCells = pointCells_2212(mesh);
+
+    auto cpPtr_ = autoPtr<labelListList>::New(mesh.nCells());
+
+    invertManyToMany(mesh.nCells(), pointCells(), *cpPtr_);
+
+    return cpPtr_;
+}
+
+
+// Calculate with bitSet tracking and avoid cells::labels
+autoPtr<labelListList> pointCells_bitSet(const polyMesh& mesh)
+{
+    // Calculate point-cell topology
+
+    const cellList& cellLst = mesh.cells();
+    const faceList& faceLst = mesh.faces();
+
+    // For tracking (only use each point id once)
+    bitSet usedPoints(mesh.nPoints());
+
+    // Vertex labels for the current cell
+    DynamicList<label> vertices(256);
+
+    const label loopLen = mesh.nCells();
+
+    // Step 1: count number of cells per point
+
+    labelList pointCount(mesh.nPoints(), Zero);
+
+    for (label celli = 0; celli < loopLen; ++celli)
+    {
+        // Clear any previous contents
+        usedPoints.unset(vertices);
+        vertices.clear();
+
+        for (const label facei : cellLst[celli])
+        {
+            for (const label pointi : faceLst[facei])
+            {
+                // Only once for each point id
+                if (usedPoints.set(pointi))
+                {
+                    vertices.push_back(pointi);
+                    ++pointCount[pointi];
+                }
+            }
+        }
+    }
+
+
+    // Step 2: set sizing, reset counters
+
+    auto pcPtr_ = autoPtr<labelListList>::New(mesh.nPoints());
+    auto& pointCellAddr = *pcPtr_;
+
+    forAll(pointCellAddr, pointi)
+    {
+        pointCellAddr[pointi].resize_nocopy(pointCount[pointi]);
+        pointCount[pointi] = 0;
+    }
+
+
+    // Step 3: fill in values. Logic as per step 1
+    for (label celli = 0; celli < loopLen; ++celli)
+    {
+        // Clear any previous contents
+        usedPoints.unset(vertices);
+        vertices.clear();
+
+        for (const label facei : cellLst[celli])
+        {
+            for (const label pointi : faceLst[facei])
+            {
+                // Only once for each point id
+                if (usedPoints.set(pointi))
+                {
+                    vertices.push_back(pointi);
+                    pointCellAddr[pointi][pointCount[pointi]++] = celli;
+                }
+            }
+        }
+    }
+
+    return pcPtr_;
+}
+
+
+// Calculate with bitSet tracking and avoid cells::labels
+autoPtr<labelListList> cellPoints_bitSet(const polyMesh& mesh)
+{
+    // Calculate cell-point topology
+
+    auto cpPtr_ = autoPtr<labelListList>::New(mesh.nCells());
+    auto& cellPointAddr = *cpPtr_;
+
+    const cellList& cellLst = mesh.cells();
+    const faceList& faceLst = mesh.faces();
+
+    // For tracking (only use each point id once)
+    bitSet usedPoints(mesh.nPoints());
+
+    // Vertex labels for the current cell
+    DynamicList<label> vertices(256);
+
+    const label loopLen = mesh.nCells();
+
+    for (label celli = 0; celli < loopLen; ++celli)
+    {
+        // Clear any previous contents
+        usedPoints.unset(vertices);
+        vertices.clear();
+
+        for (const label facei : cellLst[celli])
+        {
+            for (const label pointi : faceLst[facei])
+            {
+                // Only once for each point id
+                if (usedPoints.set(pointi))
+                {
+                    vertices.push_back(pointi);
+                }
+            }
+        }
+
+        cellPointAddr[celli] = vertices;  // unsorted
+    }
+
+    return cpPtr_;
+}
+
+
+// Calculate with linear lookup and avoid cells::labels
+autoPtr<labelListList> pointCells_linear(const polyMesh& mesh)
+{
+    // Calculate point-cell topology
+
+    const cellList& cellLst = mesh.cells();
+    const faceList& faceLst = mesh.faces();
+
+    // Vertex labels for the current cell
+    DynamicList<label> vertices(256);
+
+    const label loopLen = mesh.nCells();
+
+    // Step 1: count number of cells per point
+
+    labelList pointCount(mesh.nPoints(), Zero);
+
+    for (label celli = 0; celli < loopLen; ++celli)
+    {
+        // Clear any previous contents
+        vertices.clear();
+
+        for (const label facei : cellLst[celli])
+        {
+            for (const label pointi : faceLst[facei])
+            {
+                // Only once for each point id
+                if (!vertices.contains(pointi))
+                {
+                    vertices.push_back(pointi);
+                    ++pointCount[pointi];
+                }
+            }
+        }
+    }
+
+
+    // Step 2: set sizing, reset counters
+
+    auto pcPtr_ = autoPtr<labelListList>::New(mesh.nPoints());
+    auto& pointCellAddr = *pcPtr_;
+
+    forAll(pointCellAddr, pointi)
+    {
+        pointCellAddr[pointi].resize_nocopy(pointCount[pointi]);
+        pointCount[pointi] = 0;
+    }
+
+
+    // Step 3: fill in values. Logic as per step 1
+    for (label celli = 0; celli < loopLen; ++celli)
+    {
+        // Clear any previous contents
+        vertices.clear();
+
+        for (const label facei : cellLst[celli])
+        {
+            for (const label pointi : faceLst[facei])
+            {
+                // Only once for each point id
+                if (!vertices.contains(pointi))
+                {
+                    vertices.push_back(pointi);
+                    pointCellAddr[pointi][pointCount[pointi]++] = celli;
+                }
+            }
+        }
+    }
+
+    return pcPtr_;
+}
+
+
+// Calculate with linear lookup and avoid cells::labels
+autoPtr<labelListList> cellPoints_linear(const polyMesh& mesh)
+{
+    // Calculate cell-point topology
+
+    auto cpPtr_ = autoPtr<labelListList>::New(mesh.nCells());
+    auto& cellPointAddr = *cpPtr_;
+
+    const cellList& cellLst = mesh.cells();
+    const faceList& faceLst = mesh.faces();
+
+    // Vertex labels for the current cell
+    DynamicList<label> vertices(256);
+
+    const label loopLen = mesh.nCells();
+
+    for (label celli = 0; celli < loopLen; ++celli)
+    {
+        // Clear any previous contents
+        vertices.clear();
+
+        for (const label facei : cellLst[celli])
+        {
+            for (const label pointi : faceLst[facei])
+            {
+                // Only once for each point id
+                if (!vertices.contains(pointi))
+                {
+                    vertices.push_back(pointi);
+                }
+            }
+        }
+
+        cellPointAddr[celli] = vertices;  // unsorted
+    }
+
+    return cpPtr_;
+}
+
+
+// Calculate point-cell from point-face information
+autoPtr<labelListList> pointCells_faces(const polyMesh& mesh)
+{
+    const labelList& own = mesh.faceOwner();
+    const labelList& nei = mesh.faceNeighbour();
+    const labelListList& pFaces = mesh.pointFaces();
+
+    const label loopLen = mesh.nPoints();
+
+    auto pcPtr_ = autoPtr<labelListList>::New(mesh.nPoints());
+    auto& pointCellAddr = *pcPtr_;
+
+    DynamicList<label> storage(256);
+
+    for (label pointi = 0; pointi < loopLen; ++pointi)
+    {
+        // Clear any previous contents
+        storage.clear();
+
+        for (const label facei : pFaces[pointi])
+        {
+            // Owner cell
+            storage.push_back(own[facei]);
+
+            // Neighbour cell
+            if (facei < mesh.nInternalFaces())
+            {
+                storage.push_back(nei[facei]);
+            }
+        }
+
+        // Sort + unique to eliminate duplicates
+        std::sort(storage.begin(), storage.end());
+        auto last = std::unique(storage.begin(), storage.end());
+        storage.resize(label(last - storage.begin()));
+
+        pointCellAddr[pointi] = storage;
+    }
+
+    return pcPtr_;
+}
+
+// Calculate point-cell from point-face information
+autoPtr<labelListList> pointCells_bitSet_faces(const polyMesh& mesh)
+{
+    const labelList& own = mesh.faceOwner();
+    const labelList& nei = mesh.faceNeighbour();
+    const labelListList& pFaces = mesh.pointFaces();
+
+    const label loopLen = mesh.nPoints();
+
+    auto pcPtr_ = autoPtr<labelListList>::New(mesh.nPoints());
+    auto& pointCellAddr = *pcPtr_;
+
+    // For tracking (only use each cell id once)
+    bitSet usedCells(mesh.nCells());
+
+    DynamicList<label> storage(256);
+
+    for (label pointi = 0; pointi < loopLen; ++pointi)
+    {
+        // Clear any previous contents
+        usedCells.unset(storage);
+        storage.clear();
+
+        for (const label facei : pFaces[pointi])
+        {
+            // Owner cell - only once
+            if (usedCells.set(own[facei]))
+            {
+                storage.push_back(own[facei]);
+            }
+
+            // Neighbour cell
+            if (facei < mesh.nInternalFaces() && usedCells.set(nei[facei]))
+            {
+                storage.push_back(nei[facei]);
+            }
+        }
+
+        pointCellAddr[pointi] = storage;
+    }
+
+    return pcPtr_;
+}
+
+
+// Calculate point-cell from cell-point information
+autoPtr<labelListList> pointCells_bitSet_alon(const polyMesh& mesh)
+{
+    autoPtr<labelListList> cellPoints = cellPoints_bitSet(mesh);
+
+    auto pcPtr_ = autoPtr<labelListList>::New(mesh.nPoints());
+
+    invertManyToMany(mesh.nPoints(), cellPoints(), *pcPtr_);
+
+    return pcPtr_;
+}
+
+
+// Eliminate duplicates with sort+unique
+autoPtr<labelListList> cellPoints_sorted(const polyMesh& mesh)
+{
+    // Calculate cell-point topology
+
+    auto cpPtr_ = autoPtr<labelListList>::New(mesh.nCells());
+    auto& cellPointAddr = *cpPtr_;
+
+    const cellList& cellLst = mesh.cells();
+    const faceList& faceLst = mesh.faces();
+
+    // Vertex labels for the current cell
+    DynamicList<label> vertices(256);
+
+    const label loopLen = mesh.nCells();
+
+    for (label celli = 0; celli < loopLen; ++celli)
+    {
+        // Clear any previous contents
+        vertices.clear();
+
+        for (const label facei : cellLst[celli])
+        {
+            for (const label pointi : faceLst[facei])
+            {
+                vertices.push_back(pointi);
+            }
+        }
+
+        // Sort + unique to eliminate duplicates
+        std::sort(vertices.begin(), vertices.end());
+        auto last = std::unique(vertices.begin(), vertices.end());
+        vertices.resize(label(last - vertices.begin()));
+
+        cellPointAddr[celli] = vertices;
+    }
+
+    return cpPtr_;
+}
+
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Main program:
+
+int main(int argc, char *argv[])
+{
+    argList::noBanner();
+    argList::noParallel();
+    argList::noFunctionObjects();
+    argList::addOption("nCells", "number", "The number of cells");
+
+    #include "setRootCase.H"
+
+    const scalar cellCount(args.getOrDefault<scalar>("nCells", 1000));
+
+    const label nDivs(::round(::cbrt(cellCount)));
+
+    PDRblock blkMesh(boundBox(zero_one{}), labelVector::uniform(nDivs));
+
+    autoPtr<Time> dummyTimePtr(Time::New());
+
+    Info<< "Requested " << cellCount
+        << " cells, blockMesh with " << blkMesh.nCells() << " cells" << nl;
+
+    autoPtr<polyMesh> meshPtr = blkMesh.innerMesh
+    (
+        IOobject
+        (
+            "Testing",
+            dummyTimePtr->system(),
+            *dummyTimePtr,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            IOobject::NO_REGISTER
+        )
+    );
+
+    auto& mesh = meshPtr();
+
+    printInfo(mesh);
+    printAlloc(mesh);
+
+    clockTime timing;
+
+    // pointCells
+    {
+        mesh.clearOut();
+        timing.resetTime();
+        (void) mesh.pointCells();
+        Info<< "pointCells (builtin): " << timing.elapsedTime() << " s" << nl;
+    }
+
+    // cellPoints
+    {
+        mesh.clearOut();
+        timing.resetTime();
+        (void) mesh.cellPoints();
+        Info<< "cellPoints (builtin): " << timing.elapsedTime() << " s" << nl;
+    }
+    Info<< nl;
+
+
+    // pointCells
+    {
+        mesh.clearOut();
+        timing.resetTime();
+        (void) pointCells_2212(mesh);
+        Info<< "pointCells (2212): " << timing.elapsedTime() << " s" << nl;
+    }
+
+    {
+        mesh.clearOut();
+        timing.resetTime();
+        (void) pointCells_2212mod(mesh);
+        Info<< "pointCells (2212mod): " << timing.elapsedTime() << " s" << nl;
+    }
+
+    {
+        mesh.clearOut();
+        timing.resetTime();
+        (void) pointCells_bitSet(mesh);
+        Info<< "pointCells (bitSet): " << timing.elapsedTime() << " s" << nl;
+    }
+
+    {
+        mesh.clearOut();
+        timing.resetTime();
+        (void) pointCells_linear(mesh);
+        Info<< "pointCells (linear): " << timing.elapsedTime() << " s" << nl;
+    }
+
+    {
+        mesh.clearOut();
+        timing.resetTime();
+        (void) pointCells_faces(mesh);
+        Info<< "pointCells (faces): " << timing.elapsedTime() << " s" << nl;
+    }
+
+    {
+        mesh.clearOut();
+        timing.resetTime();
+        (void) pointCells_bitSet_faces(mesh);
+        Info<< "pointCells (bitSet faces): " << timing.elapsedTime() << " s" << nl;
+    }
+
+    {
+        mesh.clearOut();
+        timing.resetTime();
+        (void) pointCells_bitSet_alon(mesh);
+        Info<< "pointCells (bitSet alon): " << timing.elapsedTime() << " s" << nl;
+    }
+
+    // cellPoints
+    {
+        mesh.clearOut();
+        timing.resetTime();
+        (void) cellPoints_2212(mesh);
+        Info<< "cellPoints (2212): " << timing.elapsedTime() << " s" << nl;
+    }
+
+    {
+        mesh.clearOut();
+        timing.resetTime();
+        (void) cellPoints_bitSet(mesh);
+        Info<< "cellPoints (bitSet): " << timing.elapsedTime() << " s" << nl;
+    }
+
+    {
+        mesh.clearOut();
+        timing.resetTime();
+        (void) cellPoints_linear(mesh);
+        Info<< "cellPoints (linear): " << timing.elapsedTime() << " s" << nl;
+    }
+
+    {
+        mesh.clearOut();
+        timing.resetTime();
+        (void) cellPoints_sorted(mesh);
+        Info<< "cellPoints (sorted): " << timing.elapsedTime() << " s" << nl;
+    }
+
+
+    // With precalculated values
+    {
+        mesh.clearOut();
+        const auto& cp = mesh.cellPoints();
+        timing.resetTime();
+
+        auto pcPtr_ = autoPtr<labelListList>::New(mesh.nPoints());
+
+        invertManyToMany(mesh.nPoints(), cp, *pcPtr_);
+
+        Info<< "pointCells (from cached cellPoints): " << timing.elapsedTime() << " s" << nl;
+    }
+
+    // With precalculated values
+    {
+        mesh.clearOut();
+        (void)mesh.pointFaces();
+        timing.resetTime();
+
+        (void) pointCells_bitSet_faces(mesh);
+
+        Info<< "pointCells (bitSet from cached pointFaces): " << timing.elapsedTime() << " s" << nl;
+    }
+
+
+    // With precalculated values
+    {
+        mesh.clearOut();
+        const auto& pc = mesh.pointCells();
+        timing.resetTime();
+
+        auto cpPtr_ = autoPtr<labelListList>::New(mesh.nCells());
+
+        invertManyToMany(mesh.nCells(), pc, *cpPtr_);
+
+        Info<< "cellPoints (from cached pointCells): " << timing.elapsedTime() << " s" << nl;
+    }
+
+
+    // Re-measure timings
+    Info<< nl;
+    {
+        mesh.clearOut();
+        timing.resetTime();
+        (void) mesh.pointCells();
+        Info<< "pointCells (builtin): " << timing.elapsedTime() << " s" << nl;
+    }
+
+    {
+        mesh.clearOut();
+        timing.resetTime();
+        (void) mesh.cellPoints();
+        Info<< "cellPoints (builtin): " << timing.elapsedTime() << " s" << nl;
+    }
+
+    Info<< "\nEnd\n" << nl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/test/primitives/Test-primitives.C

@@ -224,73 +224,21 @@ int main(int argc, char *argv[])
             << lerp(vector::uniform(0), vector::uniform(100), 0.5) << nl;
     }
 
-    {
-        const lerpOp1<vector> half(0.5);
-
-        const vector a(vector::uniform(20));
-        const vector b(vector::uniform(100));
-
-        Info<< "lerp half: "
-            << a << " : " << b << " => " << half(a, b) << nl;
-    }
-
     {
         const labelVector a(labelVector::uniform(10000));
         const labelVector b(labelVector::uniform(1));
 
-        Info<< "lerp (labelVector) = "
+        Info<<"lerp (labelVector) = "
             << lerp(a, b, 0.1) << nl;
     }
 
-    {
-        const scalar a(0);
-        const scalar b(100);
-
-        Info<< "lerp of " << a << " : " << b << nl;
-
-        for (const double t : { 0.0, 0.5, 1.0, -0.5, 1.5 })
-        {
-            Info<< "    " << t << " = " << lerp(a, b, t) << nl;
-        }
-    }
-
-
-    // No yet
-    #if 0
-    {
-        const label a(10000);
-        const label b(1);
-
-        Info<<"lerp (label) = "
-            << label(lerp(a, b, 0.1)) << nl;
-    }
-
-    {
-        const bool a(true);
-        const bool b(false);
-
-        Info<<"lerp (bool) = "
-            << (lerp(a, b, 0.5)) << nl;
-    }
-    #endif
-
     {
         const sphericalTensor a(10), b(20);
 
         Info<<"lerp exact: "
             << (a == lerp(a, b, 0.0f)) << " "
             << (b == lerp(a, b, 1.0f)) << nl;
-//        Info<< "lerp: "
-//            << lerp(vector::uniform(0), vector::uniform(100), 0.5) << nl;
-    }
-
-    {
-        const tensor a(tensor::uniform(1e24));
-        const tensor b(tensor::uniform(0));
-
-        Info<<"lerp exact: "
-            << (a == lerp(a, b, 0.0f)) << " "
-            << (b == lerp(a, b, 1.0f)) << nl;
+//
 //        Info<< "lerp: "
 //            << lerp(vector::uniform(0), vector::uniform(100), 0.5) << nl;
     }

applications/test/triangleIntersection/Test-triangleIntersection.C

@@ -88,8 +88,7 @@ int main(int argc, char *argv[])
     // Info<<"tree-bb faces: " << treeBoundBox::faces << nl
     //     <<"tree-bb edges: " << treeBoundBox::edges << endl;
 
-    treeBoundBox bb;
-    bb = cube(0, 1);
+    treeBoundBox bb(zero_one{});
 
     triPoints tri;
     tri.a() = point(-0.1, 0.5, 0.5);

etc/controlDict

@@ -130,9 +130,7 @@ OptimisationSwitches
     // Number processors to change to tree communication
     nProcsSimpleSum 0;
     // Min numProc to use non-blocking exchange algorithm (Hoeffler: NBX)
-    nonBlockingExchange 1;
-    // Use hybrid NBX/PEX for PstreamBuffers
-    pbufs.algorithm 0;
+    nonBlockingExchange 0;
 
     // MPI buffer size (bytes)
     // Can override with the MPI_BUFFER_SIZE env variable.

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

@@ -173,6 +173,10 @@ public:
         //- (discard old element at that location).
         //- Return reference to the new list element.
         template<class... Args>
+        inline T& emplace_set(const label i, Args&&... args);
+
+        //- Same as emplace_set()
+        template<class... Args>
         inline T& emplace(const label i, Args&&... args);
 
         //- Set element to given pointer and return old element (can be null)

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

@@ -172,11 +172,17 @@ inline void Foam::PtrList<T>::push_back(PtrList<T>&& other)
 
 template<class T>
 template<class... Args>
-inline T& Foam::PtrList<T>::emplace
-(
-    const label i,
-    Args&&... args
-)
+inline T& Foam::PtrList<T>::emplace_set(const label i, Args&&... args)
+{
+    T* ptr = new T(std::forward<Args>(args)...);
+    (void)this->set(i, ptr);
+    return *ptr;
+}
+
+
+template<class T>
+template<class... Args>
+inline T& Foam::PtrList<T>::emplace(const label i, Args&&... args)
 {
     T* ptr = new T(std::forward<Args>(args)...);
     (void)this->set(i, ptr);

src/OpenFOAM/db/IOstreams/Pstreams/PstreamBuffers.C

@@ -27,6 +27,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "PstreamBuffers.H"
+#include "bitSet.H"
 #include "debug.H"
 #include "registerSwitch.H"
 
@@ -35,7 +36,7 @@ License
 int Foam::PstreamBuffers::algorithm
 (
     // Not really the most creative name...
-    Foam::debug::optimisationSwitch("pbufs.algorithm", 0)
+    Foam::debug::optimisationSwitch("pbufs.algorithm", -1)
 );
 registerOptSwitch
 (
@@ -133,7 +134,8 @@ void Foam::PstreamBuffers::finalExchange
 
 void Foam::PstreamBuffers::finalExchange
 (
-    const labelUList& neighProcs,
+    const labelUList& sendProcs,
+    const labelUList& recvProcs,
     const bool wait,
     labelList& recvSizes
 )
@@ -153,7 +155,7 @@ void Foam::PstreamBuffers::finalExchange
             // Preserve self-send, even if not described by neighbourhood
             recvSizes[UPstream::myProcNo(comm_)] = 1;
 
-            for (const label proci : neighProcs)
+            for (const label proci : sendProcs)
             {
                 recvSizes[proci] = 1;  // Connected
             }
@@ -170,7 +172,8 @@ void Foam::PstreamBuffers::finalExchange
         // PEX stage 1: exchange sizes (limited neighbourhood)
         Pstream::exchangeSizes
         (
-            neighProcs,
+            sendProcs,
+            recvProcs,
             sendBuffers_,
             recvSizes,
             tag_,
@@ -623,7 +626,7 @@ void Foam::PstreamBuffers::finishedNeighbourSends
     const bool wait
 )
 {
-    finalExchange(neighProcs, wait, recvSizes);
+    finalExchange(neighProcs, neighProcs, wait, recvSizes);
 }
 
 
@@ -634,7 +637,71 @@ void Foam::PstreamBuffers::finishedNeighbourSends
 )
 {
     labelList recvSizes;
-    finalExchange(neighProcs, wait, recvSizes);
+    finalExchange(neighProcs, neighProcs, wait, recvSizes);
+}
+
+
+bool Foam::PstreamBuffers::finishedSends
+(
+    bitSet& sendConnections,
+    DynamicList<label>& sendProcs,
+    DynamicList<label>& recvProcs,
+    const bool wait
+)
+{
+    bool changed = (sendConnections.size() != nProcs());
+
+    if (changed)
+    {
+        sendConnections.resize(nProcs());
+    }
+
+    // Update send connections
+    forAll(sendBuffers_, proci)
+    {
+        if (sendConnections.set(proci, !sendBuffers_[proci].empty()))
+        {
+            // The state changed
+            changed = true;
+        }
+    }
+
+    UPstream::reduceOr(changed, comm_);
+
+    if (changed)
+    {
+        // Update send/recv topology
+        labelList recvSizes;
+        finishedSends(recvSizes, wait);  // eg, using all-to-all
+
+        // The send ranks
+        sendProcs.clear();
+        forAll(sendBuffers_, proci)
+        {
+            if (!sendBuffers_[proci].empty())
+            {
+                sendProcs.push_back(proci);
+            }
+        }
+
+        // The recv ranks
+        recvProcs.clear();
+        forAll(recvSizes, proci)
+        {
+            if (recvSizes[proci] > 0)
+            {
+                recvProcs.push_back(proci);
+            }
+        }
+    }
+    else
+    {
+        // Use existing send/recv ranks
+        labelList recvSizes;
+        finalExchange(sendProcs, recvProcs, wait, recvSizes);
+    }
+
+    return changed;
 }
 
 

src/OpenFOAM/db/IOstreams/Pstreams/PstreamBuffers.H

@@ -108,6 +108,9 @@ SourceFiles
 namespace Foam
 {
 
+// Forward Declarations
+class bitSet;
+
 /*---------------------------------------------------------------------------*\
                        Class PstreamBuffers Declaration
 \*---------------------------------------------------------------------------*/
@@ -165,7 +168,8 @@ class PstreamBuffers
         //  (nonBlocking comms).
         void finalExchange
         (
-            const labelUList& neighProcs,
+            const labelUList& sendProcs,
+            const labelUList& recvProcs,
             const bool wait,
             labelList& recvSizes
         );
@@ -431,6 +435,25 @@ public:
             const bool wait = true
         );
 
+        //- A caching version that uses a limited send/recv connectivity.
+        //
+        //  Non-blocking mode: populates receive buffers.
+        //  \param sendConnections on/off for sending ranks
+        //  \param sendProcs ranks used for sends
+        //  \param recvProcs ranks used for recvs
+        //  \param wait wait for requests to complete (in nonBlocking mode)
+        //
+        //  \return True if the send/recv connectivity changed
+        //
+        //  \warning currently only valid for nonBlocking comms.
+        bool finishedSends
+        (
+            bitSet& sendConnections,
+            DynamicList<label>& sendProcs,
+            DynamicList<label>& recvProcs,
+            const bool wait = true
+        );
+
 
     // Gather/scatter modes
 

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

@@ -58,7 +58,7 @@ void reduce
     const label comm
 )
 {
-    if (UPstream::warnComm != -1 && comm != UPstream::warnComm)
+    if (UPstream::warnComm >= 0 && comm != UPstream::warnComm)
     {
         Pout<< "** reducing:" << value << " with comm:" << comm << endl;
         error::printStack(Pout);

src/OpenFOAM/db/IOstreams/Pstreams/UPstream.H

@@ -284,24 +284,52 @@ public:
 
     // Standard Communicators
 
-        //- Default world communicator (all processors).
+        //- Communicator for all ranks.
         //- May differ from globalComm if local worlds are in use
         static label worldComm;
 
         //- Debugging: warn for use of any communicator differing from warnComm
         static label warnComm;
 
-        //- Communicator for all processors, irrespective of any local worlds
+        //- Communicator for all ranks, irrespective of any local worlds
         static constexpr label globalComm = 0;
 
         //- A communicator within the current rank only
         static constexpr label selfComm = 1;
 
+        //- Communicator for all ranks, irrespective of any local worlds
+        static constexpr label commGlobal() noexcept { return 0; }
+
+        //- Communicator within the current rank only
+        static constexpr label commSelf() noexcept { return 1; }
+
+        //- Communicator for all ranks (respecting any local worlds)
+        static label commWorld() noexcept { return worldComm; }
+
+        //- Alter value of world communicator
+        //  \returns the previous value
+        static label commWorld(const label communicator) noexcept
+        {
+            label old(worldComm);
+            worldComm = communicator;
+            return old;
+        }
+
+        //- Alter communicator debugging setting.
+        //- Warns for use of any communicator differing from specified.
+        //  \returns the previous warn communicator
+        static label commWarn(const label communicator) noexcept
+        {
+            label old(warnComm);
+            warnComm = communicator;
+            return old;
+        }
+
         //- Number of currently defined communicators
         static label nComms() noexcept { return parentComm_.size(); }
 
         //- True if communicator appears to be user-allocated
-        static bool isUserComm(label communicator) noexcept
+        static bool isUserComm(const label communicator) noexcept
         {
             return (communicator > worldComm && communicator > selfComm);
         }

src/OpenFOAM/db/error/messageStream.C

@@ -143,7 +143,7 @@ Foam::OSstream& Foam::messageStream::stream(OSstream* alternative)
 
 Foam::OSstream& Foam::messageStream::masterStream(const label communicator)
 {
-    if (UPstream::warnComm != -1 && communicator != UPstream::warnComm)
+    if (UPstream::warnComm >= 0 && communicator != UPstream::warnComm)
     {
         Pout<< "** messageStream with comm:" << communicator << endl;
         error::printStack(Pout);

src/OpenFOAM/fields/GeometricFields/pointFields/pointFields.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -33,12 +34,14 @@ License
 namespace Foam
 {
 
+defineTemplateTypeNameAndDebug(pointLabelField::Internal, 0);
 defineTemplateTypeNameAndDebug(pointScalarField::Internal, 0);
 defineTemplateTypeNameAndDebug(pointVectorField::Internal, 0);
 defineTemplateTypeNameAndDebug(pointSphericalTensorField::Internal, 0);
 defineTemplateTypeNameAndDebug(pointSymmTensorField::Internal, 0);
 defineTemplateTypeNameAndDebug(pointTensorField::Internal, 0);
 
+defineTemplateTypeNameAndDebug(pointLabelField, 0);
 defineTemplateTypeNameAndDebug(pointScalarField, 0);
 defineTemplateTypeNameAndDebug(pointVectorField, 0);
 defineTemplateTypeNameAndDebug(pointSphericalTensorField, 0);
@@ -54,6 +57,7 @@ defineTemplateTypeNameAndDebug(pointTensorField, 0);
 
 const Foam::wordList Foam::fieldTypes::point
 ({
+    "pointLabelField",
     "pointScalarField",
     "pointVectorField",
     "pointSphericalTensorField",

src/OpenFOAM/fields/GeometricFields/pointFields/pointFields.H

@@ -33,8 +33,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef pointFields_H
-#define pointFields_H
+#ifndef Foam_pointFields_H
+#define Foam_pointFields_H
 
 #include "GeometricFields.H"
 #include "pointMesh.H"

src/OpenFOAM/fields/GeometricFields/pointFields/pointFieldsFwd.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
-    Copyright (C) 2018-2022 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -80,6 +80,7 @@ using PointInternalField = DimensionedField<Type, pointMesh>;
 
 // Typedefs
 
+typedef GeometricField<label, pointPatchField, pointMesh> pointLabelField;
 typedef GeometricField<scalar, pointPatchField, pointMesh> pointScalarField;
 typedef GeometricField<vector, pointPatchField, pointMesh> pointVectorField;
 typedef GeometricField<sphericalTensor, pointPatchField, pointMesh>

src/OpenFOAM/fields/pointPatchFields/basic/basicSymmetry/basicSymmetryPointPatchField.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,7 +30,6 @@ License
 #include "transformField.H"
 #include "symmTransformField.H"
 
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class Type>
@@ -87,15 +87,17 @@ void Foam::basicSymmetryPointPatchField<Type>::evaluate
     const Pstream::commsTypes
 )
 {
-    const vectorField& nHat = this->patch().pointNormals();
+    if (pTraits<Type>::rank == 0)
+    {
+        // Transform-invariant types
+        return;
+    }
 
-    tmp<Field<Type>> tvalues =
-    (
-        (
-            this->patchInternalField()
-          + transform(I - 2.0*sqr(nHat), this->patchInternalField())
-        )/2.0
-    );
+    Field<Type> pif(this->patchInternalField());
+
+    symmTensorField rot(I - 2.0*sqr(this->patch().pointNormals()));
+
+    tmp<Field<Type>> tvalues = (pif + transform(rot, pif))/2.0;
 
     // Get internal field to insert values into
     Field<Type>& iF = const_cast<Field<Type>&>(this->primitiveField());

src/OpenFOAM/fields/pointPatchFields/basic/basicSymmetry/basicSymmetryPointPatchField.H

@@ -34,8 +34,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef basicSymmetryPointPatchField_H
-#define basicSymmetryPointPatchField_H
+#ifndef Foam_basicSymmetryPointPatchField_H
+#define Foam_basicSymmetryPointPatchField_H
 
 #include "pointPatchField.H"
 #include "symmetryPointPatch.H"
@@ -54,7 +54,6 @@ class basicSymmetryPointPatchField
 :
     public pointPatchField<Type>
 {
-
 public:
 
     // Constructors

src/OpenFOAM/fields/pointPatchFields/basic/calculated/calculatedPointPatchFields.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,17 +30,12 @@ License
 #include "pointPatchFields.H"
 #include "addToRunTimeSelectionTable.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-makePointPatchFields(calculated);
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
+    makePointPatchFields(calculated);
+    makePointPatchFieldType(label, calculated);
+}
 
 // ************************************************************************* //

src/OpenFOAM/fields/pointPatchFields/basic/calculated/calculatedPointPatchFields.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,11 +26,10 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef calculatedPointPatchFields_H
-#define calculatedPointPatchFields_H
+#ifndef Foam_calculatedPointPatchFields_H
+#define Foam_calculatedPointPatchFields_H
 
 #include "calculatedPointPatchField.H"
-#include "fieldTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -39,6 +39,7 @@ namespace Foam
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 makePointPatchFieldTypedefs(calculated);
+makePointPatchFieldTypedef(label, calculated);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/OpenFOAM/fields/pointPatchFields/basic/coupled/coupledPointPatchFields.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -26,18 +27,15 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "coupledPointPatchFields.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
+#include "pointPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-makePointPatchFieldsTypeName(coupled);
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
+namespace Foam
+{
+    makePointPatchFieldsTypeName(coupled);
+    makePointPatchFieldTypeName(label, coupled);
+}
 
 // ************************************************************************* //

src/OpenFOAM/fields/pointPatchFields/basic/coupled/coupledPointPatchFields.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,12 +26,10 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef coupledPointPatchFields_H
-#define coupledPointPatchFields_H
+#ifndef Foam_coupledPointPatchFields_H
+#define Foam_coupledPointPatchFields_H
 
 #include "coupledPointPatchField.H"
-#include "coupledPointPatch.H"
-#include "fieldTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -40,6 +39,7 @@ namespace Foam
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 makePointPatchFieldTypedefs(coupled);
+makePointPatchFieldTypedef(label, coupled);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/OpenFOAM/fields/pointPatchFields/basic/fixedValue/fixedValuePointPatchField.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -26,7 +27,6 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "fixedValuePointPatchField.H"
-#include "boolList.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -47,10 +47,10 @@ Foam::fixedValuePointPatchField<Type>::fixedValuePointPatchField
     const pointPatch& p,
     const DimensionedField<Type, pointMesh>& iF,
     const dictionary& dict,
-    const bool valueRequired
+    IOobjectOption::readOption requireValue
 )
 :
-    valuePointPatchField<Type>(p, iF, dict, valueRequired)
+    valuePointPatchField<Type>(p, iF, dict, requireValue)
 {}
 
 

src/OpenFOAM/fields/pointPatchFields/basic/fixedValue/fixedValuePointPatchField.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -34,8 +35,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef fixedValuePointPatchField_H
-#define fixedValuePointPatchField_H
+#ifndef Foam_fixedValuePointPatchField_H
+#define Foam_fixedValuePointPatchField_H
 
 #include "valuePointPatchField.H"
 
@@ -53,7 +54,6 @@ class fixedValuePointPatchField
 :
     public valuePointPatchField<Type>
 {
-
 public:
 
     //- Runtime type information
@@ -75,9 +75,25 @@ public:
             const pointPatch&,
             const DimensionedField<Type, pointMesh>&,
             const dictionary&,
-            const bool valueRequired=true
+            IOobjectOption::readOption requireValue = IOobjectOption::MUST_READ
         );
 
+        //- Compatibility. Prefer with readOption
+        fixedValuePointPatchField
+        (
+            const pointPatch& p,
+            const DimensionedField<Type, pointMesh>& iF,
+            const dictionary& dict,
+            const bool valueReqd
+        )
+        :
+            fixedValuePointPatchField
+            (
+                p, iF, dict,
+                (valueReqd? IOobjectOption::MUST_READ : IOobjectOption::NO_READ)
+            )
+        {}
+
         //- Construct by mapping given patch field onto a new patch
         fixedValuePointPatchField
         (

src/OpenFOAM/fields/pointPatchFields/basic/value/valuePointPatchField.C

@@ -84,29 +84,17 @@ Foam::valuePointPatchField<Type>::valuePointPatchField
     const pointPatch& p,
     const DimensionedField<Type, pointMesh>& iF,
     const dictionary& dict,
-    const bool valueRequired
+    IOobjectOption::readOption requireValue
 )
 :
     pointPatchField<Type>(p, iF, dict),
     Field<Type>(p.size())
 {
-    const auto* hasValue = dict.findEntry("value", keyType::LITERAL);
-
-    if (hasValue)
-    {
-        Field<Type>::assign(*hasValue, p.size());
-    }
-    else if (!valueRequired)
+    if (!readValueEntry(dict, requireValue))
     {
+        // Not read (eg, optional and missing): define zero
         Field<Type>::operator=(Zero);
     }
-    else
-    {
-        FatalIOErrorInFunction(dict)
-            << "Essential entry 'value' missing on patch "
-            << p.name() << endl
-            << exit(FatalIOError);
-    }
 }
 
 

src/OpenFOAM/fields/pointPatchFields/basic/value/valuePointPatchField.H

@@ -101,10 +101,27 @@ public:
         (
             const pointPatch&,
             const DimensionedField<Type, pointMesh>&,
-            const dictionary&,
-            const bool valueRequired=true
+            const dictionary& dict,
+            //! The "value" entry (default: mandatory)
+            IOobjectOption::readOption requireValue = IOobjectOption::MUST_READ
         );
 
+        //- Construct, forwarding to readOption variant
+        valuePointPatchField
+        (
+            const pointPatch& p,
+            const DimensionedField<Type, pointMesh>& iF,
+            const dictionary& dict,
+            const bool valueReqd
+        )
+        :
+            valuePointPatchField
+            (
+                p, iF, dict,
+                (valueReqd? IOobjectOption::MUST_READ : IOobjectOption::NO_READ)
+            )
+        {}
+
         //- Construct by mapping given patch field onto a new patch
         valuePointPatchField
         (

src/OpenFOAM/fields/pointPatchFields/basic/value/valuePointPatchFields.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,17 +30,12 @@ License
 #include "pointPatchFields.H"
 #include "addToRunTimeSelectionTable.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-makePointPatchFields(value);
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
+    makePointPatchFields(value);
+    makePointPatchFieldTypeName(label, value);
+}
 
 // ************************************************************************* //

src/OpenFOAM/fields/pointPatchFields/basic/value/valuePointPatchFields.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,11 +26,10 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef valuePointPatchFields_H
-#define valuePointPatchFields_H
+#ifndef Foam_valuePointPatchFields_H
+#define Foam_valuePointPatchFields_H
 
 #include "valuePointPatchField.H"
-#include "fieldTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -39,6 +39,7 @@ namespace Foam
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 makePointPatchFieldTypedefs(value);
+makePointPatchFieldTypedef(label, value);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/OpenFOAM/fields/pointPatchFields/basic/zeroGradient/zeroGradientPointPatchFields.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,17 +30,12 @@ License
 #include "pointPatchFields.H"
 #include "addToRunTimeSelectionTable.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-makePointPatchFields(zeroGradient);
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
+    makePointPatchFields(zeroGradient);
+    makePointPatchFieldType(label, zeroGradient);
+}
 
 // ************************************************************************* //

src/OpenFOAM/fields/pointPatchFields/basic/zeroGradient/zeroGradientPointPatchFields.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,11 +26,10 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef zeroGradientPointPatchFields_H
-#define zeroGradientPointPatchFields_H
+#ifndef Foam_zeroGradientPointPatchFields_H
+#define Foam_zeroGradientPointPatchFields_H
 
 #include "zeroGradientPointPatchField.H"
-#include "fieldTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -39,6 +39,7 @@ namespace Foam
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 makePointPatchFieldTypedefs(zeroGradient);
+makePointPatchFieldTypedef(label, zeroGradient);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/OpenFOAM/fields/pointPatchFields/constraint/empty/emptyPointPatchFields.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,17 +30,12 @@ License
 #include "pointPatchFields.H"
 #include "addToRunTimeSelectionTable.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-makePointPatchFields(empty);
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
+    makePointPatchFieldsTypeName(empty);
+    makePointPatchFieldTypeName(label, empty);
+}
 
 // ************************************************************************* //

src/OpenFOAM/fields/pointPatchFields/constraint/empty/emptyPointPatchFields.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,11 +26,10 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef emptyPointPatchFields_H
-#define emptyPointPatchFields_H
+#ifndef Foam_emptyPointPatchFields_H
+#define Foam_emptyPointPatchFields_H
 
 #include "emptyPointPatchField.H"
-#include "fieldTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -39,6 +39,7 @@ namespace Foam
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 makePointPatchFieldTypedefs(empty);
+makePointPatchFieldTypedef(label, empty);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/OpenFOAM/fields/pointPatchFields/constraint/processor/processorPointPatchFields.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,17 +30,12 @@ License
 #include "pointPatchFields.H"
 #include "addToRunTimeSelectionTable.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-makePointPatchFields(processor);
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
+    makePointPatchFields(processor);
+    makePointPatchFieldType(label, processor);
+}
 
 // ************************************************************************* //

src/OpenFOAM/fields/pointPatchFields/constraint/processor/processorPointPatchFields.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,11 +26,10 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef processorPointPatchFields_H
-#define processorPointPatchFields_H
+#ifndef Foam_processorPointPatchFields_H
+#define Foam_processorPointPatchFields_H
 
 #include "processorPointPatchField.H"
-#include "fieldTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -39,6 +39,7 @@ namespace Foam
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 makePointPatchFieldTypedefs(processor);
+makePointPatchFieldTypedef(label, processor);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/OpenFOAM/fields/pointPatchFields/constraint/symmetry/symmetryPointPatchFields.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,17 +30,12 @@ License
 #include "pointPatchFields.H"
 #include "addToRunTimeSelectionTable.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-makePointPatchFields(symmetry);
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
+    makePointPatchFields(symmetry);
+    makePointPatchFieldType(label, symmetry);
+}
 
 // ************************************************************************* //

src/OpenFOAM/fields/pointPatchFields/constraint/symmetry/symmetryPointPatchFields.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,11 +26,10 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef symmetryPointPatchFields_H
-#define symmetryPointPatchFields_H
+#ifndef Foam_symmetryPointPatchFields_H
+#define Foam_symmetryPointPatchFields_H
 
 #include "symmetryPointPatchField.H"
-#include "fieldTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -39,6 +39,7 @@ namespace Foam
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 makePointPatchFieldTypedefs(symmetry);
+makePointPatchFieldTypedef(label, symmetry);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/OpenFOAM/fields/pointPatchFields/constraint/symmetryPlane/symmetryPlanePointPatchField.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2013-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -106,15 +107,17 @@ void Foam::symmetryPlanePointPatchField<Type>::evaluate
     const Pstream::commsTypes
 )
 {
-    vector nHat = symmetryPlanePatch_.n();
+    if (pTraits<Type>::rank == 0)
+    {
+        // Transform-invariant types
+        return;
+    }
 
-    tmp<Field<Type>> tvalues =
-    (
-        (
-            this->patchInternalField()
-          + transform(I - 2.0*sqr(nHat), this->patchInternalField())
-        )/2.0
-    );
+    Field<Type> pif(this->patchInternalField());
+
+    symmTensor rot(I - 2.0*sqr(symmetryPlanePatch_.n()));
+
+    tmp<Field<Type>> tvalues = (pif + transform(rot, pif))/2.0;
 
     // Get internal field to insert values into
     Field<Type>& iF = const_cast<Field<Type>&>(this->primitiveField());

src/OpenFOAM/fields/pointPatchFields/constraint/symmetryPlane/symmetryPlanePointPatchField.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2013-2017 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -34,8 +35,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef symmetryPlanePointPatchField_H
-#define symmetryPlanePointPatchField_H
+#ifndef Foam_symmetryPlanePointPatchField_H
+#define Foam_symmetryPlanePointPatchField_H
 
 #include "basicSymmetryPointPatchField.H"
 #include "symmetryPlanePointPatch.H"
@@ -54,7 +55,7 @@ class symmetryPlanePointPatchField
 :
     public basicSymmetryPointPatchField<Type>
 {
-    // Private data
+    // Private Data
 
         //- Local reference cast into the symmetryPlane patch
         const symmetryPlanePointPatch& symmetryPlanePatch_;

src/OpenFOAM/fields/pointPatchFields/constraint/symmetryPlane/symmetryPlanePointPatchFields.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2013 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,17 +30,13 @@ License
 #include "pointPatchFields.H"
 #include "addToRunTimeSelectionTable.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
+    makePointPatchFields(symmetryPlane);
+    makePointPatchFieldType(label, symmetryPlane);
+}
 
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-makePointPatchFields(symmetryPlane);
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
 
 // ************************************************************************* //

src/OpenFOAM/fields/pointPatchFields/constraint/symmetryPlane/symmetryPlanePointPatchFields.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2013 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,11 +26,10 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef symmetryPlanePointPatchFields_H
-#define symmetryPlanePointPatchFields_H
+#ifndef Foam_symmetryPlanePointPatchFields_H
+#define Foam_symmetryPlanePointPatchFields_H
 
 #include "symmetryPlanePointPatchField.H"
-#include "fieldTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -39,6 +39,7 @@ namespace Foam
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 makePointPatchFieldTypedefs(symmetryPlane);
+makePointPatchFieldTypedef(label, symmetryPlane);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/OpenFOAM/fields/pointPatchFields/constraint/wedge/wedgePointPatchField.C

@@ -28,7 +28,6 @@ License
 #include "wedgePointPatchField.H"
 #include "transformField.H"
 
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class Type>
@@ -101,12 +100,18 @@ Foam::wedgePointPatchField<Type>::wedgePointPatchField
 template<class Type>
 void Foam::wedgePointPatchField<Type>::evaluate(const Pstream::commsTypes)
 {
+    // label, scalar, sphericalTensor are rotationally invariant
+    if (pTraits<Type>::rank == 0 || std::is_same<sphericalTensor, Type>::value)
+    {
+        return;
+    }
+
     // In order to ensure that the wedge patch is always flat, take the
     // normal vector from the first point
-    const vector& nHat = this->patch().pointNormals()[0];
 
-    tmp<Field<Type>> tvalues =
-        transform(I - nHat*nHat, this->patchInternalField());
+    symmTensor rot(I - sqr(this->patch().pointNormals()[0]));
+
+    tmp<Field<Type>> tvalues = transform(rot, this->patchInternalField());
 
     // Get internal field to insert values into
     Field<Type>& iF = const_cast<Field<Type>&>(this->primitiveField());

src/OpenFOAM/fields/pointPatchFields/constraint/wedge/wedgePointPatchFields.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,17 +30,13 @@ License
 #include "pointPatchFields.H"
 #include "addToRunTimeSelectionTable.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
+    makePointPatchFields(wedge);
+    makePointPatchFieldType(label, wedge);
+}
 
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-makePointPatchFields(wedge);
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
 
 // ************************************************************************* //

src/OpenFOAM/fields/pointPatchFields/constraint/wedge/wedgePointPatchFields.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,11 +26,10 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef wedgePointPatchFields_H
-#define wedgePointPatchFields_H
+#ifndef Foam_wedgePointPatchFields_H
+#define Foam_wedgePointPatchFields_H
 
 #include "wedgePointPatchField.H"
-#include "fieldTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -39,6 +39,7 @@ namespace Foam
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 makePointPatchFieldTypedefs(wedge);
+makePointPatchFieldTypedef(label, wedge);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/OpenFOAM/fields/pointPatchFields/derived/codedFixedValue/codedFixedValuePointPatchField.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2012-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2021 OpenCFD Ltd.
+    Copyright (C) 2016-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -161,11 +161,11 @@ Foam::codedFixedValuePointPatchField<Type>::codedFixedValuePointPatchField
 (
     const pointPatch& p,
     const DimensionedField<Type, pointMesh>& iF,
-    const dictionary& dict,
-    const bool valueRequired
+    const dictionary& dict
 )
 :
-    parent_bctype(p, iF, dict, false),
+    // The 'value' is optional (handled below)
+    parent_bctype(p, iF, dict, IOobjectOption::NO_READ),
     codedBase(),
     dict_
     (
@@ -186,10 +186,7 @@ Foam::codedFixedValuePointPatchField<Type>::codedFixedValuePointPatchField
 {
     updateLibrary(name_);
 
-    // Note: 'value' is used even with valueRequired = false ! This is
-    // inconsistent with fixedValueFvPatchField behaviour.
-
-    if (!dict.found("value")) // Q: check for valueRequired?
+    if (!this->readValueEntry(dict))
     {
         // Evaluate to assign a value
         this->evaluate(Pstream::commsTypes::blocking);

src/OpenFOAM/fields/pointPatchFields/derived/codedFixedValue/codedFixedValuePointPatchField.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2012-2017 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -100,8 +100,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef codedFixedValuePointPatchField_H
-#define codedFixedValuePointPatchField_H
+#ifndef Foam_codedFixedValuePointPatchField_H
+#define Foam_codedFixedValuePointPatchField_H
 
 #include "fixedValuePointPatchFields.H"
 #include "codedBase.H"
@@ -187,8 +187,7 @@ public:
         (
             const pointPatch&,
             const DimensionedField<Type, pointMesh>&,
-            const dictionary&,
-            const bool valueRequired=true
+            const dictionary&
         );
 
         //- Construct by mapping given codedFixedValuePointPatchField

src/OpenFOAM/fields/pointPatchFields/derived/slip/slipPointPatchFields.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,17 +30,12 @@ License
 #include "pointPatchFields.H"
 #include "addToRunTimeSelectionTable.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-makePointPatchFields(slip);
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
+    makePointPatchFields(slip);
+    makePointPatchFieldType(label, slip);
+}
 
 // ************************************************************************* //

src/OpenFOAM/fields/pointPatchFields/derived/slip/slipPointPatchFields.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,11 +26,10 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef slipPointPatchFields_H
-#define slipPointPatchFields_H
+#ifndef Foam_slipPointPatchFields_H
+#define Foam_slipPointPatchFields_H
 
 #include "slipPointPatchField.H"
-#include "fieldTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -39,6 +39,7 @@ namespace Foam
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 makePointPatchFieldTypedefs(slip);
+makePointPatchFieldTypedef(label, slip);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

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

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2022 OpenCFD Ltd.
+    Copyright (C) 2022-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.

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

@@ -37,6 +37,7 @@ namespace Foam
     defineTemplateRunTimeSelectionTable(PatchTypeField, patchMapper);         \
     defineTemplateRunTimeSelectionTable(PatchTypeField, dictionary);
 
+makePointPatchField(pointPatchLabelField);
 makePointPatchField(pointPatchScalarField);
 makePointPatchField(pointPatchVectorField);
 makePointPatchField(pointPatchSphericalTensorField);

src/OpenFOAM/fields/pointPatchFields/pointPatchField/pointPatchFields.H

@@ -31,8 +31,6 @@ License
 #include "pointPatchField.H"
 #include "pointPatchFieldsFwd.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 #endif
 
 // ************************************************************************* //

src/OpenFOAM/fields/pointPatchFields/pointPatchField/pointPatchFieldsFwd.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -39,6 +40,7 @@ namespace Foam
 
 template<class Type> class pointPatchField;
 
+typedef pointPatchField<label> pointPatchLabelField;
 typedef pointPatchField<scalar> pointPatchScalarField;
 typedef pointPatchField<vector> pointPatchVectorField;
 typedef pointPatchField<sphericalTensor> pointPatchSphericalTensorField;

src/OpenFOAM/meshes/boundBox/boundBox.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2022 OpenCFD Ltd.
+    Copyright (C) 2016-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -163,6 +163,9 @@ public:
         //- Construct a bounding box containing a single initial point
         inline explicit boundBox(const point& p);
 
+        //- Construct a 0/1 unit bounding box
+        inline explicit boundBox(const Foam::zero_one);
+
         //- Construct from bound box min/max points
         inline boundBox(const point& min, const point& max);
 
@@ -291,6 +294,9 @@ public:
             //- Reset to an inverted box
             inline void reset();
 
+            //- Reset to a 0/1 unit bounding box
+            inline void reset(const Foam::zero_one);
+
             //- Reset min/max to be identical to the specified point
             inline void reset(const point& pt);
 

src/OpenFOAM/meshes/boundBox/boundBoxI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2022 OpenCFD Ltd.
+    Copyright (C) 2016-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -112,6 +112,13 @@ inline Foam::boundBox::boundBox()
 {}
 
 
+inline Foam::boundBox::boundBox(const Foam::zero_one)
+:
+    min_(point::zero),
+    max_(point::one)
+{}
+
+
 inline Foam::boundBox::boundBox(const point& p)
 :
     min_(p),
@@ -299,6 +306,13 @@ inline void Foam::boundBox::reset()
 }
 
 
+inline void Foam::boundBox::reset(const Foam::zero_one)
+{
+    min_ = point::zero;
+    max_ = point::one;
+}
+
+
 inline void Foam::boundBox::reset(const point& pt)
 {
     min_ = pt;

src/OpenFOAM/meshes/ijkMesh/ijkAddressing.H

@@ -34,8 +34,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef ijkAddressing_H
-#define ijkAddressing_H
+#ifndef Foam_ijkAddressing_H
+#define Foam_ijkAddressing_H
 
 #include "labelVector.H"
 #include "vector.H"

src/OpenFOAM/meshes/ijkMesh/ijkMesh.H

@@ -38,8 +38,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef ijkMesh_H
-#define ijkMesh_H
+#ifndef Foam_ijkMesh_H
+#define Foam_ijkMesh_H
 
 #include "ijkAddressing.H"
 

src/OpenFOAM/meshes/polyMesh/globalMeshData/globalMeshData.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2015-2022 OpenCFD Ltd.
+    Copyright (C) 2015-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -2721,8 +2721,7 @@ void Foam::globalMeshData::updateMesh()
         identity(UPstream::nProcs(UPstream::worldComm)),
         true
     );
-    const label oldWarnComm = UPstream::warnComm;
-    UPstream::warnComm = comm;
+    const label oldWarnComm = UPstream::commWarn(comm);
 
 
     // Total number of faces.
@@ -2760,8 +2759,9 @@ void Foam::globalMeshData::updateMesh()
         comm
     );
 
+    // Restore communicator settings
     UPstream::freeCommunicator(comm);
-    UPstream::warnComm = oldWarnComm;
+    UPstream::commWarn(oldWarnComm);
 
     if (debug)
     {

src/OpenFOAM/meshes/primitiveMesh/primitiveMeshCellPoints.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,6 +29,7 @@ License
 #include "primitiveMesh.H"
 #include "cell.H"
 #include "bitSet.H"
+#include "DynamicList.H"
 #include "ListOps.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
@@ -57,12 +58,51 @@ void Foam::primitiveMesh::calcCellPoints() const
             << "cellPoints already calculated"
             << abort(FatalError);
     }
-    else
+    else if (hasPointCells())
     {
         // Invert pointCells
         cpPtr_ = new labelListList(nCells());
         invertManyToMany(nCells(), pointCells(), *cpPtr_);
     }
+    else
+    {
+        // Calculate cell-point topology
+
+        cpPtr_ = new labelListList(nCells());
+        auto& cellPointAddr = *cpPtr_;
+
+        const cellList& cellLst = cells();
+        const faceList& faceLst = faces();
+
+        // Tracking (only use each point id once)
+        bitSet usedPoints(nPoints());
+
+        // Vertex labels for the current cell
+        DynamicList<label> currPoints(256);
+
+        const label loopLen = nCells();
+
+        for (label celli = 0; celli < loopLen; ++celli)
+        {
+            // Clear any previous contents
+            usedPoints.unset(currPoints);
+            currPoints.clear();
+
+            for (const label facei : cellLst[celli])
+            {
+                for (const label pointi : faceLst[facei])
+                {
+                    // Only once for each point id
+                    if (usedPoints.set(pointi))
+                    {
+                        currPoints.push_back(pointi);
+                    }
+                }
+            }
+
+            cellPointAddr[celli] = currPoints;  // NB: unsorted
+        }
+    }
 }
 
 

src/OpenFOAM/meshes/primitiveMesh/primitiveMeshPointCells.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -28,14 +29,13 @@ License
 #include "primitiveMesh.H"
 #include "cell.H"
 #include "bitSet.H"
+#include "DynamicList.H"
 #include "ListOps.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 void Foam::primitiveMesh::calcPointCells() const
 {
-    // Loop through cells and mark up points
-
     if (debug)
     {
         Pout<< "primitiveMesh::calcPointCells() : "
@@ -59,48 +59,128 @@ void Foam::primitiveMesh::calcPointCells() const
             << "pointCells already calculated"
             << abort(FatalError);
     }
+    else if (hasCellPoints())
+    {
+        // Invert cellPoints
+        pcPtr_ = new labelListList(nPoints());
+        invertManyToMany(nPoints(), cellPoints(), *pcPtr_);
+    }
+    else if (hasPointFaces())
+    {
+        // Calculate point-cell from point-face information
+
+        const labelList& own = faceOwner();
+        const labelList& nei = faceNeighbour();
+        const labelListList& pFaces = pointFaces();
+
+        // Tracking (only use each cell id once)
+        bitSet usedCells(nCells());
+
+        // Cell ids for the point currently being processed
+        DynamicList<label> currCells(256);
+
+        const label loopLen = nPoints();
+
+        pcPtr_ = new labelListList(nPoints());
+        auto& pointCellAddr = *pcPtr_;
+
+        for (label pointi = 0; pointi < loopLen; ++pointi)
+        {
+            // Clear any previous contents
+            usedCells.unset(currCells);
+            currCells.clear();
+
+            for (const label facei : pFaces[pointi])
+            {
+                // Owner cell - only allow one occurance
+                if (usedCells.set(own[facei]))
+                {
+                    currCells.push_back(own[facei]);
+                }
+
+                // Neighbour cell - only allow one occurance
+                if (facei < nInternalFaces())
+                {
+                    if (usedCells.set(nei[facei]))
+                    {
+                        currCells.push_back(nei[facei]);
+                    }
+                }
+            }
+
+            pointCellAddr[pointi] = currCells;  // NB: unsorted
+        }
+    }
     else
     {
-        const cellList& cf = cells();
+        // Calculate point-cell topology
 
-        // Count number of cells per point
+        const cellList& cellLst = cells();
+        const faceList& faceLst = faces();
 
-        labelList npc(nPoints(), Zero);
+        // Tracking (only use each point id once)
+        bitSet usedPoints(nPoints());
 
-        forAll(cf, celli)
+        // Which of usedPoints needs to be unset [faster]
+        DynamicList<label> currPoints(256);
+
+        const label loopLen = nCells();
+
+        // Step 1: count number of cells per point
+
+        labelList pointCount(nPoints(), Zero);
+
+        for (label celli = 0; celli < loopLen; ++celli)
         {
-            const labelList curPoints = cf[celli].labels(faces());
+            // Clear any previous contents
+            usedPoints.unset(currPoints);
+            currPoints.clear();
 
-            forAll(curPoints, pointi)
+            for (const label facei : cellLst[celli])
             {
-                label ptI = curPoints[pointi];
-
-                npc[ptI]++;
+                for (const label pointi : faceLst[facei])
+                {
+                    // Only once for each point id
+                    if (usedPoints.set(pointi))
+                    {
+                        currPoints.push_back(pointi);  // Needed for cleanup
+                        ++pointCount[pointi];
+                    }
+                }
             }
         }
 
 
-        // Size and fill cells per point
+        // Step 2: set sizing, reset counters
 
-        pcPtr_ = new labelListList(npc.size());
-        labelListList& pointCellAddr = *pcPtr_;
+        pcPtr_ = new labelListList(nPoints());
+        auto& pointCellAddr = *pcPtr_;
 
         forAll(pointCellAddr, pointi)
         {
-            pointCellAddr[pointi].setSize(npc[pointi]);
+            pointCellAddr[pointi].resize_nocopy(pointCount[pointi]);
+            pointCount[pointi] = 0;
         }
-        npc = 0;
 
 
-        forAll(cf, celli)
+        // Step 3: fill in values. Logic as per step 1
+        for (label celli = 0; celli < loopLen; ++celli)
         {
-            const labelList curPoints = cf[celli].labels(faces());
+            // Clear any previous contents
+            usedPoints.unset(currPoints);
+            currPoints.clear();
 
-            forAll(curPoints, pointi)
+            for (const label facei : cellLst[celli])
             {
-                label ptI = curPoints[pointi];
-
-                pointCellAddr[ptI][npc[ptI]++] = celli;
+                for (const label pointi : faceLst[facei])
+                {
+                    // Only once for each point id
+                    if (usedPoints.set(pointi))
+                    {
+                        currPoints.push_back(pointi);  // Needed for cleanup
+                        pointCellAddr[pointi][pointCount[pointi]++] = celli;
+                    }
+                }
             }
         }
     }
@@ -154,12 +234,8 @@ const Foam::labelList& Foam::primitiveMesh::pointCells
         if (storage.size() > 1)
         {
             std::sort(storage.begin(), storage.end());
-
             auto last = std::unique(storage.begin(), storage.end());
-
-            const label newLen = label(last - storage.begin());
-
-            storage.resize(newLen);
+            storage.resize(label(last - storage.begin()));
         }
 
         return storage;

src/OpenFOAM/meshes/treeBoundBox/treeBoundBox.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2022 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -201,6 +201,9 @@ public:
 
     // Constructors
 
+        //- Construct a 0/1 unit bounding box
+        inline explicit treeBoundBox(const Foam::zero_one);
+
         //- Construct a bounding box containing a single initial point
         inline explicit treeBoundBox(const point& p);
 

src/OpenFOAM/meshes/treeBoundBox/treeBoundBoxI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
-    Copyright (C) 2017-2022 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -31,6 +31,12 @@ License
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
+inline Foam::treeBoundBox::treeBoundBox(const Foam::zero_one)
+:
+    boundBox(zero_one{})
+{}
+
+
 inline Foam::treeBoundBox::treeBoundBox(const point& p)
 :
     boundBox(p)

src/Pstream/mpi/UIPstreamRead.C

@@ -114,7 +114,7 @@ Foam::label Foam::UIPstream::read
             << " commsType:" << UPstream::commsTypeNames[commsType]
             << Foam::endl;
     }
-    if (UPstream::warnComm != -1 && communicator != UPstream::warnComm)
+    if (UPstream::warnComm >= 0 && communicator != UPstream::warnComm)
     {
         Pout<< "UIPstream::read : starting read from:" << fromProcNo
             << " tag:" << tag << " comm:" << communicator

src/Pstream/mpi/UOPstreamWrite.C

@@ -68,7 +68,7 @@ bool Foam::UOPstream::write
             << " commType:" << UPstream::commsTypeNames[commsType]
             << Foam::endl;
     }
-    if (UPstream::warnComm != -1 && communicator != UPstream::warnComm)
+    if (UPstream::warnComm >= 0 && communicator != UPstream::warnComm)
     {
         Pout<< "UOPstream::write : starting write to:" << toProcNo
             << " tag:" << tag

src/Pstream/mpi/UPstreamBroadcast.C

@@ -54,7 +54,7 @@ bool Foam::UPstream::broadcast
             << " size:" << label(bufSize)
             << Foam::endl;
     }
-    if (UPstream::warnComm != -1 && comm != UPstream::warnComm)
+    if (UPstream::warnComm >= 0 && comm != UPstream::warnComm)
     {
         Pout<< "UPstream::broadcast : root:" << rootProcNo
             << " comm:" << comm

src/Pstream/mpi/UPstreamWrappingTemplates.C

@@ -78,7 +78,7 @@ void Foam::PstreamDetail::reduce0
         return;
     }
 
-    if (UPstream::warnComm != -1 && comm != UPstream::warnComm)
+    if (UPstream::warnComm >= 0 && comm != UPstream::warnComm)
     {
         Pout<< "** reducing:";
         if (count == 1)
@@ -135,7 +135,7 @@ void Foam::PstreamDetail::allReduce
 
     const bool immediate = (req || requestID);
 
-    if (UPstream::warnComm != -1 && comm != UPstream::warnComm)
+    if (UPstream::warnComm >= 0 && comm != UPstream::warnComm)
     {
         if (immediate)
         {
@@ -246,7 +246,7 @@ void Foam::PstreamDetail::allToAll
 
     const label numProc = UPstream::nProcs(comm);
 
-    if (UPstream::warnComm != -1 && comm != UPstream::warnComm)
+    if (UPstream::warnComm >= 0 && comm != UPstream::warnComm)
     {
         if (immediate)
         {
@@ -383,7 +383,7 @@ void Foam::PstreamDetail::allToAllv
 
     const label np = UPstream::nProcs(comm);
 
-    if (UPstream::warnComm != -1 && comm != UPstream::warnComm)
+    if (UPstream::warnComm >= 0 && comm != UPstream::warnComm)
     {
         if (immediate)
         {
@@ -531,7 +531,7 @@ void Foam::PstreamDetail::allToAllConsensus
     const label myProci = UPstream::myProcNo(comm);
     const label numProc = UPstream::nProcs(comm);
 
-    if (UPstream::warnComm != -1 && comm != UPstream::warnComm)
+    if (UPstream::warnComm >= 0 && comm != UPstream::warnComm)
     {
         Pout<< "** non-blocking consensus Alltoall (list):";
         Pout<< " numProc:" << numProc
@@ -717,7 +717,7 @@ void Foam::PstreamDetail::allToAllConsensus
     const label myProci = UPstream::myProcNo(comm);
     const label numProc = UPstream::nProcs(comm);
 
-    if (UPstream::warnComm != -1 && comm != UPstream::warnComm)
+    if (UPstream::warnComm >= 0 && comm != UPstream::warnComm)
     {
         Pout<< "** non-blocking consensus Alltoall (map):";
         Pout<< " numProc:" << numProc
@@ -911,7 +911,7 @@ void Foam::PstreamDetail::gather
 
     const label np = UPstream::nProcs(comm);
 
-    if (UPstream::warnComm != -1 && comm != UPstream::warnComm)
+    if (UPstream::warnComm >= 0 && comm != UPstream::warnComm)
     {
         if (immediate)
         {
@@ -1037,7 +1037,7 @@ void Foam::PstreamDetail::scatter
 
     const label np = UPstream::nProcs(comm);
 
-    if (UPstream::warnComm != -1 && comm != UPstream::warnComm)
+    if (UPstream::warnComm >= 0 && comm != UPstream::warnComm)
     {
         if (immediate)
         {
@@ -1165,7 +1165,7 @@ void Foam::PstreamDetail::gatherv
 
     const label np = UPstream::nProcs(comm);
 
-    if (UPstream::warnComm != -1 && comm != UPstream::warnComm)
+    if (UPstream::warnComm >= 0 && comm != UPstream::warnComm)
     {
         if (immediate)
         {
@@ -1317,7 +1317,7 @@ void Foam::PstreamDetail::scatterv
 
     const label np = UPstream::nProcs(comm);
 
-    if (UPstream::warnComm != -1 && comm != UPstream::warnComm)
+    if (UPstream::warnComm >= 0 && comm != UPstream::warnComm)
     {
         if (immediate)
         {

src/TurbulenceModels/turbulenceModels/derivedFvPatchFields/fixedShearStress/fixedShearStressFvPatchVectorField.C

@@ -53,7 +53,7 @@ Foam::fixedShearStressFvPatchVectorField::fixedShearStressFvPatchVectorField
     const dictionary& dict
 )
 :
-    fixedValueFvPatchVectorField(p, iF, dict, false),
+    fixedValueFvPatchVectorField(p, iF, dict, IOobjectOption::NO_READ),
     tau0_(dict.getOrDefault<vector>("tau", Zero))
 {
     fvPatchField<vector>::operator=(patchInternalField());

src/TurbulenceModels/turbulenceModels/derivedFvPatchFields/porousBafflePressure/porousBafflePressureFvPatchField.C

@@ -67,14 +67,7 @@ Foam::porousBafflePressureFvPatchField::porousBafflePressureFvPatchField
 {
     if (valueRequired)
     {
-        if (dict.found("value"))
-        {
-            fvPatchField<scalar>::operator=
-            (
-                Field<scalar>("value", dict, p.size())
-            );
-        }
-        else
+        if (!this->readValueEntry(dict))
         {
             this->evaluate(Pstream::commsTypes::blocking);
         }

src/atmosphericModels/derivedFvPatchFields/atmTurbulentHeatFluxTemperature/atmTurbulentHeatFluxTemperatureFvPatchScalarField.C

@@ -92,7 +92,7 @@ atmTurbulentHeatFluxTemperatureFvPatchScalarField
     const dictionary& dict
 )
 :
-    fixedGradientFvPatchScalarField(p, iF),
+    fixedGradientFvPatchScalarField(p, iF),  // Bypass dictionary constructor
     heatSource_
     (
         heatSourceTypeNames.getOrDefault
@@ -106,13 +106,11 @@ atmTurbulentHeatFluxTemperatureFvPatchScalarField
     Cp0_(Function1<scalar>::New("Cp0", dict, &db())),
     q_(PatchFunction1<scalar>::New(p.patch(), "q", dict))
 {
-    if (dict.found("value") && dict.found("gradient"))
+    const auto* hasGrad = dict.findEntry("gradient", keyType::LITERAL);
+
+    if (hasGrad && this->readValueEntry(dict))
     {
-        fvPatchField<scalar>::operator =
-            (
-                Field<scalar>("value", dict, p.size())
-            );
-        gradient() = Field<scalar>("gradient", dict, p.size());
+        gradient().assign(*hasGrad, p.size());
     }
     else
     {

src/dynamicFaMesh/interfaceTrackingFvMesh/fvPatchFields/freeSurfacePressure/freeSurfacePressureFvPatchScalarField.C

@@ -56,17 +56,10 @@ freeSurfacePressureFvPatchScalarField
     const dictionary& dict
 )
 :
-    fixedValueFvPatchScalarField(p, iF, dict, false),
+    fixedValueFvPatchScalarField(p, iF, dict, IOobjectOption::NO_READ),
     pa_("pa", dict, p.size())
 {
-    if (dict.found("value"))
-    {
-        fvPatchScalarField::operator=
-        (
-            scalarField("value", dict, p.size())
-        );
-    }
-    else
+    if (!this->readValueEntry(dict))
     {
         fvPatchField<scalar>::operator=(pa_);
     }

src/finiteArea/Make/files

@@ -44,6 +44,7 @@ $(faPatchFields)/faPatchField/faPatchFields.C
 basicFaPatchFields = $(faPatchFields)/basic
 $(basicFaPatchFields)/basicSymmetry/basicSymmetryFaPatchFields.C
 $(basicFaPatchFields)/calculated/calculatedFaPatchFields.C
+$(basicFaPatchFields)/extrapolatedCalculated/extrapolatedCalculatedFaPatchFields.C
 $(basicFaPatchFields)/coupled/coupledFaPatchFields.C
 $(basicFaPatchFields)/zeroGradient/zeroGradientFaPatchFields.C
 $(basicFaPatchFields)/fixedValue/fixedValueFaPatchFields.C
@@ -62,9 +63,13 @@ $(constraintFaPatchFields)/symmetry/symmetryFaPatchFields.C
 derivedFaPatchFields = $(faPatchFields)/derived
 $(derivedFaPatchFields)/fixedValueOutflow/fixedValueOutflowFaPatchFields.C
 $(derivedFaPatchFields)/inletOutlet/inletOutletFaPatchFields.C
+$(derivedFaPatchFields)/outletInlet/outletInletFaPatchFields.C
 $(derivedFaPatchFields)/slip/slipFaPatchFields.C
 $(derivedFaPatchFields)/edgeNormalFixedValue/edgeNormalFixedValueFaPatchVectorField.C
 $(derivedFaPatchFields)/timeVaryingUniformFixedValue/timeVaryingUniformFixedValueFaPatchFields.C
+$(derivedFaPatchFields)/uniformFixedGradient/uniformFixedGradientFaPatchFields.C
+$(derivedFaPatchFields)/uniformFixedValue/uniformFixedValueFaPatchFields.C
+$(derivedFaPatchFields)/uniformMixed/uniformMixedFaPatchFields.C
 $(derivedFaPatchFields)/clampedPlate/clampedPlateFaPatchFields.C
 
 faePatchFields = fields/faePatchFields

src/finiteArea/fields/areaFields/areaFields.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016-2017 Wikki Ltd
-    Copyright (C) 2018-2022 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -34,12 +34,14 @@ License
 namespace Foam
 {
 
+defineTemplateTypeNameAndDebug(areaLabelField::Internal, 0);
 defineTemplateTypeNameAndDebug(areaScalarField::Internal, 0);
 defineTemplateTypeNameAndDebug(areaVectorField::Internal, 0);
 defineTemplateTypeNameAndDebug(areaSphericalTensorField::Internal, 0);
 defineTemplateTypeNameAndDebug(areaSymmTensorField::Internal, 0);
 defineTemplateTypeNameAndDebug(areaTensorField::Internal, 0);
 
+defineTemplateTypeNameAndDebug(areaLabelField, 0);
 defineTemplateTypeNameAndDebug(areaScalarField, 0);
 defineTemplateTypeNameAndDebug(areaVectorField, 0);
 defineTemplateTypeNameAndDebug(areaSphericalTensorField, 0);

src/finiteArea/fields/areaFields/areaFieldsFwd.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016-2017 Wikki Ltd
-    Copyright (C) 2018-2022 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -75,6 +75,7 @@ using AreaInternalField = DimensionedField<Type, areaMesh>;
 
 // Typedefs
 
+typedef GeometricField<label, faPatchField, areaMesh> areaLabelField;
 typedef GeometricField<scalar, faPatchField, areaMesh> areaScalarField;
 typedef GeometricField<vector, faPatchField, areaMesh> areaVectorField;
 typedef GeometricField<sphericalTensor, faPatchField, areaMesh>

src/finiteArea/fields/edgeFields/edgeFields.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016-2017 Wikki Ltd
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -33,12 +34,14 @@ License
 namespace Foam
 {
 
+defineTemplateTypeNameAndDebug(edgeLabelField::Internal, 0);
 defineTemplateTypeNameAndDebug(edgeScalarField::Internal, 0);
 defineTemplateTypeNameAndDebug(edgeVectorField::Internal, 0);
 defineTemplateTypeNameAndDebug(edgeSphericalTensorField::Internal, 0);
 defineTemplateTypeNameAndDebug(edgeSymmTensorField::Internal, 0);
 defineTemplateTypeNameAndDebug(edgeTensorField::Internal, 0);
 
+defineTemplateTypeNameAndDebug(edgeLabelField, 0);
 defineTemplateTypeNameAndDebug(edgeScalarField, 0);
 defineTemplateTypeNameAndDebug(edgeVectorField, 0);
 defineTemplateTypeNameAndDebug(edgeSphericalTensorField, 0);

src/finiteArea/fields/edgeFields/edgeFieldsFwd.H

@@ -60,6 +60,7 @@ template<class Type> class faePatchField;
 
 // Typedefs
 
+typedef GeometricField<label, faePatchField, edgeMesh> edgeLabelField;
 typedef GeometricField<scalar, faePatchField, edgeMesh> edgeScalarField;
 typedef GeometricField<vector, faePatchField, edgeMesh> edgeVectorField;
 typedef GeometricField<sphericalTensor, faePatchField, edgeMesh>

src/finiteArea/fields/faPatchFields/basic/basicSymmetry/basicSymmetryFaPatchField.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016-2017 Wikki Ltd
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -95,13 +96,23 @@ template<class Type>
 Foam::tmp<Foam::Field<Type>>
 Foam::basicSymmetryFaPatchField<Type>::snGrad() const
 {
-    const vectorField nHat(this->patch().edgeNormals());
+    if (pTraits<Type>::rank == 0)
+    {
+        // Transform-invariant types
+        return tmp<Field<Type>>::New(this->size(), Zero);
+    }
+    else
+    {
+        symmTensorField rot(I - 2.0*sqr(this->patch().edgeNormals()));
 
-    return
-    (
-        transform(I - 2.0*sqr(nHat), this->patchInternalField())
-      - this->patchInternalField()
-    )*(this->patch().deltaCoeffs()/2.0);
+        Field<Type> pif(this->patchInternalField());
+
+        return
+        (
+            (transform(rot, pif) - pif)
+          * (this->patch().deltaCoeffs()/2.0)
+        );
+    }
 }
 
 
@@ -113,14 +124,19 @@ void Foam::basicSymmetryFaPatchField<Type>::evaluate(const Pstream::commsTypes)
         this->updateCoeffs();
     }
 
-    const vectorField nHat(this->patch().edgeNormals());
-    Field<Type>::operator=
-    (
-        (
-            this->patchInternalField()
-          + transform(I - 2.0*sqr(nHat), this->patchInternalField())
-        )/2.0
-    );
+    if (pTraits<Type>::rank == 0)
+    {
+        // Transform-invariant types
+        Field<Type>::operator=(this->patchInternalField());
+    }
+    else
+    {
+        symmTensorField rot(I - 2.0*sqr(this->patch().edgeNormals()));
+
+        Field<Type> pif(this->patchInternalField());
+
+        Field<Type>::operator=((pif + transform(rot, pif))/2.0);
+    }
 
     transformFaPatchField<Type>::evaluate();
 }

src/finiteArea/fields/faPatchFields/basic/basicSymmetry/basicSymmetryFaPatchField.H

@@ -38,8 +38,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef basicSymmetryFaPatchField_H
-#define basicSymmetryFaPatchField_H
+#ifndef Foam_basicSymmetryFaPatchField_H
+#define Foam_basicSymmetryFaPatchField_H
 
 #include "transformFaPatchField.H"
 #include "symmetryFaPatch.H"
@@ -58,7 +58,6 @@ class basicSymmetryFaPatchField
 :
     public transformFaPatchField<Type>
 {
-
 public:
 
     // Constructors
@@ -71,6 +70,7 @@ public:
         );
 
         //- Construct from patch, internal field and dictionary
+        //  The "value" entry: NO_READ
         basicSymmetryFaPatchField
         (
             const faPatch&,
@@ -78,7 +78,8 @@ public:
             const dictionary&
         );
 
-        //- Construct by mapping given basicSymmetryFaPatchField onto a new patch
+        //- Construct by mapping given basicSymmetryFaPatchField
+        //- onto a new patch
         basicSymmetryFaPatchField
         (
             const basicSymmetryFaPatchField<Type>&,
@@ -130,8 +131,6 @@ public:
             virtual tmp<Field<Type>> snGrad() const;
 
             //- Evaluate the patch field
-            //  Default argument needed to allow call in constructors
-            //  HJ, 30/Jun/2009
             virtual void evaluate
             (
                 const Pstream::commsTypes commsType = Pstream::commsTypes::blocking
@@ -142,18 +141,6 @@ public:
 };
 
 
-// * * * * * * * * * * * Template Specialisations  * * * * * * * * * * * * * //
-
-template<>
-tmp<scalarField> basicSymmetryFaPatchField<scalar>::snGrad() const;
-
-template<>
-void basicSymmetryFaPatchField<scalar>::evaluate
-(
-    const Pstream::commsTypes commsType
-);
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

src/finiteArea/fields/faPatchFields/basic/basicSymmetry/basicSymmetryFaPatchFields.C

@@ -32,28 +32,4 @@ License
 
 // * * * * * * * * * * * * * * * Specialisations * * * * * * * * * * * * * * //
 
-template<>
-Foam::tmp<Foam::scalarField>
-Foam::basicSymmetryFaPatchField<Foam::scalar>::snGrad() const
-{
-    return tmp<scalarField>::New(size(), Zero);
-}
-
-
-template<>
-void Foam::basicSymmetryFaPatchField<Foam::scalar>::evaluate
-(
-    const Pstream::commsTypes
-)
-{
-    if (!updated())
-    {
-        updateCoeffs();
-    }
-
-    scalarField::operator=(patchInternalField());
-    transformFaPatchField<scalar>::evaluate();
-}
-
-
 // ************************************************************************* //

src/finiteArea/fields/faPatchFields/basic/calculated/calculatedFaPatchField.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016-2017 Wikki Ltd
-    Copyright (C) 2021 OpenCFD Ltd.
+    Copyright (C) 2021-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -38,7 +38,7 @@ const Foam::word& Foam::faPatchField<Type>::calculatedType()
 }
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class Type>
 Foam::calculatedFaPatchField<Type>::calculatedFaPatchField
@@ -51,6 +51,19 @@ Foam::calculatedFaPatchField<Type>::calculatedFaPatchField
 {}
 
 
+template<class Type>
+Foam::calculatedFaPatchField<Type>::calculatedFaPatchField
+(
+    const faPatch& p,
+    const DimensionedField<Type, areaMesh>& iF,
+    const dictionary& dict,
+    IOobjectOption::readOption valueRequired
+)
+:
+    faPatchField<Type>(p, iF, dict, valueRequired)
+{}
+
+
 template<class Type>
 Foam::calculatedFaPatchField<Type>::calculatedFaPatchField
 (
@@ -64,18 +77,6 @@ Foam::calculatedFaPatchField<Type>::calculatedFaPatchField
 {}
 
 
-template<class Type>
-Foam::calculatedFaPatchField<Type>::calculatedFaPatchField
-(
-    const faPatch& p,
-    const DimensionedField<Type, areaMesh>& iF,
-    const dictionary& dict
-)
-:
-    faPatchField<Type>(p, iF, Field<Type>("value", dict, p.size()))
-{}
-
-
 template<class Type>
 Foam::calculatedFaPatchField<Type>::calculatedFaPatchField
 (
@@ -98,10 +99,10 @@ Foam::calculatedFaPatchField<Type>::calculatedFaPatchField
 
 
 template<class Type>
-template<class Type2>
+template<class AnyType>
 Foam::tmp<Foam::faPatchField<Type>> Foam::faPatchField<Type>::NewCalculatedType
 (
-    const faPatchField<Type2>& pf
+    const faPatchField<AnyType>& pf
 )
 {
     auto* patchTypeCtor = patchConstructorTable(pf.patch().type());

src/finiteArea/fields/faPatchFields/basic/calculated/calculatedFaPatchField.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016-2017 Wikki Ltd
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -37,8 +38,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef calculatedFaPatchField_H
-#define calculatedFaPatchField_H
+#ifndef Foam_calculatedFaPatchField_H
+#define Foam_calculatedFaPatchField_H
 
 #include "faPatchField.H"
 
@@ -56,7 +57,6 @@ class calculatedFaPatchField
 :
     public faPatchField<Type>
 {
-
 public:
 
     //- Runtime type information
@@ -77,7 +77,9 @@ public:
         (
             const faPatch&,
             const DimensionedField<Type, areaMesh>&,
-            const dictionary&
+            const dictionary& dict,
+            //! The "value" entry (default: optional)
+            IOobjectOption::readOption valueRequired = IOobjectOption::LAZY_READ
         );
 
         //- Construct by mapping given patch field onto a new patch

src/finiteArea/fields/faPatchFields/basic/calculated/calculatedFaPatchFields.C

@@ -30,17 +30,12 @@ License
 #include "areaFaMesh.H"
 #include "addToRunTimeSelectionTable.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-makeFaPatchFields(calculated);
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
+    makeFaPatchFields(calculated);
+    makeFaPatchFieldType(label, calculated);
+}
 
 // ************************************************************************* //

src/finiteArea/fields/faPatchFields/basic/calculated/calculatedFaPatchFields.H

@@ -38,6 +38,7 @@ namespace Foam
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 makeFaPatchTypeFieldTypedefs(calculated);
+makeFaPatchFieldTypedef(label, calculated);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/finiteArea/fields/faPatchFields/basic/coupled/coupledFaPatchField.C

@@ -73,11 +73,12 @@ Foam::coupledFaPatchField<Type>::coupledFaPatchField
 (
     const faPatch& p,
     const DimensionedField<Type, areaMesh>& iF,
-    const dictionary& dict
+    const dictionary& dict,
+    IOobjectOption::readOption valueRequired
 )
 :
     lduInterfaceField(refCast<const lduInterface>(p, dict)),
-    faPatchField<Type>(p, iF, dict)
+    faPatchField<Type>(p, iF, dict, valueRequired)
 {}
 
 

src/finiteArea/fields/faPatchFields/basic/coupled/coupledFaPatchField.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016-2017 Wikki Ltd
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -38,8 +38,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef coupledFaPatchField_H
-#define coupledFaPatchField_H
+#ifndef Foam_coupledFaPatchField_H
+#define Foam_coupledFaPatchField_H
 
 #include "lduInterfaceField.H"
 #include "faPatchField.H"
@@ -60,7 +60,6 @@ class coupledFaPatchField
     public lduInterfaceField,
     public faPatchField<Type>
 {
-
 public:
 
     //- Runtime type information
@@ -89,7 +88,9 @@ public:
         (
             const faPatch&,
             const DimensionedField<Type, areaMesh>&,
-            const dictionary&
+            const dictionary& dict,
+            //! The "value" entry (default: mandatory)
+            IOobjectOption::readOption valueRequired = IOobjectOption::MUST_READ
         );
 
         //- Construct by mapping the given coupledFaPatchField onto a new patch
@@ -211,6 +212,27 @@ public:
 };
 
 
+// * * * * * * * * * * * * Template Specialisations  * * * * * * * * * * * * //
+
+template<>
+tmp<Field<label>> coupledFaPatchField<label>::snGrad() const;
+
+template<>
+void coupledFaPatchField<label>::evaluate(const Pstream::commsTypes);
+
+template<>
+tmp<Field<label>>
+coupledFaPatchField<label>::valueInternalCoeffs(const tmp<scalarField>&) const;
+
+template<>
+tmp<Field<label>>
+coupledFaPatchField<label>::valueBoundaryCoeffs(const tmp<scalarField>&) const;
+
+template<>
+tmp<Field<label>>
+coupledFaPatchField<label>::gradientInternalCoeffs() const;
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

src/finiteArea/fields/faPatchFields/basic/coupled/coupledFaPatchFields.C

@@ -29,17 +29,70 @@ License
 #include "coupledFaPatchFields.H"
 #include "areaFields.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
+    makeFaPatchFieldsTypeName(coupled);
+    makeFaPatchFieldTypeName(label, coupled);
+}
 
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * Specialisations * * * * * * * * * * * * * * //
 
-makeFaPatchFieldsTypeName(coupled);
+template<>
+Foam::tmp<Foam::Field<Foam::label>>
+Foam::coupledFaPatchField<Foam::label>::snGrad() const
+{
+    // TBD: Treat like zero-gradient
+    return tmp<Field<label>>::New(this->size(), Zero);
+}
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace Foam
+template<>
+void Foam::coupledFaPatchField<Foam::label>::evaluate(const Pstream::commsTypes)
+{
+    if (!this->updated())
+    {
+        this->updateCoeffs();
+    }
+
+    // TBD: Treat like zero-gradient
+    faPatchField<label>::operator=(this->patchInternalField());
+    faPatchField<label>::evaluate();
+}
+
+
+template<>
+Foam::tmp<Foam::Field<Foam::label>>
+Foam::coupledFaPatchField<Foam::label>::valueInternalCoeffs
+(
+    const tmp<scalarField>&
+) const
+{
+    // TBD: Treat like zero-gradient
+    return tmp<Field<label>>::New(this->size(), label(1));
+}
+
+
+template<>
+Foam::tmp<Foam::Field<Foam::label>>
+Foam::coupledFaPatchField<Foam::label>::valueBoundaryCoeffs
+(
+    const tmp<scalarField>&
+) const
+{
+    // TBD: Treat like zero-gradient
+    return tmp<Field<label>>::New(this->size(), Zero);
+}
+
+
+template<>
+Foam::tmp<Foam::Field<Foam::label>>
+Foam::coupledFaPatchField<Foam::label>::gradientInternalCoeffs() const
+{
+    // TBD: Treat like zero-gradient
+    return tmp<Field<label>>::New(this->size(), Zero);
+}
+
 
 // ************************************************************************* //

src/finiteArea/fields/faPatchFields/basic/coupled/coupledFaPatchFields.H

@@ -38,6 +38,7 @@ namespace Foam
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 makeFaPatchTypeFieldTypedefs(coupled);
+makeFaPatchFieldTypedef(label, coupled);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/finiteArea/fields/faPatchFields/basic/extrapolatedCalculated/extrapolatedCalculatedFaPatchField.C

@@ -0,0 +1,117 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2016 OpenFOAM Foundation
+    Copyright (C) 2023 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 "extrapolatedCalculatedFaPatchField.H"
+#include "faPatchFieldMapper.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::extrapolatedCalculatedFaPatchField<Type>::
+extrapolatedCalculatedFaPatchField
+(
+    const faPatch& p,
+    const DimensionedField<Type, areaMesh>& iF
+)
+:
+    calculatedFaPatchField<Type>(p, iF)
+{}
+
+
+template<class Type>
+Foam::extrapolatedCalculatedFaPatchField<Type>::
+extrapolatedCalculatedFaPatchField
+(
+    const faPatch& p,
+    const DimensionedField<Type, areaMesh>& iF,
+    const dictionary& dict
+)
+:
+    calculatedFaPatchField<Type>(p, iF, dict, IOobjectOption::NO_READ)
+{
+    calculatedFaPatchField<Type>::operator==(this->patchInternalField());
+}
+
+
+template<class Type>
+Foam::extrapolatedCalculatedFaPatchField<Type>::
+extrapolatedCalculatedFaPatchField
+(
+    const extrapolatedCalculatedFaPatchField<Type>& ptf,
+    const faPatch& p,
+    const DimensionedField<Type, areaMesh>& iF,
+    const faPatchFieldMapper& mapper
+)
+:
+    calculatedFaPatchField<Type>(ptf, p, iF, mapper)
+{}
+
+
+template<class Type>
+Foam::extrapolatedCalculatedFaPatchField<Type>::
+extrapolatedCalculatedFaPatchField
+(
+    const extrapolatedCalculatedFaPatchField<Type>& ptf
+)
+:
+    calculatedFaPatchField<Type>(ptf)
+{}
+
+
+template<class Type>
+Foam::extrapolatedCalculatedFaPatchField<Type>::
+extrapolatedCalculatedFaPatchField
+(
+    const extrapolatedCalculatedFaPatchField<Type>& ptf,
+    const DimensionedField<Type, areaMesh>& iF
+)
+:
+    calculatedFaPatchField<Type>(ptf, iF)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::extrapolatedCalculatedFaPatchField<Type>::evaluate
+(
+    const Pstream::commsTypes
+)
+{
+    if (!this->updated())
+    {
+        this->updateCoeffs();
+    }
+
+    // Set to the internal field
+    faPatchField<Type>::patchInternalField(*this);
+    calculatedFaPatchField<Type>::evaluate();
+}
+
+
+// ************************************************************************* //

src/finiteArea/fields/faPatchFields/basic/extrapolatedCalculated/extrapolatedCalculatedFaPatchField.H

@@ -0,0 +1,163 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2016 OpenFOAM Foundation
+    Copyright (C) 2023 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/>.
+
+Class
+    Foam::extrapolatedCalculatedFaPatchField
+
+Group
+    grpGenericBoundaryConditions
+
+Description
+    This boundary condition applies a zero-gradient condition from the patch
+    internal field onto the patch faces when \c evaluated but may also be
+    assigned.  \c snGrad returns the patch gradient evaluated from the current
+    internal and patch field values rather than returning zero.
+
+Usage
+    Example of the boundary condition specification:
+    \verbatim
+    <patchName>
+    {
+        type            extrapolatedCalculated;
+    }
+    \endverbatim
+
+SourceFiles
+    extrapolatedCalculatedFaPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef Foam_extrapolatedCalculatedFaPatchField_H
+#define Foam_extrapolatedCalculatedFaPatchField_H
+
+#include "calculatedFaPatchField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class extrapolatedCalculatedFaPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class extrapolatedCalculatedFaPatchField
+:
+    public calculatedFaPatchField<Type>
+{
+public:
+
+    //- Runtime type information
+    TypeName("extrapolatedCalculated");
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        extrapolatedCalculatedFaPatchField
+        (
+            const faPatch&,
+            const DimensionedField<Type, areaMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        extrapolatedCalculatedFaPatchField
+        (
+            const faPatch&,
+            const DimensionedField<Type, areaMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given patchField onto a new patch
+        extrapolatedCalculatedFaPatchField
+        (
+            const extrapolatedCalculatedFaPatchField<Type>&,
+            const faPatch&,
+            const DimensionedField<Type, areaMesh>&,
+            const faPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        extrapolatedCalculatedFaPatchField
+        (
+            const extrapolatedCalculatedFaPatchField<Type>&
+        );
+
+        //- Construct and return a clone
+        virtual tmp<faPatchField<Type>> clone() const
+        {
+            return tmp<faPatchField<Type>>
+            (
+                new extrapolatedCalculatedFaPatchField<Type>(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        extrapolatedCalculatedFaPatchField
+        (
+            const extrapolatedCalculatedFaPatchField<Type>&,
+            const DimensionedField<Type, areaMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<faPatchField<Type>> clone
+        (
+            const DimensionedField<Type, areaMesh>& iF
+        ) const
+        {
+            return tmp<faPatchField<Type>>
+            (
+                new extrapolatedCalculatedFaPatchField<Type>(*this, iF)
+            );
+        }
+
+
+    // Member Functions
+
+        //- Evaluate the patch field
+        virtual void evaluate
+        (
+            const Pstream::commsTypes commsType=Pstream::commsTypes::blocking
+        );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "extrapolatedCalculatedFaPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteArea/fields/faPatchFields/basic/extrapolatedCalculated/extrapolatedCalculatedFaPatchFields.C

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2023 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 "extrapolatedCalculatedFaPatchFields.H"
+#include "faPatchFields.H"
+#include "areaFaMesh.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makeFaPatchFields(extrapolatedCalculated);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/finiteArea/fields/faPatchFields/basic/extrapolatedCalculated/extrapolatedCalculatedFaPatchFields.H

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2023 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef Foam_extrapolatedCalculatedFaPatchFields_H
+#define Foam_extrapolatedCalculatedFaPatchFields_H
+
+#include "extrapolatedCalculatedFaPatchField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makeFaPatchTypeFieldTypedefs(extrapolatedCalculated);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteArea/fields/faPatchFields/basic/fixedGradient/fixedGradientFaPatchField.C

@@ -26,6 +26,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "fixedGradientFaPatchField.H"
+#include "dictionary.H"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
@@ -63,7 +64,7 @@ Foam::fixedGradientFaPatchField<Type>::fixedGradientFaPatchField
     const dictionary& dict
 )
 :
-    faPatchField<Type>(p, iF),
+    faPatchField<Type>(p, iF, dict, IOobjectOption::NO_READ),
     gradient_("gradient", dict, p.size())
 {
     evaluate();

src/finiteArea/fields/faPatchFields/basic/fixedGradient/fixedGradientFaPatchField.H

@@ -129,20 +129,19 @@ public:
         }
 
 
-    // Member functions
+    // Member Functions
 
-        // Return defining fields
+        //- The reference gradient at boundary
+        virtual Field<Type>& gradient() noexcept
+        {
+            return gradient_;
+        }
 
-            //- Return gradient at boundary
-            virtual Field<Type>& gradient()
-            {
-                return gradient_;
-            }
-
-            virtual const Field<Type>& gradient() const
-            {
-                return gradient_;
-            }
+        //- The reference gradient at boundary
+        virtual const Field<Type>& gradient() const noexcept
+        {
+            return gradient_;
+        }
 
 
         // Mapping functions

src/finiteArea/fields/faPatchFields/basic/fixedValue/fixedValueFaPatchField.C

@@ -45,10 +45,11 @@ Foam::fixedValueFaPatchField<Type>::fixedValueFaPatchField
 (
     const faPatch& p,
     const DimensionedField<Type, areaMesh>& iF,
-    const dictionary& dict
+    const dictionary& dict,
+    IOobjectOption::readOption valueRequired
 )
 :
-    faPatchField<Type>(p, iF, Field<Type>("value", dict, p.size()))
+    faPatchField<Type>(p, iF, dict, valueRequired)
 {}
 
 
@@ -137,5 +138,4 @@ void Foam::fixedValueFaPatchField<Type>::write(Ostream& os) const
 }
 
 
-
 // ************************************************************************* //

src/finiteArea/fields/faPatchFields/basic/fixedValue/fixedValueFaPatchField.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016-2017 Wikki Ltd
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -37,8 +38,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef fixedValueFaPatchField_H
-#define fixedValueFaPatchField_H
+#ifndef Foam_fixedValueFaPatchField_H
+#define Foam_fixedValueFaPatchField_H
 
 #include "faPatchField.H"
 
@@ -56,7 +57,6 @@ class fixedValueFaPatchField
 :
     public faPatchField<Type>
 {
-
 public:
 
     //- Runtime type information
@@ -77,7 +77,9 @@ public:
         (
             const faPatch&,
             const DimensionedField<Type, areaMesh>&,
-            const dictionary&
+            const dictionary&,
+            //! The "value" entry (default: mandatory)
+            IOobjectOption::readOption valueRequired = IOobjectOption::MUST_READ
         );
 
         //- Construct by mapping the given fixedValue patch field