BUG: snappyHexMesh: revert inside/outside test for triSurface. See #3349

Not yet working for distributedTriSurfaceMesh

META-INFO/api-info

@@ -1,2 +1,2 @@
-api=2501
+api=2502
 patch=0

applications/utilities/parallelProcessing/decomposePar/decomposePar.C

@@ -210,6 +210,7 @@ autoPtr<labelIOList> faProcAddressing
 
 
 // Return cached or read proc addressing from facesInstance
+FOAM_NO_DANGLING_REFERENCE
 const labelIOList& procAddressing
 (
     const PtrList<fvMesh>& procMeshList,

applications/utilities/preProcessing/mapFieldsPar/MapVolFields.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2018-2023 OpenCFD Ltd.
+    Copyright (C) 2018-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -39,74 +39,23 @@ namespace Foam
 {
 
 template<class Type>
-void evaluateConstraintTypes(GeometricField<Type, fvPatchField, volMesh>& fld)
+void evaluateConstraintTypes
+(
+    GeometricField<Type, fvPatchField, volMesh>& fld
+)
 {
-    auto& bfld = fld.boundaryFieldRef();
-
-    const UPstream::commsTypes commsType = UPstream::defaultCommsType;
-
-    if
+    fld.boundaryFieldRef().evaluate_if
     (
-        commsType == UPstream::commsTypes::buffered
-     || commsType == UPstream::commsTypes::nonBlocking
-    )
-    {
-        const label startOfRequests = UPstream::nRequests();
-
-        for (auto& pfld : bfld)
+        [](const auto& pfld) -> bool
         {
-            if
+            return
             (
                 pfld.type() == pfld.patch().patch().type()
              && polyPatch::constraintType(pfld.patch().patch().type())
-            )
-            {
-                pfld.initEvaluate(commsType);
-            }
-        }
-
-        // Wait for outstanding requests (non-blocking)
-        UPstream::waitRequests(startOfRequests);
-
-        for (auto& pfld : bfld)
-        {
-            if
-            (
-                pfld.type() == pfld.patch().patch().type()
-             && polyPatch::constraintType(pfld.patch().patch().type())
-            )
-            {
-                pfld.evaluate(commsType);
-            }
-        }
-    }
-    else if (commsType == UPstream::commsTypes::scheduled)
-    {
-        const lduSchedule& patchSchedule =
-            fld.mesh().globalData().patchSchedule();
-
-        for (const auto& schedEval : patchSchedule)
-        {
-            const label patchi = schedEval.patch;
-            auto& pfld = bfld[patchi];
-
-            if
-            (
-                pfld.type() == pfld.patch().patch().type()
-             && polyPatch::constraintType(pfld.patch().patch().type())
-            )
-            {
-                if (schedEval.init)
-                {
-                    pfld.initEvaluate(commsType);
-                }
-                else
-                {
-                    pfld.evaluate(commsType);
-                }
-            }
-        }
-    }
+            );
+        },
+        UPstream::defaultCommsType
+    );
 }
 
 

src/OpenFOAM/Make/files

@@ -587,7 +587,7 @@ meshes/Identifiers/surface/geometricSurfacePatch.C
 meshes/Identifiers/surface/surfZoneIdentifier.C
 meshes/Identifiers/zone/zoneIdentifier.C
 
-meshes/MeshObject/meshObject.C
+meshes/MeshObject/meshObject.cxx
 
 polyMesh = meshes/polyMesh
 

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

@@ -373,6 +373,33 @@ public:
             Field<Type>&& iField
         );
 
+        //- Return tmp field (NO_READ, NO_WRITE)
+        //- from name, mesh, dimensions, primitive field (tmp).
+        //- [Takes current timeName from the mesh registry].
+        //  For LEGACY_REGISTER, registration is determined by
+        //  objectRegistry::is_cacheTemporaryObject().
+        static tmp<DimensionedField<Type, GeoMesh>> New
+        (
+            const word& name,
+            IOobjectOption::registerOption regOpt,
+            const Mesh& mesh,
+            const dimensionSet& dims,
+            const tmp<Field<Type>>& tfield
+        );
+
+        //- Return tmp field (NO_READ, NO_WRITE)
+        //- from name, mesh, dimensions, primitive field (tmp).
+        //- [Takes current timeName from the mesh registry].
+        //  Registration/persistence determined by
+        //  objectRegistry::is_cacheTemporaryObject().
+        static tmp<DimensionedField<Type, GeoMesh>> New
+        (
+            const word& name,
+            const Mesh& mesh,
+            const dimensionSet& dims,
+            const tmp<Field<Type>>& tfield
+        );
+
         //- Return tmp field (NO_READ, NO_WRITE)
         //- from name, mesh, dimensions.
         //- [Takes current timeName from the mesh registry].

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

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2022-2024 OpenCFD Ltd.
+    Copyright (C) 2022-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -163,6 +163,49 @@ Foam::DimensionedField<Type, GeoMesh>::New
 }
 
 
+template<class Type, class GeoMesh>
+Foam::tmp<Foam::DimensionedField<Type, GeoMesh>>
+Foam::DimensionedField<Type, GeoMesh>::New
+(
+    const word& name,
+    IOobjectOption::registerOption regOpt,
+    const Mesh& mesh,
+    const dimensionSet& dims,
+    const tmp<Field<Type>>& tfield
+)
+{
+    return DimensionedField<Type, GeoMesh>::New_impl
+    (
+        regOpt,
+        name,
+        mesh,
+        dims,
+        tfield
+    );
+}
+
+
+template<class Type, class GeoMesh>
+Foam::tmp<Foam::DimensionedField<Type, GeoMesh>>
+Foam::DimensionedField<Type, GeoMesh>::New
+(
+    const word& name,
+    const Mesh& mesh,
+    const dimensionSet& dims,
+    const tmp<Field<Type>>& tfield
+)
+{
+    return DimensionedField<Type, GeoMesh>::New_impl
+    (
+        IOobjectOption::LEGACY_REGISTER,
+        name,
+        mesh,
+        dims,
+        tfield
+    );
+}
+
+
 template<class Type, class GeoMesh>
 Foam::tmp<Foam::DimensionedField<Type, GeoMesh>>
 Foam::DimensionedField<Type, GeoMesh>::New

src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017,2022 OpenFOAM Foundation
-    Copyright (C) 2016-2024 OpenCFD Ltd.
+    Copyright (C) 2016-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -64,6 +64,8 @@ bool Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::checkConsistency
     //Note: areaFields (finiteArea) do not have manipulatedMatrix() flag. TBD.
     //boolList oldManipulated(this->size());
 
+    label nEvaluated(0);
+
     for (auto& pfld : bfld)
     {
         if (isA<CheckPatchFieldType>(pfld))
@@ -72,19 +74,24 @@ bool Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::checkConsistency
             oldUpdated[patchi] = pfld.updated();
             oldBfld[patchi] = pfld;
             //oldManipulated[patchi] = pfld.manipulatedMatrix();
+            ++nEvaluated;
         }
     }
 
+    if (!nEvaluated) return true;  // Early termination
 
     // Re-evaluate
     {
         const label startOfRequests = UPstream::nRequests();
 
+        nEvaluated = 0;
+
         for (auto& pfld : bfld)
         {
             if (isA<CheckPatchFieldType>(pfld))
             {
                 pfld.initEvaluate(UPstream::commsTypes::nonBlocking);
+                ++nEvaluated;
             }
         }
 
@@ -96,13 +103,15 @@ bool Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::checkConsistency
             if (isA<CheckPatchFieldType>(pfld))
             {
                 pfld.evaluate(UPstream::commsTypes::nonBlocking);
+                if (--nEvaluated == 0) break;  // Early termination
             }
         }
     }
 
 
     // Check
-    bool ok = true;
+    bool allOk(true);
+
     for (auto& pfld : bfld)
     {
         if (isA<CheckPatchFieldType>(pfld))
@@ -110,16 +119,23 @@ bool Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::checkConsistency
             const label patchi = pfld.patch().index();
             const auto& oldPfld = oldBfld[patchi];
 
-            forAll(pfld, facei)
+            bool localOk(true);
+
+            if (allOk)
             {
-                if (mag(pfld[facei]-oldPfld[facei]) > tol)
+                // Only check once
+                forAll(pfld, facei)
                 {
-                    ok = false;
-                    break;
+                    if (mag(pfld[facei]-oldPfld[facei]) > tol)
+                    {
+                        allOk = false;
+                        localOk = false;
+                        break;
+                    }
                 }
             }
 
-            if (!ok)
+            if (!localOk)
             {
                 if (doExit)
                 {
@@ -133,7 +149,7 @@ bool Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::checkConsistency
                         << ". Average of evaluated field = "
                         << average(pfld)
                         << ". Difference:" << average(pfld-oldPfld)
-                        << ". Tolerance:" << tol
+                        << ". Tolerance:" << tol << endl
                         << exit(FatalError);
                 }
                 else
@@ -148,25 +164,13 @@ bool Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::checkConsistency
                         << ". Average of evaluated field = "
                         << average(pfld)
                         << ". Difference:" << average(pfld-oldPfld)
-                        << ". Tolerance:" << tol
-                        << endl;
-
-                    // Skip other patches
-                    break;
+                        << ". Tolerance:" << tol << endl;
                 }
             }
-        }
-    }
 
-    // Restore bfld, updated
-    for (auto& pfld : bfld)
-    {
-        if (isA<CheckPatchFieldType>(pfld))
-        {
-            const label patchi = pfld.patch().index();
+            // Restore bfld, updated
             pfld.setUpdated(oldUpdated[patchi]);
-            Field<Type>& vals = pfld;
-            vals = std::move(oldBfld[patchi]);
+            static_cast<Field<Type>&>(pfld) = std::move(oldBfld[patchi]);
             //pfld.setManipulated(oldManipulated[patchi]);
         }
     }
@@ -176,10 +180,10 @@ bool Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::checkConsistency
         const auto& pfld0 = this->operator[](0);
         PoutInFunction
             << " Result of checking for field "
-            << pfld0.internalField().name() << " : " << ok << endl;
+            << pfld0.internalField().name() << " : " << allOk << endl;
     }
 
-    return ok;
+    return allOk;
 }
 
 
@@ -626,6 +630,7 @@ void Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::evaluate_if
      || commsType == UPstream::commsTypes::nonBlocking
     )
     {
+        label nEvaluated(0);
         const label startOfRequests = UPstream::nRequests();
 
         for (auto& pfld : *this)
@@ -633,17 +638,21 @@ void Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::evaluate_if
             if (pred(pfld))
             {
                 pfld.initEvaluate(commsType);
+                ++nEvaluated;
             }
         }
 
         // Wait for outstanding requests (non-blocking)
         UPstream::waitRequests(startOfRequests);
 
+        if (!nEvaluated) return;  // Early termination
+
         for (auto& pfld : *this)
         {
             if (pred(pfld))
             {
                 pfld.evaluate(commsType);
+                if (--nEvaluated == 0) break;  // Early termination
             }
         }
     }
@@ -778,81 +787,25 @@ void Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::evaluateCoupled
     const UPstream::commsTypes commsType
 )
 {
-    // Alternative (C++14)
-    //
-    // this->evaluate_if
-    // (
-    //     [](const auto& pfld) -> bool
-    //     {
-    //         const auto* cpp = isA<CoupledPatchType>(pfld.patch());
-    //         return (cpp && cpp->coupled());
-    //     },
-    //     commsType
-    // );
-
-    // DebugInFunction << nl;
-
-    if
-    (
-        commsType == UPstream::commsTypes::buffered
-     || commsType == UPstream::commsTypes::nonBlocking
-    )
+    if constexpr (std::is_void_v<CoupledPatchType>)
     {
-        const label startOfRequests = UPstream::nRequests();
-
-        for (auto& pfld : *this)
-        {
-            const auto* cpp = isA<CoupledPatchType>(pfld.patch());
-
-            if (cpp && cpp->coupled())
-            {
-                pfld.initEvaluate(commsType);
-            }
-        }
-
-        // Wait for outstanding requests (non-blocking)
-        UPstream::waitRequests(startOfRequests);
-
-        for (auto& pfld : *this)
-        {
-            const auto* cpp = isA<CoupledPatchType>(pfld.patch());
-
-            if (cpp && cpp->coupled())
-            {
-                pfld.evaluate(commsType);
-            }
-        }
-    }
-    else if (commsType == UPstream::commsTypes::scheduled)
-    {
-        const lduSchedule& patchSchedule =
-            bmesh_.mesh().globalData().patchSchedule();
-
-        for (const auto& schedEval : patchSchedule)
-        {
-            const label patchi = schedEval.patch;
-            auto& pfld = (*this)[patchi];
-
-            const auto* cpp = isA<CoupledPatchType>(pfld.patch());
-
-            if (cpp && cpp->coupled())
-            {
-                if (schedEval.init)
-                {
-                    pfld.initEvaluate(commsType);
-                }
-                else
-                {
-                    pfld.evaluate(commsType);
-                }
-            }
-        }
+        this->evaluate_if
+        (
+            [](const auto& pfld) { return pfld.coupled(); },
+            commsType
+        );
     }
     else
     {
-        FatalErrorInFunction
-            << "Unsupported communications type " << int(commsType) << nl
-            << exit(FatalError);
+        this->evaluate_if
+        (
+            [](const auto& pfld) -> bool
+            {
+                const auto* cpp = isA<CoupledPatchType>(pfld.patch());
+                return (cpp && cpp->coupled());
+            },
+            commsType
+        );
     }
 }
 

src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.H

@@ -205,8 +205,12 @@ public:
             const UPstream::commsTypes commsType = UPstream::defaultCommsType
         );
 
-        //- Evaluate boundary conditions on coupled patches of given type.
-        //- Uses specified or default comms.
+        //- Evaluate boundary conditions on coupled patches of the given type,
+        //- using specified or default comms.
+        //
+        //  \tparam CoupledPatchType The coupled \b patch type that should
+        //     be evaluated. For a \c void type,
+        //     all coupled patch fields will be evaluated.
         template<class CoupledPatchType>
         void evaluateCoupled
         (

src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.C

@@ -63,8 +63,10 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::readFields
 
     if (dict.readIfPresent("referenceLevel", refLevel))
     {
-        Field<Type>::operator+=(refLevel);
+        // Add to internal (primitive) field
+        this->field() += refLevel;
 
+        // Add to boundary fields
         forAll(boundaryField_, patchi)
         {
             boundaryField_[patchi] == boundaryField_[patchi] + refLevel;
@@ -409,7 +411,7 @@ Foam::GeometricField<Type, PatchField, GeoMesh>::GeometricField
     boundaryField_(mesh.boundary(), *this, patchFieldType)
 {
     DebugInFunction
-        << "Copy construct from internal field" << nl << this->info() << endl;
+        << "Copy construct from primitive field" << nl << this->info() << endl;
 
     readIfPresent();
 }
@@ -430,7 +432,28 @@ Foam::GeometricField<Type, PatchField, GeoMesh>::GeometricField
     boundaryField_(mesh.boundary(), *this, patchFieldType)
 {
     DebugInFunction
-        << "Move construct from internal field" << nl << this->info() << endl;
+        << "Move construct from primitive field" << nl << this->info() << endl;
+
+    readIfPresent();
+}
+
+
+template<class Type, template<class> class PatchField, class GeoMesh>
+Foam::GeometricField<Type, PatchField, GeoMesh>::GeometricField
+(
+    const IOobject& io,
+    const Mesh& mesh,
+    const dimensionSet& dims,
+    const tmp<Field<Type>>& tfield,
+    const word& patchFieldType
+)
+:
+    Internal(io, mesh, dims, tfield),
+    timeIndex_(this->time().timeIndex()),
+    boundaryField_(mesh.boundary(), *this, patchFieldType)
+{
+    DebugInFunction
+        << "Construct from tmp primitive field" << nl << this->info() << endl;
 
     readIfPresent();
 }
@@ -1391,10 +1414,7 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::operator=
     // Make sure any e.g. jump-cyclic are updated.
     boundaryFieldRef().evaluate_if
     (
-        [](const auto& pfld) -> bool
-        {
-            return pfld.constraintOverride();
-        }
+        [](const auto& pfld) { return pfld.constraintOverride(); }
     );
 }
 
@@ -1436,10 +1456,7 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::operator=
     // Make sure any e.g. jump-cyclic are updated.
     boundaryFieldRef().evaluate_if
     (
-        [](const auto& pfld) -> bool
-        {
-            return pfld.constraintOverride();
-        }
+        [](const auto& pfld) { return pfld.constraintOverride(); }
     );
 }
 
@@ -1456,10 +1473,7 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::operator=
     // Make sure any e.g. jump-cyclic are updated.
     boundaryFieldRef().evaluate_if
     (
-        [](const auto& pfld) -> bool
-        {
-            return pfld.constraintOverride();
-        }
+        [](const auto& pfld) { return pfld.constraintOverride(); }
     );
 }
 
