ENH: AMI caching - addeduser-selectable stride

Applicable to rotational cases:

- stores AMI weights and addressing on the first revolution
- cached evaluations performed on subsequent revolutions to reduce computational
  costs

Cached values are stored in angular bins, specified using the [optional]
`cacheSize` entry when defining the patch in the polyMesh/boundary file, e.g.

    AMI1
    {
        type            cyclicAMI;
        AMIMethod       faceAreaWeightAMI;
        neighbourPatch  AMI2;

        cacheSize       360; // New entry
        transform       rotational;
        rotationAxis    (0 0 1);
        rotationCentre  (0 0 0);
    }

Note that the transform must also be set to rotational; the additional
`rotationAxis` and `rotationCentre` entries are used to construct a local AMI
co-ordinate system to determine the rotation angle as the mesh moves.

360 bins are created in the example above, equating to a uniform bin width
of 1 degree.

src/TurbulenceModels/turbulenceModels/LES/LESdeltas/smoothDelta/smoothDelta.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2020 OpenCFD Ltd.
+    Copyright (C) 2016-2020,2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -189,6 +189,23 @@ public:
                 template<class TrackingData>
                 inline bool equal(const deltaData&, TrackingData& td) const;
 
+                //- Interpolate between two values (lerp). Returns true if
+                //- causes changes. Not sure if needs to be specialised between
+                //- face and cell and what index is needed...
+                template<class TrackingData>
+                inline bool interpolate
+                (
+                    const polyMesh&,
+                    const point& pt,
+                    const label i0,
+                    const deltaData& f0,
+                    const label i1,
+                    const deltaData& f1,
+                    const scalar weight,
+                    const scalar tol,
+                    TrackingData& td
+                );
+
 
         // Member Operators
 
@@ -296,6 +313,17 @@ public:
 template<>
 struct is_contiguous<LESModels::smoothDelta::deltaData> : std::true_type {};
 
+//- Interpolation - used in e.g. cyclicAMI interpolation
+inline LESModels::smoothDelta::deltaData lerp
+(
+    const LESModels::smoothDelta::deltaData& a,
+    const LESModels::smoothDelta::deltaData& b,
+    const scalar t
+)
+{
+    return LESModels::smoothDelta::deltaData(lerp(a.delta(), b.delta(), t));
+}
+
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/TurbulenceModels/turbulenceModels/LES/LESdeltas/smoothDelta/smoothDeltaDeltaDataI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019,2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -191,6 +191,40 @@ inline bool Foam::LESModels::smoothDelta::deltaData::equal
 }
 
 
+template<class TrackingData>
+inline bool Foam::LESModels::smoothDelta::deltaData::interpolate
+(
+    const polyMesh&,
+    const point& pt,
+    const label i0,
+    const deltaData& f0,
+    const label i1,
+    const deltaData& f1,
+    const scalar weight,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    if (f0.valid(td) && f1.valid(td))
+    {
+        const deltaData w2(lerp(f0.delta(), f1.delta(), weight));
+        return update(w2, 1.0, tol, td);
+    }
+    else if (f0.valid(td))
+    {
+        return update(f0, 1.0, tol, td);
+    }
+    else if (f1.valid(td))
+    {
+        return update(f1, 1.0, tol, td);
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 inline bool Foam::LESModels::smoothDelta::deltaData::operator==

src/dynamicMesh/meshCut/directions/directionInfo/directionInfo.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2020 OpenCFD Ltd.
+    Copyright (C) 2019-2020,2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -242,6 +242,23 @@ public:
             template<class TrackingData>
             inline bool equal(const directionInfo&, TrackingData& td) const;
 
+            //- Interpolate between two values (lerp). Returns true if
+            //- causes changes. Not sure if needs to be specialised between
+            //- face and cell and what index is needed...
+            template<class TrackingData>
+            inline bool interpolate
+            (
+                const polyMesh&,
+                const point& pt,
+                const label i0,
+                const directionInfo& f0,
+                const label i1,
+                const directionInfo& f1,
+                const scalar weight,
+                const scalar tol,
+                TrackingData& td
+            );
+
 
     // Member Operators
 

src/dynamicMesh/meshCut/directions/directionInfo/directionInfoI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2020 OpenCFD Ltd.
+    Copyright (C) 2020,2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -287,6 +287,35 @@ inline bool Foam::directionInfo::equal
 }
 
 
+template<class TrackingData>
+inline bool Foam::directionInfo::interpolate
+(
+    const polyMesh& mesh,
+    const point& pt,
+    const label i0,
+    const directionInfo& f0,
+    const label i1,
+    const directionInfo& f1,
+    const scalar weight,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    if (f0.valid(td))
+    {
+        return updateFace(mesh, -1, f0, tol, td);
+    }
+    if (f1.valid(td))
+    {
+        return updateFace(mesh, -1, f1, tol, td);
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 inline bool Foam::directionInfo::operator==

src/dynamicMesh/meshCut/wallLayerCells/wallNormalInfo/wallNormalInfo.H

@@ -186,6 +186,23 @@ public:
                 TrackingData& td
             );
 
+            //- Interpolate between two values (lerp). Returns true if
+            //- causes changes. Not sure if needs to be specialised between
+            //- face and cell and what index is needed...
+            template<class TrackingData>
+            inline bool interpolate
+            (
+                const polyMesh&,
+                const point& pt,
+                const label i0,
+                const wallNormalInfo& f0,
+                const label i1,
+                const wallNormalInfo& f1,
+                const scalar weight,
+                const scalar tol,
+                TrackingData& td
+            );
+
             //- Test for equality, with TrackingData
             template<class TrackingData>
             inline bool equal(const wallNormalInfo&, TrackingData& td) const;

src/dynamicMesh/meshCut/wallLayerCells/wallNormalInfo/wallNormalInfoI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2020 OpenCFD Ltd.
+    Copyright (C) 2020,2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -191,6 +191,35 @@ inline bool Foam::wallNormalInfo::equal
 }
 
 
+template<class TrackingData>
+inline bool Foam::wallNormalInfo::interpolate
+(
+    const polyMesh&,
+    const point& pt,
+    const label i0,
+    const wallNormalInfo& f0,
+    const label i1,
+    const wallNormalInfo& f1,
+    const scalar weight,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    if (f0.valid(td))
+    {
+        return update(f0, td);
+    }
+    if (f1.valid(td))
+    {
+        return update(f1, td);
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 inline bool Foam::wallNormalInfo::operator==

src/dynamicMesh/polyTopoChange/polyTopoChange/refinementData.H

@@ -197,6 +197,23 @@ public:
             template<class TrackingData>
             inline bool equal(const refinementData&, TrackingData& td) const;
 
+            //- Interpolate between two values (lerp). Returns true if
+            //- causes changes. Not sure if needs to be specialised between
+            //- face and cell and what index is needed...
+            template<class TrackingData>
+            inline bool interpolate
+            (
+                const polyMesh&,
+                const point& pt,
+                const label i0,
+                const refinementData& f0,
+                const label i1,
+                const refinementData& f1,
+                const scalar weight,
+                const scalar tol,
+                TrackingData& td
+            );
+
 
     // Member Operators
 

src/dynamicMesh/polyTopoChange/polyTopoChange/refinementDataI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2020 OpenCFD Ltd.
+    Copyright (C) 2020,2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -248,6 +248,35 @@ inline bool Foam::refinementData::equal
 }
 
 
+template<class TrackingData>
+inline bool Foam::refinementData::interpolate
+(
+    const polyMesh& mesh,
+    const point& pt,
+    const label i0,
+    const refinementData& f0,
+    const label i1,
+    const refinementData& f1,
+    const scalar weight,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    if (f0.valid(td))
+    {
+        return updateFace(mesh, -1, f0, tol, td);
+    }
+    if (f1.valid(td))
+    {
+        return updateFace(mesh, -1, f1, tol, td);
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 inline bool Foam::refinementData::operator==

src/dynamicMesh/polyTopoChange/polyTopoChange/refinementDistanceData.H

@@ -229,6 +229,23 @@ public:
             inline bool equal(const refinementDistanceData&, TrackingData&)
             const;
 
+            //- Interpolate between two values (lerp). Returns true if
+            //- causes changes. Not sure if needs to be specialised between
+            //- face and cell and what index is needed...
+            template<class TrackingData>
+            inline bool interpolate
+            (
+                const polyMesh&,
+                const point& pt,
+                const label i0,
+                const refinementDistanceData& f0,
+                const label i1,
+                const refinementDistanceData& f1,
+                const scalar weight,
+                const scalar tol,
+                TrackingData& td
+            );
+
 
     // Member Operators
 

src/dynamicMesh/polyTopoChange/polyTopoChange/refinementDistanceDataI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2020 OpenCFD Ltd.
+    Copyright (C) 2019-2020,2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -278,6 +278,35 @@ inline bool Foam::refinementDistanceData::equal
 }
 
 
+template<class TrackingData>
+inline bool Foam::refinementDistanceData::interpolate
+(
+    const polyMesh&,
+    const point& pt,
+    const label i0,
+    const refinementDistanceData& f0,
+    const label i1,
+    const refinementDistanceData& f1,
+    const scalar weight,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    if (f0.valid(td))
+    {
+        return update(pt, f0, tol, td);
+    }
+    if (f1.valid(td))
+    {
+        return update(pt, f1, tol, td);
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 inline bool Foam::refinementDistanceData::operator==

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

@@ -227,9 +227,15 @@ bool Foam::cyclicACMIFvPatchField<Type>::all_ready() const
             recvRequests_.start(),
             recvRequests_.size()
         )
+     && UPstream::finishedRequests
+        (
+            recvRequests1_.start(),
+            recvRequests1_.size()
+        )
     )
     {
         recvRequests_.clear();
+        recvRequests1_.clear();
         ++done;
     }
 
@@ -240,9 +246,15 @@ bool Foam::cyclicACMIFvPatchField<Type>::all_ready() const
             sendRequests_.start(),
             sendRequests_.size()
         )
+     && UPstream::finishedRequests
+        (
+            sendRequests1_.start(),
+            sendRequests1_.size()
+        )
     )
     {
         sendRequests_.clear();
+        sendRequests1_.clear();
         ++done;
     }
 
@@ -260,9 +272,15 @@ bool Foam::cyclicACMIFvPatchField<Type>::ready() const
             recvRequests_.start(),
             recvRequests_.size()
         )
+     && UPstream::finishedRequests
+        (
+            recvRequests1_.start(),
+            recvRequests1_.size()
+        )
     )
     {
         recvRequests_.clear();
+        recvRequests1_.clear();
 
         if
         (
@@ -271,9 +289,15 @@ bool Foam::cyclicACMIFvPatchField<Type>::ready() const
                 sendRequests_.start(),
                 sendRequests_.size()
             )
+         && UPstream::finishedRequests
+            (
+                sendRequests1_.start(),
+                sendRequests1_.size()
+            )
         )
         {
             sendRequests_.clear();
+            sendRequests1_.clear();
         }
 
         return true;
@@ -483,7 +507,7 @@ void Foam::cyclicACMIFvPatchField<Type>::initEvaluate
         const Field<Type> pnf(this->primitiveField(), nbrFaceCells);
 
         // Assert that all receives are known to have finished
-        if (!recvRequests_.empty())
+        if (!recvRequests_.empty() || !recvRequests1_.empty())
         {
             FatalErrorInFunction
                 << "Outstanding recv request(s) on patch "
@@ -494,14 +518,20 @@ void Foam::cyclicACMIFvPatchField<Type>::initEvaluate
 
         // Assume that sends are also OK
         sendRequests_.clear();
+        sendRequests1_.clear();
 
         cyclicACMIPatch_.initInterpolate
         (
             pnf,
             sendRequests_,
-            sendBufs_,
             recvRequests_,
-            recvBufs_
+            sendBufs_,
+            recvBufs_,
+
+            sendRequests1_,
+            recvRequests1_,
+            sendBufs1_,
+            recvBufs1_
         );
     }
 }
@@ -547,12 +577,15 @@ void Foam::cyclicACMIFvPatchField<Type>::evaluate
             (
                 Field<Type>::null(),    // Not used for distributed
                 recvRequests_,
-                recvBufs_
+                recvBufs_,
+                recvRequests1_,
+                recvBufs1_
             ).ptr()
         );
 
         // Receive requests all handled by last function call
         recvRequests_.clear();
+        recvRequests1_.clear();
 
         if (doTransform())
         {
@@ -608,7 +641,7 @@ void Foam::cyclicACMIFvPatchField<Type>::initInterfaceMatrixUpdate
         transformCoupleField(pnf, cmpt);
 
         // Assert that all receives are known to have finished
-        if (!recvRequests_.empty())
+        if (!recvRequests_.empty() || !recvRequests1_.empty())
         {
             FatalErrorInFunction
                 << "Outstanding recv request(s) on patch "
@@ -619,14 +652,20 @@ void Foam::cyclicACMIFvPatchField<Type>::initInterfaceMatrixUpdate
 
         // Assume that sends are also OK
         sendRequests_.clear();
+        sendRequests1_.clear();
 
         cyclicACMIPatch_.initInterpolate
         (
             pnf,
             sendRequests_,
-            scalarSendBufs_,
             recvRequests_,
-            scalarRecvBufs_
+            scalarSendBufs_,
+            scalarRecvBufs_,
+
+            sendRequests1_,
+            recvRequests1_,
+            scalarSendBufs1_,
+            scalarRecvBufs1_
         );
     }
 
@@ -681,11 +720,14 @@ void Foam::cyclicACMIFvPatchField<Type>::updateInterfaceMatrix
             (
                 solveScalarField::null(),    // Not used for distributed
                 recvRequests_,
-                scalarRecvBufs_
+                scalarRecvBufs_,
+                recvRequests1_,
+                scalarRecvBufs1_
             );
 
         // Receive requests all handled by last function call
         recvRequests_.clear();
+        recvRequests1_.clear();
     }
     else
     {
@@ -738,7 +780,7 @@ void Foam::cyclicACMIFvPatchField<Type>::initInterfaceMatrixUpdate
         transformCoupleField(pnf);
 
         // Assert that all receives are known to have finished
-        if (!recvRequests_.empty())
+        if (!recvRequests_.empty() || !recvRequests1_.empty())
         {
             FatalErrorInFunction
                 << "Outstanding recv request(s) on patch "
@@ -749,14 +791,20 @@ void Foam::cyclicACMIFvPatchField<Type>::initInterfaceMatrixUpdate
 
         // Assume that sends are also OK
         sendRequests_.clear();
+        sendRequests1_.clear();
 
         cyclicACMIPatch_.initInterpolate
         (
             pnf,
             sendRequests_,
-            sendBufs_,
             recvRequests_,
-            recvBufs_
+            sendBufs_,
+            recvBufs_,
+
+            sendRequests1_,
+            recvRequests1_,
+            sendBufs1_,
+            recvBufs1_
         );
     }
 
@@ -798,11 +846,14 @@ void Foam::cyclicACMIFvPatchField<Type>::updateInterfaceMatrix
             (
                 Field<Type>::null(),    // Not used for distributed
                 recvRequests_,
-                recvBufs_
+                recvBufs_,
+                recvRequests1_,
+                recvBufs1_
             );
 
         // Receive requests all handled by last function call
         recvRequests_.clear();
+        recvRequests1_.clear();
     }
     else
     {

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

@@ -102,6 +102,28 @@ class cyclicACMIFvPatchField
             //- Scalar receive buffers
             mutable PtrList<List<solveScalar>> scalarRecvBufs_;
 
+
+            // Only used for AMI caching
+
+                //- Current range of send requests (non-blocking)
+                mutable labelRange sendRequests1_;
+
+                //- Current range of recv requests (non-blocking)
+                mutable labelRange recvRequests1_;
+
+                //- Send buffers
+                mutable PtrList<List<Type>> sendBufs1_;
+
+                //- Receive buffers_
+                mutable PtrList<List<Type>> recvBufs1_;
+
+                //- Scalar send buffers
+                mutable PtrList<List<solveScalar>> scalarSendBufs1_;
+
+                //- Scalar receive buffers
+                mutable PtrList<List<solveScalar>> scalarRecvBufs1_;
+
+
             //- Neighbour coupled internal cell data
             mutable autoPtr<Field<Type>> patchNeighbourFieldPtr_;
 

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

@@ -207,9 +207,15 @@ bool Foam::cyclicAMIFvPatchField<Type>::all_ready() const
             recvRequests_.start(),
             recvRequests_.size()
         )
+    &&  UPstream::finishedRequests
+        (
+            recvRequests1_.start(),
+            recvRequests1_.size()
+        )
     )
     {
         recvRequests_.clear();
+        recvRequests1_.clear();
         ++done;
     }
 
@@ -220,9 +226,15 @@ bool Foam::cyclicAMIFvPatchField<Type>::all_ready() const
             sendRequests_.start(),
             sendRequests_.size()
         )
+    &&  UPstream::finishedRequests
+        (
+            sendRequests1_.start(),
+            sendRequests1_.size()
+        )
     )
     {
         sendRequests_.clear();
+        sendRequests1_.clear();
         ++done;
     }
 
@@ -240,9 +252,15 @@ bool Foam::cyclicAMIFvPatchField<Type>::ready() const
             recvRequests_.start(),
             recvRequests_.size()
         )
+     && UPstream::finishedRequests
+        (
+            recvRequests1_.start(),
+            recvRequests1_.size()
+        )
     )
     {
         recvRequests_.clear();
+        recvRequests1_.clear();
 
         if
         (
@@ -251,9 +269,15 @@ bool Foam::cyclicAMIFvPatchField<Type>::ready() const
                 sendRequests_.start(),
                 sendRequests_.size()
             )
+         && UPstream::finishedRequests
+            (
+                sendRequests1_.start(),
+                sendRequests1_.size()
+            )
         )
         {
             sendRequests_.clear();
+            sendRequests1_.clear();
         }
 
         return true;
@@ -319,9 +343,18 @@ Foam::cyclicAMIFvPatchField<Type>::getNeighbourField
 
 
 template<class Type>
-bool Foam::cyclicAMIFvPatchField<Type>::cacheNeighbourField()
+bool Foam::cyclicAMIFvPatchField<Type>::cacheNeighbourField() const
 {
-    return (FieldBase::localBoundaryConsistency() != 0);
+    // const auto& AMI = this->ownerAMI();
+
+    // if (AMI.cacheActive())
+    // {
+    //     return false;
+    // }
+    // else
+    {
+        return (FieldBase::localBoundaryConsistency() != 0);
+    }
 }
 
 
@@ -350,11 +383,12 @@ Foam::cyclicAMIFvPatchField<Type>::getPatchNeighbourField
         }
 
         const auto& fvp = this->patch();
+        const auto& mesh = fvp.boundaryMesh().mesh();
 
         if
         (
             patchNeighbourFieldPtr_
-        && !fvp.boundaryMesh().mesh().upToDatePoints(this->internalField())
+        && !mesh.upToDatePoints(this->internalField())
         )
         {
             //DebugPout
@@ -418,7 +452,8 @@ template<class Type>
 Foam::tmp<Foam::Field<Type>>
 Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField() const
 {
-    return this->getPatchNeighbourField(true);  // checkCommunicator = true
+    // checkCommunicator = true
+    return this->getPatchNeighbourField(true);
 }
 
 
@@ -491,7 +526,7 @@ void Foam::cyclicAMIFvPatchField<Type>::initEvaluate
         const cyclicAMIPolyPatch& cpp = cyclicAMIPatch_.cyclicAMIPatch();
 
         // Assert that all receives are known to have finished
-        if (!recvRequests_.empty())
+        if (!recvRequests_.empty() || !recvRequests1_.empty())
         {
             FatalErrorInFunction
                 << "Outstanding recv request(s) on patch "
@@ -502,14 +537,20 @@ void Foam::cyclicAMIFvPatchField<Type>::initEvaluate
 
         // Assume that sends are also OK
         sendRequests_.clear();
+        sendRequests1_.clear();
 
         cpp.initInterpolate
         (
             pnf,
             sendRequests_,
-            sendBufs_,
             recvRequests_,
-            recvBufs_
+            sendBufs_,
+            recvBufs_,
+
+            sendRequests1_,
+            recvRequests1_,
+            sendBufs1_,
+            recvBufs1_
         );
     }
 }
@@ -562,12 +603,15 @@ void Foam::cyclicAMIFvPatchField<Type>::evaluate
                 Field<Type>::null(),    // Not used for distributed
                 recvRequests_,
                 recvBufs_,
+                recvRequests1_,
+                recvBufs1_,
                 defaultValues
             ).ptr()
         );
 
         // Receive requests all handled by last function call
         recvRequests_.clear();
+        recvRequests1_.clear();
 
         if (doTransform())
         {
@@ -618,7 +662,7 @@ void Foam::cyclicAMIFvPatchField<Type>::initInterfaceMatrixUpdate
         const cyclicAMIPolyPatch& cpp = cyclicAMIPatch_.cyclicAMIPatch();
 
         // Assert that all receives are known to have finished
-        if (!recvRequests_.empty())
+        if (!recvRequests_.empty() || !recvRequests1_.empty())
         {
             FatalErrorInFunction
                 << "Outstanding recv request(s) on patch "
@@ -629,14 +673,20 @@ void Foam::cyclicAMIFvPatchField<Type>::initInterfaceMatrixUpdate
 
         // Assume that sends are also OK
         sendRequests_.clear();
+        sendRequests1_.clear();
 
         cpp.initInterpolate
         (
             pnf,
             sendRequests_,
-            scalarSendBufs_,
             recvRequests_,
-            scalarRecvBufs_
+            scalarSendBufs_,
+            scalarRecvBufs_,
+
+            sendRequests1_,
+            recvRequests1_,
+            scalarSendBufs1_,
+            scalarRecvBufs1_
         );
     }
 
@@ -691,11 +741,14 @@ void Foam::cyclicAMIFvPatchField<Type>::updateInterfaceMatrix
                 solveScalarField::null(),   // Not used for distributed
                 recvRequests_,
                 scalarRecvBufs_,
+                recvRequests1_,
+                scalarRecvBufs1_,
                 defaultValues
             );
 
         // Receive requests all handled by last function call
         recvRequests_.clear();
+        recvRequests1_.clear();
     }
     else
     {
@@ -757,7 +810,7 @@ void Foam::cyclicAMIFvPatchField<Type>::initInterfaceMatrixUpdate
         const cyclicAMIPolyPatch& cpp = cyclicAMIPatch_.cyclicAMIPatch();
 
         // Assert that all receives are known to have finished
-        if (!recvRequests_.empty())
+        if (!recvRequests_.empty() || !recvRequests1_.empty())
         {
             FatalErrorInFunction
                 << "Outstanding recv request(s) on patch "
@@ -768,14 +821,20 @@ void Foam::cyclicAMIFvPatchField<Type>::initInterfaceMatrixUpdate
 
         // Assume that sends are also OK
         sendRequests_.clear();
+        sendRequests1_.clear();
 
         cpp.initInterpolate
         (
             pnf,
             sendRequests_,
-            sendBufs_,
             recvRequests_,
-            recvBufs_
+            sendBufs_,
+            recvBufs_,
+
+            sendRequests1_,
+            recvRequests1_,
+            sendBufs1_,
+            recvBufs1_
         );
     }
 
@@ -829,11 +888,14 @@ void Foam::cyclicAMIFvPatchField<Type>::updateInterfaceMatrix
                 Field<Type>::null(),  // Not used for distributed
                 recvRequests_,
                 recvBufs_,
+                recvRequests1_,
+                recvBufs1_,
                 defaultValues
             );
 
         // Receive requests all handled by last function call
         recvRequests_.clear();
+        recvRequests1_.clear();
     }
     else
     {
@@ -918,7 +980,7 @@ void Foam::cyclicAMIFvPatchField<Type>::manipulateMatrix
         }
 
         // Set internalCoeffs and boundaryCoeffs in the assembly matrix
-        // on clyclicAMI patches to be used in the individual matrix by
+        // on cyclicAMI patches to be used in the individual matrix by
         // matrix.flux()
         if (matrix.psi(mat).mesh().fluxRequired(this->internalField().name()))
         {

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

@@ -113,6 +113,28 @@ class cyclicAMIFvPatchField
             //- Scalar receive buffers
             mutable PtrList<List<solveScalar>> scalarRecvBufs_;
 
+
+            // Only used for AMI caching
+
+                //- Current range of send requests (non-blocking)
+                mutable labelRange sendRequests1_;
+
+                //- Current range of recv requests (non-blocking)
+                mutable labelRange recvRequests1_;
+
+                //- Send buffers
+                mutable PtrList<List<Type>> sendBufs1_;
+
+                //- Receive buffers_
+                mutable PtrList<List<Type>> recvBufs1_;
+
+                //- Scalar send buffers
+                mutable PtrList<List<solveScalar>> scalarSendBufs1_;
+
+                //- Scalar receive buffers
+                mutable PtrList<List<solveScalar>> scalarRecvBufs1_;
+
+
             //- Neighbour coupled internal cell data
             mutable autoPtr<Field<Type>> patchNeighbourFieldPtr_;
 
@@ -134,7 +156,7 @@ class cyclicAMIFvPatchField
         virtual bool all_ready() const;
 
         //- Use neighbour field caching
-        static bool cacheNeighbourField();
+        bool cacheNeighbourField() const;
 
         //- Return neighbour coupled internal cell data
         tmp<Field<Type>> getNeighbourField(const UList<Type>&) const;

src/finiteVolume/finiteVolume/fvc/fvcSmooth/smoothData.H

@@ -209,6 +209,23 @@ public:
             template<class TrackingData>
             inline bool equal(const smoothData&, TrackingData& td) const;
 
+            //- Interpolate between two values (lerp). Returns true if
+            //- causes changes. Not sure if needs to be specialised between
+            //- face and cell and what index is needed...
+            template<class TrackingData>
+            inline bool interpolate
+            (
+                const polyMesh&,
+                const point& pt,
+                const label i0,
+                const smoothData& f0,
+                const label i1,
+                const smoothData& f1,
+                const scalar weight,
+                const scalar tol,
+                TrackingData& td
+            );
+
 
     // Member Operators
 

src/finiteVolume/finiteVolume/fvc/fvcSmooth/smoothDataI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2013 OpenFOAM Foundation
-    Copyright (C) 2020 OpenCFD Ltd.
+    Copyright (C) 2020,2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -191,6 +191,45 @@ inline bool Foam::smoothData::equal
 }
 
 
+template<class TrackingData>
+inline bool Foam::smoothData::interpolate
+(
+    const polyMesh&,
+    const point& pt,
+    const label i0,
+    const smoothData& f0,
+    const label i1,
+    const smoothData& f1,
+    const scalar weight,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    // TBD. What to interpolate? Do we have a position? cell/face centre?
+
+    if (!valid(td))
+    {
+        if (f0.valid(td))
+        {
+            operator=(f0);
+        }
+        else
+        {
+            operator=(f1);
+        }
+    }
+    else if (f0.valid(td))
+    {
+        operator=(f0);
+    }
+    else
+    {
+        operator=(f1);
+    }
+    return true;
+}
+
+
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 inline bool Foam::smoothData::operator==

src/finiteVolume/finiteVolume/fvc/fvcSmooth/sweepData.H

@@ -207,6 +207,23 @@ public:
             template<class TrackingData>
             inline bool equal(const sweepData&, TrackingData& td) const;
 
+            //- Interpolate between two values (lerp). Returns true if
+            //- causes changes. Not sure if needs to be specialised between
+            //- face and cell and what index is needed...
+            template<class TrackingData>
+            inline bool interpolate
+            (
+                const polyMesh&,
+                const point& pt,
+                const label i0,
+                const sweepData& f0,
+                const label i1,
+                const sweepData& f1,
+                const scalar weight,
+                const scalar tol,
+                TrackingData& td
+            );
+
 
     // Member Operators
 

src/finiteVolume/finiteVolume/fvc/fvcSmooth/sweepDataI.H

@@ -210,6 +210,45 @@ inline bool Foam::sweepData::equal
 }
 
 
+template<class TrackingData>
+inline bool Foam::sweepData::interpolate
+(
+    const polyMesh&,
+    const point& pt,
+    const label i0,
+    const sweepData& f0,
+    const label i1,
+    const sweepData& f1,
+    const scalar weight,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    // TBD. What to interpolate? Do we have a position? cell/face centre?
+
+    if (!valid(td))
+    {
+        if (f0.valid(td))
+        {
+            operator=(f0);
+        }
+        else
+        {
+            operator=(f1);
+        }
+    }
+    else if (f0.valid(td))
+    {
+        operator=(f0);
+    }
+    else
+    {
+        operator=(f1);
+    }
+    return true;
+}
+
+
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 inline bool Foam::sweepData::operator==

src/finiteVolume/fvMesh/fvPatches/constraint/cyclicACMI/cyclicACMIFvPatch.H

@@ -220,9 +220,14 @@ public:
                 (
                     const Field<Type>& fld,
                     labelRange& sendRequests,
-                    PtrList<List<Type>>& sendBuffers,
                     labelRange& recvRequests,
-                    PtrList<List<Type>>& recvBuffers
+                    PtrList<List<Type>>& sendBuffers,
+                    PtrList<List<Type>>& recvBuffers,
+
+                    labelRange& sendRequests1,
+                    labelRange& recvRequests1,
+                    PtrList<List<Type>>& sendBuffers1,
+                    PtrList<List<Type>>& recvBuffers1
                 ) const
                 {
                     // Make sure areas are up-to-date
@@ -232,9 +237,14 @@ public:
                     (
                         fld,
                         sendRequests,
-                        sendBuffers,
                         recvRequests,
-                        recvBuffers
+                        sendBuffers,
+                        recvBuffers,
+
+                        sendRequests1,
+                        recvRequests1,
+                        sendBuffers1,
+                        recvBuffers1
                     );
                 }
 
@@ -243,7 +253,9 @@ public:
                 (
                     const Field<Type>& localFld,
                     const labelRange& requests,  // The receive requests
-                    const PtrList<List<Type>>& recvBuffers
+                    const PtrList<List<Type>>& recvBuffers,
+                    const labelRange& requests1,  // The receive requests
+                    const PtrList<List<Type>>& recvBuffers1
                 ) const
                 {
                     return cyclicACMIPolyPatch_.interpolate
@@ -251,6 +263,8 @@ public:
                         localFld,
                         requests,
                         recvBuffers,
+                        requests1,
+                        recvBuffers1,
                         UList<Type>()
                     );
                 }

src/functionObjects/utilities/Make/files

@@ -57,7 +57,6 @@ writeDictionary/writeDictionary.C
 writeObjects/writeObjects.C
 
 thermoCoupleProbes/thermoCoupleProbes.C
-radiometerProbes/radiometerProbes.C
 
 syncObjects/syncObjects.C
 

src/functionObjects/utilities/Make/options

@@ -9,9 +9,7 @@ EXE_INC = \
     -I$(LIB_SRC)/sampling/lnInclude \
     -I$(LIB_SRC)/ODE/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
-    -I$(LIB_SRC)/transportModels/compressible/lnInclude \
-    -I$(LIB_SRC)/thermophysicalModels/radiation/lnInclude \
-    -I$(LIB_SRC)/parallel/distributed/lnInclude
+    -I$(LIB_SRC)/transportModels/compressible/lnInclude
 
 LIB_LIBS = \
     -lfiniteVolume \