@@ -1484,10 +1498,7 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::operator==
     // Make sure any e.g. jump-cyclic are updated.
     boundaryFieldRef().evaluate_if
     (
-        [](const auto& pfld) -> bool
-        {
-            return pfld.constraintOverride();
-        }
+        [](const auto& pfld) { return pfld.constraintOverride(); }
     );
 }
 
@@ -1504,10 +1515,7 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::operator==
     // Make sure any e.g. jump-cyclic are updated.
     boundaryFieldRef().evaluate_if
     (
-        [](const auto& pfld) -> bool
-        {
-            return pfld.constraintOverride();
-        }
+        [](const auto& pfld) { return pfld.constraintOverride(); }
     );
 }
 
@@ -1527,10 +1535,7 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::operator op              \
                                                                                \
     boundaryFieldRef().evaluate_if                                             \
     (                                                                          \
-        [](const auto& pfld) -> bool                                           \
-        {                                                                      \
-            return pfld.constraintOverride();                                  \
-        }                                                                      \
+        [](const auto& pfld) { return pfld.constraintOverride(); }             \
     );                                                                         \
 }                                                                              \
                                                                                \
@@ -1545,10 +1550,7 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::operator op              \
                                                                                \
     boundaryFieldRef().evaluate_if                                             \
     (                                                                          \
-        [](const auto& pfld) -> bool                                           \
-        {                                                                      \
-            return pfld.constraintOverride();                                  \
-        }                                                                      \
+        [](const auto& pfld) { return pfld.constraintOverride(); }             \
     );                                                                         \
 }                                                                              \
                                                                                \
@@ -1563,10 +1565,7 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::operator op              \
                                                                                \
     boundaryFieldRef().evaluate_if                                             \
     (                                                                          \
-        [](const auto& pfld) -> bool                                           \
-        {                                                                      \
-            return pfld.constraintOverride();                                  \
-        }                                                                     \
+        [](const auto& pfld) { return pfld.constraintOverride(); }             \
     );                                                                         \
 }
 

src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.H

@@ -251,7 +251,7 @@ public:
             const PtrList<PatchField<Type>>& ptfl
         );
 
-        //- Move construct from internal field and a patch list to clone
+        //- Construct from internal field (tmp) and a patch list to clone
         GeometricField
         (
             const IOobject& io,
@@ -273,7 +273,7 @@ public:
             const PtrList<PatchField<Type>>& ptfl
         );
 
-        //- Copy construct from internal field, with specified patch type
+        //- Copy construct from primitive field, with specified patch type
         GeometricField
         (
             const IOobject& io,
@@ -283,7 +283,7 @@ public:
             const word& patchFieldType = PatchField<Type>::calculatedType()
         );
 
-        //- Move construct from internal field, with specified patch type
+        //- Move construct from primitive field, with specified patch type
         GeometricField
         (
             const IOobject& io,
@@ -293,7 +293,17 @@ public:
             const word& patchFieldType = PatchField<Type>::calculatedType()
         );
 
-        //- Copy construct from components
+        //- Construct from primitive field (tmp), with specified patch type
+        GeometricField
+        (
+            const IOobject& io,
+            const Mesh& mesh,
+            const dimensionSet& dims,
+            const tmp<Field<Type>>& tfield,
+            const word& patchFieldType = PatchField<Type>::calculatedType()
+        );
+
+        //- Copy construct from primitive field and a patch list to clone
         GeometricField
         (
             const IOobject& io,
@@ -303,7 +313,7 @@ public:
             const PtrList<PatchField<Type>>& ptfl
         );
 
-        //- Move construct from internal field and a patch list to clone
+        //- Move construct from primitive field and a patch list to clone
         GeometricField
         (
             const IOobject& io,
@@ -319,7 +329,7 @@ public:
             const IOobject& io,
             const Mesh& mesh,
             const dimensionSet& dims,
-            const tmp<Field<Type>>& tiField,
+            const tmp<Field<Type>>& tfield,
             const PtrList<PatchField<Type>>& ptfl
         );
 
@@ -508,6 +518,37 @@ public:
             const word& patchFieldType = PatchField<Type>::calculatedType()
         );
 
+        //- Return tmp field (NO_READ, NO_WRITE)
+        //- from name, mesh, dimensions, tmp of primitive field
+        //- and patch type.
+        //- [Takes current timeName from the mesh registry].
+        //  For LEGACY_REGISTER, registration is determined by
+        //  objectRegistry::is_cacheTemporaryObject().
+        static tmp<GeometricField<Type, PatchField, GeoMesh>> New
+        (
+            const word& name,
+            IOobjectOption::registerOption regOpt,
+            const Mesh& mesh,
+            const dimensionSet& dims,
+            const tmp<Field<Type>>& tfield,
+            const word& patchFieldType = PatchField<Type>::calculatedType()
+        );
+
+        //- Return tmp field (NO_READ, NO_WRITE)
+        //- from name, mesh, dimensions, tmp of primitive field
+        //- and patch type.
+        //- [Takes current timeName from the mesh registry].
+        //  Registration/persistence determined by
+        //  objectRegistry::is_cacheTemporaryObject().
+        static tmp<GeometricField<Type, PatchField, GeoMesh>> New
+        (
+            const word& name,
+            const Mesh& mesh,
+            const dimensionSet& dims,
+            const tmp<Field<Type>>& tfield,
+            const word& patchFieldType = PatchField<Type>::calculatedType()
+        );
+
         //- Return tmp field (NO_READ, NO_WRITE)
         //- from name, mesh, dimensions, copy of internal field contents
         //- and patch list to clone.

src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldNew.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2017 OpenFOAM Foundation
-    Copyright (C) 2019-2024 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -215,6 +215,53 @@ Foam::GeometricField<Type, PatchField, GeoMesh>::New
 }
 
 
+template<class Type, template<class> class PatchField, class GeoMesh>
+Foam::tmp<Foam::GeometricField<Type, PatchField, GeoMesh>>
+Foam::GeometricField<Type, PatchField, GeoMesh>::New
+(
+    const word& name,
+    IOobjectOption::registerOption regOpt,
+    const Mesh& mesh,
+    const dimensionSet& dims,
+    const tmp<Field<Type>>& tfield,
+    const word& patchFieldType
+)
+{
+    return GeometricField<Type, PatchField, GeoMesh>::New_impl
+    (
+        regOpt,
+        name,
+        mesh,
+        dims,
+        tfield,
+        patchFieldType
+    );
+}
+
+
+template<class Type, template<class> class PatchField, class GeoMesh>
+Foam::tmp<Foam::GeometricField<Type, PatchField, GeoMesh>>
+Foam::GeometricField<Type, PatchField, GeoMesh>::New
+(
+    const word& name,
+    const Mesh& mesh,
+    const dimensionSet& dims,
+    const tmp<Field<Type>>& tfield,
+    const word& patchFieldType
+)
+{
+    return GeometricField<Type, PatchField, GeoMesh>::New_impl
+    (
+        IOobjectOption::LEGACY_REGISTER,
+        name,
+        mesh,
+        dims,
+        tfield,
+        patchFieldType
+    );
+}
+
+
 template<class Type, template<class> class PatchField, class GeoMesh>
 Foam::tmp<Foam::GeometricField<Type, PatchField, GeoMesh>>
 Foam::GeometricField<Type, PatchField, GeoMesh>::New

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

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -87,20 +88,27 @@ void Foam::basicSymmetryPointPatchField<Type>::evaluate
     const Pstream::commsTypes
 )
 {
-    const vectorField& nHat = this->patch().pointNormals();
+    if constexpr (!is_rotational_vectorspace_v<Type>)
+    {
+        // Rotational-invariant type : no-op
+    }
+    else
+    {
+        const vectorField& nHat = this->patch().pointNormals();
 
-    tmp<Field<Type>> tvalues =
-    (
+        const Field<Type> pif(this->patchInternalField());
+
+        // Could write as loop instead...
+        tmp<Field<Type>> tvalues
         (
-            this->patchInternalField()
-          + transform(I - 2.0*sqr(nHat), this->patchInternalField())
-        )/2.0
-    );
+            0.5*(pif + transform(I - 2.0*sqr(nHat), pif))
+        );
 
-    // Get internal field to insert values into
-    Field<Type>& iF = const_cast<Field<Type>&>(this->primitiveField());
+        // Get internal field to insert values into
+        auto& iF = const_cast<Field<Type>&>(this->primitiveField());
 
-    this->setInInternalField(iF, tvalues());
+        this->setInInternalField(iF, tvalues());
+    }
 }
 
 

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

@@ -27,7 +27,6 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "fixedValuePointPatchField.H"
-#include "boolList.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 

src/OpenFOAM/fields/pointPatchFields/constraint/cyclicSlip/cyclicSlipPointPatchField.C

@@ -84,20 +84,27 @@ Foam::cyclicSlipPointPatchField<Type>::cyclicSlipPointPatchField
 template<class Type>
 void Foam::cyclicSlipPointPatchField<Type>::evaluate(const Pstream::commsTypes)
 {
-    const vectorField& nHat = this->patch().pointNormals();
+    if constexpr (!is_rotational_vectorspace_v<Type>)
+    {
+        // Rotational-invariant type : no-op
+    }
+    else
+    {
+        const vectorField& nHat = this->patch().pointNormals();
 
-    tmp<Field<Type>> tvalues =
-    (
+        const Field<Type> pif(this->patchInternalField());
+
+        // Could write as loop instead...
+        tmp<Field<Type>> tvalues
         (
-            this->patchInternalField()
-          + transform(I - 2.0*sqr(nHat), this->patchInternalField())
-        )/2.0
-    );
+            0.5*(pif + transform(I - 2.0*sqr(nHat), pif))
+        );
 
-    // Get internal field to insert values into
-    Field<Type>& iF = const_cast<Field<Type>&>(this->primitiveField());
+        // Get internal field to insert values into
+        auto& iF = const_cast<Field<Type>&>(this->primitiveField());
 
-    this->setInInternalField(iF, tvalues());
+        this->setInInternalField(iF, tvalues());
+    }
 }
 
 

src/OpenFOAM/fields/pointPatchFields/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicPointPatchField.C

@@ -91,20 +91,27 @@ void Foam::nonuniformTransformCyclicPointPatchField<Type>::evaluate
     const Pstream::commsTypes
 )
 {
-    const vectorField& nHat = this->patch().pointNormals();
+    if constexpr (!is_rotational_vectorspace_v<Type>)
+    {
+        // Rotational-invariant type : no-op
+    }
+    else
+    {
+        const vectorField& nHat = this->patch().pointNormals();
 
-    tmp<Field<Type>> tvalues =
-    (
+        const Field<Type> pif(this->patchInternalField());
+
+        // Could write as loop instead...
+        tmp<Field<Type>> tvalues
         (
-            this->patchInternalField()
-          + transform(I - 2.0*sqr(nHat), this->patchInternalField())
-        )/2.0
-    );
+            0.5*(pif + transform(I - 2.0*sqr(nHat), pif))
+        );
 
-    // Get internal field to insert values into
-    Field<Type>& iF = const_cast<Field<Type>&>(this->primitiveField());
+        // Get internal field to insert values into
+        auto& iF = const_cast<Field<Type>&>(this->primitiveField());
 
-    this->setInInternalField(iF, tvalues());
+        this->setInInternalField(iF, tvalues());
+    }
 }
 
 

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

@@ -106,20 +106,27 @@ void Foam::symmetryPlanePointPatchField<Type>::evaluate
     const Pstream::commsTypes
 )
 {
-    vector nHat = symmetryPlanePatch_.n();
+    if constexpr (!is_rotational_vectorspace_v<Type>)
+    {
+        // Rotational-invariant type : no-op
+    }
+    else
+    {
+        const symmTensor rot(I - 2.0*sqr(symmetryPlanePatch_.n()));
 
-    tmp<Field<Type>> tvalues =
-    (
+        const Field<Type> pif(this->patchInternalField());
+
+        // Could write as loop instead...
+        tmp<Field<Type>> tvalues
         (
-            this->patchInternalField()
-          + transform(I - 2.0*sqr(nHat), this->patchInternalField())
-        )/2.0
-    );
+            0.5*(pif + transform(rot, pif))
+        );
 
-    // Get internal field to insert values into
-    Field<Type>& iF = const_cast<Field<Type>&>(this->primitiveField());
+        // Get internal field to insert values into
+        auto& iF = const_cast<Field<Type>&>(this->primitiveField());
 
-    this->setInInternalField(iF, tvalues());
+        this->setInInternalField(iF, tvalues());
+    }
 }
 
 

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

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -28,7 +29,6 @@ License
 #include "wedgePointPatchField.H"
 #include "transformField.H"
 
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class Type>
@@ -101,17 +101,28 @@ Foam::wedgePointPatchField<Type>::wedgePointPatchField
 template<class Type>
 void Foam::wedgePointPatchField<Type>::evaluate(const Pstream::commsTypes)
 {
-    // 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];
+    if constexpr (!is_rotational_vectorspace_v<Type>)
+    {
+        // Rotational-invariant type : no-op
+    }
+    else
+    {
+        // In order to ensure that the wedge patch is always flat, take the
+        // normal vector from the first point
 
-    tmp<Field<Type>> tvalues =
-        transform(I - nHat*nHat, this->patchInternalField());
+        const symmTensor rot(I - 2.0*sqr(this->patch().pointNormals()[0]));
 
-    // Get internal field to insert values into
-    Field<Type>& iF = const_cast<Field<Type>&>(this->primitiveField());
+        // Could write as loop instead...
+        tmp<Field<Type>> tvalues
+        (
+            transform(rot, this->patchInternalField())
+        );
 
-    this->setInInternalField(iF, tvalues());
+        // Get internal field to insert values into
+        auto& iF = const_cast<Field<Type>&>(this->primitiveField());
+
+        this->setInInternalField(iF, tvalues());
+    }
 }
 
 

src/OpenFOAM/fields/pointPatchFields/derived/fixedNormalSlip/fixedNormalSlipPointPatchField.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -88,13 +89,22 @@ void Foam::fixedNormalSlipPointPatchField<Type>::evaluate
     const Pstream::commsTypes
 )
 {
-    tmp<Field<Type>> tvalues =
-        transform(I - n_*n_, this->patchInternalField());
+    if constexpr (!is_rotational_vectorspace_v<Type>)
+    {
+        // Rotational-invariant type : no-op
+    }
+    else
+    {
+        tmp<Field<Type>> tvalues
+        (
+            transform(I - n_*n_, this->patchInternalField())
+        );
 
-    // Get internal field to insert values into
-    Field<Type>& iF = const_cast<Field<Type>&>(this->primitiveField());
+        // Get internal field to insert values into
+        auto& iF = const_cast<Field<Type>&>(this->primitiveField());
 
-    this->setInInternalField(iF, tvalues());
+        this->setInInternalField(iF, tvalues());
+    }
 }
 
 

src/OpenFOAM/include/stdFoam.H

@@ -71,6 +71,21 @@ Description
 #  define FOAM_LIKELY(cond)   (cond)
 #endif
 
+// Shadow macro for __GNUC__, excluding compilers masquerading as gcc
+#undef FOAM_REAL_GNUC
+#if defined(__GNUC__) && !defined(__llvm__)
+#  define FOAM_REAL_GNUC __GNUC__
+#endif
+
+// Suppress false positives from -Wdangling-reference (gcc >= 14)
+#if (FOAM_REAL_GNUC >= 14)
+#  define FOAM_NO_DANGLING_REFERENCE [[gnu::no_dangling]]
+#endif
+
+#ifndef FOAM_NO_DANGLING_REFERENCE
+#define FOAM_NO_DANGLING_REFERENCE
+#endif
+
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/OpenFOAM/meshes/MeshObject/MeshObject.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2024 OpenCFD Ltd.
+    Copyright (C) 2018-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -168,10 +168,12 @@ public:
 
         //- Get existing or create MeshObject registered with typeName
         template<class... Args>
+        FOAM_NO_DANGLING_REFERENCE  //< Reference stored in registry
         static const Type& New(const Mesh& mesh, Args&&... args);
 
         //- Get existing or create MeshObject with given registration name
         template<class... Args>
+        FOAM_NO_DANGLING_REFERENCE  //< Reference stored in registry
         static const Type& New
         (
             const word& objName,
@@ -320,7 +322,7 @@ public:
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #ifdef NoRepository
-    #include "MeshObject.C"
+    #include "MeshObject.txx"
 #endif
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processor/processorPointPatch.H

@@ -167,13 +167,13 @@ public:
         }
 
         //- Return processor number
-        int myProcNo() const
+        int myProcNo() const noexcept
         {
             return procPolyPatch_.myProcNo();
         }
 
         //- Return neighbour processor number
-        int neighbProcNo() const
+        int neighbProcNo() const noexcept
         {
             return procPolyPatch_.neighbProcNo();
         }
@@ -191,13 +191,13 @@ public:
         }
 
         //- Return the underlying processorPolyPatch
-        const processorPolyPatch& procPolyPatch() const
+        const processorPolyPatch& procPolyPatch() const noexcept
         {
             return procPolyPatch_;
         }
 
         //- Return mesh points in the correct order for the receiving side
-        const labelList& reverseMeshPoints() const
+        const labelList& reverseMeshPoints() const noexcept
         {
             return reverseMeshPoints_;
         }

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/wedge/wedgePointPatch.H

@@ -34,8 +34,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef wedgePointPatch_H
-#define wedgePointPatch_H
+#ifndef Foam_wedgePointPatch_H
+#define Foam_wedgePointPatch_H
 
 #include "facePointPatch.H"
 #include "wedgePolyPatch.H"
@@ -53,9 +53,9 @@ class wedgePointPatch
 :
     public facePointPatch
 {
-    // Private data
+    // Private Data
 
-        //- Local reference cast into the symmetryPlane patch
+        //- Local reference cast into the wedgePolyPatch patch
         const wedgePolyPatch& wedgePolyPatch_;
 
 
@@ -120,8 +120,8 @@ public:
             pointConstraint&
         ) const;
 
-        //- Return symmetry plane normal
-        const vector& n() const
+        //- Return the normal to the patch
+        const vector& n() const noexcept
         {
             return wedgePolyPatch_.n();
         }

src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/wedge/wedgePolyPatch.H

@@ -34,8 +34,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef wedgePolyPatch_H
-#define wedgePolyPatch_H
+#ifndef Foam_wedgePolyPatch_H
+#define Foam_wedgePolyPatch_H
 
 #include "polyPatch.H"
 
@@ -52,7 +52,7 @@ class wedgePolyPatch
 :
     public polyPatch
 {
-    // Private data
+    // Private Data
 
         //- Axis of the wedge
         vector axis_;
@@ -173,45 +173,27 @@ public:
         }
 
 
-    // Member functions
+    // Member Functions
 
-        // Access
+    // Access
 
-            //- Return axis of the wedge
-            const vector& axis() const
-            {
-                return axis_;
-            }
+        //- Return axis of the wedge
+        const vector& axis() const noexcept { return axis_; }
 
-            //- Return plane normal between the wedge boundaries
-            const vector& centreNormal() const
-            {
-                return centreNormal_;
-            }
+        //- Return plane normal between the wedge boundaries
+        const vector& centreNormal() const noexcept { return centreNormal_; }
 
-            //- Return the normal to the patch
-            const vector& n() const
-            {
-                return n_;
-            }
+        //- Return the normal to the patch
+        const vector& n() const noexcept { return n_; }
 
-            //- Return the cosine of the wedge angle
-            scalar cosAngle() const
-            {
-                return cosAngle_;
-            }
+        //- Return the cosine of the wedge angle
+        scalar cosAngle() const noexcept { return cosAngle_; }
 
-            //- Return face transformation tensor
-            const tensor& faceT() const
-            {
-                return faceT_;
-            }
+        //- Return face transformation tensor
+        const tensor& faceT() const noexcept { return faceT_; }
 
-            //- Return neighbour-cell transformation tensor
-            const tensor& cellT() const
-            {
-                return cellT_;
-            }
+        //- Return neighbour-cell transformation tensor
+        const tensor& cellT() const noexcept { return cellT_; }
 };
 
 

src/OpenFOAM/primitives/DiagTensor/DiagTensor.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2023 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -92,7 +92,7 @@ public:
     // Constructors
 
         //- Construct initialized to zero
-        inline DiagTensor(const Foam::zero);
+        inline DiagTensor(Foam::zero);
 
         //- Construct given VectorSpace
         template<class Cmpt2>
@@ -123,6 +123,9 @@ public:
 
     // Diagonal access and manipulation
 
+        //- Extract the diagonal as a vector
+        inline Vector<Cmpt> diag() const;
+
         //- The L2-norm squared of the diagonal
         inline scalar diagSqr() const;
 };

src/OpenFOAM/primitives/DiagTensor/DiagTensorI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2020-2023 OpenCFD Ltd.
+    Copyright (C) 2020-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -32,9 +32,9 @@ License
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class Cmpt>
-inline Foam::DiagTensor<Cmpt>::DiagTensor(const Foam::zero)
+inline Foam::DiagTensor<Cmpt>::DiagTensor(Foam::zero)
 :
-    VectorSpace<DiagTensor<Cmpt>, Cmpt, 3>(Zero)
+    VectorSpace<DiagTensor<Cmpt>, Cmpt, 3>(Foam::zero{})
 {}
 
 
@@ -81,6 +81,13 @@ inline Foam::DiagTensor<Cmpt>::DiagTensor(Istream& is)
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+template<class Cmpt>
+inline Foam::Vector<Cmpt> Foam::DiagTensor<Cmpt>::diag() const
+{
+    return Vector<Cmpt>(this->xx(), this->yy(), this->zz());
+}
+
+
 template<class Cmpt>
 inline Foam::scalar Foam::DiagTensor<Cmpt>::diagSqr() const
 {

src/OpenFOAM/primitives/SymmTensor/SymmTensor.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2023 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -94,7 +94,7 @@ public:
     // Constructors
 
         //- Construct initialized to zero
-        inline SymmTensor(const Foam::zero);
+        inline SymmTensor(Foam::zero);
 
         //- Construct given VectorSpace of the same rank
         template<class Cmpt2>
@@ -234,6 +234,12 @@ public:
         inline scalar diagSqr() const;
 
 
+    // Characteristics
+
+        //- Is identity tensor?
+        inline bool is_identity(const scalar tol = ROOTVSMALL) const;
+
+
     // Tensor Operations
 
         //- Return non-Hermitian transpose

src/OpenFOAM/primitives/SymmTensor/SymmTensorI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2023 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -31,9 +31,9 @@ License
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class Cmpt>
-inline Foam::SymmTensor<Cmpt>::SymmTensor(const Foam::zero)
+inline Foam::SymmTensor<Cmpt>::SymmTensor(Foam::zero)
 :
-    SymmTensor::vsType(Zero)
+    SymmTensor::vsType(Foam::zero{})
 {}
 
 
@@ -238,6 +238,21 @@ inline Foam::scalar Foam::SymmTensor<Cmpt>::diagSqr() const
 }
 
 
+template<class Cmpt>
+inline bool Foam::SymmTensor<Cmpt>::is_identity(const scalar tol) const
+{
+    return
+    (
+        Foam::mag(xx() - pTraits<Cmpt>::one) < tol
+     && Foam::mag(yy() - pTraits<Cmpt>::one) < tol
+     && Foam::mag(zz() - pTraits<Cmpt>::one) < tol
+     && Foam::mag(xy()) < tol
+     && Foam::mag(xz()) < tol
+     && Foam::mag(yz()) < tol
+    );
+}
+
+
 template<class Cmpt>
 inline Cmpt Foam::SymmTensor<Cmpt>::det() const
 {

src/OpenFOAM/primitives/Tensor/TensorI.H

@@ -410,12 +410,12 @@ inline bool Foam::Tensor<Cmpt>::is_identity(const scalar tol) const
 {
     return
     (
-        mag(xx() - pTraits<Cmpt>::one) < tol
-     && mag(yy() - pTraits<Cmpt>::one) < tol
-     && mag(zz() - pTraits<Cmpt>::one) < tol
-     && mag(xy()) < tol && mag(xz()) < tol
-     && mag(yx()) < tol && mag(yz()) < tol
-     && mag(zx()) < tol && mag(zy()) < tol
+        Foam::mag(xx() - pTraits<Cmpt>::one) < tol
+     && Foam::mag(yy() - pTraits<Cmpt>::one) < tol
+     && Foam::mag(zz() - pTraits<Cmpt>::one) < tol
+     && Foam::mag(xy()) < tol && Foam::mag(xz()) < tol
+     && Foam::mag(yx()) < tol && Foam::mag(yz()) < tol
+     && Foam::mag(zx()) < tol && Foam::mag(zy()) < tol
     );
 }
 

src/TurbulenceModels/turbulenceModels/LES/sigma/sigma.C

@@ -43,8 +43,8 @@ template<class BasicTurbulenceModel>
 void sigma<BasicTurbulenceModel>::correctNut()
 {
     this->nut_ =
-        sqr(this->delta())
-       *DESModel<BasicTurbulenceModel>::Ssigma(fvc::grad(this->U_), Csigma_);
+        sqr(this->delta()*Csigma_)
+       *DESModel<BasicTurbulenceModel>::Ssigma(fvc::grad(this->U_), scalar(1));
     this->nut_.correctBoundaryConditions();
     fv::options::New(this->mesh_).correct(this->nut_);
 

src/finiteArea/Make/files

@@ -45,7 +45,6 @@ $(faPatchFields)/faPatchField/faPatchFieldBase.C
 $(faPatchFields)/faPatchField/faPatchFields.C
 
 basicFaPatchFields = $(faPatchFields)/basic
-$(basicFaPatchFields)/basicSymmetry/basicSymmetryFaPatchFields.C
 $(basicFaPatchFields)/calculated/calculatedFaPatchFields.C
 $(basicFaPatchFields)/extrapolatedCalculated/extrapolatedCalculatedFaPatchFields.C
 $(basicFaPatchFields)/coupled/coupledFaPatchFields.C

src/finiteArea/faMesh/faPatches/constraint/wedge/wedgeFaPatch.C

@@ -93,16 +93,12 @@ Foam::wedgeFaPatch::wedgeFaPatch
             << this->name() << exit(FatalError);
     }
 
-    const auto* wedgePtr = isA<wedgePolyPatch>
+    wedgePolyPatchPtr_ = isA<wedgePolyPatch>
     (
         bm.mesh().mesh().boundaryMesh()[ngbPolyPatchIndex()]
     );
 
-    if (wedgePtr)
-    {
-        wedgePolyPatchPtr_ = wedgePtr;
-    }
-    else
+    if (!wedgePolyPatchPtr_)
     {
         FatalErrorInFunction
             << "Neighbour polyPatch is not of type "

src/finiteArea/faMesh/faPatches/constraint/wedge/wedgeFaPatch.H

@@ -77,7 +77,9 @@ public:
     //- Runtime type information
     TypeName("wedge");
 
-    //- Construct from dictionary
+    //- Construct from dictionary.
+    //  Fatal if ngbPolyPatchIndex is not defined
+    //  or does not correspond to a wedgePolyPatch
     wedgeFaPatch
     (
         const word& name,
@@ -97,25 +99,25 @@ public:
         // Access
 
             //- Return axis of the wedge
-            const vector& axis() const
+            const vector& axis() const noexcept
             {
                 return wedgePolyPatchPtr_->axis();
             }
 
             //- Return plane normal between the wedge boundaries
-            const vector& centreNormal() const
+            const vector& centreNormal() const noexcept
             {
                 return wedgePolyPatchPtr_->centreNormal();
             }
 
             //- Return face transformation tensor
-            const tensor& edgeT() const
+            const tensor& edgeT() const noexcept
             {
                 return wedgePolyPatchPtr_->faceT();
             }
 
             //- Return neighbour-cell transformation tensor
-            const tensor& faceT() const
+            const tensor& faceT() const noexcept
             {
                 return wedgePolyPatchPtr_->cellT();
             }

src/finiteArea/faMesh/faPatches/faPatch/faPatch.H

@@ -480,25 +480,26 @@ public:
                 const UList<Type>& internalData
             ) const;
 
-            //- Return the patch field of the GeometricField
-            //- corresponding to this patch.
-            template<class GeometricField, class AnyType = bool>
-            const typename GeometricField::Patch& patchField
-            (
-                const GeometricField& gf
-            ) const;
 
-            //- Lookup the named field from the local registry and
-            //- return the patch field corresponding to this patch.
-            //  N.B.  The dummy pointer arguments are used if this function is
-            //  instantiated within a templated function to avoid a bug in gcc.
-            template<class GeometricField, class AnyType = bool>
-            const typename GeometricField::Patch& lookupPatchField
-            (
-                const word& name,
-                const GeometricField* = nullptr,
-                const AnyType* = nullptr
-            ) const;
+    // Lookup
+
+        //- Return the patch field of the GeometricField
+        //- corresponding to this patch.
+        template<class GeometricField, class AnyType = bool>
+        const typename GeometricField::Patch&
+        patchField(const GeometricField& gf) const;
+
+        //- Lookup the named field from the local registry and
+        //- return the patch field corresponding to this patch.
+        template<class GeometricField, class AnyType = bool>
+        const typename GeometricField::Patch&
+        lookupPatchField(const word& fldName) const;
+
+        //- Lookup the named field (if any) from the local registry and
+        //- return the patch field corresponding to this patch.
+        template<class GeometricField>
+        const typename GeometricField::Patch*
+        cfindPatchField(const word& fldName) const;
 
 
     // Ostream Operator

src/finiteArea/faMesh/faPatches/faPatch/faPatchFaMeshTemplates.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016-2017 Wikki Ltd
-    Copyright (C) 2021-2022 OpenCFD Ltd.
+    Copyright (C) 2021-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -31,18 +31,33 @@ License
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class GeometricField, class AnyType>
-const typename GeometricField::Patch& Foam::faPatch::lookupPatchField
-(
-    const word& name,
-    const GeometricField*,
-    const AnyType*
-) const
+const typename GeometricField::Patch&
+Foam::faPatch::lookupPatchField(const word& fldName) const
 {
     return
         boundaryMesh().mesh().thisDb().template
-            lookupObject<GeometricField>(name)
+            lookupObject<GeometricField>(fldName)
             .boundaryField()[this->index()];
 }
 
 
+template<class GeometricField>
+const typename GeometricField::Patch*
+Foam::faPatch::cfindPatchField(const word& fldName) const
+{
+    const auto* fldptr =
+        boundaryMesh().mesh().thisDb().template
+        cfindObject<GeometricField>(fldName);
+
+    if (fldptr)
+    {
+        return &(fldptr->boundaryField()[this->index()]);
+    }
+    else
+    {
+        return nullptr;
+    }
+}
+
+
 // ************************************************************************* //

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

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016-2017 Wikki Ltd
+    Copyright (C) 2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -85,13 +86,25 @@ template<class Type>
 Foam::tmp<Foam::Field<Type>>
 Foam::basicSymmetryFaPatchField<Type>::snGrad() const
 {
-    const vectorField nHat(this->patch().edgeNormals());
+    if constexpr (!is_rotational_vectorspace_v<Type>)
+    {
+        // Rotational-invariant type : treat like zero-gradient
+        return tmp<Field<Type>>::New(this->size(), Foam::zero{});
+    }
+    else
+    {
+        tmp<vectorField> nHat = this->patch().edgeNormals();
 
-    return
-    (
-        transform(I - 2.0*sqr(nHat), this->patchInternalField())
-      - this->patchInternalField()
-    )*(this->patch().deltaCoeffs()/2.0);
+        const auto& dc = this->patch().deltaCoeffs();
+
+        const Field<Type> pif(this->patchInternalField());
+
+        return
+        (
+            (0.5*dc)
+          * (transform(I - 2.0*sqr(nHat), pif) - pif)
+        );
+    }
 }
 
 
@@ -103,14 +116,22 @@ void Foam::basicSymmetryFaPatchField<Type>::evaluate(const Pstream::commsTypes)
         this->updateCoeffs();
     }
 
-    const vectorField nHat(this->patch().edgeNormals());
-    Field<Type>::operator=
-    (
+    if constexpr (!is_rotational_vectorspace_v<Type>)
+    {
+        // Rotational-invariant type : treat like zero-gradient
+        this->extrapolateInternal();
+    }
+    else
+    {
+        tmp<vectorField> nHat = this->patch().edgeNormals();
+
+        const Field<Type> pif(this->patchInternalField());
+
+        Field<Type>::operator=
         (
-            this->patchInternalField()
-          + transform(I - 2.0*sqr(nHat), this->patchInternalField())
-        )/2.0
-    );
+            0.5*(pif + transform(I - 2.0*sqr(nHat), pif))
+        );
+    }
 
     transformFaPatchField<Type>::evaluate();
 }

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