@@ -24,6 +22,4 @@ LIB_LIBS = \
     -lsampling \
     -lODE \
     -lfluidThermophysicalModels \
-    -lcompressibleTransportModels \
-    -lradiationModels \
-    -ldistributed
+    -lcompressibleTransportModels

src/functionObjects/utilities/radiometerProbes/radiometerProbes.C

@@ -1,260 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2025 OpenCFD Ltd.
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "radiometerProbes.H"
-#include "addToRunTimeSelectionTable.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-namespace functionObjects
-{
-    defineTypeNameAndDebug(radiometerProbes, 0);
-    addToRunTimeSelectionTable(functionObject, radiometerProbes, dictionary);
-}
-}
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::functionObjects::radiometerProbes::writeFileHeader(Ostream& os)
-{
-    const pointField& locs = probeLocations();
-
-    writeCommented(os, "Probe,Location,Normal");
-
-    os  << nl;
-    for (label i = 0; i < szProbes_; ++i)
-    {
-        const vector& loc = locs[i];
-        const vector& n = n_[i];
-
-        os  << '#' << ' ' << i
-            << ',' << loc.x() << ',' << loc.y() << ',' << loc.z()
-            << ',' << n.x()   << ',' << n.y()   << ',' << n.z()
-            << nl;
-    }
-
-    os  << "# Time";
-    for (int i = 0; i < szProbes_; ++i)
-    {
-        os  << ',' << i;
-    }
-    os  << endl;
-
-    writtenHeader_ = true;
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::functionObjects::radiometerProbes::radiometerProbes
-(
-    const word& name,
-    const Time& runTime,
-    const dictionary& dict
-)
-:
-    regionFunctionObject(name, runTime, dict),
-    internalProber(mesh_, dict),
-    writeFile(mesh_, name, typeName, dict),
-    dom_(mesh_.lookupObject<radiation::fvDOM>("radiationProperties")),
-    firstIter_(true)
-{
-    read(dict);
-}
-
-
-// * * * * * * * * * * * * * * Public Member Functions * * * * * * * * * * * //
-
-bool Foam::functionObjects::radiometerProbes::read(const dictionary& dict)
-{
-    if
-    (
-        !(
-            regionFunctionObject::read(dict)
-         && internalProber::read(dict)
-         && writeFile::read(dict)
-        )
-    )
-    {
-        return false;
-    }
-
-
-    // Skip if the radiation model is inactive
-    if (!dom_.radiation())
-    {
-        WarningInFunction
-            << "The radiation model is inactive."
-            << "Skipping the function object " << type() << ' ' << name()
-            << endl;
-        return false;
-    }
-
-    Log << type() << ':' << name() << ": read" << nl << nl;
-
-
-    // Probe locations are read by 'internalProber'
-    szProbes_ = this->size();
-
-    // If/when fvDOM is updated, the 'read' func is assumed to be executed to
-    // update the fvDOM properties
-    nRay_ = dom_.nRay();
-
-    if (!szProbes_ || !nRay_)
-    {
-        FatalIOErrorInFunction(dict)
-            << "size(probe locations): " << szProbes_ << nl
-            << "size(rays): " << nRay_ << nl
-            << "The input size of probe locations and rays cannot be zero."
-            << exit(FatalIOError);
-    }
-
-    // Read and check size consistency of probe normals with probe locations
-    dict.readEntry("probeNormals", n_);
-    if (n_.size() != szProbes_)
-    {
-        FatalIOErrorInFunction(dict)
-            << "size(probe locations): " << szProbes_ << nl
-            << "size(probe normals): " << n_.size() << nl
-            << "The input size of probe locations and normals must match."
-            << exit(FatalIOError);
-    }
-    n_.normalise();
-
-
-    // Pre-compute and cache inner product of 'n_' and 'dAve_', and 'C_'
-    // This simplification of calculation is valid only if I is non-negative
-    n_dAve_.resize(nRay_);
-    C_.resize(nRay_);
-
-    for (label rayi = 0; rayi < nRay_; ++rayi)
-    {
-        const vector& dAvei = dom_.IRay(rayi).dAve();
-
-        scalarList& n_dAveRay = n_dAve_[rayi];
-        boolList& Cray = C_[rayi];
-
-        n_dAveRay.resize(szProbes_, Zero);
-        Cray.resize(szProbes_, false);
-
-        for (label pi = 0; pi < szProbes_; ++pi)
-        {
-            n_dAveRay[pi] = n_[pi] & dAvei;
-
-            if (n_dAveRay[pi] < 0)  // ray entering the probe
-            {
-                Cray[pi] = true;
-            }
-        }
-    }
-
-    qin_.resize(szProbes_);
-
-
-    if (writeFile::canResetFile())
-    {
-        writeFile::resetFile(typeName);
-    }
-
-    if (writeFile::canWriteHeader())
-    {
-        writeFileHeader(file());
-    }
-
-    return true;
-}
-
-
-bool Foam::functionObjects::radiometerProbes::execute()
-{
-    // Skip if there is no probe to sample, or the radiation model is inactive
-    if (!szProbes_ || !dom_.radiation() || !shouldCalcThisStep())
-    {
-        return false;
-    }
-
-    Log << type() << ' ' << name() << ": execute" << nl << nl;
-
-    qin_ = Zero;  // resized in 'read'
-
-    for (label rayi = 0; rayi < nRay_; ++rayi)
-    {
-        // Radiative intensity field for this ray
-        const volScalarField& I = dom_.IRay(rayi).I();
-
-        // Sample radiative intensity ray at probe locations
-        tmp<scalarField> tIp  = internalProber::sample(I);
-        const scalarField& Ip = tIp.cref();
-
-        const scalarList& n_dAveRay = n_dAve_[rayi];
-        const boolList& Cray = C_[rayi];
-
-        // Add incident radiative heat flux per probe location for each ray
-        for (label pi = 0; pi < szProbes_; ++pi)
-        {
-            if (Cray[pi])
-            {
-                qin_[pi] += Ip[pi]*n_dAveRay[pi];
-            }
-        }
-    }
-
-    return true;
-}
-
-
-bool Foam::functionObjects::radiometerProbes::write()
-{
-    // Skip if there is no probe to sample, or the radiation model is inactive
-    if (!szProbes_ || !dom_.radiation() || !shouldCalcThisStep())
-    {
-        return false;
-    }
-
-    Log << type() << ' ' << name() << ": write" << nl << nl;
-
-    if (UPstream::master())
-    {
-        Ostream& os = file();
-
-        os  << mesh_.time().timeOutputValue();
-        for (label pi = 0; pi < szProbes_; ++pi)
-        {
-            os  << ',' << qin_[pi];
-        }
-        os  << endl;
-    }
-
-    firstIter_ = false;
-
-    return true;
-}
-
-
-// ************************************************************************* //

src/functionObjects/utilities/radiometerProbes/radiometerProbes.H

@@ -1,200 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2025 OpenCFD Ltd.
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::functionObjects::radiometerProbes
-
-Group
-    grpUtilitiesFunctionObjects
-
-Description
-    Probes the incident radiative heat flux, qin, at arbitrary points within a
-    domain.
-
-Usage
-    Minimal example by using \c system/controlDict.functions:
-    \verbatim
-    radiometer
-    {
-        // Mandatory entries
-        type                radiometerProbes;
-        libs                (utilityFunctionObjects);
-        probeLocations      (<vectorList>);
-        probeNormals        (<vectorList>);
-
-        // Inherited entries
-        ...
-    }
-    \endverbatim
-
-    where the entries mean:
-    \table
-      Property     | Description                        | Type | Reqd | Deflt
-      type         | Type name: radiometerProbes        | word | yes  | -
-      libs         | Library name: utilityFunctionObjects | word | yes  | -
-      probeLocations | Locations of probes              | vectorList | yes | -
-      probeNormals | Normals of specified probes        | vectorList | yes | -
-    \endtable
-
-    The inherited entries are elaborated in:
-     - \link regionFunctionObject.H \endlink
-     - \link internalProber.H \endlink
-     - \link writeFile.H \endlink
-     - \link fvDOM.H \endlink
-
-Note
-  - The function object can only be used with the \c fvDOM radiation model.
-  - The \c solverFreq input of the \c fvDOM model has superiority over
-    \c executeControl and \c writeControl entries.
-
-SourceFiles
-    radiometerProbes.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef Foam_functionObjects_radiometerProbes_H
-#define Foam_functionObjects_radiometerProbes_H
-
-#include "regionFunctionObject.H"
-#include "internalProber.H"
-#include "writeFile.H"
-#include "fvDOM.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-namespace functionObjects
-{
-
-/*---------------------------------------------------------------------------*\
-                     Class radiometerProbes Declaration
-\*---------------------------------------------------------------------------*/
-
-class radiometerProbes
-:
-    public regionFunctionObject,
-    public internalProber,
-    public writeFile
-{
-    // Private Data
-
-        //- Const reference to the underlying radiation model
-        const radiation::fvDOM& dom_;
-
-        //- Normal vectors of the specified probes
-        vectorField n_;
-
-        //- Pre-computed inner product of probe normals (n_) and average
-        //- solid-angle direction (dAve) per radiative intensity ray
-        List<scalarList> n_dAve_;
-
-        //- Directional selection coefficient for radiative intensity rays
-        //  false: ray entering the probe
-        //  true: ray leaving the probe
-        List<boolList> C_;
-
-        //- Incident radiative heat flux per probe location
-        scalarField qin_;
-
-        //- Number of radiative intensity rays
-        label nRay_;
-
-        //- Number of probe locations/normals
-        label szProbes_;
-
-        //- Flag to identify whether the iteration is the first iteration
-        //  Resets with a restarted simulation
-        bool firstIter_;
-
-
-    // Private Member Functions
-
-        //- Write file-header information into the output file
-        virtual void writeFileHeader(Ostream& os);
-
-        //- Return the flag to decide if radiation-model calculations are
-        //- performed, so that function object calculations can proceed
-        bool shouldCalcThisStep() const
-        {
-            return
-                firstIter_
-             || (mesh_.time().timeIndex() % dom_.solverFreq() == 0);
-        }
-
-
-public:
-
-    //- Runtime type information
-    TypeName("radiometerProbes");
-
-
-    // Generated Methods
-
-        //- No copy construct
-        radiometerProbes(const radiometerProbes&) = delete;
-
-        //- No copy assignment
-        void operator=(const radiometerProbes&) = delete;
-
-
-    // Constructors
-
-        //- Construct from name, Time and dictionary
-        radiometerProbes
-        (
-            const word& name,
-            const Time& runTime,
-            const dictionary& dict
-        );
-
-
-    //- Destructor
-    virtual ~radiometerProbes() = default;
-
-
-    // Public Member Functions
-
-        //- Read the function object settings
-        virtual bool read(const dictionary&);
-
-        //- Execute the function object
-        virtual bool execute();
-
-        //- Write to data files/fields and to streams
-        virtual bool write();
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace functionObjects
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

src/functionObjects/utilities/thermoCoupleProbes/thermoCoupleProbes.C

@@ -76,7 +76,7 @@ Foam::functionObjects::thermoCoupleProbes::thermoCoupleProbes
     }
     else
     {
-        Ttc_ = prober().sample(thermo_.T());
+        Ttc_ = probes::sample(thermo_.T());
     }
 
     // Note: can only create the solver once all samples have been found
@@ -89,7 +89,7 @@ Foam::functionObjects::thermoCoupleProbes::thermoCoupleProbes
 
 Foam::label Foam::functionObjects::thermoCoupleProbes::nEqns() const
 {
-    return prober().size();
+    return this->size();
 }
 
 
@@ -108,21 +108,19 @@ void Foam::functionObjects::thermoCoupleProbes::derivatives
     scalarField Cpc(y.size(), Zero);
     scalarField kappac(y.size(), Zero);
 
-    const auto& p = prober();
-
     if (radiationFieldName_ != "none")
     {
-        G = p.sample(mesh_.lookupObject<volScalarField>(radiationFieldName_));
+        G = sample(mesh_.lookupObject<volScalarField>(radiationFieldName_));
     }
 
-    Tc = p.sample(thermo_.T());
+    Tc = probes::sample(thermo_.T());
 
-    Uc = mag(p.sample(mesh_.lookupObject<volVectorField>(UName_)));
+    Uc = mag(this->sample(mesh_.lookupObject<volVectorField>(UName_)));
 
-    rhoc = p.sample(thermo_.rho()());
-    kappac = p.sample(thermo_.kappa()());
-    muc = p.sample(thermo_.mu()());
-    Cpc = p.sample(thermo_.Cp()());
+    rhoc = this->sample(thermo_.rho()());
+    kappac = this->sample(thermo_.kappa()());
+    muc = this->sample(thermo_.mu()());
+    Cpc = this->sample(thermo_.Cp()());
 
     scalarField Re(rhoc*Uc*d_/muc);
     scalarField Pr(Cpc*muc/kappac);
@@ -165,7 +163,7 @@ void Foam::functionObjects::thermoCoupleProbes::jacobian
 
 bool Foam::functionObjects::thermoCoupleProbes::write()
 {
-    if (!prober().empty())
+    if (!pointField::empty())
     {
         (void) prepare(ACTION_WRITE);
 
@@ -184,7 +182,7 @@ bool Foam::functionObjects::thermoCoupleProbes::write()
 
 bool Foam::functionObjects::thermoCoupleProbes::execute()
 {
-    if (!prober().empty())
+    if (!pointField::empty())
     {
         scalar dt = mesh_.time().deltaTValue();
         scalar t = mesh_.time().value();

src/functionObjects/utilities/thermoCoupleProbes/thermoCoupleProbesTemplates.C

@@ -42,8 +42,7 @@ void Foam::functionObjects::thermoCoupleProbes::writeValues
 
         os  << setw(w) << timeValue;
 
-        const pointField& probes = prober().probeLocations();
-        forAll(probes, probei)
+        forAll(*this, probei)
         {
             // if (includeOutOfBounds_ || processor_[probei] != -1)
             {

src/mesh/snappyHexMesh/meshRefinement/wallPoints.H

@@ -251,6 +251,23 @@ public:
             template<class TrackingData>
             inline bool equal(const wallPoints&, TrackingData&) const;
 
+            //- Interpolate between two values (lerp). Returns true if
+            //- causes changes. Not sure if needs to be specialised between
+            //- face and cell and what index is needed...
+            template<class TrackingData>
+            inline bool interpolate
+            (
+                const polyMesh&,
+                const point& pt,
+                const label i0,
+                const wallPoints& f0,
+                const label i1,
+                const wallPoints& f1,
+                const scalar weight,
+                const scalar tol,
+                TrackingData& td
+            );
+
 
     // Member Operators
 

src/mesh/snappyHexMesh/meshRefinement/wallPointsI.H

@@ -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.
@@ -443,6 +443,41 @@ inline bool Foam::wallPoints::equal
 }
 
 
+template<class TrackingData>
+inline bool Foam::wallPoints::interpolate
+(
+    const polyMesh&,
+    const point& pt,
+    const label i0,
+    const wallPoints& f0,
+    const label i1,
+    const wallPoints& f1,
+    const scalar weight,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    if (valid(td))
+    {
+        return false;
+    }
+    else if (f0.valid(td))
+    {
+        operator=(f0);
+        return true;
+    }
+    else if (f1.valid(td))
+    {
+        operator=(f1);
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 inline bool Foam::wallPoints::operator==

src/meshTools/AMIInterpolation/AMIInterpolation/AMICache.C

@@ -0,0 +1,651 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2025 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "AMICache.H"
+#include "AMIInterpolation.H"
+#include "mathematicalConstants.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+Foam::scalar Foam::AMICache::cacheThetaTolerance_ = 1e-8;
+
+int Foam::AMICache::debug = 0;
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::scalar Foam::AMICache::getRotationAngle(const point& globalPoint) const
+{
+    if (!coordSysPtr_)
+    {
+        FatalErrorInFunction
+            << "No co-ordinate system available for theta evaluation"
+            << abort(FatalError);
+    }
+
+
+    scalar theta = coordSysPtr_->localPosition(globalPoint).y();
+
+    // Ensure 0 < theta < 2pi
+    if (mag(theta) < cacheThetaTolerance_)
+    {
+        theta = 0;
+    }
+    else if (theta < 0)
+    {
+        theta += constant::mathematical::twoPi;
+    }
+
+    return theta;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::AMICache::AMICache(const dictionary& dict, const bool toSource)
+:
+    size_(dict.getOrDefault<label>("cacheSize", 0)),
+    rotationAxis_(dict.getOrDefault<vector>("rotationAxis", Zero)),
+    rotationCentre_(dict.getOrDefault<point>("rotationCentre", Zero)),
+    maxThetaDeg_(dict.getOrDefault<scalar>("maxThetaDeg", 5)),
+    complete_(false),
+    index0_(-1),
+    index1_(-1),
+    interpWeight_(0),
+    coordSysPtr_(nullptr),
+    theta_(),
+    cachedSrcAddress_(),
+    cachedSrcWeights_(),
+    cachedSrcWeightsSum_(),
+    cachedSrcMapPtr_(),
+    cachedTgtAddress_(),
+    cachedTgtWeights_(),
+    cachedTgtWeightsSum_(),
+    cachedTgtMapPtr_(),
+    toSource_(toSource)
+{
+    if (size_ != 0)
+    {
+        theta_.resize(size_, GREAT);
+        cachedSrcAddress_.resize(size_);
+        cachedSrcWeights_.resize(size_);
+        cachedSrcWeightsSum_.resize(size_);
+        cachedSrcMapPtr_.resize(size_);
+        cachedTgtAddress_.resize(size_);
+        cachedTgtWeights_.resize(size_);
+        cachedTgtWeightsSum_.resize(size_);
+        cachedTgtMapPtr_.resize(size_);
+    }
+}
+
+
+Foam::AMICache::AMICache(const bool toSource)
+:
+    size_(0),
+    rotationAxis_(Zero),
+    rotationCentre_(Zero),
+    complete_(false),
+    index0_(-1),
+    index1_(-1),
+    interpWeight_(0),
+    coordSysPtr_(nullptr),
+    theta_(),
+    cachedSrcAddress_(),
+    cachedSrcWeights_(),
+    cachedSrcWeightsSum_(),
+    cachedSrcMapPtr_(),
+    cachedTgtAddress_(),
+    cachedTgtWeights_(),
+    cachedTgtWeightsSum_(),
+    cachedTgtMapPtr_(),
+    toSource_(toSource)
+{}
+
+
+Foam::AMICache::AMICache(const AMICache& cache)
+:
+    size_(cache.size_),
+    rotationAxis_(cache.rotationAxis_),
+    rotationCentre_(cache.rotationCentre_),
+    complete_(cache.complete_),
+    index0_(cache.index0_),
+    index1_(cache.index1_),
+    interpWeight_(cache.interpWeight_),
+    coordSysPtr_(nullptr),  // Need to clone as cylindricalCS
+    theta_(cache.theta_),
+    cachedSrcAddress_(cache.cachedSrcAddress_),
+    cachedSrcWeights_(cache.cachedSrcWeights_),
+    cachedSrcWeightsSum_(cache.cachedSrcWeightsSum_),
+    cachedSrcMapPtr_(cache.cachedSrcMapPtr_.size()),  // Need to clone
+    cachedTgtAddress_(cache.cachedTgtAddress_),
+    cachedTgtWeights_(cache.cachedTgtWeights_),
+    cachedTgtWeightsSum_(cache.cachedTgtWeightsSum_),
+    cachedTgtMapPtr_(cache.cachedTgtMapPtr_.size()),  // Need to clone
+    toSource_(cache.toSource_)
+{
+    if (cache.coordSysPtr_)
+    {
+        coordSysPtr_.reset(new coordSystem::cylindrical(cache.coordSysPtr_()));
+    }
+
+    forAll(cachedSrcMapPtr_, cachei)
+    {
+        cachedSrcMapPtr_[cachei].reset(cache.cachedSrcMapPtr_[cachei].clone());
+    }
+
+    forAll(cachedTgtMapPtr_, cachei)
+    {
+        cachedTgtMapPtr_[cachei].reset(cache.cachedTgtMapPtr_[cachei].clone());
+    }
+}
+
+
+Foam::AMICache::AMICache
+(
+    const AMICache& cache,
+    const AMIInterpolation& fineAMI,
+    const labelList& sourceRestrictAddressing,
+    const labelList& targetRestrictAddressing
+)
+:
+    size_(cache.size_),
+    rotationAxis_(cache.rotationAxis_),
+    rotationCentre_(cache.rotationCentre_),
+    complete_(cache.complete_),
+    index0_(cache.index0_),
+    index1_(cache.index1_),
+    interpWeight_(cache.interpWeight_),
+    coordSysPtr_(nullptr),
+    theta_(cache.theta_),
+    cachedSrcAddress_(cache.size_),
+    cachedSrcWeights_(cache.size_),
+    cachedSrcWeightsSum_(cache.size_),
+    cachedSrcMapPtr_(cache.size_),
+    cachedTgtAddress_(cache.size_),
+    cachedTgtWeights_(cache.size_),
+    cachedTgtWeightsSum_(cache.size_),
+    cachedTgtMapPtr_(cache.size_),
+    toSource_(cache.toSource_)
+{
+    if (size_ > 0 && fineAMI.comm() != -1)
+    {
+        for (label cachei : {index0_, index1_})
+        {
+            if (cachei == -1) continue;
+
+            scalarField dummySrcMagSf;
+            labelListList srcAddress;
+            scalarListList srcWeights;
+            scalarField srcWeightsSum;
+            autoPtr<mapDistribute> tgtMapPtr;
+
+            AMIInterpolation::agglomerate
+            (
+                cache.cachedTgtMapPtr()[cachei],
+                fineAMI.srcMagSf(),
+                cache.cachedSrcAddress()[cachei],
+                cache.cachedSrcWeights()[cachei],
+
+                sourceRestrictAddressing,
+                targetRestrictAddressing,
+
+                dummySrcMagSf,
+                srcAddress,
+                srcWeights,
+                srcWeightsSum,
+                tgtMapPtr,
+                fineAMI.comm()
+            );
+
+            scalarField dummyTgtMagSf;
+            labelListList tgtAddress;
+            scalarListList tgtWeights;
+            scalarField tgtWeightsSum;
+            autoPtr<mapDistribute> srcMapPtr;
+
+            AMIInterpolation::agglomerate
+            (
+                cache.cachedSrcMapPtr()[cachei],
+                fineAMI.tgtMagSf(),
+                cache.cachedTgtAddress()[cachei],
+                cache.cachedTgtWeights()[cachei],
+
+                targetRestrictAddressing,
+                sourceRestrictAddressing,
+
+                dummyTgtMagSf,
+                tgtAddress,
+                tgtWeights,
+                tgtWeightsSum,
+                srcMapPtr,
+                fineAMI.comm()
+            );
+
+            cachedSrcAddress_[cachei] = srcAddress;
+            cachedSrcWeights_[cachei] = srcWeights;
+            cachedSrcWeightsSum_[cachei] = srcWeightsSum;
+            cachedSrcMapPtr_[cachei] = srcMapPtr.clone();
+
+            cachedTgtAddress_[cachei] = tgtAddress;
+            cachedTgtWeights_[cachei] = tgtWeights;
+            cachedTgtWeightsSum_[cachei] = tgtWeightsSum;
+            cachedTgtMapPtr_[cachei] = tgtMapPtr.clone();
+        }
+    }
+}
+
+
+Foam::AMICache::AMICache(Istream& is)
+:
+    size_(readLabel(is)),
+
+    rotationAxis_(is),
+    rotationCentre_(is),
+    maxThetaDeg_(readScalar(is)),
+
+    complete_(readBool(is)),
+
+    index0_(-1),
+    index1_(-1),
+    interpWeight_(0),
+    coordSysPtr_(nullptr),
+    theta_(),
+    cachedSrcAddress_(),
+    cachedSrcWeights_(),
+    cachedSrcWeightsSum_(),
+    cachedSrcMapPtr_(),
+    cachedTgtAddress_(),
+    cachedTgtWeights_(),
+    cachedTgtWeightsSum_(),
+    cachedTgtMapPtr_()
+{
+    const bitSet goodMap(is);
+
+    if (goodMap.size())
+    {
+        is >> index0_
+           >> index1_
+           >> interpWeight_
+           >> theta_;
+
+        const bool goodCoord(readBool(is));
+        if (goodCoord)
+        {
+            coordSysPtr_.reset(new coordSystem::cylindrical(is));
+        }
+
+        is >> cachedSrcAddress_
+           >> cachedSrcWeights_
+           >> cachedSrcWeightsSum_;
+
+        cachedSrcMapPtr_.setSize(goodMap.size());
+        forAll(goodMap, cachei)
+        {
+            if (goodMap[cachei])
+            {
+                cachedSrcMapPtr_[cachei].reset(new mapDistribute(is));
+            }
+        }
+
+        is >> cachedTgtAddress_
+           >> cachedTgtWeights_
+           >> cachedTgtWeightsSum_;
+
+        cachedTgtMapPtr_.setSize(goodMap.size());
+        forAll(goodMap, cachei)
+        {
+            if (goodMap[cachei])
+            {
+                cachedTgtMapPtr_[cachei].reset(new mapDistribute(is));
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::AMICache::addToCache
+(
+    const AMIInterpolation& ami,
+    const point& globalPoint
+)
+{
+    DebugPout<< "-- addToCache" << endl;
+
+
+    if (!active())
+    {
+        DebugInfo<< "-- addToCache - deactivated" << endl;
+        return;
+    }
+
+    if (!coordSysPtr_)
+    {
+        DebugInfo
+            << "Creating rotation co-ordinate system:"
+            << " rotationCentre:" << rotationCentre_
+            << " rotationAxis:" << rotationAxis_
+            << " p:" << globalPoint
+            << endl;
+
+        coordSysPtr_.reset
+        (
+            new coordSystem::cylindrical(rotationCentre_, rotationAxis_)
+        );
+        DebugPout<< "Coord sys:" << coordSysPtr_() << endl;
+    }
+
+    // Check if cache is complete
+    if (!complete_)
+    {
+        for (const scalar angle : theta_)
+        {
+            // Check against null value; if any are present, cache is incomplete
+            if (angle > constant::mathematical::twoPi)
+            {
+                complete_ = false;
+                break;
+            }
+        }
+    }
+
+    if (!complete_)
+    {
+        const scalar theta = getRotationAngle(globalPoint);
+
+        const label bini = theta/constant::mathematical::twoPi*size_;
+
+        DebugPout<< "  -- bini:" << bini << " for theta:" << theta << endl;
+
+        // Check if already have entry for this bin
+        if (theta_[bini] > constant::mathematical::twoPi)
+        {
+            DebugPout<< "  -- setting cache at index " << bini << endl;
+
+            // New entry
+            theta_[bini] = theta;
+
+            cachedSrcAddress_[bini] = ami.srcAddress();
+            cachedSrcWeights_[bini] = ami.srcWeights();
+            cachedSrcWeightsSum_[bini] = ami.srcWeightsSum();
+
+            if (ami.hasSrcMap())
+            {
+                cachedSrcMapPtr_[bini] = ami.srcMap().clone();
+            }
+
+            cachedTgtAddress_[bini] = ami.tgtAddress();
+            cachedTgtWeights_[bini] = ami.tgtWeights();
+            cachedTgtWeightsSum_[bini] = ami.tgtWeightsSum();
+
+            if (ami.hasTgtMap())
+            {
+                cachedTgtMapPtr_[bini] = ami.tgtMap().clone();
+            }
+        }
+    }
+}
+
+
+bool Foam::AMICache::restoreCache(const point& globalPoint)
+{
+    DebugPout<< "-- restoreCache" << endl;
+
+    index0_ = -1;
+    index1_ = -1;
+    interpWeight_ = -1;
+
+    if (!coordSysPtr_ || size_ == -1)
+    {
+        return false;
+    }
+
+    const scalar theta = getRotationAngle(globalPoint);
+    const scalar twoPi = constant::mathematical::twoPi;
+    const label bini = theta/twoPi*size_;
+
+    DebugPout<< "  -- bini:" << bini << " for theta:" << theta << endl;
+
+    const auto validIndex = [&](const scalar bini)
+    {
+        return theta_[bini] < constant::mathematical::twoPi;
+    };
+
+    // Maximum angle in degrees for which to search for cached bins
+    const scalar maxThetaStencil = maxThetaDeg_*constant::mathematical::pi/180.0;
+
+    if
+    (
+        validIndex(bini)
+     && (
+            mag(theta - theta_[bini]) < cacheThetaTolerance_
+         || mag(theta - twoPi - theta_[bini]) < cacheThetaTolerance_
+        )
+    )
+    {
+        // Hit cached value - no interpolation needed
+        // index1_ = -1 indicates no interpolation
+        index0_ = bini;
+        index1_ = -1;
+        interpWeight_ = 0;
+
+        DebugInfo
+            << "  -- t0:" << theta_[index0_] << " theta:" << theta
+            << " i0:" << index0_ << " i1:" << index1_
+            << " w:" << interpWeight_ << endl;
+        return true;
+    }
+    else
+    {
+        // Find indices and values bracketing theta
+        const label nBin = theta_.size();
+
+        // Participating theta values and bin addresses
+        // - Note we add wrap-around values at start and end
+        DynamicList<scalar> thetap(nBin+2);
+        DynamicList<label> binAddresses(nBin+2);
+
+        // Initialise wrap-around values
+        thetap.push_back(0);
+        binAddresses.push_back(-1);
+        forAll(theta_, thetai)
+        {
+            if (validIndex(thetai))
+            {
+                thetap.push_back(theta_[thetai]);
+                binAddresses.push_back(thetai);
+            }
+        }
+
+        // Check that we have enough data points for interpolation
+        // - We added storage for lower wrap-around value, and we then need
+        //   at least 2 additional values for the interpolation
+        if (thetap.size() < 3)
+        {
+            DebugPout<< "  -- no cache available" << endl;
+            return false;
+        }
+
+        // Set wrap-around values if we have sufficient data
+        thetap[0] = thetap.last() - twoPi;
+        binAddresses[0] = binAddresses.last();
+        thetap.push_back(thetap[1] + twoPi);
+        binAddresses.push_back(binAddresses[1]);
+
+        // Find interpolation indices
+        label loweri = labelMax;
+        label i = 0;
+        while (i < thetap.size())
+        {
+            if (thetap[i] < theta)
+            {
+                loweri = i;
+            }
+            else
+            {
+                break;
+            }
+            ++i;
+        }
+
+        if (loweri == labelMax)
+        {
+            DebugPout<< "  -- no cache available" << endl;
+            return false;
+        }
+
+        label upperi = labelMax;
+        i = thetap.size() - 1;
+        while (i >= 0)
+        {
+            if (thetap[i] > theta)
+            {
+                upperi = i;
+            }
+            else
+            {
+                break;
+            }
+            --i;
+        }
+
+        if (upperi == labelMax)
+        {
+            DebugPout<< "  -- no cache available" << endl;
+            return false;
+        }
+
+        // Ensure distances are valid
+        if (upperi == loweri)
+        {
+            DebugPout
+                << "  -- no cache available: theta:" << theta
+                << " lower:" << loweri << " upper:" << upperi << endl;
+            return false;
+        }
+        if (mag(theta - thetap[loweri]) > maxThetaStencil)
+        {
+            DebugPout
+                << "  -- no cache available: theta:" << theta
+                << " lower:" << thetap[loweri] << endl;
+            return false;
+        }
+        if (mag(theta - thetap[upperi]) > maxThetaStencil)
+        {
+            DebugPout
+                << "  -- no cache available: theta:" << theta
+                << " upper:" << thetap[upperi] << endl;
+            return false;
+        }
+
+        index0_ = binAddresses[loweri];
+        index1_ = binAddresses[upperi];
+        interpWeight_ =
+            (theta - theta_[index0_])/(theta_[index1_] - theta_[index0_]);
+
+        DebugInfo
+            << theta_.size()
+            << "  -- t0:" << theta_[index0_] << " theta:" << theta
+            << " t1:" << theta_[index1_]
+            << " i0:" << index0_ << " i1:" << index1_
+            << " w:" << interpWeight_ << endl;
+
+
+        return true;
+    }
+
+    // If we get here then no valid cache found within stencil
+    DebugPout<< "  -- no cache available" << endl;
+    return false;
+}
+
+
+void Foam::AMICache::write(Ostream& os) const
+{
+    if (size_ > 0)
+    {
+        os.writeEntry("cacheSize", size_);
+        os.writeEntry("rotationAxis", rotationAxis_);
+        os.writeEntry("rotationCentre", rotationCentre_);
+        os.writeEntry("maxThetaDeg", maxThetaDeg_);
+    }
+}
+
+
+bool Foam::AMICache::writeData(Ostream& os) const
+{
+    os  << token::SPACE<< size_
+        << token::SPACE<< rotationAxis_
+        << token::SPACE<< rotationCentre_
+        << token::SPACE<< maxThetaDeg_
+        << token::SPACE<< complete_;
+
+    bitSet goodMap(cachedSrcMapPtr_.size());
+    forAll(goodMap, cachei)
+    {
+        goodMap.set(cachei, cachedSrcMapPtr_[cachei].good());
+    }
+    os  << token::SPACE << goodMap;
+
+    if (goodMap.size())
+    {
+        os  << token::SPACE << index0_
+            << token::SPACE << index1_
+            << token::SPACE << interpWeight_
+            << token::SPACE << theta_;
+
+        os  << token::SPACE << coordSysPtr_.good();
+
+        if (coordSysPtr_.good())
+        {
+            os  << token::SPACE << coordSysPtr_();
+        }
+
+        os  << token::SPACE << cachedSrcAddress_
+            << token::SPACE << cachedSrcWeights_
+            << token::SPACE << cachedSrcWeightsSum_;
+
+        for (const auto& index : goodMap)
+        {
+            os  << token::SPACE << cachedSrcMapPtr_[index]();
+        }
+
+        os  << token::SPACE << cachedTgtAddress_
+            << token::SPACE << cachedTgtWeights_
+            << token::SPACE << cachedTgtWeightsSum_;
+
+        for (const auto& index : goodMap)
+        {
+            os  << token::SPACE << cachedTgtMapPtr_[index]();
+        }
+    }
+
+    return true;
+}
+
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/AMIInterpolation/AMICache.H

@@ -0,0 +1,388 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2025 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::AMICache
+
+Description
+    Provides caching of weights and addressing to AMIInterpolation
+
+SourceFiles
+    AMICache.C
+
+SeeAlso
+    Foam::AMIInterpolation.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef Foam_AMICache_H
+#define Foam_AMICache_H
+
+#include "cylindricalCS.H"
+#include "mapDistribute.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class AMIInterpolation;
+
+/*---------------------------------------------------------------------------*\
+                          Class AMICache Declaration
+\*---------------------------------------------------------------------------*/
+
+class AMICache
+{
+public:
+
+    // Public Data Types
+
+        //- Tolerance used when caching the AMI to identify e.g. if the
+        //- current rotation angle has already been captured
+        static scalar cacheThetaTolerance_;
+
+        static int debug;
+
+private:
+
+    // Private Data
+
+        //- Cache size
+        label size_;
+
+        //- Axis of rotation for rotational cyclics
+        vector rotationAxis_;
+
+        //- Point on axis of rotation for rotational cyclics
+        point rotationCentre_;
+
+        //- Maximum angle in degrees for which to search for cached bins
+        scalar maxThetaDeg_;
+
+        //- Flag to indicate that the cache is complete
+        bool complete_;
+
+        //- Cache index 0 in lists
+        label index0_;
+
+        //- Cache index 1 in lists
+        label index1_;
+
+        //- Interpolation weight between cache indices 0 and 1
+        scalar interpWeight_;
+
+        //- Local co-ordinate system
+        autoPtr<coordSystem::cylindrical> coordSysPtr_;
+
+        //- List of cached angle snapshots
+        List<scalar> theta_;
+
+        //- List of source addresses
+        List<labelListList> cachedSrcAddress_;
+
+        //- List of source weights
+        List<scalarListList> cachedSrcWeights_;
+
+        //- List of source weights sums
+        List<scalarField> cachedSrcWeightsSum_;
+
+        //- List of source parallel maps
+        List<autoPtr<mapDistribute>> cachedSrcMapPtr_;
+
+        //- List of target addresses
+        List<labelListList> cachedTgtAddress_;
+
+        //- List of target weights
+        List<scalarListList> cachedTgtWeights_;
+
+        //- List of target weights sums
+        List<scalarField> cachedTgtWeightsSum_;
+
+        //- List of target parallel maps
+        List<autoPtr<mapDistribute>> cachedTgtMapPtr_;
+
+
+        //- Flag to indicate interpolation direction
+        mutable bool toSource_;
+
+
+    // Private Member Functions
+
+        //- Get rotation angle for point using local co-ordinate system
+        scalar getRotationAngle(const point& globalPoint) const;
+
+
+public:
+
+    // Constructors
+
+        //- Null constructor
+        AMICache(const bool toSource = true);
+
+        //- Construct from dictionary
+        AMICache(const dictionary& dict, const bool toSource = true);
+
+        //- Construct as copy
+        AMICache(const AMICache& cache);
+
+        //- Construct from agglomeration of AMIInterpolation. Agglomeration
+        //- passed in as new coarse size and addressing from fine from coarse
+        AMICache
+        (
+            const AMICache& cache,
+            const AMIInterpolation& fineAMI,
+            const labelList& sourceRestrictAddressing,
+            const labelList& targetRestrictAddressing
+        );
+
+        //- Construct from stream
+        AMICache(Istream& is);
+
+
+    // Member Functions
+
+        //- Return true if cache is active
+        constexpr bool active() const noexcept { return size_ > 0; }
+
+        //- Return cache size
+        constexpr label size() const noexcept { return size_; }
+
+        //- Return true if cache is complete
+        constexpr bool complete() const noexcept { return complete_; }
+
+        //- Return cache lower bound index
+        constexpr label index0() const noexcept { return index0_; }
+
+        //- Return cache upper bound index
+        constexpr label index1() const noexcept { return index1_; }
+
+        //- Return cache interpolation weight
+        constexpr label weight() const noexcept { return interpWeight_; }
+
+        //- Return list of cached rotation angles
+        const List<scalar>& theta() const noexcept { return theta_; }
+
+        //- Return List of source addresses
+        const List<labelListList>& cachedSrcAddress() const noexcept
+        {
+            return cachedSrcAddress_;
+        }
+
+        //- Return List of source weights
+        const List<scalarListList>& cachedSrcWeights() const noexcept
+        {
+            return cachedSrcWeights_;
+        }
+
+        //- Return List of source weights sums
+        const List<scalarField>& cachedSrcWeightsSum() const noexcept
+        {
+            return cachedSrcWeightsSum_;
+        }
+
+        //- Return List of source parallel maps
+        const List<autoPtr<mapDistribute>>& cachedSrcMapPtr() const noexcept
+        {
+            return cachedSrcMapPtr_;
+        }
+
+        //- Return List of target addresses
+        const List<labelListList>& cachedTgtAddress() const noexcept
+        {
+            return cachedTgtAddress_;
+        }
+
+        //- Return List of target weights
+        const List<scalarListList>& cachedTgtWeights() const noexcept
+        {
+            return cachedTgtWeights_;
+        }
+
+        //- Return List of target weights sums
+        const List<scalarField>& cachedTgtWeightsSum() const noexcept
+        {
+            return cachedTgtWeightsSum_;
+        }
+
+        //- Return List of target parallel maps
+        const List<autoPtr<mapDistribute>>& cachedTgtMapPtr() const noexcept
+        {
+            return cachedTgtMapPtr_;
+        }
+
+        //- Apply cached evaluation based on user supplied evaluation function
+        template<class Type, class EvalFunction>
+        bool apply(List<Type>& result, const EvalFunction& eval) const;
+
+        //- Flag that lower bound is applicable
+        constexpr bool applyLower() const noexcept
+        {
+            return index0_ != -1 && index1_ == -1;
+        }
+
+        //- Flag that upper bound is applicable
+        constexpr bool applyUpper() const noexcept
+        {
+            return index0_ == -1 && index1_ != -1;
+        }
+
+        //- Flag that interpolation is applicable
+        constexpr bool applyInterpolate() const noexcept
+        {
+            return index0_ != -1 && index1_ != -1;
+        }
+
+        //- Set the interpolation direction
+        constexpr bool setDirection(bool toSource) const noexcept
+        {
+            toSource_ = toSource;
+            return toSource_;
+        }
+
+        //- Restore AMI weights and addressing from the cache
+        bool restoreCache(const point& globalPoint);
+
+        //- Add AMI weights and addressing to the cache
+        void addToCache
+        (
+            const AMIInterpolation& ami,
+            const point& globalPoint
+        );
+
+        //- Check cache index is valid
+        void checkIndex(const label index) const
+        {
+            if ((index < 0) || (index > size_-1))
+            {
+                FatalErrorInFunction
+                    << "Supplied out of bounds: " << index << "/"
+                    << size_ << abort(FatalError);
+            }
+        }
+
+
+        // Helper functions to retrieve cached values at index0 and index1
+        // Note: uses interpolation direction toSource_
+        #undef  defineMethods01
+        #define defineMethods01(Src, Tgt, idx)                                 \
+            const labelListList& c##Src##Address##idx() const                  \
+            {                                                                  \
+                checkIndex(index##idx##_);                                     \
+                return toSource_ ?                                             \
+                    cached##Src##Address_[index##idx##_]                       \
+                  : cached##Tgt##Address_[index##idx##_];                      \
+            }                                                                  \
+            const scalarListList& c##Src##Weights##idx() const                 \
+            {                                                                  \
+                checkIndex(index##idx##_);                                     \
+                return toSource_ ?                                             \
+                    cached##Src##Weights_[index##idx##_]                       \
+                  : cached##Tgt##Weights_[index##idx##_];                      \
+            }                                                                  \
+            const scalarField& c##Src##WeightsSum##idx() const                 \
+            {                                                                  \
+                checkIndex(index##idx##_);                                     \
+                return toSource_ ?                                             \
+                    cached##Src##WeightsSum_[index##idx##_]                    \
+                  : cached##Tgt##WeightsSum_[index##idx##_];                   \
+            }                                                                  \
+            const autoPtr<mapDistribute>& c##Src##MapPtr##idx() const          \
+            {                                                                  \
+                checkIndex(index##idx##_);                                     \
+                return toSource_ ?                                             \
+                    cached##Src##MapPtr_[index##idx##_]                        \
+                  : cached##Tgt##MapPtr_[index##idx##_];                       \
+            }
+
+        defineMethods01(Src, Tgt, 0)
+        defineMethods01(Src, Tgt, 1)
+        defineMethods01(Tgt, Src, 0)
+        defineMethods01(Tgt, Src, 1)
+
+
+        // Helper functions to retrieve cached values at supplied index
+        // Note: uses interpolation direction toSource_
+        #undef  defineMethodsIndex
+        #define defineMethodsIndex(Src, Tgt)                                   \
+            const labelListList& c##Src##Address(const label index) const      \
+            {                                                                  \
+                checkIndex(index);                                             \
+                return toSource_ ?                                             \
+                    cached##Src##Address_[index]                               \
+                  : cached##Tgt##Address_[index];                              \
+            }                                                                  \
+            const scalarListList& c##Src##Weights(const label index) const     \
+            {                                                                  \
+                checkIndex(index);                                             \
+                return toSource_ ?                                             \
+                    cached##Src##Weights_[index]                               \
+                  : cached##Tgt##Weights_[index];                              \
+            }                                                                  \
+            const scalarField& c##Src##WeightsSum(const label index) const     \
+            {                                                                  \
+                checkIndex(index);                                             \
+                return toSource_ ?                                             \
+                    cached##Src##WeightsSum_[index]                            \
+                  : cached##Tgt##WeightsSum_[index];                           \
+            }                                                                  \
+            const autoPtr<mapDistribute>& c##Src##MapPtr(const label index)    \
+            const                                                              \
+            {                                                                  \
+                checkIndex(index);                                             \
+                return toSource_ ?                                             \
+                    cached##Src##MapPtr_[index]                                \
+                  : cached##Tgt##MapPtr_[index];                               \
+            }
+
+        defineMethodsIndex(Src, Tgt)
+        defineMethodsIndex(Tgt, Src)
+
+
+    // I-O
+
+        //- Write AMI as a dictionary
+        void write(Ostream& os) const;
+
+        //- Write AMI raw
+        bool writeData(Ostream& os) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "AMICacheTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/AMIInterpolation/AMICacheTemplates.C

@@ -0,0 +1,63 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2025 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type, class EvalFunction>
+bool Foam::AMICache::apply(List<Type>& result, const EvalFunction& eval) const
+{
+    if (applyLower())
+    {
+        eval(result, index0_);
+        return true;
+    }
+    else if (applyUpper())
+    {
+        eval(result, index1_);
+        return true;
+    }
+    else if (applyInterpolate())
+    {
+        List<Type> r0(result);
+        eval(r0, index0_);
+        List<Type> r1(result);
+        eval(r1, index1_);
+
+        //result = (r1 - r0)*interpWeight_ + r0;
+        forAll(result, i)
+        {
+            result[i] = lerp(r0[i], r1[i], interpWeight_);
+        }
+        return true;
+    }
+
+    return false;
+}
+
+
+// ************************************************************************* //

src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C

@@ -61,11 +61,26 @@ registerOptSwitch
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
+void Foam::AMIInterpolation::addToCache(const point& refPt)
+{
+    DebugInfo<< "-- addToCache" << endl;
+
+    cache_.addToCache(*this, refPt);
+}
+
+
+bool Foam::AMIInterpolation::restoreCache(const point& refPt)
+{
+    DebugInfo<< "-- restoreCache" << endl;
+
+    upToDate_ = cache_.restoreCache(refPt);
+
+    return upToDate_;
+}
+
+
 Foam::autoPtr<Foam::indexedOctree<Foam::AMIInterpolation::treeType>>
-Foam::AMIInterpolation::createTree
-(
-    const primitivePatch& patch
-) const
+Foam::AMIInterpolation::createTree(const primitivePatch &patch) const
 {
     treeBoundBox bb(patch.points(), patch.meshPoints());
     bb.inflate(0.01);
@@ -700,7 +715,8 @@ Foam::AMIInterpolation::AMIInterpolation
     tgtWeightsSum_(),
     tgtCentroids_(),
     tgtMapPtr_(nullptr),
-    upToDate_(false)
+    upToDate_(false),
+    cache_(dict)
 {}
 
 
@@ -730,7 +746,8 @@ Foam::AMIInterpolation::AMIInterpolation
     tgtCentroids_(),
     tgtPatchPts_(),
     tgtMapPtr_(nullptr),
-    upToDate_(false)
+    upToDate_(false),
+    cache_()
 {}
 
 
@@ -743,7 +760,7 @@ Foam::AMIInterpolation::AMIInterpolation
 :
     requireMatch_(fineAMI.requireMatch_),
     reverseTarget_(fineAMI.reverseTarget_),
-    lowWeightCorrection_(-1.0),
+    lowWeightCorrection_(-1.0), // Deactivated?
     singlePatchProc_(fineAMI.singlePatchProc_),
     comm_(fineAMI.comm()),  // use fineAMI geomComm if present, comm otherwise
     geomComm_(),
@@ -759,16 +776,17 @@ Foam::AMIInterpolation::AMIInterpolation
     tgtWeightsSum_(),
     tgtPatchPts_(),
     tgtMapPtr_(nullptr),
-    upToDate_(false)
+    upToDate_(false),
+    cache_(fineAMI.cache(), fineAMI, sourceRestrictAddressing, targetRestrictAddressing)
 {
-    label sourceCoarseSize =
+    const label sourceCoarseSize =
     (
         sourceRestrictAddressing.size()
       ? max(sourceRestrictAddressing)+1
       : 0
     );
 
-    label neighbourCoarseSize =
+    const label neighbourCoarseSize =
     (
         targetRestrictAddressing.size()
       ? max(targetRestrictAddressing)+1
@@ -895,14 +913,15 @@ Foam::AMIInterpolation::AMIInterpolation(const AMIInterpolation& ami)
     srcWeights_(ami.srcWeights_),
     srcWeightsSum_(ami.srcWeightsSum_),
     srcCentroids_(ami.srcCentroids_),
-    srcMapPtr_(nullptr),
+    srcMapPtr_(ami.srcMapPtr_.clone()),
     tgtMagSf_(ami.tgtMagSf_),
     tgtAddress_(ami.tgtAddress_),
     tgtWeights_(ami.tgtWeights_),
     tgtWeightsSum_(ami.tgtWeightsSum_),
     tgtCentroids_(ami.tgtCentroids_),
-    tgtMapPtr_(nullptr),
-    upToDate_(false)
+    tgtMapPtr_(ami.tgtMapPtr_.clone()),
+    upToDate_(ami.upToDate_),
+    cache_(ami.cache_)
 {}
 
 
@@ -930,7 +949,9 @@ Foam::AMIInterpolation::AMIInterpolation(Istream& is)
     //tgtPatchPts_(is),
     tgtMapPtr_(nullptr),
 
-    upToDate_(readBool(is))
+    upToDate_(readBool(is)),
+
+    cache_(is)
 {
     // Hopefully no need to stream geomComm_ since only used in processor
     // agglomeration?
@@ -1361,7 +1382,6 @@ const
         }
         else if (ray.distance() < nearest.distance())
         {
-
             nearest = ray;
             nearestFacei = srcFacei;
         }
@@ -1539,6 +1559,8 @@ void Foam::AMIInterpolation::write(Ostream& os) const
     {
         os.writeEntry("lowWeightCorrection", lowWeightCorrection_);
     }
+
+    cache_.write(os);
 }
 
 
@@ -1564,6 +1586,8 @@ bool Foam::AMIInterpolation::writeData(Ostream& os) const
 
         << token::SPACE<< upToDate();
 
+    cache_.writeData(os);
+
     if (distributed() && comm() != -1)
     {
         os  << token::SPACE<< srcMap()

src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2016-2024 OpenCFD Ltd.
+    Copyright (C) 2016-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -61,7 +61,7 @@ SourceFiles
 #include "indexedOctree.H"
 #include "treeDataPrimitivePatch.H"
 #include "runTimeSelectionTables.H"
-
+#include "AMICache.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -78,6 +78,7 @@ public:
 
     // Public Data Types
 
+        //- Flag to store face-to-face intersection triangles; default = false
         static bool cacheIntersections_;
 
         //- Control use of local communicator for AMI communication
@@ -86,6 +87,10 @@ public:
         //  localComm : 2 : like 1 but always include master (for messages)
         static int useLocalComm_;
 
+        //- Tolerance used when caching the AMI to identify e.g. if the
+        //- current rotation angle has already been captured
+        static scalar cacheThetaTolerance_;
+
 
 protected:
 
@@ -145,7 +150,6 @@ protected:
             autoPtr<mapDistribute> srcMapPtr_;
 
 
-
         // Target patch
 
             //- Target face areas
@@ -173,9 +177,13 @@ protected:
             //- Target map pointer - parallel running only
             autoPtr<mapDistribute> tgtMapPtr_;
 
+
         //- Up-to-date flag
         bool upToDate_;
 
+        //- Cache
+        AMICache cache_;
+
 
     // Protected Member Functions
 
@@ -212,10 +220,10 @@ protected:
 
         // Access
 
-            //- Return the orginal src patch with optionally updated points
+            //- Return the original src patch with optionally updated points
             inline const primitivePatch& srcPatch0() const;
 
-            //- Return the orginal tgt patch with optionally updated points
+            //- Return the original tgt patch with optionally updated points
             inline const primitivePatch& tgtPatch0() const;
 
 
@@ -240,27 +248,6 @@ protected:
             );
 
 
-        // Constructor helpers
-
-            static void agglomerate
-            (
-                const autoPtr<mapDistribute>& targetMap,
-                const scalarList& fineSrcMagSf,
-                const labelListList& fineSrcAddress,
-                const scalarListList& fineSrcWeights,
-
-                const labelList& sourceRestrictAddressing,
-                const labelList& targetRestrictAddressing,
-
-                scalarList& srcMagSf,
-                labelListList& srcAddress,
-                scalarListList& srcWeights,
-                scalarField& srcWeightsSum,
-                autoPtr<mapDistribute>& tgtMap,
-                const label comm
-            );
-
-
 public:
 
     //- Runtime type information
@@ -366,6 +353,26 @@ public:
 
     // Member Functions
 
+        // Constructor helpers
+
+            static void agglomerate
+            (
+                const autoPtr<mapDistribute>& targetMap,
+                const scalarList& fineSrcMagSf,
+                const labelListList& fineSrcAddress,
+                const scalarListList& fineSrcWeights,
+
+                const labelList& sourceRestrictAddressing,
+                const labelList& targetRestrictAddressing,
+
+                scalarList& srcMagSf,
+                labelListList& srcAddress,
+                scalarListList& srcWeights,
+                scalarField& srcWeightsSum,
+                autoPtr<mapDistribute>& tgtMap,
+                const label comm
+            );
+
         // Access
 
             //- Is up-to-date?
@@ -379,6 +386,10 @@ public:
                 return old;
             }
 
+            //- Return a reference to the AMI cache
+            const AMICache& cache() const noexcept { return cache_; }
+            AMICache& cache() noexcept { return cache_; }
+
             //- Distributed across processors (singlePatchProc == -1)
             inline bool distributed() const noexcept;
 
@@ -411,6 +422,8 @@ public:
             //  \returns old value
             inline label comm(label communicator) noexcept;
 
+            //- Return true if caching is active
+            inline bool cacheActive() const;
 
             // Source patch
 
@@ -531,7 +544,8 @@ public:
 
             // Low-level
 
-                //- Weighted sum of contributions
+                //- Weighted sum of contributions. Note: cop operates on
+                //- single Type only.
                 template<class Type, class CombineOp>
                 static void weightedSum
                 (
@@ -545,20 +559,35 @@ public:
                     const UList<Type>& defaultValues
                 );
 
-                //- Weighted sum of contributions
+                //- Weighted sum of contributions (includes caching+interp)
+                //- (for primitive types only)
                 template<class Type>
                 void weightedSum
                 (
-                    const bool interpolateToSource,
+                    const bool toSource,
                     const UList<Type>& fld,
                     List<Type>& result,
                     const UList<Type>& defaultValues
                 ) const;
 
-                //- Interpolate from target to source with supplied op
+                //- Weighted sum of (potentially distributed) contributions
+                //- and apply caching+interpolation. Note: iop
+                //- operates on single Type only
+                template<class Type, class CombineOp, class InterpolateOp>
+                void interpolate
+                (
+                    const bool toSource,
+                    const UList<Type>& fld,
+                    const CombineOp& cop,
+                    const InterpolateOp& iop,
+                    List<Type>& result,
+                    const UList<Type>& defaultValues
+                ) const;
+
+                //- Interpolate from source to target with supplied op
                 //- to combine existing value with remote value and weight
                 template<class Type, class CombineOp>
-                void interpolateToSource
+                void interpolateToTarget
                 (
                     const UList<Type>& fld,
                     const CombineOp& cop,
@@ -566,10 +595,10 @@ public:
                     const UList<Type>& defaultValues = UList<Type>::null()
                 ) const;
 
-                //- Interpolate from source to target with supplied op
+                //- Interpolate from target to source with supplied op
                 //- to combine existing value with remote value and weight
                 template<class Type, class CombineOp>
-                void interpolateToTarget
+                void interpolateToSource
                 (
                     const UList<Type>& fld,
                     const CombineOp& cop,
@@ -671,6 +700,12 @@ public:
             )
             const;
 
+            //- Restore AMI weights and addressing from the cache
+            bool restoreCache(const point& refPt);
+
+            //- Add AMI weights and addressing to the cache
+            void addToCache(const point& refPt);
+
 
         // Checks
 

src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolationI.H

@@ -123,6 +123,12 @@ inline Foam::label Foam::AMIInterpolation::comm(label communicator) noexcept
 }
 
 
+inline bool Foam::AMIInterpolation::cacheActive() const
+{
+    return cache_.active();
+}
+
+
 inline const Foam::List<Foam::scalar>& Foam::AMIInterpolation::srcMagSf() const
 {
     return srcMagSf_;

src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolationTemplates.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2015-2023 OpenCFD Ltd.
+    Copyright (C) 2015-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -83,18 +83,19 @@ void Foam::AMIInterpolation::weightedSum
 template<class Type>
 void Foam::AMIInterpolation::weightedSum
 (
-    const bool interpolateToSource,
+    const bool toSource,
     const UList<Type>& fld,
     List<Type>& result,
     const UList<Type>& defaultValues
 ) const
 {
+    // Note: using non-caching AMI
     weightedSum
     (
         lowWeightCorrection_,
-        (interpolateToSource ? srcAddress_ : tgtAddress_),
-        (interpolateToSource ? srcWeights_ : tgtWeights_),
-        (interpolateToSource ? srcWeightsSum_ : tgtWeightsSum_),
+        (toSource ? srcAddress_ : tgtAddress_),
+        (toSource ? srcWeights_ : tgtWeights_),
+        (toSource ? srcWeightsSum_ : tgtWeightsSum_),
         fld,
         multiplyWeightedOp<Type, plusEqOp<Type>>(plusEqOp<Type>()),
         result,
@@ -103,6 +104,223 @@ void Foam::AMIInterpolation::weightedSum
 }
 
 
+template<class Type, class CombineOp, class InterpolateOp>
+void Foam::AMIInterpolation::interpolate
+(
+    const bool toSource,
+    const UList<Type>& fld,
+    const CombineOp& cop,
+    const InterpolateOp& iop,
+    List<Type>& result,
+    const UList<Type>& defaultValues
+) const
+{
+    // Note
+    // - behaves as old AMIInterpolation::interpolateToSource if toSource=true
+    // - `result` should be preallocated to correct size and initialized to
+    //   an appropriate value (e.g. Zero)
+
+    // Get data locally and do a weighted sum
+
+    addProfiling(ami, "AMIInterpolation::interpolate");
+
+    cache_.setDirection(toSource);
+
+    auto checkSizes = [&](
+        const UList<Type>& fld,
+        const labelListList& srcAddr,
+        const labelListList& tgtAddr,
+        const UList<Type>& defVals
+    )
+    {
+
+        if (fld.size() != tgtAddr.size())
+        {
+            FatalErrorInFunction
+                << "Supplied field size is not equal to "
+                << (toSource ? "target" : "source") << " patch size" << nl
+                << "    source patch   = " << srcAddr.size() << nl
+                << "    target patch   = " << tgtAddr.size() << nl
+                << "    supplied field = " << fld.size()
+                << abort(FatalError);
+        }
+        else if
+        (
+            (lowWeightCorrection_ > 0) && (defVals.size() != srcAddr.size())
+        )
+        {
+            FatalErrorInFunction
+                << "Employing default values when sum of weights falls below "
+                << lowWeightCorrection_
+                << " but number of default values is not equal to "
+                << (toSource ? "source" : "target") << " patch size" << nl
+                << "    default values = " << defVals.size() << nl
+                << "    source patch   = " << srcAddr.size() << nl
+                << abort(FatalError);
+        }
+    };
+
+
+    // Work space for if distributed
+    List<Type> work;
+
+    List<Type> result0;
+    if (cache_.index0() != -1)
+    {
+        result0 = result;
+
+        const auto& srcAddress = cache_.cSrcAddress0();
+        const auto& srcWeights = cache_.cSrcWeights0();
+        const auto& srcWeightsSum = cache_.cSrcWeightsSum0();
+        const auto& tgtAddress = cache_.cTgtAddress0();
+
+        checkSizes(fld, srcAddress, tgtAddress, defaultValues);
+
+        if (distributed() && cache_.cTgtMapPtr0())
+        {
+            const mapDistribute& map = cache_.cTgtMapPtr0()();
+
+            if (map.comm() == -1)
+            {
+                return;
+            }
+
+            work.resize_nocopy(map.constructSize());
+            SubList<Type>(work, fld.size()) = fld;  // deep copy
+            map.distribute(work);
+        }
+
+        // if constexpr (is_contiguous_scalar<Type>::value)
+        // {
+        //     result0 = Zero;
+        // }
+
+        weightedSum
+        (
+            lowWeightCorrection_,
+            srcAddress,
+            srcWeights,
+            srcWeightsSum,
+            (distributed() ? work : fld),
+            cop,
+            result0,
+            defaultValues
+        );
+    }
+
+    List<Type> result1;
+    if (cache_.index1() != -1)
+    {
+        result1 = result;
+
+        const auto& srcAddress = cache_.cSrcAddress1();
+        const auto& srcWeights = cache_.cSrcWeights1();
+        const auto& srcWeightsSum = cache_.cSrcWeightsSum1();
+        const auto& tgtAddress = cache_.cTgtAddress1();
+
+        checkSizes(fld, srcAddress, tgtAddress, defaultValues);
+
+        if (distributed() && cache_.cTgtMapPtr1())
+        {
+            const mapDistribute& map = cache_.cTgtMapPtr1()();
+
+            if (map.comm() == -1)
+            {
+                return;
+            }
+
+            work.resize_nocopy(map.constructSize());
+            SubList<Type>(work, fld.size()) = fld;  // deep copy
+            map.distribute(work);
+        }
+
+        // if constexpr (is_contiguous_scalar<Type>::value)
+        // {
+        //     result1 = Zero;
+        // }
+
+        weightedSum
+        (
+            lowWeightCorrection_,
+            srcAddress,
+            srcWeights,
+            srcWeightsSum,
+            (distributed() ? work : fld),
+            cop,
+            result1,
+            defaultValues
+        );
+    }
+
+    if (cache_.applyLower())
+    {
+        result = result0;
+    }
+    else if (cache_.applyUpper())
+    {
+        result = result1;
+    }
+    else if (cache_.applyInterpolate())
+    {
+        forAll(result, i)
+        {
+            iop(result[i], i, i, result0[i], i, result1[i], cache_.weight());
+        }
+    }
+    else
+    {
+        // No cache - evaluate the AMI
+
+        const auto& srcAddress = (toSource ? srcAddress_ : tgtAddress_);
+        const auto& srcWeights = (toSource ? srcWeights_ : tgtWeights_);
+        const auto& srcWeightsSum =
+            (toSource ? srcWeightsSum_ : tgtWeightsSum_);
+        const auto& tgtAddress = (toSource ? tgtAddress_ : srcAddress_);
+
+        checkSizes(fld, srcAddress, tgtAddress, defaultValues);
+
+        if (distributed() && tgtMapPtr_)
+        {
+            const mapDistribute& map =
+            (
+                toSource
+              ? tgtMapPtr_()
+              : srcMapPtr_()
+            );
+
+            if (map.comm() == -1)
+            {
+                return;
+            }
+
+            work.resize_nocopy(map.constructSize());
+            SubList<Type>(work, fld.size()) = fld;  // deep copy
+            map.distribute(work);
+        }
+
+        // result.resize_nocopy(srcAddress.size());
+
+        // if constexpr (is_contiguous_scalar<Type>::value)
+        // {
+        //     result = Zero;
+        // }
+
+        weightedSum
+        (
+            lowWeightCorrection_,
+            srcAddress,
+            srcWeights,
+            srcWeightsSum,
+            (distributed() ? work : fld),
+            cop,
+            result,
+            defaultValues
+        );
+    }
+}
+
+
+// Leave API intact below!
 template<class Type, class CombineOp>
 void Foam::AMIInterpolation::interpolateToTarget
 (
@@ -112,58 +330,31 @@ void Foam::AMIInterpolation::interpolateToTarget
     const UList<Type>& defaultValues
 ) const
 {
+    // In-place interpolation
+
     addProfiling(ami, "AMIInterpolation::interpolateToTarget");
 
-    if (fld.size() != srcAddress_.size())
-    {
-        FatalErrorInFunction
-            << "Supplied field size is not equal to source patch size" << nl
-            << "    source patch   = " << srcAddress_.size() << nl
-            << "    target patch   = " << tgtAddress_.size() << nl
-            << "    supplied field = " << fld.size()
-            << abort(FatalError);
-    }
-    else if
+    // Wrap lerp operator to operate inplace
+    auto iop = [&]
     (
-        (lowWeightCorrection_ > 0)
-     && (defaultValues.size() != tgtAddress_.size())
+        Type& res,
+        const label i,
+        const label ia,
+        const Type& a,
+        const label ib,
+        const Type& b,
+        const scalar w
     )
     {
-        FatalErrorInFunction
-            << "Employing default values when sum of weights falls below "
-            << lowWeightCorrection_
-            << " but supplied default field size is not equal to target "
-            << "patch size" << nl
-            << "    default values = " << defaultValues.size() << nl
-            << "    target patch   = " << tgtAddress_.size() << nl
-            << abort(FatalError);
-    }
+        res = lerp(a, b, w);
+    };
 
-    result.setSize(tgtAddress_.size());
-    List<Type> work;
-
-    if (distributed() && srcMapPtr_)
-    {
-        const mapDistribute& map = srcMapPtr_();
-
-        if (map.comm() == -1)
-        {
-            return;
-        }
-
-        work.resize_nocopy(map.constructSize());
-        SubList<Type>(work, fld.size()) = fld;  // deep copy
-        map.distribute(work);
-    }
-
-    weightedSum
+    interpolate
     (
-        lowWeightCorrection_,
-        tgtAddress_,
-        tgtWeights_,
-        tgtWeightsSum_,
-        (distributed() ? work : fld),
+        false,                  // interpolate to target
+        fld,
         cop,
+        iop,
         result,
         defaultValues
     );
@@ -179,58 +370,32 @@ void Foam::AMIInterpolation::interpolateToSource
     const UList<Type>& defaultValues
 ) const
 {
+    // In-place interpolation
+
     addProfiling(ami, "AMIInterpolation::interpolateToSource");
 
-    if (fld.size() != tgtAddress_.size())
-    {
-        FatalErrorInFunction
-            << "Supplied field size is not equal to target patch size" << nl
-            << "    source patch   = " << srcAddress_.size() << nl
-            << "    target patch   = " << tgtAddress_.size() << nl
-            << "    supplied field = " << fld.size()
-            << abort(FatalError);
-    }
-    else if
+    // Wrap lerp operator to operate inplace
+    auto iop = [&]
     (
-        (lowWeightCorrection_ > 0)
-     && (defaultValues.size() != srcAddress_.size())
+        Type& res,
+        const label i,
+        const label ia,
+        const Type& a,
+        const label ib,
+        const Type& b,
+        const scalar w
     )
     {
-        FatalErrorInFunction
-            << "Employing default values when sum of weights falls below "
-            << lowWeightCorrection_
-            << " but number of default values is not equal to source "
-            << "patch size" << nl
-            << "    default values = " << defaultValues.size() << nl
-            << "    source patch   = " << srcAddress_.size() << nl
-            << abort(FatalError);
-    }
+        res = lerp(a, b, w);
+    };
 
-    result.setSize(srcAddress_.size());
-    List<Type> work;
 
-    if (distributed() && tgtMapPtr_)
-    {
-        const mapDistribute& map = tgtMapPtr_();
-
-        if (map.comm() == -1)
-        {
-            return;
-        }
-
-        work.resize_nocopy(map.constructSize());
-        SubList<Type>(work, fld.size()) = fld;  // deep copy
-        map.distribute(work);
-    }
-
-    weightedSum
+    interpolate
     (
-        lowWeightCorrection_,
-        srcAddress_,
-        srcWeights_,
-        srcWeightsSum_,
-        (distributed() ? work : fld),
+        true,                   // toSource,
+        fld,
         cop,
+        iop,
         result,
         defaultValues
     );

src/meshTools/AMIInterpolation/GAMG/interfaceFields/cyclicACMIGAMGInterfaceField/cyclicACMIGAMGInterfaceField.C

@@ -67,9 +67,7 @@ Foam::cyclicACMIGAMGInterfaceField::cyclicACMIGAMGInterfaceField
     GAMGInterfaceField(GAMGCp, fineInterface),
     cyclicACMIInterface_(refCast<const cyclicACMIGAMGInterface>(GAMGCp)),
     doTransform_(false),
-    rank_(0),
-    sendRequests_(),
-    recvRequests_()
+    rank_(0)
 {
     const cyclicAMILduInterfaceField& p =
         refCast<const cyclicAMILduInterfaceField>(fineInterface);
@@ -89,9 +87,7 @@ Foam::cyclicACMIGAMGInterfaceField::cyclicACMIGAMGInterfaceField
     GAMGInterfaceField(GAMGCp, doTransform, rank),
     cyclicACMIInterface_(refCast<const cyclicACMIGAMGInterface>(GAMGCp)),
     doTransform_(doTransform),
-    rank_(rank),
-    sendRequests_(),
-    recvRequests_()
+    rank_(rank)
 {}
 
 
@@ -104,9 +100,7 @@ Foam::cyclicACMIGAMGInterfaceField::cyclicACMIGAMGInterfaceField
     GAMGInterfaceField(GAMGCp, is),
     cyclicACMIInterface_(refCast<const cyclicACMIGAMGInterface>(GAMGCp)),
     doTransform_(readBool(is)),
-    rank_(readLabel(is)),
-    sendRequests_(),
-    recvRequests_()
+    rank_(readLabel(is))
 {}
 
 
@@ -120,9 +114,7 @@ Foam::cyclicACMIGAMGInterfaceField::cyclicACMIGAMGInterfaceField
     GAMGInterfaceField(GAMGCp, local),
     cyclicACMIInterface_(refCast<const cyclicACMIGAMGInterface>(GAMGCp)),
     doTransform_(false),
-    rank_(0),
-    sendRequests_(),
-    recvRequests_()
+    rank_(0)
 {
     const auto& p = refCast<const cyclicACMILduInterfaceField>(local);
 
@@ -142,9 +134,15 @@ bool Foam::cyclicACMIGAMGInterfaceField::ready() const
             recvRequests_.start(),
             recvRequests_.size()
         )
+     && UPstream::finishedRequests
+        (
+            recvRequests1_.start(),
+            recvRequests1_.size()
+        )
     )
     {
         recvRequests_.clear();
+        recvRequests1_.clear();
 
         if
         (
@@ -153,9 +151,15 @@ bool Foam::cyclicACMIGAMGInterfaceField::ready() const
                 sendRequests_.start(),
                 sendRequests_.size()
             )
+         && UPstream::finishedRequests
+            (
+                sendRequests1_.start(),
+                sendRequests1_.size()
+            )
         )
         {
             sendRequests_.clear();
+            sendRequests1_.clear();
         }
 
         return true;
@@ -210,15 +214,9 @@ void Foam::cyclicACMIGAMGInterfaceField::initInterfaceMatrixUpdate
         // Transform according to the transformation tensors
         transformCoupleField(pnf, cmpt);
 
-        const auto& map =
-        (
-            cyclicACMIInterface_.owner()
-          ? AMI.tgtMap()
-          : AMI.srcMap()
-        );
 
         // Assert that all receives are known to have finished
-        if (!recvRequests_.empty())
+        if (!recvRequests_.empty() || !recvRequests1_.empty())
         {
             FatalErrorInFunction
                 << "Outstanding recv request(s) on patch "
@@ -226,22 +224,63 @@ void Foam::cyclicACMIGAMGInterfaceField::initInterfaceMatrixUpdate
                 << abort(FatalError);
         }
 
-        // Assume that sends are also OK
-        sendRequests_.clear();
+        const auto& cache = AMI.cache();
 
-        // Insert send/receive requests (non-blocking). See e.g.
-        // cyclicAMIPolyPatchTemplates.C
-        const label oldWarnComm = UPstream::commWarn(AMI.comm());
-        map.send
-        (
-            pnf,
-            sendRequests_,
-            scalarSendBufs_,
-            recvRequests_,
-            scalarRecvBufs_,
-            19462+cyclicACMIInterface_.index()  // unique offset + patch index
-        );
-        UPstream::commWarn(oldWarnComm);
+        if (cache.index0() == -1 && cache.index1() == -1)
+        {
+            const auto& map =
+            (
+                cyclicACMIInterface_.owner()
+              ? AMI.tgtMap()
+              : AMI.srcMap()
+            );
+
+            // Insert send/receive requests (non-blocking). See e.g.
+            // cyclicAMIPolyPatchTemplates.C
+            const label oldWarnComm = UPstream::commWarn(AMI.comm());
+            map.send
+            (
+                pnf,
+                sendRequests_,
+                scalarSendBufs_,
+                recvRequests_,
+                scalarRecvBufs_,
+                19462+cyclicACMIInterface_.index()  // unique offset + patch index
+            );
+            UPstream::commWarn(oldWarnComm);
+        }
+        else
+        {
+            cache.setDirection(cyclicACMIInterface_.owner());
+
+            if (cache.index0() != -1)
+            {
+                const auto& map0 = cache.cTgtMapPtr0()();
+                map0.send
+                (
+                    pnf,
+                    sendRequests_,
+                    scalarSendBufs_,
+                    recvRequests_,
+                    scalarRecvBufs_,
+                    19462+cyclicACMIInterface_.index()   // unique offset + patch index
+                );
+            }
+
+            if (cache.index1() != -1)
+            {
+                const auto& map1 = cache.cTgtMapPtr1()();
+                map1.send
+                (
+                    pnf,
+                    sendRequests1_,
+                    scalarSendBufs1_,
+                    recvRequests1_,
+                    scalarRecvBufs1_,
+                    19463+cyclicACMIInterface_.index()   // unique offset + patch index
+                );
+            }
+        }
     }
 
     this->updatedMatrix(false);
@@ -260,6 +299,8 @@ void Foam::cyclicACMIGAMGInterfaceField::updateInterfaceMatrix
     const Pstream::commsTypes
 ) const
 {
+    typedef multiplyWeightedOp<scalar, plusEqOp<scalar>> opType;
+
     const labelUList& faceCells = lduAddr.patchAddr(patchId);
 
     const auto& AMI =
@@ -269,48 +310,122 @@ void Foam::cyclicACMIGAMGInterfaceField::updateInterfaceMatrix
       : cyclicACMIInterface_.neighbPatch().AMI()
     );
 
-    DebugPout<< "cyclicACMIGAMGInterfaceField::updateInterfaceMatrix() :"
-        << " interface:" << cyclicACMIInterface_.index()
-        << " size:" << cyclicACMIInterface_.size()
-        << " owner:" << cyclicACMIInterface_.owner()
-        << " AMI distributed:" << AMI.distributed()
-        << endl;
-
+    const auto& cache = AMI.cache();
 
     if (AMI.distributed() && AMI.comm() != -1)
     {
-        const auto& map =
-        (
-            cyclicACMIInterface_.owner()
-          ? AMI.tgtMap()
-          : AMI.srcMap()
-        );
+        if (cache.index0() == -1 && cache.index1() == -1)
+        {
+            const auto& map =
+            (
+                cyclicACMIInterface_.owner()
+              ? AMI.tgtMap()
+              : AMI.srcMap()
+            );
 
-        // Receive (= copy) data from buffers into work. TBD: receive directly
-        // into slices of work.
-        solveScalarField work;
-        map.receive
-        (
-            recvRequests_,
-            scalarRecvBufs_,
-            work,
-            19462+cyclicACMIInterface_.index()  // unique offset + patch index
-        );
+            // Receive (= copy) data from buffers into work. TBD: receive directly
+            // into slices of work.
+            solveScalarField work;
+            map.receive
+            (
+                recvRequests_,
+                scalarRecvBufs_,
+                work,
+                19462+cyclicACMIInterface_.index()  // unique offset + patch index
+            );
 
-        // Receive requests all handled by last function call
-        recvRequests_.clear();
+            // Receive requests all handled by last function call
+            recvRequests_.clear();
 
-        solveScalarField pnf(faceCells.size(), Zero);
-        AMI.weightedSum
-        (
-            cyclicACMIInterface_.owner(),
-            work,
-            pnf,               // result
-            solveScalarField::null()
-        );
+            solveScalarField pnf(faceCells.size(), Zero);
+            AMI.weightedSum
+            (
+                cyclicACMIInterface_.owner(),
+                work,
+                pnf,               // result
+                solveScalarField::null()
+            );
 
-        // Add result using coefficients
-        this->addToInternalField(result, !add, faceCells, coeffs, pnf);
+            // Add result using coefficients
+            this->addToInternalField(result, !add, faceCells, coeffs, pnf);
+        }
+        else
+        {
+            cache.setDirection(cyclicACMIInterface_.owner());
+
+            solveScalarField pnf(faceCells.size());
+            solveScalarField work(faceCells.size());
+
+            if (cache.index0() != -1)
+            {
+                // Receive (= copy) data from buffers into work. TBD: receive directly
+                // into slices of work.
+                work = Zero;
+                cache.cTgtMapPtr0()().receive
+                (
+                    recvRequests_,
+                    scalarRecvBufs_,
+                    work,
+                    19462+cyclicACMIInterface_.index()   // unique offset + patch index
+                );
+
+                // Receive requests all handled by last function call
+                recvRequests_.clear();
+
+                pnf = Zero;
+                AMIInterpolation::weightedSum
+                (
+                    AMI.lowWeightCorrection(),
+                    cache.cSrcAddress0(),
+                    cache.cSrcWeights0(),
+                    cache.cSrcWeightsSum0(),
+                    work,
+                    opType(plusEqOp<scalar>()),
+                    pnf,
+                    solveScalarField::null()
+                );
+
+                pnf *= (1-cache.weight());
+
+                // Add result using coefficients
+                this->addToInternalField(result, !add, faceCells, coeffs, pnf);
+            }
+
+            if (cache.index1() != -1)
+            {
+                // Receive (= copy) data from buffers into work. TBD: receive directly
+                // into slices of work.
+                work = Zero;
+                cache.cTgtMapPtr1()().receive
+                (
+                    recvRequests1_,
+                    scalarRecvBufs1_,
+                    work,
+                    19463+cyclicACMIInterface_.index()   // unique offset + patch index
+                );
+
+                // Receive requests all handled by last function call
+                recvRequests1_.clear();
+
+                pnf = Zero;
+                AMIInterpolation::weightedSum
+                (
+                    AMI.lowWeightCorrection(),
+                    cache.cSrcAddress1(),
+                    cache.cSrcWeights1(),
+                    cache.cSrcWeightsSum1(),
+                    work,
+                    opType(plusEqOp<scalar>()),
+                    pnf,
+                    solveScalarField::null()
+                );
+
+                pnf *= cache.weight();
+
+                // Add result using coefficients
+                this->addToInternalField(result, !add, faceCells, coeffs, pnf);
+            }
+        }
     }
     else
     {
@@ -318,23 +433,73 @@ void Foam::cyclicACMIGAMGInterfaceField::updateInterfaceMatrix
         const labelUList& nbrFaceCells =
             lduAddr.patchAddr(cyclicACMIInterface_.neighbPatchID());
 
-        solveScalarField pnf(psiInternal, nbrFaceCells);
+        solveScalarField work(psiInternal, nbrFaceCells);
 
         // Transform according to the transformation tensors
-        transformCoupleField(pnf, cmpt);
+        transformCoupleField(work, cmpt);
 
-        if (cyclicACMIInterface_.owner())
+        if (cache.index0() == -1 && cache.index1() == -1)
         {
-            pnf = AMI.interpolateToSource(pnf);
+            solveScalarField pnf(faceCells.size(), Zero);
+
+            AMI.weightedSum
+            (
+                cyclicACMIInterface_.owner(),
+                work,
+                pnf,                // result
+                solveScalarField::null()
+            );
+
+            const labelUList& faceCells = lduAddr.patchAddr(patchId);
+
+            this->addToInternalField(result, !add, faceCells, coeffs, pnf);
         }
         else
         {
-            pnf = AMI.interpolateToTarget(pnf);
+            cache.setDirection(cyclicACMIInterface_.owner());
+
+            solveScalarField pnf(faceCells.size());
+
+            if (cache.index0() != -1)
+            {
+                pnf = Zero;
+                AMIInterpolation::weightedSum
+                (
+                    AMI.lowWeightCorrection(),
+                    cache.cSrcAddress0(),
+                    cache.cSrcWeights0(),
+                    cache.cSrcWeightsSum0(),
+                    work,
+                    opType(plusEqOp<scalar>()),
+                    pnf,
+                    solveScalarField::null()
+                );
+
+                pnf *= (1 - cache.weight());
+
+                this->addToInternalField(result, !add, faceCells, coeffs, pnf);
+            }
+
+            if (cache.index1() != -1)
+            {
+                pnf = Zero;
+                AMIInterpolation::weightedSum
+                (
+                    AMI.lowWeightCorrection(),
+                    cache.cSrcAddress1(),
+                    cache.cSrcWeights1(),
+                    cache.cSrcWeightsSum1(),
+                    work,
+                    opType(plusEqOp<scalar>()),
+                    pnf,
+                    solveScalarField::null()
+                );
+
+                pnf *= cache.weight();
+
+                this->addToInternalField(result, !add, faceCells, coeffs, pnf);
+            }
         }
-
-        const labelUList& faceCells = lduAddr.patchAddr(patchId);
-
-        this->addToInternalField(result, !add, faceCells, coeffs, pnf);
     }
 
     this->updatedMatrix(true);

src/meshTools/AMIInterpolation/GAMG/interfaceFields/cyclicACMIGAMGInterfaceField/cyclicACMIGAMGInterfaceField.H

@@ -83,6 +83,20 @@ class cyclicACMIGAMGInterfaceField
             //- Scalar receive buffers
             mutable PtrList<List<solveScalar>> scalarRecvBufs_;
 
+            // Only used for AMI caching
+
+                //- Current range of send requests (non-blocking)
+                mutable labelRange sendRequests1_;
+
+                //- Current range of recv requests (non-blocking)
+                mutable labelRange recvRequests1_;
+
+                //- Scalar send buffers
+                mutable PtrList<List<solveScalar>> scalarSendBufs1_;
+
+                //- Scalar receive buffers
+                mutable PtrList<List<solveScalar>> scalarRecvBufs1_;
+
 
     // Private Member Functions
 

src/meshTools/AMIInterpolation/GAMG/interfaceFields/cyclicAMIGAMGInterfaceField/cyclicAMIGAMGInterfaceField.C

@@ -67,9 +67,7 @@ Foam::cyclicAMIGAMGInterfaceField::cyclicAMIGAMGInterfaceField
     GAMGInterfaceField(GAMGCp, fineInterface),
     cyclicAMIInterface_(refCast<const cyclicAMIGAMGInterface>(GAMGCp)),
     doTransform_(false),
-    rank_(0),
-    sendRequests_(),
-    recvRequests_()
+    rank_(0)
 {
     const cyclicAMILduInterfaceField& p =
         refCast<const cyclicAMILduInterfaceField>(fineInterface);
@@ -89,9 +87,7 @@ Foam::cyclicAMIGAMGInterfaceField::cyclicAMIGAMGInterfaceField
     GAMGInterfaceField(GAMGCp, doTransform, rank),
     cyclicAMIInterface_(refCast<const cyclicAMIGAMGInterface>(GAMGCp)),
     doTransform_(doTransform),
-    rank_(rank),
-    sendRequests_(),
-    recvRequests_()
+    rank_(rank)
 {}
 
 
@@ -104,9 +100,7 @@ Foam::cyclicAMIGAMGInterfaceField::cyclicAMIGAMGInterfaceField
     GAMGInterfaceField(GAMGCp, is),
     cyclicAMIInterface_(refCast<const cyclicAMIGAMGInterface>(GAMGCp)),
     doTransform_(readBool(is)),
-    rank_(readLabel(is)),
-    sendRequests_(),
-    recvRequests_()
+    rank_(readLabel(is))
 {}
 
 
@@ -120,9 +114,7 @@ Foam::cyclicAMIGAMGInterfaceField::cyclicAMIGAMGInterfaceField
     GAMGInterfaceField(GAMGCp, local),
     cyclicAMIInterface_(refCast<const cyclicAMIGAMGInterface>(GAMGCp)),
     doTransform_(false),
-    rank_(0),
-    sendRequests_(),    // assume no requests in flight for input field
-    recvRequests_()
+    rank_(0)
 {
     const auto& p = refCast<const cyclicAMILduInterfaceField>(local);
 
@@ -142,9 +134,15 @@ bool Foam::cyclicAMIGAMGInterfaceField::ready() const
             recvRequests_.start(),
             recvRequests_.size()
         )
+     && UPstream::finishedRequests
+        (
+            recvRequests1_.start(),
+            recvRequests1_.size()
+        )
     )
     {
         recvRequests_.clear();
+        recvRequests1_.clear();
 
         if
         (
@@ -153,9 +151,15 @@ bool Foam::cyclicAMIGAMGInterfaceField::ready() const
                 sendRequests_.start(),
                 sendRequests_.size()
             )
+         && UPstream::finishedRequests
+            (
+                sendRequests1_.start(),
+                sendRequests1_.size()
+            )
         )
         {
             sendRequests_.clear();
+            sendRequests1_.clear();
         }
 
         return true;
@@ -183,7 +187,6 @@ void Foam::cyclicAMIGAMGInterfaceField::initInterfaceMatrixUpdate
       ? cyclicAMIInterface_.AMI()
       : cyclicAMIInterface_.neighbPatch().AMI()
     );
-
     if (AMI.distributed() && AMI.comm() != -1)
     {
         //DebugPout<< "cyclicAMIFvPatchField::initInterfaceMatrixUpdate() :"
@@ -211,15 +214,8 @@ void Foam::cyclicAMIGAMGInterfaceField::initInterfaceMatrixUpdate
         // Transform according to the transformation tensors
         transformCoupleField(pnf, cmpt);
 
-        const auto& map =
-        (
-            cyclicAMIInterface_.owner()
-          ? AMI.tgtMap()
-          : AMI.srcMap()
-        );
-
         // Assert that all receives are known to have finished
-        if (!recvRequests_.empty())
+        if (!recvRequests_.empty() || !recvRequests1_.empty())
         {
             FatalErrorInFunction
                 << "Outstanding recv request(s) on patch "
@@ -227,22 +223,63 @@ void Foam::cyclicAMIGAMGInterfaceField::initInterfaceMatrixUpdate
                 << abort(FatalError);
         }
 
-        // Assume that sends are also OK
-        sendRequests_.clear();
+        const auto& cache = AMI.cache();
 
-        // Insert send/receive requests (non-blocking). See e.g.
-        // cyclicAMIPolyPatchTemplates.C
-        const label oldWarnComm = UPstream::commWarn(AMI.comm());
-        map.send
-        (
-            pnf,
-            sendRequests_,
-            scalarSendBufs_,
-            recvRequests_,
-            scalarRecvBufs_,
-            19462+cyclicAMIInterface_.index()   // unique offset + patch index
-        );
-        UPstream::commWarn(oldWarnComm);
+        if (cache.index0() == -1 && cache.index1() == -1)
+        {
+            const auto& map =
+            (
+                cyclicAMIInterface_.owner()
+              ? AMI.tgtMap()
+              : AMI.srcMap()
+            );
+
+            // Insert send/receive requests (non-blocking). See e.g.
+            // cyclicAMIPolyPatchTemplates.C
+            const label oldWarnComm = UPstream::commWarn(AMI.comm());
+            map.send
+            (
+                pnf,
+                sendRequests_,
+                scalarSendBufs_,
+                recvRequests_,
+                scalarRecvBufs_,
+                19462+cyclicAMIInterface_.index()   // unique offset + patch index
+            );
+            UPstream::commWarn(oldWarnComm);
+        }
+        else
+        {
+            cache.setDirection(cyclicAMIInterface_.owner());
+
+            if (cache.index0() != -1)
+            {
+                const auto& map0 = cache.cTgtMapPtr0()();
+                map0.send
+                (
+                    pnf,
+                    sendRequests_,
+                    scalarSendBufs_,
+                    recvRequests_,
+                    scalarRecvBufs_,
+                    19462+cyclicAMIInterface_.index()   // unique offset + patch index
+                );
+            }
+
+            if (cache.index1() != -1)
+            {
+                const auto& map1 = cache.cTgtMapPtr1()();
+                map1.send
+                (
+                    pnf,
+                    sendRequests1_,
+                    scalarSendBufs1_,
+                    recvRequests1_,
+                    scalarRecvBufs1_,
+                    19463+cyclicAMIInterface_.index()   // unique offset + patch index
+                );
+            }
+        }
     }
 
     this->updatedMatrix(false);
@@ -261,6 +298,8 @@ void Foam::cyclicAMIGAMGInterfaceField::updateInterfaceMatrix
     const Pstream::commsTypes commsType
 ) const
 {
+    typedef multiplyWeightedOp<scalar, plusEqOp<scalar>> opType;
+
     const labelUList& faceCells = lduAddr.patchAddr(patchId);
 
     const auto& AMI =
@@ -284,6 +323,12 @@ void Foam::cyclicAMIGAMGInterfaceField::updateInterfaceMatrix
     //    << " AMI low-weight:" << AMI.applyLowWeightCorrection()
     //    << endl;
 
+    const auto& cache = AMI.cache();
+
+    // Assume that sends are also OK
+    sendRequests_.clear();
+    sendRequests1_.clear();
+
     if (AMI.distributed() && AMI.comm() != -1)
     {
         if (commsType != UPstream::commsTypes::nonBlocking)
@@ -293,38 +338,118 @@ void Foam::cyclicAMIGAMGInterfaceField::updateInterfaceMatrix
                 << exit(FatalError);
         }
 
-        const auto& map =
-        (
-            cyclicAMIInterface_.owner()
-          ? AMI.tgtMap()
-          : AMI.srcMap()
-        );
+        if (cache.index0() == -1 && cache.index1() == -1)
+        {
+            const auto& map =
+            (
+                cyclicAMIInterface_.owner()
+              ? AMI.tgtMap()
+              : AMI.srcMap()
+            );
 
-        // Receive (= copy) data from buffers into work. TBD: receive directly
-        // into slices of work.
-        solveScalarField work;
-        map.receive
-        (
-            recvRequests_,
-            scalarRecvBufs_,
-            work,
-            19462+cyclicAMIInterface_.index()   // unique offset + patch index
-        );
+            // Receive (= copy) data from buffers into work. TBD: receive directly
+            // into slices of work.
+            solveScalarField work;
+            map.receive
+            (
+                recvRequests_,
+                scalarRecvBufs_,
+                work,
+                19462+cyclicAMIInterface_.index()   // unique offset + patch index
+            );
 
-        // Receive requests all handled by last function call
-        recvRequests_.clear();
+            // Receive requests all handled by last function call
+            recvRequests_.clear();
 
-        solveScalarField pnf(faceCells.size(), Zero);
-        AMI.weightedSum
-        (
-            cyclicAMIInterface_.owner(),
-            work,
-            pnf,                // result
-            defaultValues
-        );
+            solveScalarField pnf(faceCells.size(), Zero);
+            AMI.weightedSum
+            (
+                cyclicAMIInterface_.owner(),
+                work,
+                pnf,                // result
+                defaultValues
+            );
 
-        // Add result using coefficients
-        this->addToInternalField(result, !add, faceCells, coeffs, pnf);
+            // Add result using coefficients
+            this->addToInternalField(result, !add, faceCells, coeffs, pnf);
+        }
+        else
+        {
+            cache.setDirection(cyclicAMIInterface_.owner());
+
+            solveScalarField pnf(faceCells.size());
+            solveScalarField work(faceCells.size());
+
+            if (cache.index0() != -1)
+            {
+                // Receive (= copy) data from buffers into work. TBD: receive directly
+                // into slices of work.
+                work = Zero;
+                cache.cTgtMapPtr0()().receive
+                (
+                    recvRequests_,
+                    scalarRecvBufs_,
+                    work,
+                    19462+cyclicAMIInterface_.index()   // unique offset + patch index
+                );
+
+                // Receive requests all handled by last function call
+                recvRequests_.clear();
+
+                pnf = Zero;
+                AMIInterpolation::weightedSum
+                (
+                    AMI.lowWeightCorrection(),
+                    cache.cSrcAddress0(),
+                    cache.cSrcWeights0(),
+                    cache.cSrcWeightsSum0(),
+                    work,
+                    opType(plusEqOp<scalar>()),
+                    pnf,
+                    defaultValues
+                );
+
+                pnf *= (1-cache.weight());
+
+                // Add result using coefficients
+                this->addToInternalField(result, !add, faceCells, coeffs, pnf);
+            }
+
+            if (cache.index1() != -1)
+            {
+                // Receive (= copy) data from buffers into work. TBD: receive directly
+                // into slices of work.
+                work = Zero;
+                cache.cTgtMapPtr1()().receive
+                (
+                    recvRequests1_,
+                    scalarRecvBufs1_,
+                    work,
+                    19463+cyclicAMIInterface_.index()   // unique offset + patch index
+                );
+
+                // Receive requests all handled by last function call
+                recvRequests1_.clear();
+
+                pnf = Zero;
+                AMIInterpolation::weightedSum
+                (
+                    AMI.lowWeightCorrection(),
+                    cache.cSrcAddress1(),
+                    cache.cSrcWeights1(),
+                    cache.cSrcWeightsSum1(),
+                    work,
+                    opType(plusEqOp<scalar>()),
+                    pnf,
+                    defaultValues
+                );
+
+                pnf *= cache.weight();
+
+                // Add result using coefficients
+                this->addToInternalField(result, !add, faceCells, coeffs, pnf);
+            }
+        }
     }
     else
     {
@@ -337,17 +462,68 @@ void Foam::cyclicAMIGAMGInterfaceField::updateInterfaceMatrix
         // Transform according to the transformation tensors
         transformCoupleField(work, cmpt);
 
-        solveScalarField pnf(faceCells.size(), Zero);
-        AMI.weightedSum
-        (
-            cyclicAMIInterface_.owner(),
-            work,
-            pnf,                // result
-            defaultValues
-        );
+        solveScalarField pnf(faceCells.size());
 
-        // Add result using coefficients
-        this->addToInternalField(result, !add, faceCells, coeffs, pnf);
+        if (cache.index0() == -1 && cache.index1() == -1)
+        {
+            pnf = Zero;
+            AMI.weightedSum
+            (
+                cyclicAMIInterface_.owner(),
+                work,
+                pnf,                // result
+                defaultValues
+            );
+
+            // Add result using coefficients
+            this->addToInternalField(result, !add, faceCells, coeffs, pnf);
+        }
+        else
+        {
+            cache.setDirection(cyclicAMIInterface_.owner());
+
+            if (cache.index0() != -1)
+            {
+                pnf = Zero;
+                AMIInterpolation::weightedSum
+                (
+                    AMI.lowWeightCorrection(),
+                    cache.cSrcAddress0(),
+                    cache.cSrcWeights0(),
+                    cache.cSrcWeightsSum0(),
+                    work,
+                    opType(plusEqOp<scalar>()),
+                    pnf,
+                    defaultValues
+                );
+
+                pnf *= (1 - cache.weight());
+
+                // Add result using coefficients
+                this->addToInternalField(result, !add, faceCells, coeffs, pnf);
+            }
+
+            if (cache.index1() != -1)
+            {
+                pnf = Zero;
+                AMIInterpolation::weightedSum
+                (
+                    AMI.lowWeightCorrection(),
+                    cache.cSrcAddress1(),
+                    cache.cSrcWeights1(),
+                    cache.cSrcWeightsSum1(),
+                    work,
+                    opType(plusEqOp<scalar>()),
+                    pnf,
+                    defaultValues
+                );
+
+                pnf *= cache.weight();
+
+                // Add result using coefficients
+                this->addToInternalField(result, !add, faceCells, coeffs, pnf);
+            }
+        }
     }
 
     this->updatedMatrix(true);

src/meshTools/AMIInterpolation/GAMG/interfaceFields/cyclicAMIGAMGInterfaceField/cyclicAMIGAMGInterfaceField.H

@@ -83,6 +83,21 @@ class cyclicAMIGAMGInterfaceField
             mutable PtrList<List<solveScalar>> scalarRecvBufs_;
 
 
+            // Only used for AMI caching
+
+                //- Current range of send requests (non-blocking)
+                mutable labelRange sendRequests1_;
+
+                //- Current range of recv requests (non-blocking)
+                mutable labelRange recvRequests1_;
+
+                //- Scalar send buffers
+                mutable PtrList<List<solveScalar>> scalarSendBufs1_;
+
+                //- Scalar receive buffers
+                mutable PtrList<List<solveScalar>> scalarRecvBufs1_;
+
+
     // Private Member Functions
 
         //- No copy construct

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C

@@ -381,6 +381,46 @@ void Foam::cyclicAMIPolyPatch::resetAMI(const UList<point>& points) const
         return;
     }
 
+    point refPt = point::max;
+
+    bool restoredFromCache = false;
+    if (AMIPtr_->cacheActive())
+    {
+        const label comm = boundaryMesh().mesh().comm();
+
+        if (UPstream::parRun())
+        {
+            label refProci = -1;
+            if (size() > 0)
+            {
+                refProci = UPstream::myProcNo(comm);
+            }
+            reduce(refProci, maxOp<label>(), UPstream::msgType(), comm);
+
+            if (refProci == UPstream::myProcNo(comm))
+            {
+                refPt = points[meshPoints()[0]];
+            }
+            reduce(refPt, minOp<point>(), UPstream::msgType(), comm);
+        }
+        else
+        {
+            refPt = points[meshPoints()[0]];
+        }
+
+
+        // Sets cache indices to use and time interpolation weight
+        restoredFromCache = AMIPtr_->restoreCache(refPt);
+
+        if (returnReduceOr(restoredFromCache, comm))
+        {
+            // Restored AMI weight and addressing from cache - all done
+            Info<< "AMI: weights and addresses restored from cache" << endl;
+
+            return;
+        }
+    }
+
     const cyclicAMIPolyPatch& nbr = neighbPatch();
     const pointField srcPoints(points, meshPoints());
     pointField nbrPoints(points, nbr.meshPoints());
@@ -432,7 +472,7 @@ void Foam::cyclicAMIPolyPatch::resetAMI(const UList<point>& points) const
         meshTools::writeOBJ(osN, nbrPatch0.localFaces(), nbrPoints);
 
         OFstream osO(t.path()/name() + "_ownerPatch.obj");
-        meshTools::writeOBJ(osO, this->localFaces(), localPoints());
+        meshTools::writeOBJ(osO, this->localFaces(), srcPoints);
     }
 
     // Construct/apply AMI interpolation to determine addressing and weights
@@ -446,6 +486,8 @@ void Foam::cyclicAMIPolyPatch::resetAMI(const UList<point>& points) const
     {
         AMIPtr_->checkSymmetricWeights(true);
     }
+
+    AMIPtr_->addToCache(refPt);
 }
 
 

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H

@@ -99,7 +99,7 @@ protected:
         //- Index of other half
         mutable label nbrPatchID_;
 
-        //- Particle displacement fraction accross AMI
+        //- Particle displacement fraction across AMI
         const scalar fraction_;
 
 
@@ -166,6 +166,9 @@ protected:
             //- Temporary storage for AMI face centres
             mutable vectorField faceCentres0_;
 
+        // Cache
+        bool cacheAMI_;
+
 
     // Protected Member Functions
 
@@ -520,9 +523,14 @@ public:
                 (
                     const Field<Type>& fld,
                     labelRange& sendRequests,
-                    PtrList<List<Type>>& sendBuffers,
                     labelRange& recvRequests,
-                    PtrList<List<Type>>& recvBuffers
+                    PtrList<List<Type>>& sendBuffers,
+                    PtrList<List<Type>>& recvBuffers,
+
+                    labelRange& sendRequests1,
+                    labelRange& recvRequests1,
+                    PtrList<List<Type>>& sendBuffers1,
+                    PtrList<List<Type>>& recvBuffers1
                 ) const;
 
                 template<class Type>
@@ -530,9 +538,14 @@ public:
                 (
                     const Field<Type>& fld,
                     labelRange& sendRequests,
-                    PtrList<List<Type>>& sendBuffers,
                     labelRange& recvRequests,
-                    PtrList<List<Type>>& recvBuffers
+                    PtrList<List<Type>>& sendBuffers,
+                    PtrList<List<Type>>& recvBuffers,
+
+                    labelRange& sendRequests1,
+                    labelRange& recvRequests1,
+                    PtrList<List<Type>>& sendBuffers1,
+                    PtrList<List<Type>>& recvBuffers1
                 ) const;
 
                 template<class Type>
@@ -541,6 +554,8 @@ public:
                     const Field<Type>& localFld,
                     const labelRange& requests,  // The receive requests
                     const PtrList<List<Type>>& recvBuffers,
+                    const labelRange& requests1,  // The receive requests
+                    const PtrList<List<Type>>& recvBuffers1,
                     const UList<Type>& defaultValues
                 ) const;
 

src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatchTemplates.C

@@ -63,6 +63,7 @@ Foam::tmp<Foam::Field<Type>> Foam::cyclicAMIPolyPatch::interpolate
 
     if constexpr (transform_supported)
     {
+        // Only creates the co-ord system if using periodic AMI
         cs.reset(cylindricalCS());
     }
 
@@ -130,7 +131,7 @@ Foam::tmp<Foam::Field<Type>> Foam::cyclicAMIPolyPatch::interpolate
         const tensorField ownT(cs().R(this->faceCentres()));
 
         Field<Type> localDeflt(defaultValues.size());
-        if (defaultValues.size() == size())
+        if (defaultValues.size() != 0 && defaultValues.size() == size())
         {
             // Transform default values into cylindrical coords (using
             // *this faceCentres)
@@ -176,27 +177,77 @@ void Foam::cyclicAMIPolyPatch::initInterpolateUntransformed
 (
     const Field<Type>& fld,
     labelRange& sendRequests,
-    PtrList<List<Type>>& sendBuffers,
     labelRange& recvRequests,
-    PtrList<List<Type>>& recvBuffers
+    PtrList<List<Type>>& sendBuffers,
+    PtrList<List<Type>>& recvBuffers,
+
+    labelRange& sendRequests1,
+    labelRange& recvRequests1,
+    PtrList<List<Type>>& sendBuffers1,
+    PtrList<List<Type>>& recvBuffers1
 ) const
 {
     const auto& AMI = (owner() ? this->AMI() : neighbPatch().AMI());
 
     if (AMI.distributed() && AMI.comm() != -1)
     {
-        const auto& map = (owner() ? AMI.tgtMap() : AMI.srcMap());
+        const auto& cache = AMI.cache();
 
-        // Insert send/receive requests (non-blocking)
-        map.send
-        (
-            fld,
-            sendRequests,
-            sendBuffers,
-            recvRequests,
-            recvBuffers,
-            3894+this->index()  // unique offset + patch index
-        );
+        if (cache.index0() == -1 && cache.index1() == -1)
+        {
+            // No caching
+
+            const auto& map = (owner() ? AMI.tgtMap() : AMI.srcMap());
+
+            // Insert send/receive requests (non-blocking)
+            map.send
+            (
+                fld,
+                sendRequests,
+                sendBuffers,
+                recvRequests,
+                recvBuffers,
+                3894+this->index()  // unique offset + patch index
+            );
+        }
+        else
+        {
+            // Caching is active
+
+            cache.setDirection(owner());
+
+            if (cache.index0() != -1)
+            {
+                const auto& map0 = cache.cTgtMapPtr0()();
+
+                // Insert send/receive requests (non-blocking)
+                map0.send
+                (
+                    fld,
+                    sendRequests,
+                    sendBuffers,
+                    recvRequests,
+                    recvBuffers,
+                    3894+this->index()  // unique offset + patch index
+                );
+            }
+
+            if (cache.index1() != -1)
+            {
+                const auto& map1 = cache.cTgtMapPtr1()();
+
+                // Insert send/receive requests (non-blocking)
+                map1.send
+                (
+                    fld,
+                    sendRequests1,
+                    sendBuffers1,
+                    recvRequests1,
+                    recvBuffers1,
+                    3895+this->index()  // unique offset + patch index
+                );
+            }
+        }
     }
 }
 
@@ -206,9 +257,14 @@ void Foam::cyclicAMIPolyPatch::initInterpolate
 (
     const Field<Type>& fld,
     labelRange& sendRequests,
-    PtrList<List<Type>>& sendBuffers,
     labelRange& recvRequests,
-    PtrList<List<Type>>& recvBuffers
+    PtrList<List<Type>>& sendBuffers,
+    PtrList<List<Type>>& recvBuffers,
+
+    labelRange& sendRequests1,
+    labelRange& recvRequests1,
+    PtrList<List<Type>>& sendBuffers1,
+    PtrList<List<Type>>& recvBuffers1
 ) const
 {
     const auto& AMI = (owner() ? this->AMI() : neighbPatch().AMI());
@@ -221,46 +277,50 @@ void Foam::cyclicAMIPolyPatch::initInterpolate
     // Can rotate fields (vector and non-spherical tensors)
     constexpr bool transform_supported = is_rotational_vectorspace_v<Type>;
 
-    [[maybe_unused]]
-    autoPtr<coordSystem::cylindrical> cs;
-
     if constexpr (transform_supported)
     {
-        cs.reset(cylindricalCS());
-    }
+        // Only creates the co-ord system if using periodic AMI
+        // - convert to cylindrical coordinate system
+        auto cs = cylindricalCS();
 
-    if (!cs)
-    {
-        initInterpolateUntransformed
-        (
-            fld,
-            sendRequests,
-            sendBuffers,
-            recvRequests,
-            recvBuffers
-        );
-    }
-    else if constexpr (transform_supported)
-    {
-        const cyclicAMIPolyPatch& nbrPp = this->neighbPatch();
-
-        Field<Type> localFld(fld.size());
-
-        // Transform to cylindrical coords
+        if (cs)
         {
+            Field<Type> localFld(fld.size());
+            const cyclicAMIPolyPatch& nbrPp = this->neighbPatch();
             const tensorField nbrT(cs().R(nbrPp.faceCentres()));
             Foam::invTransform(localFld, nbrT, fld);
-        }
 
-        initInterpolateUntransformed
-        (
-            localFld,
-            sendRequests,
-            sendBuffers,
-            recvRequests,
-            recvBuffers
-        );
+            initInterpolateUntransformed
+            (
+                localFld,
+                sendRequests,
+                recvRequests,
+                sendBuffers,
+                recvBuffers,
+
+                sendRequests1,
+                recvRequests1,
+                sendBuffers1,
+                recvBuffers1
+            );
+
+            return;
+        }
     }
+
+    initInterpolateUntransformed
+    (
+        fld,
+        sendRequests,
+        recvRequests,
+        sendBuffers,
+        recvBuffers,
+
+        sendRequests1,
+        recvRequests1,
+        sendBuffers1,
+        recvBuffers1
+    );
 }
 
 
@@ -270,14 +330,21 @@ Foam::tmp<Foam::Field<Type>> Foam::cyclicAMIPolyPatch::interpolate
     const Field<Type>& localFld,
     const labelRange& requests,
     const PtrList<List<Type>>& recvBuffers,
+    const labelRange& requests1,
+    const PtrList<List<Type>>& recvBuffers1,
     const UList<Type>& defaultValues
 ) const
 {
+    // Note: cannot be localFld.size() -> is set to null for distributed AMI
     auto tresult = tmp<Field<Type>>::New(this->size(), Zero);
 
     const auto& AMI = (owner() ? this->AMI() : neighbPatch().AMI());
 
+    const auto& cache = AMI.cache();
+    cache.setDirection(owner());
+
     Field<Type> work;
+    Field<Type> work1;
     if (AMI.distributed())
     {
         if (AMI.comm() == -1)
@@ -285,71 +352,157 @@ Foam::tmp<Foam::Field<Type>> Foam::cyclicAMIPolyPatch::interpolate
             return tresult;
         }
 
-        const auto& map = (owner() ? AMI.tgtMap() : AMI.srcMap());
+        if (cache.index0() == -1 && cache.index1() == -1)
+        {
+            // No caching
+            const auto& map = (owner() ? AMI.tgtMap() : AMI.srcMap());
 
-        // Receive (= copy) data from buffers into work. TBD: receive directly
-        // into slices of work.
-        map.receive
-        (
-            requests,
-            recvBuffers,
-            work,
-            3894+this->index()  // unique offset + patch index
-        );
+            // Receive (= copy) data from buffers into work. TBD: receive
+            // directly into slices of work.
+            map.receive
+            (
+                requests,
+                recvBuffers,
+                work,
+                3894+this->index()  // unique offset + patch index
+            );
+        }
+        else
+        {
+            // Using AMI cache
+
+            if (cache.index0() != -1)
+            {
+                cache.cTgtMapPtr0()().receive
+                (
+                    requests,
+                    recvBuffers,
+                    work,
+                    3894+this->index()  // unique offset + patch index
+                );
+            }
+
+            if (cache.index1() != -1)
+            {
+                cache.cTgtMapPtr1()().receive
+                (
+                    requests1,
+                    recvBuffers1,
+                    work1,
+                    3895+this->index()  // unique offset + patch index
+                );
+            }
+        }
     }
+
     const Field<Type>& fld = (AMI.distributed() ? work : localFld);
+    const Field<Type>& fld1 = (AMI.distributed() ? work1 : localFld);
 
     // Rotate fields (vector and non-spherical tensors)
     constexpr bool transform_supported = is_rotational_vectorspace_v<Type>;
 
-    [[maybe_unused]]
-    autoPtr<coordSystem::cylindrical> cs;
+    // Rotate fields (vector and non-spherical tensors) for periodic AMI
+    tensorField ownTransform;
+    Field<Type> localDeflt;
 
-    // Rotate fields (vector and non-spherical tensors)
     if constexpr (transform_supported)
     {
-        cs.reset(cylindricalCS());
-    }
+        // Only creates the co-ord system if using periodic AMI
+        // - convert to cylindrical coordinate system
+        auto cs = cylindricalCS();
 
-    if (!cs)
-    {
-        AMI.weightedSum
-        (
-            owner(),
-            fld,
-            tresult.ref(),
-            defaultValues
-        );
-    }
-    else if constexpr (transform_supported)
-    {
-        const tensorField ownT(cs().R(this->faceCentres()));
-
-        Field<Type> localDeflt(defaultValues.size());
-        if (defaultValues.size() == size())
+        if (cs)
         {
-            // Transform default values into cylindrical coords (using
-            // *this faceCentres)
-            // We get in UList (why? Copied from cyclicAMI). Convert to
-            // Field so we can use transformField routines.
-            const SubField<Type> defaultSubFld(defaultValues);
-            const Field<Type>& defaultFld(defaultSubFld);
-            Foam::invTransform(localDeflt, ownT, defaultFld);
-        }
+            ownTransform = cs().R(this->faceCentres());
+            localDeflt = defaultValues;
 
+            if (defaultValues.size() == size())
+            {
+                // Transform default values into cylindrical coords (using
+                // *this faceCentres)
+                // We get in UList (why? Copied from cyclicAMI). Convert to
+                // Field so we can use transformField routines.
+                const SubField<Type> defaultSubFld(defaultValues);
+                const Field<Type>& defaultFld(defaultSubFld);
+                Foam::invTransform(localDeflt, ownTransform, defaultFld);
+            }
+        }
+    }
+
+    const auto& localDefaultValues =
+        localDeflt.size() ? localDeflt : defaultValues;
+
+    if (cache.index0() == -1 && cache.index1() == -1)
+    {
+        // No caching
         AMI.weightedSum
         (
             owner(),
             fld,
             tresult.ref(),
-            localDeflt
+            localDefaultValues
         );
 
         // Transform back
-        Foam::transform(tresult.ref(), ownT, tresult());
-    }
+        if (ownTransform.size())
+        {
+            Foam::transform(tresult.ref(), ownTransform, tresult());
+        }
 
-    return tresult;
+        return tresult;
+    }
+    else
+    {
+        if (cache.index0() != -1)
+        {
+            AMIInterpolation::weightedSum
+            (
+                AMI.lowWeightCorrection(),
+                cache.cSrcAddress0(),
+                cache.cSrcWeights0(),
+                cache.cSrcWeightsSum0(),
+                fld,
+                multiplyWeightedOp<Type, plusEqOp<Type>>(plusEqOp<Type>()),
+                tresult.ref(),
+                localDefaultValues
+            );
+
+            if (ownTransform.size())
+            {
+                Foam::transform(tresult.ref(), ownTransform, tresult());
+            }
+
+            // Assuming cache weight is zero when index1 is inactive (==-1)
+            tresult.ref() *= (1 - cache.weight());
+        }
+
+        if (cache.index1() != -1)
+        {
+            auto tresult1 = tmp<Field<Type>>::New(this->size(), Zero);
+
+            AMIInterpolation::weightedSum
+            (
+                AMI.lowWeightCorrection(),
+                cache.cSrcAddress1(),
+                cache.cSrcWeights1(),
+                cache.cSrcWeightsSum1(),
+                fld1,
+                multiplyWeightedOp<Type, plusEqOp<Type>>(plusEqOp<Type>()),
+                tresult1.ref(),
+                localDefaultValues
+            );
+
+            if (ownTransform.size())
+            {
+                Foam::transform(tresult1.ref(), ownTransform, tresult1());
+            }
+
+            tresult1.ref() *= cache.weight();
+            tresult.ref() += tresult1();
+        }
+
+        return tresult;
+    }
 }
 
 

src/meshTools/Make/files

@@ -281,6 +281,7 @@ processorLOD/faceBox/faceBox.C
 AMI=AMIInterpolation
 $(AMI)/AMIInterpolation/AMIInterpolation.C
 $(AMI)/AMIInterpolation/AMIInterpolationNew.C
+$(AMI)/AMIInterpolation/AMICache.C
 $(AMI)/AMIInterpolation/advancingFrontAMI/advancingFrontAMI.C
 $(AMI)/AMIInterpolation/advancingFrontAMI/advancingFrontAMIParallelOps.C
 $(AMI)/AMIInterpolation/faceAreaWeightAMI/faceAreaWeightAMI.C

src/meshTools/algorithms/MeshWave/FaceCellWave.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2018-2024 OpenCFD Ltd.
+    Copyright (C) 2018-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -95,6 +95,102 @@ namespace Foam
                 }
             }
     };
+
+    template<class Type, class TrackingData>
+    class interpolate
+    {
+        //- Combine operator for AMIInterpolation
+
+        FaceCellWave<Type, TrackingData>& solver_;
+
+        const cyclicAMIPolyPatch& patch_;
+
+    public:
+
+            interpolate
+            (
+                FaceCellWave<Type, TrackingData>& solver,
+                const cyclicAMIPolyPatch& patch
+            )
+            :
+                solver_(solver),
+                patch_(patch)
+            {}
+
+
+            void operator()
+            (
+                Type& x,
+                const label localFacei,
+                const label f0i,
+                const Type& y0,
+                const label f1i,
+                const Type& y1,
+                const scalar weight
+            ) const
+            {
+                if (y0.valid(solver_.data()))
+                {
+                    if (y1.valid(solver_.data()))
+                    {
+                        x.interpolate
+                        (
+                            solver_.mesh(),
+                            patch_.faceCentres()[localFacei],
+                            f0i,
+                            y0,
+                            f1i,
+                            y1,
+                            weight,
+                            solver_.propagationTol(),
+                            solver_.data()
+                        );
+                    }
+                    else
+                    {
+                        // Convert patch face into mesh face
+                        label meshFacei = -1;
+                        if (patch_.owner())
+                        {
+                            meshFacei = patch_.start() + f0i;
+                        }
+                        else
+                        {
+                            meshFacei = patch_.neighbPatch().start() + f0i;
+                        }
+                        x.updateFace
+                        (
+                            solver_.mesh(),
+                            meshFacei,
+                            y0,
+                            solver_.propagationTol(),
+                            solver_.data()
+                        );
+                    }
+                }
+                else if (y1.valid(solver_.data()))
+                {
+                    // Convert patch face into mesh face
+                    label meshFacei = -1;
+                    if (patch_.owner())
+                    {
+                        meshFacei = patch_.start() + f1i;
+                    }
+                    else
+                    {
+                        meshFacei = patch_.neighbPatch().start() + f1i;
+                    }
+                    x.updateFace
+                    (
+                        solver_.mesh(),
+                        meshFacei,
+                        y1,
+                        solver_.propagationTol(),
+                        solver_.data()
+                    );
+                }
+            }
+    };
 }
 
 
@@ -784,18 +880,43 @@ void Foam::FaceCellWave<Type, TrackingData>::handleAMICyclicPatches()
                 // Transfer sendInfo to cycPatch
                 combine<Type, TrackingData> cmb(*this, cycPatch);
 
+                // Linear interpolation
+                interpolate<Type, TrackingData> interp(*this, cycPatch);
+
+                const auto& AMI =
+                (
+                    cycPatch.owner()
+                  ? cycPatch.AMI()
+                  : cycPatch.neighbPatch().AMI()
+                );
+
                 if (cycPatch.applyLowWeightCorrection())
                 {
-                    List<Type> defVals
+                    const List<Type> defVals
                     (
                         cycPatch.patchInternalList(allCellInfo_)
                     );
-
-                    cycPatch.interpolate(sendInfo, cmb, receiveInfo, defVals);
+                    AMI.interpolate
+                    (
+                        cycPatch.owner(),
+                        sendInfo,
+                        cmb,
+                        interp,
+                        receiveInfo,
+                        defVals
+                    );
                 }
                 else
                 {
-                    cycPatch.interpolate(sendInfo, cmb, receiveInfo);
+                    AMI.interpolate
+                    (
+                        cycPatch.owner(),
+                        sendInfo,
+                        cmb,
+                        interp,
+                        receiveInfo,
+                        UList<Type>::null() // no default values needed
+                    );
                 }
             }
 

src/meshTools/cellClassification/cellInfo.H

@@ -197,6 +197,23 @@ public:
             template<class TrackingData>
             inline bool equal(const cellInfo&, TrackingData& td) const;
 
+            //- Interpolate between two values (lerp). Returns true if
+            //- causes changes. Not sure if needs to be specialised between
+            //- face and cell and what index is needed...
+            template<class TrackingData>
+            inline bool interpolate
+            (
+                const polyMesh&,
+                const point& pt,
+                const label i0,
+                const cellInfo& f0,
+                const label i1,
+                const cellInfo& f1,
+                const scalar weight,
+                const scalar tol,
+                TrackingData& td
+            );
+
 
     // Member Operators
 

src/meshTools/cellClassification/cellInfoI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2020 OpenCFD Ltd.
+    Copyright (C) 2020,2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -249,6 +249,31 @@ inline bool Foam::cellInfo::equal
 }
 
 
+template<class TrackingData>
+inline bool Foam::cellInfo::interpolate
+(
+    const polyMesh&,
+    const point& pt,
+    const label i0,
+    const cellInfo& f0,
+    const label i1,
+    const cellInfo& f1,
+    const scalar weight,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    if (!f0.valid(td))
+    {
+        return update(f1, -1, -1, -1, -1, td);
+    }
+    else
+    {
+        return update(f0, -1, -1, -1, -1, td);
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 inline bool Foam::cellInfo::operator==

src/meshTools/cellDist/wallPoint/wallPoint.H

@@ -76,6 +76,16 @@ class wallPoint
 
     // Private Member Functions
 
+        // Update this with w2 if distance less
+        template<class TrackingData>
+        inline bool update
+        (
+            const wallPoint& w2,
+            const scalar dist2,
+            const scalar tol,
+            TrackingData& td
+        );
+
         //- Evaluate distance to point.
         //  Update distSqr, origin from whomever is nearer pt.
         //  \return true if w2 is closer to point, false otherwise.
@@ -206,10 +216,41 @@ public:
                 TrackingData& td
             );
 
+            //- Interpolate different values
+            template<class TrackingData>
+            wallPoint
+            (
+                const polyMesh&,
+                const scalar weight,
+                const label face0,
+                const wallPoint& info0,
+                const label face1,
+                const wallPoint& info1,
+                const scalar tol,
+                TrackingData& td
+            );
+
             //- Test for equality, with TrackingData
             template<class TrackingData>
             inline bool equal(const wallPoint&, TrackingData& td) const;
 
+            //- Interpolate between two values (lerp). Returns true if
+            //- causes changes. Not sure if needs to be specialised between
+            //- face and cell and what index is needed...
+            template<class TrackingData>
+            inline bool interpolate
+            (
+                const polyMesh&,
+                const point& pt,
+                const label i0,
+                const wallPoint& f0,
+                const label i1,
+                const wallPoint& f1,
+                const scalar weight,
+                const scalar tol,
+                TrackingData& td
+            );
+
 
     // Member Operators
 

src/meshTools/cellDist/wallPoint/wallPointI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2020 OpenCFD Ltd.
+    Copyright (C) 2020,2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -35,21 +35,12 @@ License
 template<class TrackingData>
 inline bool Foam::wallPoint::update
 (
-    const point& pt,
     const wallPoint& w2,
+    const scalar dist2,
     const scalar tol,
     TrackingData& td
 )
 {
-    //Already done in calling algorithm
-    //if (w2.origin() == origin_)
-    //{
-    //    // Shortcut. Same input so same distance.
-    //    return false;
-    //}
-
-    const scalar dist2 = magSqr(pt - w2.origin());
-
     if (!valid(td))
     {
         // current not yet set so use any value
@@ -83,6 +74,26 @@ inline bool Foam::wallPoint::update
 }
 
 
+// Update this with w2 if w2 nearer to pt.
+template<class TrackingData>
+inline bool Foam::wallPoint::update
+(
+    const point& pt,
+    const wallPoint& w2,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    return update
+    (
+        w2,
+        magSqr(pt - w2.origin()),
+        tol,
+        td
+    );
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 inline Foam::wallPoint::wallPoint()
@@ -260,6 +271,58 @@ inline bool Foam::wallPoint::equal
 }
 
 
+template<class TrackingData>
+inline bool Foam::wallPoint::interpolate
+(
+    const polyMesh&,
+    const point& pt,
+    const label i0,
+    const wallPoint& f0,
+    const label i1,
+    const wallPoint& f1,
+    const scalar weight,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    if (f0.valid(td))
+    {
+        if (f1.valid(td))
+        {
+            // What do we do about the origin? Should be consistent with the
+            // distance? But then interpolating between a point 'on the left'
+            // and a point 'on the right' the interpolate might just be on
+            // top of us so suddenly setting the distance to be zero...
+
+            const scalar dist2 =
+                sqr(lerp(sqrt(f0.distSqr()), sqrt(f1.distSqr()), weight));
+
+            if (f0.distSqr() < f1.distSqr())
+            {
+                // Update with interpolated distance and f0 origin
+                return update(f0, dist2, tol, td);
+            }
+            else
+            {
+                return update(f1, dist2, tol, td);
+            }
+        }
+        else
+        {
+            return update(f0, f0.distSqr(), tol, td);
+        }
+    }
+    else if (f1.valid(td))
+    {
+        return update(f1, f1.distSqr(), tol, td);
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 inline bool Foam::wallPoint::operator==

src/meshTools/meshStructure/topoDistanceData.H

@@ -196,6 +196,23 @@ public:
                 TrackingData& td
             ) const;
 
+            //- Interpolate between two values (lerp). Returns true if
+            //- causes changes. Not sure if needs to be specialised between
+            //- face and cell and what index is needed...
+            template<class TrackingData>
+            inline bool interpolate
+            (
+                const polyMesh&,
+                const point& pt,
+                const label i0,
+                const topoDistanceData<Type>& f0,
+                const label i1,
+                const topoDistanceData<Type>& f1,
+                const scalar weight,
+                const scalar tol,
+                TrackingData& td
+            );
+
 
     // Member Operators
 

src/meshTools/meshStructure/topoDistanceDataI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2020 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -199,6 +199,38 @@ inline bool Foam::topoDistanceData<Type>::equal
 }
 
 
+template<class Type>
+template<class TrackingData>
+inline bool Foam::topoDistanceData<Type>::interpolate
+(
+    const polyMesh&,
+    const point& pt,
+    const label i0,
+    const topoDistanceData<Type>& f0,
+    const label i1,
+    const topoDistanceData<Type>& f1,
+    const scalar weight,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    // Topological distance - how to interpolate?
+    if (!valid(td))
+    {
+        if (f0.valid(td))
+        {
+            this->operator=(f0);
+        }
+        else
+        {
+            this->operator=(f1);
+        }
+        return true;
+    }
+    return false;
+}
+
+
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 template<class Type>

src/meshTools/regionSplit/minData.H

@@ -174,6 +174,23 @@ public:
             template<class TrackingData>
             inline bool equal(const minData&, TrackingData& td) const;
 
+            //- Interpolate between two values (lerp). Returns true if
+            //- causes changes. Not sure if needs to be specialised between
+            //- face and cell and what index is needed...
+            template<class TrackingData>
+            inline bool interpolate
+            (
+                const polyMesh&,
+                const point& pt,
+                const label i0,
+                const minData& f0,
+                const label i1,
+                const minData& f1,
+                const scalar weight,
+                const scalar tol,
+                TrackingData& td
+            );
+
 
     // Member Operators
 

src/meshTools/regionSplit/minDataI.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2014-2016 OpenFOAM Foundation
-    Copyright (C) 2015-2020 OpenCFD Ltd.
+    Copyright (C) 2015-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -173,6 +173,35 @@ inline bool Foam::minData::equal
 }
 
 
+template<class TrackingData>
+inline bool Foam::minData::interpolate
+(
+    const polyMesh& mesh,
+    const point& pt,
+    const label i0,
+    const minData& f0,
+    const label i1,
+    const minData& f1,
+    const scalar weight,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    if (f0.valid(td))
+    {
+        return updateFace(mesh, -1, f0, tol, td);
+    }
+    if (f1.valid(td))
+    {
+        return updateFace(mesh, -1, f1, tol, td);
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 inline bool Foam::minData::operator==

src/overset/cellCellStencil/inverseDistance/meshToMeshData.H

@@ -200,6 +200,23 @@ public:
                 TrackingData&
             ) const;
 
+            //- Interpolate between two values (lerp). Returns true if
+            //- causes changes. Not sure if needs to be specialised between
+            //- face and cell and what index is needed...
+            template<class TrackingData>
+            inline bool interpolate
+            (
+                const polyMesh&,
+                const point& pt,
+                const label i0,
+                const meshToMeshData& f0,
+                const label i1,
+                const meshToMeshData& f1,
+                const scalar weight,
+                const scalar tol,
+                TrackingData& td
+            );
+
 
     // Member Operators
 

src/overset/cellCellStencil/inverseDistance/meshToMeshDataI.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2020 OpenCFD Ltd.
+    Copyright (C) 2017-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -205,6 +205,35 @@ inline bool Foam::meshToMeshData::equal
 }
 
 
+template<class TrackingData>
+inline bool Foam::meshToMeshData::interpolate
+(
+    const polyMesh& mesh,
+    const point& pt,
+    const label i0,
+    const meshToMeshData& f0,
+    const label i1,
+    const meshToMeshData& f1,
+    const scalar weight,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    if (f0.valid(td))
+    {
+        return updateFace(mesh, -1, f0, tol, td);
+    }
+    if (f1.valid(td))
+    {
+        return updateFace(mesh, -1, f1, tol, td);;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 inline bool Foam::meshToMeshData::operator==

src/sampling/Make/files

@@ -1,6 +1,3 @@
-probes/probers/prober.C
-probes/probers/internalProber/internalProber.C
-probes/probers/patchProber/patchProber.C
 probes/probes.C
 probes/patchProbes.C
 

src/sampling/probes/Probes/Probes.C

@@ -1,453 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2015-2025 OpenCFD Ltd.
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "Probes.H"
-#include "IOmanip.H"
-#include "volFields.H"
-#include "surfaceFields.H"
-#include "SpanStream.H"
-#include "addToRunTimeSelectionTable.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-template<class Prober>
-void Foam::Probes<Prober>::createProbeFiles(const wordList& fieldNames)
-{
-    // Open new output streams
-
-    bool needsNewFiles = false;
-    for (const word& fieldName : fieldNames)
-    {
-        if (!probeFilePtrs_.found(fieldName))
-        {
-            needsNewFiles = true;
-            break;
-        }
-    }
-
-    if (needsNewFiles && Pstream::master())
-    {
-        DebugInfo
-            << "Probing fields: " << fieldNames << nl
-            << "Probing locations: " << prober_.probeLocations() << nl
-            << endl;
-
-        // Put in undecomposed case
-        // (Note: gives problems for distributed data running)
-
-        fileName probeDir
-        (
-            mesh_.time().globalPath()
-          / functionObject::outputPrefix
-          / name()/mesh_.regionName()
-            // Use startTime as the instance for output files
-          / mesh_.time().timeName(mesh_.time().startTime().value())
-        );
-        probeDir.clean();  // Remove unneeded ".."
-
-        // Create directory if needed
-        Foam::mkDir(probeDir);
-
-        for (const word& fieldName : fieldNames)
-        {
-            if (probeFilePtrs_.found(fieldName))
-            {
-                // Safety
-                continue;
-            }
-
-            auto osPtr = autoPtr<OFstream>::New(probeDir/fieldName);
-            auto& os = *osPtr;
-
-            if (!os.good())
-            {
-                FatalErrorInFunction
-                    << "Cannot open probe output file: " << os.name() << nl
-                    << exit(FatalError);
-            }
-
-            probeFilePtrs_.insert(fieldName, osPtr);
-
-            DebugInfo<< "open probe stream: " << os.name() << endl;
-
-            const unsigned int width(IOstream::defaultPrecision() + 7);
-            os.setf(std::ios_base::left);
-
-            const pointField& probeLocs = prober_.probeLocations();
-            const labelList& processors = prober_.processors();
-            const labelList& patchIDList = prober_.patchIDList();
-            const pointField& oldPoints = prober_.oldPoints();
-
-            forAll(probeLocs, probei)
-            {
-                os  << "# Probe " << probei << ' ' << probeLocs[probei];
-
-                if (processors[probei] == -1)
-                {
-                    os  << "  # Not Found";
-                }
-                else if (probei < patchIDList.size())
-                {
-                    const label patchi = patchIDList[probei];
-                    if (patchi != -1)
-                    {
-                        const polyBoundaryMesh& bm = mesh_.boundaryMesh();
-                        if
-                        (
-                            patchi < bm.nNonProcessor()
-                         || processors[probei] == Pstream::myProcNo()
-                        )
-                        {
-                            os  << " at patch " << bm[patchi].name();
-                        }
-                        os  << " with a distance of "
-                            << mag(probeLocs[probei]-oldPoints[probei])
-                            << " m to the original point "
-                            << oldPoints[probei];
-                    }
-                }
-
-                os  << nl;
-            }
-
-            os  << setw(width) << "# Time";
-
-            forAll(probeLocs, probei)
-            {
-                if (prober_.includeOutOfBounds() || processors[probei] != -1)
-                {
-                    os  << ' ' << setw(width) << probei;
-                }
-            }
-            os  << endl;
-        }
-    }
-}
-
-
-template<class Prober>
-template<class Type>
-void Foam::Probes<Prober>::writeValues
-(
-    const word& fieldName,
-    const Field<Type>& values,
-    const scalar timeValue
-)
-{
-    if (Pstream::master())
-    {
-        const unsigned int width(IOstream::defaultPrecision() + 7);
-        OFstream& os = *probeFilePtrs_[fieldName];
-
-        os  << setw(width) << timeValue;
-
-        OCharStream buf;
-
-        const bool includeOutOfBounds = prober_.includeOutOfBounds();
-        const labelList& procs = prober_.processors();
-        forAll(values, probei)
-        {
-            if (includeOutOfBounds || procs[probei] != -1)
-            {
-                buf.rewind();
-                buf << values[probei];
-                os  << ' ' << setw(width) << buf.str().data();
-            }
-        }
-        os  << endl;
-    }
-}
-
-
-template<class Prober>
-template<class GeoField>
-void Foam::Probes<Prober>::performAction
-(
-    const fieldGroup<GeoField>& fieldNames,
-    unsigned request
-)
-{
-    for (const word& fieldName : fieldNames)
-    {
-        tmp<GeoField> tfield = getOrLoadField<GeoField>(fieldName);
-
-        if (tfield)
-        {
-            const auto& field = tfield();
-            const scalar timeValue = field.time().timeOutputValue();
-
-            Field<typename GeoField::value_type> values(prober_.sample(field));
-
-            this->storeResults(fieldName, values);
-            if (request & ACTION_WRITE)
-            {
-                this->writeValues(fieldName, values, timeValue);
-            }
-        }
-    }
-}
-
-
-// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
-
-template<class Prober>
-Foam::label Foam::Probes<Prober>::prepare(unsigned request)
-{
-    // Prefilter on selection
-    HashTable<wordHashSet> selected =
-    (
-        loadFromFiles_
-      ? IOobjectList(mesh_, mesh_.time().timeName()).classes(fieldSelection_)
-      : mesh_.classes(fieldSelection_)
-    );
-
-    // Classify and count fields
-    label nFields = 0;
-    do
-    {
-        #undef  doLocalCode
-        #define doLocalCode(InputType, Target)                                \
-        {                                                                     \
-            Target.clear();  /* Remove old values */                          \
-            const auto iter = selected.cfind(InputType::typeName);            \
-            if (iter.good())                                                  \
-            {                                                                 \
-                /* Add new (current) values */                                \
-                Target.append(iter.val().sortedToc());                        \
-                nFields += Target.size();                                     \
-            }                                                                 \
-        }
-
-        doLocalCode(volScalarField, scalarFields_);
-        doLocalCode(volVectorField, vectorFields_);
-        doLocalCode(volSphericalTensorField, sphericalTensorFields_);
-        doLocalCode(volSymmTensorField, symmTensorFields_);
-        doLocalCode(volTensorField, tensorFields_);
-
-        doLocalCode(surfaceScalarField, surfaceScalarFields_);
-        doLocalCode(surfaceVectorField, surfaceVectorFields_);
-        doLocalCode(surfaceSphericalTensorField, surfaceSphericalTensorFields_);
-        doLocalCode(surfaceSymmTensorField, surfaceSymmTensorFields_);
-        doLocalCode(surfaceTensorField, surfaceTensorFields_);
-        #undef doLocalCode
-    }
-    while (false);
-
-
-    // Adjust file streams
-    if (Pstream::master())
-    {
-        wordHashSet currentFields(2*nFields);
-        currentFields.insert(scalarFields_);
-        currentFields.insert(vectorFields_);
-        currentFields.insert(sphericalTensorFields_);
-        currentFields.insert(symmTensorFields_);
-        currentFields.insert(tensorFields_);
-
-        currentFields.insert(surfaceScalarFields_);
-        currentFields.insert(surfaceVectorFields_);
-        currentFields.insert(surfaceSphericalTensorFields_);
-        currentFields.insert(surfaceSymmTensorFields_);
-        currentFields.insert(surfaceTensorFields_);
-
-        DebugInfo
-            << "Probing fields: " << currentFields << nl
-            << "Probing locations: " << prober_.probeLocations() << nl
-            << endl;
-
-        // Close streams for fields that no longer exist
-        forAllIters(probeFilePtrs_, iter)
-        {
-            if (!currentFields.erase(iter.key()))
-            {
-                DebugInfo<< "close probe stream: " << iter()->name() << endl;
-
-                probeFilePtrs_.remove(iter);
-            }
-        }
-
-        if ((request & ACTION_WRITE) && !currentFields.empty())
-        {
-            createProbeFiles(currentFields.sortedToc());
-        }
-    }
-
-    return nFields;
-}
-
-
-template<class Prober>
-template<class GeoField>
-Foam::tmp<GeoField>
-Foam::Probes<Prober>::getOrLoadField(const word& fieldName) const
-{
-    tmp<GeoField> tfield;
-
-    if (loadFromFiles_)
-    {
-        tfield.emplace
-        (
-            IOobject
-            (
-                fieldName,
-                mesh_.time().timeName(),
-                mesh_.thisDb(),
-                IOobjectOption::MUST_READ,
-                IOobjectOption::NO_WRITE,
-                IOobjectOption::NO_REGISTER
-            ),
-            mesh_
-        );
-    }
-    else
-    {
-        tfield.cref(mesh_.cfindObject<GeoField>(fieldName));
-    }
-
-    return tfield;
-}
-
-
-template<class Prober>
-template<class Type>
-void Foam::Probes<Prober>::storeResults
-(
-    const word& fieldName,
-    const Field<Type>& values
-)
-{
-    const MinMax<Type> limits(values);
-    const Type avgVal = average(values);
-
-    this->setResult("average(" + fieldName + ")", avgVal);
-    this->setResult("min(" + fieldName + ")", limits.min());
-    this->setResult("max(" + fieldName + ")", limits.max());
-    this->setResult("size(" + fieldName + ")", values.size());
-
-    if (verbose_)
-    {
-        Info<< name() << " : " << fieldName << nl
-            << "    avg: " << avgVal << nl
-            << "    min: " << limits.min() << nl
-            << "    max: " << limits.max() << nl << nl;
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-template<class Prober>
-Foam::Probes<Prober>::Probes
-(
-    const word& name,
-    const Time& runTime,
-    const dictionary& dict,
-    const bool loadFromFiles,
-    const bool readFields
-)
-:
-    functionObjects::fvMeshFunctionObject(name, runTime, dict),
-    prober_(mesh_, dict),
-    loadFromFiles_(loadFromFiles),
-    onExecute_(false),
-    fieldSelection_()
-{
-    if (readFields)
-    {
-        read(dict);
-    }
-}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class Prober>
-bool Foam::Probes<Prober>::verbose(const bool on) noexcept
-{
-    bool old(verbose_);
-    verbose_ = on;
-    return old;
-}
-
-
-template<class Prober>
-bool Foam::Probes<Prober>::read(const dictionary& dict)
-{
-    dict.readEntry("fields", fieldSelection_);
-
-    verbose_ = dict.getOrDefault("verbose", false);
-    onExecute_ = dict.getOrDefault("sampleOnExecute", false);
-
-    // Close old (unused) streams
-    prepare(ACTION_NONE);
-
-    return true;
-}
-
-
-template<class Prober>
-bool Foam::Probes<Prober>::performAction(unsigned request)
-{
-    if (!prober_.empty() && request && prepare(request))
-    {
-        performAction(scalarFields_, request);
-        performAction(vectorFields_, request);
-        performAction(sphericalTensorFields_, request);
-        performAction(symmTensorFields_, request);
-        performAction(tensorFields_, request);
-
-        performAction(surfaceScalarFields_, request);
-        performAction(surfaceVectorFields_, request);
-        performAction(surfaceSphericalTensorFields_, request);
-        performAction(surfaceSymmTensorFields_, request);
-        performAction(surfaceTensorFields_, request);
-    }
-    return true;
-}
-
-
-template<class Prober>
-bool Foam::Probes<Prober>::execute()
-{
-    if (onExecute_)
-    {
-        return performAction(ACTION_ALL & ~ACTION_WRITE);
-    }
-
-    return true;
-}
-
-
-template<class Prober>
-bool Foam::Probes<Prober>::write()
-{
-    return performAction(ACTION_ALL);
-}
-
-
-// ************************************************************************* //

src/sampling/probes/Probes/Probes.H

@@ -1,238 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2025 OpenCFD Ltd.
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::Probes
-
-Description
-    Base class for sampling fields at specified locations and writing to file.
-    The locations are specified and determined in the derived class. The
-    sampling is done using the specified point prober class.
-
-SourceFiles
-    Probes.C
-    ProbesTemplates.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef Foam_Probes_H
-#define Foam_Probes_H
-
-#include "fvMeshFunctionObject.H"
-#include "polyMesh.H"
-#include "HashPtrTable.H"
-#include "OFstream.H"
-#include "volFieldsFwd.H"
-#include "surfaceFieldsFwd.H"
-#include "prober.H"
-#include "IOobjectList.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-/*---------------------------------------------------------------------------*\
-                          Class Probes Declaration
-\*---------------------------------------------------------------------------*/
-
-template<class Prober>
-class Probes
-:
-    public functionObjects::fvMeshFunctionObject
-{
-protected:
-
-    // Protected Data
-
-        //- The specified point prober
-        Prober prober_;
-
-
-    // Protected Classes
-
-        //- Grouping of field names by GeometricField type
-        template<class GeoField>
-        struct fieldGroup : public DynamicList<word> {};
-
-
-    // Data Types
-
-        //- Local control for sampling actions
-        enum sampleActionType : unsigned
-        {
-            ACTION_NONE  = 0,
-            ACTION_WRITE = 0x1,
-            ACTION_STORE = 0x2,
-            ACTION_ALL = 0xF
-        };
-
-
-    // Protected Data
-
-        //- Load fields from files (not from objectRegistry)
-        bool loadFromFiles_;
-
-        //- Output verbosity
-        bool verbose_;
-
-        //- Perform sample actions on execute as well
-        bool onExecute_;
-
-        //- Requested names of fields to probe
-        wordRes fieldSelection_;
-
-
-    // Calculated
-
-        //- Current list of field names selected for sampling
-        DynamicList<word> selectedFieldNames_;
-
-        //- Categorized scalar/vector/tensor volume fields
-        fieldGroup<volScalarField> scalarFields_;
-        fieldGroup<volVectorField> vectorFields_;
-        fieldGroup<volSphericalTensorField> sphericalTensorFields_;
-        fieldGroup<volSymmTensorField> symmTensorFields_;
-        fieldGroup<volTensorField> tensorFields_;
-
-        //- Categorized scalar/vector/tensor surface fields
-        fieldGroup<surfaceScalarField> surfaceScalarFields_;
-        fieldGroup<surfaceVectorField> surfaceVectorFields_;
-        fieldGroup<surfaceSphericalTensorField> surfaceSphericalTensorFields_;
-        fieldGroup<surfaceSymmTensorField> surfaceSymmTensorFields_;
-        fieldGroup<surfaceTensorField> surfaceTensorFields_;
-
-        //- Current open files (non-empty on master only)
-        HashPtrTable<OFstream> probeFilePtrs_;
-
-
-    // Protected Member Functions
-
-        //- Classify field types, close/open file streams
-        //  \return number of fields to sample
-        label prepare(unsigned request);
-
-        //- Get from registry or load from disk
-        template<class GeoField>
-        tmp<GeoField> getOrLoadField(const word& fieldName) const;
-
-        //- Store results: min/max/average/size
-        template<class Type>
-        void storeResults(const word& fieldName, const Field<Type>& values);
-
-
-private:
-
-    // Private Member Functions
-
-        //- Create new streams as required
-        void createProbeFiles(const wordList& fieldNames);
-
-        //- Write field values
-        template<class Type>
-        void writeValues
-        (
-            const word& fieldName,
-            const Field<Type>& values,
-            const scalar timeValue
-        );
-
-        //- Sample and store/write all applicable sampled fields
-        template<class GeoField>
-        void performAction
-        (
-            const fieldGroup<GeoField>& fieldNames,  /* must be sorted */
-            unsigned request
-        );
-
-        //- Perform sampling action with store/write
-        bool performAction(unsigned request);
-
-
-public:
-
-    // Constructors
-
-        //- Construct from Time and dictionary
-        Probes
-        (
-            const word& name,
-            const Time& runTime,
-            const dictionary& dict,
-            const bool loadFromFiles = false,
-            const bool readFields = true
-        );
-
-
-    //- Destructor
-    virtual ~Probes() = default;
-
-
-    // Member Functions
-
-        //- Enable/disable verbose output
-        //  \return old value
-        bool verbose(const bool on) noexcept;
-
-        //- Return names of fields to probe
-        virtual const wordRes& fieldNames() const noexcept
-        {
-            return fieldSelection_;
-        }
-
-        //- Return const reference to the point prober
-        const Prober& prober() const noexcept { return prober_; }
-
-        //- Read the settings from the dictionary
-        virtual bool read(const dictionary&);
-
-        //- Sample and store result if the sampleOnExecute is enabled.
-        virtual bool execute();
-
-        //- Sample and write
-        virtual bool write();
-
-        //- Update for changes of mesh due to readUpdate
-        virtual void readUpdate(const polyMesh::readUpdateState state)
-        {}
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#ifdef NoRepository
-    #include "Probes.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

src/sampling/probes/patchProbes.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2025 OpenCFD Ltd.
+    Copyright (C) 2016-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -27,6 +27,11 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "patchProbes.H"
+#include "volFields.H"
+#include "IOmanip.H"
+#include "mappedPatchBase.H"
+#include "treeBoundBox.H"
+#include "treeDataFace.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -34,6 +39,7 @@ License
 namespace Foam
 {
     defineTypeNameAndDebug(patchProbes, 0);
+
     addToRunTimeSelectionTable
     (
         functionObject,
@@ -42,6 +48,179 @@ namespace Foam
     );
 }
 
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::patchProbes::findElements(const fvMesh& mesh)
+{
+    (void)mesh.tetBasePtIs();
+
+    const polyBoundaryMesh& bm = mesh.boundaryMesh();
+
+    // All the info for nearest. Construct to miss
+    List<mappedPatchBase::nearInfo> nearest(this->size());
+
+    const labelList patchIDs(bm.patchSet(patchNames_).sortedToc());
+
+    label nFaces = 0;
+    forAll(patchIDs, i)
+    {
+        nFaces += bm[patchIDs[i]].size();
+    }
+
+    if (nFaces > 0)
+    {
+        // Collect mesh faces and bounding box
+        labelList bndFaces(nFaces);
+        treeBoundBox overallBb;
+
+        nFaces = 0;
+        forAll(patchIDs, i)
+        {
+            const polyPatch& pp = bm[patchIDs[i]];
+            forAll(pp, i)
+            {
+                bndFaces[nFaces++] = pp.start()+i;
+                const face& f = pp[i];
+
+                // Without reduction.
+                overallBb.add(pp.points(), f);
+            }
+        }
+
+        Random rndGen(123456);
+        overallBb.inflate(rndGen, 1e-4, ROOTVSMALL);
+
+
+        const indexedOctree<treeDataFace> boundaryTree
+        (
+            treeDataFace(mesh, bndFaces),  // patch faces only
+
+            overallBb,      // overall search domain
+            8,              // maxLevel
+            10,             // leafsize
+            3.0             // duplicity
+        );
+
+        forAll(probeLocations(), probei)
+        {
+            const auto& treeData = boundaryTree.shapes();
+            const point sample = probeLocations()[probei];
+
+            pointIndexHit info = boundaryTree.findNearest
+            (
+                sample,
+                Foam::sqr(boundaryTree.bb().mag())
+            );
+
+            if (!info.hit())
+            {
+                info = boundaryTree.findNearest(sample, Foam::sqr(GREAT));
+            }
+
+            const label facei = treeData.objectIndex(info.index());
+
+            const label patchi = bm.whichPatch(facei);
+
+            if (isA<emptyPolyPatch>(bm[patchi]))
+            {
+                WarningInFunction
+                    << " The sample point: " << sample
+                    << " belongs to " << patchi
+                    << " which is an empty patch. This is not permitted. "
+                    << " This sample will not be included "
+                    << endl;
+            }
+            else if (info.hit())
+            {
+                // Note: do we store the face centre or the actual nearest?
+                // We interpolate using the faceI only though (no
+                // interpolation) so it does not actually matter much, just for
+                // the location written to the header.
+
+                //const point& facePt = mesh.faceCentres()[faceI];
+                const point& facePt = info.point();
+
+                mappedPatchBase::nearInfo sampleInfo;
+
+                sampleInfo.first() = pointIndexHit(true, facePt, facei);
+
+                sampleInfo.second().first() = facePt.distSqr(sample);
+                sampleInfo.second().second() = Pstream::myProcNo();
+
+                nearest[probei] = sampleInfo;
+            }
+        }
+    }
+
+
+    // Find nearest - globally consistent
+    Pstream::listCombineReduce(nearest, mappedPatchBase::nearestEqOp());
+
+    oldPoints_.resize(this->size());
+
+    // Update actual probe locations and store old ones
+    forAll(nearest, samplei)
+    {
+        oldPoints_[samplei] = operator[](samplei);
+        operator[](samplei) = nearest[samplei].first().point();
+    }
+
+    if (debug)
+    {
+        InfoInFunction << nl;
+        forAll(nearest, samplei)
+        {
+            label proci = nearest[samplei].second().second();
+            label locali = nearest[samplei].first().index();
+
+            Info<< "    " << samplei << " coord:"<< operator[](samplei)
+                << " found on processor:" << proci
+                << " in local face:" << locali
+                << " with location:" << nearest[samplei].first().point()
+                << endl;
+        }
+    }
+
+    // Extract any local faces to sample:
+    // - operator[] : actual point to sample (=nearest point on patch)
+    // - oldPoints_ : original provided point (might be anywhere in the mesh)
+    // - elementList_   : cells, not used
+    // - faceList_      : faces (now patch faces)
+    // - patchIDList_   : patch corresponding to faceList
+    // - processor_     : processor
+    elementList_.resize_nocopy(nearest.size());
+    elementList_ = -1;
+
+    faceList_.resize_nocopy(nearest.size());
+    faceList_ = -1;
+
+    processor_.resize_nocopy(nearest.size());
+    processor_ = -1;
+
+    patchIDList_.resize_nocopy(nearest.size());
+    patchIDList_ = -1;
+
+    forAll(nearest, sampleI)
+    {
+        processor_[sampleI] = nearest[sampleI].second().second();
+
+        if (nearest[sampleI].second().second() == Pstream::myProcNo())
+        {
+            // Store the face to sample
+            faceList_[sampleI] = nearest[sampleI].first().index();
+            const label facei = faceList_[sampleI];
+            if (facei != -1)
+            {
+                processor_[sampleI] = Pstream::myProcNo();
+                patchIDList_[sampleI] = bm.whichPatch(facei);
+            }
+        }
+        reduce(processor_[sampleI], maxOp<label>());
+        reduce(patchIDList_[sampleI], maxOp<label>());
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::patchProbes::patchProbes
@@ -53,14 +232,7 @@ Foam::patchProbes::patchProbes
     const bool readFields
 )
 :
-    Base
-    (
-        name,
-        runTime,
-        dict,
-        loadFromFiles,
-        readFields
-    )
+    probes(name, runTime, dict, loadFromFiles, false)
 {
     if (readFields)
     {
@@ -71,14 +243,53 @@ Foam::patchProbes::patchProbes
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-bool Foam::patchProbes::read(const dictionary& dict)
+bool Foam::patchProbes::performAction(unsigned request)
 {
-    if (!(Probes::read(dict) && prober_.read(dict)))
+    if (!pointField::empty() && request && prepare(request))
     {
-        return false;
+        performAction(scalarFields_, request);
+        performAction(vectorFields_, request);
+        performAction(sphericalTensorFields_, request);
+        performAction(symmTensorFields_, request);
+        performAction(tensorFields_, request);
+
+        performAction(surfaceScalarFields_, request);
+        performAction(surfaceVectorFields_, request);
+        performAction(surfaceSphericalTensorFields_, request);
+        performAction(surfaceSymmTensorFields_, request);
+        performAction(surfaceTensorFields_, request);
     }
     return true;
 }
 
 
+bool Foam::patchProbes::execute()
+{
+    if (onExecute_)
+    {
+        return performAction(ACTION_ALL & ~ACTION_WRITE);
+    }
+
+    return true;
+}
+
+
+bool Foam::patchProbes::write()
+{
+    return performAction(ACTION_ALL);
+}
+
+
+bool Foam::patchProbes::read(const dictionary& dict)
+{
+    if (!dict.readIfPresent("patches", patchNames_))
+    {
+        patchNames_.resize(1);
+        patchNames_.first() = dict.get<word>("patch");
+    }
+
+    return probes::read(dict);
+}
+
+
 // ************************************************************************* //

src/sampling/probes/patchProbes.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2025 OpenCFD Ltd.
+    Copyright (C) 2016-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -28,71 +28,52 @@ Class
     Foam::patchProbes
 
 Description
-    Probes the specified points on specified patches. The points get snapped
-    onto the nearest point on the nearest face of the specified patch, and the
-    sampling is actioned on the snapped locations.
+    Set of locations to sample at patches
 
-Usage
-    Minimal example by using \c system/controlDict.functions:
+    Call write() to sample and write files.
+    - find nearest location on nearest face
+    - update *this with location (so header contains 'snapped' locations
+    - use *this as the sampling location
+
+    Example of function object specification:
     \verbatim
     patchProbes
     {
-        // Mandatory entries
         type            patchProbes;
         libs            (sampling);
 
-        fields          (<wordRes>);
-        probeLocations  (<vectorList>);
-        patches         (<wordRes>);    // or patch  <word>;
+        // Name of the directory for probe data
+        name            patchProbes;
 
-        // Optional entries
-        verbose         <bool>;
-        sampleOnExecute <bool>;
-        fixedLocations  <bool>;
-        includeOutOfBounds <bool>;
-        interpolationScheme <word>;
+        // Patches to sample (wildcards allowed)
+        patches         (".*inl.*");
 
-        ...
+        // Write at same frequency as fields
+        writeControl    writeTime;
+        writeInterval   1;
+
+        // Fields to be probed
+        fields          (p U);
+
+        // Locations to probe. These get snapped onto the nearest point
+        // on the selected patches
+        probeLocations
+        (
+            ( -100 0 0.01 )      // at inlet
+        );
     }
     \endverbatim
 
-    where the entries mean:
-    \table
-      Property     | Description                        | Type | Reqd | Deflt
-      type         | Type name: patchProbes             | word | yes  | -
-      libs         | Library name: sampling             | word | yes  | -
-      fields       | Names of the fields to be probed   | wordRes | yes | -
-      probeLocations | Locations of the probes          | vectorField | yes | -
-      patches      | Patches to sample (wildcards allowed) | wordRes | yes | -
-      verbose      | Enable/disable verbose output         | bool | no | false
-      sampleOnExecute | Sample on execution and store results | bool | no <!--
-                   -->                                               | false
-      fixedLocations | Do not recalculate cells if mesh moves | bool | no | true
-      includeOutOfBounds | Include out-of-bounds locations | bool | no | true
-      interpolationScheme | Scheme to obtain values at the points | word <!--
-                   -->                                            | no | cell
-    \endtable
-
-    The inherited entries are elaborated in:
-     - \link fvMeshFunctionObject.H \endlink
-     - \link Probes.H \endlink
-     - \link patchProber.H \endlink
-     - \link prober.H \endlink
-
-Note
-  - The \c includeOutOfBounds filters out points that haven't been found.
-    Default is to include them (with value \c -VGREAT).
-
 SourceFiles
     patchProbes.C
+    patchProbesTemplates.C
 
 \*---------------------------------------------------------------------------*/
 
 #ifndef Foam_patchProbes_H
 #define Foam_patchProbes_H
 
-#include "Probes.H"
-#include "patchProber.H"
+#include "probes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -100,17 +81,57 @@ namespace Foam
 {
 
 /*---------------------------------------------------------------------------*\
-                        Class patchProbes Declaration
+                          Class patchProbes Declaration
 \*---------------------------------------------------------------------------*/
 
 class patchProbes
 :
-    public Probes<patchProber>
+    public probes
 {
-    // Private Data
+protected:
 
-        //- Use simpler synonym for the base type
-        using Base = Probes<patchProber>;
+    // Protected Data
+
+        //- Patches to sample
+        wordRes patchNames_;
+
+
+    // Protected Member Functions
+
+        //- Find elements containing patchProbes
+        virtual void findElements(const fvMesh& mesh);  // override
+
+
+private:
+
+    // Private Member Functions
+
+        //- Write field values
+        template<class Type>
+        void writeValues
+        (
+            const word& fieldName,
+            const Field<Type>& values,
+            const scalar timeValue
+        );
+
+        //- Sample and store/write applicable volume/surface fields
+        template<class GeoField>
+        void performAction
+        (
+            const fieldGroup<GeoField>& fieldNames,  /* must be sorted */
+            unsigned request
+        );
+
+        //- Perform sampling action with store/write
+        bool performAction(unsigned request);
+
+
+        //- No copy construct
+        patchProbes(const patchProbes&) = delete;
+
+        //- No copy assignment
+        void operator=(const patchProbes&) = delete;
 
 
 public:
@@ -121,7 +142,7 @@ public:
 
     // Constructors
 
-        //- Construct from name, Time and dictionary
+        //- Construct from Time and dictionary
         patchProbes
         (
             const word& name,
@@ -131,26 +152,54 @@ public:
             const bool readFields = true
         );
 
-
     //- Destructor
     virtual ~patchProbes() = default;
 
 
     // Member Functions
 
-        //- Bring Base::prober into this class's public scope.
-        using Base::prober;
+        //- Sample and store result if the sampleOnExecute is enabled.
+        virtual bool execute();
 
-        //- Read the settings from the dictionary
+        //- Sample and write
+        virtual bool write();
+
+        //- Read
         virtual bool read(const dictionary&);
+
+
+    // Sampling
+
+        //- Sample a volume field at all locations
+        template<class Type>
+        tmp<Field<Type>> sample(const VolumeField<Type>&) const;
+
+        //- Sample a surface field at all locations
+        template<class Type>
+        tmp<Field<Type>> sample(const SurfaceField<Type>&) const;
+
+        //- Sample a single field on all sample locations
+        template<class Type>
+        tmp<Field<Type>> sample(const word& fieldName) const;
+
+        //- Sample a surface field at all locations
+        template<class Type>
+        tmp<Field<Type>> sampleSurfaceField(const word& fieldName) const;
 };
 
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+    #include "patchProbesTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 #endif
 
 // ************************************************************************* //

src/sampling/probes/patchProbesTemplates.C

@@ -5,7 +5,8 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2025 OpenCFD Ltd.
+    Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2021-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,15 +26,70 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "patchProber.H"
+#include "patchProbes.H"
 #include "volFields.H"
 #include "surfaceFields.H"
+#include "IOmanip.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Type>
+void Foam::patchProbes::writeValues
+(
+    const word& fieldName,
+    const Field<Type>& values,
+    const scalar timeValue
+)
+{
+    if (Pstream::master())
+    {
+        const unsigned int w = IOstream::defaultPrecision() + 7;
+        OFstream& os = *probeFilePtrs_[fieldName];
+
+        os  << setw(w) << timeValue;
+
+        for (const auto& v : values)
+        {
+            os  << ' ' << setw(w) << v;
+        }
+        os  << endl;
+    }
+}
+
+
+template<class GeoField>
+void Foam::patchProbes::performAction
+(
+    const fieldGroup<GeoField>& fieldNames,
+    unsigned request
+)
+{
+    for (const word& fieldName : fieldNames)
+    {
+        tmp<GeoField> tfield = getOrLoadField<GeoField>(fieldName);
+
+        if (tfield)
+        {
+            const auto& field = tfield();
+            const scalar timeValue = field.time().timeOutputValue();
+
+            Field<typename GeoField::value_type> values(sample(field));
+
+            this->storeResults(fieldName, values);
+            if (request & ACTION_WRITE)
+            {
+                this->writeValues(fieldName, values, timeValue);
+            }
+        }
+    }
+}
+
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
-Foam::patchProber::sample(const VolumeField<Type>& vField) const
+Foam::patchProbes::sample(const VolumeField<Type>& vField) const
 {
     const Type unsetVal(-VGREAT*pTraits<Type>::one);
 
@@ -45,7 +101,7 @@ Foam::patchProber::sample(const VolumeField<Type>& vField) const
 
     forAll(*this, probei)
     {
-        label facei = faceIds_[probei];
+        label facei = faceList_[probei];
 
         if (facei >= 0)
         {
@@ -63,7 +119,7 @@ Foam::patchProber::sample(const VolumeField<Type>& vField) const
 
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
-Foam::patchProber::sample(const SurfaceField<Type>& sField) const
+Foam::patchProbes::sample(const SurfaceField<Type>& sField) const
 {
     const Type unsetVal(-VGREAT*pTraits<Type>::one);
 
@@ -75,7 +131,7 @@ Foam::patchProber::sample(const SurfaceField<Type>& sField) const
 
     forAll(*this, probei)
     {
-        label facei = faceIds_[probei];
+        label facei = faceList_[probei];
 
         if (facei >= 0)
         {
@@ -93,7 +149,7 @@ Foam::patchProber::sample(const SurfaceField<Type>& sField) const
 
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
-Foam::patchProber::sample(const word& fieldName) const
+Foam::patchProbes::sample(const word& fieldName) const
 {
     return sample(mesh_.lookupObject<VolumeField<Type>>(fieldName));
 }
@@ -101,7 +157,7 @@ Foam::patchProber::sample(const word& fieldName) const
 
 template<class Type>
 Foam::tmp<Foam::Field<Type>>
-Foam::patchProber::sampleSurfaceField(const word& fieldName) const
+Foam::patchProbes::sampleSurfaceField(const word& fieldName) const
 {
     return sample(mesh_.lookupObject<SurfaceField<Type>>(fieldName));
 }

src/sampling/probes/probers/internalProber/internalProber.C

@@ -1,188 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2025 OpenCFD Ltd.
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "internalProber.H"
-#include "addToRunTimeSelectionTable.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    defineTypeNameAndDebug(internalProber, 0);
-}
-
-// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
-
-void Foam::internalProber::findElements(const fvMesh& mesh)
-{
-    DebugInfo<< "internalProber: resetting sample locations" << endl;
-
-    const pointField& probeLocations = this->probeLocations();
-
-    cellIds_.resize_nocopy(probeLocations.size());
-    faceIds_.resize_nocopy(probeLocations.size());
-    procIds_.resize_nocopy(probeLocations.size());
-    procIds_ = -1;
-
-    forAll(probeLocations, probei)
-    {
-        const point& location = probeLocations[probei];
-
-        const label celli = mesh.findCell(location);
-
-        cellIds_[probei] = celli;
-
-        if (celli != -1)
-        {
-            const labelList& cellFaces = mesh.cells()[celli];
-            const vector& cellCentre = mesh.cellCentres()[celli];
-            scalar minDistance = GREAT;
-            label minFaceID = -1;
-            forAll(cellFaces, i)
-            {
-                label facei = cellFaces[i];
-                vector dist = mesh.faceCentres()[facei] - cellCentre;
-                if (mag(dist) < minDistance)
-                {
-                    minDistance = mag(dist);
-                    minFaceID = facei;
-                }
-            }
-            faceIds_[probei] = minFaceID;
-        }
-        else
-        {
-            faceIds_[probei] = -1;
-        }
-
-        if (debug && (cellIds_[probei] != -1 || faceIds_[probei] != -1))
-        {
-            Pout<< "internalProber : found point " << location
-                << " in cell " << cellIds_[probei]
-                << " and face " << faceIds_[probei] << endl;
-        }
-    }
-
-
-    // Check if all probes have been found.
-    forAll(cellIds_, probei)
-    {
-        const point& location = probeLocations[probei];
-        label celli = cellIds_[probei];
-        label facei = faceIds_[probei];
-
-        procIds_[probei] = (celli != -1 ? Pstream::myProcNo() : -1);
-
-        // Check at least one processor with cell.
-        reduce(celli, maxOp<label>());
-        reduce(facei, maxOp<label>());
-        reduce(procIds_[probei], maxOp<label>());
-
-        if (celli == -1)
-        {
-            if (Pstream::master())
-            {
-                WarningInFunction
-                    << "Did not find location " << location
-                    << " in any cell. Skipping location." << endl;
-            }
-        }
-        else if (facei == -1)
-        {
-            if (Pstream::master())
-            {
-                WarningInFunction
-                    << "Did not find location " << location
-                    << " in any face. Skipping location." << endl;
-            }
-        }
-        else
-        {
-            // Make sure location not on two domains.
-            if (cellIds_[probei] != -1 && cellIds_[probei] != celli)
-            {
-                WarningInFunction
-                    << "Location " << location
-                    << " seems to be on multiple domains:"
-                    << " cell " << cellIds_[probei]
-                    << " on my domain " << Pstream::myProcNo()
-                    << " and cell " << celli << " on some other domain."
-                    << nl
-                    << "This might happen if the probe location is on"
-                    << " a processor patch. Change the location slightly"
-                    << " to prevent this." << endl;
-            }
-
-            if (faceIds_[probei] != -1 && faceIds_[probei] != facei)
-            {
-                WarningInFunction
-                    << "Location " << location
-                    << " seems to be on multiple domains:"
-                    << " cell " << faceIds_[probei]
-                    << " on my domain " << Pstream::myProcNo()
-                    << " and face " << facei << " on some other domain."
-                    << nl
-                    << "This might happen if the probe location is on"
-                    << " a processor patch. Change the location slightly"
-                    << " to prevent this." << endl;
-            }
-        }
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::internalProber::internalProber
-(
-    const fvMesh& mesh,
-    const dictionary& dict
-)
-:
-    prober(mesh, dict)
-{
-    read(dict);
-}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-bool Foam::internalProber::read(const dictionary& dict)
-{
-    if (!prober::read(dict))
-    {
-        return false;
-    }
-
-    // Initialise cells to sample from supplied locations
-    findElements(mesh_);
-
-    return true;
-}
-
-
-// ************************************************************************* //

src/sampling/probes/probers/internalProber/internalProber.H

@@ -1,140 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2025 OpenCFD Ltd.
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::internalProber
-
-Description
-    A utility class for probing field values at specified point locations
-    within an \c fvMesh.
-
-    The \c internalProber stores a list of 3D point coordinates and
-    determines the corresponding mesh elements (cells or faces) that contain
-    these points. It provides methods to sample volume or surface fields at
-    the stored locations, with support for fixed or mesh-moving point
-    coordinates.
-
-    Features include:
-      - Reading probe locations and settings from a dictionary
-      - Support for fixed or moving locations (for dynamic mesh cases)
-      - Optional inclusion of points that lie outside of the mesh domain
-      - Selection of interpolation/sampling schemes for fixed locations
-      - Sampling of volume and surface fields by name or by direct reference
-      - Automatic update of element mapping when the mesh changes or moves
-
-SourceFiles
-    internalProber.C
-    internalProberTemplates.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef Foam_internalProber_H
-#define Foam_internalProber_H
-
-#include "prober.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-/*---------------------------------------------------------------------------*\
-                          Class internalProber Declaration
-\*---------------------------------------------------------------------------*/
-
-class internalProber
-:
-    public prober
-{
-protected:
-
-    // Protected Member Functions
-
-        //- Find cells and faces containing probes
-        virtual void findElements(const fvMesh& mesh);
-
-
-public:
-
-    //- Runtime type information
-    TypeName("internalProber");
-
-
-    // Constructors
-
-        //- Construct from Time and dictionary
-        internalProber
-        (
-            const fvMesh& mesh,
-            const dictionary& dict
-        );
-
-
-    //- Destructor
-    virtual ~internalProber() = default;
-
-
-    // Member Functions
-
-    // Sampling
-
-        //- Sample a volume field at all locations
-        template<class Type>
-        tmp<Field<Type>> sample(const VolumeField<Type>&) const;
-
-        //- Sample a surface field at all locations
-        template<class Type>
-        tmp<Field<Type>> sample(const SurfaceField<Type>&) const;
-
-        //- Sample a volume field at all locations
-        template<class Type>
-        tmp<Field<Type>> sample(const word& fieldName) const;
-
-        //- Sample a surface field at all locations
-        template<class Type>
-        tmp<Field<Type>> sampleSurfaceField(const word& fieldName) const;
-
-
-    // I-O
-
-        //- Read the settings dictionary
-        virtual bool read(const dictionary&);
-};
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#ifdef NoRepository
-    #include "internalProberTemplates.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

src/sampling/probes/probers/internalProber/internalProberTemplates.C

@@ -1,122 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2025 OpenCFD Ltd.
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "internalProber.H"
-#include "interpolation.H"
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class Type>
-Foam::tmp<Foam::Field<Type>>
-Foam::internalProber::sample(const VolumeField<Type>& vField) const
-{
-    const Type unsetVal(-VGREAT*pTraits<Type>::one);
-
-    auto tvalues = tmp<Field<Type>>::New(Field<Type>(this->size(), unsetVal));
-    auto& values = tvalues.ref();
-
-    if (fixedLocations_)
-    {
-        autoPtr<interpolation<Type>> interpPtr
-        (
-            interpolation<Type>::New(samplePointScheme_, vField)
-        );
-
-        const pointField& probeLocations = this->probeLocations();
-        forAll(probeLocations, probei)
-        {
-            if (cellIds_[probei] >= 0)
-            {
-                const vector& position = probeLocations[probei];
-
-                values[probei] = interpPtr().interpolate
-                (
-                    position,
-                    cellIds_[probei],
-                    -1
-                );
-            }
-        }
-    }
-    else
-    {
-        forAll(*this, probei)
-        {
-            if (cellIds_[probei] >= 0)
-            {
-                values[probei] = vField[cellIds_[probei]];
-            }
-        }
-    }
-
-    Pstream::listCombineReduce(values, isNotEqOp<Type>());
-
-    return tvalues;
-}
-
-
-template<class Type>
-Foam::tmp<Foam::Field<Type>>
-Foam::internalProber::sample(const SurfaceField<Type>& sField) const
-{
-    const Type unsetVal(-VGREAT*pTraits<Type>::one);
-
-    auto tvalues = tmp<Field<Type>>::New(Field<Type>(this->size(), unsetVal));
-    auto& values = tvalues.ref();
-
-    const pointField& probeLocations = this->probeLocations();
-    forAll(probeLocations, probei)
-    {
-        if (faceIds_[probei] >= 0)
-        {
-            values[probei] = sField[faceIds_[probei]];
-        }
-    }
-
-    Pstream::listCombineReduce(values, isNotEqOp<Type>());
-
-    return tvalues;
-}
-
-
-template<class Type>
-Foam::tmp<Foam::Field<Type>>
-Foam::internalProber::sample(const word& fieldName) const
-{
-    return sample(mesh_.lookupObject<VolumeField<Type>>(fieldName));
-}
-
-
-template<class Type>
-Foam::tmp<Foam::Field<Type>>
-Foam::internalProber::sampleSurfaceField(const word& fieldName) const
-{
-    return sample(mesh_.lookupObject<SurfaceField<Type>>(fieldName));
-}
-
-
-// ************************************************************************* //

src/sampling/probes/probers/patchProber/patchProber.C

@@ -1,252 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2022 OpenCFD Ltd.
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "patchProber.H"
-#include "mappedPatchBase.H"
-#include "treeBoundBox.H"
-#include "treeDataFace.H"
-#include "addToRunTimeSelectionTable.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    defineTypeNameAndDebug(patchProber, 0);
-}
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::patchProber::findElements(const fvMesh& mesh)
-{
-    (void)mesh.tetBasePtIs();
-
-    const polyBoundaryMesh& bm = mesh.boundaryMesh();
-
-    // All the info for nearest. Construct to miss
-    List<mappedPatchBase::nearInfo> nearest(this->size());
-
-    patchIDs_ = bm.patchSet(patchNames_).sortedToc();
-
-    label nFaces = 0;
-    forAll(patchIDs_, i)
-    {
-        nFaces += bm[patchIDs_[i]].size();
-    }
-
-    if (nFaces > 0)
-    {
-        // Collect mesh faces and bounding box
-        labelList bndFaces(nFaces);
-        treeBoundBox overallBb;
-
-        nFaces = 0;
-        forAll(patchIDs_, i)
-        {
-            const polyPatch& pp = bm[patchIDs_[i]];
-            forAll(pp, i)
-            {
-                bndFaces[nFaces++] = pp.start()+i;
-                const face& f = pp[i];
-
-                // Without reduction.
-                overallBb.add(pp.points(), f);
-            }
-        }
-
-        Random rndGen(123456);
-        overallBb.inflate(rndGen, 1e-4, ROOTVSMALL);
-
-
-        const indexedOctree<treeDataFace> boundaryTree
-        (
-            treeDataFace(mesh, bndFaces),  // patch faces only
-
-            overallBb,      // overall search domain
-            8,              // maxLevel
-            10,             // leafsize
-            3.0             // duplicity
-        );
-
-        forAll(probeLocations(), probei)
-        {
-            const auto& treeData = boundaryTree.shapes();
-            const point sample = probeLocations()[probei];
-
-            pointIndexHit info = boundaryTree.findNearest
-            (
-                sample,
-                Foam::sqr(boundaryTree.bb().mag())
-            );
-
-            if (!info.hit())
-            {
-                info = boundaryTree.findNearest(sample, Foam::sqr(GREAT));
-            }
-
-            const label facei = treeData.objectIndex(info.index());
-
-            const label patchi = bm.whichPatch(facei);
-
-            if (isA<emptyPolyPatch>(bm[patchi]))
-            {
-                WarningInFunction
-                    << " The sample point: " << sample
-                    << " belongs to " << patchi
-                    << " which is an empty patch. This is not permitted. "
-                    << " This sample will not be included "
-                    << endl;
-            }
-            else if (info.hit())
-            {
-                // Note: do we store the face centre or the actual nearest?
-                // We interpolate using the faceI only though (no
-                // interpolation) so it does not actually matter much, just for
-                // the location written to the header.
-
-                //const point& facePt = mesh.faceCentres()[faceI];
-                const point& facePt = info.point();
-
-                mappedPatchBase::nearInfo sampleInfo;
-
-                sampleInfo.first() = pointIndexHit(true, facePt, facei);
-
-                sampleInfo.second().first() = facePt.distSqr(sample);
-                sampleInfo.second().second() = Pstream::myProcNo();
-
-                nearest[probei] = sampleInfo;
-            }
-        }
-    }
-
-
-    // Find nearest - globally consistent
-    Pstream::listCombineReduce(nearest, mappedPatchBase::nearestEqOp());
-
-    oldPoints_.resize(this->size());
-
-    pointField& probeLocations = this->probeLocations();
-    // Update actual probe locations and store old ones
-    forAll(nearest, samplei)
-    {
-        oldPoints_[samplei] = probeLocations[samplei];
-        probeLocations[samplei] = nearest[samplei].first().point();
-    }
-
-    if (debug)
-    {
-        InfoInFunction << nl;
-        forAll(nearest, samplei)
-        {
-            label proci = nearest[samplei].second().second();
-            label locali = nearest[samplei].first().index();
-
-            Info<< "    " << samplei << " coord:"<< probeLocations[samplei]
-                << " found on processor:" << proci
-                << " in local face:" << locali
-                << " with location:" << nearest[samplei].first().point()
-                << endl;
-        }
-    }
-
-    // Extract any local faces to sample:
-    // - operator[] : actual point to sample (=nearest point on patch)
-    // - oldPoints_ : original provided point (might be anywhere in the mesh)
-    // - cellIds_   : cells, not used
-    // - faceIds_      : faces (now patch faces)
-    // - patchIds_   : patch corresponding to faceList
-    // - procIds_     : processor
-    cellIds_.resize_nocopy(nearest.size());
-    cellIds_ = -1;
-
-    faceIds_.resize_nocopy(nearest.size());
-    faceIds_ = -1;
-
-    procIds_.resize_nocopy(nearest.size());
-    procIds_ = -1;
-
-    patchIds_.resize_nocopy(nearest.size());
-    patchIds_ = -1;
-
-    forAll(nearest, sampleI)
-    {
-        procIds_[sampleI] = nearest[sampleI].second().second();
-
-        if (nearest[sampleI].second().second() == Pstream::myProcNo())
-        {
-            // Store the face to sample
-            faceIds_[sampleI] = nearest[sampleI].first().index();
-            const label facei = faceIds_[sampleI];
-            if (facei != -1)
-            {
-                procIds_[sampleI] = Pstream::myProcNo();
-                patchIds_[sampleI] = bm.whichPatch(facei);
-            }
-        }
-        reduce(procIds_[sampleI], maxOp<label>());
-        reduce(patchIds_[sampleI], maxOp<label>());
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::patchProber::patchProber
-(
-    const fvMesh& mesh,
-    const dictionary& dict
-)
-:
-    prober(mesh, dict)
-{
-    read(dict);
-}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-bool Foam::patchProber::read(const dictionary& dict)
-{
-    if (!prober::read(dict))
-    {
-        return false;
-    }
-
-    if (!dict.readIfPresent("patches", patchNames_))
-    {
-        patchNames_.resize(1);
-        patchNames_.first() = dict.get<word>("patch");
-    }
-
-    // Initialise cells to sample from supplied locations
-    findElements(mesh_);
-
-    return true;
-}
-
-
-// ************************************************************************* //

src/sampling/probes/probers/patchProber/patchProber.H

@@ -1,152 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2025 OpenCFD Ltd.
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::patchProber
-
-Description
-    Utility class for probing specified points on user-selected boundary
-    patches. The input points are projected onto the nearest point of the
-    nearest face on the specified patch, ensuring sampling occurs at valid
-    patch locations.
-
-    The patchProber enables sampling of both volume and surface fields
-    at these snapped locations. Patch selection is controlled via patch names or
-    indices, and the class provides runtime selection and dictionary-driven
-    configuration.
-
-    Typical usage involves specifying patch names and probe locations in a
-    dictionary, after which the class manages the mapping and sampling
-    operations.
-
-SourceFiles
-    patchProber.C
-    patchProberTemplates.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef Foam_patchProber_H
-#define Foam_patchProber_H
-
-#include "prober.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-/*---------------------------------------------------------------------------*\
-                        Class patchProber Declaration
-\*---------------------------------------------------------------------------*/
-
-class patchProber
-:
-    public prober
-{
-protected:
-
-    // Protected Data
-
-        //- Names of the patches to sample
-        wordRes patchNames_;
-
-        //- Index of the patches to sample
-        labelList patchIDs_;
-
-
-    // Protected Member Functions
-
-        //- Find elements containing patchProber
-        virtual void findElements(const fvMesh& mesh);
-
-
-public:
-
-    //- Runtime type information
-    TypeName("patchProber");
-
-
-    // Constructors
-
-        //- Construct from Time and dictionary
-        patchProber
-        (
-            const fvMesh& mesh,
-            const dictionary& dict
-        );
-
-
-    //- Destructor
-    virtual ~patchProber() = default;
-
-
-    // Member Functions
-
-    // Access
-
-        //- Return the index of the patches to sample
-        const labelList& patchIDs() const noexcept { return patchIDs_; }
-
-
-    // Sampling
-
-        //- Sample a volume field at all locations
-        template<class Type>
-        tmp<Field<Type>> sample(const VolumeField<Type>&) const;
-
-        //- Sample a surface field at all locations
-        template<class Type>
-        tmp<Field<Type>> sample(const SurfaceField<Type>&) const;
-
-        //- Sample a volume field at all locations
-        template<class Type>
-        tmp<Field<Type>> sample(const word& fieldName) const;
-
-        //- Sample a surface field at all locations
-        template<class Type>
-        tmp<Field<Type>> sampleSurfaceField(const word& fieldName) const;
-
-
-    // I-O
-
-        //- Read the settings dictionary
-        virtual bool read(const dictionary&);
-};
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#ifdef NoRepository
-    #include "patchProberTemplates.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

src/sampling/probes/probers/prober.C

@@ -1,188 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2025 OpenCFD Ltd.
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "prober.H"
-#include "mapPolyMesh.H"
-#include "addToRunTimeSelectionTable.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    defineTypeNameAndDebug(prober, 0);
-}
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::prober::prober
-(
-    const fvMesh& mesh,
-    const dictionary& dict
-)
-:
-    mesh_(mesh),
-    samplePointScheme_("cell")
-{
-    read(dict);
-}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-bool Foam::prober::read(const dictionary& dict)
-{
-    dict.readEntry("probeLocations", probes_);
-
-    if (probes_.empty())
-    {
-        FatalIOErrorInFunction(dict)
-            << "Empty 'probeLocations' list."
-            << exit(FatalIOError);
-    }
-
-    fixedLocations_ = dict.getOrDefault<bool>("fixedLocations", true);
-    includeOutOfBounds_ = dict.getOrDefault<bool>("includeOutOfBounds", true);
-
-    if (dict.readIfPresent("interpolationScheme", samplePointScheme_))
-    {
-        if (!fixedLocations_ && samplePointScheme_ != "cell")
-        {
-            WarningInFunction
-                << "Only cell interpolation can be applied when "
-                << "not using fixedLocations. InterpolationScheme "
-                << "entry will be ignored"
-                << endl;
-        }
-    }
-
-    return true;
-}
-
-
-void Foam::prober::updateMesh(const mapPolyMesh& mpm)
-{
-    DebugInfo<< "probes: updateMesh" << endl;
-
-    if (&mpm.mesh() != &mesh_)
-    {
-        return;
-    }
-
-    if (fixedLocations_)
-    {
-        this->findElements(mesh_);
-    }
-    else
-    {
-        DebugInfo<< "probes: remapping sample locations" << endl;
-
-        // 1. Update cells
-        {
-            DynamicList<label> elems(cellIds_.size());
-
-            const labelList& reverseMap = mpm.reverseCellMap();
-            forAll(cellIds_, i)
-            {
-                label celli = cellIds_[i];
-                if (celli != -1)
-                {
-                    label newCelli = reverseMap[celli];
-                    if (newCelli == -1)
-                    {
-                        // cell removed
-                    }
-                    else if (newCelli < -1)
-                    {
-                        // cell merged
-                        elems.append(-newCelli - 2);
-                    }
-                    else
-                    {
-                        // valid new cell
-                        elems.append(newCelli);
-                    }
-                }
-                else
-                {
-                    // Keep -1 elements so the size stays the same
-                    elems.append(-1);
-                }
-            }
-
-            cellIds_.transfer(elems);
-        }
-
-        // 2. Update faces
-        {
-            DynamicList<label> elems(faceIds_.size());
-
-            const labelList& reverseMap = mpm.reverseFaceMap();
-            for (const label facei : faceIds_)
-            {
-                if (facei != -1)
-                {
-                    label newFacei = reverseMap[facei];
-                    if (newFacei == -1)
-                    {
-                        // face removed
-                    }
-                    else if (newFacei < -1)
-                    {
-                        // face merged
-                        elems.append(-newFacei - 2);
-                    }
-                    else
-                    {
-                        // valid new face
-                        elems.append(newFacei);
-                    }
-                }
-                else
-                {
-                    // Keep -1 elements
-                    elems.append(-1);
-                }
-            }
-
-            faceIds_.transfer(elems);
-        }
-    }
-}
-
-
-void Foam::prober::movePoints(const polyMesh& mesh)
-{
-    DebugInfo<< "probes: movePoints" << endl;
-
-    if (fixedLocations_ && &mesh == &mesh_)
-    {
-        this->findElements(mesh_);
-    }
-}
-
-
-// ************************************************************************* //

src/sampling/probes/probers/prober.H

@@ -1,220 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2025 OpenCFD Ltd.
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::patchProber
-
-Description
-    Base class for sampling fields at specified internal and boundary locations.
-
-SourceFiles
-    prober.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef Foam_prober_H
-#define Foam_prober_H
-
-#include "fvMesh.H"
-#include "pointField.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-/*---------------------------------------------------------------------------*\
-                        Class prober Declaration
-\*---------------------------------------------------------------------------*/
-
-class prober
-{
-protected:
-
-    template<class T>
-    struct isNotEqOp
-    {
-        void operator()(T& x, const T& y) const
-        {
-            const T unsetVal(-VGREAT*pTraits<T>::one);
-
-            if (x != unsetVal)
-            {
-                // Keep x.
-
-                // Note: should check for y != unsetVal but multiple sample cells
-                // already handled in read().
-            }
-            else
-            {
-                // x is not set. y might be.
-                x = y;
-            }
-        }
-    };
-
-
-    // Protected Data
-
-        //- Const reference to the mesh
-        const fvMesh& mesh_;
-
-        //- Fixed locations (default: true)
-        //  Note: set to false for moving mesh calculations where locations
-        //        should move with the mesh
-        bool fixedLocations_;
-
-        //- Include probes that were not found (default: true)
-        bool includeOutOfBounds_;
-
-        //- Interpolation/sample scheme to obtain values at the points
-        //  Note: only possible when fixedLocations_ is true
-        word samplePointScheme_;
-
-
-    // Calculated
-
-        //- Probe locations
-        pointField probes_;
-
-        //- Cells to be probed (obtained from the locations)
-        labelList cellIds_;
-
-        //- Faces to be probed
-        labelList faceIds_;
-
-        //- Processor holding the cell or face (-1 if point not found
-        //- on any processor)
-        labelList procIds_;
-
-        //- Patch IDs on which the new probes are located
-        labelList patchIds_;
-
-        //- Original probes location
-        pointField oldPoints_;
-
-
-    // Protected Member Functions
-
-        //- Find cells and faces containing probes
-        virtual void findElements(const fvMesh& mesh) = 0;
-
-
-public:
-
-    //- Runtime type information
-    TypeName("prober");
-
-
-    // Generated Methods
-
-        //- No copy construct
-        prober(const prober&) = delete;
-
-        //- No copy assignment
-        void operator=(const prober&) = delete;
-
-
-    // Constructors
-
-        //- Construct from Time and dictionary
-        prober
-        (
-            const fvMesh& mesh,
-            const dictionary& dict
-        );
-
-
-    //- Destructor
-    virtual ~prober() = default;
-
-
-    // Member Functions
-
-    // Access
-
-        //- Return true if no probe locations
-        bool empty() const { return probes_.empty(); }
-
-        //- Return number of probe locations
-        label size() const { return probes_.size(); }
-
-        //- Return true if fixed locations
-        bool fixedLocations() const { return fixedLocations_; }
-
-        //- Return true if include out of bounds probes
-        bool includeOutOfBounds() const { return includeOutOfBounds_; }
-
-        //- Return the interpolation scheme to obtain values at the points
-        //  Note: only possible when fixedLocations_ is true
-        const word& samplePointScheme() const { return samplePointScheme_; }
-
-        //- Return const reference to the probe locations
-        const pointField& probeLocations() const { return probes_; }
-
-        //- Return reference to the probe locations
-        pointField& probeLocations() { return probes_; }
-
-        //- Return the location of probe i
-        const point& probe(const label i) const { return probes_[i]; }
-
-        //- Cells to be probed (obtained from the locations)
-        const labelList& elements() const { return cellIds_; }
-
-        //- Return const reference to the faces to be probed
-        const labelList& faces() const { return faceIds_; }
-
-        //- Return const reference to the processor list
-        const labelList& processors() const { return procIds_; }
-
-        //- Return const reference to the patch ID list
-        const labelList& patchIDList() const noexcept { return patchIds_; }
-
-        //- Return const reference to the original probe locations
-        const pointField& oldPoints() const noexcept { return oldPoints_; }
-
-
-    // I-O
-
-        //- Read the settings dictionary
-        virtual bool read(const dictionary&);
-
-        //- Update for changes of mesh
-        virtual void updateMesh(const mapPolyMesh&);
-
-        //- Update for changes of mesh
-        virtual void movePoints(const polyMesh&);
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

src/sampling/probes/probes.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2015-2025 OpenCFD Ltd.
+    Copyright (C) 2015-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -27,6 +27,12 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "probes.H"
+#include "dictionary.H"
+#include "volFields.H"
+#include "surfaceFields.H"
+#include "Time.H"
+#include "IOmanip.H"
+#include "mapPolyMesh.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -34,6 +40,7 @@ License
 namespace Foam
 {
     defineTypeNameAndDebug(probes, 0);
+
     addToRunTimeSelectionTable
     (
         functionObject,
@@ -42,6 +49,315 @@ namespace Foam
     );
 }
 
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::probes::createProbeFiles(const wordList& fieldNames)
+{
+    // Open new output streams
+
+    bool needsNewFiles = false;
+    for (const word& fieldName : fieldNames)
+    {
+        if (!probeFilePtrs_.found(fieldName))
+        {
+            needsNewFiles = true;
+            break;
+        }
+    }
+
+    if (needsNewFiles && Pstream::master())
+    {
+        DebugInfo
+            << "Probing fields: " << fieldNames << nl
+            << "Probing locations: " << *this << nl
+            << endl;
+
+        // Put in undecomposed case
+        // (Note: gives problems for distributed data running)
+
+        fileName probeDir
+        (
+            mesh_.time().globalPath()
+          / functionObject::outputPrefix
+          / name()/mesh_.regionName()
+            // Use startTime as the instance for output files
+          / mesh_.time().timeName(mesh_.time().startTime().value())
+        );
+        probeDir.clean();  // Remove unneeded ".."
+
+        // Create directory if needed
+        Foam::mkDir(probeDir);
+
+        for (const word& fieldName : fieldNames)
+        {
+            if (probeFilePtrs_.found(fieldName))
+            {
+                // Safety
+                continue;
+            }
+
+            auto osPtr = autoPtr<OFstream>::New(probeDir/fieldName);
+            auto& os = *osPtr;
+
+            probeFilePtrs_.insert(fieldName, osPtr);
+
+            DebugInfo<< "open probe stream: " << os.name() << endl;
+
+            const unsigned int width(IOstream::defaultPrecision() + 7);
+            os.setf(std::ios_base::left);
+
+            forAll(*this, probei)
+            {
+                os  << "# Probe " << probei << ' ' << operator[](probei);
+
+                if (processor_[probei] == -1)
+                {
+                    os  << "  # Not Found";
+                }
+                // Only for patchProbes
+                else if (probei < patchIDList_.size())
+                {
+                    const label patchi = patchIDList_[probei];
+                    if (patchi != -1)
+                    {
+                        const polyBoundaryMesh& bm = mesh_.boundaryMesh();
+                        if
+                        (
+                            patchi < bm.nNonProcessor()
+                         || processor_[probei] == Pstream::myProcNo()
+                        )
+                        {
+                            os  << " at patch " << bm[patchi].name();
+                        }
+                        os  << " with a distance of "
+                            << mag(operator[](probei)-oldPoints_[probei])
+                            << " m to the original point "
+                            << oldPoints_[probei];
+                    }
+                }
+
+                os  << nl;
+            }
+
+            os  << setw(width) << "# Time";
+
+            forAll(*this, probei)
+            {
+                if (includeOutOfBounds_ || processor_[probei] != -1)
+                {
+                    os  << ' ' << setw(width) << probei;
+                }
+            }
+            os  << endl;
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+void Foam::probes::findElements(const fvMesh& mesh)
+{
+    DebugInfo<< "probes: resetting sample locations" << endl;
+
+    elementList_.resize_nocopy(pointField::size());
+    faceList_.resize_nocopy(pointField::size());
+    processor_.resize_nocopy(pointField::size());
+    processor_ = -1;
+
+    forAll(*this, probei)
+    {
+        const point& location = (*this)[probei];
+
+        const label celli = mesh.findCell(location);
+
+        elementList_[probei] = celli;
+
+        if (celli != -1)
+        {
+            const labelList& cellFaces = mesh.cells()[celli];
+            const vector& cellCentre = mesh.cellCentres()[celli];
+            scalar minDistance = GREAT;
+            label minFaceID = -1;
+            forAll(cellFaces, i)
+            {
+                label facei = cellFaces[i];
+                vector dist = mesh.faceCentres()[facei] - cellCentre;
+                if (mag(dist) < minDistance)
+                {
+                    minDistance = mag(dist);
+                    minFaceID = facei;
+                }
+            }
+            faceList_[probei] = minFaceID;
+        }
+        else
+        {
+            faceList_[probei] = -1;
+        }
+
+        if (debug && (elementList_[probei] != -1 || faceList_[probei] != -1))
+        {
+            Pout<< "probes : found point " << location
+                << " in cell " << elementList_[probei]
+                << " and face " << faceList_[probei] << endl;
+        }
+    }
+
+
+    // Check if all probes have been found.
+    forAll(elementList_, probei)
+    {
+        const point& location = operator[](probei);
+        label celli = elementList_[probei];
+        label facei = faceList_[probei];
+
+        processor_[probei] = (celli != -1 ? Pstream::myProcNo() : -1);
+
+        // Check at least one processor with cell.
+        reduce(celli, maxOp<label>());
+        reduce(facei, maxOp<label>());
+        reduce(processor_[probei], maxOp<label>());
+
+        if (celli == -1)
+        {
+            if (Pstream::master())
+            {
+                WarningInFunction
+                    << "Did not find location " << location
+                    << " in any cell. Skipping location." << endl;
+            }
+        }
+        else if (facei == -1)
+        {
+            if (Pstream::master())
+            {
+                WarningInFunction
+                    << "Did not find location " << location
+                    << " in any face. Skipping location." << endl;
+            }
+        }
+        else
+        {
+            // Make sure location not on two domains.
+            if (elementList_[probei] != -1 && elementList_[probei] != celli)
+            {
+                WarningInFunction
+                    << "Location " << location
+                    << " seems to be on multiple domains:"
+                    << " cell " << elementList_[probei]
+                    << " on my domain " << Pstream::myProcNo()
+                    << " and cell " << celli << " on some other domain."
+                    << nl
+                    << "This might happen if the probe location is on"
+                    << " a processor patch. Change the location slightly"
+                    << " to prevent this." << endl;
+            }
+
+            if (faceList_[probei] != -1 && faceList_[probei] != facei)
+            {
+                WarningInFunction
+                    << "Location " << location
+                    << " seems to be on multiple domains:"
+                    << " cell " << faceList_[probei]
+                    << " on my domain " << Pstream::myProcNo()
+                    << " and face " << facei << " on some other domain."
+                    << nl
+                    << "This might happen if the probe location is on"
+                    << " a processor patch. Change the location slightly"
+                    << " to prevent this." << endl;
+            }
+        }
+    }
+}
+
+
+Foam::label Foam::probes::prepare(unsigned request)
+{
+    // Prefilter on selection
+    HashTable<wordHashSet> selected =
+    (
+        loadFromFiles_
+      ? IOobjectList(mesh_, mesh_.time().timeName()).classes(fieldSelection_)
+      : mesh_.classes(fieldSelection_)
+    );
+
+    // Classify and count fields
+    label nFields = 0;
+    do
+    {
+        #undef  doLocalCode
+        #define doLocalCode(InputType, Target)                                \
+        {                                                                     \
+            Target.clear();  /* Remove old values */                          \
+            const auto iter = selected.cfind(InputType::typeName);            \
+            if (iter.good())                                                  \
+            {                                                                 \
+                /* Add new (current) values */                                \
+                Target.append(iter.val().sortedToc());                        \
+                nFields += Target.size();                                     \
+            }                                                                 \
+        }
+
+        doLocalCode(volScalarField, scalarFields_);
+        doLocalCode(volVectorField, vectorFields_)
+        doLocalCode(volSphericalTensorField, sphericalTensorFields_);
+        doLocalCode(volSymmTensorField, symmTensorFields_);
+        doLocalCode(volTensorField, tensorFields_);
+
+        doLocalCode(surfaceScalarField, surfaceScalarFields_);
+        doLocalCode(surfaceVectorField, surfaceVectorFields_);
+        doLocalCode(surfaceSphericalTensorField, surfaceSphericalTensorFields_);
+        doLocalCode(surfaceSymmTensorField, surfaceSymmTensorFields_);
+        doLocalCode(surfaceTensorField, surfaceTensorFields_);
+        #undef doLocalCode
+    }
+    while (false);
+
+
+    // Adjust file streams
+    if (Pstream::master())
+    {
+        wordHashSet currentFields(2*nFields);
+        currentFields.insert(scalarFields_);
+        currentFields.insert(vectorFields_);
+        currentFields.insert(sphericalTensorFields_);
+        currentFields.insert(symmTensorFields_);
+        currentFields.insert(tensorFields_);
+
+        currentFields.insert(surfaceScalarFields_);
+        currentFields.insert(surfaceVectorFields_);
+        currentFields.insert(surfaceSphericalTensorFields_);
+        currentFields.insert(surfaceSymmTensorFields_);
+        currentFields.insert(surfaceTensorFields_);
+
+        DebugInfo
+            << "Probing fields: " << currentFields << nl
+            << "Probing locations: " << *this << nl
+            << endl;
+
+        // Close streams for fields that no longer exist
+        forAllIters(probeFilePtrs_, iter)
+        {
+            if (!currentFields.erase(iter.key()))
+            {
+                DebugInfo<< "close probe stream: " << iter()->name() << endl;
+
+                probeFilePtrs_.remove(iter);
+            }
+        }
+
+        if ((request & ACTION_WRITE) && !currentFields.empty())
+        {
+            createProbeFiles(currentFields.sortedToc());
+        }
+    }
+
+    return nFields;
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::probes::probes
@@ -53,14 +369,15 @@ Foam::probes::probes
     const bool readFields
 )
 :
-    Base
-    (
-        name,
-        runTime,
-        dict,
-        loadFromFiles,
-        readFields
-    )
+    functionObjects::fvMeshFunctionObject(name, runTime, dict),
+    pointField(),
+    loadFromFiles_(loadFromFiles),
+    fixedLocations_(true),
+    includeOutOfBounds_(true),
+    verbose_(false),
+    onExecute_(false),
+    fieldSelection_(),
+    samplePointScheme_("cell")
 {
     if (readFields)
     {
@@ -71,14 +388,184 @@ Foam::probes::probes
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+bool Foam::probes::verbose(const bool on) noexcept
+{
+    bool old(verbose_);
+    verbose_ = on;
+    return old;
+}
+
+
 bool Foam::probes::read(const dictionary& dict)
 {
-    if (!(Probes::read(dict) && prober_.read(dict)))
+    dict.readEntry("probeLocations", static_cast<pointField&>(*this));
+    dict.readEntry("fields", fieldSelection_);
+
+    dict.readIfPresent("fixedLocations", fixedLocations_);
+    dict.readIfPresent("includeOutOfBounds", includeOutOfBounds_);
+
+    verbose_ = dict.getOrDefault("verbose", false);
+    onExecute_ = dict.getOrDefault("sampleOnExecute", false);
+
+    if (dict.readIfPresent("interpolationScheme", samplePointScheme_))
     {
-        return false;
+        if (!fixedLocations_ && samplePointScheme_ != "cell")
+        {
+            WarningInFunction
+                << "Only cell interpolation can be applied when "
+                << "not using fixedLocations. InterpolationScheme "
+                << "entry will be ignored"
+                << endl;
+        }
+    }
+
+    // Initialise cells to sample from supplied locations
+    findElements(mesh_);
+
+    // Close old (ununsed) streams
+    prepare(ACTION_NONE);
+
+    return true;
+}
+
+
+bool Foam::probes::performAction(unsigned request)
+{
+    if (!pointField::empty() && request && prepare(request))
+    {
+        performAction(scalarFields_, request);
+        performAction(vectorFields_, request);
+        performAction(sphericalTensorFields_, request);
+        performAction(symmTensorFields_, request);
+        performAction(tensorFields_, request);
+
+        performAction(surfaceScalarFields_, request);
+        performAction(surfaceVectorFields_, request);
+        performAction(surfaceSphericalTensorFields_, request);
+        performAction(surfaceSymmTensorFields_, request);
+        performAction(surfaceTensorFields_, request);
     }
     return true;
 }
 
 
+bool Foam::probes::execute()
+{
+    if (onExecute_)
+    {
+        return performAction(ACTION_ALL & ~ACTION_WRITE);
+    }
+
+    return true;
+}
+
+
+bool Foam::probes::write()
+{
+    return performAction(ACTION_ALL);
+}
+
+
+void Foam::probes::updateMesh(const mapPolyMesh& mpm)
+{
+    DebugInfo<< "probes: updateMesh" << endl;
+
+    if (&mpm.mesh() != &mesh_)
+    {
+        return;
+    }
+
+    if (fixedLocations_)
+    {
+        findElements(mesh_);
+    }
+    else
+    {
+        DebugInfo<< "probes: remapping sample locations" << endl;
+
+        // 1. Update cells
+        {
+            DynamicList<label> elems(elementList_.size());
+
+            const labelList& reverseMap = mpm.reverseCellMap();
+            forAll(elementList_, i)
+            {
+                label celli = elementList_[i];
+                if (celli != -1)
+                {
+                    label newCelli = reverseMap[celli];
+                    if (newCelli == -1)
+                    {
+                        // cell removed
+                    }
+                    else if (newCelli < -1)
+                    {
+                        // cell merged
+                        elems.append(-newCelli - 2);
+                    }
+                    else
+                    {
+                        // valid new cell
+                        elems.append(newCelli);
+                    }
+                }
+                else
+                {
+                    // Keep -1 elements so the size stays the same
+                    elems.append(-1);
+                }
+            }
+
+            elementList_.transfer(elems);
+        }
+
+        // 2. Update faces
+        {
+            DynamicList<label> elems(faceList_.size());
+
+            const labelList& reverseMap = mpm.reverseFaceMap();
+            for (const label facei : faceList_)
+            {
+                if (facei != -1)
+                {
+                    label newFacei = reverseMap[facei];
+                    if (newFacei == -1)
+                    {
+                        // face removed
+                    }
+                    else if (newFacei < -1)
+                    {
+                        // face merged
+                        elems.append(-newFacei - 2);
+                    }
+                    else
+                    {
+                        // valid new face
+                        elems.append(newFacei);
+                    }
+                }
+                else
+                {
+                    // Keep -1 elements
+                    elems.append(-1);
+                }
+            }
+
+            faceList_.transfer(elems);
+        }
+    }
+}
+
+
+void Foam::probes::movePoints(const polyMesh& mesh)
+{
+    DebugInfo<< "probes: movePoints" << endl;
+
+    if (fixedLocations_ && &mesh == &mesh_)
+    {
+        findElements(mesh_);
+    }
+}
+
+
 // ************************************************************************* //

src/sampling/probes/probes.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2025 OpenCFD Ltd.
+    Copyright (C) 2016-2022 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -31,88 +31,237 @@ Group
     grpUtilitiesFunctionObjects
 
 Description
-    Function object to sample fields at specified internal-mesh locations and
-    write to file.
+    Set of locations to sample.
 
-Usage
-    Minimal example by using \c system/controlDict.functions:
+    Call write() to sample and write files.
+
+    Example of function object specification:
     \verbatim
     probes
     {
-        // Mandatory entries
         type            probes;
         libs            (sampling);
 
-        fields          (<wordRes>);
-        probeLocations  (<vectorList>);
+        // Name of the directory for probe data
+        name            probes;
 
-        // Optional entries
-        verbose         <bool>;
-        sampleOnExecute <bool>;
-        fixedLocations  <bool>;
-        includeOutOfBounds <bool>;
-        interpolationScheme <word>;
+        // Write at same frequency as fields
+        writeControl    writeTime;
+        writeInterval   1;
 
-        // Inherited entries
-        ...
+        // Fields to be probed
+        fields          (U "p.*");
+
+        // Optional: do not recalculate cells if mesh moves
+        fixedLocations  false;
+
+        // Optional: interpolation scheme to use (default is cell)
+        interpolationScheme cellPoint;
+
+        probeLocations
+        (
+            ( 1e-06 0 0.01 )      // at inlet
+            (0.21 -0.20999 0.01)  // at outlet1
+            (0.21 0.20999 0.01)   // at outlet2
+            (0.21 0 0.01)         // at central block
+        );
+
+        // Optional: filter out points that haven't been found. Default
+        //           is to include them (with value -VGREAT)
+        includeOutOfBounds  true;
     }
     \endverbatim
 
-    where the entries mean:
+    Entries:
     \table
-      Property     | Description                           | Type | Reqd | Deflt
-      type         | Type name: probes                     | word |  yes  | -
-      libs         | Library name: sampling                | word |  yes  | -
-      fields       | Names of fields to probe              | wordRes | yes | -
-      probeLocations | Locations of probes              | vectorList | yes | -
-      verbose      | Enable/disable verbose output         | bool | no | false
-      sampleOnExecute | Sample on execution and store results | bool | no <!--
-                   -->                                               | false
-      fixedLocations | Do not recalculate cells if mesh moves | bool | no | true
-      includeOutOfBounds | Include out-of-bounds locations | bool | no | true
-      interpolationScheme | Scheme to obtain values at the points | word <!--
-                   -->                                            | no | cell
+        Property | Description                              | Required | Default
+        type     | Type-name: probes                        | yes |
+        probeLocations | Probe locations                    | yes |
+        fields   | word/regex list of fields to sample      | yes |
+        interpolationScheme | scheme to obtain values       | no  | cell
+        fixedLocations | Do not recalculate cells if mesh moves | no | true
+        includeOutOfBounds | Include out-of-bounds locations | no | true
+        sampleOnExecute | Sample on execution and store results | no | false
     \endtable
 
-    The inherited entries are elaborated in:
-     - \link fvMeshFunctionObject.H \endlink
-     - \link Probes.H \endlink
-     - \link internalProber.H \endlink
-     - \link prober.H \endlink
-
-Note
-  - The \c includeOutOfBounds filters out points that haven't been found.
-    Default is to include them (with value \c -VGREAT).
-
 SourceFiles
     probes.C
+    probesTemplates.C
 
 \*---------------------------------------------------------------------------*/
 
 #ifndef Foam_probes_H
 #define Foam_probes_H
 
-#include "Probes.H"
-#include "internalProber.H"
+#include "fvMeshFunctionObject.H"
+#include "HashPtrTable.H"
+#include "OFstream.H"
+#include "polyMesh.H"
+#include "pointField.H"
+#include "volFieldsFwd.H"
+#include "surfaceFieldsFwd.H"
+#include "surfaceMesh.H"
+#include "wordRes.H"
+#include "IOobjectList.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 
+// Forward Declarations
+class Time;
+class objectRegistry;
+class dictionary;
+class fvMesh;
+class mapPolyMesh;
+
 /*---------------------------------------------------------------------------*\
                           Class probes Declaration
 \*---------------------------------------------------------------------------*/
 
 class probes
 :
-    public Probes<internalProber>
+    public functionObjects::fvMeshFunctionObject,
+    public pointField
 {
-    // Private Data
+protected:
 
-        //- Use simpler synonym for the base type
-        using Base = Probes<internalProber>;
+    // Protected Classes
 
+        //- Grouping of field names by GeometricField type
+        template<class GeoField>
+        struct fieldGroup : public DynamicList<word> {};
+
+
+    // Data Types
+
+        //- Local control for sampling actions
+        enum sampleActionType : unsigned
+        {
+            ACTION_NONE  = 0,
+            ACTION_WRITE = 0x1,
+            ACTION_STORE = 0x2,
+            ACTION_ALL = 0xF
+        };
+
+
+    // Protected Data
+
+        //- Load fields from files (not from objectRegistry)
+        bool loadFromFiles_;
+
+        //- Fixed locations (default: true)
+        //  Note: set to false for moving mesh calculations where locations
+        //        should move with the mesh
+        bool fixedLocations_;
+
+        //- Include probes that were not found (default: true)
+        bool includeOutOfBounds_;
+
+        //- Output verbosity
+        bool verbose_;
+
+        //- Perform sample actions on execute as well
+        bool onExecute_;
+
+        //- Requested names of fields to probe
+        wordRes fieldSelection_;
+
+        //- Interpolation/sample scheme to obtain values at the points
+        //  Note: only possible when fixedLocations_ is true
+        word samplePointScheme_;
+
+
+    // Calculated
+
+        //- Current list of field names selected for sampling
+        DynamicList<word> selectedFieldNames_;
+
+        //- Categorized scalar/vector/tensor volume fields
+        fieldGroup<volScalarField> scalarFields_;
+        fieldGroup<volVectorField> vectorFields_;
+        fieldGroup<volSphericalTensorField> sphericalTensorFields_;
+        fieldGroup<volSymmTensorField> symmTensorFields_;
+        fieldGroup<volTensorField> tensorFields_;
+
+        //- Categorized scalar/vector/tensor surface fields
+        fieldGroup<surfaceScalarField> surfaceScalarFields_;
+        fieldGroup<surfaceVectorField> surfaceVectorFields_;
+        fieldGroup<surfaceSphericalTensorField> surfaceSphericalTensorFields_;
+        fieldGroup<surfaceSymmTensorField> surfaceSymmTensorFields_;
+        fieldGroup<surfaceTensorField> surfaceTensorFields_;
+
+        //- Cells to be probed (obtained from the locations)
+        labelList elementList_;
+
+        //- Faces to be probed
+        labelList faceList_;
+
+        //- Processor holding the cell or face (-1 if point not found
+        //  on any processor)
+        labelList processor_;
+
+        //- Current open files (non-empty on master only)
+        HashPtrTable<OFstream> probeFilePtrs_;
+
+        //- Patch IDs on which the new probes are located (for patchProbes)
+        labelList patchIDList_;
+
+        //- Original probes location (only used for patchProbes)
+        pointField oldPoints_;
+
+
+    // Protected Member Functions
+
+        //- Find cells and faces containing probes
+        virtual void findElements(const fvMesh& mesh);
+
+        //- Classify field types, close/open file streams
+        //  \return number of fields to sample
+        label prepare(unsigned request);
+
+        //- Get from registry or load from disk
+        template<class GeoField>
+        tmp<GeoField> getOrLoadField(const word& fieldName) const;
+
+        //- Store results: min/max/average/size
+        template<class Type>
+        void storeResults(const word& fieldName, const Field<Type>& values);
+
+
+private:
+
+    // Private Member Functions
+
+        //- Create new streams as required
+        void createProbeFiles(const wordList& fieldNames);
+
+        //- Write field values
+        template<class Type>
+        void writeValues
+        (
+            const word& fieldName,
+            const Field<Type>& values,
+            const scalar timeValue
+        );
+
+        //- Sample and store/write all applicable sampled fields
+        template<class GeoField>
+        void performAction
+        (
+            const fieldGroup<GeoField>& fieldNames,  /* must be sorted */
+            unsigned request
+        );
+
+        //- Perform sampling action with store/write
+        bool performAction(unsigned request);
+
+        //- No copy construct
+        probes(const probes&) = delete;
+
+        //- No copy assignment
+        void operator=(const probes&) = delete;
 
 public:
 
@@ -139,19 +288,86 @@ public:
 
     // Member Functions
 
-        //- Bring Base::prober into this class's public scope.
-        using Base::prober;
+        //- Enable/disable verbose output
+        //  \return old value
+        bool verbose(const bool on) noexcept;
 
-        //- Read the settings from the dictionary
+        //- Return names of fields to probe
+        virtual const wordRes& fieldNames() const noexcept
+        {
+            return fieldSelection_;
+        }
+
+        //- Return locations to probe
+        virtual const pointField& probeLocations() const noexcept
+        {
+            return *this;
+        }
+
+        //- Return location for probe i
+        virtual const point& probe(const label i) const
+        {
+            return operator[](i);
+        }
+
+        //- Cells to be probed (obtained from the locations)
+        const labelList& elements() const noexcept
+        {
+            return elementList_;
+        }
+
+        //- Read the probes
         virtual bool read(const dictionary&);
+
+        //- Sample and store result if the sampleOnExecute is enabled.
+        virtual bool execute();
+
+        //- Sample and write
+        virtual bool write();
+
+        //- Update for changes of mesh
+        virtual void updateMesh(const mapPolyMesh&);
+
+        //- Update for changes of mesh
+        virtual void movePoints(const polyMesh&);
+
+        //- Update for changes of mesh due to readUpdate
+        virtual void readUpdate(const polyMesh::readUpdateState state)
+        {}
+
+
+    // Sampling
+
+        //- Sample a volume field at all locations
+        template<class Type>
+        tmp<Field<Type>> sample(const VolumeField<Type>&) const;
+
+        //- Sample a surface field at all locations
+        template<class Type>
+        tmp<Field<Type>> sample(const SurfaceField<Type>&) const;
+
+        //- Sample a volume field at all locations
+        template<class Type>
+        tmp<Field<Type>> sample(const word& fieldName) const;
+
+        //- Sample a surface field at all locations
+        template<class Type>
+        tmp<Field<Type>> sampleSurfaceField(const word& fieldName) const;
 };
 
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+    #include "probesTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 #endif
 
 // ************************************************************************* //

src/sampling/probes/probesTemplates.C

@@ -0,0 +1,274 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2017-2023 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "probes.H"
+#include "volFields.H"
+#include "surfaceFields.H"
+#include "IOmanip.H"
+#include "interpolation.H"
+#include "SpanStream.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+template<class T>
+struct isNotEqOp
+{
+    void operator()(T& x, const T& y) const
+    {
+        const T unsetVal(-VGREAT*pTraits<T>::one);
+
+        if (x != unsetVal)
+        {
+            // Keep x.
+
+            // Note: should check for y != unsetVal but multiple sample cells
+            // already handled in read().
+        }
+        else
+        {
+            // x is not set. y might be.
+            x = y;
+        }
+    }
+};
+
+} // End namespace Foam
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+template<class GeoField>
+Foam::tmp<GeoField>
+Foam::probes::getOrLoadField(const word& fieldName) const
+{
+    tmp<GeoField> tfield;
+
+    if (loadFromFiles_)
+    {
+        tfield.emplace
+        (
+            IOobject
+            (
+                fieldName,
+                mesh_.time().timeName(),
+                mesh_.thisDb(),
+                IOobjectOption::MUST_READ,
+                IOobjectOption::NO_WRITE,
+                IOobjectOption::NO_REGISTER
+            ),
+            mesh_
+        );
+    }
+    else
+    {
+        tfield.cref(mesh_.cfindObject<GeoField>(fieldName));
+    }
+
+    return tfield;
+}
+
+
+template<class Type>
+void Foam::probes::storeResults
+(
+    const word& fieldName,
+    const Field<Type>& values
+)
+{
+    const MinMax<Type> limits(values);
+    const Type avgVal = average(values);
+
+    this->setResult("average(" + fieldName + ")", avgVal);
+    this->setResult("min(" + fieldName + ")", limits.min());
+    this->setResult("max(" + fieldName + ")", limits.max());
+    this->setResult("size(" + fieldName + ")", values.size());
+
+    if (verbose_)
+    {
+        Info<< name() << " : " << fieldName << nl
+            << "    avg: " << avgVal << nl
+            << "    min: " << limits.min() << nl
+            << "    max: " << limits.max() << nl << nl;
+    }
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Type>
+void Foam::probes::writeValues
+(
+    const word& fieldName,
+    const Field<Type>& values,
+    const scalar timeValue
+)
+{
+    if (Pstream::master())
+    {
+        const unsigned int width(IOstream::defaultPrecision() + 7);
+        OFstream& os = *probeFilePtrs_[fieldName];
+
+        os  << setw(width) << timeValue;
+
+        OCharStream buf;
+
+        forAll(values, probei)
+        {
+            if (includeOutOfBounds_ || processor_[probei] != -1)
+            {
+                buf.rewind();
+                buf << values[probei];
+                os  << ' ' << setw(width) << buf.str().data();
+            }
+        }
+        os  << endl;
+    }
+}
+
+
+template<class GeoField>
+void Foam::probes::performAction
+(
+    const fieldGroup<GeoField>& fieldNames,
+    unsigned request
+)
+{
+    for (const word& fieldName : fieldNames)
+    {
+        tmp<GeoField> tfield = getOrLoadField<GeoField>(fieldName);
+
+        if (tfield)
+        {
+            const auto& field = tfield();
+            const scalar timeValue = field.time().timeOutputValue();
+
+            Field<typename GeoField::value_type> values(sample(field));
+
+            this->storeResults(fieldName, values);
+            if (request & ACTION_WRITE)
+            {
+                this->writeValues(fieldName, values, timeValue);
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::tmp<Foam::Field<Type>>
+Foam::probes::sample(const VolumeField<Type>& vField) const
+{
+    const Type unsetVal(-VGREAT*pTraits<Type>::one);
+
+    auto tvalues = tmp<Field<Type>>::New(Field<Type>(this->size(), unsetVal));
+    auto& values = tvalues.ref();
+
+    if (fixedLocations_)
+    {
+        autoPtr<interpolation<Type>> interpPtr
+        (
+            interpolation<Type>::New(samplePointScheme_, vField)
+        );
+
+        forAll(*this, probei)
+        {
+            if (elementList_[probei] >= 0)
+            {
+                const vector& position = operator[](probei);
+
+                values[probei] = interpPtr().interpolate
+                (
+                    position,
+                    elementList_[probei],
+                    -1
+                );
+            }
+        }
+    }
+    else
+    {
+        forAll(*this, probei)
+        {
+            if (elementList_[probei] >= 0)
+            {
+                values[probei] = vField[elementList_[probei]];
+            }
+        }
+    }
+
+    Pstream::listCombineReduce(values, isNotEqOp<Type>());
+
+    return tvalues;
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type>>
+Foam::probes::sample(const SurfaceField<Type>& sField) const
+{
+    const Type unsetVal(-VGREAT*pTraits<Type>::one);
+
+    auto tvalues = tmp<Field<Type>>::New(Field<Type>(this->size(), unsetVal));
+    auto& values = tvalues.ref();
+
+    forAll(*this, probei)
+    {
+        if (faceList_[probei] >= 0)
+        {
+            values[probei] = sField[faceList_[probei]];
+        }
+    }
+
+    Pstream::listCombineReduce(values, isNotEqOp<Type>());
+
+    return tvalues;
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type>>
+Foam::probes::sample(const word& fieldName) const
+{
+    return sample(mesh_.lookupObject<VolumeField<Type>>(fieldName));
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type>>
+Foam::probes::sampleSurfaceField(const word& fieldName) const
+{
+    return sample(mesh_.lookupObject<SurfaceField<Type>>(fieldName));
+}
+
+
+// ************************************************************************* //

src/thermophysicalModels/radiation/radiationModels/radiationModel/radiationModel.H

@@ -243,9 +243,6 @@ public:
             //- Return access to the temperature field
             const volScalarField& T() const noexcept { return T_; }
 
-            //- Return the radiation solver frequency
-            label solverFreq() const noexcept { return solverFreq_; }
-
             //- Source term component (for power of T^4)
             virtual tmp<volScalarField> Rp() const = 0;
 

tutorials/incompressible/pimpleFoam/laminar/mixerVesselAMI2D/mixerVesselAMI2D/system/blockMeshDict.m4

@@ -788,9 +788,14 @@ boundary
 
     AMI1
     {
+        cacheSize       360;
+
         type            cyclicAMI;
         neighbourPatch  AMI2;
         transform       noOrdering;
+        rotationCentre  (0 0 0);
+        rotationAxis    (0 0 1);
+
 /* optional
         surface
         {
@@ -815,9 +820,13 @@ boundary
 
     AMI2
     {
+        cacheSize       360;
+
         type            cyclicAMI;
         neighbourPatch  AMI1;
         transform       noOrdering;
+        rotationCentre  (0 0 0);
+        rotationAxis    (0 0 1);
 /* optional
         surface
         {