@@ -143,18 +143,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

@@ -1,59 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2016-2017 Wikki 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 "basicSymmetryFaPatchField.H"
-#include "areaFields.H"
-
-// No run-time selection
-
-// * * * * * * * * * * * * * * * 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/coupled/coupledFaPatchField.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016-2017 Wikki Ltd
-    Copyright (C) 2019-2023 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -125,7 +125,7 @@ public:
         ) const = 0;
 
 
-    // Member functions
+    // Member Functions
 
         // Access
 
@@ -139,6 +139,9 @@ public:
             //- Return neighbour field of internal field
             virtual tmp<Field<Type>> patchNeighbourField() const = 0;
 
+            //- Retrieve neighbour coupled field
+            virtual void patchNeighbourField(UList<Type>&) const = 0;
+
 
         // Evaluation functions
 

src/finiteArea/fields/faPatchFields/basic/sliced/slicedFaPatchField.C

@@ -151,24 +151,12 @@ Foam::slicedFaPatchField<Type>::patchInternalField() const
 
 
 template<class Type>
-void Foam::slicedFaPatchField<Type>::patchInternalField(Field<Type>&) const
+void Foam::slicedFaPatchField<Type>::patchInternalField(UList<Type>&) const
 {
     NotImplemented;
 }
 
 
-template<class Type>
-Foam::tmp<Foam::Field<Type>>
-Foam::slicedFaPatchField<Type>::patchNeighbourField
-(
-    const Field<Type>& iField
-) const
-{
-    NotImplemented;
-    return nullptr;
-}
-
-
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
 Foam::slicedFaPatchField<Type>::patchNeighbourField() const
@@ -178,6 +166,13 @@ Foam::slicedFaPatchField<Type>::patchNeighbourField() const
 }
 
 
+template<class Type>
+void Foam::slicedFaPatchField<Type>::patchNeighbourField(UList<Type>&) const
+{
+    NotImplemented;
+}
+
+
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
 Foam::slicedFaPatchField<Type>::valueInternalCoeffs

src/finiteArea/fields/faPatchFields/basic/sliced/slicedFaPatchField.H

@@ -153,27 +153,23 @@ public:
         virtual bool assignable() const { return false; }
 
 
-        // Evaluation functions
+        // Evaluation Functions
 
             //- Return patch-normal gradient
             virtual tmp<Field<Type>> snGrad() const;
 
-            //- Return internal field next to patch as patch field
+            //- Return internal field next to patch
             virtual tmp<Field<Type>> patchInternalField() const;
 
-            //- Return internal field next to patch as patch field
-            virtual void patchInternalField(Field<Type>&) const;
+            //- Retrieve internal field next to patch
+            virtual void patchInternalField(UList<Type>&) const;
 
-            //- Return neighbour coupled given internal cell data
-            virtual tmp<Field<Type>> patchNeighbourField
-            (
-                const Field<Type>& iField
-            ) const;
-
-            //- Return patchField of the values on the patch or on the
-            //  opposite patch
+            //- Return patchField on the opposite patch of a coupled patch
             virtual tmp<Field<Type>> patchNeighbourField() const;
 
+            //- Retrieve neighbour coupled field
+            virtual void patchNeighbourField(UList<Type>&) const;
+
             //- Initialise the evaluation of the patch field
             virtual void initEvaluate
             (

src/finiteArea/fields/faPatchFields/basic/transform/transformFaPatchField.C

@@ -37,7 +37,7 @@ Foam::transformFaPatchField<Type>::transformFaPatchField
     const DimensionedField<Type, areaMesh>& iF
 )
 :
-   faPatchField<Type>(p, iF)
+    faPatchField<Type>(p, iF)
 {}
 
 

src/finiteArea/fields/faPatchFields/basic/transform/transformFaPatchField.H

@@ -148,12 +148,6 @@ public:
 };
 
 
-// * * * * * * * * * * * Template Specialisations  * * * * * * * * * * * * * //
-
-template<>
-tmp<scalarField> transformFaPatchField<scalar>::gradientInternalCoeffs() const;
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

src/finiteArea/fields/faPatchFields/basic/transform/transformFaPatchFields.C

@@ -37,14 +37,4 @@ namespace Foam
 }
 
 
-// * * * * * * * * * * * * * * * Specialisations * * * * * * * * * * * * * * //
-
-template<>
-Foam::tmp<Foam::scalarField>
-Foam::transformFaPatchField<Foam::scalar>::gradientInternalCoeffs() const
-{
-    return tmp<scalarField>::New(size(), Zero);
-}
-
-
 // ************************************************************************* //

src/finiteArea/fields/faPatchFields/constraint/cyclic/cyclicFaPatchField.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016-2017 Wikki Ltd
-    Copyright (C) 2019-2023 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -124,16 +124,15 @@ Foam::cyclicFaPatchField<Type>::cyclicFaPatchField
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class Type>
-Foam::tmp<Foam::Field<Type>>
-Foam::cyclicFaPatchField<Type>::patchNeighbourField() const
+void Foam::cyclicFaPatchField<Type>::patchNeighbourField
+(
+    UList<Type>& pnf
+) const
 {
     const Field<Type>& iField = this->primitiveField();
     const labelUList& faceCells = cyclicPatch_.faceCells();
 
-    auto tpnf = tmp<Field<Type>>::New(this->size());
-    auto& pnf = tpnf.ref();
-
-    const label sizeby2 = this->size()/2;
+    const label sizeby2 = pnf.size()/2;
 
     if (doTransform())
     {
@@ -158,7 +157,15 @@ Foam::cyclicFaPatchField<Type>::patchNeighbourField() const
             pnf[facei + sizeby2] = iField[faceCells[facei]];
         }
     }
+}
 
+
+template<class Type>
+Foam::tmp<Foam::Field<Type>>
+Foam::cyclicFaPatchField<Type>::patchNeighbourField() const
+{
+    auto tpnf = tmp<Field<Type>>::New(this->size());
+    this->patchNeighbourField(tpnf.ref());
     return tpnf;
 }
 

src/finiteArea/fields/faPatchFields/constraint/cyclic/cyclicFaPatchField.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016-2017 Wikki Ltd
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -67,17 +67,6 @@ class cyclicFaPatchField
         //- Local reference cast into the cyclic patch
         const cyclicFaPatch& cyclicPatch_;
 
-
-    // Private Member Functions
-
-        //- Return neighbour side field given internal fields
-        template<class Type2>
-        tmp<Field<Type2>> neighbourSideField
-        (
-            const Field<Type2>&
-        ) const;
-
-
 public:
 
     //- Runtime type information
@@ -141,22 +130,25 @@ public:
         }
 
 
-    // Member functions
+    // Member Functions
 
         // Access
 
             //- Return local reference cast into the cyclic patch
-            const cyclicFaPatch& cyclicPatch() const
+            const cyclicFaPatch& cyclicPatch() const noexcept
             {
                 return cyclicPatch_;
             }
 
 
-        // Evaluation functions
+        // Evaluation Functions
 
             //- Return neighbour coupled given internal cell data
             virtual tmp<Field<Type>> patchNeighbourField() const;
 
+            //- Retrieve neighbour coupled given internal cell data
+            virtual void patchNeighbourField(UList<Type>& pnf) const;
+
 
         // Coupled interface functionality
 

src/finiteArea/fields/faPatchFields/constraint/processor/processorFaPatchField.C

@@ -207,6 +207,22 @@ Foam::processorFaPatchField<Type>::patchNeighbourField() const
 }
 
 
+template<class Type>
+void Foam::processorFaPatchField<Type>::patchNeighbourField
+(
+    UList<Type>& pnf
+) const
+{
+    if (debug && !this->ready())
+    {
+        FatalErrorInFunction
+            << "Outstanding request on patch " << procPatch_.name()
+            << abort(FatalError);
+    }
+    pnf.deepCopy(*this);
+}
+
+
 template<class Type>
 void Foam::processorFaPatchField<Type>::initEvaluate
 (
@@ -215,6 +231,7 @@ void Foam::processorFaPatchField<Type>::initEvaluate
 {
     if (UPstream::parRun())
     {
+        sendBuf_.resize_nocopy(this->patch().size());
         this->patchInternalField(sendBuf_);
 
         if (commsType == UPstream::commsTypes::nonBlocking)

src/finiteArea/fields/faPatchFields/constraint/processor/processorFaPatchField.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016-2017 Wikki Ltd
-    Copyright (C) 2019-2023 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -177,6 +177,9 @@ public:
         //- Return neighbour field given internal field
         virtual tmp<Field<Type>> patchNeighbourField() const;
 
+        //- Retrieve neighbour field
+        virtual void patchNeighbourField(UList<Type>& pnf) const;
+
 
     // Evaluation
 

src/finiteArea/fields/faPatchFields/constraint/wedge/wedgeFaPatchField.C

@@ -29,7 +29,6 @@ License
 #include "wedgeFaPatchField.H"
 #include "transformField.H"
 #include "symmTransform.H"
-#include "diagTensor.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -105,13 +104,25 @@ Foam::wedgeFaPatchField<Type>::wedgeFaPatchField
 template<class Type>
 Foam::tmp<Foam::Field<Type>> Foam::wedgeFaPatchField<Type>::snGrad() const
 {
-    const Field<Type> pif (this->patchInternalField());
+    if constexpr (!is_rotational_vectorspace_v<Type>)
+    {
+        // Rotational-invariant type: treat like zero-gradient
+        return tmp<Field<Type>>::New(this->size(), Foam::zero{});
+    }
+    else
+    {
+        const auto& rot = refCast<const wedgeFaPatch>(this->patch()).faceT();
 
-    return
-    (
-        transform(refCast<const wedgeFaPatch>(this->patch()).faceT(), pif)
-      - pif
-    )*(0.5*this->patch().deltaCoeffs());
+        const Field<Type> pif(this->patchInternalField());
+
+        const auto& dc = this->patch().deltaCoeffs();
+
+        return
+        (
+            (0.5*dc)
+          * (transform(rot, pif) - pif)
+        );
+    }
 }
 
 
@@ -123,14 +134,20 @@ void Foam::wedgeFaPatchField<Type>::evaluate(const Pstream::commsTypes)
         this->updateCoeffs();
     }
 
-    faPatchField<Type>::operator==
-    (
-        transform
+    if constexpr (!is_rotational_vectorspace_v<Type>)
+    {
+        // Rotational-invariant type: treat like zero-gradient
+        this->extrapolateInternal();
+    }
+    else
+    {
+        const auto& rot = refCast<const wedgeFaPatch>(this->patch()).edgeT();
+
+        faPatchField<Type>::operator==
         (
-            refCast<const wedgeFaPatch>(this->patch()).edgeT(),
-            this->patchInternalField()
-        )
-    );
+            transform(rot, this->patchInternalField())
+        );
+    }
 }
 
 
@@ -138,10 +155,9 @@ template<class Type>
 Foam::tmp<Foam::Field<Type>>
 Foam::wedgeFaPatchField<Type>::snGradTransformDiag() const
 {
-    const diagTensor diagT =
-        0.5*diag(I - refCast<const wedgeFaPatch>(this->patch()).faceT());
+    const auto& rot = refCast<const wedgeFaPatch>(this->patch()).faceT();
 
-    const vector diagV(diagT.xx(), diagT.yy(), diagT.zz());
+    const vector diagV = 0.5*(I - rot).diag();
 
     return tmp<Field<Type>>::New
     (

src/finiteArea/fields/faPatchFields/constraint/wedge/wedgeFaPatchField.H

@@ -133,18 +133,6 @@ public:
 };
 
 
-// * * * * * * * * * * * Template Specialisations  * * * * * * * * * * * * * //
-
-template<>
-tmp<scalarField> wedgeFaPatchField<scalar>::snGrad() const;
-
-template<>
-void wedgeFaPatchField<scalar>::evaluate
-(
-    const Pstream::commsTypes commsType
-);
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

src/finiteArea/fields/faPatchFields/constraint/wedge/wedgeFaPatchFields.C

@@ -36,26 +36,4 @@ namespace Foam
     makeFaPatchFields(wedge);
 }
 
-// * * * * * * * * * * * * * * * Specialisations * * * * * * * * * * * * * * //
-
-template<>
-Foam::tmp<Foam::scalarField>
-Foam::wedgeFaPatchField<Foam::scalar>::snGrad() const
-{
-    return tmp<scalarField>::New(size(), Zero);
-}
-
-
-template<>
-void Foam::wedgeFaPatchField<Foam::scalar>::evaluate(const Pstream::commsTypes)
-{
-    if (!updated())
-    {
-        updateCoeffs();
-    }
-
-    this->operator==(patchInternalField());
-}
-
-
 // ************************************************************************* //

src/finiteArea/fields/faPatchFields/faPatchField/faPatchField.C

@@ -215,11 +215,9 @@ Foam::faPatchField<Type>::patchInternalField() const
 
 
 template<class Type>
-void Foam::faPatchField<Type>::patchInternalField(Field<Type>& pfld) const
+void Foam::faPatchField<Type>::patchInternalField(UList<Type>& pfld) const
 {
-    const auto& p = faPatchFieldBase::patch();
-    pfld.resize_nocopy(p.size());  // In general this is a no-op
-    p.patchInternalField(internalField_, pfld);
+    patch().patchInternalField(internalField_, pfld);
 }
 
 

src/finiteArea/fields/faPatchFields/faPatchField/faPatchField.H

@@ -543,7 +543,7 @@ public:
             );
 
 
-        // Evaluation
+        // Evaluation Functions
 
             //- Return patch-normal gradient
             virtual tmp<Field<Type>> snGrad() const;
@@ -551,9 +551,9 @@ public:
             //- Return internal field next to patch
             virtual tmp<Field<Type>> patchInternalField() const;
 
-            //- Extract internal field next to patch
+            //- Retrieve internal field next to patch
             //  \param [out] pfld The extracted patch field.
-            virtual void patchInternalField(Field<Type>& pfld) const;
+            virtual void patchInternalField(UList<Type>& pfld) const;
 
             //- Return patchField on the opposite patch of a coupled patch
             virtual tmp<Field<Type>> patchNeighbourField() const
@@ -562,6 +562,12 @@ public:
                 return *this;
             }
 
+            //- Retrieve patchField on the opposite patch of a coupled patch
+            virtual void patchNeighbourField(UList<Type>&) const
+            {
+                NotImplemented;
+            }
+
             //- Update the coefficients associated with the patch field
             //  Sets Updated to true
             virtual void updateCoeffs();

src/finiteVolume/Make/files

@@ -128,7 +128,6 @@ $(fvPatchFields)/fvPatchField/fvPatchFieldBase.C
 $(fvPatchFields)/fvPatchField/fvPatchFields.C
 
 basicFvPatchFields = $(fvPatchFields)/basic
-$(basicFvPatchFields)/basicSymmetry/basicSymmetryFvPatchFields.C
 $(basicFvPatchFields)/calculated/calculatedFvPatchFields.C
 $(basicFvPatchFields)/extrapolatedCalculated/extrapolatedCalculatedFvPatchFields.C
 $(basicFvPatchFields)/coupled/coupledFvPatchFields.C

src/finiteVolume/fields/fvPatchFields/basic/basicSymmetry/basicSymmetryFvPatchField.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -85,13 +86,25 @@ template<class Type>
 Foam::tmp<Foam::Field<Type>>
 Foam::basicSymmetryFvPatchField<Type>::snGrad() const
 {
-    tmp<vectorField> nHat = this->patch().nf();
+    if constexpr (!is_rotational_vectorspace_v<Type>)
+    {
+        // Rotational-invariant type : treat like zero-gradient
+        return tmp<Field<Type>>::New(this->size(), Foam::zero{});
+    }
+    else
+    {
+        tmp<vectorField> nHat = this->patch().nf();
 
-    const Field<Type> iF(this->patchInternalField());
+        const auto& dc = this->patch().deltaCoeffs();
 
-    return
-        (transform(I - 2.0*sqr(nHat), iF) - iF)
-       *(this->patch().deltaCoeffs()/2.0);
+        const Field<Type> pif(this->patchInternalField());
+
+        return
+        (
+            (0.5*dc)
+          * (transform(I - 2.0*sqr(nHat), pif) - pif)
+        );
+    }
 }
 
 
@@ -103,14 +116,22 @@ void Foam::basicSymmetryFvPatchField<Type>::evaluate(const Pstream::commsTypes)
         this->updateCoeffs();
     }
 
-    tmp<vectorField> nHat = this->patch().nf();
+    if constexpr (!is_rotational_vectorspace_v<Type>)
+    {
+        // Rotational-invariant type : treat like zero-gradient
+        this->extrapolateInternal();
+    }
+    else
+    {
+        tmp<vectorField> nHat = this->patch().nf();
 
-    const Field<Type> iF(this->patchInternalField());
+        const Field<Type> pif(this->patchInternalField());
 
-    Field<Type>::operator=
-    (
-        (iF + transform(I - 2.0*sqr(nHat), iF))/2.0
-    );
+        Field<Type>::operator=
+        (
+            0.5*(pif + transform(I - 2.0*sqr(nHat), pif))
+        );
+    }
 
     transformFvPatchField<Type>::evaluate();
 }

src/finiteVolume/fields/fvPatchFields/basic/basicSymmetry/basicSymmetryFvPatchField.H

@@ -139,18 +139,6 @@ public:
 };
 
 
-// * * * * * * * * * * * Template Specialisations  * * * * * * * * * * * * * //
-
-template<>
-tmp<scalarField> basicSymmetryFvPatchField<scalar>::snGrad() const;
-
-template<>
-void basicSymmetryFvPatchField<scalar>::evaluate
-(
-    const Pstream::commsTypes commsType
-);
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

src/finiteVolume/fields/fvPatchFields/basic/basicSymmetry/basicSymmetryFvPatchFields.C

@@ -1,59 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2011-2013 OpenFOAM Foundation
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "basicSymmetryFvPatchField.H"
-#include "volFields.H"
-
-// No run-time selection
-
-// * * * * * * * * * * * * * * * Specialisations * * * * * * * * * * * * * * //
-
-template<>
-Foam::tmp<Foam::scalarField>
-Foam::basicSymmetryFvPatchField<Foam::scalar>::snGrad() const
-{
-    return tmp<scalarField>::New(size(), Zero);
-}
-
-
-template<>
-void Foam::basicSymmetryFvPatchField<Foam::scalar>::evaluate
-(
-    const Pstream::commsTypes
-)
-{
-    if (!updated())
-    {
-        updateCoeffs();
-    }
-
-    scalarField::operator=(patchInternalField());
-    transformFvPatchField<scalar>::evaluate();
-}
-
-
-// ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/basic/coupled/coupledFvPatchField.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2023 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -142,7 +142,7 @@ public:
         ) const = 0;
 
 
-    // Member functions
+    // Member Functions
 
         // Access
 
@@ -155,8 +155,11 @@ public:
             //- Return neighbour field of internal field
             virtual tmp<Field<Type>> patchNeighbourField() const = 0;
 
+            //- Retrieve neighbour coupled data
+            virtual void patchNeighbourField(UList<Type>&) const = 0;
 
-        // Evaluation functions
+
+        // Evaluation Functions
 
             //- Return patch-normal gradient
             virtual tmp<Field<Type>> snGrad

src/finiteVolume/fields/fvPatchFields/basic/sliced/slicedFvPatchField.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2023 OpenCFD Ltd.
+    Copyright (C) 2017-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -151,24 +151,12 @@ Foam::slicedFvPatchField<Type>::patchInternalField() const
 
 
 template<class Type>
-void Foam::slicedFvPatchField<Type>::patchInternalField(Field<Type>&) const
+void Foam::slicedFvPatchField<Type>::patchInternalField(UList<Type>&) const
 {
     NotImplemented;
 }
 
 
-template<class Type>
-Foam::tmp<Foam::Field<Type>>
-Foam::slicedFvPatchField<Type>::patchNeighbourField
-(
-    const Field<Type>& iField
-) const
-{
-    NotImplemented;
-    return nullptr;
-}
-
-
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
 Foam::slicedFvPatchField<Type>::patchNeighbourField() const
@@ -178,6 +166,13 @@ Foam::slicedFvPatchField<Type>::patchNeighbourField() const
 }
 
 
+template<class Type>
+void Foam::slicedFvPatchField<Type>::patchNeighbourField(UList<Type>&) const
+{
+    NotImplemented;
+}
+
+
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
 Foam::slicedFvPatchField<Type>::valueInternalCoeffs

src/finiteVolume/fields/fvPatchFields/basic/sliced/slicedFvPatchField.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2017-2023 OpenCFD Ltd.
+    Copyright (C) 2017-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -151,27 +151,23 @@ public:
         virtual bool assignable() const { return false; }
 
 
-        // Evaluation functions
+        // Evaluation Functions
 
             //- Return patch-normal gradient
             virtual tmp<Field<Type>> snGrad() const;
 
-            //- Return internal field next to patch as patch field
+            //- Return internal field next to patch
             virtual tmp<Field<Type>> patchInternalField() const;
 
-            //- Return internal field next to patch as patch field
-            virtual void patchInternalField(Field<Type>&) const;
+            //- Retrieve internal field next to patch
+            virtual void patchInternalField(UList<Type>&) const;
 
-            //- Return neighbour coupled given internal cell data
-            virtual tmp<Field<Type>> patchNeighbourField
-            (
-                const Field<Type>& iField
-            ) const;
-
-            //- Return patchField of the values on the patch or on the
-            //  opposite patch
+            //- Return patchField on the opposite patch of a coupled patch
             virtual tmp<Field<Type>> patchNeighbourField() const;
 
+            //- Retrieve neighbour coupled field
+            virtual void patchNeighbourField(UList<Type>&) const;
+
             //- Initialise the evaluation of the patch field
             virtual void initEvaluate
             (

src/finiteVolume/fields/fvPatchFields/basic/transform/transformFvPatchField.H

@@ -157,18 +157,6 @@ public:
 };
 
 
-// * * * * * * * * * * * Template Specialisations  * * * * * * * * * * * * * //
-
-template<>
-tmp<scalarField> transformFvPatchField<scalar>::valueInternalCoeffs
-(
-    const tmp<scalarField>&
-) const;
-
-template<>
-tmp<scalarField> transformFvPatchField<scalar>::gradientInternalCoeffs() const;
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

src/finiteVolume/fields/fvPatchFields/basic/transform/transformFvPatchFields.C

@@ -37,25 +37,4 @@ namespace Foam
 }
 
 
-// * * * * * * * * * * * * * * * Specialisations * * * * * * * * * * * * * * //
-
-template<>
-Foam::tmp<Foam::scalarField>
-Foam::transformFvPatchField<Foam::scalar>::valueInternalCoeffs
-(
-    const tmp<scalarField>&
-) const
-{
-    return tmp<scalarField>::New(size(), 1.0);
-}
-
-
-template<>
-Foam::tmp<Foam::scalarField>
-Foam::transformFvPatchField<Foam::scalar>::gradientInternalCoeffs() const
-{
-    return tmp<scalarField>::New(size(), Zero);
-}
-
-
 // ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/constraint/calculatedProcessor/calculatedProcessorFvPatchField.C

@@ -110,6 +110,25 @@ Foam::calculatedProcessorFvPatchField<Type>::patchNeighbourField() const
 }
 
 
+template<class Type>
+void Foam::calculatedProcessorFvPatchField<Type>::patchNeighbourField
+(
+    UList<Type>& pnf
+) const
+{
+    if (!this->ready())
+    {
+        FatalErrorInFunction
+            << "Outstanding request on patch of size "
+            << procInterface_.faceCells().size()
+            << " between proc " << procInterface_.myProcNo()
+            << " and " << procInterface_.neighbProcNo()
+            << abort(FatalError);
+    }
+    pnf.deepCopy(*this);
+}
+
+
 template<class Type>
 void Foam::calculatedProcessorFvPatchField<Type>::initEvaluate
 (

src/finiteVolume/fields/fvPatchFields/constraint/calculatedProcessor/calculatedProcessorFvPatchField.H

@@ -169,9 +169,12 @@ public:
         //- Are all (receive) data available?
         virtual bool ready() const;
 
-        //- Return neighbour field of internal field
+        //- Return neighbour field
         virtual tmp<Field<Type>> patchNeighbourField() const;
 
+        //- Retrieve neighbour field
+        virtual void patchNeighbourField(UList<Type>& result) const;
+
 
     // Evaluation
 

src/finiteVolume/fields/fvPatchFields/constraint/cyclic/cyclicFvPatchField.C

@@ -127,17 +127,12 @@ Foam::cyclicFvPatchField<Type>::cyclicFvPatchField
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class Type>
-Foam::tmp<Foam::Field<Type>>
-Foam::cyclicFvPatchField<Type>::patchNeighbourField() const
+void Foam::cyclicFvPatchField<Type>::patchNeighbourField(UList<Type>& pnf) const
 {
     const Field<Type>& iField = this->primitiveField();
     const labelUList& nbrFaceCells =
         cyclicPatch().cyclicPatch().neighbPatch().faceCells();
 
-    auto tpnf = tmp<Field<Type>>::New(this->size());
-    auto& pnf = tpnf.ref();
-
-
     if (doTransform())
     {
         forAll(pnf, facei)
@@ -155,7 +150,15 @@ Foam::cyclicFvPatchField<Type>::patchNeighbourField() const
             pnf[facei] = iField[nbrFaceCells[facei]];
         }
     }
+}
 
+
+template<class Type>
+Foam::tmp<Foam::Field<Type>>
+Foam::cyclicFvPatchField<Type>::patchNeighbourField() const
+{
+    auto tpnf = tmp<Field<Type>>::New(this->size());
+    this->patchNeighbourField(tpnf.ref());
     return tpnf;
 }
 
@@ -164,7 +167,7 @@ template<class Type>
 const Foam::cyclicFvPatchField<Type>&
 Foam::cyclicFvPatchField<Type>::neighbourPatchField() const
 {
-    const GeometricField<Type, fvPatchField, volMesh>& fld =
+    const auto& fld =
     static_cast<const GeometricField<Type, fvPatchField, volMesh>&>
     (
         this->primitiveField()

src/finiteVolume/fields/fvPatchFields/constraint/cyclic/cyclicFvPatchField.H

@@ -83,16 +83,6 @@ class cyclicFvPatchField
         const cyclicFvPatch& cyclicPatch_;
 
 
-    // Private Member Functions
-
-        //- Return neighbour side field given internal fields
-        template<class Type2>
-        tmp<Field<Type2>> neighbourSideField
-        (
-            const Field<Type2>&
-        ) const;
-
-
 public:
 
 
@@ -172,6 +162,9 @@ public:
             //- Return neighbour coupled internal cell data
             virtual tmp<Field<Type>> patchNeighbourField() const;
 
+            //- Retrieve neighbour coupled internal cell data
+            virtual void patchNeighbourField(UList<Type>& pnf) const;
+
             //- Return reference to neighbour patchField
             const cyclicFvPatchField<Type>& neighbourPatchField() const;
 

src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2013-2017 OpenFOAM Foundation
-    Copyright (C) 2019-2024 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -91,11 +91,12 @@ Foam::cyclicACMIFvPatchField<Type>::cyclicACMIFvPatchField
         // Extra check: make sure that the non-overlap patch is before
         // this so it has actually been read - evaluate will crash otherwise
 
-        const GeometricField<Type, fvPatchField, volMesh>& fld =
+        const auto& fld =
             static_cast<const GeometricField<Type, fvPatchField, volMesh>&>
             (
                 this->primitiveField()
             );
+
         if (!fld.boundaryField().set(cyclicACMIPatch_.nonOverlapPatchID()))
         {
             FatalIOErrorInFunction(dict)
@@ -284,32 +285,27 @@ bool Foam::cyclicACMIFvPatchField<Type>::ready() const
 
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
-Foam::cyclicACMIFvPatchField<Type>::patchNeighbourField
+Foam::cyclicACMIFvPatchField<Type>::getNeighbourField
 (
-    const Field<Type>& iField
+    const UList<Type>& internalData
 ) const
 {
     DebugPout
-        << "cyclicACMIFvPatchField::patchNeighbourField(const Field<Type>&) :"
+        << "cyclicACMIFvPatchField::getNeighbourField(const UList<Type>&) :"
         << " field:" << this->internalField().name()
         << " patch:" << this->patch().name()
         << endl;
 
     // By pass polyPatch to get nbrId. Instead use cyclicACMIFvPatch virtual
     // neighbPatch()
-    const cyclicACMIFvPatch& neighbPatch = cyclicACMIPatch_.neighbPatch();
+    const auto& neighbPatch = cyclicACMIPatch_.neighbPatch();
     const labelUList& nbrFaceCells = neighbPatch.faceCells();
 
     tmp<Field<Type>> tpnf
     (
         cyclicACMIPatch_.interpolate
         (
-            Field<Type>
-            (
-                iField,
-                nbrFaceCells
-                //cpp.neighbPatch().faceCells()
-            )
+            Field<Type>(internalData, nbrFaceCells)
         )
     );
 
@@ -334,11 +330,18 @@ bool Foam::cyclicACMIFvPatchField<Type>::cacheNeighbourField()
 
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
-Foam::cyclicACMIFvPatchField<Type>::patchNeighbourField() const
+Foam::cyclicACMIFvPatchField<Type>::getPatchNeighbourField
+(
+    const bool checkCommunicator
+) const
 {
     const auto& AMI = this->ownerAMI();
 
-    if (AMI.distributed() && cacheNeighbourField() && AMI.comm() != -1)
+    if
+    (
+        AMI.distributed() && cacheNeighbourField()
+     && (!checkCommunicator || AMI.comm() != -1)
+    )
     {
         if (!this->ready())
         {
@@ -362,7 +365,7 @@ Foam::cyclicACMIFvPatchField<Type>::patchNeighbourField() const
             // Do interpolation and store result
             patchNeighbourFieldPtr_.reset
             (
-                patchNeighbourField(this->primitiveField()).ptr()
+                getNeighbourField(this->primitiveField()).ptr()
             );
         }
         else
@@ -386,16 +389,36 @@ Foam::cyclicACMIFvPatchField<Type>::patchNeighbourField() const
             << " calculating up-to-date patchNeighbourField"
             << endl;
 
-        return patchNeighbourField(this->primitiveField());
+        return getNeighbourField(this->primitiveField());
     }
 }
 
 
+template<class Type>
+Foam::tmp<Foam::Field<Type>>
+Foam::cyclicACMIFvPatchField<Type>::patchNeighbourField() const
+{
+    return this->getPatchNeighbourField(true);  // checkCommunicator = true
+}
+
+
+template<class Type>
+void Foam::cyclicACMIFvPatchField<Type>::patchNeighbourField
+(
+    UList<Type>& pnf
+) const
+{
+    // checkCommunicator = false
+    auto tpnf = this->getPatchNeighbourField(false);
+    pnf.deepCopy(tpnf());
+}
+
+
 template<class Type>
 const Foam::cyclicACMIFvPatchField<Type>&
 Foam::cyclicACMIFvPatchField<Type>::neighbourPatchField() const
 {
-    const GeometricField<Type, fvPatchField, volMesh>& fld =
+    const auto& fld =
         static_cast<const GeometricField<Type, fvPatchField, volMesh>&>
         (
             this->primitiveField()
@@ -412,7 +435,7 @@ template<class Type>
 const Foam::fvPatchField<Type>&
 Foam::cyclicACMIFvPatchField<Type>::nonOverlapPatchField() const
 {
-    const GeometricField<Type, fvPatchField, volMesh>& fld =
+    const auto& fld =
         static_cast<const GeometricField<Type, fvPatchField, volMesh>&>
         (
             this->primitiveField()
@@ -531,13 +554,11 @@ void Foam::cyclicACMIFvPatchField<Type>::evaluate
         // Receive requests all handled by last function call
         recvRequests_.clear();
 
-
-        auto& patchNeighbourField = patchNeighbourFieldPtr_.ref();
-
         if (doTransform())
         {
             // In-place transform
-            transform(patchNeighbourField, forwardT(), patchNeighbourField);
+            auto& pnf = *patchNeighbourFieldPtr_;
+            transform(pnf, forwardT(), pnf);
         }
      }
 

src/finiteVolume/fields/fvPatchFields/constraint/cyclicACMI/cyclicACMIFvPatchField.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2013-2016 OpenFOAM Foundation
-    Copyright (C) 2019,2023 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -126,16 +126,13 @@ class cyclicACMIFvPatchField
         static bool cacheNeighbourField();
 
         //- Return neighbour coupled internal cell data
-        tmp<Field<Type>> patchNeighbourField(const Field<Type>&) const;
+        tmp<Field<Type>> getNeighbourField(const UList<Type>&) const;
 
-        //- Return neighbour side field given internal fields
-        template<class Type2>
-        tmp<Field<Type2>> neighbourSideField
-        (
-            const Field<Type2>&
-        ) const;
+        //- Return neighbour coupled internal cell data (cached or extracted),
+        //- with optional check that AMI.comm() is valid.
+        tmp<Field<Type>> getPatchNeighbourField(bool checkCommunicator) const;
 
-         //- Return new matrix coeffs
+        //- Return new matrix coeffs
         tmp<Field<scalar>> coeffs
         (
             fvMatrix<Type>& matrix,
@@ -144,7 +141,6 @@ class cyclicACMIFvPatchField
         ) const;
 
 
-
 public:
 
     //- Runtime type information
@@ -246,6 +242,9 @@ public:
             //- Return neighbour coupled internal cell data
             virtual tmp<Field<Type>> patchNeighbourField() const;
 
+            //- Retrieve neighbour coupled internal cell data
+            virtual void patchNeighbourField(UList<Type>& pnf) const;
+
             //- Return reference to neighbour patchField
             const cyclicACMIFvPatchField<Type>& neighbourPatchField() const;
 

src/finiteVolume/fields/fvPatchFields/constraint/cyclicAMI/cyclicAMIFvPatchField.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2019-2024 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -289,22 +289,22 @@ void Foam::cyclicAMIFvPatchField<Type>::rmap
 
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
-Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField
+Foam::cyclicAMIFvPatchField<Type>::getNeighbourField
 (
-    const Field<Type>& iField
+    const UList<Type>& internalData
 ) const
 {
     // By pass polyPatch to get nbrId. Instead use cyclicAMIFvPatch virtual
     // neighbPatch()
-    const cyclicAMIFvPatch& neighbPatch = cyclicAMIPatch_.neighbPatch();
+    const auto& neighbPatch = cyclicAMIPatch_.neighbPatch();
     const labelUList& nbrFaceCells = neighbPatch.faceCells();
 
-    Field<Type> pnf(iField, nbrFaceCells);
+    Field<Type> pnf(internalData, nbrFaceCells);
     Field<Type> defaultValues;
 
     if (cyclicAMIPatch_.applyLowWeightCorrection())
     {
-        defaultValues = Field<Type>(iField, cyclicAMIPatch_.faceCells());
+        defaultValues = Field<Type>(internalData, cyclicAMIPatch_.faceCells());
     }
 
     tmp<Field<Type>> tpnf = cyclicAMIPatch_.interpolate(pnf, defaultValues);
@@ -327,11 +327,18 @@ bool Foam::cyclicAMIFvPatchField<Type>::cacheNeighbourField()
 
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
-Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField() const
+Foam::cyclicAMIFvPatchField<Type>::getPatchNeighbourField
+(
+    bool checkCommunicator
+) const
 {
     const auto& AMI = this->ownerAMI();
 
-    if (AMI.distributed() && cacheNeighbourField() && AMI.comm() != -1)
+    if
+    (
+        AMI.distributed() && cacheNeighbourField()
+     && (!checkCommunicator || AMI.comm() != -1)
+    )
     {
         if (!this->ready())
         {
@@ -372,7 +379,7 @@ Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField() const
             // Do interpolation and store result
             patchNeighbourFieldPtr_.reset
             (
-                patchNeighbourField(this->primitiveField()).ptr()
+                getNeighbourField(this->primitiveField()).ptr()
             );
         }
         else
@@ -382,7 +389,7 @@ Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField() const
             //{
             //    tmp<Field<Type>> tpnf
             //    (
-            //        patchNeighbourField(this->primitiveField())
+            //        getNeighbourField(this->primitiveField())
             //    );
             //    if (tpnf() != patchNeighbourFieldPtr_())
             //    {
@@ -402,16 +409,36 @@ Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField() const
     else
     {
         // Do interpolation
-        return patchNeighbourField(this->primitiveField());
+        return getNeighbourField(this->primitiveField());
     }
 }
 
 
+template<class Type>
+Foam::tmp<Foam::Field<Type>>
+Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField() const
+{
+    return this->getPatchNeighbourField(true);  // checkCommunicator = true
+}
+
+
+template<class Type>
+void Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField
+(
+    UList<Type>& pnf
+) const
+{
+    // checkCommunicator = false
+    auto tpnf = this->getPatchNeighbourField(false);
+    pnf.deepCopy(tpnf());
+}
+
+
 template<class Type>
 const Foam::cyclicAMIFvPatchField<Type>&
 Foam::cyclicAMIFvPatchField<Type>::neighbourPatchField() const
 {
-    const GeometricField<Type, fvPatchField, volMesh>& fld =
+    const auto& fld =
         static_cast<const GeometricField<Type, fvPatchField, volMesh>&>
         (
             this->primitiveField()
@@ -542,12 +569,11 @@ void Foam::cyclicAMIFvPatchField<Type>::evaluate
         // Receive requests all handled by last function call
         recvRequests_.clear();
 
-        auto& patchNeighbourField = patchNeighbourFieldPtr_.ref();
-
         if (doTransform())
         {
             // In-place transform
-            transform(patchNeighbourField, forwardT(), patchNeighbourField);
+            auto& pnf = *patchNeighbourFieldPtr_;
+            transform(pnf, forwardT(), pnf);
         }
     }
 
@@ -982,7 +1008,7 @@ void Foam::cyclicAMIFvPatchField<Type>::collectStencilData
 
         forAll(stencil, facei)
         {
-            const labelList& slots = stencil[facei];
+            const auto& slots = stencil[facei];
             expandedData[facei].push_back
             (
                 UIndirectList<typename Type2::value_type>(work, slots)
@@ -993,7 +1019,7 @@ void Foam::cyclicAMIFvPatchField<Type>::collectStencilData
     {
         forAll(stencil, facei)
         {
-            const labelList& slots = stencil[facei];
+            const auto& slots = stencil[facei];
             expandedData[facei].push_back
             (
                 UIndirectList<typename Type2::value_type>(data, slots)
@@ -1033,31 +1059,21 @@ void Foam::cyclicAMIFvPatchField<Type>::operator=
     //    << endl;
 
     const auto* cycPtr = isA<cyclicAMIFvPatchField<Type>>(ptf);
-    if (cycPtr)
+
+    if
+    (
+        cycPtr
+     && cycPtr->patchNeighbourFieldPtr_
+     && cycPtr->patchNeighbourFieldPtr_->size() == this->size()
+    )
     {
-        const auto& cyc = *cycPtr;
-        if
-        (
-            cyc.patchNeighbourFieldPtr_
-         && cyc.patchNeighbourFieldPtr_->size() == this->size()
-        )
+        if (!patchNeighbourFieldPtr_)
         {
-            const auto& cycPnf = cyc.patchNeighbourFieldPtr_();
-            if (patchNeighbourFieldPtr_)
-            {
-                // Copy values
-                patchNeighbourFieldPtr_() = cycPnf;
-            }
-            else
-            {
-                // Copy values
-                patchNeighbourFieldPtr_.reset(new Field<Type>(cycPnf));
-            }
-        }
-        else
-        {
-            patchNeighbourFieldPtr_.reset(nullptr);
+            patchNeighbourFieldPtr_ = autoPtr<Field<Type>>::New();
         }
+
+        // Copy values
+        *patchNeighbourFieldPtr_ = *(cycPtr->patchNeighbourFieldPtr_);
     }
     else
     {
@@ -1081,31 +1097,21 @@ void Foam::cyclicAMIFvPatchField<Type>::operator==
     //    << endl;
 
     const auto* cycPtr = isA<cyclicAMIFvPatchField<Type>>(ptf);
-    if (cycPtr)
+
+    if
+    (
+        cycPtr
+     && cycPtr->patchNeighbourFieldPtr_
+     && cycPtr->patchNeighbourFieldPtr_->size() == this->size()
+    )
     {
-        const auto& cyc = *cycPtr;
-        if
-        (
-            cyc.patchNeighbourFieldPtr_
-         && cyc.patchNeighbourFieldPtr_->size() == this->size()
-        )
+        if (!patchNeighbourFieldPtr_)
         {
-            const auto& cycPnf = cyc.patchNeighbourFieldPtr_();
-            if (patchNeighbourFieldPtr_)
-            {
-                // Copy values
-                patchNeighbourFieldPtr_() = cycPnf;
-            }
-            else
-            {
-                // Copy values
-                patchNeighbourFieldPtr_.reset(new Field<Type>(cycPnf));
-            }
-        }
-        else
-        {
-            patchNeighbourFieldPtr_.reset(nullptr);
+            patchNeighbourFieldPtr_ = autoPtr<Field<Type>>::New();
         }
+
+        // Copy values
+        *patchNeighbourFieldPtr_ = *(cycPtr->patchNeighbourFieldPtr_);
     }
     else
     {

src/finiteVolume/fields/fvPatchFields/constraint/cyclicAMI/cyclicAMIFvPatchField.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2023 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -137,15 +137,11 @@ class cyclicAMIFvPatchField
         static bool cacheNeighbourField();
 
         //- Return neighbour coupled internal cell data
-        tmp<Field<Type>> patchNeighbourField(const Field<Type>&) const;
-
-        //- Return neighbour side field given internal fields
-        template<class Type2>
-        tmp<Field<Type2>> neighbourSideField
-        (
-            const Field<Type2>&
-        ) const;
+        tmp<Field<Type>> getNeighbourField(const UList<Type>&) const;
 
+        //- Return neighbour coupled internal cell data (cached or extracted),
+        //- with optional check that AMI.comm() is valid.
+        tmp<Field<Type>> getPatchNeighbourField(bool checkCommunicator) const;
 
         //- Return new matrix coeffs
         tmp<Field<scalar>> coeffs
@@ -244,6 +240,9 @@ public:
         //- Return neighbour coupled internal cell data
         virtual tmp<Field<Type>> patchNeighbourField() const;
 
+        //- Retrieve neighbour coupled internal cell data
+        virtual void patchNeighbourField(UList<Type>& pnf) const;
+
         //- Return reference to neighbour patchField
         const cyclicAMIFvPatchField<Type>& neighbourPatchField() const;
 

src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclic/jumpCyclicFvPatchField.C

@@ -91,16 +91,15 @@ Foam::jumpCyclicFvPatchField<Type>::jumpCyclicFvPatchField
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class Type>
-Foam::tmp<Foam::Field<Type>>
-Foam::jumpCyclicFvPatchField<Type>::patchNeighbourField() const
+void Foam::jumpCyclicFvPatchField<Type>::patchNeighbourField
+(
+    UList<Type>& pnf
+) const
 {
     const Field<Type>& iField = this->primitiveField();
     const labelUList& nbrFaceCells =
         this->cyclicPatch().neighbFvPatch().faceCells();
 
-    auto tpnf = tmp<Field<Type>>::New(this->size());
-    auto& pnf = tpnf.ref();
-
     Field<Type> jf(this->jump());
     if (!this->cyclicPatch().owner())
     {
@@ -109,22 +108,29 @@ Foam::jumpCyclicFvPatchField<Type>::patchNeighbourField() const
 
     if (this->doTransform())
     {
-        forAll(*this, facei)
+        const auto& rot = this->forwardT()[0];
+
+        forAll(pnf, i)
         {
-            pnf[facei] = transform
-            (
-                this->forwardT()[0], iField[nbrFaceCells[facei]]
-            ) - jf[facei];
+            pnf[i] = (transform(rot, iField[nbrFaceCells[i]]) - jf[i]);
         }
     }
     else
     {
-        forAll(*this, facei)
+        forAll(pnf, i)
         {
-            pnf[facei] = iField[nbrFaceCells[facei]] - jf[facei];
+            pnf[i] = (iField[nbrFaceCells[i]] - jf[i]);
         }
     }
+}
 
+
+template<class Type>
+Foam::tmp<Foam::Field<Type>>
+Foam::jumpCyclicFvPatchField<Type>::patchNeighbourField() const
+{
+    auto tpnf = tmp<Field<Type>>::New(this->size());
+    this->patchNeighbourField(tpnf.ref());
     return tpnf;
 }
 
@@ -176,14 +182,14 @@ void Foam::jumpCyclicFvPatchField<Type>::updateInterfaceMatrix
             jf *= -1.0;
         }
 
-        forAll(*this, facei)
+        forAll(pnf, facei)
         {
             pnf[facei] = psiInternal[nbrFaceCells[facei]] - jf[facei];
         }
     }
     else
     {
-        forAll(*this, facei)
+        forAll(pnf, facei)
         {
             pnf[facei] = psiInternal[nbrFaceCells[facei]];
         }

src/finiteVolume/fields/fvPatchFields/constraint/jumpCyclic/jumpCyclicFvPatchField.H

@@ -127,9 +127,12 @@ public:
 
         // Evaluation functions
 
-            //- Return neighbour coupled given internal cell data
+            //- Return neighbour coupled values
             virtual tmp<Field<Type>> patchNeighbourField() const;
 
+            //- Retrieve neighbour coupled values
+            virtual void patchNeighbourField(UList<Type>& pnf) const;
+
             //- Update result field based on interface functionality
             virtual void updateInterfaceMatrix
             (

src/finiteVolume/fields/fvPatchFields/constraint/processor/processorFvPatchField.C

@@ -208,6 +208,22 @@ Foam::processorFvPatchField<Type>::patchNeighbourField() const
 }
 
 
+template<class Type>
+void Foam::processorFvPatchField<Type>::patchNeighbourField
+(
+    UList<Type>& pnf
+) const
+{
+    if (debug && !this->ready())
+    {
+        FatalErrorInFunction
+            << "Outstanding request on patch " << procPatch_.name()
+            << abort(FatalError);
+    }
+    pnf.deepCopy(*this);
+}
+
+
 template<class Type>
 void Foam::processorFvPatchField<Type>::initEvaluate
 (
@@ -216,6 +232,7 @@ void Foam::processorFvPatchField<Type>::initEvaluate
 {
     if (UPstream::parRun())
     {
+        sendBuf_.resize_nocopy(this->patch().size());
         this->patchInternalField(sendBuf_);
 
         if

src/finiteVolume/fields/fvPatchFields/constraint/processor/processorFvPatchField.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2023 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -182,9 +182,12 @@ public:
         //- Are all (receive) data available?
         virtual bool ready() const;
 
-        //- Return neighbour field given internal field
+        //- Return neighbour field
         virtual tmp<Field<Type>> patchNeighbourField() const;
 
+        //- Retrieve neighbour field
+        virtual void patchNeighbourField(UList<Type>& pnf) const;
+
 
     // Evaluation
 

src/finiteVolume/fields/fvPatchFields/constraint/symmetryPlane/symmetryPlaneFvPatchField.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2013-2016 OpenFOAM Foundation
+    Copyright (C) 2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -27,7 +28,6 @@ License
 
 #include "symmetryPlaneFvPatchField.H"
 
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class Type>
@@ -120,13 +120,25 @@ template<class Type>
 Foam::tmp<Foam::Field<Type>>
 Foam::symmetryPlaneFvPatchField<Type>::snGrad() const
 {
-    vector nHat(symmetryPlanePatch_.n());
+    if constexpr (!is_rotational_vectorspace_v<Type>)
+    {
+        // Rotational-invariant type: treat like zero-gradient
+        return tmp<Field<Type>>::New(this->size(), Foam::zero{});
+    }
+    else
+    {
+        const symmTensor rot(I - 2.0*sqr(symmetryPlanePatch_.n()));
 
-    const Field<Type> iF(this->patchInternalField());
+        const Field<Type> pif(this->patchInternalField());
 
-    return
-        (transform(I - 2.0*sqr(nHat), iF) - iF)
-       *(this->patch().deltaCoeffs()/2.0);
+        const auto& dc = this->patch().deltaCoeffs();
+
+        return
+        (
+            (0.5*dc)
+          * (transform(rot, pif) - pif)
+        );
+    }
 }
 
 
@@ -138,14 +150,19 @@ void Foam::symmetryPlaneFvPatchField<Type>::evaluate(const Pstream::commsTypes)
         this->updateCoeffs();
     }
 
-    vector nHat(symmetryPlanePatch_.n());
+    if constexpr (!is_rotational_vectorspace_v<Type>)
+    {
+        // Rotational-invariant type: treat like zero-gradient
+        this->extrapolateInternal();
+    }
+    else
+    {
+        const symmTensor rot(I - 2.0*sqr(symmetryPlanePatch_.n()));
 
-    const Field<Type> iF(this->patchInternalField());
+        const Field<Type> pif(this->patchInternalField());
 
-    Field<Type>::operator=
-    (
-        (iF + transform(I - 2.0*sqr(nHat), iF))/2.0
-    );
+        Field<Type>::operator=(0.5*(pif + transform(rot, pif)));
+    }
 
     transformFvPatchField<Type>::evaluate();
 }
@@ -155,9 +172,7 @@ template<class Type>
 Foam::tmp<Foam::Field<Type>>
 Foam::symmetryPlaneFvPatchField<Type>::snGradTransformDiag() const
 {
-    vector nHat(symmetryPlanePatch_.n());
-
-    const vector diag(mag(nHat.x()), mag(nHat.y()), mag(nHat.z()));
+    const vector diag(cmptMag(symmetryPlanePatch_.n()));
 
     return tmp<Field<Type>>::New
     (

src/finiteVolume/fields/fvPatchFields/constraint/symmetryPlane/symmetryPlaneFvPatchField.H

@@ -49,8 +49,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef symmetryPlaneFvPatchField_H
-#define symmetryPlaneFvPatchField_H
+#ifndef Foam_symmetryPlaneFvPatchField_H
+#define Foam_symmetryPlaneFvPatchField_H
 
 #include "basicSymmetryFvPatchField.H"
 #include "symmetryPlaneFvPatch.H"
@@ -61,7 +61,7 @@ namespace Foam
 {
 
 /*---------------------------------------------------------------------------*\
-                         Class symmetryPlaneFvPatchField Declaration
+                  Class symmetryPlaneFvPatchField Declaration
 \*---------------------------------------------------------------------------*/
 
 template<class Type>
@@ -153,18 +153,6 @@ public:
 };
 
 
-// * * * * * * * * * * * Template Specialisations  * * * * * * * * * * * * * //
-
-template<>
-tmp<scalarField> symmetryPlaneFvPatchField<scalar>::snGrad() const;
-
-template<>
-void symmetryPlaneFvPatchField<scalar>::evaluate
-(
-    const Pstream::commsTypes commsType
-);
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

src/finiteVolume/fields/fvPatchFields/constraint/symmetryPlane/symmetryPlaneFvPatchFields.C

@@ -37,30 +37,4 @@ namespace Foam
 }
 
 
-// * * * * * * * * * * * * * * * Specialisations * * * * * * * * * * * * * * //
-
-template<>
-Foam::tmp<Foam::scalarField>
-Foam::symmetryPlaneFvPatchField<Foam::scalar>::snGrad() const
-{
-    return tmp<scalarField>::New(size(), Zero);
-}
-
-
-template<>
-void Foam::symmetryPlaneFvPatchField<Foam::scalar>::evaluate
-(
-    const Pstream::commsTypes
-)
-{
-    if (!updated())
-    {
-        updateCoeffs();
-    }
-
-    scalarField::operator=(patchInternalField());
-    transformFvPatchField<scalar>::evaluate();
-}
-
-
 // ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/constraint/wedge/wedgeFvPatchField.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2024 OpenCFD Ltd.
+    Copyright (C) 2024-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -30,7 +30,6 @@ License
 #include "wedgeFvPatchField.H"
 #include "transformField.H"
 #include "symmTransform.H"
-#include "diagTensor.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -120,12 +119,25 @@ Foam::wedgeFvPatchField<Type>::wedgeFvPatchField
 template<class Type>
 Foam::tmp<Foam::Field<Type>> Foam::wedgeFvPatchField<Type>::snGrad() const
 {
-    const Field<Type> pif(this->patchInternalField());
+    if constexpr (!is_rotational_vectorspace_v<Type>)
+    {
+        // Rotational-invariant type : treat like zero-gradient
+        return tmp<Field<Type>>::New(this->size(), Foam::zero{});
+    }
+    else
+    {
+        const auto& rot = refCast<const wedgeFvPatch>(this->patch()).cellT();
 
-    return
-    (
-        transform(refCast<const wedgeFvPatch>(this->patch()).cellT(), pif) - pif
-    )*(0.5*this->patch().deltaCoeffs());
+        const Field<Type> pif(this->patchInternalField());
+
+        const auto& dc = this->patch().deltaCoeffs();
+
+        return
+        (
+            (0.5*dc)
+          * (transform(rot, pif) - pif)
+        );
+    }
 }
 
 
@@ -137,14 +149,20 @@ void Foam::wedgeFvPatchField<Type>::evaluate(const Pstream::commsTypes)
         this->updateCoeffs();
     }
 
-    fvPatchField<Type>::operator==
-    (
-        transform
+    if constexpr (!is_rotational_vectorspace_v<Type>)
+    {
+        // Rotational-invariant type : treat like zero-gradient
+        this->extrapolateInternal();
+    }
+    else
+    {
+        const auto& rot = refCast<const wedgeFvPatch>(this->patch()).faceT();
+
+        fvPatchField<Type>::operator==
         (
-            refCast<const wedgeFvPatch>(this->patch()).faceT(),
-            this->patchInternalField()
-        )
-    );
+            transform(rot, this->patchInternalField())
+        );
+     }
 }
 
 
@@ -152,10 +170,9 @@ template<class Type>
 Foam::tmp<Foam::Field<Type>>
 Foam::wedgeFvPatchField<Type>::snGradTransformDiag() const
 {
-    const diagTensor diagT =
-        0.5*diag(I - refCast<const wedgeFvPatch>(this->patch()).cellT());
+    const auto& rot = refCast<const wedgeFvPatch>(this->patch()).cellT();
 
-    const vector diagV(diagT.xx(), diagT.yy(), diagT.zz());
+    const vector diagV = 0.5*(I - rot).diag();
 
     return tmp<Field<Type>>::New
     (

src/finiteVolume/fields/fvPatchFields/constraint/wedge/wedgeFvPatchField.H

@@ -138,7 +138,7 @@ public:
         }
 
 
-    // Member functions
+    // Member Functions
 
         //- Return gradient at boundary
         virtual tmp<Field<Type>> snGrad() const;
@@ -154,18 +154,6 @@ public:
 };
 
 
-// * * * * * * * * * * * Template Specialisations  * * * * * * * * * * * * * //
-
-template<>
-tmp<scalarField> wedgeFvPatchField<scalar>::snGrad() const;
-
-template<>
-void wedgeFvPatchField<scalar>::evaluate
-(
-    const Pstream::commsTypes commsType
-);
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

src/finiteVolume/fields/fvPatchFields/constraint/wedge/wedgeFvPatchFields.C

@@ -37,29 +37,4 @@ namespace Foam
 }
 
 
-// * * * * * * * * * * * * * * * Specialisations * * * * * * * * * * * * * * //
-
-template<>
-Foam::tmp<Foam::scalarField>
-Foam::wedgeFvPatchField<Foam::scalar>::snGrad() const
-{
-    return tmp<scalarField>::New(size(), Zero);
-}
-
-
-template<>
-void Foam::wedgeFvPatchField<Foam::scalar>::evaluate
-(
-    const Pstream::commsTypes
-)
-{
-    if (!updated())
-    {
-        updateCoeffs();
-    }
-
-    this->operator==(patchInternalField());
-}
-
-
 // ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/derived/flowRateInletVelocity/flowRateInletVelocityFvPatchVectorField.C

@@ -212,12 +212,13 @@ void Foam::flowRateInletVelocityFvPatchVectorField::updateCoeffs()
     else
     {
         // Mass flow-rate
-        if (db().foundObject<volScalarField>(rhoName_))
+        if
+        (
+            const auto* rhop
+          = patch().cfindPatchField<volScalarField>(rhoName_)
+        )
         {
-            const auto& rhop =
-                patch().lookupPatchField<volScalarField>(rhoName_);
-
-            updateValues(rhop);
+            updateValues(*rhop);
         }
         else
         {

src/finiteVolume/fields/fvPatchFields/derived/flowRateOutletVelocity/flowRateOutletVelocityFvPatchVectorField.C

@@ -196,12 +196,13 @@ void Foam::flowRateOutletVelocityFvPatchVectorField::updateCoeffs()
     else
     {
         // Mass flow-rate
-        if (db().foundObject<volScalarField>(rhoName_))
+        if
+        (
+            const auto* rhop
+          = patch().cfindPatchField<volScalarField>(rhoName_)
+        )
         {
-            const auto& rhop =
-                patch().lookupPatchField<volScalarField>(rhoName_);
-
-            updateValues(rhop);
+            updateValues(*rhop);
         }
         else
         {

src/finiteVolume/fields/fvPatchFields/fvPatchField/fvPatchField.C

@@ -234,11 +234,9 @@ Foam::fvPatchField<Type>::patchInternalField() const
 
 
 template<class Type>
-void Foam::fvPatchField<Type>::patchInternalField(Field<Type>& pfld) const
+void Foam::fvPatchField<Type>::patchInternalField(UList<Type>& pfld) const
 {
-    const auto& p = fvPatchFieldBase::patch();
-    pfld.resize_nocopy(p.size());  // In general this is a no-op
-    p.patchInternalField(internalField_, pfld);
+    patch().patchInternalField(internalField_, pfld);
 }
 
 

src/finiteVolume/fields/fvPatchFields/fvPatchField/fvPatchField.H

@@ -626,9 +626,9 @@ public:
             //- Return internal field next to patch
             virtual tmp<Field<Type>> patchInternalField() const;
 
-            //- Extract internal field next to patch
-            // \param [out] pfld The extracted patch field.
-            virtual void patchInternalField(Field<Type>& pfld) const;
+            //- Retrieve internal field next to patch
+            //  \param [out] pfld The extracted patch field.
+            virtual void patchInternalField(UList<Type>& pfld) const;
 
             //- Return patchField on the opposite patch of a coupled patch
             virtual tmp<Field<Type>> patchNeighbourField() const

src/finiteVolume/fvMesh/fvPatches/constraint/wedge/wedgeFvPatch.C

@@ -33,23 +33,23 @@ License
 namespace Foam
 {
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 defineTypeNameAndDebug(wedgeFvPatch, 0);
 addToRunTimeSelectionTable(fvPatch, wedgeFvPatch, polyPatch);
 
+} // End namespace Foam
+
 
 // * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * * * * //
 
-wedgeFvPatch::wedgeFvPatch(const polyPatch& patch, const fvBoundaryMesh& bm)
+Foam::wedgeFvPatch::wedgeFvPatch
+(
+    const polyPatch& patch,
+    const fvBoundaryMesh& bm
+)
 :
     fvPatch(patch, bm),
     wedgePolyPatch_(refCast<const wedgePolyPatch>(patch))
 {}
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/finiteVolume/fvMesh/fvPatches/constraint/wedge/wedgeFvPatch.H

@@ -34,8 +34,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef wedgeFvPatch_H
-#define wedgeFvPatch_H
+#ifndef Foam_wedgeFvPatch_H
+#define Foam_wedgeFvPatch_H
 
 #include "fvPatch.H"
 #include "wedgePolyPatch.H"
@@ -53,7 +53,7 @@ class wedgeFvPatch
 :
     public fvPatch
 {
-    // Private data
+    // Private Data
 
         const wedgePolyPatch& wedgePolyPatch_;
 
@@ -70,21 +70,21 @@ public:
         wedgeFvPatch(const polyPatch& patch, const fvBoundaryMesh& bm);
 
 
-    // Member functions
+    // Member Functions
 
-        // Access
+    // Access
 
-            //- Return face transformation tensor
-            const tensor& faceT() const
-            {
-                return wedgePolyPatch_.faceT();
-            }
+        //- Return face transformation tensor
+        const tensor& faceT() const noexcept
+        {
+            return wedgePolyPatch_.faceT();
+        }
 
-            //- Return neighbour-cell transformation tensor
-            const tensor& cellT() const
-            {
-                return wedgePolyPatch_.cellT();
-            }
+        //- Return neighbour-cell transformation tensor
+        const tensor& cellT() const noexcept
+        {
+            return wedgePolyPatch_.cellT();
+        }
 };
 
 

src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatch.H

@@ -325,25 +325,26 @@ public:
                 const UList<Type>& internalData
             ) const;
 
-            //- Return the patch field of the GeometricField
-            //- corresponding to this patch.
-            template<class GeometricField, class AnyType = bool>
-            const typename GeometricField::Patch& patchField
-            (
-                const GeometricField& gf
-            ) const;
 
-            //- Lookup the named field from the local registry and
-            //- return the patch field corresponding to this patch.
-            //  N.B.  The dummy pointer arguments are used if this function is
-            //  instantiated within a templated function to avoid a bug in gcc.
-            template<class GeometricField, class AnyType = bool>
-            const typename GeometricField::Patch& lookupPatchField
-            (
-                const word& name,
-                const GeometricField* = nullptr,
-                const AnyType* = nullptr
-            ) const;
+    // Lookup
+
+        //- Return the patch field of the GeometricField
+        //- corresponding to this patch.
+        template<class GeometricField, class AnyType = bool>
+        const typename GeometricField::Patch&
+        patchField(const GeometricField& gf) const;
+
+        //- Lookup the named field from the local registry and
+        //- return the patch field corresponding to this patch.
+        template<class GeometricField, class AnyType = bool>
+        const typename GeometricField::Patch&
+        lookupPatchField(const word& name) const;
+
+        //- Find the named field (if any) from the local registry and
+        //- return the patch field corresponding to this patch.
+        template<class GeometricField>
+        const typename GeometricField::Patch*
+        cfindPatchField(const word& name) const;
 };
 
 

src/finiteVolume/fvMesh/fvPatches/fvPatch/fvPatchFvMeshTemplates.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2022 OpenCFD Ltd.
+    Copyright (C) 2022-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -31,18 +31,33 @@ License
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class GeometricField, class AnyType>
-const typename GeometricField::Patch& Foam::fvPatch::lookupPatchField
-(
-    const word& name,
-    const GeometricField*,
-    const AnyType*
-) const
+const typename GeometricField::Patch&
+Foam::fvPatch::lookupPatchField(const word& fldName) const
 {
     return
         boundaryMesh().mesh().thisDb().template
-            lookupObject<GeometricField>(name)
+            lookupObject<GeometricField>(fldName)
             .boundaryField()[this->index()];
 }
 
 
+template<class GeometricField>
+const typename GeometricField::Patch*
+Foam::fvPatch::cfindPatchField(const word& fldName) const
+{
+    const auto* fldptr =
+        boundaryMesh().mesh().thisDb().template
+        cfindObject<GeometricField>(fldName);
+
+    if (fldptr)
+    {
+        return &(fldptr->boundaryField()[this->index()]);
+    }
+    else
+    {
+        return nullptr;
+    }
+}
+
+
 // ************************************************************************* //

src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWaveAddressing/meshWaveAddressingPatchDistMethod.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2023 OpenCFD Ltd.
+    Copyright (C) 2023-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -88,12 +88,14 @@ bool Foam::patchDistMethods::meshWaveAddressing::correct
     // since the supplied options (wall patchIDs and correctWalls)
     // are not assumed to be different from the defaults of other usage.
 
+    const labelList patchIds(patchIDs_.sortedToc());
+
     // Calculate distance and addressing
     const auto& wDist = wallDistAddressing::New
     (
         "wall",
         mesh_,
-        patchIDs_.sortedToc(),
+        patchIds,
         correctWalls_
     );
 
@@ -102,31 +104,18 @@ bool Foam::patchDistMethods::meshWaveAddressing::correct
     // Note: copying value only so might not be consistent with supplied
     // patch types (e.g. zeroGradient when called from wallDist). Assume
     // only affected ones are the supplied patches ...
-    {
-        auto& bfld = y.boundaryFieldRef();
-        const label startOfRequests = UPstream::nRequests();
-        for (const label patchi : patchIDs_)
-        {
-            bfld[patchi].initEvaluate(UPstream::commsTypes::nonBlocking);
-        }
 
-        // Wait for outstanding requests
-        UPstream::waitRequests(startOfRequests);
-
-        for (const label patchi : patchIDs_)
-        {
-            bfld[patchi].evaluate(UPstream::commsTypes::nonBlocking);
-        }
-    }
+    y.boundaryFieldRef().evaluateSelected(patchIds);
 
 
     // Only calculate n if the field is defined
     if (notNull(n))
     {
-        for (const label patchi : patchIDs_)
+        auto& bfld = n.boundaryFieldRef();
+
+        for (const label patchi : patchIds)
         {
-            auto& pnf = n.boundaryFieldRef()[patchi];
-            pnf == pnf.patch().nf();
+            bfld[patchi] == bfld[patchi].patch().nf();
         }
 
         // No problem with inconsistency as for y (see above) since doing

src/functionObjects/field/cellDecomposer/cellDecomposerTemplates.C

@@ -39,79 +39,17 @@ License
 //    GeometricField<Type, fvPatchField, volMesh>& fld
 //) const
 //{
-//    auto& fldBf = fld.boundaryFieldRef();
-//
-//    const UPstream::commsTypes commsType = UPstream::defaultCommsType;
-//    const label startOfRequests = UPstream::nRequests();
-//
-//    if
+//    fld.boundaryFieldRef().evaluate_if
 //    (
-//        commsType == UPstream::commsTypes::blocking
-//     || commsType == UPstream::commsTypes::nonBlocking
-//    )
-//    {
-//        forAll(fldBf, patchi)
+//        [](const auto& pfld) -> bool
 //        {
-//            fvPatchField<Type>& tgtField = fldBf[patchi];
-//
-//            if
+//            return
 //            (
-//                tgtField.type() == tgtField.patch().patch().type()
-//             && polyPatch::constraintType(tgtField.patch().patch().type())
-//            )
-//            {
-//                tgtField.initEvaluate(commsType);
-//            }
+//                pfld.type() == pfld.patch().patch().type()
+//             && polyPatch::constraintType(pfld.patch().patch().type())
+//            );
 //        }
-//
-//        // Wait for outstanding requests
-//        if (commsType == UPstream::commsTypes::nonBlocking)
-//        {
-//            UPstream::waitRequests(startOfRequests);
-//        }
-//
-//        forAll(fldBf, patchi)
-//        {
-//            fvPatchField<Type>& tgtField = fldBf[patchi];
-//
-//            if
-//            (
-//                tgtField.type() == tgtField.patch().patch().type()
-//             && polyPatch::constraintType(tgtField.patch().patch().type())
-//            )
-//            {
-//                tgtField.evaluate(commsType);
-//            }
-//        }
-//    }
-//    else if (commsType == UPstream::commsTypes::scheduled)
-//    {
-//        const lduSchedule& patchSchedule =
-//            fld.mesh().globalData().patchSchedule();
-//
-//        for (const auto& schedEval : patchSchedule)
-//        {
-//            const label patchi = schedEval.patch;
-//
-//            fvPatchField<Type>& tgtField = fldBf[patchi];
-//
-//            if
-//            (
-//                tgtField.type() == tgtField.patch().patch().type()
-//             && polyPatch::constraintType(tgtField.patch().patch().type())
-//            )
-//            {
-//                if (schedEval.init)
-//                {
-//                    tgtField.initEvaluate(commsType);
-//                }
-//                else
-//                {
-//                    tgtField.evaluate(commsType);
-//                }
-//            }
-//        }
-//    }
+//    );
 //}
 
 template<class Type>

src/functionObjects/field/mapFields/mapFieldsTemplates.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2016-2022 OpenCFD Ltd.
+    Copyright (C) 2016-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -36,72 +36,18 @@ void Foam::functionObjects::mapFields::evaluateConstraintTypes
     GeometricField<Type, fvPatchField, volMesh>& fld
 ) const
 {
-    auto& bfld = fld.boundaryFieldRef();
-
-    const UPstream::commsTypes commsType = UPstream::defaultCommsType;
-
-    if
+    fld.boundaryFieldRef().evaluate_if
     (
-        commsType == UPstream::commsTypes::buffered
-     || commsType == UPstream::commsTypes::nonBlocking
-    )
-    {
-        const label startOfRequests = UPstream::nRequests();
-
-        for (auto& pfld : bfld)
+        [](const auto& pfld) -> bool
         {
-            if
+            return
             (
                 pfld.type() == pfld.patch().patch().type()
              && polyPatch::constraintType(pfld.patch().patch().type())
-            )
-            {
-                pfld.initEvaluate(commsType);
-            }
-        }
-
-        // Wait for outstanding requests (non-blocking)
-        UPstream::waitRequests(startOfRequests);
-
-        for (auto& pfld : bfld)
-        {
-            if
-            (
-                pfld.type() == pfld.patch().patch().type()
-             && polyPatch::constraintType(pfld.patch().patch().type())
-            )
-            {
-                pfld.evaluate(commsType);
-            }
-        }
-    }
-    else if (commsType == UPstream::commsTypes::scheduled)
-    {
-        const lduSchedule& patchSchedule =
-            fld.mesh().globalData().patchSchedule();
-
-        for (const auto& schedEval : patchSchedule)
-        {
-            const label patchi = schedEval.patch;
-            auto& pfld = bfld[patchi];
-
-            if
-            (
-                pfld.type() == pfld.patch().patch().type()
-             && polyPatch::constraintType(pfld.patch().patch().type())
-            )
-            {
-                if (schedEval.init)
-                {
-                    pfld.initEvaluate(commsType);
-                }
-                else
-                {
-                    pfld.evaluate(commsType);
-                }
-            }
-        }
-    }
+            );
+        },
+        UPstream::defaultCommsType
+    );
 }
 
 

src/mesh/snappyHexMesh/meshRefinement/meshRefinement.H

@@ -1927,6 +1927,7 @@ public:
             );
 
             //- Wrapper around dictionary::subDict which does not exit
+            FOAM_NO_DANGLING_REFERENCE
             static const dictionary& subDict
             (
                 const dictionary& dict,

src/mesh/snappyHexMesh/shellSurfaces/shellSurfaces.C

@@ -193,34 +193,47 @@ void Foam::shellSurfaces::orient()
 
             if (modes_[shellI] != DISTANCE && isA<triSurfaceMesh>(s))
             {
-                List<pointIndexHit> info;
-                vectorField normal;
-                labelList region;
-                s.findNearest
+                triSurfaceMesh& shell = const_cast<triSurfaceMesh&>
                 (
-                    pointField(1, outsidePt),
-                    scalarField(1, GREAT),
-                    info,
-                    normal,
-                    region
+                    refCast<const triSurfaceMesh>(s)
                 );
-
-                //Pout<< "outsidePt:" << outsidePt << endl;
-                //Pout<< "info     :" << info[0] << endl;
-                //Pout<< "normal   :" << normal[0] << endl;
-                //Pout<< "region   :" << region[0] << endl;
-
                 bool anyFlipped = false;
-                if ((normal[0] & (info[0].point()-outsidePt)) > 0)
+                if (!isA<distributedTriSurfaceMesh>(s))
                 {
-                    triSurfaceMesh& shell = const_cast<triSurfaceMesh&>
+                    anyFlipped = orientedSurface::orient
                     (
-                        refCast<const triSurfaceMesh>(s)
+                       shell,
+                        outsidePt,
+                        true
                     );
-                    shell.flip();
-                    anyFlipped = true;
                 }
+                else
+                {
+                    // TBD. - determine nearest with normal
+                    //      - override nearest only if better normal
 
+                    // Make sure that normals are consistent. Does not change
+                    // anything if surface is consistent.
+                    orientedSurface::orientConsistent(shell);
+
+                    List<pointIndexHit> info;
+                    vectorField normal;
+                    labelList region;
+                    s.findNearest
+                    (
+                        pointField(1, outsidePt),
+                        scalarField(1, GREAT),
+                        info,
+                        normal,
+                        region
+                    );
+
+                    if ((normal[0] & (info[0].point()-outsidePt)) > 0)
+                    {
+                        shell.flip();
+                        anyFlipped = true;
+                    }
+                }
 
                 if (anyFlipped && !dryRun_)
                 {

src/meshTools/mappedPatches/mappedPolyPatch/mappedPatchBase.H

@@ -88,8 +88,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef mappedPatchBase_H
-#define mappedPatchBase_H
+#ifndef Foam_mappedPatchBase_H
+#define Foam_mappedPatchBase_H
 
 #include "pointField.H"
 #include "Tuple2.H"
@@ -103,6 +103,7 @@ SourceFiles
 namespace Foam
 {
 
+// Forward Declarations
 class polyPatch;
 class polyMesh;
 class mapDistribute;
@@ -405,6 +406,7 @@ protected:
 
             //- Lookup (sub)objectRegistry by following names of sub registries.
             //- Creates non-existing intermediate ones.
+            FOAM_NO_DANGLING_REFERENCE
             static const objectRegistry& subRegistry
             (
                 const objectRegistry& obr,
@@ -603,12 +605,12 @@ public:
 
         // For database storage
 
-            inline const fileName& sampleDatabasePath() const
+            const fileName& sampleDatabasePath() const
             {
                 return *sampleDatabasePtr_;
             }
 
-            inline bool sampleDatabase() const
+            bool sampleDatabase() const noexcept
             {
                 return bool(sampleDatabasePtr_);
             }
@@ -630,6 +632,7 @@ public:
 
             //- Lookup (sub)objectRegistry from '/' separated path (relative to
             //- objectRegistry). Creates non-existing intermediate ones.
+            FOAM_NO_DANGLING_REFERENCE
             static const objectRegistry& subRegistry
             (
                 const objectRegistry& obr,

src/meshTools/triSurface/orientedSurface/orientedSurface.H

@@ -126,10 +126,6 @@ private:
         //  anything flipped.
         static bool flipSurface(triSurface& s, const labelList& flipState);
 
-        //- Make surface surface has consistent orientation across connected
-        //  triangles.
-        static bool orientConsistent(triSurface& s);
-
 
 public:
 
@@ -176,6 +172,10 @@ public:
             const point& samplePoint,
             const bool orientOutside
         );
+
+        //- Make surface surface has consistent orientation across connected
+        //  triangles.
+        static bool orientConsistent(triSurface& s);
 };
 
 

src/overset/cellCellStencil/cellCellStencil/cellCellStencilTemplates.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2023 OpenCFD Ltd.
+    Copyright (C) 2018-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -182,31 +182,16 @@ void Foam::cellCellStencil::correctBoundaryConditions
     GeoField& psi
 )
 {
-    // Version of GeoField::correctBoundaryConditions that exclude evaluation
-    // of oversetFvPatchFields
+    // correctBoundaryConditions excluding oversetFvPatchFields
 
-    auto& bfld = psi.boundaryFieldRef();
-
-    const label startOfRequests = UPstream::nRequests();
-
-    for (auto& pfld : bfld)
-    {
-        if (!isA<SuppressBC>(pfld))
+    psi.boundaryFieldRef().evaluate_if
+    (
+        [](const auto& pfld)
         {
-            pfld.initEvaluate(UPstream::commsTypes::nonBlocking);
-        }
-    }
-
-    // Wait for outstanding requests (non-blocking)
-    UPstream::waitRequests(startOfRequests);
-
-    for (auto& pfld : bfld)
-    {
-        if (!isA<SuppressBC>(pfld))
-        {
-            pfld.evaluate(UPstream::commsTypes::nonBlocking);
-        }
-    }
+            return (!isA<SuppressBC>(pfld));
+        },
+        UPstream::commsTypes::nonBlocking
+    );
 }
 
 

src/overset/cellCellStencil/cellVolumeWeight/cellVolumeWeightCellCellStencil.C

@@ -1033,8 +1033,9 @@ bool Foam::cellCellStencils::cellVolumeWeight::update()
     oversetFvMeshBase::correctBoundaryConditions
     <
         volScalarField,
-        oversetFvPatchField<scalar>
-    >(cellInterpolationWeight_.boundaryFieldRef(), false);
+        oversetFvPatchField<scalar>,
+        false
+    >(cellInterpolationWeight_.boundaryFieldRef());
 
     DynamicList<label> interpolationCells;
     forAll(cellStencil_, cellI)

src/overset/cellCellStencil/inverseDistance/inverseDistanceCellCellStencil.C

@@ -2351,8 +2351,9 @@ bool Foam::cellCellStencils::inverseDistance::update()
     oversetFvMeshBase::correctBoundaryConditions
     <
         volScalarField,
-        oversetFvPatchField<scalar>
-    >(cellInterpolationWeight_.boundaryFieldRef(), false);
+        oversetFvPatchField<scalar>,
+        false
+    >(cellInterpolationWeight_.boundaryFieldRef());
 
 
     if ((debug & 2) && mesh_.time().writeTime())
@@ -2435,8 +2436,9 @@ bool Foam::cellCellStencils::inverseDistance::update()
             oversetFvMeshBase::correctBoundaryConditions
             <
                 volScalarField,
-                oversetFvPatchField<scalar>
-            >(tfld.ref().boundaryFieldRef(), false);
+                oversetFvPatchField<scalar>,
+                false
+            >(tfld.ref().boundaryFieldRef());
             tfld().write();
         }
 
@@ -2450,8 +2452,9 @@ bool Foam::cellCellStencils::inverseDistance::update()
             oversetFvMeshBase::correctBoundaryConditions
             <
                 volScalarField,
-                oversetFvPatchField<scalar>
-            >(tfld.ref().boundaryFieldRef(), false);
+                oversetFvPatchField<scalar>,
+                false
+            >(tfld.ref().boundaryFieldRef());
             tfld().write();
         }
 

src/overset/cellCellStencil/trackingInverseDistance/trackingInverseDistanceCellCellStencil.C

@@ -1059,8 +1059,9 @@ bool Foam::cellCellStencils::trackingInverseDistance::update()
     oversetFvMeshBase::correctBoundaryConditions
     <
         volScalarField,
-        oversetFvPatchField<scalar>
-    >(cellInterpolationWeight_.boundaryFieldRef(), false);
+        oversetFvPatchField<scalar>,
+        false
+    >(cellInterpolationWeight_.boundaryFieldRef());
 
 
     if ((debug & 2) && mesh_.time().writeTime())