From 4d7180ae7c87bc992fe52fd38f375ed050f9b6ae Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@esi-group.com>
Date: Thu, 2 Feb 2023 14:15:24 +0100
Subject: [PATCH 01/11] COMP: rename field methods clamp() -> clamp_range()

- this is slightly longer to write (but consistent with clamp_min
  etc). The main reason is that this allows easier use of the clamp()
  free function.

STYLE: skip checks for bad/invalid clamping ranges

- ranges are either already validated before calling, the caller logic
  has already made the branching decision.
---
 applications/test/minMax2/Test-minMax2.C      | 11 ++-
 .../FieldFields/FieldField/FieldField.C       | 64 +++++++-------
 .../FieldFields/FieldField/FieldField.H       | 16 ++--
 src/OpenFOAM/fields/Fields/Field/Field.C      | 41 +++++----
 src/OpenFOAM/fields/Fields/Field/Field.H      | 16 ++--
 .../fields/Fields/Field/FieldFunctions.C      | 26 +++---
 .../GeometricField/GeometricField.C           | 88 +++++++++----------
 .../GeometricField/GeometricField.H           | 56 ++++++------
 8 files changed, 158 insertions(+), 160 deletions(-)

diff --git a/applications/test/minMax2/Test-minMax2.C b/applications/test/minMax2/Test-minMax2.C
index 201b0548d6..531235e6f5 100644
--- a/applications/test/minMax2/Test-minMax2.C
+++ b/applications/test/minMax2/Test-minMax2.C
@@ -162,9 +162,16 @@ int main(int argc, char *argv[])
 
         Info<< "result: " << result << nl;
 
-        someField.clamp(zero_one{});
-
+        someField.clamp_range(zero_one{});
         Info<< "inplace: " << someField << nl;
+
+        scalar val(1.414);
+
+        Info<< "clamp " << val
+            // nope << " : " << clamp(val, zero_one{})
+            // nope << " : " << clamp(val, scalarMinMax(zero_one{}))
+            << " : " << clamp(val, 0, 1)
+            << nl;
     }
 
     Info<< nl << "\nDone\n" << endl;
diff --git a/src/OpenFOAM/fields/FieldFields/FieldField/FieldField.C b/src/OpenFOAM/fields/FieldFields/FieldField/FieldField.C
index 5566474746..17d07fb2f0 100644
--- a/src/OpenFOAM/fields/FieldFields/FieldField/FieldField.C
+++ b/src/OpenFOAM/fields/FieldFields/FieldField/FieldField.C
@@ -282,39 +282,6 @@ void FieldField<Field, Type>::replace
 }
 
 
-template<template<class> class Field, class Type>
-void FieldField<Field, Type>::clamp
-(
-    const Type& lower,
-    const Type& upper
-)
-{
-    if (lower < upper)
-    {
-        for (auto& ff : *this)
-        {
-            ff.clamp(lower, upper);
-        }
-    }
-}
-
-
-template<template<class> class Field, class Type>
-void FieldField<Field, Type>::clamp
-(
-    const MinMax<Type>& range
-)
-{
-    if (range.min() < range.max())
-    {
-        for (auto& ff : *this)
-        {
-            ff.clamp(range.min(), range.max());
-        }
-    }
-}
-
-
 template<template<class> class Field, class Type>
 void FieldField<Field, Type>::clamp_min
 (
@@ -341,6 +308,37 @@ void FieldField<Field, Type>::clamp_max
 }
 
 
+template<template<class> class Field, class Type>
+void FieldField<Field, Type>::clamp_range
+(
+    const Type& lower,
+    const Type& upper
+)
+{
+    // Note: no checks for bad/invalid clamping ranges
+
+    for (auto& ff : *this)
+    {
+        ff.clamp_range(lower, upper);
+    }
+}
+
+
+template<template<class> class Field, class Type>
+void FieldField<Field, Type>::clamp_range
+(
+    const MinMax<Type>& range
+)
+{
+    // Note: no checks for bad/invalid clamping ranges
+
+    for (auto& ff : *this)
+    {
+        ff.clamp_range(range.min(), range.max());
+    }
+}
+
+
 template<template<class> class Field, class Type>
 tmp<FieldField<Field, Type>> FieldField<Field, Type>::T() const
 {
diff --git a/src/OpenFOAM/fields/FieldFields/FieldField/FieldField.H b/src/OpenFOAM/fields/FieldFields/FieldField/FieldField.H
index 11504cbe79..d8dbbcdf0e 100644
--- a/src/OpenFOAM/fields/FieldFields/FieldField/FieldField.H
+++ b/src/OpenFOAM/fields/FieldFields/FieldField/FieldField.H
@@ -149,20 +149,20 @@ public:
         //- Replace a component field of the field
         void replace(const direction, const cmptType&);
 
-        //- Clamp field values (in-place) to the specified range.
-        //  A no-op for an invalid range.
-        void clamp(const Type& lower, const Type& upper);
-
-        //- Clamp field values (in-place) to the specified range.
-        //  A no-op for an invalid range.
-        void clamp(const MinMax<Type>& range);
-
         //- Impose lower (floor) clamp on the field values (in-place)
         void clamp_min(const Type& lower);
 
         //- Impose upper (ceiling) clamp on the field values (in-place)
         void clamp_max(const Type& upper);
 
+        //- Clamp field values (in-place) to the specified range.
+        //  Does not check if range is valid or not.
+        void clamp_range(const Type& lower, const Type& upper);
+
+        //- Clamp field values (in-place) to the specified range.
+        //  Does not check if range is valid or not.
+        void clamp_range(const MinMax<Type>& range);
+
         //- Return the field transpose (only defined for second rank tensors)
         tmp<FieldField<Field, Type>> T() const;
 
diff --git a/src/OpenFOAM/fields/Fields/Field/Field.C b/src/OpenFOAM/fields/Fields/Field/Field.C
index fad7a81541..64dc2d73a3 100644
--- a/src/OpenFOAM/fields/Fields/Field/Field.C
+++ b/src/OpenFOAM/fields/Fields/Field/Field.C
@@ -658,27 +658,6 @@ void Foam::Field<Type>::replace
 }
 
 
-template<class Type>
-void Foam::Field<Type>::clamp(const Type& lower, const Type& upper)
-{
-    // Use free functions min(), max() to impose component-wise clamping
-    if (lower < upper)
-    {
-        // std::for_each
-        for (auto& val : *this)
-        {
-            val = min(max(val, lower), upper);
-        }
-    }
-}
-
-template<class Type>
-void Foam::Field<Type>::clamp(const MinMax<Type>& range)
-{
-    clamp(range.min(), range.max());
-}
-
-
 template<class Type>
 void Foam::Field<Type>::clamp_min(const Type& lower)
 {
@@ -702,6 +681,26 @@ void Foam::Field<Type>::clamp_max(const Type& upper)
 }
 
 
+template<class Type>
+void Foam::Field<Type>::clamp_range(const Type& lower, const Type& upper)
+{
+    // Note: no checks for bad/invalid clamping ranges
+
+    // Use free functions min(), max() to impose component-wise clamping
+    // std::for_each
+    for (auto& val : *this)
+    {
+        val = min(max(val, lower), upper);
+    }
+}
+
+template<class Type>
+void Foam::Field<Type>::clamp_range(const MinMax<Type>& range)
+{
+    Field<Type>::clamp_range(range.min(), range.max());
+}
+
+
 template<class Type>
 template<class VSForm>
 VSForm Foam::Field<Type>::block(const label start) const
diff --git a/src/OpenFOAM/fields/Fields/Field/Field.H b/src/OpenFOAM/fields/Fields/Field/Field.H
index f398928d1a..0f5d81237f 100644
--- a/src/OpenFOAM/fields/Fields/Field/Field.H
+++ b/src/OpenFOAM/fields/Fields/Field/Field.H
@@ -434,20 +434,20 @@ public:
         //- Replace a component field of the field
         void replace(const direction, const cmptType&);
 
-        //- Clamp field values (in-place) to the specified range.
-        //  A no-op for an invalid range.
-        void clamp(const Type& lower, const Type& upper);
-
-        //- Clamp field values (in-place) to the specified range.
-        //  A no-op for an invalid range.
-        void clamp(const MinMax<Type>& range);
-
         //- Impose lower (floor) clamp on the field values (in-place)
         void clamp_min(const Type& lower);
 
         //- Impose upper (ceiling) clamp on the field values (in-place)
         void clamp_max(const Type& upper);
 
+        //- Clamp field values (in-place) to the specified range.
+        //  Does not check if range is valid or not.
+        void clamp_range(const Type& lower, const Type& upper);
+
+        //- Clamp field values (in-place) to the specified range.
+        //  Does not check if range is valid or not.
+        void clamp_range(const MinMax<Type>& range);
+
         template<class VSForm>
         VSForm block(const label start) const;
 
diff --git a/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C b/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
index bfcc7860d3..d3576ac210 100644
--- a/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
+++ b/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
@@ -664,28 +664,22 @@ void clamp
     const MinMax<Type>& range
 )
 {
+    // Note: no checks for bad/invalid clamping ranges
+
     if (result.cdata() == f1.cdata())
     {
         // Apply in-place
-        result.clamp(range);
+        result.clamp_range(range);
     }
     else
     {
-        if (range.good())
-        {
-            std::transform
-            (
-                f1.cbegin(),
-                f1.cbegin(result.size()),
-                result.begin(),
-                clampOp<Type>(range)
-            );
-        }
-        else
-        {
-            // No clamping
-            std::copy(f1.cbegin(), f1.cbegin(result.size()), result.begin());
-        }
+        std::transform
+        (
+            f1.cbegin(),
+            f1.cbegin(result.size()),
+            result.begin(),
+            clampOp<Type>(range)
+        );
     }
 }
 
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.C b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.C
index 0f39b3f116..af2ef82dd9 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.C
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.C
@@ -1249,50 +1249,6 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::replace
 }
 
 
-template<class Type, template<class> class PatchField, class GeoMesh>
-void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp
-(
-    const Type& lower,
-    const Type& upper
-)
-{
-    primitiveFieldRef().clamp(lower, upper);
-    boundaryFieldRef().clamp(lower, upper);
-}
-
-
-template<class Type, template<class> class PatchField, class GeoMesh>
-void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp
-(
-    const MinMax<Type>& range
-)
-{
-    primitiveFieldRef().clamp(range.min(), range.max());
-    boundaryFieldRef().clamp(range.min(), range.max());
-}
-
-
-template<class Type, template<class> class PatchField, class GeoMesh>
-void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp
-(
-    const dimensioned<Type>& lower,
-    const dimensioned<Type>& upper
-)
-{
-    this->clamp(lower.value(), upper.value());
-}
-
-
-template<class Type, template<class> class PatchField, class GeoMesh>
-void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp
-(
-    const dimensioned<MinMax<Type>>& range
-)
-{
-    this->clamp(range.value());
-}
-
-
 template<class Type, template<class> class PatchField, class GeoMesh>
 void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp_min
 (
@@ -1335,6 +1291,50 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp_max
 }
 
 
+template<class Type, template<class> class PatchField, class GeoMesh>
+void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp_range
+(
+    const Type& lower,
+    const Type& upper
+)
+{
+    primitiveFieldRef().clamp_range(lower, upper);
+    boundaryFieldRef().clamp_range(lower, upper);
+}
+
+
+template<class Type, template<class> class PatchField, class GeoMesh>
+void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp_range
+(
+    const MinMax<Type>& range
+)
+{
+    primitiveFieldRef().clamp_range(range.min(), range.max());
+    boundaryFieldRef().clamp_range(range.min(), range.max());
+}
+
+
+template<class Type, template<class> class PatchField, class GeoMesh>
+void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp_range
+(
+    const dimensioned<Type>& lower,
+    const dimensioned<Type>& upper
+)
+{
+    this->clamp_range(lower.value(), upper.value());
+}
+
+
+template<class Type, template<class> class PatchField, class GeoMesh>
+void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp_range
+(
+    const dimensioned<MinMax<Type>>& range
+)
+{
+    this->clamp_range(range.value());
+}
+
+
 template<class Type, template<class> class PatchField, class GeoMesh>
 void Foam::GeometricField<Type, PatchField, GeoMesh>::negate()
 {
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.H b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.H
index cf4a09c683..d7fffa0d23 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.H
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.H
@@ -629,26 +629,6 @@ public:
             const dimensioned<cmptType>& ds
         );
 
-        //- Clamp field values (in-place) to the specified range.
-        //  A no-op for an invalid range.
-        void clamp(const Type& lower, const Type& upper);
-
-        //- Clamp field values (in-place) to the specified range.
-        //  A no-op for an invalid range.
-        void clamp(const MinMax<Type>& range);
-
-        //- Clamp field values (in-place) to the specified range.
-        //  A no-op for an invalid range. No dimension checking.
-        void clamp
-        (
-            const dimensioned<Type>& lower,
-            const dimensioned<Type>& upper
-        );
-
-        //- Clamp field values (in-place) to the specified range.
-        //  A no-op for an invalid range. No dimension checking.
-        void clamp(const dimensioned<MinMax<Type>>& range);
-
         //- Impose lower (floor) clamp on the field values (in-place)
         void clamp_min(const Type& lower);
 
@@ -663,6 +643,26 @@ public:
         //  No dimension checking
         void clamp_max(const dimensioned<Type>& upper);
 
+        //- Clamp field values (in-place) to the specified range.
+        //  Does not check if range is valid or not. No dimension checking.
+        void clamp_range(const dimensioned<MinMax<Type>>& range);
+
+        //- Clamp field values (in-place) to the specified range.
+        //  Does not check if range is valid or not.
+        void clamp_range(const Type& lower, const Type& upper);
+
+        //- Clamp field values (in-place) to the specified range.
+        //  Does not check if range is valid or not.
+        void clamp_range(const MinMax<Type>& range);
+
+        //- Clamp field values (in-place) to the specified range.
+        //  Does not check if range is valid or not. No dimension checking.
+        void clamp_range
+        (
+            const dimensioned<Type>& lower,
+            const dimensioned<Type>& upper
+        );
+
 
     // Member Operators
 
@@ -715,17 +715,17 @@ public:
     // Housekeeping
 
         //- Clamp field values (in-place) to the specified range.
-        //  \deprecated(2023-01) prefer clamp() naming
+        //  \deprecated(2023-01) prefer clamp_range() naming
         void clip(const dimensioned<MinMax<Type>>& range)
         {
-            this->clamp(range);
+            this->clamp_range(range);
         }
 
         //- Clamp field values (in-place) to the specified range.
-        //  \deprecated(2023-01) prefer clamp() naming
+        //  \deprecated(2023-01) prefer clamp_range() naming
         void clip(const dimensioned<Type>& lo, const dimensioned<Type>& hi)
         {
-            this->clamp(lo.value(), hi.value());
+            this->clamp_range(lo.value(), hi.value());
         }
 
         //- Use minimum of the field and specified value. ie, clamp_max().
@@ -738,12 +738,12 @@ public:
         //  \deprecated(2023-01) prefer clamp_min()
         void max(const dimensioned<Type>& lower) { this->clamp_min(lower); }
 
-        //- Deprecated(2019-01) identical to clamp()
-        //  \deprecated(2019-01) identical to clamp()
-        FOAM_DEPRECATED_FOR(2019-01, "clamp() method")
+        //- Deprecated(2019-01) identical to clamp_range()
+        //  \deprecated(2019-01) identical to clamp_range()
+        FOAM_DEPRECATED_FOR(2019-01, "clamp_range() method")
         void maxMin(const dimensioned<Type>& lo, const dimensioned<Type>& hi)
         {
-            return this->clamp(lo.value(), hi.value());
+            return this->clamp_range(lo.value(), hi.value());
         }
 };
 

From 3d8a6a54331f64b212ed2c96bab6ca23169f1c26 Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@esi-group.com>
Date: Fri, 20 Jan 2023 09:48:40 +0100
Subject: [PATCH 02/11] ENH: use GeometricField clamp_min, clamp_max,
 clamp_range

- newer naming allows for less confusing code.
  Eg,
      max(lower)  ->  clamp_min(lower)
      min(upper)  ->  clamp_max(upper)

- prefer combined method, for few operations.
  Eg,
      max(lower) + min(upper) -> clamp_range(lower, upper)

  The updated naming also helps avoid some obvious coding errors.
  Eg,

     Re.min(1200.0);
     Re.max(18800.0);

  instead of
     Re.clamp_range(1200.0, 18800.0);

- can also use implicit conversion of zero_one to MinMax<Type> for
  this type of code:

      lambda_.clamp_range(zero_one{});
---
 applications/solvers/combustion/XiFoam/bEqn.H |  5 +-
 .../solvers/combustion/fireFoam/YEEqn.H       |  4 +-
 .../solvers/combustion/reactingFoam/YEqn.H    |  4 +-
 .../chtMultiRegionFoam/fluid/YEqn.H           |  4 +-
 .../lagrangian/coalChemistryFoam/YEqn.H       |  4 +-
 .../lagrangian/reactingParcelFoam/YEqn.H      |  4 +-
 .../simpleReactingParcelFoam/YEqn.H           |  4 +-
 .../lagrangian/simpleCoalParcelFoam/YEqn.H    |  4 +-
 .../solvers/lagrangian/sprayFoam/YEqn.H       |  4 +-
 .../applyBoundaryLayer/applyBoundaryLayer.C   |  4 +-
 .../setTurbulenceFields/setTurbulenceFields.C | 10 +---
 .../LES/dynamicKEqn/dynamicKEqn.C             |  4 +-
 .../ReynoldsStress/ReynoldsStress.C           | 17 +++----
 .../relaxation/relaxation.C                   |  3 +-
 .../Poisson/PoissonPatchDistMethod.C          |  2 +-
 .../advectionDiffusionPatchDistMethod.C       |  2 +-
 src/functionObjects/field/comfort/comfort.C   | 16 ++++---
 .../field/limitFields/limitFields.C           | 46 +++++++++++++------
 .../field/limitFields/limitFields.H           | 15 +++---
 .../field/limitFields/limitFieldsTemplates.C  |  8 ++--
 .../stabilityBlendingFactor.C                 |  5 +-
 .../MultiComponentPhaseModel.C                |  2 +-
 .../ThermalPhaseChangePhaseSystem.C           |  4 +-
 .../TwoResistanceHeatTransferPhaseSystem.C    |  4 +-
 .../dragModels/IshiiZuber/IshiiZuber.C        |  2 +-
 .../liftModels/Moraga/Moraga.C                |  7 +--
 .../multiphaseSystem/multiphaseSystem.C       |  2 +-
 .../MultiComponentPhaseModel.C                |  4 +-
 .../kineticTheoryModel/kineticTheoryModel.C   |  6 +--
 .../twoPhaseSystem/twoPhaseSystem.C           |  2 +-
 .../kineticTheoryModel/kineticTheoryModel.C   |  6 +--
 .../dragModels/IshiiZuber/IshiiZuber.C        |  2 +-
 .../liftModels/Moraga/Moraga.C                |  7 +--
 .../twoPhaseSystem/twoPhaseSystem.C           |  3 +-
 .../filmTurbulenceModel/filmTurbulenceModel.C |  2 +-
 .../reactingOneDim/reactingOneDim.C           |  2 +-
 .../kinematicSingleLayer.C                    |  2 +-
 .../kinematicSingleLayerI.H                   |  2 +-
 .../filmTurbulenceModel/laminar/laminar.C     |  2 +-
 .../thixotropicViscosity.C                    |  6 +--
 .../waxSolventEvaporation.C                   |  3 +-
 .../thermoSingleLayer/thermoSingleLayer.C     | 19 +++++---
 .../thermoSingleLayer/thermoSingleLayer.H     | 29 ++++++++----
 .../thermoSingleLayer/thermoSingleLayerI.H    | 15 +++++-
 .../BilgerMixtureFraction.C                   |  6 +--
 45 files changed, 163 insertions(+), 145 deletions(-)

diff --git a/applications/solvers/combustion/XiFoam/bEqn.H b/applications/solvers/combustion/XiFoam/bEqn.H
index fda39d3f51..38740d0dd5 100644
--- a/applications/solvers/combustion/XiFoam/bEqn.H
+++ b/applications/solvers/combustion/XiFoam/bEqn.H
@@ -171,10 +171,7 @@ if (ign.ignited())
 
         fvOptions.correct(Su);
 
-        // Limit the maximum Su
-        // ~~~~~~~~~~~~~~~~~~~~
-        Su.min(SuMax);
-        Su.max(SuMin);
+        Su.clamp_range(SuMin, SuMax);
     }
     else
     {
diff --git a/applications/solvers/combustion/fireFoam/YEEqn.H b/applications/solvers/combustion/fireFoam/YEEqn.H
index 5176956acc..adc849bc2d 100644
--- a/applications/solvers/combustion/fireFoam/YEEqn.H
+++ b/applications/solvers/combustion/fireFoam/YEEqn.H
@@ -39,13 +39,13 @@ tmp<fv::convectionScheme<scalar>> mvConvection
 
             fvOptions.correct(Yi);
 
-            Yi.max(0.0);
+            Yi.clamp_min(0);
             Yt += Yi;
         }
     }
 
     Y[inertIndex] = scalar(1) - Yt;
-    Y[inertIndex].max(0.0);
+    Y[inertIndex].clamp_min(0);
 
     radiation->correct();
 
diff --git a/applications/solvers/combustion/reactingFoam/YEqn.H b/applications/solvers/combustion/reactingFoam/YEqn.H
index 4d209a3d81..ea8681628a 100644
--- a/applications/solvers/combustion/reactingFoam/YEqn.H
+++ b/applications/solvers/combustion/reactingFoam/YEqn.H
@@ -38,11 +38,11 @@ tmp<fv::convectionScheme<scalar>> mvConvection
 
             fvOptions.correct(Yi);
 
-            Yi.max(0.0);
+            Yi.clamp_min(0);
             Yt += Yi;
         }
     }
 
     Y[inertIndex] = scalar(1) - Yt;
-    Y[inertIndex].max(0.0);
+    Y[inertIndex].clamp_min(0);
 }
diff --git a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/YEqn.H b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/YEqn.H
index c32c1fdab2..b42c7986ab 100644
--- a/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/YEqn.H
+++ b/applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/YEqn.H
@@ -48,7 +48,7 @@ if (Y.size())
 
             fvOptions.correct(Yi);
 
-            Yi.max(0.0);
+            Yi.clamp_min(0);
             Yt += Yi;
         }
     }
@@ -56,6 +56,6 @@ if (Y.size())
     if (Y.size())
     {
         Y[inertIndex] = scalar(1) - Yt;
-        Y[inertIndex].max(0.0);
+        Y[inertIndex].clamp_min(0);
     }
 }
diff --git a/applications/solvers/lagrangian/coalChemistryFoam/YEqn.H b/applications/solvers/lagrangian/coalChemistryFoam/YEqn.H
index 49e3f70d89..f3cbb702a7 100644
--- a/applications/solvers/lagrangian/coalChemistryFoam/YEqn.H
+++ b/applications/solvers/lagrangian/coalChemistryFoam/YEqn.H
@@ -40,11 +40,11 @@ tmp<fv::convectionScheme<scalar>> mvConvection
 
             fvOptions.correct(Yi);
 
-            Yi.max(0.0);
+            Yi.clamp_min(0);
             Yt += Yi;
         }
     }
 
     Y[inertIndex] = scalar(1) - Yt;
-    Y[inertIndex].max(0.0);
+    Y[inertIndex].clamp_min(0);
 }
diff --git a/applications/solvers/lagrangian/reactingParcelFoam/YEqn.H b/applications/solvers/lagrangian/reactingParcelFoam/YEqn.H
index c7f9dbce34..ecbf120887 100644
--- a/applications/solvers/lagrangian/reactingParcelFoam/YEqn.H
+++ b/applications/solvers/lagrangian/reactingParcelFoam/YEqn.H
@@ -41,11 +41,11 @@ tmp<fv::convectionScheme<scalar>> mvConvection
 
             fvOptions.correct(Yi);
 
-            Yi.max(0.0);
+            Yi.clamp_min(0);
             Yt += Yi;
         }
     }
 
     Y[inertIndex] = scalar(1) - Yt;
-    Y[inertIndex].max(0.0);
+    Y[inertIndex].clamp_min(0);
 }
diff --git a/applications/solvers/lagrangian/reactingParcelFoam/simpleReactingParcelFoam/YEqn.H b/applications/solvers/lagrangian/reactingParcelFoam/simpleReactingParcelFoam/YEqn.H
index 1510f8e391..db2d6c9b9c 100644
--- a/applications/solvers/lagrangian/reactingParcelFoam/simpleReactingParcelFoam/YEqn.H
+++ b/applications/solvers/lagrangian/reactingParcelFoam/simpleReactingParcelFoam/YEqn.H
@@ -38,11 +38,11 @@ tmp<fv::convectionScheme<scalar>> mvConvection
 
             fvOptions.correct(Yi);
 
-            Yi.max(0.0);
+            Yi.clamp_min(0);
             Yt += Yi;
         }
     }
 
     Y[inertIndex] = scalar(1) - Yt;
-    Y[inertIndex].max(0.0);
+    Y[inertIndex].clamp_min(0);
 }
diff --git a/applications/solvers/lagrangian/simpleCoalParcelFoam/YEqn.H b/applications/solvers/lagrangian/simpleCoalParcelFoam/YEqn.H
index c81ac66c8b..a6f70bf4f2 100644
--- a/applications/solvers/lagrangian/simpleCoalParcelFoam/YEqn.H
+++ b/applications/solvers/lagrangian/simpleCoalParcelFoam/YEqn.H
@@ -38,11 +38,11 @@ tmp<fv::convectionScheme<scalar>> mvConvection
 
             fvOptions.correct(Yi);
 
-            Yi.max(0.0);
+            Yi.clamp_min(0);
             Yt += Yi;
         }
     }
 
     Y[inertIndex] = scalar(1) - Yt;
-    Y[inertIndex].max(0.0);
+    Y[inertIndex].clamp_min(0);
 }
diff --git a/applications/solvers/lagrangian/sprayFoam/YEqn.H b/applications/solvers/lagrangian/sprayFoam/YEqn.H
index 60a27fec85..e80f884202 100644
--- a/applications/solvers/lagrangian/sprayFoam/YEqn.H
+++ b/applications/solvers/lagrangian/sprayFoam/YEqn.H
@@ -39,11 +39,11 @@ tmp<fv::convectionScheme<scalar>> mvConvection
 
             fvOptions.correct(Yi);
 
-            Yi.max(0.0);
+            Yi.clamp_min(0);
             Yt += Yi;
         }
     }
 
     Y[inertIndex] = scalar(1) - Yt;
-    Y[inertIndex].max(0.0);
+    Y[inertIndex].clamp_min(0);
 }
diff --git a/applications/utilities/preProcessing/applyBoundaryLayer/applyBoundaryLayer.C b/applications/utilities/preProcessing/applyBoundaryLayer/applyBoundaryLayer.C
index 63f0e514ff..c072c06826 100644
--- a/applications/utilities/preProcessing/applyBoundaryLayer/applyBoundaryLayer.C
+++ b/applications/utilities/preProcessing/applyBoundaryLayer/applyBoundaryLayer.C
@@ -92,7 +92,7 @@ void blendField
         volScalarField fld(fieldHeader, mesh);
         scalarField& pf = fld.primitiveFieldRef();
         pf = (1 - mask)*pf + mask*boundaryLayerField;
-        fld.max(SMALL);
+        fld.clamp_min(SMALL);
 
         // Correct the processor patches only.
         // Do not correct BC
@@ -131,7 +131,7 @@ void calcOmegaField
         scalarField& pf = omega.primitiveFieldRef();
 
         pf = (1 - mask)*pf + mask*epsilonBL/(Cmu*kBL + SMALL);
-        omega.max(SMALL);
+        omega.clamp_min(SMALL);
 
         // Correct the processor patches only.
         // Do not correct BC
diff --git a/applications/utilities/preProcessing/setTurbulenceFields/setTurbulenceFields.C b/applications/utilities/preProcessing/setTurbulenceFields/setTurbulenceFields.C
index 06481f514a..71d945503a 100644
--- a/applications/utilities/preProcessing/setTurbulenceFields/setTurbulenceFields.C
+++ b/applications/utilities/preProcessing/setTurbulenceFields/setTurbulenceFields.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2022 OpenCFD Ltd.
+    Copyright (C) 2022-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -241,13 +241,7 @@ void calcF
     solve(fEqn);
 
     // (M:p. 2)
-    const dimensioned<scalarMinMax> fMinMax
-    (
-        dimless,
-        scalarMinMax(Zero, scalar(1) - Foam::exp(-scalar(400)/scalar(50)))
-    );
-
-    f.clip(fMinMax);
+    f.clamp_range(0, scalar(1) - Foam::exp(-scalar(400)/scalar(50)));
 }
 
 
diff --git a/src/TurbulenceModels/turbulenceModels/LES/dynamicKEqn/dynamicKEqn.C b/src/TurbulenceModels/turbulenceModels/LES/dynamicKEqn/dynamicKEqn.C
index 5b173b01aa..bdfc9ef03a 100644
--- a/src/TurbulenceModels/turbulenceModels/LES/dynamicKEqn/dynamicKEqn.C
+++ b/src/TurbulenceModels/turbulenceModels/LES/dynamicKEqn/dynamicKEqn.C
@@ -102,7 +102,7 @@ volScalarField dynamicKEqn<BasicTurbulenceModel>::Ce() const
     (
         0.5*(filter_(magSqr(this->U_)) - magSqr(filter_(this->U_)))
     );
-    KK.max(dimensionedScalar("small", KK.dimensions(), SMALL));
+    KK.clamp_min(SMALL);
 
     return Ce(D, KK);
 }
@@ -245,7 +245,7 @@ void dynamicKEqn<BasicTurbulenceModel>::correct()
     tgradU.clear();
 
     volScalarField KK(0.5*(filter_(magSqr(U)) - magSqr(filter_(U))));
-    KK.max(dimensionedScalar("small", KK.dimensions(), SMALL));
+    KK.clamp_min(SMALL);
 
     tmp<fvScalarMatrix> kEqn
     (
diff --git a/src/TurbulenceModels/turbulenceModels/ReynoldsStress/ReynoldsStress.C b/src/TurbulenceModels/turbulenceModels/ReynoldsStress/ReynoldsStress.C
index d1e785e409..b71be0e31f 100644
--- a/src/TurbulenceModels/turbulenceModels/ReynoldsStress/ReynoldsStress.C
+++ b/src/TurbulenceModels/turbulenceModels/ReynoldsStress/ReynoldsStress.C
@@ -39,20 +39,15 @@ void Foam::ReynoldsStress<BasicTurbulenceModel>::boundNormalStress
     volSymmTensorField& R
 ) const
 {
-    scalar kMin = this->kMin_.value();
+    const scalar kMin = this->kMin_.value();
 
-    R.max
+    R.clamp_min
     (
-        dimensionedSymmTensor
+        symmTensor
         (
-            "zero",
-            R.dimensions(),
-            symmTensor
-            (
-                kMin, -GREAT, -GREAT,
-                kMin, -GREAT,
-                kMin
-            )
+            kMin, -GREAT, -GREAT,
+            kMin, -GREAT,
+            kMin
         )
     );
 }
diff --git a/src/combustionModels/FSD/reactionRateFlameAreaModels/relaxation/relaxation.C b/src/combustionModels/FSD/reactionRateFlameAreaModels/relaxation/relaxation.C
index eea9d2fc7a..10df906bd5 100644
--- a/src/combustionModels/FSD/reactionRateFlameAreaModels/relaxation/relaxation.C
+++ b/src/combustionModels/FSD/reactionRateFlameAreaModels/relaxation/relaxation.C
@@ -136,8 +136,7 @@ void Foam::reactionRateFlameAreaModels::relaxation::correct
        - fvm::SuSp(rho*(tau + Rc), omega_)
     );
 
-    omega_.min(omega0);
-    omega_.max(0.0);
+    omega_.clamp_range(0, omega0.value());
 }
 
 
diff --git a/src/finiteVolume/fvMesh/wallDist/patchDistMethods/Poisson/PoissonPatchDistMethod.C b/src/finiteVolume/fvMesh/wallDist/patchDistMethods/Poisson/PoissonPatchDistMethod.C
index 2e54d2d5cb..5984f960c7 100644
--- a/src/finiteVolume/fvMesh/wallDist/patchDistMethods/Poisson/PoissonPatchDistMethod.C
+++ b/src/finiteVolume/fvMesh/wallDist/patchDistMethods/Poisson/PoissonPatchDistMethod.C
@@ -120,7 +120,7 @@ bool Foam::patchDistMethods::Poisson::correct
     // Need to stabilise the y for overset meshes since the holed cells
     // keep the initial value (0.0) so the gradient of that will be
     // zero as well. Turbulence models do not like zero wall distance.
-    y.max(SMALL);
+    y.clamp_min(SMALL);
 
     // For overset: enforce smooth y field (yPsi is smooth, magGradyPsi is
     // not)
diff --git a/src/finiteVolume/fvMesh/wallDist/patchDistMethods/advectionDiffusion/advectionDiffusionPatchDistMethod.C b/src/finiteVolume/fvMesh/wallDist/patchDistMethods/advectionDiffusion/advectionDiffusionPatchDistMethod.C
index be028a323c..4a78d65e05 100644
--- a/src/finiteVolume/fvMesh/wallDist/patchDistMethods/advectionDiffusion/advectionDiffusionPatchDistMethod.C
+++ b/src/finiteVolume/fvMesh/wallDist/patchDistMethods/advectionDiffusion/advectionDiffusionPatchDistMethod.C
@@ -153,7 +153,7 @@ bool Foam::patchDistMethods::advectionDiffusion::correct
     // Need to stabilise the y for overset meshes since the holed cells
     // keep the initial value (0.0) so the gradient of that will be
     // zero as well. Turbulence models do not like zero wall distance.
-    y.max(SMALL);
+    y.clamp_min(SMALL);
 
     // Only calculate n if the field is defined
     if (notNull(n))
diff --git a/src/functionObjects/field/comfort/comfort.C b/src/functionObjects/field/comfort/comfort.C
index 2952500de8..ed0d465e5c 100644
--- a/src/functionObjects/field/comfort/comfort.C
+++ b/src/functionObjects/field/comfort/comfort.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2019 OpenFOAM Foundation
-    Copyright (C) 2021 OpenCFD Ltd.
+    Copyright (C) 2021-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -41,6 +41,11 @@ namespace functionObjects
 }
 }
 
+
+// Temperature bounds based on EN ISO 7730 (10 - 40 degC)
+static const Foam::scalarMinMax Tbounds(283.15, 313.15);
+
+
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 Foam::tmp<Foam::volScalarField> Foam::functionObjects::comfort::magU() const
@@ -93,7 +98,7 @@ Foam::dimensionedScalar Foam::functionObjects::comfort::Trad() const
     }
 
     // Bounds based on EN ISO 7730
-    if ((Trad.value() < 283.15) || (Trad.value() > 313.15))
+    if (!Tbounds.contains(Trad.value()))
     {
         WarningInFunction
             << "The calculated mean wall radiation temperature is out of the\n"
@@ -177,9 +182,6 @@ Foam::tmp<Foam::volScalarField> Foam::functionObjects::comfort::Tcloth
 
     Tcl.storePrevIter();
 
-    // Same temperatures as for the radiation
-    const dimensionedScalar Tmin(dimTemperature, 283.15);
-    const dimensionedScalar Tmax(dimTemperature, 313.15);
 
     // Iterative solving of equation (2)
     do
@@ -208,7 +210,7 @@ Foam::tmp<Foam::volScalarField> Foam::functionObjects::comfort::Tcloth
 
         // Make sure that Tcl is in some physical limit (same range as we used
         // for the radiative estimation - based on ISO EN 7730:2005)
-        Tcl.clip(Tmin, Tmax);
+        Tcl.clamp_range(Tbounds);
 
     } while (!converged(Tcl) && i++ < maxClothIter_);
 
@@ -422,7 +424,7 @@ bool Foam::functionObjects::comfort::execute()
 
     // Limit the velocity field to the values given in EN ISO 7733
     volScalarField Umag(mag(lookupObject<volVectorField>("U")));
-    Umag.clip(Umin, Umax);
+    Umag.clamp_range(Umin, Umax);
 
     // Calculate the turbulent intensity if turbulent kinetic energy field k
     // exists
diff --git a/src/functionObjects/field/limitFields/limitFields.C b/src/functionObjects/field/limitFields/limitFields.C
index c89d230848..c03eb37fcc 100644
--- a/src/functionObjects/field/limitFields/limitFields.C
+++ b/src/functionObjects/field/limitFields/limitFields.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2019 OpenCFD Ltd
+    Copyright (C) 2019-2023 OpenCFD Ltd
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -46,9 +46,10 @@ const Foam::Enum
 >
 Foam::functionObjects::limitFields::limitTypeNames_
 ({
-    { limitType::MIN, "min" },
-    { limitType::MAX, "max" },
-    { limitType::BOTH, "both" },
+    { limitType::CLAMP_MIN, "min" },
+    { limitType::CLAMP_MAX, "max" },
+    { limitType::CLAMP_RANGE, "range" },
+    { limitType::CLAMP_RANGE, "both" },
 });
 
 
@@ -67,16 +68,31 @@ bool Foam::functionObjects::limitFields::limitScalarField
 
     auto& field = *fieldPtr;
 
-    if (limit_ & MIN)
+    if (limitType::CLAMP_NONE != withBounds_)
     {
-        Log << ": min(" << gMin(field) << ")";
-        field.max(dimensionedScalar("", field.dimensions(), min_));
+        MinMax<scalar> currentRange = gMinMax(field);
+
+        if (withBounds_ & limitType::CLAMP_MIN)
+        {
+            Log << ": min(" << currentRange.min() << ')';
+        }
+        if (withBounds_ & limitType::CLAMP_MAX)
+        {
+            Log << ": max(" << currentRange.max() << ')';
+        }
     }
 
-    if (limit_ & MAX)
+    if (limitType::CLAMP_MIN == withBounds_)
     {
-        Log << ": max(" << gMax(field) << ")";
-        field.min(dimensionedScalar("", field.dimensions(), max_));
+        field.clamp_min(min_);
+    }
+    else if (limitType::CLAMP_MAX == withBounds_)
+    {
+        field.clamp_max(max_);
+    }
+    else if (limitType::CLAMP_RANGE == withBounds_)
+    {
+        field.clamp_range(min_, max_);
     }
 
     return true;
@@ -93,8 +109,8 @@ Foam::functionObjects::limitFields::limitFields
 )
 :
     fvMeshFunctionObject(name, runTime, dict),
-    limit_(MIN),
     fieldSet_(mesh_),
+    withBounds_(limitType::CLAMP_NONE),
     min_(-VGREAT),
     max_(VGREAT)
 {
@@ -106,19 +122,21 @@ Foam::functionObjects::limitFields::limitFields
 
 bool Foam::functionObjects::limitFields::read(const dictionary& dict)
 {
+    withBounds_ = limitType::CLAMP_NONE;
+
     if (fvMeshFunctionObject::read(dict))
     {
         Info<< type() << " " << name() << ":" << nl;
 
-        limit_ = limitTypeNames_.get("limit", dict);
+        withBounds_ = limitTypeNames_.get("limit", dict);
 
-        if (limit_ & MIN)
+        if (withBounds_ & limitType::CLAMP_MIN)
         {
             min_ = dict.get<scalar>("min");
             Info<< "    Imposing lower limit " << min_ << nl;
         }
 
-        if (limit_ & MAX)
+        if (withBounds_ & limitType::CLAMP_MAX)
         {
             max_ = dict.get<scalar>("max");
             Info<< "    Imposing upper limit " << max_ << nl;
diff --git a/src/functionObjects/field/limitFields/limitFields.H b/src/functionObjects/field/limitFields/limitFields.H
index d40324fe8b..405d2c4316 100644
--- a/src/functionObjects/field/limitFields/limitFields.H
+++ b/src/functionObjects/field/limitFields/limitFields.H
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2019-2020 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -127,9 +127,10 @@ public:
 
         enum limitType : unsigned
         {
-            MIN = 0x1,          //!< limit by minimum value
-            MAX = 0x2,          //!< limit by maximum value
-            BOTH = (MIN | MAX)  //!< limit by both minimum and maximum values
+            CLAMP_NONE = 0,     //!< No limit
+            CLAMP_MIN = 0x1,    //!< Clamp minimum value
+            CLAMP_MAX = 0x2,    //!< Clamp maximum value
+            CLAMP_RANGE = (CLAMP_MIN | CLAMP_MAX)  //!< Clamp min/max
         };
 
 
@@ -140,12 +141,12 @@ protected:
         //- Limit type names
         static const Enum<limitType> limitTypeNames_;
 
-        //- Limiting type
-        limitType limit_;
-
         //- Fields to limit
         volFieldSelection fieldSet_;
 
+        //- Limiting type
+        limitType withBounds_;
+
         //- Minimum limit
         scalar min_;
 
diff --git a/src/functionObjects/field/limitFields/limitFieldsTemplates.C b/src/functionObjects/field/limitFields/limitFieldsTemplates.C
index 3e1bc00483..0b20a6cbe2 100644
--- a/src/functionObjects/field/limitFields/limitFieldsTemplates.C
+++ b/src/functionObjects/field/limitFields/limitFieldsTemplates.C
@@ -47,23 +47,23 @@ bool Foam::functionObjects::limitFields::limitField(const word& fieldName)
 
     const dimensionedScalar eps("eps", field.dimensions(), ROOTVSMALL);
 
-    if (limit_ & MIN)
+    if (withBounds_ & limitType::CLAMP_MIN)
     {
         volScalarField mField(typeName + ":mag" + field.name(), mag(field));
         Log << " min(|" << gMin(mField) << "|)";
         //field.normalise();
         field /= mag(field) + eps;
-        mField.max(dimensionedScalar("min", field.dimensions(), min_));
+        mField.clamp_min(min_);
         field *= mField;
     }
 
-    if (limit_ & MAX)
+    if (withBounds_ & limitType::CLAMP_MAX)
     {
         volScalarField mField(typeName + ":mag" + field.name(), mag(field));
         Log << " max(|" << gMax(mField) << "|)";
         //field.normalise();
         field /= mag(field) + eps;
-        mField.min(dimensionedScalar("max", field.dimensions(), max_));
+        mField.clamp_max(max_);
         field *= mField;
     }
 
diff --git a/src/functionObjects/field/stabilityBlendingFactor/stabilityBlendingFactor.C b/src/functionObjects/field/stabilityBlendingFactor/stabilityBlendingFactor.C
index 827d882b79..8837f3784d 100644
--- a/src/functionObjects/field/stabilityBlendingFactor/stabilityBlendingFactor.C
+++ b/src/functionObjects/field/stabilityBlendingFactor/stabilityBlendingFactor.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -448,8 +448,7 @@ bool Foam::functionObjects::stabilityBlendingFactor::init(bool first)
     }
 
     indicator.correctBoundaryConditions();
-    indicator.min(1.0);
-    indicator.max(0.0);
+    indicator.clamp_range(zero_one{});
 
     // Update the blended surface field
     auto& surBlended = mesh_.lookupObjectRef<surfaceScalarField>(resultName_);
diff --git a/src/phaseSystemModels/multiphaseInter/phasesSystem/phaseModel/MultiComponentPhaseModel/MultiComponentPhaseModel.C b/src/phaseSystemModels/multiphaseInter/phasesSystem/phaseModel/MultiComponentPhaseModel/MultiComponentPhaseModel.C
index 3926d26730..1dca7f055c 100644
--- a/src/phaseSystemModels/multiphaseInter/phasesSystem/phaseModel/MultiComponentPhaseModel/MultiComponentPhaseModel.C
+++ b/src/phaseSystemModels/multiphaseInter/phasesSystem/phaseModel/MultiComponentPhaseModel/MultiComponentPhaseModel.C
@@ -428,7 +428,7 @@ void Foam::MultiComponentPhaseModel<BasePhaseModel, phaseThermo>::solveYi
     }
 
     X_[inertIndex_] = scalar(1) - Yt;
-    X_[inertIndex_].max(0.0);
+    X_[inertIndex_].clamp_min(0);
 
     calculateMassFractions();
 }
diff --git a/src/phaseSystemModels/reactingEuler/multiphaseSystem/PhaseSystems/ThermalPhaseChangePhaseSystem/ThermalPhaseChangePhaseSystem.C b/src/phaseSystemModels/reactingEuler/multiphaseSystem/PhaseSystems/ThermalPhaseChangePhaseSystem/ThermalPhaseChangePhaseSystem.C
index b91b656ae4..e3a2be4b9a 100644
--- a/src/phaseSystemModels/reactingEuler/multiphaseSystem/PhaseSystems/ThermalPhaseChangePhaseSystem/ThermalPhaseChangePhaseSystem.C
+++ b/src/phaseSystemModels/reactingEuler/multiphaseSystem/PhaseSystems/ThermalPhaseChangePhaseSystem/ThermalPhaseChangePhaseSystem.C
@@ -425,8 +425,8 @@ Foam::ThermalPhaseChangePhaseSystem<BasePhaseSystem>::correctInterfaceThermo()
         volScalarField H2(heatTransferModelIter().second()->K());
 
         // Limit the H[12] to avoid /0
-        H1.max(SMALL);
-        H2.max(SMALL);
+        H1.clamp_min(SMALL);
+        H2.clamp_min(SMALL);
 
         Tf = (H1*T1 + H2*T2 + iDmdtNew*L)/(H1 + H2);
 
diff --git a/src/phaseSystemModels/reactingEuler/multiphaseSystem/PhaseSystems/TwoResistanceHeatTransferPhaseSystem/TwoResistanceHeatTransferPhaseSystem.C b/src/phaseSystemModels/reactingEuler/multiphaseSystem/PhaseSystems/TwoResistanceHeatTransferPhaseSystem/TwoResistanceHeatTransferPhaseSystem.C
index d2e61843e3..c08c6601a2 100644
--- a/src/phaseSystemModels/reactingEuler/multiphaseSystem/PhaseSystems/TwoResistanceHeatTransferPhaseSystem/TwoResistanceHeatTransferPhaseSystem.C
+++ b/src/phaseSystemModels/reactingEuler/multiphaseSystem/PhaseSystems/TwoResistanceHeatTransferPhaseSystem/TwoResistanceHeatTransferPhaseSystem.C
@@ -297,8 +297,8 @@ correctInterfaceThermo()
         );
 
         // Limit the H[12] to avoid /0
-        H1.max(SMALL);
-        H2.max(SMALL);
+        H1.clamp_min(SMALL);
+        H2.clamp_min(SMALL);
 
         Tf = (H1*T1 + H2*T2 + dmdt*L)/(H1 + H2);
 
diff --git a/src/phaseSystemModels/reactingEuler/multiphaseSystem/interfacialModels/dragModels/IshiiZuber/IshiiZuber.C b/src/phaseSystemModels/reactingEuler/multiphaseSystem/interfacialModels/dragModels/IshiiZuber/IshiiZuber.C
index 8946f1093d..44f552f592 100644
--- a/src/phaseSystemModels/reactingEuler/multiphaseSystem/interfacialModels/dragModels/IshiiZuber/IshiiZuber.C
+++ b/src/phaseSystemModels/reactingEuler/multiphaseSystem/interfacialModels/dragModels/IshiiZuber/IshiiZuber.C
@@ -86,7 +86,7 @@ Foam::dragModels::IshiiZuber::CdRe() const
     );
 
     volScalarField F((muc/muMix)*sqrt(1 - pair_.dispersed()));
-    F.max(1e-3);
+    F.clamp_min(1e-3);
 
     const volScalarField Ealpha((1 + 17.67*pow(F, 0.8571428))/(18.67*F));
 
diff --git a/src/phaseSystemModels/reactingEuler/multiphaseSystem/interfacialModels/liftModels/Moraga/Moraga.C b/src/phaseSystemModels/reactingEuler/multiphaseSystem/interfacialModels/liftModels/Moraga/Moraga.C
index 97364b5fe8..ee0067f732 100644
--- a/src/phaseSystemModels/reactingEuler/multiphaseSystem/interfacialModels/liftModels/Moraga/Moraga.C
+++ b/src/phaseSystemModels/reactingEuler/multiphaseSystem/interfacialModels/liftModels/Moraga/Moraga.C
@@ -87,11 +87,8 @@ Foam::tmp<Foam::volScalarField> Foam::liftModels::Moraga::Cl() const
             << endl;
     }
 
-    Re.min(1200.0);
-    Re.max(18800.0);
-
-    sqrSr.min(0.0016);
-    sqrSr.max(0.04);
+    Re.clamp_range(1200.0, 18800.0);
+    sqrSr.clamp_range(0.0016, 0.04);
 
     return 0.2*exp(- Re*sqrSr/3.6e5 - 0.12)*exp(Re*sqrSr/3.0e7);
 }
diff --git a/src/phaseSystemModels/reactingEuler/multiphaseSystem/multiphaseSystem/multiphaseSystem.C b/src/phaseSystemModels/reactingEuler/multiphaseSystem/multiphaseSystem/multiphaseSystem.C
index 3b795194c9..e232ec1e39 100644
--- a/src/phaseSystemModels/reactingEuler/multiphaseSystem/multiphaseSystem/multiphaseSystem.C
+++ b/src/phaseSystemModels/reactingEuler/multiphaseSystem/multiphaseSystem/multiphaseSystem.C
@@ -708,7 +708,7 @@ void Foam::multiphaseSystem::solve()
         phase.alphaRhoPhiRef() =
             fvc::interpolate(phase.rho())*phase.alphaPhi();
 
-        phase.clip(SMALL, 1 - SMALL);
+        phase.clamp_range(SMALL, 1 - SMALL);
     }
 
     calcAlphas();
diff --git a/src/phaseSystemModels/reactingEuler/multiphaseSystem/phaseModel/MultiComponentPhaseModel/MultiComponentPhaseModel.C b/src/phaseSystemModels/reactingEuler/multiphaseSystem/phaseModel/MultiComponentPhaseModel/MultiComponentPhaseModel.C
index 0f36a58829..9482f0244c 100644
--- a/src/phaseSystemModels/reactingEuler/multiphaseSystem/phaseModel/MultiComponentPhaseModel/MultiComponentPhaseModel.C
+++ b/src/phaseSystemModels/reactingEuler/multiphaseSystem/phaseModel/MultiComponentPhaseModel/MultiComponentPhaseModel.C
@@ -124,14 +124,14 @@ void Foam::MultiComponentPhaseModel<BasePhaseModel>::correctThermo()
     if (inertIndex_ != -1)
     {
         Yi[inertIndex_] = scalar(1) - Yt;
-        Yi[inertIndex_].max(0);
+        Yi[inertIndex_].clamp_min(0);
     }
     else
     {
         forAll(Yi, i)
         {
             Yi[i] /= Yt;
-            Yi[i].max(0);
+            Yi[i].clamp_min(0);
         }
     }
 
diff --git a/src/phaseSystemModels/reactingEuler/twoPhaseCompressibleTurbulenceModels/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.C b/src/phaseSystemModels/reactingEuler/twoPhaseCompressibleTurbulenceModels/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.C
index 25572bfb3c..cab9367831 100644
--- a/src/phaseSystemModels/reactingEuler/twoPhaseCompressibleTurbulenceModels/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.C
+++ b/src/phaseSystemModels/reactingEuler/twoPhaseCompressibleTurbulenceModels/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.C
@@ -526,8 +526,7 @@ void Foam::RASModels::kineticTheoryModel::correct()
         kappa_ = conductivityModel_->kappa(alpha, Theta_, gs0_, rho, da, e_);
     }
 
-    Theta_.max(0);
-    Theta_.min(100);
+    Theta_.clamp_range(0, 100);
 
     {
         // particle viscosity (Table 3.2, p.47)
@@ -559,7 +558,8 @@ void Foam::RASModels::kineticTheoryModel::correct()
         );
 
         // Limit viscosity and add frictional viscosity
-        nut_.min(maxNut_);
+        nut_.clamp_max(maxNut_);
+
         nuFric_ = min(nuFric_, maxNut_ - nut_);
         nut_ += nuFric_;
     }
diff --git a/src/phaseSystemModels/reactingEuler/twoPhaseSystem/twoPhaseSystem.C b/src/phaseSystemModels/reactingEuler/twoPhaseSystem/twoPhaseSystem.C
index c52aae49ed..51f8dd9898 100644
--- a/src/phaseSystemModels/reactingEuler/twoPhaseSystem/twoPhaseSystem.C
+++ b/src/phaseSystemModels/reactingEuler/twoPhaseSystem/twoPhaseSystem.C
@@ -340,7 +340,7 @@ void Foam::twoPhaseSystem::solve()
             << endl;
 
         // Ensure the phase-fractions are bounded
-        alpha1.clip(SMALL, 1 - SMALL);
+        alpha1.clamp_range(SMALL, 1 - SMALL);
 
         // Update the phase-fraction of the other phase
         alpha2 = scalar(1) - alpha1;
diff --git a/src/phaseSystemModels/twoPhaseEuler/phaseCompressibleTurbulenceModels/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.C b/src/phaseSystemModels/twoPhaseEuler/phaseCompressibleTurbulenceModels/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.C
index bca4b78442..010322104d 100644
--- a/src/phaseSystemModels/twoPhaseEuler/phaseCompressibleTurbulenceModels/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.C
+++ b/src/phaseSystemModels/twoPhaseEuler/phaseCompressibleTurbulenceModels/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.C
@@ -530,8 +530,7 @@ void Foam::RASModels::kineticTheoryModel::correct()
         kappa_ = conductivityModel_->kappa(alpha, Theta_, gs0_, rho, da, e_);
     }
 
-    Theta_.max(0);
-    Theta_.min(100);
+    Theta_.clamp_range(0, 100);
 
     {
         // particle viscosity (Table 3.2, p.47)
@@ -563,7 +562,8 @@ void Foam::RASModels::kineticTheoryModel::correct()
         );
 
         // Limit viscosity and add frictional viscosity
-        nut_.min(maxNut_);
+        nut_.clamp_max(maxNut_);
+
         nuFric_ = min(nuFric_, maxNut_ - nut_);
         nut_ += nuFric_;
     }
diff --git a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/interfacialModels/dragModels/IshiiZuber/IshiiZuber.C b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/interfacialModels/dragModels/IshiiZuber/IshiiZuber.C
index 96288f39d0..5aa9237fda 100644
--- a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/interfacialModels/dragModels/IshiiZuber/IshiiZuber.C
+++ b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/interfacialModels/dragModels/IshiiZuber/IshiiZuber.C
@@ -87,7 +87,7 @@ Foam::dragModels::IshiiZuber::CdRe() const
     );
 
     volScalarField F((muc/muMix)*sqrt(1 - pair_.dispersed()));
-    F.max(1e-3);
+    F.clamp_min(1e-3);
 
     volScalarField Ealpha((1 + 17.67*pow(F, 0.8571428))/(18.67*F));
 
diff --git a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/interfacialModels/liftModels/Moraga/Moraga.C b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/interfacialModels/liftModels/Moraga/Moraga.C
index 8064581e6f..dca601c284 100644
--- a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/interfacialModels/liftModels/Moraga/Moraga.C
+++ b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/interfacialModels/liftModels/Moraga/Moraga.C
@@ -87,11 +87,8 @@ Foam::tmp<Foam::volScalarField> Foam::liftModels::Moraga::Cl() const
             << endl;
     }
 
-    Re.min(1200.0);
-    Re.max(18800.0);
-
-    sqrSr.min(0.0016);
-    sqrSr.max(0.04);
+    Re.clamp_range(1200.0, 18800.0);
+    sqrSr.clamp_range(0.0016, 0.04);
 
     return 0.2*exp(- Re*sqrSr/3.6e5 - 0.12)*exp(Re*sqrSr/3.0e7);
 }
diff --git a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/twoPhaseSystem/twoPhaseSystem.C b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/twoPhaseSystem/twoPhaseSystem.C
index f4198b56fd..fdb52fea29 100644
--- a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/twoPhaseSystem/twoPhaseSystem.C
+++ b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/twoPhaseSystem/twoPhaseSystem.C
@@ -530,8 +530,7 @@ void Foam::twoPhaseSystem::solve()
             << endl;
 
         // Ensure the phase-fractions are bounded
-        alpha1.max(0);
-        alpha1.min(1);
+        alpha1.clamp_range(zero_one{});
 
         alpha2 = scalar(1) - alpha1;
     }
diff --git a/src/regionFaModels/liquidFilm/subModels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModel.C b/src/regionFaModels/liquidFilm/subModels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModel.C
index 9fbbe55b35..486ab4767c 100644
--- a/src/regionFaModels/liquidFilm/subModels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModel.C
+++ b/src/regionFaModels/liquidFilm/subModels/kinematic/filmTurbulenceModel/filmTurbulenceModel/filmTurbulenceModel.C
@@ -128,7 +128,7 @@ tmp<areaScalarField> filmTurbulenceModel::Cw() const
             const scalar h0 = film_.h0().value();
 
             Cw.primitiveFieldRef() = 3*mu/((h + h0)*rho);
-            Cw.min(5000.0);
+            Cw.clamp_max(5000.0);
 
             break;
         }
diff --git a/src/regionModels/pyrolysisModels/reactingOneDim/reactingOneDim.C b/src/regionModels/pyrolysisModels/reactingOneDim/reactingOneDim.C
index d3c1652d95..acadb10b20 100644
--- a/src/regionModels/pyrolysisModels/reactingOneDim/reactingOneDim.C
+++ b/src/regionModels/pyrolysisModels/reactingOneDim/reactingOneDim.C
@@ -276,7 +276,7 @@ void reactingOneDim::solveSpeciesMass()
         }
 
         YiEqn.solve(regionMesh().solver("Yi"));
-        Yi.max(0.0);
+        Yi.clamp_min(0);
         Yt += Yi;
     }
 
diff --git a/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C b/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C
index d448c5fdf6..3e624c271e 100644
--- a/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C
+++ b/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C
@@ -412,7 +412,7 @@ void kinematicSingleLayer::solveThickness
     }
 
     // Bound film thickness by a minimum of zero
-    delta_.max(0.0);
+    delta_.clamp_min(0);
 
     // Update U field
     U_ -= fvc::reconstruct(deltarUAf*phiAdd);
diff --git a/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayerI.H b/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayerI.H
index f3cd4b31dd..5a022e964b 100644
--- a/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayerI.H
+++ b/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayerI.H
@@ -250,7 +250,7 @@ inline tmp<volScalarField> kinematicSingleLayer::gNormClipped() const
     );
 
     volScalarField& gNormClipped = tgNormClipped.ref();
-    gNormClipped.min(0.0);
+    gNormClipped.clamp_max(0);
 
     return tgNormClipped;
 }
diff --git a/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/laminar/laminar.C b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/laminar/laminar.C
index 67a5dd47d8..fd2bbc8de7 100644
--- a/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/laminar/laminar.C
+++ b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmTurbulenceModel/laminar/laminar.C
@@ -136,7 +136,7 @@ tmp<fvVectorMatrix> laminar::Su(volVectorField& U) const
     // employ simple coeff-based model
     volScalarField Cs("Cs", Cf_*rhop*mag(Up - U));
     volScalarField Cw("Cw", mu/((1.0/3.0)*(delta + film.deltaSmall())));
-    Cw.min(5000.0);
+    Cw.clamp_max(5000.0);
 
     return
     (
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/thixotropicViscosity/thixotropicViscosity.C b/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/thixotropicViscosity/thixotropicViscosity.C
index f7f991820f..931b23d3ff 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/thixotropicViscosity/thixotropicViscosity.C
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/thixotropicViscosity/thixotropicViscosity.C
@@ -85,8 +85,7 @@ thixotropicViscosity::thixotropicViscosity
         film.regionMesh()
     )
 {
-    lambda_.min(1);
-    lambda_.max(0);
+    lambda_.clamp_range(zero_one{});
 
     // Initialise viscosity to inf value because it cannot be evaluated yet
     mu_ = muInf_;
@@ -166,8 +165,7 @@ void thixotropicViscosity::correct
     lambdaEqn.relax();
     lambdaEqn.solve();
 
-    lambda_.min(1);
-    lambda_.max(0);
+    lambda_.clamp_range(zero_one{});
 
     mu_ = muInf_/(sqr(1 - K_*lambda_) + ROOTVSMALL);
     mu_.correctBoundaryConditions();
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/waxSolventEvaporation/waxSolventEvaporation.C b/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/waxSolventEvaporation/waxSolventEvaporation.C
index 0b20fe648f..737382070c 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/waxSolventEvaporation/waxSolventEvaporation.C
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/waxSolventEvaporation/waxSolventEvaporation.C
@@ -357,8 +357,7 @@ void waxSolventEvaporation::correctModel
         YsolventEqn.relax();
         YsolventEqn.solve();
 
-        Ysolvent_.min(1);
-        Ysolvent_.max(0);
+        Ysolvent_.clamp_range(zero_one{});
 
         scalarField dm
         (
diff --git a/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayer.C b/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayer.C
index d46132aa6f..79d805c38b 100644
--- a/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayer.C
+++ b/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayer.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2017-2020 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -478,18 +478,23 @@ thermoSingleLayer::thermoSingleLayer
     ),
     phaseChange_(phaseChangeModel::New(*this, coeffs())),
     radiation_(filmRadiationModel::New(*this, coeffs())),
-    Tmin_(-VGREAT),
-    Tmax_(VGREAT)
+    withTbounds_(limitType::CLAMP_NONE),
+    Tbounds_(0, 5000)
 {
-    if (coeffs().readIfPresent("Tmin", Tmin_))
+    unsigned userLimits(limitType::CLAMP_NONE);
+
+    if (coeffs().readIfPresent("Tmin", Tbounds_.min()))
     {
-        Info<< "    limiting minimum temperature to " << Tmin_ << endl;
+        userLimits |= limitType::CLAMP_MIN;
+        Info<< "    limiting minimum temperature to " << Tbounds_.min() << nl;
     }
 
-    if (coeffs().readIfPresent("Tmax", Tmax_))
+    if (coeffs().readIfPresent("Tmax", Tbounds_.max()))
     {
-        Info<< "    limiting maximum temperature to " << Tmax_ << endl;
+        userLimits |= limitType::CLAMP_MAX;
+        Info<< "    limiting maximum temperature to " << Tbounds_.max() << nl;
     }
+    withTbounds_ = limitType(userLimits);
 
     if (thermo_.hasMultiComponentCarrier())
     {
diff --git a/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayer.H b/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayer.H
index 4ebda18c47..6835f1dee5 100644
--- a/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayer.H
+++ b/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayer.H
@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -40,8 +41,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef thermoSingleLayer_H
-#define thermoSingleLayer_H
+#ifndef Foam_thermoSingleLayer_H
+#define Foam_thermoSingleLayer_H
 
 #include "kinematicSingleLayer.H"
 #include "SLGThermo.H"
@@ -69,7 +70,7 @@ class thermoSingleLayer
 :
     public kinematicSingleLayer
 {
-    // Private member functions
+    // Private Member Functions
 
         //- No copy construct
         thermoSingleLayer(const thermoSingleLayer&) = delete;
@@ -83,7 +84,17 @@ class thermoSingleLayer
 
 protected:
 
-    // Protected data
+    // Protected Data
+
+        //- Enumerated limiter type
+        enum limitType : unsigned
+        {
+            CLAMP_NONE = 0,     //!< No limit
+            CLAMP_MIN = 0x1,    //!< Clamp minimum value
+            CLAMP_MAX = 0x2,    //!< Clamp maximum value
+            CLAMP_RANGE = (CLAMP_MIN | CLAMP_MAX)  //!< Clamp min/max
+        };
+
 
         // Thermo properties
 
@@ -184,14 +195,14 @@ protected:
 
         // Limits
 
-            //- Minimum temperature limit (optional)
-            scalar Tmin_;
+            //- Limiting type
+            limitType withTbounds_;
 
-            //- Maximum temperature limit (optional)
-            scalar Tmax_;
+            //- Temperature limits (optional)
+            scalarMinMax Tbounds_;
 
 
-    // Protected member functions
+    // Protected Member Functions
 
         //- Read control parameters from dictionary
         virtual bool read();
diff --git a/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayerI.H b/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayerI.H
index 1da7e294d1..2cfefdc521 100644
--- a/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayerI.H
+++ b/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayerI.H
@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -102,8 +103,18 @@ inline tmp<volScalarField> thermoSingleLayer::T
         )
     );
 
-    tT.ref().min(Tmax_);
-    tT.ref().max(Tmin_);
+    if (limitType::CLAMP_MIN == withTbounds_)
+    {
+        tT.ref().clamp_min(Tbounds_.min());
+    }
+    else if (limitType::CLAMP_MAX == withTbounds_)
+    {
+        tT.ref().clamp_max(Tbounds_.max());
+    }
+    else if (limitType::CLAMP_RANGE == withTbounds_)
+    {
+        tT.ref().clamp_range(Tbounds_);
+    }
 
     return tT;
 }
diff --git a/src/thermophysicalModels/chemistryModel/functionObjects/BilgerMixtureFraction/BilgerMixtureFraction.C b/src/thermophysicalModels/chemistryModel/functionObjects/BilgerMixtureFraction/BilgerMixtureFraction.C
index dae741f81e..2db2a51f07 100644
--- a/src/thermophysicalModels/chemistryModel/functionObjects/BilgerMixtureFraction/BilgerMixtureFraction.C
+++ b/src/thermophysicalModels/chemistryModel/functionObjects/BilgerMixtureFraction/BilgerMixtureFraction.C
@@ -89,11 +89,7 @@ void Foam::functionObjects::BilgerMixtureFraction::calcBilgerMixtureFraction()
            /thermo_.W(i);
     }
     f_Bilger /= o2RequiredFuelOx_;
-    f_Bilger.clip
-    (
-        dimensionedScalar(dimless, 0),
-        dimensionedScalar(dimless, 1)
-    );
+    f_Bilger.clamp_range(zero_one{});
 }
 
 

From 6f68ce5239fca6628bf2c9c9047d05abbe45ef81 Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@esi-group.com>
Date: Thu, 19 Jan 2023 09:40:26 +0100
Subject: [PATCH 03/11] ENH: update field function macros and 'reuse' field
 handling

- clearer, more consistent parameter naming, which helps when
  maintaining different field function types (eg, DimensionedFields,
  GeometricFields)

- provide reuseTmpGeometricField::New taking a reference (not a tmp),
  with forwarding. This helps centralise naming and acquisition etc

- split binary function macros into transform/interface
  for easier support of different transform loops.

- initial field macros for looping over ternaries
---
 .../DimensionedFieldFunctions.C               | 416 ++++++------
 .../DimensionedFieldFunctions.H               |  96 +--
 .../DimensionedFieldFunctionsM.C              | 534 ++++++++--------
 .../DimensionedFieldFunctionsM.H              | 209 ++++---
 .../DimensionedFieldReuseFunctions.H          | 149 +++--
 .../FieldField/FieldFieldFunctions.C          | 245 +++-----
 .../FieldField/FieldFieldFunctions.H          |   2 +-
 .../FieldField/FieldFieldFunctionsM.C         | 207 +++---
 .../FieldField/FieldFieldFunctionsM.H         |  61 +-
 .../FieldField/FieldFieldReuseFunctions.H     |  30 +-
 .../fields/Fields/Field/FieldFunctions.C      | 460 +++++++-------
 .../fields/Fields/Field/FieldFunctionsM.C     | 188 +++---
 .../fields/Fields/Field/FieldFunctionsM.H     | 130 ++--
 src/OpenFOAM/fields/Fields/Field/FieldM.H     | 113 +++-
 .../fields/Fields/Field/FieldReuseFunctions.H |  21 +-
 .../Fields/Field/undefFieldFunctionsM.H       |  27 +-
 .../GeometricField/GeometricFieldFunctions.C  | 592 ++++++++----------
 .../GeometricField/GeometricFieldFunctions.H  | 151 ++---
 .../GeometricField/GeometricFieldFunctionsM.C | 533 +++++++---------
 .../GeometricField/GeometricFieldFunctionsM.H | 207 +++---
 .../GeometricFieldReuseFunctions.H            | 154 +++--
 21 files changed, 2292 insertions(+), 2233 deletions(-)

diff --git a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.C b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.C
index 487c655226..841324d1f2 100644
--- a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.C
+++ b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -36,32 +36,27 @@ License
 namespace Foam
 {
 
-// * * * * * * * * * * * * * * * Global functions  * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
 
 template<class Type, class GeoMesh, direction r>
 tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>>
 pow
 (
-    const DimensionedField<Type, GeoMesh>& df,
+    const DimensionedField<Type, GeoMesh>& f1,
     typename powProduct<Type, r>::type
 )
 {
-    typedef typename powProduct<Type, r>::type powProductType;
+    typedef typename powProduct<Type, r>::type resultType;
 
     auto tres =
-        tmp<DimensionedField<powProductType, GeoMesh>>::New
+        reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
         (
-            IOobject
-            (
-                "pow(" + df.name() + ',' + name(r) + ')',
-                df.instance(),
-                df.db()
-            ),
-            df.mesh(),
-            pow(df.dimensions(), r)
+            f1,
+            "pow(" + f1.name() + ',' + Foam::name(r) + ')',
+            pow(f1.dimensions(), r)
         );
 
-    pow<Type, r, GeoMesh>(tres.ref().field(), df.field());
+    pow<Type, r, GeoMesh>(tres.ref().field(), f1.field());
 
     return tres;
 }
@@ -71,166 +66,151 @@ template<class Type, class GeoMesh, direction r>
 tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>>
 pow
 (
-    const tmp<DimensionedField<Type, GeoMesh>>& tdf,
+    const tmp<DimensionedField<Type, GeoMesh>>& tf1,
     typename powProduct<Type, r>::type
 )
 {
-    typedef typename powProduct<Type, r>::type powProductType;
+    typedef typename powProduct<Type, r>::type resultType;
 
-    const DimensionedField<Type, GeoMesh>& df = tdf();
+    const auto& f1 = tf1();
 
     auto tres =
-        reuseTmpDimensionedField<powProductType, Type, GeoMesh>::New
+        reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
         (
-            tdf,
-            "pow(" + df.name() + ',' + name(r) + ')',
-            pow(df.dimensions(), r)
+            tf1,
+            "pow(" + f1.name() + ',' + Foam::name(r) + ')',
+            pow(f1.dimensions(), r)
         );
 
-    pow<Type, r, GeoMesh>(tres.ref().field(), df.field());
+    pow<Type, r, GeoMesh>(tres.ref().field(), f1.field());
 
-    tdf.clear();
+    tf1.clear();
     return tres;
 }
 
 
 template<class Type, class GeoMesh>
 tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>>
-sqr(const DimensionedField<Type, GeoMesh>& df)
+sqr(const DimensionedField<Type, GeoMesh>& f1)
 {
-    typedef typename outerProduct<Type, Type>::type outerProductType;
+    typedef typename outerProduct<Type, Type>::type resultType;
 
     auto tres =
-        tmp<DimensionedField<outerProductType, GeoMesh>>::New
+        reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
         (
-            IOobject
-            (
-                "sqr(" + df.name() + ')',
-                df.instance(),
-                df.db()
-            ),
-            df.mesh(),
-            sqr(df.dimensions())
+            f1,
+            "sqr(" + f1.name() + ')',
+            sqr(f1.dimensions())
         );
 
-    sqr(tres.ref().field(), df.field());
+    sqr(tres.ref().field(), f1.field());
 
     return tres;
 }
 
 template<class Type, class GeoMesh>
 tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>>
-sqr(const tmp<DimensionedField<Type, GeoMesh>>& tdf)
+sqr(const tmp<DimensionedField<Type, GeoMesh>>& tf1)
 {
-    typedef typename outerProduct<Type, Type>::type outerProductType;
+    typedef typename outerProduct<Type, Type>::type resultType;
 
-    const DimensionedField<Type, GeoMesh>& df = tdf();
+    const auto& f1 = tf1();
 
     auto tres =
-        reuseTmpDimensionedField<outerProductType, Type, GeoMesh>::New
+        reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
         (
-            tdf,
-            "sqr(" + df.name() + ')',
-            sqr(df.dimensions())
+            tf1,
+            "sqr(" + f1.name() + ')',
+            sqr(f1.dimensions())
         );
 
-    sqr(tres.ref().field(), df.field());
+    sqr(tres.ref().field(), f1.field());
 
-    tdf.clear();
+    tf1.clear();
     return tres;
 }
 
 
 template<class Type, class GeoMesh>
 tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
-magSqr(const DimensionedField<Type, GeoMesh>& df)
+magSqr(const DimensionedField<Type, GeoMesh>& f1)
 {
-    typedef typename typeOfMag<Type>::type magType;
+    typedef typename typeOfMag<Type>::type resultType;
 
     auto tres =
-        tmp<DimensionedField<magType, GeoMesh>>::New
+        reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
         (
-            IOobject
-            (
-                "magSqr(" + df.name() + ')',
-                df.instance(),
-                df.db()
-            ),
-            df.mesh(),
-            sqr(df.dimensions())
+            f1,
+            "magSqr(" + f1.name() + ')',
+            sqr(f1.dimensions())
         );
 
-    magSqr(tres.ref().field(), df.field());
+    magSqr(tres.ref().field(), f1.field());
 
     return tres;
 }
 
 template<class Type, class GeoMesh>
 tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
-magSqr(const tmp<DimensionedField<Type, GeoMesh>>& tdf)
+magSqr(const tmp<DimensionedField<Type, GeoMesh>>& tf1)
 {
-    typedef typename typeOfMag<Type>::type magType;
+    typedef typename typeOfMag<Type>::type resultType;
 
-    const DimensionedField<Type, GeoMesh>& df = tdf();
+    const auto& f1 = tf1();
 
     auto tres =
-        reuseTmpDimensionedField<magType, Type, GeoMesh>::New
+        reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
         (
-            tdf,
-            "magSqr(" + df.name() + ')',
-            sqr(df.dimensions())
+            tf1,
+            "magSqr(" + f1.name() + ')',
+            sqr(f1.dimensions())
         );
 
-    magSqr(tres.ref().field(), df.field());
+    magSqr(tres.ref().field(), f1.field());
 
-    tdf.clear();
+    tf1.clear();
     return tres;
 }
 
 
 template<class Type, class GeoMesh>
 tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
-mag(const DimensionedField<Type, GeoMesh>& df)
+mag(const DimensionedField<Type, GeoMesh>& f1)
 {
-    typedef typename typeOfMag<Type>::type magType;
+    typedef typename typeOfMag<Type>::type resultType;
 
     auto tres =
-        tmp<DimensionedField<magType, GeoMesh>>::New
+        reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
         (
-            IOobject
-            (
-                "mag(" + df.name() + ')',
-                df.instance(),
-                df.db()
-            ),
-            df.mesh(),
-            df.dimensions()
+            f1,
+            "mag(" + f1.name() + ')',
+            f1.dimensions()
         );
 
-    mag(tres.ref().field(), df.field());
+    mag(tres.ref().field(), f1.field());
 
     return tres;
 }
 
 template<class Type, class GeoMesh>
 tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
-mag(const tmp<DimensionedField<Type, GeoMesh>>& tdf)
+mag(const tmp<DimensionedField<Type, GeoMesh>>& tf1)
 {
-    typedef typename typeOfMag<Type>::type magType;
+    typedef typename typeOfMag<Type>::type resultType;
 
-    const DimensionedField<Type, GeoMesh>& df = tdf();
+    const auto& f1 = tf1();
 
     auto tres =
-        reuseTmpDimensionedField<magType, Type, GeoMesh>::New
+        reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
         (
-            tdf,
-            "mag(" + df.name() + ')',
-            df.dimensions()
+            tf1,
+            "mag(" + f1.name() + ')',
+            f1.dimensions()
         );
 
-    mag(tres.ref().field(), df.field());
+    mag(tres.ref().field(), f1.field());
 
-    tdf.clear();
+    tf1.clear();
     return tres;
 }
 
@@ -243,24 +223,19 @@ tmp
         typename DimensionedField<Type, GeoMesh>::cmptType, GeoMesh
     >
 >
-cmptAv(const DimensionedField<Type, GeoMesh>& df)
+cmptAv(const DimensionedField<Type, GeoMesh>& f1)
 {
-    typedef typename DimensionedField<Type, GeoMesh>::cmptType cmptType;
+    typedef typename DimensionedField<Type, GeoMesh>::cmptType resultType;
 
     auto tres =
-        tmp<DimensionedField<cmptType, GeoMesh>>::New
+        reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
         (
-            IOobject
-            (
-                "cmptAv(" + df.name() + ')',
-                df.instance(),
-                df.db()
-            ),
-            df.mesh(),
-            df.dimensions()
+            f1,
+            "cmptAv(" + f1.name() + ')',
+            f1.dimensions()
         );
 
-    cmptAv(tres.ref().field(), df.field());
+    cmptAv(tres.ref().field(), f1.field());
 
     return tres;
 }
@@ -274,51 +249,51 @@ tmp
         typename DimensionedField<Type, GeoMesh>::cmptType, GeoMesh
     >
 >
-cmptAv(const tmp<DimensionedField<Type, GeoMesh>>& tdf)
+cmptAv(const tmp<DimensionedField<Type, GeoMesh>>& tf1)
 {
-    typedef typename DimensionedField<Type, GeoMesh>::cmptType cmptType;
+    typedef typename DimensionedField<Type, GeoMesh>::cmptType resultType;
 
-    const DimensionedField<Type, GeoMesh>& df = tdf();
+    const auto& f1 = tf1();
 
     auto tres =
-        reuseTmpDimensionedField<cmptType, Type, GeoMesh>::New
+        reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
         (
-            tdf,
-            "cmptAv(" + df.name() + ')',
-            df.dimensions()
+            tf1,
+            "cmptAv(" + f1.name() + ')',
+            f1.dimensions()
         );
 
-    cmptAv(tres.ref().field(), df.field());
+    cmptAv(tres.ref().field(), f1.field());
 
-    tdf.clear();
+    tf1.clear();
     return tres;
 }
 
 
-#define UNARY_REDUCTION_FUNCTION(returnType, func, dfunc)                      \
+#define UNARY_REDUCTION_FUNCTION(ReturnType, Func, gFunc)                      \
                                                                                \
 template<class Type, class GeoMesh>                                            \
-dimensioned<returnType> func                                                   \
+dimensioned<ReturnType> Func                                                   \
 (                                                                              \
-    const DimensionedField<Type, GeoMesh>& df                                  \
+    const DimensionedField<Type, GeoMesh>& f1                                  \
 )                                                                              \
 {                                                                              \
-    return dimensioned<returnType>                                             \
+    return dimensioned<ReturnType>                                             \
     (                                                                          \
-        #func "(" + df.name() + ')',                                           \
-        df.dimensions(),                                                       \
-        dfunc(df.field())                                                      \
+        #Func "(" + f1.name() + ')',                                           \
+        f1.dimensions(),                                                       \
+        gFunc(f1.field())                                                      \
     );                                                                         \
 }                                                                              \
                                                                                \
 template<class Type, class GeoMesh>                                            \
-dimensioned<returnType> func                                                   \
+dimensioned<ReturnType> Func                                                   \
 (                                                                              \
-    const tmp<DimensionedField<Type, GeoMesh>>& tdf1                           \
+    const tmp<DimensionedField<Type, GeoMesh>>& tf1                            \
 )                                                                              \
 {                                                                              \
-    dimensioned<returnType> res = func(tdf1());                                \
-    tdf1.clear();                                                              \
+    dimensioned<ReturnType> res = Func(tf1());                                 \
+    tf1.clear();                                                               \
     return res;                                                                \
 }
 
@@ -347,7 +322,7 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
 BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clip)
 
 
-// * * * * * * * * * * * * * * * Global operators  * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 
 UNARY_OPERATOR(Type, Type, -, negate, transform)
 
@@ -363,32 +338,27 @@ BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, '|', divide)
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define PRODUCT_OPERATOR(product, op, opFunc)                                  \
+#define PRODUCT_OPERATOR(product, Op, OpFunc)                                  \
                                                                                \
 template<class Type1, class Type2, class GeoMesh>                              \
 tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>>           \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
+    typedef typename product<Type1, Type2>::type resultType;                   \
                                                                                \
     auto tres =                                                                \
-        tmp<DimensionedField<productType, GeoMesh>>::New                       \
+        reuseTmpDimensionedField<resultType, Type1, GeoMesh>::New              \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                '(' + df1.name() + #op + df2.name() + ')',                     \
-                df1.instance(),                                                \
-                df1.db()                                                       \
-            ),                                                                 \
-            df1.mesh(),                                                        \
-            df1.dimensions() op df2.dimensions()                               \
+            f1,                                                                \
+            '(' + f1.name() + #Op + f2.name() + ')',                           \
+            (f1.dimensions() Op f2.dimensions())                               \
         );                                                                     \
                                                                                \
-    Foam::opFunc(tres.ref().field(), df1.field(), df2.field());                \
+    Foam::OpFunc(tres.ref().field(), f1.field(), f2.field());                  \
                                                                                \
     return tres;                                                               \
 }                                                                              \
@@ -396,113 +366,108 @@ operator op                                                                    \
                                                                                \
 template<class Type1, class Type2, class GeoMesh>                              \
 tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>>           \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
+    typedef typename product<Type1, Type2>::type resultType;                   \
                                                                                \
-    const DimensionedField<Type2, GeoMesh>& df2 = tdf2();                      \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
-        reuseTmpDimensionedField<productType, Type2, GeoMesh>::New             \
+        reuseTmpDimensionedField<resultType, Type2, GeoMesh>::New              \
         (                                                                      \
-            tdf2,                                                              \
-            '(' + df1.name() + #op + df2.name() + ')',                         \
-            df1.dimensions() op df2.dimensions()                               \
+            tf2,                                                               \
+            '(' + f1.name() + #Op + f2.name() + ')',                           \
+            (f1.dimensions() Op f2.dimensions())                               \
         );                                                                     \
                                                                                \
-    Foam::opFunc(tres.ref().field(), df1.field(), df2.field());                \
+    Foam::OpFunc(tres.ref().field(), f1.field(), f2.field());                  \
                                                                                \
-    tdf2.clear();                                                              \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
                                                                                \
 template<class Type1, class Type2, class GeoMesh>                              \
 tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>>           \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
+    typedef typename product<Type1, Type2>::type resultType;                   \
                                                                                \
-    const DimensionedField<Type1, GeoMesh>& df1 = tdf1();                      \
+    const auto& f1 = tf1();                                                    \
                                                                                \
     auto tres =                                                                \
-        reuseTmpDimensionedField<productType, Type1, GeoMesh>::New             \
+        reuseTmpDimensionedField<resultType, Type1, GeoMesh>::New              \
         (                                                                      \
-            tdf1,                                                              \
-            '(' + df1.name() + #op + df2.name() + ')',                         \
-            df1.dimensions() op df2.dimensions()                               \
+            tf1,                                                               \
+            '(' + f1.name() + #Op + f2.name() + ')',                           \
+            (f1.dimensions() Op f2.dimensions())                               \
         );                                                                     \
                                                                                \
-    Foam::opFunc(tres.ref().field(), df1.field(), df2.field());                \
+    Foam::OpFunc(tres.ref().field(), f1.field(), f2.field());                  \
                                                                                \
-    tdf1.clear();                                                              \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
                                                                                \
 template<class Type1, class Type2, class GeoMesh>                              \
 tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>>           \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
+    typedef typename product<Type1, Type2>::type resultType;                   \
                                                                                \
-    const DimensionedField<Type1, GeoMesh>& df1 = tdf1();                      \
-    const DimensionedField<Type2, GeoMesh>& df2 = tdf2();                      \
+    const auto& f1 = tf1();                                                    \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpTmpDimensionedField                                            \
-        <productType, Type1, Type1, Type2, GeoMesh>::New                       \
+        <resultType, Type1, Type1, Type2, GeoMesh>::New                        \
         (                                                                      \
-            tdf1,                                                              \
-            tdf2,                                                              \
-            '(' + df1.name() + #op + df2.name() + ')',                         \
-            df1.dimensions() op df2.dimensions()                               \
+            tf1,                                                               \
+            tf2,                                                               \
+            '(' + f1.name() + #Op + f2.name() + ')',                           \
+            (f1.dimensions() Op f2.dimensions())                               \
         );                                                                     \
                                                                                \
-    Foam::opFunc(tres.ref().field(), df1.field(), df2.field());                \
+    Foam::OpFunc(tres.ref().field(), f1.field(), f2.field());                  \
                                                                                \
-    tdf1.clear();                                                              \
-    tdf2.clear();                                                              \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
                                                                                \
 template<class Form, class Type, class GeoMesh>                                \
 tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>>             \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const DimensionedField<Type, GeoMesh>& df1,                                \
+    const DimensionedField<Type, GeoMesh>& f1,                                 \
     const dimensioned<Form>& dvs                                               \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type, Form>::type productType;                    \
+    typedef typename product<Type, Form>::type resultType;                     \
                                                                                \
     auto tres =                                                                \
-        tmp<DimensionedField<productType, GeoMesh>>::New                       \
+        reuseTmpDimensionedField<resultType, Type, GeoMesh>::New               \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                '(' + df1.name() + #op + dvs.name() + ')',                     \
-                df1.instance(),                                                \
-                df1.db()                                                       \
-            ),                                                                 \
-            df1.mesh(),                                                        \
-            df1.dimensions() op dvs.dimensions()                               \
+            f1,                                                                \
+            '(' + f1.name() + #Op + dvs.name() + ')',                          \
+            (f1.dimensions() Op dvs.dimensions())                              \
         );                                                                     \
                                                                                \
-    Foam::opFunc(tres.ref().field(), df1.field(), dvs.value());                \
+    Foam::OpFunc(tres.ref().field(), f1.field(), dvs.value());                 \
                                                                                \
     return tres;                                                               \
 }                                                                              \
@@ -510,79 +475,74 @@ operator op                                                                    \
                                                                                \
 template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh>   \
 tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>>             \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const DimensionedField<Type, GeoMesh>& df1,                                \
+    const DimensionedField<Type, GeoMesh>& f1,                                 \
     const VectorSpace<Form,Cmpt,nCmpt>& vs                                     \
 )                                                                              \
 {                                                                              \
-    return df1 op dimensioned<Form>(static_cast<const Form&>(vs));             \
+    return f1 Op dimensioned<Form>(static_cast<const Form&>(vs));              \
 }                                                                              \
                                                                                \
                                                                                \
 template<class Form, class Type, class GeoMesh>                                \
 tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>>             \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const tmp<DimensionedField<Type, GeoMesh>>& tdf1,                          \
+    const tmp<DimensionedField<Type, GeoMesh>>& tf1,                           \
     const dimensioned<Form>& dvs                                               \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type, Form>::type productType;                    \
+    typedef typename product<Type, Form>::type resultType;                     \
                                                                                \
-    const DimensionedField<Type, GeoMesh>& df1 = tdf1();                       \
+    const auto& f1 = tf1();                                                    \
                                                                                \
     auto tres =                                                                \
-        reuseTmpDimensionedField<productType, Type, GeoMesh>::New              \
+        reuseTmpDimensionedField<resultType, Type, GeoMesh>::New               \
         (                                                                      \
-            tdf1,                                                              \
-            '(' + df1.name() + #op + dvs.name() + ')',                         \
-            df1.dimensions() op dvs.dimensions()                               \
+            tf1,                                                               \
+            '(' + f1.name() + #Op + dvs.name() + ')',                          \
+            (f1.dimensions() Op dvs.dimensions())                              \
         );                                                                     \
                                                                                \
-    Foam::opFunc(tres.ref().field(), df1.field(), dvs.value());                \
+    Foam::OpFunc(tres.ref().field(), f1.field(), dvs.value());                 \
                                                                                \
-    tdf1.clear();                                                              \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
                                                                                \
 template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh>   \
 tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>>             \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const tmp<DimensionedField<Type, GeoMesh>>& tdf1,                          \
+    const tmp<DimensionedField<Type, GeoMesh>>& tf1,                           \
     const VectorSpace<Form,Cmpt,nCmpt>& vs                                     \
 )                                                                              \
 {                                                                              \
-    return tdf1 op dimensioned<Form>(static_cast<const Form&>(vs));            \
+    return tf1 Op dimensioned<Form>(static_cast<const Form&>(vs));             \
 }                                                                              \
                                                                                \
                                                                                \
 template<class Form, class Type, class GeoMesh>                                \
 tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>>             \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const dimensioned<Form>& dvs,                                              \
-    const DimensionedField<Type, GeoMesh>& df1                                 \
+    const DimensionedField<Type, GeoMesh>& f2                                  \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Form, Type>::type productType;                    \
+    typedef typename product<Form, Type>::type resultType;                     \
                                                                                \
     auto tres =                                                                \
-        tmp<DimensionedField<productType, GeoMesh>>::New                       \
+        reuseTmpDimensionedField<resultType, Type, GeoMesh>::New               \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                '(' + dvs.name() + #op + df1.name() + ')',                     \
-                df1.instance(),                                                \
-                df1.db()                                                       \
-            ),                                                                 \
-            df1.mesh(),                                                        \
-            dvs.dimensions() op df1.dimensions()                               \
+            f2,                                                                \
+            '(' + dvs.name() + #Op + f2.name() + ')',                          \
+            (dvs.dimensions() Op f2.dimensions())                              \
         );                                                                     \
                                                                                \
-    Foam::opFunc(tres.ref().field(), dvs.value(), df1.field());                \
+    Foam::OpFunc(tres.ref().field(), dvs.value(), f2.field());                 \
                                                                                \
     return tres;                                                               \
 }                                                                              \
@@ -590,52 +550,52 @@ operator op                                                                    \
                                                                                \
 template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh>   \
 tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>>             \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const VectorSpace<Form,Cmpt,nCmpt>& vs,                                    \
-    const DimensionedField<Type, GeoMesh>& df1                                 \
+    const DimensionedField<Type, GeoMesh>& f2                                  \
 )                                                                              \
 {                                                                              \
-    return dimensioned<Form>(static_cast<const Form&>(vs)) op df1;             \
+    return dimensioned<Form>(static_cast<const Form&>(vs)) Op f2;              \
 }                                                                              \
                                                                                \
                                                                                \
 template<class Form, class Type, class GeoMesh>                                \
 tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>>             \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const dimensioned<Form>& dvs,                                              \
-    const tmp<DimensionedField<Type, GeoMesh>>& tdf1                           \
+    const tmp<DimensionedField<Type, GeoMesh>>& tf2                            \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Form, Type>::type productType;                    \
+    typedef typename product<Form, Type>::type resultType;                     \
                                                                                \
-    const DimensionedField<Type, GeoMesh>& df1 = tdf1();                       \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
-        reuseTmpDimensionedField<productType, Type, GeoMesh>::New              \
+        reuseTmpDimensionedField<resultType, Type, GeoMesh>::New               \
         (                                                                      \
-            tdf1,                                                              \
-            '(' + dvs.name() + #op + df1.name() + ')',                         \
-            dvs.dimensions() op df1.dimensions()                               \
+            tf2,                                                               \
+            '(' + dvs.name() + #Op + f2.name() + ')',                          \
+            (dvs.dimensions() Op f2.dimensions())                              \
         );                                                                     \
                                                                                \
-    Foam::opFunc(tres.ref().field(), dvs.value(), df1.field());                \
+    Foam::OpFunc(tres.ref().field(), dvs.value(), f2.field());                 \
                                                                                \
-    tdf1.clear();                                                              \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
                                                                                \
 template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh>   \
 tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>>             \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const VectorSpace<Form,Cmpt,nCmpt>& vs,                                    \
-    const tmp<DimensionedField<Type, GeoMesh>>& tdf1                           \
+    const tmp<DimensionedField<Type, GeoMesh>>& tf2                            \
 )                                                                              \
 {                                                                              \
-    return dimensioned<Form>(static_cast<const Form&>(vs)) op tdf1;            \
+    return dimensioned<Form>(static_cast<const Form&>(vs)) Op tf2;             \
 }
 
 
diff --git a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.H b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.H
index 81a625342f..3adb4ececb 100644
--- a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.H
+++ b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -36,13 +36,13 @@ License
 namespace Foam
 {
 
-// * * * * * * * * * * * * * * * Global functions  * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
 
 template<class Type, class GeoMesh, direction r>
 tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>>
 pow
 (
-    const DimensionedField<Type, GeoMesh>& df,
+    const DimensionedField<Type, GeoMesh>& f1,
     typename powProduct<Type, r>::type
 );
 
@@ -50,33 +50,33 @@ template<class Type, class GeoMesh, direction r>
 tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>>
 pow
 (
-    const tmp<DimensionedField<Type, GeoMesh>>& tdf,
+    const tmp<DimensionedField<Type, GeoMesh>>& tf1,
     typename powProduct<Type, r>::type
 );
 
 template<class Type, class GeoMesh>
 tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>>
-sqr(const DimensionedField<Type, GeoMesh>& df);
+sqr(const DimensionedField<Type, GeoMesh>& f1);
 
 template<class Type, class GeoMesh>
 tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>>
-sqr(const tmp<DimensionedField<Type, GeoMesh>>& tdf);
+sqr(const tmp<DimensionedField<Type, GeoMesh>>& tf1);
 
 template<class Type, class GeoMesh>
 tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
-magSqr(const DimensionedField<Type, GeoMesh>& df);
+magSqr(const DimensionedField<Type, GeoMesh>& f1);
 
 template<class Type, class GeoMesh>
 tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
-magSqr(const tmp<DimensionedField<Type, GeoMesh>>& tdf);
+magSqr(const tmp<DimensionedField<Type, GeoMesh>>& tf1);
 
 template<class Type, class GeoMesh>
 tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
-mag(const DimensionedField<Type, GeoMesh>& df);
+mag(const DimensionedField<Type, GeoMesh>& f1);
 
 template<class Type, class GeoMesh>
 tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
-mag(const tmp<DimensionedField<Type, GeoMesh>>& tdf);
+mag(const tmp<DimensionedField<Type, GeoMesh>>& tf1);
 
 template<class Type, class GeoMesh>
 tmp
@@ -87,7 +87,7 @@ tmp
         GeoMesh
     >
 >
-cmptAv(const DimensionedField<Type, GeoMesh>& df);
+cmptAv(const DimensionedField<Type, GeoMesh>& f1);
 
 template<class Type, class GeoMesh>
 tmp
@@ -98,21 +98,21 @@ tmp
         GeoMesh
     >
 >
-cmptAv(const tmp<DimensionedField<Type, GeoMesh>>& tdf);
+cmptAv(const tmp<DimensionedField<Type, GeoMesh>>& tf1);
 
 
-// Forward to FieldFunction via dfunc()
-#define UNARY_REDUCTION_FUNCTION(returnType, func, dfunc)                      \
+// Forward to FieldFunction via gFunc()
+#define UNARY_REDUCTION_FUNCTION(ReturnType, Func, gFunc)                      \
                                                                                \
 template<class Type, class GeoMesh>                                            \
-dimensioned<returnType> func                                                   \
+dimensioned<ReturnType> Func                                                   \
 (                                                                              \
-    const DimensionedField<Type, GeoMesh>& df                                  \
+    const DimensionedField<Type, GeoMesh>& f1                                  \
 );                                                                             \
 template<class Type, class GeoMesh>                                            \
-dimensioned<returnType> func                                                   \
+dimensioned<ReturnType> Func                                                   \
 (                                                                              \
-    const tmp<DimensionedField<Type, GeoMesh>>& tdf1                           \
+    const tmp<DimensionedField<Type, GeoMesh>>& tf1                            \
 );
 
 UNARY_REDUCTION_FUNCTION(Type, max, gMax)
@@ -140,7 +140,7 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
 BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clip)
 
 
-// * * * * * * * * * * * * * * * Global operators  * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 
 UNARY_OPERATOR(Type, Type, -, negate, transform)
 
@@ -156,102 +156,102 @@ BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, '|', divide)
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define PRODUCT_OPERATOR(product, op, opFunc)                                  \
+#define PRODUCT_OPERATOR(product, Op, OpFunc)                                  \
                                                                                \
 template<class Type1, class Type2, class GeoMesh>                              \
 tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>>           \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 );                                                                             \
                                                                                \
 template<class Type1, class Type2, class GeoMesh>                              \
 tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>>           \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 );                                                                             \
                                                                                \
 template<class Type1, class Type2, class GeoMesh>                              \
 tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>>           \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 );                                                                             \
                                                                                \
 template<class Type1, class Type2, class GeoMesh>                              \
 tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>>           \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 );                                                                             \
                                                                                \
 template<class Form, class Type, class GeoMesh>                                \
 tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>>             \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const DimensionedField<Type, GeoMesh>& df1,                                \
+    const DimensionedField<Type, GeoMesh>& f1,                                 \
     const dimensioned<Form>& dvs                                               \
 );                                                                             \
                                                                                \
 template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh>   \
 tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>>             \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const DimensionedField<Type, GeoMesh>& df1,                                \
+    const DimensionedField<Type, GeoMesh>& f1,                                 \
     const VectorSpace<Form,Cmpt,nCmpt>& vs                                     \
 );                                                                             \
                                                                                \
 template<class Form, class Type, class GeoMesh>                                \
 tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>>             \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const tmp<DimensionedField<Type, GeoMesh>>& tdf1,                          \
+    const tmp<DimensionedField<Type, GeoMesh>>& tf1,                           \
     const dimensioned<Form>& dvs                                               \
 );                                                                             \
                                                                                \
 template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh>   \
 tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>>             \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const tmp<DimensionedField<Type, GeoMesh>>& tdf1,                          \
+    const tmp<DimensionedField<Type, GeoMesh>>& tf1,                           \
     const VectorSpace<Form,Cmpt,nCmpt>& vs                                     \
 );                                                                             \
                                                                                \
 template<class Form, class Type, class GeoMesh>                                \
 tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>>             \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const dimensioned<Form>& dvs,                                              \
-    const DimensionedField<Type, GeoMesh>& df1                                 \
+    const DimensionedField<Type, GeoMesh>& f2                                  \
 );                                                                             \
                                                                                \
 template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh>   \
 tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>>             \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const VectorSpace<Form,Cmpt,nCmpt>& vs,                                    \
-    const DimensionedField<Type, GeoMesh>& df1                                 \
+    const DimensionedField<Type, GeoMesh>& f2                                  \
 );                                                                             \
                                                                                \
 template<class Form, class Type, class GeoMesh>                                \
 tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>>             \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const dimensioned<Form>& dvs,                                              \
-    const tmp<DimensionedField<Type, GeoMesh>>& tdf1                           \
+    const tmp<DimensionedField<Type, GeoMesh>>& tf2                            \
 );                                                                             \
                                                                                \
 template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh>   \
 tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>>             \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const VectorSpace<Form,Cmpt,nCmpt>& vs,                                    \
-    const tmp<DimensionedField<Type, GeoMesh>>& tdf1                           \
+    const tmp<DimensionedField<Type, GeoMesh>>& tf2                            \
 );
 
 PRODUCT_OPERATOR(typeOfSum, +, add)
diff --git a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.C b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.C
index 54978f94ac..e8ee293203 100644
--- a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.C
+++ b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -33,27 +33,32 @@ License
 #define UNARY_FUNCTION(ReturnType, Type1, Func, Dfunc)                         \
                                                                                \
 TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const DimensionedField<Type1, GeoMesh>& f1                                 \
+)                                                                              \
+{                                                                              \
+    /* TBD: reset dimensions? */                                               \
+    Func(result.field(), f1.field());                                          \
+    result.oriented() = Dfunc(f1.oriented());                                  \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1                                \
+    const DimensionedField<Type1, GeoMesh>& f1                                 \
 )                                                                              \
 {                                                                              \
     auto tres =                                                                \
-        tmp<DimensionedField<ReturnType, GeoMesh>>::New                        \
+        reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New              \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                #Func "(" + df1.name() + ')',                                  \
-                df1.instance(),                                                \
-                df1.db()                                                       \
-            ),                                                                 \
-            df1.mesh(),                                                        \
-            Dfunc(df1.dimensions())                                            \
+            f1,                                                                \
+            #Func "(" + f1.name() + ')',                                       \
+            Dfunc(f1.dimensions())                                             \
         );                                                                     \
                                                                                \
-    Func(tres.ref().field(), df1.field());                                     \
-    tres.ref().oriented() = Dfunc(df1.oriented());                             \
-                                                                               \
+    Foam::Func(tres.ref(), f1);                                                \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -61,23 +66,21 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1                          \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1                           \
 )                                                                              \
 {                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1 = tdf1();                      \
+    const auto& f1 = tf1();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New              \
         (                                                                      \
-            tdf1,                                                              \
-            #Func "(" + df1.name() + ')',                                      \
-            Dfunc(df1.dimensions())                                            \
+            tf1,                                                               \
+            #Func "(" + f1.name() + ')',                                       \
+            Dfunc(f1.dimensions())                                             \
         );                                                                     \
                                                                                \
-    Func(tres.ref().field(), df1.field());                                     \
-    tres.ref().oriented() = Dfunc(df1.oriented());                             \
-                                                                               \
-    tdf1.clear();                                                              \
+    Foam::Func(tres.ref(), f1);                                                \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }
 
@@ -87,27 +90,32 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 #define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc, Dfunc)                   \
                                                                                \
 TEMPLATE                                                                       \
+void OpFunc                                                                    \
+(                                                                              \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const DimensionedField<Type1, GeoMesh>& f1                                 \
+)                                                                              \
+{                                                                              \
+    /* TBD: reset dimensions? */                                               \
+    Foam::OpFunc(result.field(), f1.field());                                  \
+    result.oriented() = Dfunc(f1.oriented());                                  \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1                                \
+    const DimensionedField<Type1, GeoMesh>& f1                                 \
 )                                                                              \
 {                                                                              \
     auto tres =                                                                \
-        tmp<DimensionedField<ReturnType, GeoMesh>>::New                        \
+        reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New              \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                #Op + df1.name(),                                              \
-                df1.instance(),                                                \
-                df1.db()                                                       \
-            ),                                                                 \
-            df1.mesh(),                                                        \
-            Dfunc(df1.dimensions())                                            \
+            f1,                                                                \
+            #Op + f1.name(),                                                   \
+            Dfunc(f1.dimensions())                                             \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref().field(), df1.field());                             \
-    tres.ref().oriented() = Dfunc(df1.oriented());                             \
-                                                                               \
+    Foam::OpFunc(tres.ref(), f1);                                              \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -115,23 +123,21 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1                          \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1                           \
 )                                                                              \
 {                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1 = tdf1();                      \
+    const auto& f1 = tf1();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New              \
         (                                                                      \
-            tdf1,                                                              \
-            #Op + df1.name(),                                                  \
-            Dfunc(df1.dimensions())                                            \
+            tf1,                                                               \
+            #Op + f1.name(),                                                   \
+            Dfunc(f1.dimensions())                                             \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref().field(), df1.field());                             \
-    tres.ref().oriented() = Dfunc(df1.oriented());                             \
-                                                                               \
-    tdf1.clear();                                                              \
+    Foam::OpFunc(tres.ref(), f1);                                              \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }
 
@@ -141,28 +147,34 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 #define BINARY_FUNCTION(ReturnType, Type1, Type2, Func)                        \
                                                                                \
 TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
+)                                                                              \
+{                                                                              \
+    /* TBD: reset dimensions? */                                               \
+    Foam::Func(result.field(), f1.field(), f2.field());                        \
+    result.oriented() = Func(f1.oriented(), f2.oriented());                    \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 )                                                                              \
 {                                                                              \
     auto tres =                                                                \
-        tmp<DimensionedField<ReturnType, GeoMesh>>::New                        \
+        reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New              \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                #Func "(" + df1.name() + ',' + df2.name() + ')',               \
-                df1.instance(),                                                \
-                df1.db()                                                       \
-            ),                                                                 \
-            df1.mesh(),                                                        \
-            Func(df1.dimensions(), df2.dimensions())                           \
+            f1,                                                                \
+            #Func "(" + f1.name() + ',' + f2.name() + ')',                     \
+            Func(f1.dimensions(), f2.dimensions())                             \
         );                                                                     \
                                                                                \
-    Func(tres.ref().field(), df1.field(), df2.field());                        \
-    tres.ref().oriented() = Func(df1.oriented(), df2.oriented());              \
-                                                                               \
+    Foam::Func(tres.ref(), f1, f2);                                            \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -170,24 +182,22 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 )                                                                              \
 {                                                                              \
-    const DimensionedField<Type2, GeoMesh>& df2 = tdf2();                      \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New              \
         (                                                                      \
-            tdf2,                                                              \
-            #Func "(" + df1.name() + ',' + df2.name() + ')',                   \
-            Func(df1.dimensions(), df2.dimensions())                           \
+            tf2,                                                               \
+            #Func "(" + f1.name() + ',' + f2.name() + ')',                     \
+            Func(f1.dimensions(), f2.dimensions())                             \
         );                                                                     \
                                                                                \
-    Func(tres.ref().field(), df1.field(), df2.field());                        \
-    tres.ref().oriented() = Func(df1.oriented(), df2.oriented());              \
-                                                                               \
-    tdf2.clear();                                                              \
+    Foam::Func(tres.ref(), f1, f2);                                            \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -195,26 +205,22 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 )                                                                              \
 {                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1 = tdf1();                      \
+    const auto& f1 = tf1();                                                    \
                                                                                \
-    tmp<DimensionedField<ReturnType, GeoMesh>> tres                            \
-    (                                                                          \
+    auto tres =                                                                \
         reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New              \
         (                                                                      \
-            tdf1,                                                              \
-            #Func "(" + df1.name() + ',' + df2.name() + ')',                   \
-            Func(df1.dimensions(), df2.dimensions())                           \
-        )                                                                      \
-    );                                                                         \
+            tf1,                                                               \
+            #Func "(" + f1.name() + ',' + f2.name() + ')',                     \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
                                                                                \
-    Func(tres.ref().field(), df1.field(), df2.field());                        \
-    tres.ref().oriented() = Func(df1.oriented(), df2.oriented());              \
-                                                                               \
-    tdf1.clear();                                                              \
+    Foam::Func(tres.ref(), f1, f2);                                            \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -222,28 +228,26 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 )                                                                              \
 {                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1 = tdf1();                      \
-    const DimensionedField<Type2, GeoMesh>& df2 = tdf2();                      \
+    const auto& f1 = tf1();                                                    \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpTmpDimensionedField                                            \
         <ReturnType, Type1, Type1, Type2, GeoMesh>::New                        \
         (                                                                      \
-            tdf1,                                                              \
-            tdf2,                                                              \
-            #Func "(" + df1.name() + ',' + df2.name() + ')',                   \
-            Func(df1.dimensions(), df2.dimensions())                           \
+            tf1,                                                               \
+            tf2,                                                               \
+            #Func "(" + f1.name() + ',' + f2.name() + ')',                     \
+            Func(f1.dimensions(), f2.dimensions())                             \
         );                                                                     \
                                                                                \
-    Func(tres.ref().field(), df1.field(), df2.field());                        \
-    tres.ref().oriented() = Func(df1.oriented(), df2.oriented());              \
-                                                                               \
-    tdf1.clear();                                                              \
-    tdf2.clear();                                                              \
+    Foam::Func(tres.ref(), f1, f2);                                            \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }
 
@@ -253,28 +257,34 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 #define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func)                \
                                                                                \
 TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const dimensioned<Type1>& dt1,                                             \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
+)                                                                              \
+{                                                                              \
+    /* TBD: reset dimensions? */                                               \
+    Func(result.field(), dt1.value(), f2.field());                             \
+    result.oriented() = f2.oriented();                                         \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
     const dimensioned<Type1>& dt1,                                             \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 )                                                                              \
 {                                                                              \
     auto tres =                                                                \
-        tmp<DimensionedField<ReturnType, GeoMesh>>::New                        \
+        reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New              \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                #Func "(" + dt1.name() + ',' + df2.name() + ')',               \
-                df2.instance(),                                                \
-                df2.db()                                                       \
-            ),                                                                 \
-            df2.mesh(),                                                        \
-            Func(dt1.dimensions(), df2.dimensions())                           \
+            f2,                                                                \
+            #Func "(" + dt1.name() + ',' + f2.name() + ')',                    \
+            Func(dt1.dimensions(), f2.dimensions())                            \
         );                                                                     \
                                                                                \
-    Func(tres.ref().field(), dt1.value(), df2.field());                        \
-    tres.ref().oriented() = df2.oriented();                                    \
-                                                                               \
+    Foam::Func(tres.ref(), dt1, f2);                                           \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -282,11 +292,11 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const Type1& t1,                                                           \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    const Type1& s1,                                                           \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 )                                                                              \
 {                                                                              \
-    return Func(dimensioned<Type1>(t1), df2);                                  \
+    return Foam::Func(dimensioned<Type1>(s1), f2);                             \
 }                                                                              \
                                                                                \
                                                                                \
@@ -294,63 +304,66 @@ TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
     const dimensioned<Type1>& dt1,                                             \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 )                                                                              \
 {                                                                              \
-    const DimensionedField<Type2, GeoMesh>& df2 = tdf2();                      \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New              \
         (                                                                      \
-            tdf2,                                                              \
-            #Func "(" + dt1.name() + ',' + df2.name() + ')',                   \
-            Func(dt1.dimensions(), df2.dimensions())                           \
+            tf2,                                                               \
+            #Func "(" + dt1.name() + ',' + f2.name() + ')',                    \
+            Func(dt1.dimensions(), f2.dimensions())                            \
         );                                                                     \
                                                                                \
-    Func(tres.ref().field(), dt1.value(), df2.field());                        \
-    tres.ref().oriented() = df2.oriented();                                    \
-                                                                               \
-    tdf2.clear();                                                              \
+    Foam::Func(tres.ref(), dt1, f2);                                           \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
-                                                                               \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const Type1& t1,                                                           \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const Type1& s1,                                                           \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 )                                                                              \
 {                                                                              \
-    return Func(dimensioned<Type2>(t1), tdf2);                                 \
+    return Foam::Func(dimensioned<Type2>(s1), tf2);                            \
 }
 
 
 #define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)                \
                                                                                \
 TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const dimensioned<Type2>& dt2                                              \
+)                                                                              \
+{                                                                              \
+    /* TBD: reset dimensions? */                                               \
+    Func(result.field(), f1.field(), dt2.value());                             \
+    result.oriented() = f1.oriented();                                         \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
     const dimensioned<Type2>& dt2                                              \
 )                                                                              \
 {                                                                              \
     auto tres =                                                                \
-        tmp<DimensionedField<ReturnType, GeoMesh>>::New                        \
+        reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New              \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                #Func "(" + df1.name() + ',' + dt2.name() + ')',               \
-                df1.instance(),                                                \
-                df1.db()                                                       \
-            ),                                                                 \
-            df1.mesh(),                                                        \
-            Func(df1.dimensions(), dt2.dimensions())                           \
+            f1,                                                                \
+            #Func "(" + f1.name() + ',' + dt2.name() + ')',                    \
+            Func(f1.dimensions(), dt2.dimensions())                            \
         );                                                                     \
                                                                                \
-    Func(tres.ref().field(), df1.field(), dt2.value());                        \
-    tres.ref().oriented() = df1.oriented();                                    \
-                                                                               \
+    Foam::Func(tres.ref(), f1, dt2);                                           \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -358,35 +371,33 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
-    const Type2& t2                                                            \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    return Func(df1, dimensioned<Type2>(t2));                                  \
+    return Foam::Func(f1, dimensioned<Type2>(s2));                             \
 }                                                                              \
                                                                                \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
     const dimensioned<Type2>& dt2                                              \
 )                                                                              \
 {                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1 = tdf1();                      \
+    const auto& f1 = tf1();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New              \
         (                                                                      \
-            tdf1,                                                              \
-            #Func "(" + df1.name() + ',' + dt2.name() + ')',                   \
-            Func(df1.dimensions(), dt2.dimensions())                           \
+            tf1,                                                               \
+            #Func "(" + f1.name() + ',' + dt2.name() + ')',                    \
+            Func(f1.dimensions(), dt2.dimensions())                            \
         );                                                                     \
                                                                                \
-    Func(tres.ref().field(), df1.field(), dt2.value());                        \
-    tres.ref().oriented() = df1.oriented();                                    \
-                                                                               \
-    tdf1.clear();                                                              \
+    Foam::Func(tres.ref(), f1, dt2);                                           \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -394,11 +405,11 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
-    const Type2& t2                                                            \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    return Func(tdf1, dimensioned<Type2>(t2));                                 \
+    return Foam::Func(tf1, dimensioned<Type2>(s2));                            \
 }
 
 
@@ -412,28 +423,35 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 #define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc)          \
                                                                                \
 TEMPLATE                                                                       \
+void OpFunc                                                                    \
+(                                                                              \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
+)                                                                              \
+{                                                                              \
+    /* TBD: reset dimensions? */                                               \
+    Foam::OpFunc(result.field(), f1.field(), f2.field());                      \
+    result.oriented() = f1.oriented() Op f2.oriented();                        \
+}                                                                              \
+                                                                               \
+                                                                               \
+TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 )                                                                              \
 {                                                                              \
     auto tres =                                                                \
-        tmp<DimensionedField<ReturnType, GeoMesh>>::New                        \
+        reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New              \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                '(' + df1.name() + OpName + df2.name() + ')',                  \
-                df1.instance(),                                                \
-                df1.db()                                                       \
-            ),                                                                 \
-            df1.mesh(),                                                        \
-            df1.dimensions() Op df2.dimensions()                               \
+            f1,                                                                \
+            '(' + f1.name() + OpName + f2.name() + ')',                        \
+            (f1.dimensions() Op f2.dimensions())                               \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref().field(), df1.field(), df2.field());                \
-    tres.ref().oriented() = df1.oriented() Op df2.oriented();                  \
-                                                                               \
+    Foam::OpFunc(tres.ref(), f1, f2);                                          \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -441,24 +459,22 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 )                                                                              \
 {                                                                              \
-    const DimensionedField<Type2, GeoMesh>& df2 = tdf2();                      \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New              \
         (                                                                      \
-            tdf2,                                                              \
-            '(' + df1.name() + OpName + df2.name() + ')',                      \
-            df1.dimensions() Op df2.dimensions()                               \
+            tf2,                                                               \
+            '(' + f1.name() + OpName + f2.name() + ')',                        \
+            (f1.dimensions() Op f2.dimensions())                               \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref().field(), df1.field(), df2.field());                \
-    tres.ref().oriented() = df1.oriented() Op df2.oriented();                  \
-                                                                               \
-    tdf2.clear();                                                              \
+    Foam::OpFunc(tres.ref(), f1, f2);                                          \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -466,53 +482,48 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 )                                                                              \
 {                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1 = tdf1();                      \
+    const auto& f1 = tf1();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New              \
         (                                                                      \
-            tdf1,                                                              \
-            '(' + df1.name() + OpName + df2.name() + ')',                      \
-            df1.dimensions() Op df2.dimensions()                               \
+            tf1,                                                               \
+            '(' + f1.name() + OpName + f2.name() + ')',                        \
+            (f1.dimensions() Op f2.dimensions())                               \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref().field(), df1.field(), df2.field());                \
-    tres.ref().oriented() = df1.oriented() Op df2.oriented();                  \
-                                                                               \
-    tdf1.clear();                                                              \
+    Foam::OpFunc(tres.ref(), f1, f2);                                          \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
-                                                                               \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 )                                                                              \
 {                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1 = tdf1();                      \
-    const DimensionedField<Type2, GeoMesh>& df2 = tdf2();                      \
+    const auto& f1 = tf1();                                                    \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpTmpDimensionedField                                            \
         <ReturnType, Type1, Type1, Type2, GeoMesh>::New                        \
         (                                                                      \
-            tdf1,                                                              \
-            tdf2,                                                              \
-            '(' + df1.name() + OpName + df2.name() + ')',                      \
-            df1.dimensions() Op df2.dimensions()                               \
+            tf1,                                                               \
+            tf2,                                                               \
+            '(' + f1.name() + OpName + f2.name() + ')',                        \
+            f1.dimensions() Op f2.dimensions()                                 \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref().field(), df1.field(), df2.field());                \
-    tres.ref().oriented() = df1.oriented() Op df2.oriented();                  \
-                                                                               \
-    tdf1.clear();                                                              \
-    tdf2.clear();                                                              \
+    Foam::OpFunc(tres.ref(), f1, f2);                                          \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }
 
@@ -522,29 +533,34 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 #define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc)  \
                                                                                \
 TEMPLATE                                                                       \
+void OpFunc                                                                    \
+(                                                                              \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const dimensioned<Type1>& dt1,                                             \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
+)                                                                              \
+{                                                                              \
+    /* TBD: reset dimensions? */                                               \
+    Foam::OpFunc(result.field(), dt1.value(), f2.field());                     \
+    result.oriented() = f2.oriented();                                         \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
     const dimensioned<Type1>& dt1,                                             \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 )                                                                              \
 {                                                                              \
     auto tres =                                                                \
-        tmp<DimensionedField<ReturnType, GeoMesh>>::New                        \
+        reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New              \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                '(' + dt1.name() + OpName + df2.name() + ')',                  \
-                df2.instance(),                                                \
-                df2.db()                                                       \
-            ),                                                                 \
-            df2.mesh(),                                                        \
-            dt1.dimensions() Op df2.dimensions()                               \
+            f2,                                                                \
+            '(' + dt1.name() + OpName + f2.name() + ')',                       \
+            (dt1.dimensions() Op f2.dimensions())                              \
         );                                                                     \
                                                                                \
-    tres.ref().oriented() = df2.oriented();                                    \
-                                                                               \
-    Foam::OpFunc(tres.ref().field(), dt1.value(), df2.field());                \
-                                                                               \
+    Foam::OpFunc(tres.ref(), dt1, f2);                                         \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -552,11 +568,11 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const Type1& t1,                                                           \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    const Type1& s1,                                                           \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 )                                                                              \
 {                                                                              \
-    return dimensioned<Type1>(t1) Op df2;                                      \
+    return dimensioned<Type1>(s1) Op f2;                                       \
 }                                                                              \
                                                                                \
                                                                                \
@@ -564,23 +580,21 @@ TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
     const dimensioned<Type1>& dt1,                                             \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 )                                                                              \
 {                                                                              \
-    const DimensionedField<Type2, GeoMesh>& df2 = tdf2();                      \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New              \
         (                                                                      \
-            tdf2,                                                              \
-            '(' + dt1.name() + OpName + df2.name() + ')',                      \
-            dt1.dimensions() Op df2.dimensions()                               \
+            tf2,                                                               \
+            '(' + dt1.name() + OpName + f2.name() + ')',                       \
+            (dt1.dimensions() Op f2.dimensions())                              \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref().field(), dt1.value(), tdf2().field());             \
-    tres.ref().oriented() = df2.oriented();                                    \
-                                                                               \
-    tdf2.clear();                                                              \
+    Foam::OpFunc(tres.ref(), dt1, f2);                                         \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -588,39 +602,45 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const Type1& t1,                                                           \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const Type1& s1,                                                           \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 )                                                                              \
 {                                                                              \
-    return dimensioned<Type1>(t1) Op tdf2;                                     \
+    return dimensioned<Type1>(s1) Op tf2;                                      \
 }
 
 
 #define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc)  \
                                                                                \
 TEMPLATE                                                                       \
+void OpFunc                                                                    \
+(                                                                              \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const dimensioned<Type2>& dt2                                              \
+)                                                                              \
+{                                                                              \
+    /* TBD: reset dimensions? */                                               \
+    Foam::OpFunc(result.field(), f1.field(), dt2.value());                     \
+    result.oriented() = f1.oriented();                                         \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
     const dimensioned<Type2>& dt2                                              \
 )                                                                              \
 {                                                                              \
     auto tres =                                                                \
-        tmp<DimensionedField<ReturnType, GeoMesh>>::New                        \
+        reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New              \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                '(' + df1.name() + OpName + dt2.name() + ')',                  \
-                df1.instance(),                                                \
-                df1.db()                                                       \
-            ),                                                                 \
-            df1.mesh(),                                                        \
-            df1.dimensions() Op dt2.dimensions()                               \
+            f1,                                                                \
+            '(' + f1.name() + OpName + dt2.name() + ')',                       \
+            (f1.dimensions() Op dt2.dimensions())                              \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref().field(), df1.field(), dt2.value());                \
-    tres.ref().oriented() = df1.oriented();                                    \
-                                                                               \
+    Foam::OpFunc(tres.ref(), f1, dt2);                                         \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -628,35 +648,33 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
-    const Type2& t2                                                            \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    return df1 Op dimensioned<Type2>(t2);                                      \
+    return f1 Op dimensioned<Type2>(s2);                                       \
 }                                                                              \
                                                                                \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
     const dimensioned<Type2>& dt2                                              \
 )                                                                              \
 {                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1 = tdf1();                      \
+    const auto& f1 = tf1();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New              \
         (                                                                      \
-            tdf1,                                                              \
-            '(' + df1.name() + OpName + dt2.name() + ')',                      \
-            df1.dimensions() Op dt2.dimensions()                               \
+            tf1,                                                               \
+            '(' + f1.name() + OpName + dt2.name() + ')',                       \
+            (f1.dimensions() Op dt2.dimensions())                              \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref().field(), tdf1().field(), dt2.value());             \
-    tres.ref().oriented() = df1.oriented();                                    \
-                                                                               \
-    tdf1.clear();                                                              \
+    Foam::OpFunc(tres.ref(), f1, dt2);                                         \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -664,11 +682,11 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
-    const Type2& t2                                                            \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    return tdf1 Op dimensioned<Type2>(t2);                                     \
+    return tf1 Op dimensioned<Type2>(s2);                                      \
 }
 
 #define BINARY_TYPE_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc)     \
diff --git a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.H b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.H
index d7484d1729..a3157242f2 100644
--- a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.H
+++ b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.H
@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -30,32 +31,46 @@ License
 #define UNARY_FUNCTION(ReturnType, Type1, Func, Dfunc)                         \
                                                                                \
 TEMPLATE                                                                       \
-tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+void Func                                                                      \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df                                 \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const DimensionedField<Type1, GeoMesh>& f1                                 \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1                          \
+    const DimensionedField<Type1, GeoMesh>& f1                                 \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1                           \
 );
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define UNARY_OPERATOR(ReturnType, Type1, Op, opFunc, Dfunc)                   \
+#define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc, Dfunc)                   \
                                                                                \
 TEMPLATE                                                                       \
-tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
+void OpFunc                                                                    \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1                                \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const DimensionedField<Type1, GeoMesh>& f1                                 \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1                          \
+    const DimensionedField<Type1, GeoMesh>& f1                                 \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1                           \
 );
 
 
@@ -64,31 +79,39 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 #define BINARY_FUNCTION(ReturnType, Type1, Type2, Func)                        \
                                                                                \
 TEMPLATE                                                                       \
-tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+void Func                                                                      \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 );
 
 
@@ -97,62 +120,78 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 #define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func)                \
                                                                                \
 TEMPLATE                                                                       \
-tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+void Func                                                                      \
 (                                                                              \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
     const dimensioned<Type1>& dt1,                                             \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
-);                                                                             \
-                                                                               \
-TEMPLATE                                                                       \
-tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
-(                                                                              \
-    const Type1& t1,                                                           \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
     const dimensioned<Type1>& dt1,                                             \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const Type1& t1,                                                           \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const Type1& s1,                                                           \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const dimensioned<Type1>& dt1,                                             \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const Type1& s1,                                                           \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 );
 
 
 #define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)                \
                                                                                \
 TEMPLATE                                                                       \
-tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+void Func                                                                      \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
     const dimensioned<Type2>& dt2                                              \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
-    const Type2& t2                                                            \
-);                                                                             \
-                                                                               \
-TEMPLATE                                                                       \
-tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
-(                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
     const dimensioned<Type2>& dt2                                              \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf2,                         \
-    const Type2& t2                                                            \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const Type2& s2                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const dimensioned<Type2>& dt2                                              \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const Type2& s2                                                            \
 );
 
 
@@ -166,31 +205,39 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
 #define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc)          \
                                                                                \
 TEMPLATE                                                                       \
-tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
+void OpFunc                                                                    \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 );
 
 
@@ -199,62 +246,78 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 #define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc)  \
                                                                                \
 TEMPLATE                                                                       \
-tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
+void OpFunc                                                                    \
 (                                                                              \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
     const dimensioned<Type1>& dt1,                                             \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
-);                                                                             \
-                                                                               \
-TEMPLATE                                                                       \
-tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
-(                                                                              \
-    const Type1& t1,                                                           \
-    const DimensionedField<Type2, GeoMesh>& df2                                \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
     const dimensioned<Type1>& dt1,                                             \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const Type1& t1,                                                           \
-    const tmp<DimensionedField<Type2, GeoMesh>>& tdf2                          \
+    const Type1& s1,                                                           \
+    const DimensionedField<Type2, GeoMesh>& f2                                 \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
+(                                                                              \
+    const dimensioned<Type1>& dt1,                                             \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
+(                                                                              \
+    const Type1& s1,                                                           \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2                           \
 );
 
 
 #define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc)  \
                                                                                \
 TEMPLATE                                                                       \
-tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
+void OpFunc                                                                    \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
     const dimensioned<Type2>& dt2                                              \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const DimensionedField<Type1, GeoMesh>& df1,                               \
-    const Type2& t2                                                            \
-);                                                                             \
-                                                                               \
-TEMPLATE                                                                       \
-tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
-(                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
     const dimensioned<Type2>& dt2                                              \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
 (                                                                              \
-    const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,                         \
-    const Type2& t2                                                            \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const Type2& s2                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const dimensioned<Type2>& dt2                                              \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const Type2& s2                                                            \
 );
 
 
diff --git a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldReuseFunctions.H b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldReuseFunctions.H
index 4edd1b6f32..c1aae8ca0a 100644
--- a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldReuseFunctions.H
+++ b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldReuseFunctions.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2022 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -35,28 +35,51 @@ namespace Foam
 {
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// One-parameter versions
 
 template<class TypeR, class Type1, class GeoMesh>
 struct reuseTmpDimensionedField
 {
+    //- Pass-through to New DimensionedField
     static tmp<DimensionedField<TypeR, GeoMesh>> New
     (
-        const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,
+        const DimensionedField<Type1, GeoMesh>& f1,
         const word& name,
         const dimensionSet& dimensions
     )
     {
-        const auto& df1 = tdf1();
+        return tmp<DimensionedField<TypeR, GeoMesh>>::New
+        (
+            IOobject
+            (
+                name,
+                f1.instance(),
+                f1.db()
+            ),
+            f1.mesh(),
+            dimensions
+        );
+    }
+
+    //- Dissimilar types: return new field
+    static tmp<DimensionedField<TypeR, GeoMesh>> New
+    (
+        const tmp<DimensionedField<Type1, GeoMesh>>& tf1,
+        const word& name,
+        const dimensionSet& dimensions
+    )
+    {
+        const auto& f1 = tf1();
 
         return tmp<DimensionedField<TypeR, GeoMesh>>::New
         (
             IOobject
             (
                 name,
-                df1.instance(),
-                df1.db()
+                f1.instance(),
+                f1.db()
             ),
-            df1.mesh(),
+            f1.mesh(),
             dimensions
         );
     }
@@ -70,38 +93,38 @@ struct reuseTmpDimensionedField<TypeR, TypeR, GeoMesh>
     //- for identical input and output types
     static tmp<DimensionedField<TypeR, GeoMesh>> New
     (
-        const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1,
+        const tmp<DimensionedField<TypeR, GeoMesh>>& tf1,
         const word& name,
         const dimensionSet& dimensions,
         const bool initCopy = false
     )
     {
-        if (tdf1.movable())
+        if (tf1.movable())
         {
-            auto& df1 = tdf1.constCast();
+            auto& f1 = tf1.constCast();
 
-            df1.rename(name);
-            df1.dimensions().reset(dimensions);
-            return tdf1;
+            f1.rename(name);
+            f1.dimensions().reset(dimensions);
+            return tf1;
         }
 
-        const auto& df1 = tdf1();
+        const auto& f1 = tf1();
 
         auto tresult = tmp<DimensionedField<TypeR, GeoMesh>>::New
         (
             IOobject
             (
                 name,
-                df1.instance(),
-                df1.db()
+                f1.instance(),
+                f1.db()
             ),
-            df1.mesh(),
+            f1.mesh(),
             dimensions
         );
 
         if (initCopy)
         {
-            tresult.ref().field() = tdf1().field();
+            tresult.ref().field() = tf1().field();
         }
 
         return tresult;
@@ -113,7 +136,7 @@ struct reuseTmpDimensionedField<TypeR, TypeR, GeoMesh>
 template<class TypeR, class GeoMesh>
 tmp<DimensionedField<TypeR, GeoMesh>> New
 (
-    const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1,
+    const tmp<DimensionedField<TypeR, GeoMesh>>& tf1,
     const word& name,
     const dimensionSet& dimensions,
     const bool initCopy = false
@@ -121,7 +144,7 @@ tmp<DimensionedField<TypeR, GeoMesh>> New
 {
     return reuseTmpDimensionedField<TypeR, TypeR, GeoMesh>::New
     (
-        tdf1,
+        tf1,
         name,
         dimensions,
         initCopy
@@ -134,23 +157,23 @@ struct reuseTmpTmpDimensionedField
 {
     static tmp<DimensionedField<TypeR, GeoMesh>> New
     (
-        const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,
-        const tmp<DimensionedField<Type2, GeoMesh>>& tdf2,
+        const tmp<DimensionedField<Type1, GeoMesh>>& tf1,
+        const tmp<DimensionedField<Type2, GeoMesh>>& tf2,
         const word& name,
         const dimensionSet& dimensions
     )
     {
-        const auto& df1 = tdf1();
+        const auto& f1 = tf1();
 
         return tmp<DimensionedField<TypeR, GeoMesh>>::New
         (
             IOobject
             (
                 name,
-                df1.instance(),
-                df1.db()
+                f1.instance(),
+                f1.db()
             ),
-            df1.mesh(),
+            f1.mesh(),
             dimensions
         );
     }
@@ -162,32 +185,32 @@ struct reuseTmpTmpDimensionedField<TypeR, Type1, Type12, TypeR, GeoMesh>
 {
     static tmp<DimensionedField<TypeR, GeoMesh>> New
     (
-        const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,
-        const tmp<DimensionedField<TypeR, GeoMesh>>& tdf2,
+        const tmp<DimensionedField<Type1, GeoMesh>>& tf1,
+        const tmp<DimensionedField<TypeR, GeoMesh>>& tf2,
         const word& name,
         const dimensionSet& dimensions
     )
     {
-        if (tdf2.movable())
+        if (tf2.movable())
         {
-            auto& df2 = tdf2.constCast();
+            auto& f2 = tf2.constCast();
 
-            df2.rename(name);
-            df2.dimensions().reset(dimensions);
-            return tdf2;
+            f2.rename(name);
+            f2.dimensions().reset(dimensions);
+            return tf2;
         }
 
-        const auto& df1 = tdf1();
+        const auto& f1 = tf1();
 
         return tmp<DimensionedField<TypeR, GeoMesh>>::New
         (
             IOobject
             (
                 name,
-                df1.instance(),
-                df1.db()
+                f1.instance(),
+                f1.db()
             ),
-            df1.mesh(),
+            f1.mesh(),
             dimensions
         );
     }
@@ -199,32 +222,32 @@ struct reuseTmpTmpDimensionedField<TypeR, TypeR, TypeR, Type2, GeoMesh>
 {
     static tmp<DimensionedField<TypeR, GeoMesh>> New
     (
-        const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1,
-        const tmp<DimensionedField<Type2, GeoMesh>>& tdf2,
+        const tmp<DimensionedField<TypeR, GeoMesh>>& tf1,
+        const tmp<DimensionedField<Type2, GeoMesh>>& tf2,
         const word& name,
         const dimensionSet& dimensions
     )
     {
-        if (tdf1.movable())
+        if (tf1.movable())
         {
-            auto& df1 = tdf1.constCast();
+            auto& f1 = tf1.constCast();
 
-            df1.rename(name);
-            df1.dimensions().reset(dimensions);
-            return tdf1;
+            f1.rename(name);
+            f1.dimensions().reset(dimensions);
+            return tf1;
         }
 
-        const auto& df1 = tdf1();
+        const auto& f1 = tf1();
 
         return tmp<DimensionedField<TypeR, GeoMesh>>::New
         (
             IOobject
             (
                 name,
-                df1.instance(),
-                df1.db()
+                f1.instance(),
+                f1.db()
             ),
-            df1.mesh(),
+            f1.mesh(),
             dimensions
         );
     }
@@ -236,40 +259,40 @@ struct reuseTmpTmpDimensionedField<TypeR, TypeR, TypeR, TypeR, GeoMesh>
 {
     static tmp<DimensionedField<TypeR, GeoMesh>> New
     (
-        const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1,
-        const tmp<DimensionedField<TypeR, GeoMesh>>& tdf2,
+        const tmp<DimensionedField<TypeR, GeoMesh>>& tf1,
+        const tmp<DimensionedField<TypeR, GeoMesh>>& tf2,
         const word& name,
         const dimensionSet& dimensions
     )
     {
-        if (tdf1.movable())
+        if (tf1.movable())
         {
-            auto& df1 = tdf1.constCast();
+            auto& f1 = tf1.constCast();
 
-            df1.rename(name);
-            df1.dimensions().reset(dimensions);
-            return tdf1;
+            f1.rename(name);
+            f1.dimensions().reset(dimensions);
+            return tf1;
         }
-        if (tdf2.movable())
+        if (tf2.movable())
         {
-            auto& df2 = tdf2.constCast();
+            auto& f2 = tf2.constCast();
 
-            df2.rename(name);
-            df2.dimensions().reset(dimensions);
-            return tdf2;
+            f2.rename(name);
+            f2.dimensions().reset(dimensions);
+            return tf2;
         }
 
-        const auto& df1 = tdf1();
+        const auto& f1 = tf1();
 
         return tmp<DimensionedField<TypeR, GeoMesh>>::New
         (
             IOobject
             (
                 name,
-                df1.instance(),
-                df1.db()
+                f1.instance(),
+                f1.db()
             ),
-            df1.mesh(),
+            f1.mesh(),
             dimensions
         );
     }
diff --git a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.C b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.C
index 9be878df3d..abfeab9928 100644
--- a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.C
+++ b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2022 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -90,12 +90,9 @@ pow
     const FieldField<Field, Type>& f, typename powProduct<Type, r>::type
 )
 {
-    typedef typename powProduct<Type, r>::type powProductType;
+    typedef typename powProduct<Type, r>::type resultType;
 
-    auto tres
-    (
-        FieldField<Field, powProductType>::NewCalculatedType(f)
-    );
+    auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
 
     pow<Type, r>(tres.ref(), f);
     return tres;
@@ -108,12 +105,9 @@ pow
     const tmp<FieldField<Field, Type>>& tf, typename powProduct<Type, r>::type
 )
 {
-    typedef typename powProduct<Type, r>::type powProductType;
+    typedef typename powProduct<Type, r>::type resultType;
 
-    auto tres
-    (
-        reuseTmpFieldField<Field, powProductType, Type>::New(tf)
-    );
+    auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
 
     pow<Type, r>(tres.ref(), tf());
     tf.clear();
@@ -140,11 +134,10 @@ template<template<class> class Field, class Type>
 tmp<FieldField<Field, typename outerProduct<Type, Type>::type>>
 sqr(const FieldField<Field, Type>& f)
 {
-    typedef typename outerProduct<Type, Type>::type outerProductType;
-    tmp<FieldField<Field, outerProductType>> tres
-    (
-        FieldField<Field, outerProductType>::NewCalculatedType(f)
-    );
+    typedef typename outerProduct<Type, Type>::type resultType;
+
+    auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
+
     sqr(tres.ref(), f);
     return tres;
 }
@@ -153,12 +146,9 @@ template<template<class> class Field, class Type>
 tmp<FieldField<Field, typename outerProduct<Type, Type>::type>>
 sqr(const tmp<FieldField<Field, Type>>& tf)
 {
-    typedef typename outerProduct<Type, Type>::type outerProductType;
+    typedef typename outerProduct<Type, Type>::type resultType;
 
-    auto tres
-    (
-        reuseTmpFieldField<Field, outerProductType, Type>::New(tf)
-    );
+    auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
 
     sqr(tres.ref(), tf());
     tf.clear();
@@ -185,12 +175,9 @@ template<template<class> class Field, class Type>
 tmp<FieldField<Field, typename typeOfMag<Type>::type>>
 magSqr(const FieldField<Field, Type>& f)
 {
-    typedef typename typeOfMag<Type>::type magType;
+    typedef typename typeOfMag<Type>::type resultType;
 
-    auto tres
-    (
-        FieldField<Field, magType>::NewCalculatedType(f)
-    );
+    auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
 
     magSqr(tres.ref(), f);
     return tres;
@@ -200,12 +187,9 @@ template<template<class> class Field, class Type>
 tmp<FieldField<Field, typename typeOfMag<Type>::type>>
 magSqr(const tmp<FieldField<Field, Type>>& tf)
 {
-    typedef typename typeOfMag<Type>::type magType;
+    typedef typename typeOfMag<Type>::type resultType;
 
-    auto tres
-    (
-        reuseTmpFieldField<Field, magType, Type>::New(tf)
-    );
+    auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
 
     magSqr(tres.ref(), tf());
     tf.clear();
@@ -232,12 +216,9 @@ template<template<class> class Field, class Type>
 tmp<FieldField<Field, typename typeOfMag<Type>::type>>
 mag(const FieldField<Field, Type>& f)
 {
-    typedef typename typeOfMag<Type>::type magType;
+    typedef typename typeOfMag<Type>::type resultType;
 
-    auto tres
-    (
-        FieldField<Field, magType>::NewCalculatedType(f)
-    );
+    auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
 
     mag(tres.ref(), f);
     return tres;
@@ -247,12 +228,9 @@ template<template<class> class Field, class Type>
 tmp<FieldField<Field, typename typeOfMag<Type>::type>>
 mag(const tmp<FieldField<Field, Type>>& tf)
 {
-    typedef typename typeOfMag<Type>::type magType;
+    typedef typename typeOfMag<Type>::type resultType;
 
-    auto tres
-    (
-        reuseTmpFieldField<Field, magType, Type>::New(tf)
-    );
+    auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
 
     mag(tres.ref(), tf());
     tf.clear();
@@ -281,12 +259,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMax
     const FieldField<Field, Type>& f
 )
 {
-    typedef typename FieldField<Field, Type>::cmptType cmptType;
+    typedef typename FieldField<Field, Type>::cmptType resultType;
 
-    auto tres
-    (
-        FieldField<Field, cmptType>::NewCalculatedType(f)
-    );
+    auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
 
     cmptMax(tres.ref(), f);
     return tres;
@@ -298,12 +273,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMax
     const tmp<FieldField<Field, Type>>& tf
 )
 {
-    typedef typename FieldField<Field, Type>::cmptType cmptType;
+    typedef typename FieldField<Field, Type>::cmptType resultType;
 
-    auto tres
-    (
-        reuseTmpFieldField<Field, cmptType, Type>::New(tf)
-    );
+    auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
 
     cmptMax(tres.ref(), tf());
     tf.clear();
@@ -332,12 +304,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMin
     const FieldField<Field, Type>& f
 )
 {
-    typedef typename FieldField<Field, Type>::cmptType cmptType;
+    typedef typename FieldField<Field, Type>::cmptType resultType;
 
-    auto tres
-    (
-        FieldField<Field, cmptType>::NewCalculatedType(f)
-    );
+    auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
 
     cmptMin(tres.ref(), f);
     return tres;
@@ -349,12 +318,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMin
     const tmp<FieldField<Field, Type>>& tf
 )
 {
-    typedef typename FieldField<Field, Type>::cmptType cmptType;
+    typedef typename FieldField<Field, Type>::cmptType resultType;
 
-    auto tres
-    (
-        reuseTmpFieldField<Field, cmptType, Type>::New(tf)
-    );
+    auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
 
     cmptMin(tres.ref(), tf());
     tf.clear();
@@ -383,12 +349,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptAv
     const FieldField<Field, Type>& f
 )
 {
-    typedef typename FieldField<Field, Type>::cmptType cmptType;
+    typedef typename FieldField<Field, Type>::cmptType resultType;
 
-    auto tres
-    (
-        FieldField<Field, cmptType>::NewCalculatedType(f)
-    );
+    auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
 
     cmptAv(tres.ref(), f);
     return tres;
@@ -400,12 +363,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptAv
     const tmp<FieldField<Field, Type>>& tf
 )
 {
-    typedef typename FieldField<Field, Type>::cmptType cmptType;
+    typedef typename FieldField<Field, Type>::cmptType resultType;
 
-    auto tres
-    (
-        reuseTmpFieldField<Field, cmptType, Type>::New(tf)
-    );
+    auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
 
     cmptAv(tres.ref(), tf());
     tf.clear();
@@ -434,10 +394,7 @@ tmp<FieldField<Field, Type>> cmptMag
     const FieldField<Field, Type>& f
 )
 {
-    auto tres
-    (
-        FieldField<Field, Type>::NewCalculatedType(f)
-    );
+    auto tres = FieldField<Field, Type>::NewCalculatedType(f);
 
     cmptMag(tres.ref(), f);
     return tres;
@@ -456,12 +413,12 @@ tmp<FieldField<Field, Type>> cmptMag
 }
 
 
-#define TMP_UNARY_FUNCTION(returnType, func)                                   \
+#define TMP_UNARY_FUNCTION(ReturnType, Func)                                   \
                                                                                \
 template<template<class> class Field, class Type>                              \
-returnType func(const tmp<FieldField<Field, Type>>& tf1)                       \
+ReturnType Func(const tmp<FieldField<Field, Type>>& tf1)                       \
 {                                                                              \
-    returnType res = func(tf1());                                              \
+    ReturnType res = Func(tf1());                                              \
     tf1.clear();                                                               \
     return res;                                                                \
 }
@@ -529,9 +486,9 @@ TMP_UNARY_FUNCTION(Type, sum)
 template<template<class> class Field, class Type>
 typename typeOfMag<Type>::type sumMag(const FieldField<Field, Type>& f)
 {
-    typedef typename typeOfMag<Type>::type magType;
+    typedef typename typeOfMag<Type>::type resultType;
 
-    magType result = Zero;
+    resultType result = Zero;
 
     const label loopLen = (f).size();
 
@@ -609,12 +566,12 @@ TMP_UNARY_FUNCTION(scalarMinMax, minMaxMag)
 
 
 // With reduction on ReturnType
-#define G_UNARY_FUNCTION(ReturnType, gFunc, func, rFunc)                       \
+#define G_UNARY_FUNCTION(ReturnType, gFunc, Func, rFunc)                       \
                                                                                \
 template<template<class> class Field, class Type>                              \
 ReturnType gFunc(const FieldField<Field, Type>& f)                             \
 {                                                                              \
-    ReturnType res = func(f);                                                  \
+    ReturnType res = Func(f);                                                  \
     reduce(res, rFunc##Op<ReturnType>());                                      \
     return res;                                                                \
 }                                                                              \
@@ -653,7 +610,7 @@ Type gAverage(const FieldField<Field, Type>& f)
     }
 
     WarningInFunction
-        << "empty fieldField, returning zero" << endl;
+        << "Empty FieldField, returning zero" << endl;
 
     return Zero;
 }
@@ -676,7 +633,7 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
 BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
 
 
-/* * * * * * * * * * * * * * * * Global operators  * * * * * * * * * * * * * */
+/* * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * */
 
 UNARY_OPERATOR(Type, Type, -, negate)
 
@@ -692,7 +649,7 @@ BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, divide)
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define PRODUCT_OPERATOR(product, op, opFunc)                                  \
+#define PRODUCT_OPERATOR(product, Op, OpFunc)                                  \
                                                                                \
 template                                                                       \
 <                                                                              \
@@ -701,7 +658,7 @@ template                                                                       \
     class Type1,                                                               \
     class Type2                                                                \
 >                                                                              \
-void opFunc                                                                    \
+void OpFunc                                                                    \
 (                                                                              \
     FieldField<Field1, typename product<Type1, Type2>::type>& f,               \
     const FieldField<Field1, Type1>& f1,                                       \
@@ -712,7 +669,7 @@ void opFunc                                                                    \
                                                                                \
     for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
-        opFunc(f[i], f1[i], f2[i]);                                            \
+        OpFunc(f[i], f1[i], f2[i]);                                            \
     }                                                                          \
 }                                                                              \
                                                                                \
@@ -724,35 +681,29 @@ template                                                                       \
     class Type2                                                                \
 >                                                                              \
 tmp<FieldField<Field1, typename product<Type1, Type2>::type>>                  \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const FieldField<Field1, Type1>& f1,                                       \
     const FieldField<Field2, Type2>& f2                                        \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
-    tmp<FieldField<Field1, productType>> tres                                  \
-    (                                                                          \
-        FieldField<Field1, productType>::NewCalculatedType(f1)                 \
-    );                                                                         \
-    opFunc(tres.ref(), f1, f2);                                                \
+    typedef typename product<Type1, Type2>::type resultType;                   \
+    auto tres = FieldField<Field1, resultType>::NewCalculatedType(f1);         \
+    OpFunc(tres.ref(), f1, f2);                                                \
     return tres;                                                               \
 }                                                                              \
                                                                                \
 template<template<class> class Field, class Type1, class Type2>                \
 tmp<FieldField<Field, typename product<Type1, Type2>::type>>                   \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const FieldField<Field, Type1>& f1,                                        \
     const tmp<FieldField<Field, Type2>>& tf2                                   \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
-    tmp<FieldField<Field, productType>> tres                                   \
-    (                                                                          \
-        reuseTmpFieldField<Field, productType, Type2>::New(tf2)                \
-    );                                                                         \
-    opFunc(tres.ref(), f1, tf2());                                             \
+    typedef typename product<Type1, Type2>::type resultType;                   \
+    auto tres = reuseTmpFieldField<Field, resultType, Type2>::New(tf2);        \
+    OpFunc(tres.ref(), f1, tf2());                                             \
     tf2.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
@@ -765,18 +716,15 @@ template                                                                       \
     class Type2                                                                \
 >                                                                              \
 tmp<FieldField<Field, typename product<Type1, Type2>::type>>                   \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const FieldField<Field1, Type1>& f1,                                       \
     const tmp<FieldField<Field2, Type2>>& tf2                                  \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
-    tmp<FieldField<Field1, productType>> tres                                  \
-    (                                                                          \
-        FieldField<Field1, productType>::NewCalculatedType(f1)                 \
-    );                                                                         \
-    opFunc(tres.ref(), f1, tf2());                                             \
+    typedef typename product<Type1, Type2>::type resultType;                   \
+    auto tres = FieldField<Field1, resultType>::NewCalculatedType(f1);         \
+    OpFunc(tres.ref(), f1, tf2());                                             \
     tf2.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
@@ -789,18 +737,15 @@ template                                                                       \
     class Type2                                                                \
 >                                                                              \
 tmp<FieldField<Field1, typename product<Type1, Type2>::type>>                  \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const tmp<FieldField<Field1, Type1>>& tf1,                                 \
     const FieldField<Field2, Type2>& f2                                        \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
-    tmp<FieldField<Field1, productType>> tres                                  \
-    (                                                                          \
-        reuseTmpFieldField<Field1, productType, Type1>::New(tf1)               \
-    );                                                                         \
-    opFunc(tres.ref(), tf1(), f2);                                             \
+    typedef typename product<Type1, Type2>::type resultType;                   \
+    auto tres = reuseTmpFieldField<Field1, resultType, Type1>::New(tf1);       \
+    OpFunc(tres.ref(), tf1(), f2);                                             \
     tf1.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
@@ -813,19 +758,19 @@ template                                                                       \
     class Type2                                                                \
 >                                                                              \
 tmp<FieldField<Field1, typename product<Type1, Type2>::type>>                  \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const tmp<FieldField<Field1, Type1>>& tf1,                                 \
     const tmp<FieldField<Field2, Type2>>& tf2                                  \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
-    tmp<FieldField<Field1, productType>> tres                                  \
+    typedef typename product<Type1, Type2>::type resultType;                   \
+    auto tres                                                                  \
     (                                                                          \
-        reuseTmpTmpFieldField<Field1, productType, Type1, Type1, Type2>::New   \
+        reuseTmpTmpFieldField<Field1, resultType, Type1, Type1, Type2>::New    \
         (tf1, tf2)                                                             \
     );                                                                         \
-    opFunc(tres.ref(), tf1(), tf2());                                          \
+    OpFunc(tres.ref(), tf1(), tf2());                                          \
     tf1.clear();                                                               \
     tf2.clear();                                                               \
     return tres;                                                               \
@@ -839,18 +784,18 @@ template                                                                       \
     class Cmpt,                                                                \
     direction nCmpt                                                            \
 >                                                                              \
-void opFunc                                                                    \
+void OpFunc                                                                    \
 (                                                                              \
-    FieldField<Field, typename product<Type, Form>::type>& f,                  \
+    FieldField<Field, typename product<Type, Form>::type>& result,             \
     const FieldField<Field, Type>& f1,                                         \
     const VectorSpace<Form,Cmpt,nCmpt>& vs                                     \
 )                                                                              \
 {                                                                              \
-    const label loopLen = (f).size();                                          \
+    const label loopLen = (result).size();                                     \
                                                                                \
     for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
-        opFunc(f[i], f1[i], vs);                                               \
+        OpFunc(result[i], f1[i], vs);                                          \
     }                                                                          \
 }                                                                              \
                                                                                \
@@ -863,18 +808,15 @@ template                                                                       \
     direction nCmpt                                                            \
 >                                                                              \
 tmp<FieldField<Field, typename product<Type, Form>::type>>                     \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const FieldField<Field, Type>& f1,                                         \
     const VectorSpace<Form,Cmpt,nCmpt>& vs                                     \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type, Form>::type productType;                    \
-    tmp<FieldField<Field, productType>> tres                                   \
-    (                                                                          \
-        FieldField<Field, productType>::NewCalculatedType(f1)                  \
-    );                                                                         \
-    opFunc(tres.ref(), f1, static_cast<const Form&>(vs));                      \
+    typedef typename product<Type, Form>::type resultType;                     \
+    auto tres = FieldField<Field, resultType>::NewCalculatedType(f1);          \
+    OpFunc(tres.ref(), f1, static_cast<const Form&>(vs));                      \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -887,18 +829,15 @@ template                                                                       \
     direction nCmpt                                                            \
 >                                                                              \
 tmp<FieldField<Field, typename product<Type, Form>::type>>                     \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const tmp<FieldField<Field, Type>>& tf1,                                   \
     const VectorSpace<Form,Cmpt,nCmpt>& vs                                     \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type, Form>::type productType;                    \
-    tmp<FieldField<Field, productType>> tres                                   \
-    (                                                                          \
-        reuseTmpFieldField<Field, productType, Type>::New(tf1)                 \
-    );                                                                         \
-    opFunc(tres.ref(), tf1(), static_cast<const Form&>(vs));                   \
+    typedef typename product<Type, Form>::type resultType;                     \
+    auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf1);         \
+    OpFunc(tres.ref(), tf1(), static_cast<const Form&>(vs));                   \
     tf1.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
@@ -911,18 +850,18 @@ template                                                                       \
     class Cmpt,                                                                \
     direction nCmpt                                                            \
 >                                                                              \
-void opFunc                                                                    \
+void OpFunc                                                                    \
 (                                                                              \
-    FieldField<Field, typename product<Form, Type>::type>& f,                  \
+    FieldField<Field, typename product<Form, Type>::type>& result,             \
     const VectorSpace<Form,Cmpt,nCmpt>& vs,                                    \
     const FieldField<Field, Type>& f1                                          \
 )                                                                              \
 {                                                                              \
-    const label loopLen = (f).size();                                          \
+    const label loopLen = (result).size();                                     \
                                                                                \
     for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
-        opFunc(f[i], vs, f1[i]);                                               \
+        OpFunc(result[i], vs, f1[i]);                                          \
     }                                                                          \
 }                                                                              \
                                                                                \
@@ -935,18 +874,15 @@ template                                                                       \
     direction nCmpt                                                            \
 >                                                                              \
 tmp<FieldField<Field, typename product<Form, Type>::type>>                     \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const VectorSpace<Form,Cmpt,nCmpt>& vs,                                    \
     const FieldField<Field, Type>& f1                                          \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Form, Type>::type productType;                    \
-    tmp<FieldField<Field, productType>> tres                                   \
-    (                                                                          \
-        FieldField<Field, productType>::NewCalculatedType(f1)                  \
-    );                                                                         \
-    opFunc(tres.ref(), static_cast<const Form&>(vs), f1);                      \
+    typedef typename product<Form, Type>::type resultType;                     \
+    auto tres = FieldField<Field, resultType>::NewCalculatedType(f1);          \
+    OpFunc(tres.ref(), static_cast<const Form&>(vs), f1);                      \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -959,18 +895,15 @@ template                                                                       \
     direction nCmpt                                                            \
 >                                                                              \
 tmp<FieldField<Field, typename product<Form, Type>::type>>                     \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const VectorSpace<Form,Cmpt,nCmpt>& vs,                                    \
     const tmp<FieldField<Field, Type>>& tf1                                    \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Form, Type>::type productType;                    \
-    tmp<FieldField<Field, productType>> tres                                   \
-    (                                                                          \
-        reuseTmpFieldField<Field, productType, Type>::New(tf1)                 \
-    );                                                                         \
-    opFunc(tres.ref(), static_cast<const Form&>(vs), tf1());                   \
+    typedef typename product<Form, Type>::type resultType;                     \
+    auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf1);         \
+    OpFunc(tres.ref(), static_cast<const Form&>(vs), tf1());                   \
     tf1.clear();                                                               \
     return tres;                                                               \
 }
diff --git a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.H b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.H
index a9a7084e97..b1b0501e95 100644
--- a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.H
+++ b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.H
@@ -290,7 +290,7 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
 BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
 
 
-/* * * * * * * * * * * * * * * * Global operators  * * * * * * * * * * * * * */
+/* * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * */
 
 UNARY_OPERATOR(Type, Type, -, negate)
 
diff --git a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.C b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.C
index 500cd8d54e..d2dc88ce0b 100644
--- a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.C
+++ b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2022 OpenCFD Ltd.
+    Copyright (C) 2022-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -31,92 +31,86 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define UNARY_FUNCTION(ReturnType, Type, Func)                                 \
+#define UNARY_FUNCTION(ReturnType, Type1, Func)                                \
                                                                                \
 TEMPLATE                                                                       \
 void Func                                                                      \
 (                                                                              \
-    FieldField<Field, ReturnType>& res,                                        \
-    const FieldField<Field, Type>& f                                           \
+    FieldField<Field, ReturnType>& result,                                     \
+    const FieldField<Field, Type1>& f1                                         \
 )                                                                              \
 {                                                                              \
-    const label loopLen = (res).size();                                        \
+    const label loopLen = (result).size();                                     \
                                                                                \
     for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
-        Func(res[i], f[i]);                                                    \
+        Func(result[i], f1[i]);                                                \
     }                                                                          \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
-    const FieldField<Field, Type>& f                                           \
+    const FieldField<Field, Type1>& f1                                         \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
-    (                                                                          \
-        FieldField<Field, ReturnType>::NewCalculatedType(f)                    \
-    );                                                                         \
-    Func(tres.ref(), f);                                                       \
+    auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f1);          \
+    Func(tres.ref(), f1);                                                      \
     return tres;                                                               \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
-    const tmp<FieldField<Field, Type>>& tf                                     \
+    const tmp<FieldField<Field, Type1>>& tf1                                   \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres(New(tf));                          \
-    Func(tres.ref(), tf());                                                    \
-    tf.clear();                                                                \
+    auto tres = reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1);        \
+    Func(tres.ref(), tf1());                                                   \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define UNARY_OPERATOR(ReturnType, Type, Op, OpFunc)                           \
+#define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc)                          \
                                                                                \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    FieldField<Field, ReturnType>& res,                                        \
-    const FieldField<Field, Type>& f                                           \
+    FieldField<Field, ReturnType>& result,                                     \
+    const FieldField<Field, Type1>& f1                                         \
 )                                                                              \
 {                                                                              \
-    const label loopLen = (res).size();                                        \
+    const label loopLen = (result).size();                                     \
                                                                                \
     for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
-        OpFunc(res[i], f[i]);                                                  \
+        OpFunc(result[i], f1[i]);                                              \
     }                                                                          \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> operator Op                                 \
 (                                                                              \
-    const FieldField<Field, Type>& f                                           \
+    const FieldField<Field, Type1>& f1                                         \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
-    (                                                                          \
-        FieldField<Field, Type>::NewCalculatedType(f)                          \
-    );                                                                         \
-    OpFunc(tres.ref(), f);                                                     \
+    auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f1);          \
+    OpFunc(tres.ref(), f1);                                                    \
     return tres;                                                               \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> operator Op                                 \
 (                                                                              \
-    const tmp<FieldField<Field, Type>>& tf                                     \
+    const tmp<FieldField<Field, Type1>>& tf1                                   \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres(New(tf));                          \
-    OpFunc(tres.ref(), tf());                                                  \
-    tf.clear();                                                                \
+    auto tres = reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1);        \
+    OpFunc(tres.ref(), tf1());                                                 \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }
 
@@ -128,16 +122,16 @@ tmp<FieldField<Field, ReturnType>> operator Op                                 \
 TEMPLATE                                                                       \
 void Func                                                                      \
 (                                                                              \
-    FieldField<Field, ReturnType>& f,                                          \
+    FieldField<Field, ReturnType>& result,                                     \
     const FieldField<Field, Type1>& f1,                                        \
     const FieldField<Field, Type2>& f2                                         \
 )                                                                              \
 {                                                                              \
-    const label loopLen = (f).size();                                          \
+    const label loopLen = (result).size();                                     \
                                                                                \
     for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
-        Func(f[i], f1[i], f2[i]);                                              \
+        Func(result[i], f1[i], f2[i]);                                         \
     }                                                                          \
 }                                                                              \
                                                                                \
@@ -148,10 +142,7 @@ tmp<FieldField<Field, ReturnType>> Func                                        \
     const FieldField<Field, Type2>& f2                                         \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
-    (                                                                          \
-        FieldField<Field, Type1>::NewCalculatedType(f1)                        \
-    );                                                                         \
+    auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f1);          \
     Func(tres.ref(), f1, f2);                                                  \
     return tres;                                                               \
 }                                                                              \
@@ -163,10 +154,7 @@ tmp<FieldField<Field, ReturnType>> Func                                        \
     const tmp<FieldField<Field, Type2>>& tf2                                   \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
-    (                                                                          \
-        reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2)                 \
-    );                                                                         \
+    auto tres = reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2);        \
     Func(tres.ref(), f1, tf2());                                               \
     tf2.clear();                                                               \
     return tres;                                                               \
@@ -179,10 +167,7 @@ tmp<FieldField<Field, ReturnType>> Func                                        \
     const FieldField<Field, Type2>& f2                                         \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
-    (                                                                          \
-        reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1)                 \
-    );                                                                         \
+    auto tres = reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1);        \
     Func(tres.ref(), tf1(), f2);                                               \
     tf1.clear();                                                               \
     return tres;                                                               \
@@ -195,7 +180,7 @@ tmp<FieldField<Field, ReturnType>> Func                                        \
     const tmp<FieldField<Field, Type2>>& tf2                                   \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
+    auto tres                                                                  \
     (                                                                          \
         reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>::        \
             New(tf1, tf2)                                                      \
@@ -214,46 +199,40 @@ tmp<FieldField<Field, ReturnType>> Func                                        \
 TEMPLATE                                                                       \
 void Func                                                                      \
 (                                                                              \
-    FieldField<Field, ReturnType>& f,                                          \
-    const Type1& s,                                                            \
+    FieldField<Field, ReturnType>& result,                                     \
+    const Type1& s1,                                                           \
     const FieldField<Field, Type2>& f2                                         \
 )                                                                              \
 {                                                                              \
-    const label loopLen = (f).size();                                          \
+    const label loopLen = (result).size();                                     \
                                                                                \
     for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
-        Func(f[i], s, f2[i]);                                                  \
+        Func(result[i], s1, f2[i]);                                            \
     }                                                                          \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
-    const Type1& s,                                                            \
+    const Type1& s1,                                                           \
     const FieldField<Field, Type2>& f2                                         \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
-    (                                                                          \
-        FieldField<Field, Type2>::NewCalculatedType(f2)                        \
-    );                                                                         \
-    Func(tres.ref(), s, f2);                                                   \
+    auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f2);          \
+    Func(tres.ref(), s1, f2);                                                  \
     return tres;                                                               \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
-    const Type1& s,                                                            \
+    const Type1& s1,                                                           \
     const tmp<FieldField<Field, Type2>>& tf2                                   \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
-    (                                                                          \
-        reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2)                 \
-    );                                                                         \
-    Func(tres.ref(), s, tf2());                                                \
+    auto tres = reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2);        \
+    Func(tres.ref(), s1, tf2());                                               \
     tf2.clear();                                                               \
     return tres;                                                               \
 }
@@ -264,16 +243,16 @@ tmp<FieldField<Field, ReturnType>> Func                                        \
 TEMPLATE                                                                       \
 void Func                                                                      \
 (                                                                              \
-    FieldField<Field, ReturnType>& f,                                          \
+    FieldField<Field, ReturnType>& result,                                     \
     const FieldField<Field, Type1>& f1,                                        \
-    const Type2& s                                                             \
+    const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    const label loopLen = (f).size();                                          \
+    const label loopLen = (result).size();                                     \
                                                                                \
     for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
-        Func(f[i], f1[i], s);                                                  \
+        Func(result[i], f1[i], s2);                                            \
     }                                                                          \
 }                                                                              \
                                                                                \
@@ -281,14 +260,11 @@ TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
     const FieldField<Field, Type1>& f1,                                        \
-    const Type2& s                                                             \
+    const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
-    (                                                                          \
-        FieldField<Field, Type1>::NewCalculatedType(f1)                        \
-    );                                                                         \
-    Func(tres.ref(), f1, s);                                                   \
+    auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f1);          \
+    Func(tres.ref(), f1, s2);                                                  \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -296,14 +272,11 @@ TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
     const tmp<FieldField<Field, Type1>>& tf1,                                  \
-    const Type2& s                                                             \
+    const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
-    (                                                                          \
-        reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1)                 \
-    );                                                                         \
-    Func(tres.ref(), tf1(), s);                                                \
+    auto tres = reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1);        \
+    Func(tres.ref(), tf1(), s2);                                               \
     tf1.clear();                                                               \
     return tres;                                                               \
 }
@@ -321,16 +294,16 @@ tmp<FieldField<Field, ReturnType>> Func                                        \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    FieldField<Field, ReturnType>& f,                                          \
+    FieldField<Field, ReturnType>& result,                                     \
     const FieldField<Field, Type1>& f1,                                        \
     const FieldField<Field, Type2>& f2                                         \
 )                                                                              \
 {                                                                              \
-    const label loopLen = (f).size();                                          \
+    const label loopLen = (result).size();                                     \
                                                                                \
     for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
-        OpFunc(f[i], f1[i], f2[i]);                                            \
+        OpFunc(result[i], f1[i], f2[i]);                                       \
     }                                                                          \
 }                                                                              \
                                                                                \
@@ -341,10 +314,7 @@ tmp<FieldField<Field, ReturnType>> operator Op                                 \
     const FieldField<Field, Type2>& f2                                         \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
-    (                                                                          \
-        FieldField<Field, ReturnType>::NewCalculatedType(f1)                   \
-    );                                                                         \
+    auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f1);          \
     OpFunc(tres.ref(), f1, f2);                                                \
     return tres;                                                               \
 }                                                                              \
@@ -356,10 +326,7 @@ tmp<FieldField<Field, ReturnType>> operator Op                                 \
     const tmp<FieldField<Field, Type2>>& tf2                                   \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
-    (                                                                          \
-        reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2)                 \
-    );                                                                         \
+    auto tres = reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2);        \
     OpFunc(tres.ref(), f1, tf2());                                             \
     tf2.clear();                                                               \
     return tres;                                                               \
@@ -372,10 +339,7 @@ tmp<FieldField<Field, ReturnType>> operator Op                                 \
     const FieldField<Field, Type2>& f2                                         \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
-    (                                                                          \
-        reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1)                 \
-    );                                                                         \
+    auto tres = reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1);        \
     OpFunc(tres.ref(), tf1(), f2);                                             \
     tf1.clear();                                                               \
     return tres;                                                               \
@@ -388,7 +352,7 @@ tmp<FieldField<Field, ReturnType>> operator Op                                 \
     const tmp<FieldField<Field, Type2>>& tf2                                   \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
+    auto tres                                                                  \
     (                                                                          \
         reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>::        \
             New(tf1, tf2)                                                      \
@@ -407,46 +371,40 @@ tmp<FieldField<Field, ReturnType>> operator Op                                 \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    FieldField<Field, ReturnType>& f,                                          \
-    const Type1& s,                                                            \
+    FieldField<Field, ReturnType>& result,                                     \
+    const Type1& s1,                                                           \
     const FieldField<Field, Type2>& f2                                         \
 )                                                                              \
 {                                                                              \
-    const label loopLen = (f).size();                                          \
+    const label loopLen = (result).size();                                     \
                                                                                \
     for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
-        OpFunc(f[i], s, f2[i]);                                                \
+        OpFunc(result[i], s1, f2[i]);                                          \
     }                                                                          \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> operator Op                                 \
 (                                                                              \
-    const Type1& s,                                                            \
+    const Type1& s1,                                                           \
     const FieldField<Field, Type2>& f2                                         \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
-    (                                                                          \
-        FieldField<Field, Type2>::NewCalculatedType(f2)                        \
-    );                                                                         \
-    OpFunc(tres.ref(), s, f2);                                                 \
+    auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f2);          \
+    OpFunc(tres.ref(), s1, f2);                                                \
     return tres;                                                               \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> operator Op                                 \
 (                                                                              \
-    const Type1& s,                                                            \
+    const Type1& s1,                                                           \
     const tmp<FieldField<Field, Type2>>& tf2                                   \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
-    (                                                                          \
-        reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2)                 \
-    );                                                                         \
-    OpFunc(tres.ref(), s, tf2());                                              \
+    auto tres = reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2);        \
+    OpFunc(tres.ref(), s1, tf2());                                             \
     tf2.clear();                                                               \
     return tres;                                                               \
 }
@@ -457,16 +415,16 @@ tmp<FieldField<Field, ReturnType>> operator Op                                 \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    FieldField<Field, ReturnType>& f,                                          \
+    FieldField<Field, ReturnType>& result,                                     \
     const FieldField<Field, Type1>& f1,                                        \
-    const Type2& s                                                             \
+    const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    const label loopLen = (f).size();                                          \
+    const label loopLen = (result).size();                                     \
                                                                                \
     for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
-        OpFunc(f[i], f1[i], s);                                                \
+        OpFunc(result[i], f1[i], s2);                                          \
     }                                                                          \
 }                                                                              \
                                                                                \
@@ -474,14 +432,11 @@ TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> operator Op                                 \
 (                                                                              \
     const FieldField<Field, Type1>& f1,                                        \
-    const Type2& s                                                             \
+    const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
-    (                                                                          \
-        FieldField<Field, Type1>::NewCalculatedType(f1)                        \
-    );                                                                         \
-    OpFunc(tres.ref(), f1, s);                                                 \
+    auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f1);          \
+    OpFunc(tres.ref(), f1, s2);                                                \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -489,14 +444,11 @@ TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> operator Op                                 \
 (                                                                              \
     const tmp<FieldField<Field, Type1>>& tf1,                                  \
-    const Type2& s                                                             \
+    const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    tmp<FieldField<Field, ReturnType>> tres                                    \
-    (                                                                          \
-        reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1)                 \
-    );                                                                         \
-    OpFunc(tres.ref(), tf1(), s);                                              \
+    auto tres = reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1);        \
+    OpFunc(tres.ref(), tf1(), s2);                                             \
     tf1.clear();                                                               \
     return tres;                                                               \
 }
@@ -506,4 +458,5 @@ tmp<FieldField<Field, ReturnType>> operator Op                                 \
     BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpFunc)              \
     BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc)
 
+
 // ************************************************************************* //
diff --git a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.H b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.H
index 1771f2365a..1e3b0501e8 100644
--- a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.H
+++ b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.H
@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -24,9 +25,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Description
-    High performance macro functions for Field\<Type\> algebra.
-    These expand using either array element access (for vector machines)
-    or pointer dereferencing for scalar machines as appropriate.
+    Macro functions for FieldField\<Type\> algebra.
 
 \*---------------------------------------------------------------------------*/
 
@@ -37,20 +36,20 @@ Description
 TEMPLATE                                                                       \
 void Func                                                                      \
 (                                                                              \
-    FieldField<Field, ReturnType>& res,                                        \
-    const FieldField<Field, Type1>& f                                          \
+    FieldField<Field, ReturnType>& result,                                     \
+    const FieldField<Field, Type1>& f1                                         \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
-    const FieldField<Field, Type1>& f                                          \
+    const FieldField<Field, Type1>& f1                                         \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
-    const tmp<FieldField<Field, Type1>>& tf                                    \
+    const tmp<FieldField<Field, Type1>>& tf1                                   \
 );
 
 
@@ -61,20 +60,20 @@ tmp<FieldField<Field, ReturnType>> Func                                        \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    FieldField<Field, ReturnType>& res,                                        \
-    const FieldField<Field, Type1>& f                                          \
+    FieldField<Field, ReturnType>& result,                                     \
+    const FieldField<Field, Type1>& f1                                         \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> operator Op                                 \
 (                                                                              \
-    const FieldField<Field, Type1>& f                                          \
+    const FieldField<Field, Type1>& f1                                         \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> operator Op                                 \
 (                                                                              \
-    const tmp<FieldField<Field, Type1>>& tf                                    \
+    const tmp<FieldField<Field, Type1>>& tf1                                   \
 );
 
 
@@ -83,36 +82,36 @@ tmp<FieldField<Field, ReturnType>> operator Op                                 \
 #define BINARY_FUNCTION(ReturnType, Type1, Type2, Func)                        \
                                                                                \
 TEMPLATE                                                                       \
-void func                                                                      \
+void Func                                                                      \
 (                                                                              \
-    FieldField<Field, ReturnType>& f,                                          \
+    FieldField<Field, ReturnType>& result,                                     \
     const FieldField<Field, Type1>& f1,                                        \
     const FieldField<Field, Type2>& f2                                         \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
-tmp<FieldField<Field, ReturnType>> func                                        \
+tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
     const FieldField<Field, Type1>& f1,                                        \
     const FieldField<Field, Type2>& f2                                         \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
-tmp<FieldField<Field, ReturnType>> func                                        \
+tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
     const FieldField<Field, Type1>& f1,                                        \
     const tmp<FieldField<Field, Type2>>& tf2                                   \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
-tmp<FieldField<Field, ReturnType>> func                                        \
+tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
     const tmp<FieldField<Field, Type1>>& tf1,                                  \
     const FieldField<Field, Type2>& f2                                         \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
-tmp<FieldField<Field, ReturnType>> func                                        \
+tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
     const tmp<FieldField<Field, Type1>>& tf1,                                  \
     const tmp<FieldField<Field, Type2>>& tf2                                   \
@@ -124,22 +123,22 @@ tmp<FieldField<Field, ReturnType>> func                                        \
 #define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func)                \
                                                                                \
 TEMPLATE                                                                       \
-void func                                                                      \
+void Func                                                                      \
 (                                                                              \
-    FieldField<Field, ReturnType>& f,                                          \
+    FieldField<Field, ReturnType>& result,                                     \
     const Type1& s1,                                                           \
     const FieldField<Field, Type2>& f2                                         \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
-tmp<FieldField<Field, ReturnType>> func                                        \
+tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
     const Type1& s1,                                                           \
     const FieldField<Field, Type1>& f2                                         \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
-tmp<FieldField<Field, ReturnType>> func                                        \
+tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
     const Type1& s1,                                                           \
     const tmp<FieldField<Field, Type1>>& tf2                                   \
@@ -149,25 +148,25 @@ tmp<FieldField<Field, ReturnType>> func                                        \
 #define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)                \
                                                                                \
 TEMPLATE                                                                       \
-void func                                                                      \
+void Func                                                                      \
 (                                                                              \
-    FieldField<Field, ReturnType>& f,                                          \
+    FieldField<Field, ReturnType>& result,                                     \
     const FieldField<Field, Type1>& f1,                                        \
-    const Type2& s                                                             \
+    const Type2& s2                                                            \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
-tmp<FieldField<Field, ReturnType>> func                                        \
+tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
     const FieldField<Field, Type1>& f1,                                        \
-    const Type2& s                                                             \
+    const Type2& s2                                                            \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
-tmp<FieldField<Field, ReturnType>> func                                        \
+tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
     const tmp<FieldField<Field, Type1>>& tf1,                                  \
-    const Type2& s                                                             \
+    const Type2& s2                                                            \
 );
 
 
@@ -183,7 +182,7 @@ tmp<FieldField<Field, ReturnType>> func                                        \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    FieldField<Field, ReturnType>& f,                                          \
+    FieldField<Field, ReturnType>& result,                                     \
     const FieldField<Field, Type1>& f1,                                        \
     const FieldField<Field, Type2>& f2                                         \
 );                                                                             \
@@ -224,7 +223,7 @@ tmp<FieldField<Field, ReturnType>> operator Op                                 \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    FieldField<Field, ReturnType>& f,                                          \
+    FieldField<Field, ReturnType>& result,                                     \
     const Type1& s1,                                                           \
     const FieldField<Field, Type2>& f2                                         \
 );                                                                             \
@@ -249,7 +248,7 @@ tmp<FieldField<Field, ReturnType>> operator Op                                 \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    FieldField<Field, ReturnType>& f,                                          \
+    FieldField<Field, ReturnType>& result,                                     \
     const FieldField<Field, Type1>& f1,                                        \
     const Type2& s2                                                            \
 );                                                                             \
diff --git a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldReuseFunctions.H b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldReuseFunctions.H
index f0bff7dead..7e51d03daf 100644
--- a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldReuseFunctions.H
+++ b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldReuseFunctions.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2022 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -35,10 +35,21 @@ namespace Foam
 {
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// One-parameter versions
 
 template<template<class> class Field, class TypeR, class Type1>
 struct reuseTmpFieldField
 {
+    //- Pass-through to NewCalculatedType
+    static tmp<FieldField<Field, TypeR>> New
+    (
+        const FieldField<Field, Type1>& f1
+    )
+    {
+        return FieldField<Field, TypeR>::NewCalculatedType(f1);
+    }
+
+    //- Dissimilar types: just use size
     static tmp<FieldField<Field, TypeR>> New
     (
         const tmp<FieldField<Field, Type1>>& tf1
@@ -52,6 +63,8 @@ struct reuseTmpFieldField
 template<template<class> class Field, class TypeR>
 struct reuseTmpFieldField<Field, TypeR, TypeR>
 {
+    //- Identical input and return types:
+    //- allow optional copy assignment of the initial content
     static tmp<FieldField<Field, TypeR>> New
     (
         const tmp<FieldField<Field, TypeR>>& tf1,
@@ -63,19 +76,19 @@ struct reuseTmpFieldField<Field, TypeR, TypeR>
             return tf1;
         }
 
-        auto rtf = FieldField<Field, TypeR>::NewCalculatedType(tf1());
+        auto tresult = FieldField<Field, TypeR>::NewCalculatedType(tf1());
 
         if (initCopy)
         {
-            rtf.ref() = tf1();
+            tresult.ref() = tf1();
         }
 
-        return rtf;
+        return tresult;
     }
 };
 
 
-//- Global function forwards to reuseTmpFieldField::New
+//- This global function forwards to reuseTmpFieldField::New
 template<template<class> class Field, class TypeR>
 tmp<FieldField<Field, TypeR>> New
 (
@@ -87,6 +100,9 @@ tmp<FieldField<Field, TypeR>> New
 }
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Two-parameter versions
+
 template
 <
     template<class> class Field,
@@ -97,6 +113,7 @@ template
 >
 struct reuseTmpTmpFieldField
 {
+    //- Dissimilar types: just use size
     static tmp<FieldField<Field, TypeR>> New
     (
         const tmp<FieldField<Field, Type1>>& tf1,
@@ -111,6 +128,7 @@ struct reuseTmpTmpFieldField
 template<template<class> class Field, class TypeR, class Type1, class Type12>
 struct reuseTmpTmpFieldField<Field, TypeR, Type1, Type12, TypeR>
 {
+    //- Second input has return type
     static tmp<FieldField<Field, TypeR>> New
     (
         const tmp<FieldField<Field, Type1>>& tf1,
@@ -130,6 +148,7 @@ struct reuseTmpTmpFieldField<Field, TypeR, Type1, Type12, TypeR>
 template<template<class> class Field, class TypeR, class Type2>
 struct reuseTmpTmpFieldField<Field, TypeR, TypeR, TypeR, Type2>
 {
+    //- First input has return type
     static tmp<FieldField<Field, TypeR>> New
     (
         const tmp<FieldField<Field, TypeR>>& tf1,
@@ -149,6 +168,7 @@ struct reuseTmpTmpFieldField<Field, TypeR, TypeR, TypeR, Type2>
 template<template<class> class Field, class TypeR>
 struct reuseTmpTmpFieldField<Field, TypeR, TypeR, TypeR, TypeR>
 {
+    //- Both inputs have return type
     static tmp<FieldField<Field, TypeR>> New
     (
         const tmp<FieldField<Field, TypeR>>& tf1,
diff --git a/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C b/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
index d3576ac210..f3e136c2e9 100644
--- a/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
+++ b/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
@@ -42,38 +42,40 @@ namespace Foam
 template<class Type>
 void component
 (
-    Field<typename Field<Type>::cmptType>& res,
-    const UList<Type>& f,
+    Field<typename Field<Type>::cmptType>& result,
+    const UList<Type>& f1,
     const direction d
 )
 {
-    typedef typename Field<Type>::cmptType cmptType;
+    typedef typename Field<Type>::cmptType resultType;
+
     TFOR_ALL_F_OP_F_FUNC_S
     (
-        cmptType, res, =, Type, f, .component, const direction, d
+        resultType, result, =, Type, f1, .component, const direction, d
     )
 }
 
 
 template<class Type>
-void T(Field<Type>& res, const UList<Type>& f)
+void T(Field<Type>& result, const UList<Type>& f1)
 {
-    TFOR_ALL_F_OP_F_FUNC(Type, res, =, Type, f, T)
+    TFOR_ALL_F_OP_F_FUNC(Type, result, =, Type, f1, T)
 }
 
 
 template<class Type, direction r>
 void pow
 (
-    Field<typename powProduct<Type, r>::type>& res,
-    const UList<Type>& vf
+    Field<typename powProduct<Type, r>::type>& result,
+    const UList<Type>& f1
 )
 {
-    typedef typename powProduct<Type, r>::type powProductType;
+    typedef typename powProduct<Type, r>::type resultType;
+
     TFOR_ALL_F_OP_FUNC_F_S
     (
-        powProductType, res, =, pow, Type, vf, powProductType,
-        pTraits<powProductType>::zero
+        resultType, result, =, pow, Type, f1, resultType,
+        pTraits<resultType>::zero
     )
 }
 
@@ -81,16 +83,13 @@ template<class Type, direction r>
 tmp<Field<typename powProduct<Type, r>::type>>
 pow
 (
-    const UList<Type>& f,
+    const UList<Type>& f1,
     typename powProduct<Type, r>::type
 )
 {
-    typedef typename powProduct<Type, r>::type powProductType;
-    auto tres
-    (
-        tmp<Field<powProductType>>::New(f.size())
-    );
-    pow<Type, r>(tres.ref(), f);
+    typedef typename powProduct<Type, r>::type resultType;
+    auto tres = tmp<Field<resultType>>::New(f1.size());
+    pow<Type, r>(tres.ref(), f1);
     return tres;
 }
 
@@ -98,14 +97,14 @@ template<class Type, direction r>
 tmp<Field<typename powProduct<Type, r>::type>>
 pow
 (
-    const tmp<Field<Type>>& tf,
+    const tmp<Field<Type>>& tf1,
     typename powProduct<Type, r>::type
 )
 {
-    typedef typename powProduct<Type, r>::type powProductType;
-    auto tres = reuseTmp<powProductType, Type>::New(tf);
-    pow<Type, r>(tres.ref(), tf());
-    tf.clear();
+    typedef typename powProduct<Type, r>::type resultType;
+    auto tres = reuseTmp<resultType, Type>::New(tf1);
+    pow<Type, r>(tres.ref(), tf1());
+    tf1.clear();
     return tres;
 }
 
@@ -113,35 +112,33 @@ pow
 template<class Type>
 void sqr
 (
-    Field<typename outerProduct<Type, Type>::type>& res,
-    const UList<Type>& vf
+    Field<typename outerProduct<Type, Type>::type>& result,
+    const UList<Type>& f1
 )
 {
-    typedef typename outerProduct<Type, Type>::type outerProductType;
-    TFOR_ALL_F_OP_FUNC_F(outerProductType, res, =, sqr, Type, vf)
+    typedef typename outerProduct<Type, Type>::type resultType;
+
+    TFOR_ALL_F_OP_FUNC_F(resultType, result, =, sqr, Type, f1)
 }
 
 template<class Type>
 tmp<Field<typename outerProduct<Type, Type>::type>>
-sqr(const UList<Type>& f)
+sqr(const UList<Type>& f1)
 {
-    typedef typename outerProduct<Type, Type>::type outerProductType;
-    auto tres
-    (
-        tmp<Field<outerProductType>>::New(f.size())
-    );
-    sqr(tres.ref(), f);
+    typedef typename outerProduct<Type, Type>::type resultType;
+    auto tres = tmp<Field<resultType>>::New(f1.size());
+    sqr(tres.ref(), f1);
     return tres;
 }
 
 template<class Type>
 tmp<Field<typename outerProduct<Type, Type>::type>>
-sqr(const tmp<Field<Type>>& tf)
+sqr(const tmp<Field<Type>>& tf1)
 {
-    typedef typename outerProduct<Type, Type>::type outerProductType;
-    auto tres = reuseTmp<outerProductType, Type>::New(tf);
-    sqr(tres.ref(), tf());
-    tf.clear();
+    typedef typename outerProduct<Type, Type>::type resultType;
+    auto tres = reuseTmp<resultType, Type>::New(tf1);
+    sqr(tres.ref(), tf1());
+    tf1.clear();
     return tres;
 }
 
@@ -149,35 +146,35 @@ sqr(const tmp<Field<Type>>& tf)
 template<class Type>
 void magSqr
 (
-    Field<typename typeOfMag<Type>::type>& res,
-    const UList<Type>& f
+    Field<typename typeOfMag<Type>::type>& result,
+    const UList<Type>& f1
 )
 {
-    typedef typename typeOfMag<Type>::type magType;
+    typedef typename typeOfMag<Type>::type resultType;
 
-    TFOR_ALL_F_OP_FUNC_F(magType, res, =, magSqr, Type, f)
+    TFOR_ALL_F_OP_FUNC_F(resultType, result, =, magSqr, Type, f1)
 }
 
 template<class Type>
 tmp<Field<typename typeOfMag<Type>::type>>
-magSqr(const UList<Type>& f)
+magSqr(const UList<Type>& f1)
 {
-    typedef typename typeOfMag<Type>::type magType;
+    typedef typename typeOfMag<Type>::type resultType;
 
-    auto tres = tmp<Field<magType>>::New(f.size());
-    magSqr(tres.ref(), f);
+    auto tres = tmp<Field<resultType>>::New(f1.size());
+    magSqr(tres.ref(), f1);
     return tres;
 }
 
 template<class Type>
 tmp<Field<typename typeOfMag<Type>::type>>
-magSqr(const tmp<Field<Type>>& tf)
+magSqr(const tmp<Field<Type>>& tf1)
 {
-    typedef typename typeOfMag<Type>::type magType;
+    typedef typename typeOfMag<Type>::type resultType;
 
-    auto tres = reuseTmp<magType, Type>::New(tf);
-    magSqr(tres.ref(), tf());
-    tf.clear();
+    auto tres = reuseTmp<resultType, Type>::New(tf1);
+    magSqr(tres.ref(), tf1());
+    tf1.clear();
     return tres;
 }
 
@@ -185,164 +182,179 @@ magSqr(const tmp<Field<Type>>& tf)
 template<class Type>
 void mag
 (
-    Field<typename typeOfMag<Type>::type>& res,
-    const UList<Type>& f
+    Field<typename typeOfMag<Type>::type>& result,
+    const UList<Type>& f1
 )
 {
-    typedef typename typeOfMag<Type>::type magType;
+    typedef typename typeOfMag<Type>::type resultType;
 
-    TFOR_ALL_F_OP_FUNC_F(magType, res, =, mag, Type, f)
+    TFOR_ALL_F_OP_FUNC_F(resultType, result, =, mag, Type, f1)
 }
 
 template<class Type>
 tmp<Field<typename typeOfMag<Type>::type>>
-mag(const UList<Type>& f)
+mag(const UList<Type>& f1)
 {
-    typedef typename typeOfMag<Type>::type magType;
+    typedef typename typeOfMag<Type>::type resultType;
 
-    auto tres = tmp<Field<magType>>::New(f.size());
-    mag(tres.ref(), f);
+    auto tres = tmp<Field<resultType>>::New(f1.size());
+    mag(tres.ref(), f1);
     return tres;
 }
 
 template<class Type>
 tmp<Field<typename typeOfMag<Type>::type>>
-mag(const tmp<Field<Type>>& tf)
+mag(const tmp<Field<Type>>& tf1)
 {
-    typedef typename typeOfMag<Type>::type magType;
+    typedef typename typeOfMag<Type>::type resultType;
 
-    auto tres = reuseTmp<magType, Type>::New(tf);
-    mag(tres.ref(), tf());
-    tf.clear();
+    auto tres = reuseTmp<resultType, Type>::New(tf1);
+    mag(tres.ref(), tf1());
+    tf1.clear();
     return tres;
 }
 
 
 template<class Type>
-void cmptMax(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f)
+void cmptMax
+(
+    Field<typename Field<Type>::cmptType>& result,
+    const UList<Type>& f1
+)
 {
-    typedef typename Field<Type>::cmptType cmptType;
-    TFOR_ALL_F_OP_FUNC_F(cmptType, res, =, cmptMax, Type, f)
+    typedef typename Field<Type>::cmptType resultType;
+
+    TFOR_ALL_F_OP_FUNC_F(resultType, result, =, cmptMax, Type, f1)
 }
 
 template<class Type>
-tmp<Field<typename Field<Type>::cmptType>> cmptMax(const UList<Type>& f)
+tmp<Field<typename Field<Type>::cmptType>> cmptMax(const UList<Type>& f1)
 {
-    typedef typename Field<Type>::cmptType cmptType;
-    auto tres = tmp<Field<cmptType>>::New(f.size());
-    cmptMax(tres.ref(), f);
+    typedef typename Field<Type>::cmptType resultType;
+    auto tres = tmp<Field<resultType>>::New(f1.size());
+    cmptMax(tres.ref(), f1);
     return tres;
 }
 
 template<class Type>
-tmp<Field<typename Field<Type>::cmptType>> cmptMax(const tmp<Field<Type>>& tf)
+tmp<Field<typename Field<Type>::cmptType>> cmptMax(const tmp<Field<Type>>& tf1)
 {
-    typedef typename Field<Type>::cmptType cmptType;
-    auto tres = reuseTmp<cmptType, Type>::New(tf);
-    cmptMax(tres.ref(), tf());
-    tf.clear();
+    typedef typename Field<Type>::cmptType resultType;
+    auto tres = reuseTmp<resultType, Type>::New(tf1);
+    cmptMax(tres.ref(), tf1());
+    tf1.clear();
     return tres;
 }
 
 
 template<class Type>
-void cmptMin(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f)
+void cmptMin
+(
+    Field<typename Field<Type>::cmptType>& result,
+    const UList<Type>& f1
+)
 {
-    typedef typename Field<Type>::cmptType cmptType;
-    TFOR_ALL_F_OP_FUNC_F(cmptType, res, =, cmptMin, Type, f)
+    typedef typename Field<Type>::cmptType resultType;
+
+    TFOR_ALL_F_OP_FUNC_F(resultType, result, =, cmptMin, Type, f1)
 }
 
 template<class Type>
-tmp<Field<typename Field<Type>::cmptType>> cmptMin(const UList<Type>& f)
+tmp<Field<typename Field<Type>::cmptType>> cmptMin(const UList<Type>& f1)
 {
-    typedef typename Field<Type>::cmptType cmptType;
-    auto tres = tmp<Field<cmptType>>::New(f.size());
-    cmptMin(tres.ref(), f);
+    typedef typename Field<Type>::cmptType resultType;
+    auto tres = tmp<Field<resultType>>::New(f1.size());
+    cmptMin(tres.ref(), f1);
     return tres;
 }
 
 template<class Type>
-tmp<Field<typename Field<Type>::cmptType>> cmptMin(const tmp<Field<Type>>& tf)
+tmp<Field<typename Field<Type>::cmptType>> cmptMin(const tmp<Field<Type>>& tf1)
 {
-    typedef typename Field<Type>::cmptType cmptType;
-    auto tres = reuseTmp<cmptType, Type>::New(tf);
-    cmptMin(tres.ref(), tf());
-    tf.clear();
+    typedef typename Field<Type>::cmptType resultType;
+    auto tres = reuseTmp<resultType, Type>::New(tf1);
+    cmptMin(tres.ref(), tf1());
+    tf1.clear();
     return tres;
 }
 
 
 template<class Type>
-void cmptAv(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f)
+void cmptAv
+(
+    Field<typename Field<Type>::cmptType>& result,
+    const UList<Type>& f1
+)
 {
-    typedef typename Field<Type>::cmptType cmptType;
-    TFOR_ALL_F_OP_FUNC_F(cmptType, res, =, cmptAv, Type, f)
+    typedef typename Field<Type>::cmptType resultType;
+
+    TFOR_ALL_F_OP_FUNC_F(resultType, result, =, cmptAv, Type, f1)
 }
 
 template<class Type>
-tmp<Field<typename Field<Type>::cmptType>> cmptAv(const UList<Type>& f)
+tmp<Field<typename Field<Type>::cmptType>> cmptAv(const UList<Type>& f1)
 {
-    typedef typename Field<Type>::cmptType cmptType;
-    auto tres = tmp<Field<cmptType>>::New(f.size());
-    cmptAv(tres.ref(), f);
+    typedef typename Field<Type>::cmptType resultType;
+    auto tres = tmp<Field<resultType>>::New(f1.size());
+    cmptAv(tres.ref(), f1);
     return tres;
 }
 
 template<class Type>
-tmp<Field<typename Field<Type>::cmptType>> cmptAv(const tmp<Field<Type>>& tf)
+tmp<Field<typename Field<Type>::cmptType>> cmptAv(const tmp<Field<Type>>& tf1)
 {
-    typedef typename Field<Type>::cmptType cmptType;
-    auto tres = reuseTmp<cmptType, Type>::New(tf);
-    cmptAv(tres.ref(), tf());
-    tf.clear();
+    typedef typename Field<Type>::cmptType resultType;
+    auto tres = reuseTmp<resultType, Type>::New(tf1);
+    cmptAv(tres.ref(), tf1());
+    tf1.clear();
     return tres;
 }
 
 
 template<class Type>
-void cmptMag(Field<Type>& res, const UList<Type>& f)
+void cmptMag(Field<Type>& result, const UList<Type>& f1)
 {
-    TFOR_ALL_F_OP_FUNC_F(Type, res, =, cmptMag, Type, f)
+    TFOR_ALL_F_OP_FUNC_F(Type, result, =, cmptMag, Type, f1)
 }
 
 template<class Type>
-tmp<Field<Type>> cmptMag(const UList<Type>& f)
+tmp<Field<Type>> cmptMag(const UList<Type>& f1)
 {
-    auto tres = tmp<Field<Type>>::New(f.size());
-    cmptMag(tres.ref(), f);
+    auto tres = tmp<Field<Type>>::New(f1.size());
+    cmptMag(tres.ref(), f1);
     return tres;
 }
 
 template<class Type>
-tmp<Field<Type>> cmptMag(const tmp<Field<Type>>& tf)
+tmp<Field<Type>> cmptMag(const tmp<Field<Type>>& tf1)
 {
-    auto tres = New(tf);
-    cmptMag(tres.ref(), tf());
-    tf.clear();
+    auto tres = New(tf1);
+    cmptMag(tres.ref(), tf1());
+    tf1.clear();
     return tres;
 }
 
 
 template<class Type>
-void cmptMagSqr(Field<Type>& res, const UList<Type>& f)
+void cmptMagSqr(Field<Type>& result, const UList<Type>& f1)
 {
-    TFOR_ALL_F_OP_FUNC_F(Type, res, =, cmptMagSqr, Type, f)
+    TFOR_ALL_F_OP_FUNC_F(Type, result, =, cmptMagSqr, Type, f1)
 }
 
 template<class Type>
-tmp<Field<Type>> cmptMagSqr(const UList<Type>& f)
+tmp<Field<Type>> cmptMagSqr(const UList<Type>& f1)
 {
-    auto tres = tmp<Field<Type>>::New(f.size());
-    cmptMagSqr(tres.ref(), f);
+    auto tres = tmp<Field<Type>>::New(f1.size());
+    cmptMagSqr(tres.ref(), f1);
     return tres;
 }
 
 template<class Type>
-tmp<Field<Type>> cmptMagSqr(const tmp<Field<Type>>& tf)
+tmp<Field<Type>> cmptMagSqr(const tmp<Field<Type>>& tf1)
 {
-    auto tres = New(tf);
-    cmptMagSqr(tres.ref(), tf());
-    tf.clear();
+    auto tres = New(tf1);
+    cmptMagSqr(tres.ref(), tf1());
+    tf1.clear();
     return tres;
 }
 
@@ -358,13 +370,13 @@ ReturnType Func(const tmp<Field<Type>>& tf1)                                   \
 }
 
 template<class Type>
-Type max(const UList<Type>& f)
+Type max(const UList<Type>& f1)
 {
-    if (f.size())
+    if (f1.size())
     {
-        Type Max(f[0]);
-        TFOR_ALL_S_OP_FUNC_F_S(Type, Max, =, max, Type, f, Type, Max)
-        return Max;
+        Type result(f1[0]);
+        TFOR_ALL_S_OP_FUNC_F_S(Type, result, =, max, Type, f1, Type, result)
+        return result;
     }
 
     return pTraits<Type>::min;
@@ -373,13 +385,13 @@ Type max(const UList<Type>& f)
 TMP_UNARY_FUNCTION(Type, max)
 
 template<class Type>
-Type min(const UList<Type>& f)
+Type min(const UList<Type>& f1)
 {
-    if (f.size())
+    if (f1.size())
     {
-        Type Min(f[0]);
-        TFOR_ALL_S_OP_FUNC_F_S(Type, Min, =, min, Type, f, Type, Min)
-        return Min;
+        Type result(f1[0]);
+        TFOR_ALL_S_OP_FUNC_F_S(Type, result, =, min, Type, f1, Type, result)
+        return result;
     }
 
     return pTraits<Type>::max;
@@ -388,18 +400,19 @@ Type min(const UList<Type>& f)
 TMP_UNARY_FUNCTION(Type, min)
 
 template<class Type>
-Type sum(const UList<Type>& f)
+Type sum(const UList<Type>& f1)
 {
-    typedef typename Foam::typeOfSolve<Type>::type solveType;
+    typedef typename Foam::typeOfSolve<Type>::type resultType;
 
-    solveType Sum = Zero;
+    resultType result = Zero;
 
-    if (f.size())
+    if (f1.size())
     {
-        TFOR_ALL_S_OP_FUNC_F(solveType, Sum, +=, solveType, Type, f)
+        // Use resultType() as functional cast
+        TFOR_ALL_S_OP_FUNC_F(resultType, result, +=, resultType, Type, f1)
     }
 
-    return Type(Sum);
+    return Type(result);
 }
 
 TMP_UNARY_FUNCTION(Type, sum)
@@ -414,23 +427,23 @@ TMP_UNARY_FUNCTION(scalarMinMax, minMaxMag)
 
 
 template<class Type>
-Type maxMagSqr(const UList<Type>& f)
+Type maxMagSqr(const UList<Type>& f1)
 {
-    if (f.size())
+    if (f1.size())
     {
-        Type Max(f[0]);
+        Type result(f1[0]);
         TFOR_ALL_S_OP_FUNC_F_S
         (
             Type,
-            Max,
+            result,
             =,
             maxMagSqrOp<Type>(),
             Type,
-            f,
+            f1,
             Type,
-            Max
+            result
         )
-        return Max;
+        return result;
     }
 
     return Zero;
@@ -439,23 +452,23 @@ Type maxMagSqr(const UList<Type>& f)
 TMP_UNARY_FUNCTION(Type, maxMagSqr)
 
 template<class Type>
-Type minMagSqr(const UList<Type>& f)
+Type minMagSqr(const UList<Type>& f1)
 {
-    if (f.size())
+    if (f1.size())
     {
-        Type Min(f[0]);
+        Type result(f1[0]);
         TFOR_ALL_S_OP_FUNC_F_S
         (
             Type,
-            Min,
+            result,
             =,
             minMagSqrOp<Type>(),
             Type,
-            f,
+            f1,
             Type,
-            Min
+            result
         )
-        return Min;
+        return result;
     }
 
     return pTraits<Type>::rootMax;
@@ -467,12 +480,12 @@ template<class Type>
 typename scalarProduct<Type, Type>::type
 sumProd(const UList<Type>& f1, const UList<Type>& f2)
 {
-    typedef typename scalarProduct<Type, Type>::type prodType;
+    typedef typename scalarProduct<Type, Type>::type resultType;
 
-    prodType result = Zero;
+    resultType result = Zero;
     if (f1.size() && (f1.size() == f2.size()))
     {
-        TFOR_ALL_S_OP_F_OP_F(prodType, result, +=, Type, f1, &&, Type, f2)
+        TFOR_ALL_S_OP_F_OP_F(resultType, result, +=, Type, f1, &&, Type, f2)
     }
     return result;
 }
@@ -502,37 +515,39 @@ Type sumCmptProd(const UList<Type>& f1, const UList<Type>& f2)
 
 template<class Type>
 typename outerProduct1<Type>::type
-sumSqr(const UList<Type>& f)
+sumSqr(const UList<Type>& f1)
 {
-    typedef typename outerProduct1<Type>::type prodType;
-    prodType result = Zero;
-    if (f.size())
+    typedef typename outerProduct1<Type>::type resultType;
+
+    resultType result = Zero;
+    if (f1.size())
     {
-        TFOR_ALL_S_OP_FUNC_F(prodType, result, +=, sqr, Type, f)
+        TFOR_ALL_S_OP_FUNC_F(resultType, result, +=, sqr, Type, f1)
     }
     return result;
 }
 
 template<class Type>
 typename outerProduct1<Type>::type
-sumSqr(const tmp<Field<Type>>& tf)
+sumSqr(const tmp<Field<Type>>& tf1)
 {
-    typedef typename outerProduct1<Type>::type prodType;
-    prodType result = sumSqr(tf());
-    tf.clear();
+    typedef typename outerProduct1<Type>::type resultType;
+    resultType result = sumSqr(tf1());
+    tf1.clear();
     return result;
 }
 
 
 template<class Type>
 typename typeOfMag<Type>::type
-sumMag(const UList<Type>& f)
+sumMag(const UList<Type>& f1)
 {
-    typedef typename typeOfMag<Type>::type magType;
-    magType result = Zero;
-    if (f.size())
+    typedef typename typeOfMag<Type>::type resultType;
+
+    resultType result = Zero;
+    if (f1.size())
     {
-        TFOR_ALL_S_OP_FUNC_F(magType, result, +=, mag, Type, f)
+        TFOR_ALL_S_OP_FUNC_F(resultType, result, +=, mag, Type, f1)
     }
     return result;
 }
@@ -541,12 +556,12 @@ TMP_UNARY_FUNCTION(typename typeOfMag<Type>::type, sumMag)
 
 
 template<class Type>
-Type sumCmptMag(const UList<Type>& f)
+Type sumCmptMag(const UList<Type>& f1)
 {
     Type result = Zero;
-    if (f.size())
+    if (f1.size())
     {
-        TFOR_ALL_S_OP_FUNC_F(Type, result, +=, cmptMag, Type, f)
+        TFOR_ALL_S_OP_FUNC_F(Type, result, +=, cmptMag, Type, f1)
     }
     return result;
 }
@@ -554,13 +569,13 @@ Type sumCmptMag(const UList<Type>& f)
 TMP_UNARY_FUNCTION(Type, sumCmptMag)
 
 template<class Type>
-Type average(const UList<Type>& f)
+Type average(const UList<Type>& f1)
 {
-    if (f.size())
+    if (f1.size())
     {
-        Type avrg = sum(f)/f.size();
+        Type result = sum(f1)/f1.size();
 
-        return avrg;
+        return result;
     }
 
     WarningInFunction
@@ -608,10 +623,10 @@ typename scalarProduct<Type, Type>::type gSumProd
     const label comm
 )
 {
-    typedef typename scalarProduct<Type, Type>::type prodType;
+    typedef typename scalarProduct<Type, Type>::type resultType;
 
-    prodType result = sumProd(f1, f2);
-    reduce(result, sumOp<prodType>(), UPstream::msgType(), comm);
+    resultType result = sumProd(f1, f2);
+    reduce(result, sumOp<resultType>(), UPstream::msgType(), comm);
     return result;
 }
 
@@ -623,27 +638,27 @@ Type gSumCmptProd
     const label comm
 )
 {
-    Type SumProd = sumCmptProd(f1, f2);
-    reduce(SumProd, sumOp<Type>(), UPstream::msgType(), comm);
-    return SumProd;
+    Type result = sumCmptProd(f1, f2);
+    reduce(result, sumOp<Type>(), UPstream::msgType(), comm);
+    return result;
 }
 
 template<class Type>
 Type gAverage
 (
-    const UList<Type>& f,
+    const UList<Type>& f1,
     const label comm
 )
 {
-    label n = f.size();
-    Type s = sum(f);
+    label n = f1.size();
+    Type s = sum(f1);
     sumReduce(s, n, UPstream::msgType(), comm);
 
     if (n > 0)
     {
-        Type avrg = s/n;
+        Type result = s/n;
 
-        return avrg;
+        return result;
     }
 
     WarningInFunction
@@ -656,6 +671,8 @@ TMP_UNARY_FUNCTION(Type, gAverage)
 
 #undef TMP_UNARY_FUNCTION
 
+
+// Implement BINARY_FUNCTION_TRANSFORM_FS for clamp
 template<class Type>
 void clamp
 (
@@ -683,30 +700,7 @@ void clamp
     }
 }
 
-template<class Type>
-tmp<Field<Type>> clamp
-(
-    const UList<Type>& f1,
-    const MinMax<Type>& range
-)
-{
-    auto tres = tmp<Field<Type>>::New(f1.size());
-    clamp(tres.ref(), f1, range);
-    return tres;
-}
-
-template<class Type>
-tmp<Field<Type>> clamp
-(
-    const tmp<Field<Type>>& tf1,
-    const MinMax<Type>& range
-)
-{
-    auto tres = reuseTmp<Type, Type>::New(tf1);
-    clamp(tres.ref(), tf1(), range);
-    tf1.clear();
-    return tres;
-}
+BINARY_FUNCTION_INTERFACE_FS(Type, Type, MinMax<Type>, clamp)
 
 
 BINARY_FUNCTION(Type, Type, Type, max)
@@ -743,21 +737,21 @@ BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, divide)
 template<class Type1, class Type2>                                             \
 void OpFunc                                                                    \
 (                                                                              \
-    Field<typename product<Type1, Type2>::type>& res,                          \
+    Field<typename product<Type1, Type2>::type>& result,                       \
     const UList<Type1>& f1,                                                    \
     const UList<Type2>& f2                                                     \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
-    TFOR_ALL_F_OP_F_OP_F(productType, res, =, Type1, f1, Op, Type2, f2)        \
+    typedef typename product<Type1, Type2>::type resultType;                   \
+    TFOR_ALL_F_OP_F_OP_F(resultType, result, =, Type1, f1, Op, Type2, f2)      \
 }                                                                              \
                                                                                \
 template<class Type1, class Type2>                                             \
 tmp<Field<typename product<Type1, Type2>::type>>                               \
 operator Op(const UList<Type1>& f1, const UList<Type2>& f2)                    \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
-    auto tres = tmp<Field<productType>>::New(f1.size());                       \
+    typedef typename product<Type1, Type2>::type resultType;                   \
+    auto tres = tmp<Field<resultType>>::New(f1.size());                        \
     OpFunc(tres.ref(), f1, f2);                                                \
     return tres;                                                               \
 }                                                                              \
@@ -766,8 +760,8 @@ template<class Type1, class Type2>                                             \
 tmp<Field<typename product<Type1, Type2>::type>>                               \
 operator Op(const UList<Type1>& f1, const tmp<Field<Type2>>& tf2)              \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
-    auto tres = reuseTmp<productType, Type2>::New(tf2);                        \
+    typedef typename product<Type1, Type2>::type resultType;                   \
+    auto tres = reuseTmp<resultType, Type2>::New(tf2);                         \
     OpFunc(tres.ref(), f1, tf2());                                             \
     tf2.clear();                                                               \
     return tres;                                                               \
@@ -777,8 +771,8 @@ template<class Type1, class Type2>                                             \
 tmp<Field<typename product<Type1, Type2>::type>>                               \
 operator Op(const tmp<Field<Type1>>& tf1, const UList<Type2>& f2)              \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
-    auto tres = reuseTmp<productType, Type1>::New(tf1);                        \
+    typedef typename product<Type1, Type2>::type resultType;                   \
+    auto tres = reuseTmp<resultType, Type1>::New(tf1);                         \
     OpFunc(tres.ref(), tf1(), f2);                                             \
     tf1.clear();                                                               \
     return tres;                                                               \
@@ -788,8 +782,8 @@ template<class Type1, class Type2>                                             \
 tmp<Field<typename product<Type1, Type2>::type>>                               \
 operator Op(const tmp<Field<Type1>>& tf1, const tmp<Field<Type2>>& tf2)        \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
-    auto tres = reuseTmpTmp<productType, Type1, Type1, Type2>::New(tf1, tf2);  \
+    typedef typename product<Type1, Type2>::type resultType;                   \
+    auto tres = reuseTmpTmp<resultType, Type1, Type1, Type2>::New(tf1, tf2);   \
     OpFunc(tres.ref(), tf1(), tf2());                                          \
     tf1.clear();                                                               \
     tf2.clear();                                                               \
@@ -799,22 +793,22 @@ operator Op(const tmp<Field<Type1>>& tf1, const tmp<Field<Type2>>& tf2)        \
 template<class Type, class Form, class Cmpt, direction nCmpt>                  \
 void OpFunc                                                                    \
 (                                                                              \
-    Field<typename product<Type, Form>::type>& res,                            \
+    Field<typename product<Type, Form>::type>& result,                         \
     const UList<Type>& f1,                                                     \
     const VectorSpace<Form,Cmpt,nCmpt>& vs                                     \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type, Form>::type productType;                    \
+    typedef typename product<Type, Form>::type resultType;                     \
     TFOR_ALL_F_OP_F_OP_S                                                       \
-        (productType, res, =,Type, f1, Op, Form, static_cast<const Form&>(vs)) \
+        (resultType, result, =,Type, f1, Op, Form, static_cast<const Form&>(vs))\
 }                                                                              \
                                                                                \
 template<class Type, class Form, class Cmpt, direction nCmpt>                  \
 tmp<Field<typename product<Type, Form>::type>>                                 \
 operator Op(const UList<Type>& f1, const VectorSpace<Form,Cmpt,nCmpt>& vs)     \
 {                                                                              \
-    typedef typename product<Type, Form>::type productType;                    \
-    auto tres = tmp<Field<productType>>::New(f1.size());                       \
+    typedef typename product<Type, Form>::type resultType;                     \
+    auto tres = tmp<Field<resultType>>::New(f1.size());                        \
     OpFunc(tres.ref(), f1, static_cast<const Form&>(vs));                      \
     return tres;                                                               \
 }                                                                              \
@@ -827,8 +821,8 @@ operator Op                                                                    \
     const VectorSpace<Form,Cmpt,nCmpt>& vs                                     \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type, Form>::type productType;                    \
-    auto tres = reuseTmp<productType, Type>::New(tf1);                         \
+    typedef typename product<Type, Form>::type resultType;                     \
+    auto tres = reuseTmp<resultType, Type>::New(tf1);                          \
     OpFunc(tres.ref(), tf1(), static_cast<const Form&>(vs));                   \
     tf1.clear();                                                               \
     return tres;                                                               \
@@ -837,22 +831,22 @@ operator Op                                                                    \
 template<class Form, class Cmpt, direction nCmpt, class Type>                  \
 void OpFunc                                                                    \
 (                                                                              \
-    Field<typename product<Form, Type>::type>& res,                            \
+    Field<typename product<Form, Type>::type>& result,                         \
     const VectorSpace<Form,Cmpt,nCmpt>& vs,                                    \
     const UList<Type>& f1                                                      \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Form, Type>::type productType;                    \
+    typedef typename product<Form, Type>::type resultType;                     \
     TFOR_ALL_F_OP_S_OP_F                                                       \
-        (productType, res, =,Form,static_cast<const Form&>(vs), Op, Type, f1)  \
+        (resultType, result, =,Form,static_cast<const Form&>(vs), Op, Type, f1)\
 }                                                                              \
                                                                                \
 template<class Form, class Cmpt, direction nCmpt, class Type>                  \
 tmp<Field<typename product<Form, Type>::type>>                                 \
 operator Op(const VectorSpace<Form,Cmpt,nCmpt>& vs, const UList<Type>& f1)     \
 {                                                                              \
-    typedef typename product<Form, Type>::type productType;                    \
-    auto tres = tmp<Field<productType>>::New(f1.size());                       \
+    typedef typename product<Form, Type>::type resultType;                     \
+    auto tres = tmp<Field<resultType>>::New(f1.size());                        \
     OpFunc(tres.ref(), static_cast<const Form&>(vs), f1);                      \
     return tres;                                                               \
 }                                                                              \
@@ -864,8 +858,8 @@ operator Op                                                                    \
     const VectorSpace<Form,Cmpt,nCmpt>& vs, const tmp<Field<Type>>& tf1        \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Form, Type>::type productType;                    \
-    auto tres = reuseTmp<productType, Type>::New(tf1);                         \
+    typedef typename product<Form, Type>::type resultType;                     \
+    auto tres = reuseTmp<resultType, Type>::New(tf1);                          \
     OpFunc(tres.ref(), static_cast<const Form&>(vs), tf1());                   \
     tf1.clear();                                                               \
     return tres;                                                               \
diff --git a/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.C b/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.C
index 59b7a1fd24..e82f2e6345 100644
--- a/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.C
+++ b/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -31,77 +31,99 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define UNARY_FUNCTION(ReturnType, Type, Func)                                 \
-                                                                               \
-TEMPLATE                                                                       \
-void Func(Field<ReturnType>& res, const UList<Type>& f)                        \
-{                                                                              \
-    TFOR_ALL_F_OP_FUNC_F(ReturnType, res, =, ::Foam::Func, Type, f)            \
-}                                                                              \
-                                                                               \
-TEMPLATE                                                                       \
-tmp<Field<ReturnType>> Func(const UList<Type>& f)                              \
-{                                                                              \
-    auto tres = tmp<Field<ReturnType>>::New(f.size());                         \
-    Func(tres.ref(), f);                                                       \
-    return tres;                                                               \
-}                                                                              \
-                                                                               \
-TEMPLATE                                                                       \
-tmp<Field<ReturnType>> Func(const tmp<Field<Type>>& tf)                        \
-{                                                                              \
-    auto tres = reuseTmp<ReturnType, Type>::New(tf);                           \
-    Func(tres.ref(), tf());                                                    \
-    tf.clear();                                                                \
-    return tres;                                                               \
-}
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#define UNARY_OPERATOR(ReturnType, Type, Op, OpFunc)                           \
-                                                                               \
-TEMPLATE                                                                       \
-void OpFunc(Field<ReturnType>& res, const UList<Type>& f)                      \
-{                                                                              \
-    TFOR_ALL_F_OP_OP_F(ReturnType, res, =, Op, Type, f)                        \
-}                                                                              \
-                                                                               \
-TEMPLATE                                                                       \
-tmp<Field<ReturnType>> operator Op(const UList<Type>& f)                       \
-{                                                                              \
-    auto tres = tmp<Field<ReturnType>>::New(f.size());                         \
-    OpFunc(tres.ref(), f);                                                     \
-    return tres;                                                               \
-}                                                                              \
-                                                                               \
-TEMPLATE                                                                       \
-tmp<Field<ReturnType>> operator Op(const tmp<Field<Type>>& tf)                 \
-{                                                                              \
-    auto tres = reuseTmp<ReturnType, Type>::New(tf);                           \
-    OpFunc(tres.ref(), tf());                                                  \
-    tf.clear();                                                                \
-    return tres;                                                               \
-}
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func)                        \
+#define UNARY_FUNCTION(ReturnType, Type1, Func)                                \
                                                                                \
 TEMPLATE                                                                       \
 void Func                                                                      \
 (                                                                              \
-    Field<ReturnType>& res,                                                    \
+    Field<ReturnType>& result,                                                 \
+    const UList<Type1>& f1                                                     \
+)                                                                              \
+{                                                                              \
+    TFOR_ALL_F_OP_FUNC_F(ReturnType, result, =, ::Foam::Func, Type1, f1)       \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const UList<Type1>& f1                                                     \
+)                                                                              \
+{                                                                              \
+    auto tres = tmp<Field<ReturnType>>::New(f1.size());                        \
+    Func(tres.ref(), f1);                                                      \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const tmp<Field<Type1>>& tf1                                               \
+)                                                                              \
+{                                                                              \
+    auto tres = reuseTmp<ReturnType, Type1>::New(tf1);                         \
+    Func(tres.ref(), tf1());                                                   \
+    tf1.clear();                                                               \
+    return tres;                                                               \
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc)                          \
+                                                                               \
+TEMPLATE                                                                       \
+void OpFunc                                                                    \
+(                                                                              \
+    Field<ReturnType>& result,                                                 \
+    const UList<Type1>& f1                                                     \
+)                                                                              \
+{                                                                              \
+    TFOR_ALL_F_OP_OP_F(ReturnType, result, =, Op, Type1, f1)                   \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> operator Op                                             \
+(                                                                              \
+    const UList<Type1>& f1                                                     \
+)                                                                              \
+{                                                                              \
+    auto tres = tmp<Field<ReturnType>>::New(f1.size());                        \
+    OpFunc(tres.ref(), f1);                                                    \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> operator Op                                             \
+(                                                                              \
+    const tmp<Field<Type1>>& tf1                                               \
+)                                                                              \
+{                                                                              \
+    auto tres = reuseTmp<ReturnType, Type1>::New(tf1);                         \
+    OpFunc(tres.ref(), tf1());                                                 \
+    tf1.clear();                                                               \
+    return tres;                                                               \
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define BINARY_FUNCTION_TRANSFORM(ReturnType, Type1, Type2, Func)              \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    Field<ReturnType>& result,                                                 \
     const UList<Type1>& f1,                                                    \
     const UList<Type2>& f2                                                     \
 )                                                                              \
 {                                                                              \
     TFOR_ALL_F_OP_FUNC_F_F                                                     \
     (                                                                          \
-        ReturnType, res, =, ::Foam::Func, Type1, f1, Type2, f2                 \
+        ReturnType, result, =, ::Foam::Func, Type1, f1, Type2, f2              \
     )                                                                          \
-}                                                                              \
+}
+
+#define BINARY_FUNCTION_INTERFACE(ReturnType, Type1, Type2, Func)              \
                                                                                \
 TEMPLATE                                                                       \
 tmp<Field<ReturnType>> Func                                                    \
@@ -155,24 +177,30 @@ tmp<Field<ReturnType>> Func                                                    \
     return tres;                                                               \
 }
 
+#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func)                        \
+    BINARY_FUNCTION_TRANSFORM(ReturnType, Type1, Type2, Func)                  \
+    BINARY_FUNCTION_INTERFACE(ReturnType, Type1, Type2, Func)
+
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func)                \
+#define BINARY_FUNCTION_TRANSFORM_SF(ReturnType, Type1, Type2, Func)           \
                                                                                \
 TEMPLATE                                                                       \
 void Func                                                                      \
 (                                                                              \
-    Field<ReturnType>& res,                                                    \
+    Field<ReturnType>& result,                                                 \
     const Type1& s1,                                                           \
     const UList<Type2>& f2                                                     \
 )                                                                              \
 {                                                                              \
     TFOR_ALL_F_OP_FUNC_S_F                                                     \
     (                                                                          \
-        ReturnType, res, =, ::Foam::Func, Type1, s1, Type2, f2                 \
+        ReturnType, result, =, ::Foam::Func, Type1, s1, Type2, f2              \
     )                                                                          \
-}                                                                              \
+}
+
+#define BINARY_FUNCTION_INTERFACE_SF(ReturnType, Type1, Type2, Func)           \
                                                                                \
 TEMPLATE                                                                       \
 tmp<Field<ReturnType>> Func                                                    \
@@ -199,22 +227,28 @@ tmp<Field<ReturnType>> Func                                                    \
     return tres;                                                               \
 }
 
+#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func)                \
+    BINARY_FUNCTION_TRANSFORM_SF(ReturnType, Type1, Type2, Func)               \
+    BINARY_FUNCTION_INTERFACE_SF(ReturnType, Type1, Type2, Func)
 
-#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)                \
+
+#define BINARY_FUNCTION_TRANSFORM_FS(ReturnType, Type1, Type2, Func)           \
                                                                                \
 TEMPLATE                                                                       \
 void Func                                                                      \
 (                                                                              \
-    Field<ReturnType>& res,                                                    \
+    Field<ReturnType>& result,                                                 \
     const UList<Type1>& f1,                                                    \
     const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
     TFOR_ALL_F_OP_FUNC_F_S                                                     \
     (                                                                          \
-        ReturnType, res, =, ::Foam::Func, Type1, f1, Type2, s2                 \
+        ReturnType, result, =, ::Foam::Func, Type1, f1, Type2, s2              \
     )                                                                          \
-}                                                                              \
+}
+
+#define BINARY_FUNCTION_INTERFACE_FS(ReturnType, Type1, Type2, Func)           \
                                                                                \
 TEMPLATE                                                                       \
 tmp<Field<ReturnType>> Func                                                    \
@@ -241,6 +275,10 @@ tmp<Field<ReturnType>> Func                                                    \
     return tres;                                                               \
 }
 
+#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)                \
+    BINARY_FUNCTION_TRANSFORM_FS(ReturnType, Type1, Type2, Func)               \
+    BINARY_FUNCTION_INTERFACE_FS(ReturnType, Type1, Type2, Func)
+
 
 #define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func)                   \
     BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func)                    \
@@ -254,12 +292,12 @@ tmp<Field<ReturnType>> Func                                                    \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    Field<ReturnType>& res,                                                    \
+    Field<ReturnType>& result,                                                 \
     const UList<Type1>& f1,                                                    \
     const UList<Type2>& f2                                                     \
 )                                                                              \
 {                                                                              \
-    TFOR_ALL_F_OP_F_OP_F(ReturnType, res, =, Type1, f1, Op, Type2, f2)         \
+    TFOR_ALL_F_OP_F_OP_F(ReturnType, result, =, Type1, f1, Op, Type2, f2)      \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
@@ -322,12 +360,12 @@ tmp<Field<ReturnType>> operator Op                                             \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    Field<ReturnType>& res,                                                    \
+    Field<ReturnType>& result,                                                 \
     const Type1& s1,                                                           \
     const UList<Type2>& f2                                                     \
 )                                                                              \
 {                                                                              \
-    TFOR_ALL_F_OP_S_OP_F(ReturnType, res, =, Type1, s1, Op, Type2, f2)         \
+    TFOR_ALL_F_OP_S_OP_F(ReturnType, result, =, Type1, s1, Op, Type2, f2)      \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
@@ -361,12 +399,12 @@ tmp<Field<ReturnType>> operator Op                                             \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    Field<ReturnType>& res,                                                    \
+    Field<ReturnType>& result,                                                 \
     const UList<Type1>& f1,                                                    \
     const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    TFOR_ALL_F_OP_F_OP_S(ReturnType, res, =, Type1, f1, Op, Type2, s2)         \
+    TFOR_ALL_F_OP_F_OP_S(ReturnType, result, =, Type1, f1, Op, Type2, s2)      \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
diff --git a/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.H b/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.H
index f975bffa52..1730ad22ba 100644
--- a/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.H
+++ b/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.H
@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -24,9 +25,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Description
-    High performance macro functions for Field\<Type\> algebra.  These expand
-    using either array element access (for vector machines) or pointer
-    dereferencing for scalar machines as appropriate.
+    Macro functions for Field\<Type\> algebra.
 
 \*---------------------------------------------------------------------------*/
 
@@ -35,11 +34,13 @@ Description
 #define UNARY_FUNCTION(ReturnType, Type1, Func)                                \
                                                                                \
 TEMPLATE                                                                       \
-void Func(Field<ReturnType>& res, const UList<Type1>& f);                      \
+void Func(Field<ReturnType>& result, const UList<Type1>& f1);                  \
+                                                                               \
 TEMPLATE                                                                       \
-tmp<Field<ReturnType>> Func(const UList<Type1>& f);                            \
+tmp<Field<ReturnType>> Func(const UList<Type1>& f1);                           \
+                                                                               \
 TEMPLATE                                                                       \
-tmp<Field<ReturnType>> Func(const tmp<Field<Type1>>& tf);
+tmp<Field<ReturnType>> Func(const tmp<Field<Type1>>& tf1);
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -47,65 +48,74 @@ tmp<Field<ReturnType>> Func(const tmp<Field<Type1>>& tf);
 #define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc)                          \
                                                                                \
 TEMPLATE                                                                       \
-void OpFunc(Field<ReturnType>& res, const UList<Type1>& f);                    \
+void OpFunc(Field<ReturnType>& res, const UList<Type1>& f1);                   \
+                                                                               \
 TEMPLATE                                                                       \
-tmp<Field<ReturnType>> operator Op(const UList<Type1>& f);                     \
+tmp<Field<ReturnType>> operator Op(const UList<Type1>& f1);                    \
+                                                                               \
 TEMPLATE                                                                       \
-tmp<Field<ReturnType>> operator Op(const tmp<Field<Type1>>& tf);
+tmp<Field<ReturnType>> operator Op(const tmp<Field<Type1>>& tf1);
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#define BINARY_FUNCTION_TRANSFORM(ReturnType, Type1, Type2, Func)              \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    Field<ReturnType>& result,                                                 \
+    const UList<Type1>& f1,                                                    \
+    const UList<Type2>& f2                                                     \
+);
+
+#define BINARY_FUNCTION_INTERFACE(ReturnType, Type1, Type2, Func)              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const UList<Type1>& f1,                                                    \
+    const UList<Type2>& f2                                                     \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const UList<Type1>& f1,                                                    \
+    const tmp<Field<Type2>>& tf2                                               \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const tmp<Field<Type1>>& tf1,                                              \
+    const UList<Type2>& f2                                                     \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const tmp<Field<Type1>>& tf1,                                              \
+    const tmp<Field<Type2>>& tf2                                               \
+);
+
 #define BINARY_FUNCTION(ReturnType, Type1, Type2, Func)                        \
-                                                                               \
-TEMPLATE                                                                       \
-void Func                                                                      \
-(                                                                              \
-    Field<ReturnType>& f,                                                      \
-    const UList<Type1>& f1,                                                    \
-    const UList<Type2>& f2                                                     \
-);                                                                             \
-                                                                               \
-TEMPLATE                                                                       \
-tmp<Field<ReturnType>> Func                                                    \
-(                                                                              \
-    const UList<Type1>& f1,                                                    \
-    const UList<Type2>& f2                                                     \
-);                                                                             \
-                                                                               \
-TEMPLATE                                                                       \
-tmp<Field<ReturnType>> Func                                                    \
-(                                                                              \
-    const UList<Type1>& f1,                                                    \
-    const tmp<Field<Type2>>& tf2                                               \
-);                                                                             \
-                                                                               \
-TEMPLATE                                                                       \
-tmp<Field<ReturnType>> Func                                                    \
-(                                                                              \
-    const tmp<Field<Type1>>& tf1,                                              \
-    const UList<Type2>& f2                                                     \
-);                                                                             \
-                                                                               \
-TEMPLATE                                                                       \
-tmp<Field<ReturnType>> Func                                                    \
-(                                                                              \
-    const tmp<Field<Type1>>& tf1,                                              \
-    const tmp<Field<Type2>>& tf2                                               \
-);
-
+    BINARY_FUNCTION_TRANSFORM(ReturnType, Type1, Type2, Func)                  \
+    BINARY_FUNCTION_INTERFACE(ReturnType, Type1, Type2, Func)
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func)                \
+#define BINARY_FUNCTION_TRANSFORM_SF(ReturnType, Type1, Type2, Func)           \
                                                                                \
 TEMPLATE                                                                       \
 void Func                                                                      \
 (                                                                              \
-    Field<ReturnType>& f,                                                      \
+    Field<ReturnType>& result,                                                 \
     const Type1& s1,                                                           \
     const UList<Type2>& f2                                                     \
-);                                                                             \
+);
+
+#define BINARY_FUNCTION_INTERFACE_SF(ReturnType, Type1, Type2, Func)           \
                                                                                \
 TEMPLATE                                                                       \
 tmp<Field<ReturnType>> Func                                                    \
@@ -121,16 +131,22 @@ tmp<Field<ReturnType>> Func                                                    \
     const tmp<Field<Type2>>& tf2                                               \
 );
 
+#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func)                \
+    BINARY_FUNCTION_TRANSFORM_SF(ReturnType, Type1, Type2, Func)               \
+    BINARY_FUNCTION_INTERFACE_SF(ReturnType, Type1, Type2, Func)
 
-#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)                \
+
+#define BINARY_FUNCTION_TRANSFORM_FS(ReturnType, Type1, Type2, Func)           \
                                                                                \
 TEMPLATE                                                                       \
 void Func                                                                      \
 (                                                                              \
-    Field<ReturnType>& f,                                                      \
+    Field<ReturnType>& result,                                                 \
     const UList<Type1>& f1,                                                    \
     const Type2& s2                                                            \
-);                                                                             \
+);
+
+#define BINARY_FUNCTION_INTERFACE_FS(ReturnType, Type1, Type2, Func)           \
                                                                                \
 TEMPLATE                                                                       \
 tmp<Field<ReturnType>> Func                                                    \
@@ -146,6 +162,10 @@ tmp<Field<ReturnType>> Func                                                    \
     const Type2& s2                                                            \
 );
 
+#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)                \
+    BINARY_FUNCTION_TRANSFORM_FS(ReturnType, Type1, Type2, Func)               \
+    BINARY_FUNCTION_INTERFACE_FS(ReturnType, Type1, Type2, Func)
+
 
 #define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func)                   \
     BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func)                    \
@@ -159,7 +179,7 @@ tmp<Field<ReturnType>> Func                                                    \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    Field<ReturnType>& f,                                                      \
+    Field<ReturnType>& result,                                                 \
     const UList<Type1>& f1,                                                    \
     const UList<Type2>& f2                                                     \
 );                                                                             \
@@ -200,7 +220,7 @@ tmp<Field<ReturnType>> operator Op                                             \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    Field<ReturnType>& f,                                                      \
+    Field<ReturnType>& result,                                                 \
     const Type1& s1,                                                           \
     const UList<Type2>& f2                                                     \
 );                                                                             \
@@ -225,7 +245,7 @@ tmp<Field<ReturnType>> operator Op                                             \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    Field<ReturnType>& f,                                                      \
+    Field<ReturnType>& result,                                                 \
     const UList<Type1>& f1,                                                    \
     const Type2& s2                                                            \
 );                                                                             \
diff --git a/src/OpenFOAM/fields/Fields/Field/FieldM.H b/src/OpenFOAM/fields/Fields/Field/FieldM.H
index 307796eae3..0cb9072bfd 100644
--- a/src/OpenFOAM/fields/Fields/Field/FieldM.H
+++ b/src/OpenFOAM/fields/Fields/Field/FieldM.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2022 OpenCFD Ltd.
+    Copyright (C) 2022-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,9 +25,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Description
-    High performance macro functions for Field\<Type\> algebra.  These expand
-    using either array element access (for vector machines) or pointer
-    dereferencing for scalar machines as appropriate.
+    Declaration macros for Field\<Type\> algebra.
 
 \*---------------------------------------------------------------------------*/
 
@@ -86,6 +84,34 @@ void checkFields
     }
 }
 
+template<class Type1, class Type2, class Type3, class Type4>
+void checkFields
+(
+    const UList<Type1>& f1,
+    const UList<Type2>& f2,
+    const UList<Type3>& f3,
+    const UList<Type4>& f4,
+    const char* op
+)
+{
+    if
+    (
+        f1.size() != f2.size()
+     || f1.size() != f3.size()
+     || f1.size() != f4.size()
+    )
+    {
+        FatalErrorInFunction
+            << " Field<"<<pTraits<Type1>::typeName<<"> f1("<<f1.size()<<')'
+            << ", Field<"<<pTraits<Type2>::typeName<<"> f2("<<f2.size()<<')'
+            << ", Field<"<<pTraits<Type3>::typeName<<"> f3("<<f3.size()<<')'
+            << " and Field<"<<pTraits<Type4>::typeName<<"> f4("<<f4.size()<<')'
+            << endl
+            << "    for operation " << op
+            << abort(FatalError);
+    }
+}
+
 #else
 
 template<class Type1, class Type2>
@@ -107,12 +133,23 @@ void checkFields
 )
 {}
 
+template<class Type1, class Type2, class Type3, class Type4>
+void checkFields
+(
+    const UList<Type1>&,
+    const UList<Type2>&,
+    const UList<Type3>&,
+    const UList<Type4>&,
+    const char*
+)
+{}
+
 #endif
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-// Member function : f1 OP Func f2
+// Unary Free Function : f1 OP Func f2
 
 #define TFOR_ALL_F_OP_FUNC_F(typeF1, f1, OP, FUNC, typeF2, f2)                 \
                                                                                \
@@ -133,7 +170,7 @@ void checkFields
     }
 
 
-// Member function : this f1 OP f2.FUNC()
+// Nullary Member Function : f1 OP f2.FUNC()
 
 #define TFOR_ALL_F_OP_F_FUNC(typeF1, f1, OP, typeF2, f2, FUNC)                 \
                                                                                \
@@ -154,7 +191,7 @@ void checkFields
     }
 
 
-// Member function : this field f1 OP FUNC(f2, f3)
+// Binary Free Function : f1 OP FUNC(f2, f3)
 
 #define TFOR_ALL_F_OP_FUNC_F_F(typeF1, f1, OP, FUNC, typeF2, f2, typeF3, f3)   \
                                                                                \
@@ -176,7 +213,7 @@ void checkFields
     }
 
 
-// Member function : s OP FUNC(f1, f2)
+// [reduction] Binary Free Function : s OP FUNC(f1, f2)
 
 #define TFOR_ALL_S_OP_FUNC_F_F(typeS, s, OP, FUNC, typeF1, f1, typeF2, f2)     \
                                                                                \
@@ -197,7 +234,7 @@ void checkFields
     }
 
 
-// Member function : this f1 OP FUNC(f2, s)
+// Binary Free Function : f1 OP FUNC(f2, s)
 
 #define TFOR_ALL_F_OP_FUNC_F_S(typeF1, f1, OP, FUNC, typeF2, f2, typeS, s)     \
                                                                                \
@@ -218,7 +255,7 @@ void checkFields
     }
 
 
-// Member function : s1 OP FUNC(f, s2)
+// [reduction] Binary Free Function : s1 OP FUNC(f, s2)
 
 #define TFOR_ALL_S_OP_FUNC_F_S(typeS1, s1, OP, FUNC, typeF, f, typeS2, s2)     \
                                                                                \
@@ -235,7 +272,7 @@ void checkFields
     }
 
 
-// Member function : this f1 OP FUNC(s, f2)
+// Binary Free Function : f1 OP FUNC(s, f2)
 
 #define TFOR_ALL_F_OP_FUNC_S_F(typeF1, f1, OP, FUNC, typeS, s, typeF2, f2)     \
                                                                                \
@@ -256,7 +293,7 @@ void checkFields
     }
 
 
-// Member function : this f1 OP FUNC(s1, s2)
+// Binary Free Function : f1 OP FUNC(s1, s2)
 
 #define TFOR_ALL_F_OP_FUNC_S_S(typeF1, f1, OP, FUNC, typeS1, s1, typeS2, s2)   \
                                                                                \
@@ -273,7 +310,7 @@ void checkFields
     }
 
 
-// Member function : this f1 OP f2 FUNC(s)
+// Unary Member Function : f1 OP f2 FUNC(s)
 
 #define TFOR_ALL_F_OP_F_FUNC_S(typeF1, f1, OP, typeF2, f2, FUNC, typeS, s)     \
                                                                                \
@@ -294,6 +331,56 @@ void checkFields
     }
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Ternary Free Function : f1 OP FUNC(f2, f3, f4)
+
+#define TFOR_ALL_F_OP_FUNC_F_F_F\
+(typeF1, f1, OP, FUNC, typeF2, f2, typeF3, f3, typeF4, f4)                     \
+                                                                               \
+    /* Check fields have same size */                                          \
+    checkFields(f1, f2, f3, f4, "f1 " #OP " " #FUNC "(f2, f3, f4)");           \
+                                                                               \
+    /* Field access */                                                         \
+    List_ACCESS(typeF1, f1, f1P);                                              \
+    List_CONST_ACCESS(typeF2, f2, f2P);                                        \
+    List_CONST_ACCESS(typeF3, f3, f3P);                                        \
+    List_CONST_ACCESS(typeF4, f4, f4P);                                        \
+                                                                               \
+    /* Loop: f1 OP FUNC(f2, f3, f4) */                                         \
+    const label loopLen = (f1).size();                                         \
+                                                                               \
+    /* pragmas... */                                                           \
+    for (label i = 0; i < loopLen; ++i)                                        \
+    {                                                                          \
+        (f1P[i]) OP FUNC((f2P[i]), (f3P[i]), (f4P[i]));                        \
+    }
+
+// Ternary Free Function : f1 OP FUNC(f2, f3, s4)
+
+#define TFOR_ALL_F_OP_FUNC_F_F_S\
+(typeF1, f1, OP, FUNC, typeF2, f2, typeF3, f3, typeF4, s4)                     \
+                                                                               \
+    /* Check fields have same size */                                          \
+    checkFields(f1, f2, f3, "f1 " #OP " " #FUNC "(f2, f3, s)");                \
+                                                                               \
+    /* Field access */                                                         \
+    List_ACCESS(typeF1, f1, f1P);                                              \
+    List_CONST_ACCESS(typeF2, f2, f2P);                                        \
+    List_CONST_ACCESS(typeF3, f3, f3P);                                        \
+                                                                               \
+    /* Loop: f1 OP FUNC(f2, f3, s4) */                                         \
+    const label loopLen = (f1).size();                                         \
+                                                                               \
+    /* pragmas... */                                                           \
+    for (label i = 0; i < loopLen; ++i)                                        \
+    {                                                                          \
+        (f1P[i]) OP FUNC((f2P[i]), (f3P[i]), (s4));                            \
+    }
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 // Member operator : this field f1 OP1 f2 OP2 f3
 
 #define TFOR_ALL_F_OP_F_OP_F(typeF1, f1, OP1, typeF2, f2, OP2, typeF3, f3)     \
diff --git a/src/OpenFOAM/fields/Fields/Field/FieldReuseFunctions.H b/src/OpenFOAM/fields/Fields/Field/FieldReuseFunctions.H
index d05c15d427..0d23585fe9 100644
--- a/src/OpenFOAM/fields/Fields/Field/FieldReuseFunctions.H
+++ b/src/OpenFOAM/fields/Fields/Field/FieldReuseFunctions.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2022 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -35,10 +35,18 @@ namespace Foam
 {
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// One-parameter versions
 
 template<class TypeR, class Type1>
 struct reuseTmp
 {
+    //- Pass-through to tmp New
+    static tmp<Field<TypeR>> New(const Field<Type1>& f1)
+    {
+        return tmp<Field<TypeR>>::New(f1.size());
+    }
+
+    //- Dissimilar types: just use size
     static tmp<Field<TypeR>> New(const tmp<Field<Type1>>& tf1)
     {
         return tmp<Field<TypeR>>::New(tf1().size());
@@ -49,8 +57,8 @@ struct reuseTmp
 template<class TypeR>
 struct reuseTmp<TypeR, TypeR>
 {
-    //- Allow optional copy assignment of the initial content
-    //- for identical input and output types
+    //- Identical input and return types:
+    //- allow optional copy assignment of the initial content
     static tmp<Field<TypeR>> New
     (
         const tmp<Field<TypeR>>& tf1,
@@ -85,9 +93,13 @@ template<class TypeR> tmp<Field<TypeR>> New
 }
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Two-parameter versions
+
 template<class TypeR, class Type1, class Type12, class Type2>
 struct reuseTmpTmp
 {
+    //- Dissimilar types: just use size
     static tmp<Field<TypeR>> New
     (
         const tmp<Field<Type1>>& tf1,
@@ -102,6 +114,7 @@ struct reuseTmpTmp
 template<class TypeR, class Type1, class Type12>
 struct reuseTmpTmp<TypeR, Type1, Type12, TypeR>
 {
+    //- Second input has return type
     static tmp<Field<TypeR>> New
     (
         const tmp<Field<Type1>>& tf1,
@@ -121,6 +134,7 @@ struct reuseTmpTmp<TypeR, Type1, Type12, TypeR>
 template<class TypeR, class Type2>
 struct reuseTmpTmp<TypeR, TypeR, TypeR, Type2>
 {
+    //- First input has return type
     static tmp<Field<TypeR>> New
     (
         const tmp<Field<TypeR>>& tf1,
@@ -140,6 +154,7 @@ struct reuseTmpTmp<TypeR, TypeR, TypeR, Type2>
 template<class TypeR>
 struct reuseTmpTmp<TypeR, TypeR, TypeR, TypeR>
 {
+    //- Both inputs have return type
     static tmp<Field<TypeR>> New
     (
         const tmp<Field<TypeR>>& tf1,
diff --git a/src/OpenFOAM/fields/Fields/Field/undefFieldFunctionsM.H b/src/OpenFOAM/fields/Fields/Field/undefFieldFunctionsM.H
index 3eb660e382..0a1e1cc9d3 100644
--- a/src/OpenFOAM/fields/Fields/Field/undefFieldFunctionsM.H
+++ b/src/OpenFOAM/fields/Fields/Field/undefFieldFunctionsM.H
@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -26,20 +27,40 @@ License
 \*---------------------------------------------------------------------------*/
 
 #undef UNARY_FUNCTION
+#undef UNARY_FUNCTION_TRANSFORM
+#undef UNARY_FUNCTION_INTERFACE
 
 #undef UNARY_OPERATOR
+#undef UNARY_OPERATOR_TRANSFORM
+#undef UNARY_OPERATOR_INTERFACE
 
 #undef BINARY_FUNCTION
+#undef BINARY_FUNCTION_TRANSFORM
+#undef BINARY_FUNCTION_INTERFACE
 
+#undef BINARY_TYPE_FUNCTION
 #undef BINARY_TYPE_FUNCTION_SF
 #undef BINARY_TYPE_FUNCTION_FS
-#undef BINARY_TYPE_FUNCTION
+#undef BINARY_FUNCTION_TRANSFORM_SF
+#undef BINARY_FUNCTION_INTERFACE_SF
+#undef BINARY_FUNCTION_TRANSFORM_FS
+#undef BINARY_FUNCTION_INTERFACE_FS
 
 #undef BINARY_OPERATOR
-
+#undef BINARY_TYPE_OPERATOR
 #undef BINARY_TYPE_OPERATOR_SF
 #undef BINARY_TYPE_OPERATOR_FS
-#undef BINARY_TYPE_OPERATOR
+
+#undef TERNARY_FUNCTION
+#undef TERNARY_FUNCTION_TRANSFORM
+#undef TERNARY_FUNCTION_INTERFACE
+#undef TERNARY_TYPE_FUNCTION
+#undef TERNARY_TYPE_FUNCTION_FFS
+#undef TERNARY_TYPE_FUNCTION_FSF
+#undef TERNARY_TYPE_FUNCTION_SFF
+#undef TERNARY_TYPE_FUNCTION_SSF
+#undef TERNARY_TYPE_FUNCTION_SFS
+#undef TERNARY_TYPE_FUNCTION_FSS
 
 #undef TEMPLATE
 
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.C b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.C
index f6eb4fafd5..0c686d3be2 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.C
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2019 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -37,7 +37,7 @@ License
 namespace Foam
 {
 
-// * * * * * * * * * * * * * * * Global functions  * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
 
 template<class Type, template<class> class PatchField, class GeoMesh>
 void component
@@ -47,27 +47,27 @@ void component
         typename GeometricField<Type, PatchField, GeoMesh>::cmptType,
         PatchField,
         GeoMesh
-    >& gcf,
-    const GeometricField<Type, PatchField, GeoMesh>& gf,
+    >& result,
+    const GeometricField<Type, PatchField, GeoMesh>& f1,
     const direction d
 )
 {
-    component(gcf.primitiveFieldRef(), gf.primitiveField(), d);
-    component(gcf.boundaryFieldRef(), gf.boundaryField(), d);
-    gcf.oriented() = gf.oriented();
+    component(result.primitiveFieldRef(), f1.primitiveField(), d);
+    component(result.boundaryFieldRef(), f1.boundaryField(), d);
+    result.oriented() = f1.oriented();
 }
 
 
 template<class Type, template<class> class PatchField, class GeoMesh>
 void T
 (
-     GeometricField<Type, PatchField, GeoMesh>& gf,
-     const GeometricField<Type, PatchField, GeoMesh>& gf1
+     GeometricField<Type, PatchField, GeoMesh>& result,
+     const GeometricField<Type, PatchField, GeoMesh>& f1
 )
 {
-    T(gf.primitiveFieldRef(), gf1.primitiveField());
-    T(gf.boundaryFieldRef(), gf1.boundaryField());
-    gf.oriented() = gf1.oriented();
+    T(result.primitiveFieldRef(), f1.primitiveField());
+    T(result.boundaryFieldRef(), f1.boundaryField());
+    result.oriented() = f1.oriented();
 }
 
 
@@ -80,13 +80,14 @@ template
 >
 void pow
 (
-    GeometricField<typename powProduct<Type, r>::type, PatchField, GeoMesh>& gf,
-    const GeometricField<Type, PatchField, GeoMesh>& gf1
+    GeometricField
+    <typename powProduct<Type, r>::type, PatchField, GeoMesh>& result,
+    const GeometricField<Type, PatchField, GeoMesh>& f1
 )
 {
-    pow(gf.primitiveFieldRef(), gf1.primitiveField(), r);
-    pow(gf.boundaryFieldRef(), gf1.boundaryField(), r);
-    gf.oriented() = pow(gf1.oriented(), r);
+    pow(result.primitiveFieldRef(), f1.primitiveField(), r);
+    pow(result.boundaryFieldRef(), f1.boundaryField(), r);
+    result.oriented() = pow(f1.oriented(), r);
 }
 
 
@@ -100,28 +101,21 @@ template
 tmp<GeometricField<typename powProduct<Type, r>::type, PatchField, GeoMesh>>
 pow
 (
-    const GeometricField<Type, PatchField, GeoMesh>& gf,
+    const GeometricField<Type, PatchField, GeoMesh>& f1,
     typename powProduct<Type, r>::type
 )
 {
-    typedef typename powProduct<Type, r>::type powProductType;
+    typedef typename powProduct<Type, r>::type resultType;
 
     auto tres =
-        tmp<GeometricField<powProductType, PatchField, GeoMesh>>::New
+        reuseTmpGeometricField<resultType, Type, PatchField, GeoMesh>::New
         (
-            IOobject
-            (
-                "pow(" + gf.name() + ',' + name(r) + ')',
-                gf.instance(),
-                gf.db(),
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            gf.mesh(),
-            pow(gf.dimensions(), r)
+            f1,
+            "pow(" + f1.name() + ',' + Foam::name(r) + ')',
+            pow(f1.dimensions(), r)
         );
 
-    pow<Type, r, PatchField, GeoMesh>(tres.ref(), gf);
+    pow<Type, r, PatchField, GeoMesh>(tres.ref(), f1);
 
     return tres;
 }
@@ -137,32 +131,25 @@ template
 tmp<GeometricField<typename powProduct<Type, r>::type, PatchField, GeoMesh>>
 pow
 (
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf,
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1,
     typename powProduct<Type, r>::type
 )
 {
-    typedef typename powProduct<Type, r>::type powProductType;
+    typedef typename powProduct<Type, r>::type resultType;
 
-    const GeometricField<Type, PatchField, GeoMesh>& gf = tgf();
+    const auto& f1 = tf1();
 
     auto tres =
-        tmp<GeometricField<powProductType, PatchField, GeoMesh>>::New
+        reuseTmpGeometricField<resultType, Type, PatchField, GeoMesh>::New
         (
-            IOobject
-            (
-                "pow(" + gf.name() + ',' + name(r) + ')',
-                gf.instance(),
-                gf.db(),
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            gf.mesh(),
-            pow(gf.dimensions(), r)
+            tf1,
+            "pow(" + f1.name() + ',' + Foam::name(r) + ')',
+            pow(f1.dimensions(), r)
         );
 
-    pow<Type, r, PatchField, GeoMesh>(tres.ref(), gf);
+    pow<Type, r, PatchField, GeoMesh>(tres.ref(), f1);
 
-    tgf.clear();
+    tf1.clear();
     return tres;
 }
 
@@ -171,13 +158,15 @@ template<class Type, template<class> class PatchField, class GeoMesh>
 void sqr
 (
     GeometricField
-    <typename outerProduct<Type, Type>::type, PatchField, GeoMesh>& gf,
-    const GeometricField<Type, PatchField, GeoMesh>& gf1
+    <
+        typename outerProduct<Type, Type>::type, PatchField, GeoMesh
+    >& result,
+    const GeometricField<Type, PatchField, GeoMesh>& f1
 )
 {
-    sqr(gf.primitiveFieldRef(), gf1.primitiveField());
-    sqr(gf.boundaryFieldRef(), gf1.boundaryField());
-    gf.oriented() = sqr(gf1.oriented());
+    sqr(result.primitiveFieldRef(), f1.primitiveField());
+    sqr(result.boundaryFieldRef(), f1.boundaryField());
+    result.oriented() = sqr(f1.oriented());
 }
 
 
@@ -191,26 +180,19 @@ tmp
         GeoMesh
     >
 >
-sqr(const GeometricField<Type, PatchField, GeoMesh>& gf)
+sqr(const GeometricField<Type, PatchField, GeoMesh>& f1)
 {
-    typedef typename outerProduct<Type, Type>::type outerProductType;
+    typedef typename outerProduct<Type, Type>::type resultType;
 
     auto tres =
-        tmp<GeometricField<outerProductType, PatchField, GeoMesh>>::New
+        reuseTmpGeometricField<resultType, Type, PatchField, GeoMesh>::New
         (
-            IOobject
-            (
-                "sqr(" + gf.name() + ')',
-                gf.instance(),
-                gf.db(),
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            gf.mesh(),
-            sqr(gf.dimensions())
+            f1,
+            "sqr(" + f1.name() + ')',
+            sqr(f1.dimensions())
         );
 
-    sqr(tres.ref(), gf);
+    sqr(tres.ref(), f1);
 
     return tres;
 }
@@ -226,31 +208,23 @@ tmp
         GeoMesh
     >
 >
-sqr(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf)
+sqr(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1)
 {
-    typedef typename outerProduct<Type, Type>::type outerProductType;
+    typedef typename outerProduct<Type, Type>::type resultType;
 
-    const GeometricField<Type, PatchField, GeoMesh>& gf = tgf();
+    const auto& f1 = tf1();
 
     auto tres =
-        tmp<GeometricField<outerProductType, PatchField, GeoMesh>>::New
+        reuseTmpGeometricField<resultType, Type, PatchField, GeoMesh>::New
         (
-            IOobject
-            (
-                "sqr(" + gf.name() + ')',
-                gf.instance(),
-                gf.db(),
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            gf.mesh(),
-            sqr(gf.dimensions())
+            tf1,
+            "sqr(" + f1.name() + ')',
+            sqr(f1.dimensions())
         );
 
-    sqr(tres.ref(), gf);
-
-    tgf.clear();
+    sqr(tres.ref(), f1);
 
+    tf1.clear();
     return tres;
 }
 
@@ -258,13 +232,13 @@ sqr(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf)
 template<class Type, template<class> class PatchField, class GeoMesh>
 void magSqr
 (
-    GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>& gsf,
-    const GeometricField<Type, PatchField, GeoMesh>& gf
+    GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>& result,
+    const GeometricField<Type, PatchField, GeoMesh>& f1
 )
 {
-    magSqr(gsf.primitiveFieldRef(), gf.primitiveField());
-    magSqr(gsf.boundaryFieldRef(), gf.boundaryField());
-    gsf.oriented() = magSqr(gf.oriented());
+    magSqr(result.primitiveFieldRef(), f1.primitiveField());
+    magSqr(result.boundaryFieldRef(), f1.boundaryField());
+    result.oriented() = magSqr(f1.oriented());
 }
 
 
@@ -272,27 +246,20 @@ template<class Type, template<class> class PatchField, class GeoMesh>
 tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>>
 magSqr
 (
-    const GeometricField<Type, PatchField, GeoMesh>& gf
+    const GeometricField<Type, PatchField, GeoMesh>& f1
 )
 {
-    typedef typename typeOfMag<Type>::type magType;
+    typedef typename typeOfMag<Type>::type resultType;
 
     auto tres =
-        tmp<GeometricField<magType, PatchField, GeoMesh>>::New
+        reuseTmpGeometricField<resultType, Type, PatchField, GeoMesh>::New
         (
-            IOobject
-            (
-                "magSqr(" + gf.name() + ')',
-                gf.instance(),
-                gf.db(),
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            gf.mesh(),
-            sqr(gf.dimensions())
+            f1,
+            "magSqr(" + f1.name() + ')',
+            sqr(f1.dimensions())
         );
 
-    magSqr(tres.ref(), gf);
+    magSqr(tres.ref(), f1);
 
     return tres;
 }
@@ -301,11 +268,11 @@ template<class Type, template<class> class PatchField, class GeoMesh>
 tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>>
 magSqr
 (
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1
 )
 {
-    auto tres = magSqr(tgf.cref());
-    tgf.clear();
+    auto tres = magSqr(tf1.cref());
+    tf1.clear();
 
     return tres;
 }
@@ -314,13 +281,13 @@ magSqr
 template<class Type, template<class> class PatchField, class GeoMesh>
 void mag
 (
-    GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>& gsf,
-    const GeometricField<Type, PatchField, GeoMesh>& gf
+    GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>& result,
+    const GeometricField<Type, PatchField, GeoMesh>& f1
 )
 {
-    mag(gsf.primitiveFieldRef(), gf.primitiveField());
-    mag(gsf.boundaryFieldRef(), gf.boundaryField());
-    gsf.oriented() = mag(gf.oriented());
+    mag(result.primitiveFieldRef(), f1.primitiveField());
+    mag(result.boundaryFieldRef(), f1.boundaryField());
+    result.oriented() = mag(f1.oriented());
 }
 
 
@@ -328,27 +295,20 @@ template<class Type, template<class> class PatchField, class GeoMesh>
 tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>>
 mag
 (
-    const GeometricField<Type, PatchField, GeoMesh>& gf
+    const GeometricField<Type, PatchField, GeoMesh>& f1
 )
 {
-    typedef typename typeOfMag<Type>::type magType;
+    typedef typename typeOfMag<Type>::type resultType;
 
     auto tres =
-        tmp<GeometricField<magType, PatchField, GeoMesh>>::New
+        reuseTmpGeometricField<resultType, Type, PatchField, GeoMesh>::New
         (
-            IOobject
-            (
-                "mag(" + gf.name() + ')',
-                gf.instance(),
-                gf.db(),
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            gf.mesh(),
-            gf.dimensions()
+            f1,
+            "mag(" + f1.name() + ')',
+            f1.dimensions()
         );
 
-    mag(tres.ref(), gf);
+    mag(tres.ref(), f1);
 
     return tres;
 }
@@ -357,11 +317,11 @@ template<class Type, template<class> class PatchField, class GeoMesh>
 tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>>
 mag
 (
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1
 )
 {
-    auto tres = mag(tgf.cref());
-    tgf.clear();
+    auto tres = mag(tf1.cref());
+    tf1.clear();
 
     return tres;
 }
@@ -375,13 +335,13 @@ void cmptAv
         typename GeometricField<Type, PatchField, GeoMesh>::cmptType,
         PatchField,
         GeoMesh
-    >& gcf,
-    const GeometricField<Type, PatchField, GeoMesh>& gf
+    >& result,
+    const GeometricField<Type, PatchField, GeoMesh>& f1
 )
 {
-    cmptAv(gcf.primitiveFieldRef(), gf.primitiveField());
-    cmptAv(gcf.boundaryFieldRef(), gf.boundaryField());
-    gcf.oriented() = cmptAv(gf.oriented());
+    cmptAv(result.primitiveFieldRef(), f1.primitiveField());
+    cmptAv(result.boundaryFieldRef(), f1.boundaryField());
+    result.oriented() = cmptAv(f1.oriented());
 }
 
 template<class Type, template<class> class PatchField, class GeoMesh>
@@ -394,27 +354,20 @@ tmp
         GeoMesh
     >
 >
-cmptAv(const GeometricField<Type, PatchField, GeoMesh>& gf)
+cmptAv(const GeometricField<Type, PatchField, GeoMesh>& f1)
 {
-    typedef typename GeometricField<Type, PatchField, GeoMesh>::cmptType
-        cmptType;
+    typedef typename
+        GeometricField<Type, PatchField, GeoMesh>::cmptType resultType;
 
     auto tres =
-        tmp<GeometricField<cmptType, PatchField, GeoMesh>>::New
+        reuseTmpGeometricField<resultType, Type, PatchField, GeoMesh>::New
         (
-            IOobject
-            (
-                "cmptAv(" + gf.name() + ')',
-                gf.instance(),
-                gf.db(),
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            gf.mesh(),
-            gf.dimensions()
+            f1,
+            "cmptAv(" + f1.name() + ')',
+            f1.dimensions()
         );
 
-    cmptAv(tres.ref(), gf);
+    cmptAv(tres.ref(), f1);
 
     return tres;
 }
@@ -430,68 +383,47 @@ tmp
         GeoMesh
     >
 >
-cmptAv(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf)
+cmptAv(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1)
 {
-    typedef typename GeometricField<Type, PatchField, GeoMesh>::cmptType
-        cmptType;
-
-    const GeometricField<Type, PatchField, GeoMesh>& gf = tgf();
-
-    auto tres =
-        tmp<GeometricField<cmptType, PatchField, GeoMesh>>::New
-        (
-            IOobject
-            (
-                "cmptAv(" + gf.name() + ')',
-                gf.instance(),
-                gf.db(),
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            gf.mesh(),
-            gf.dimensions()
-        );
-
-    cmptAv(tres.ref(), gf);
-
-    tgf.clear();
+    auto tres = cmptAv(tf1.cref());
+    tf1.clear();
 
     return tres;
 }
 
 
-#define UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(returnType, func, binaryOp)     \
+#define UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(ReturnType, Func, BinaryOp)     \
                                                                                \
 template<class Type, template<class> class PatchField, class GeoMesh>          \
-dimensioned<returnType> func                                                   \
+dimensioned<ReturnType> Func                                                   \
 (                                                                              \
-    const GeometricField<Type, PatchField, GeoMesh>& gf                        \
+    const GeometricField<Type, PatchField, GeoMesh>& f1                        \
 )                                                                              \
 {                                                                              \
-    return dimensioned<returnType>                                             \
+    return dimensioned<ReturnType>                                             \
     (                                                                          \
-        #func "(" + gf.name() + ')',                                           \
-        gf.dimensions(),                                                       \
+        #Func "(" + f1.name() + ')',                                           \
+        f1.dimensions(),                                                       \
         returnReduce                                                           \
         (                                                                      \
-            Foam::func                                                         \
+            Foam::Func                                                         \
             (                                                                  \
-                Foam::func(gf.primitiveField()),                               \
-                Foam::func(gf.boundaryField())                                 \
+                Foam::Func(f1.primitiveField()),                               \
+                Foam::Func(f1.boundaryField())                                 \
             ),                                                                 \
-            binaryOp<returnType>()                                             \
+            BinaryOp<ReturnType>()                                             \
         )                                                                      \
     );                                                                         \
 }                                                                              \
                                                                                \
 template<class Type, template<class> class PatchField, class GeoMesh>          \
-dimensioned<returnType> func                                                   \
+dimensioned<ReturnType> Func                                                   \
 (                                                                              \
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1                 \
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1                  \
 )                                                                              \
 {                                                                              \
-    dimensioned<returnType> res = func(tgf1());                                \
-    tgf1.clear();                                                              \
+    dimensioned<ReturnType> res = Func(tf1());                                 \
+    tf1.clear();                                                               \
     return res;                                                                \
 }
 
@@ -503,30 +435,30 @@ UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(scalarMinMax, minMaxMag, minMaxMagOp)
 #undef UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY
 
 
-#define UNARY_REDUCTION_FUNCTION(returnType, func, gFunc)                      \
+#define UNARY_REDUCTION_FUNCTION(ReturnType, Func, gFunc)                      \
                                                                                \
 template<class Type, template<class> class PatchField, class GeoMesh>          \
-dimensioned<returnType> func                                                   \
+dimensioned<ReturnType> Func                                                   \
 (                                                                              \
-    const GeometricField<Type, PatchField, GeoMesh>& gf                        \
+    const GeometricField<Type, PatchField, GeoMesh>& f1                        \
 )                                                                              \
 {                                                                              \
-    return dimensioned<returnType>                                             \
+    return dimensioned<ReturnType>                                             \
     (                                                                          \
-        #func "(" + gf.name() + ')',                                           \
-        gf.dimensions(),                                                       \
-        gFunc(gf.primitiveField())                                             \
+        #Func "(" + f1.name() + ')',                                           \
+        f1.dimensions(),                                                       \
+        gFunc(f1.primitiveField())                                             \
     );                                                                         \
 }                                                                              \
                                                                                \
 template<class Type, template<class> class PatchField, class GeoMesh>          \
-dimensioned<returnType> func                                                   \
+dimensioned<ReturnType> Func                                                   \
 (                                                                              \
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1                 \
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1                  \
 )                                                                              \
 {                                                                              \
-    dimensioned<returnType> res = func(tgf1());                                \
-    tgf1.clear();                                                              \
+    dimensioned<ReturnType> res = Func(tf1());                                 \
+    tf1.clear();                                                               \
     return res;                                                                \
 }
 
@@ -548,7 +480,7 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
 
 
-// * * * * * * * * * * * * * * * Global operators  * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 
 UNARY_OPERATOR(Type, Type, -, negate, transform)
 
@@ -564,64 +496,58 @@ BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, '|', divide)
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define PRODUCT_OPERATOR(product, op, opFunc)                                  \
+#define PRODUCT_OPERATOR(product, Op, OpFunc)                                  \
                                                                                \
 template                                                                       \
 <class Type1, class Type2, template<class> class PatchField, class GeoMesh>    \
-void opFunc                                                                    \
+void OpFunc                                                                    \
 (                                                                              \
     GeometricField                                                             \
-    <typename product<Type1, Type2>::type, PatchField, GeoMesh>& gf,           \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    <typename product<Type1, Type2>::type, PatchField, GeoMesh>& result,       \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 )                                                                              \
 {                                                                              \
-    Foam::opFunc                                                               \
+    Foam::OpFunc                                                               \
     (                                                                          \
-        gf.primitiveFieldRef(),                                                \
-        gf1.primitiveField(),                                                  \
-        gf2.primitiveField()                                                   \
+        result.primitiveFieldRef(),                                            \
+        f1.primitiveField(),                                                   \
+        f2.primitiveField()                                                    \
     );                                                                         \
-    Foam::opFunc                                                               \
+    Foam::OpFunc                                                               \
     (                                                                          \
-        gf.boundaryFieldRef(),                                                 \
-        gf1.boundaryField(),                                                   \
-        gf2.boundaryField()                                                    \
+        result.boundaryFieldRef(),                                             \
+        f1.boundaryField(),                                                    \
+        f2.boundaryField()                                                     \
     );                                                                         \
                                                                                \
-    gf.oriented() = gf1.oriented() op gf2.oriented();                          \
+    result.oriented() = (f1.oriented() Op f2.oriented());                      \
 }                                                                              \
                                                                                \
+                                                                               \
 template                                                                       \
 <class Type1, class Type2, template<class> class PatchField, class GeoMesh>    \
 tmp                                                                            \
 <                                                                              \
     GeometricField<typename product<Type1, Type2>::type, PatchField, GeoMesh>  \
 >                                                                              \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
+    typedef typename product<Type1, Type2>::type resultType;                   \
                                                                                \
     auto tres =                                                                \
-        tmp<GeometricField<productType, PatchField, GeoMesh>>::New             \
+        reuseTmpGeometricField<resultType, Type1, PatchField, GeoMesh>::New    \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                '(' + gf1.name() + #op + gf2.name() + ')',                     \
-                gf1.instance(),                                                \
-                gf1.db(),                                                      \
-                IOobject::NO_READ,                                             \
-                IOobject::NO_WRITE                                             \
-            ),                                                                 \
-            gf1.mesh(),                                                        \
-            gf1.dimensions() op gf2.dimensions()                               \
+            f1,                                                                \
+           '(' + f1.name() + #Op + f2.name() + ')',                            \
+            (f1.dimensions() Op f2.dimensions())                               \
         );                                                                     \
                                                                                \
-    Foam::opFunc(tres.ref(), gf1, gf2);                                        \
+    Foam::OpFunc(tres.ref(), f1, f2);                                          \
                                                                                \
     return tres;                                                               \
 }                                                                              \
@@ -633,28 +559,27 @@ tmp                                                                            \
 <                                                                              \
     GeometricField<typename product<Type1, Type2>::type, PatchField, GeoMesh>  \
 >                                                                              \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2                \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
+    typedef typename product<Type1, Type2>::type resultType;                   \
                                                                                \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2();            \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
-        reuseTmpGeometricField<productType, Type2, PatchField, GeoMesh>::New   \
+        reuseTmpGeometricField<resultType, Type2, PatchField, GeoMesh>::New    \
         (                                                                      \
-            tgf2,                                                              \
-            '(' + gf1.name() + #op + gf2.name() + ')',                         \
-            gf1.dimensions() op gf2.dimensions()                               \
+            tf2,                                                               \
+            '(' + f1.name() + #Op + f2.name() + ')',                           \
+            (f1.dimensions() Op f2.dimensions())                               \
         );                                                                     \
                                                                                \
-    Foam::opFunc(tres.ref(), gf1, gf2);                                        \
-                                                                               \
-    tgf2.clear();                                                              \
+    Foam::OpFunc(tres.ref(), f1, f2);                                          \
                                                                                \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -664,28 +589,27 @@ tmp                                                                            \
 <                                                                              \
     GeometricField<typename product<Type1, Type2>::type, PatchField, GeoMesh>  \
 >                                                                              \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1,               \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
+    typedef typename product<Type1, Type2>::type resultType;                   \
                                                                                \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1();            \
+    const auto& f1 = tf1();                                                    \
                                                                                \
     auto tres =                                                                \
-        reuseTmpGeometricField<productType, Type1, PatchField, GeoMesh>::New   \
+        reuseTmpGeometricField<resultType, Type1, PatchField, GeoMesh>::New    \
         (                                                                      \
-            tgf1,                                                              \
-            '(' + gf1.name() + #op + gf2.name() + ')',                         \
-            gf1.dimensions() op gf2.dimensions()                               \
+            tf1,                                                               \
+            '(' + f1.name() + #Op + f2.name() + ')',                           \
+            (f1.dimensions() Op f2.dimensions())                               \
         );                                                                     \
                                                                                \
-    Foam::opFunc(tres.ref(), gf1, gf2);                                        \
-                                                                               \
-    tgf1.clear();                                                              \
+    Foam::OpFunc(tres.ref(), f1, f2);                                          \
                                                                                \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -695,77 +619,69 @@ tmp                                                                            \
 <                                                                              \
     GeometricField<typename product<Type1, Type2>::type, PatchField, GeoMesh>  \
 >                                                                              \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1,               \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2                \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type1, Type2>::type productType;                  \
+    typedef typename product<Type1, Type2>::type resultType;                   \
                                                                                \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1();            \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2();            \
+    const auto& f1 = tf1();                                                    \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpTmpGeometricField                                              \
-        <productType, Type1, Type1, Type2, PatchField, GeoMesh>::New           \
+        <resultType, Type1, Type1, Type2, PatchField, GeoMesh>::New            \
         (                                                                      \
-            tgf1,                                                              \
-            tgf2,                                                              \
-            '(' + gf1.name() + #op + gf2.name() + ')',                         \
-            gf1.dimensions() op gf2.dimensions()                               \
+            tf1,                                                               \
+            tf2,                                                               \
+            '(' + f1.name() + #Op + f2.name() + ')',                           \
+            (f1.dimensions() Op f2.dimensions())                               \
         );                                                                     \
                                                                                \
-    Foam::opFunc(tres.ref(), gf1, gf2);                                        \
-                                                                               \
-    tgf1.clear();                                                              \
-    tgf2.clear();                                                              \
+    Foam::OpFunc(tres.ref(), f1, f2);                                          \
                                                                                \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
 template                                                                       \
 <class Form, class Type, template<class> class PatchField, class GeoMesh>      \
-void opFunc                                                                    \
+void OpFunc                                                                    \
 (                                                                              \
     GeometricField                                                             \
-    <typename product<Type, Form>::type, PatchField, GeoMesh>& gf,             \
-    const GeometricField<Type, PatchField, GeoMesh>& gf1,                      \
+    <typename product<Type, Form>::type, PatchField, GeoMesh>& result,         \
+    const GeometricField<Type, PatchField, GeoMesh>& f1,                       \
     const dimensioned<Form>& dvs                                               \
 )                                                                              \
 {                                                                              \
-    Foam::opFunc(gf.primitiveFieldRef(), gf1.primitiveField(), dvs.value());   \
-    Foam::opFunc(gf.boundaryFieldRef(), gf1.boundaryField(), dvs.value());     \
-    gf.oriented() = gf1.oriented();                                            \
+    Foam::OpFunc(result.primitiveFieldRef(), f1.primitiveField(), dvs.value());\
+    Foam::OpFunc(result.boundaryFieldRef(), f1.boundaryField(), dvs.value());  \
+    result.oriented() = f1.oriented();                                         \
 }                                                                              \
                                                                                \
 template                                                                       \
 <class Form, class Type, template<class> class PatchField, class GeoMesh>      \
 tmp<GeometricField<typename product<Type, Form>::type, PatchField, GeoMesh>>   \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const GeometricField<Type, PatchField, GeoMesh>& gf1,                      \
+    const GeometricField<Type, PatchField, GeoMesh>& f1,                       \
     const dimensioned<Form>& dvs                                               \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type, Form>::type productType;                    \
+    typedef typename product<Type, Form>::type resultType;                     \
                                                                                \
     auto tres =                                                                \
-        tmp<GeometricField<productType, PatchField, GeoMesh>>::New             \
+        reuseTmpGeometricField<resultType, Type, PatchField, GeoMesh>::New     \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                '(' + gf1.name() + #op + dvs.name() + ')',                     \
-                gf1.instance(),                                                \
-                gf1.db(),                                                      \
-                IOobject::NO_READ,                                             \
-                IOobject::NO_WRITE                                             \
-            ),                                                                 \
-            gf1.mesh(),                                                        \
-            gf1.dimensions() op dvs.dimensions()                               \
+            f1,                                                                \
+            '(' + f1.name() + #Op + dvs.name() + ')',                          \
+            (f1.dimensions() Op dvs.dimensions())                              \
         );                                                                     \
                                                                                \
-    Foam::opFunc(tres.ref(), gf1, dvs);                                        \
+    Foam::OpFunc(tres.ref(), f1, dvs);                                         \
                                                                                \
     return tres;                                                               \
 }                                                                              \
@@ -779,41 +695,40 @@ template                                                                       \
     class GeoMesh                                                              \
 >                                                                              \
 tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>>   \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const GeometricField<Type, PatchField, GeoMesh>& gf1,                      \
+    const GeometricField<Type, PatchField, GeoMesh>& f1,                       \
     const VectorSpace<Form,Cmpt,nCmpt>& vs                                     \
 )                                                                              \
 {                                                                              \
-    return gf1 op dimensioned<Form>(static_cast<const Form&>(vs));             \
+    return f1 Op dimensioned<Form>(static_cast<const Form&>(vs));              \
 }                                                                              \
                                                                                \
                                                                                \
 template                                                                       \
 <class Form, class Type, template<class> class PatchField, class GeoMesh>      \
 tmp<GeometricField<typename product<Type, Form>::type, PatchField, GeoMesh>>   \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1,                \
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1,                 \
     const dimensioned<Form>& dvs                                               \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Type, Form>::type productType;                    \
+    typedef typename product<Type, Form>::type resultType;                     \
                                                                                \
-    const GeometricField<Type, PatchField, GeoMesh>& gf1 = tgf1();             \
+    const auto& f1 = tf1();                                                    \
                                                                                \
     auto tres =                                                                \
-        reuseTmpGeometricField<productType, Type, PatchField, GeoMesh>::New    \
+        reuseTmpGeometricField<resultType, Type, PatchField, GeoMesh>::New     \
         (                                                                      \
-            tgf1,                                                              \
-            '(' + gf1.name() + #op + dvs.name() + ')',                         \
-            gf1.dimensions() op dvs.dimensions()                               \
+            tf1,                                                               \
+            '(' + f1.name() + #Op + dvs.name() + ')',                          \
+            (f1.dimensions() Op dvs.dimensions())                              \
         );                                                                     \
                                                                                \
-    Foam::opFunc(tres.ref(), gf1, dvs);                                        \
-                                                                               \
-    tgf1.clear();                                                              \
+    Foam::OpFunc(tres.ref(), f1, dvs);                                         \
                                                                                \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -826,58 +741,51 @@ template                                                                       \
     class GeoMesh                                                              \
 >                                                                              \
 tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>>   \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1,                \
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1,                 \
     const VectorSpace<Form,Cmpt,nCmpt>& vs                                     \
 )                                                                              \
 {                                                                              \
-    return tgf1 op dimensioned<Form>(static_cast<const Form&>(vs));            \
+    return tf1 Op dimensioned<Form>(static_cast<const Form&>(vs));             \
 }                                                                              \
                                                                                \
                                                                                \
 template                                                                       \
 <class Form, class Type, template<class> class PatchField, class GeoMesh>      \
-void opFunc                                                                    \
+void OpFunc                                                                    \
 (                                                                              \
     GeometricField                                                             \
-    <typename product<Form, Type>::type, PatchField, GeoMesh>& gf,             \
+    <typename product<Form, Type>::type, PatchField, GeoMesh>& result,         \
     const dimensioned<Form>& dvs,                                              \
-    const GeometricField<Type, PatchField, GeoMesh>& gf1                       \
+    const GeometricField<Type, PatchField, GeoMesh>& f2                        \
 )                                                                              \
 {                                                                              \
-    Foam::opFunc(gf.primitiveFieldRef(), dvs.value(), gf1.primitiveField());   \
-    Foam::opFunc(gf.boundaryFieldRef(), dvs.value(), gf1.boundaryField());     \
-    gf.oriented() = gf1.oriented();                                            \
+    Foam::OpFunc(result.primitiveFieldRef(), dvs.value(), f2.primitiveField());\
+    Foam::OpFunc(result.boundaryFieldRef(), dvs.value(), f2.boundaryField());  \
+    result.oriented() = f2.oriented();                                         \
 }                                                                              \
                                                                                \
 template                                                                       \
 <class Form, class Type, template<class> class PatchField, class GeoMesh>      \
 tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>>   \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const dimensioned<Form>& dvs,                                              \
-    const GeometricField<Type, PatchField, GeoMesh>& gf1                       \
+    const GeometricField<Type, PatchField, GeoMesh>& f2                        \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Form, Type>::type productType;                    \
+    typedef typename product<Form, Type>::type resultType;                     \
                                                                                \
     auto tres =                                                                \
-        tmp<GeometricField<productType, PatchField, GeoMesh>>::New             \
+        reuseTmpGeometricField<resultType, Type, PatchField, GeoMesh>::New     \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                '(' + dvs.name() + #op + gf1.name() + ')',                     \
-                gf1.instance(),                                                \
-                gf1.db(),                                                      \
-                IOobject::NO_READ,                                             \
-                IOobject::NO_WRITE                                             \
-            ),                                                                 \
-            gf1.mesh(),                                                        \
-            dvs.dimensions() op gf1.dimensions()                               \
+            f2,                                                                \
+            '(' + dvs.name() + #Op + f2.name() + ')',                          \
+            (dvs.dimensions() Op f2.dimensions())                              \
         );                                                                     \
                                                                                \
-    Foam::opFunc(tres.ref(), dvs, gf1);                                        \
+    Foam::OpFunc(tres.ref(), dvs, f2);                                         \
                                                                                \
     return tres;                                                               \
 }                                                                              \
@@ -891,40 +799,39 @@ template                                                                       \
     class GeoMesh                                                              \
 >                                                                              \
 tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>>   \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const VectorSpace<Form,Cmpt,nCmpt>& vs,                                    \
-    const GeometricField<Type, PatchField, GeoMesh>& gf1                       \
+    const GeometricField<Type, PatchField, GeoMesh>& f2                        \
 )                                                                              \
 {                                                                              \
-    return dimensioned<Form>(static_cast<const Form&>(vs)) op gf1;             \
+    return dimensioned<Form>(static_cast<const Form&>(vs)) Op f2;              \
 }                                                                              \
                                                                                \
 template                                                                       \
 <class Form, class Type, template<class> class PatchField, class GeoMesh>      \
 tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>>   \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const dimensioned<Form>& dvs,                                              \
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1                 \
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf2                  \
 )                                                                              \
 {                                                                              \
-    typedef typename product<Form, Type>::type productType;                    \
+    typedef typename product<Form, Type>::type resultType;                     \
                                                                                \
-    const GeometricField<Type, PatchField, GeoMesh>& gf1 = tgf1();             \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
-        reuseTmpGeometricField<productType, Type, PatchField, GeoMesh>::New    \
+        reuseTmpGeometricField<resultType, Type, PatchField, GeoMesh>::New     \
         (                                                                      \
-            tgf1,                                                              \
-            '(' + dvs.name() + #op + gf1.name() + ')',                         \
-            dvs.dimensions() op gf1.dimensions()                               \
+            tf2,                                                               \
+            '(' + dvs.name() + #Op + f2.name() + ')',                          \
+            (dvs.dimensions() Op f2.dimensions())                              \
         );                                                                     \
                                                                                \
-    Foam::opFunc(tres.ref(), dvs, gf1);                                        \
-                                                                               \
-    tgf1.clear();                                                              \
+    Foam::OpFunc(tres.ref(), dvs, f2);                                         \
                                                                                \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -937,15 +844,16 @@ template                                                                       \
     class GeoMesh                                                              \
 >                                                                              \
 tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>>   \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const VectorSpace<Form,Cmpt,nCmpt>& vs,                                    \
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1                 \
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf2                  \
 )                                                                              \
 {                                                                              \
-    return dimensioned<Form>(static_cast<const Form&>(vs)) op tgf1;            \
+    return dimensioned<Form>(static_cast<const Form&>(vs)) Op tf2;             \
 }
 
+
 PRODUCT_OPERATOR(typeOfSum, +, add)
 PRODUCT_OPERATOR(typeOfSum, -, subtract)
 
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.H b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.H
index 1f65866247..9b91dc3c07 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.H
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2019 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -37,7 +37,7 @@ License
 namespace Foam
 {
 
-// * * * * * * * * * * * * * * * Global functions  * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
 
 template<class Type, template<class> class PatchField, class GeoMesh>
 void component
@@ -47,16 +47,16 @@ void component
         typename GeometricField<Type, PatchField, GeoMesh>::cmptType,
         PatchField,
         GeoMesh
-    >& gcf,
-    const GeometricField<Type, PatchField, GeoMesh>& gf,
+    >& result,
+    const GeometricField<Type, PatchField, GeoMesh>& f1,
     const direction d
 );
 
 template<class Type, template<class> class PatchField, class GeoMesh>
 void T
 (
-     GeometricField<Type, PatchField, GeoMesh>& gf,
-     const GeometricField<Type, PatchField, GeoMesh>& gf1
+     GeometricField<Type, PatchField, GeoMesh>& result,
+     const GeometricField<Type, PatchField, GeoMesh>& f1
 );
 
 template
@@ -68,8 +68,9 @@ template
 >
 void pow
 (
-    GeometricField<typename powProduct<Type, r>::type, PatchField, GeoMesh>& gf,
-    const GeometricField<Type, PatchField, GeoMesh>& gf1
+    GeometricField
+    <typename powProduct<Type, r>::type, PatchField, GeoMesh>& result,
+    const GeometricField<Type, PatchField, GeoMesh>& f1
 );
 
 template
@@ -86,7 +87,7 @@ tmp
 >
 pow
 (
-    const GeometricField<Type, PatchField, GeoMesh>& gf,
+    const GeometricField<Type, PatchField, GeoMesh>& f1,
     typename powProduct<Type, r>::type
 );
 
@@ -104,7 +105,7 @@ tmp
 >
 pow
 (
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf,
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1,
     typename powProduct<Type, r>::type
 );
 
@@ -112,7 +113,7 @@ template<class Type, template<class> class PatchField, class GeoMesh>
 void sqr
 (
     GeometricField
-    <typename outerProduct<Type, Type>::type, PatchField, GeoMesh>& gf,
+    <typename outerProduct<Type, Type>::type, PatchField, GeoMesh>& f1,
     const GeometricField<Type, PatchField, GeoMesh>& gf1
 );
 
@@ -126,7 +127,7 @@ tmp
         GeoMesh
     >
 >
-sqr(const GeometricField<Type, PatchField, GeoMesh>& gf);
+sqr(const GeometricField<Type, PatchField, GeoMesh>& f1);
 
 template<class Type, template<class> class PatchField, class GeoMesh>
 tmp
@@ -138,48 +139,48 @@ tmp
         GeoMesh
     >
 >
-sqr(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf);
+sqr(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1);
 
 template<class Type, template<class> class PatchField, class GeoMesh>
 void magSqr
 (
-    GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>& gsf,
-    const GeometricField<Type, PatchField, GeoMesh>& gf
+    GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>& result,
+    const GeometricField<Type, PatchField, GeoMesh>& f1
 );
 
 template<class Type, template<class> class PatchField, class GeoMesh>
 tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>>
 magSqr
 (
-    const GeometricField<Type, PatchField, GeoMesh>& gf
+    const GeometricField<Type, PatchField, GeoMesh>& f1
 );
 
 template<class Type, template<class> class PatchField, class GeoMesh>
 tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>>
 magSqr
 (
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1
 );
 
 template<class Type, template<class> class PatchField, class GeoMesh>
 void mag
 (
-    GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>& gsf,
-    const GeometricField<Type, PatchField, GeoMesh>& gf
+    GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>& result,
+    const GeometricField<Type, PatchField, GeoMesh>& tf1
 );
 
 template<class Type, template<class> class PatchField, class GeoMesh>
 tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>>
 mag
 (
-    const GeometricField<Type, PatchField, GeoMesh>& gf
+    const GeometricField<Type, PatchField, GeoMesh>& f1
 );
 
 template<class Type, template<class> class PatchField, class GeoMesh>
 tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>>
 mag
 (
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1
 );
 
 template<class Type, template<class> class PatchField, class GeoMesh>
@@ -190,8 +191,8 @@ void cmptAv
         typename GeometricField<Type, PatchField, GeoMesh>::cmptType,
         PatchField,
         GeoMesh
-    >& gcf,
-    const GeometricField<Type, PatchField, GeoMesh>& gf
+    >& result,
+    const GeometricField<Type, PatchField, GeoMesh>& f1
 );
 
 template<class Type, template<class> class PatchField, class GeoMesh>
@@ -204,7 +205,7 @@ tmp
         GeoMesh
     >
 >
-cmptAv(const GeometricField<Type, PatchField, GeoMesh>& gf);
+cmptAv(const GeometricField<Type, PatchField, GeoMesh>& f1);
 
 template<class Type, template<class> class PatchField, class GeoMesh>
 tmp
@@ -216,21 +217,21 @@ tmp
         GeoMesh
     >
 >
-cmptAv(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf);
+cmptAv(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1);
 
 
-#define UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(returnType, func, binaryOp)     \
+#define UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(ReturnType, Func, BinaryOp)     \
                                                                                \
 template<class Type, template<class> class PatchField, class GeoMesh>          \
-dimensioned<returnType> func                                                   \
+dimensioned<ReturnType> Func                                                   \
 (                                                                              \
-    const GeometricField<Type, PatchField, GeoMesh>& gf                        \
+    const GeometricField<Type, PatchField, GeoMesh>& f1                        \
 );                                                                             \
                                                                                \
 template<class Type, template<class> class PatchField, class GeoMesh>          \
-dimensioned<returnType> func                                                   \
+dimensioned<ReturnType> Func                                                   \
 (                                                                              \
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1                 \
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1                  \
 );
 
 UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(Type, max, maxOp)
@@ -241,18 +242,18 @@ UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(scalarMinMax, minMaxMag, minMaxMagOp)
 #undef UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY
 
 
-#define UNARY_REDUCTION_FUNCTION(returnType, func, gFunc)                      \
+#define UNARY_REDUCTION_FUNCTION(ReturnType, Func, gFunc)                      \
                                                                                \
 template<class Type, template<class> class PatchField, class GeoMesh>          \
-dimensioned<returnType> func                                                   \
+dimensioned<ReturnType> Func                                                   \
 (                                                                              \
-    const GeometricField<Type, PatchField, GeoMesh>& gf                        \
+    const GeometricField<Type, PatchField, GeoMesh>& f1                        \
 );                                                                             \
                                                                                \
 template<class Type, template<class> class PatchField, class GeoMesh>          \
-dimensioned<returnType> func                                                   \
+dimensioned<ReturnType> Func                                                   \
 (                                                                              \
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1                 \
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1                  \
 );
 
 UNARY_REDUCTION_FUNCTION(Type, sum, gSum)
@@ -273,7 +274,7 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
 
 
-// * * * * * * * * * * * * * * * Global operators  * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 
 UNARY_OPERATOR(Type, Type, -, negate, transform)
 
@@ -289,16 +290,16 @@ BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, '|', divide)
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define PRODUCT_OPERATOR(product, op, opFunc)                                  \
+#define PRODUCT_OPERATOR(product, Op, OpFunc)                                  \
                                                                                \
 template                                                                       \
 <class Type1, class Type2, template<class> class PatchField, class GeoMesh>    \
-void opFunc                                                                    \
+void OpFunc                                                                    \
 (                                                                              \
     GeometricField                                                             \
-    <typename product<Type1, Type2>::type, PatchField, GeoMesh>& gf,           \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    <typename product<Type1, Type2>::type, PatchField, GeoMesh>& result,       \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 );                                                                             \
                                                                                \
 template                                                                       \
@@ -308,10 +309,10 @@ tmp                                                                            \
     GeometricField                                                             \
         <typename product<Type1, Type2>::type, PatchField, GeoMesh>            \
 >                                                                              \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 );                                                                             \
                                                                                \
 template                                                                       \
@@ -321,10 +322,10 @@ tmp                                                                            \
     GeometricField                                                             \
     <typename product<Type1, Type2>::type, PatchField, GeoMesh>                \
 >                                                                              \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2                \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 );                                                                             \
                                                                                \
 template                                                                       \
@@ -334,10 +335,10 @@ tmp                                                                            \
     GeometricField                                                             \
     <typename product<Type1, Type2>::type, PatchField, GeoMesh>                \
 >                                                                              \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1,               \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 );                                                                             \
                                                                                \
 template                                                                       \
@@ -347,19 +348,19 @@ tmp                                                                            \
     GeometricField                                                             \
     <typename product<Type1, Type2>::type, PatchField, GeoMesh>                \
 >                                                                              \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1,               \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2                \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 );                                                                             \
                                                                                \
 template                                                                       \
 <class Form, class Type, template<class> class PatchField, class GeoMesh>      \
-void opFunc                                                                    \
+void OpFunc                                                                    \
 (                                                                              \
     GeometricField                                                             \
-    <typename product<Type, Form>::type, PatchField, GeoMesh>& gf,             \
-    const GeometricField<Type, PatchField, GeoMesh>& gf1,                      \
+    <typename product<Type, Form>::type, PatchField, GeoMesh>& result,         \
+    const GeometricField<Type, PatchField, GeoMesh>& f1,                       \
     const dimensioned<Form>& dvs                                               \
 );                                                                             \
                                                                                \
@@ -370,9 +371,9 @@ tmp                                                                            \
     GeometricField                                                             \
     <typename product<Type, Form>::type, PatchField, GeoMesh>                  \
 >                                                                              \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const GeometricField<Type, PatchField, GeoMesh>& gf1,                      \
+    const GeometricField<Type, PatchField, GeoMesh>& f1,                       \
     const dimensioned<Form>& dvs                                               \
 );                                                                             \
                                                                                \
@@ -389,9 +390,9 @@ tmp                                                                            \
     GeometricField                                                             \
     <typename product<Form, Type>::type, PatchField, GeoMesh>                  \
 >                                                                              \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const GeometricField<Type, PatchField, GeoMesh>& gf1,                      \
+    const GeometricField<Type, PatchField, GeoMesh>& f1,                       \
     const VectorSpace<Form,Cmpt,nCmpt>& vs                                     \
 );                                                                             \
                                                                                \
@@ -402,9 +403,9 @@ tmp                                                                            \
     GeometricField                                                             \
     <typename product<Type, Form>::type, PatchField, GeoMesh>                  \
 >                                                                              \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1,                \
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1,                 \
     const dimensioned<Form>& dvs                                               \
 );                                                                             \
                                                                                \
@@ -421,20 +422,20 @@ tmp                                                                            \
     GeometricField                                                             \
     <typename product<Form, Type>::type, PatchField, GeoMesh>                  \
 >                                                                              \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1,                \
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1,                 \
     const VectorSpace<Form,Cmpt,nCmpt>& vs                                     \
 );                                                                             \
                                                                                \
 template                                                                       \
 <class Form, class Type, template<class> class PatchField, class GeoMesh>      \
-void opFunc                                                                    \
+void OpFunc                                                                    \
 (                                                                              \
     GeometricField                                                             \
-    <typename product<Form, Type>::type, PatchField, GeoMesh>& gf,             \
+    <typename product<Form, Type>::type, PatchField, GeoMesh>& result,         \
     const dimensioned<Form>& dvs,                                              \
-    const GeometricField<Type, PatchField, GeoMesh>& gf1                       \
+    const GeometricField<Type, PatchField, GeoMesh>& f2                        \
 );                                                                             \
                                                                                \
 template                                                                       \
@@ -444,10 +445,10 @@ tmp                                                                            \
     GeometricField                                                             \
     <typename product<Form, Type>::type, PatchField, GeoMesh>                  \
 >                                                                              \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const dimensioned<Form>& dvs,                                              \
-    const GeometricField<Type, PatchField, GeoMesh>& gf1                       \
+    const GeometricField<Type, PatchField, GeoMesh>& f2                        \
 );                                                                             \
                                                                                \
 template                                                                       \
@@ -463,10 +464,10 @@ tmp                                                                            \
     GeometricField                                                             \
     <typename product<Form, Type>::type, PatchField, GeoMesh>                  \
 >                                                                              \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const VectorSpace<Form,Cmpt,nCmpt>& vs,                                    \
-    const GeometricField<Type, PatchField, GeoMesh>& gf1                       \
+    const GeometricField<Type, PatchField, GeoMesh>& f2                        \
 );                                                                             \
                                                                                \
 template                                                                       \
@@ -476,10 +477,10 @@ tmp                                                                            \
     GeometricField                                                             \
     <typename product<Form, Type>::type, PatchField, GeoMesh>                  \
 >                                                                              \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const dimensioned<Form>& dvs,                                              \
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1                 \
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf2                  \
 );                                                                             \
                                                                                \
 template                                                                       \
@@ -495,10 +496,10 @@ tmp                                                                            \
     GeometricField                                                             \
     <typename product<Form, Type>::type, PatchField, GeoMesh>                  \
 >                                                                              \
-operator op                                                                    \
+operator Op                                                                    \
 (                                                                              \
     const VectorSpace<Form,Cmpt,nCmpt>& vs,                                    \
-    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1                 \
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf2                  \
 );
 
 PRODUCT_OPERATOR(typeOfSum, +, add)
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.C b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.C
index 31d79a638d..97b916586a 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.C
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -40,39 +40,31 @@ namespace Foam
 TEMPLATE                                                                       \
 void Func                                                                      \
 (                                                                              \
-    GeometricField<ReturnType, PatchField, GeoMesh>& res,                      \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1                      \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1                       \
 )                                                                              \
 {                                                                              \
-    Foam::Func(res.primitiveFieldRef(), gf1.primitiveField());                 \
-    Foam::Func(res.boundaryFieldRef(), gf1.boundaryField());                   \
-    res.oriented() = gf1.oriented();                                           \
+    Foam::Func(result.primitiveFieldRef(), f1.primitiveField());               \
+    Foam::Func(result.boundaryFieldRef(), f1.boundaryField());                 \
+    result.oriented() = f1.oriented();                                         \
 }                                                                              \
                                                                                \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1                      \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1                       \
 )                                                                              \
 {                                                                              \
     auto tres =                                                                \
-        tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New              \
+        reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New    \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                #Func "(" + gf1.name() + ')',                                  \
-                gf1.instance(),                                                \
-                gf1.db(),                                                      \
-                IOobject::NO_READ,                                             \
-                IOobject::NO_WRITE                                             \
-            ),                                                                 \
-            gf1.mesh(),                                                        \
-            Dfunc(gf1.dimensions())                                            \
+            f1,                                                                \
+            #Func "(" + f1.name() + ')',                                       \
+            Dfunc(f1.dimensions())                                             \
         );                                                                     \
                                                                                \
-    Foam::Func(tres.ref(), gf1);                                               \
-                                                                               \
+    Foam::Func(tres.ref(), f1);                                                \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -80,23 +72,21 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1                \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1                 \
 )                                                                              \
 {                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1();            \
+    const auto& f1 = tf1();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New    \
         (                                                                      \
-            tgf1,                                                              \
-            #Func "(" + gf1.name() + ')',                                      \
-            Dfunc(gf1.dimensions())                                            \
-       );                                                                      \
-                                                                               \
-    Foam::Func(tres.ref(), gf1);                                               \
-                                                                               \
-    tgf1.clear();                                                              \
+            tf1,                                                               \
+            #Func "(" + f1.name() + ')',                                       \
+            Dfunc(f1.dimensions())                                             \
+        );                                                                     \
                                                                                \
+    Foam::Func(tres.ref(), f1);                                                \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }
 
@@ -108,38 +98,31 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    GeometricField<ReturnType, PatchField, GeoMesh>& res,                      \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1                      \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1                       \
 )                                                                              \
 {                                                                              \
-    Foam::OpFunc(res.primitiveFieldRef(), gf1.primitiveField());               \
-    Foam::OpFunc(res.boundaryFieldRef(), gf1.boundaryField());                 \
-    res.oriented() = gf1.oriented();                                           \
+    Foam::OpFunc(result.primitiveFieldRef(), f1.primitiveField());             \
+    Foam::OpFunc(result.boundaryFieldRef(), f1.boundaryField());               \
+    result.oriented() = f1.oriented();                                         \
 }                                                                              \
                                                                                \
+                                                                               \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1                      \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1                       \
 )                                                                              \
 {                                                                              \
     auto tres =                                                                \
-        tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New              \
+        reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New    \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                #Op + gf1.name(),                                              \
-                gf1.instance(),                                                \
-                gf1.db(),                                                      \
-                IOobject::NO_READ,                                             \
-                IOobject::NO_WRITE                                             \
-            ),                                                                 \
-            gf1.mesh(),                                                        \
-            Dfunc(gf1.dimensions())                                            \
+            f1,                                                                \
+            #Op + f1.name(),                                                   \
+            Dfunc(f1.dimensions())                                             \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref(), gf1);                                             \
-                                                                               \
+    Foam::OpFunc(tres.ref(), f1);                                              \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -147,23 +130,21 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1                \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1                 \
 )                                                                              \
 {                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1();            \
+    const auto& f1 = tf1();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New    \
         (                                                                      \
-            tgf1,                                                              \
-            #Op + gf1.name(),                                                  \
-            Dfunc(gf1.dimensions())                                            \
+            tf1,                                                               \
+            #Op + f1.name(),                                                   \
+            Dfunc(f1.dimensions())                                             \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref(), gf1);                                             \
-                                                                               \
-    tgf1.clear();                                                              \
-                                                                               \
+    Foam::OpFunc(tres.ref(), f1);                                              \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }
 
@@ -175,51 +156,43 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 TEMPLATE                                                                       \
 void Func                                                                      \
 (                                                                              \
-    GeometricField<ReturnType, PatchField, GeoMesh>& res,                      \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 )                                                                              \
 {                                                                              \
     Foam::Func                                                                 \
     (                                                                          \
-        res.primitiveFieldRef(),                                               \
-        gf1.primitiveField(),                                                  \
-        gf2.primitiveField()                                                   \
+        result.primitiveFieldRef(),                                            \
+        f1.primitiveField(),                                                   \
+        f2.primitiveField()                                                    \
     );                                                                         \
     Foam::Func                                                                 \
     (                                                                          \
-        res.boundaryFieldRef(),                                                \
-        gf1.boundaryField(),                                                   \
-        gf2.boundaryField()                                                    \
+        result.boundaryFieldRef(),                                             \
+        f1.boundaryField(),                                                    \
+        f2.boundaryField()                                                     \
     );                                                                         \
-    res.oriented() = Func(gf1.oriented(), gf2.oriented());                     \
+    result.oriented() = Func(f1.oriented(), f2.oriented());                    \
 }                                                                              \
                                                                                \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 )                                                                              \
 {                                                                              \
     auto tres =                                                                \
-        tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New              \
+        reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New    \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                #Func "(" + gf1.name() + ',' + gf2.name() + ')',               \
-                gf1.instance(),                                                \
-                gf1.db(),                                                      \
-                IOobject::NO_READ,                                             \
-                IOobject::NO_WRITE                                             \
-            ),                                                                 \
-            gf1.mesh(),                                                        \
-            Func(gf1.dimensions(), gf2.dimensions())                           \
+            f1,                                                                \
+            #Func "(" + f1.name() + ',' + f2.name() + ')',                     \
+            Func(f1.dimensions(), f2.dimensions())                             \
         );                                                                     \
                                                                                \
-    Foam::Func(tres.ref(), gf1, gf2);                                          \
-                                                                               \
+    Foam::Func(tres.ref(), f1, f2);                                            \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -227,24 +200,22 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2                \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 )                                                                              \
 {                                                                              \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2();            \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New    \
         (                                                                      \
-            tgf2,                                                              \
-            #Func "(" + gf1.name() + ',' + gf2.name() + ')',                   \
-            Func(gf1.dimensions(), gf2.dimensions())                           \
+            tf2,                                                               \
+            #Func "(" + f1.name() + ',' + f2.name() + ')',                     \
+            Func(f1.dimensions(), f2.dimensions())                             \
         );                                                                     \
                                                                                \
-    Foam::Func(tres.ref(), gf1, gf2);                                          \
-                                                                               \
-    tgf2.clear();                                                              \
-                                                                               \
+    Foam::Func(tres.ref(), f1, f2);                                            \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -252,24 +223,22 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1,               \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 )                                                                              \
 {                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1();            \
+    const auto& f1 = tf1();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New    \
         (                                                                      \
-            tgf1,                                                              \
-            #Func "(" + gf1.name() + ',' + gf2.name() + ')',                   \
-            Func(gf1.dimensions(), gf2.dimensions())                           \
+            tf1,                                                               \
+            #Func "(" + f1.name() + ',' + f2.name() + ')',                     \
+            Func(f1.dimensions(), f2.dimensions())                             \
         );                                                                     \
                                                                                \
-    Foam::Func(tres.ref(), gf1, gf2);                                          \
-                                                                               \
-    tgf1.clear();                                                              \
-                                                                               \
+    Foam::Func(tres.ref(), f1, f2);                                            \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -277,29 +246,27 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1,               \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2                \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 )                                                                              \
 {                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1();            \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2();            \
+    const auto& f1 = tf1();                                                    \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpTmpGeometricField                                              \
             <ReturnType, Type1, Type1, Type2, PatchField, GeoMesh>             \
         ::New                                                                  \
         (                                                                      \
-            tgf1,                                                              \
-            tgf2,                                                              \
-            #Func "(" + gf1.name() + ',' + gf2.name() + ')',                   \
-            Func(gf1.dimensions(), gf2.dimensions())                           \
+            tf1,                                                               \
+            tf2,                                                               \
+            #Func "(" + f1.name() + ',' + f2.name() + ')',                     \
+            Func(f1.dimensions(), f2.dimensions())                             \
         );                                                                     \
                                                                                \
-    Foam::Func(tres.ref(), gf1, gf2);                                          \
-                                                                               \
-    tgf1.clear();                                                              \
-    tgf2.clear();                                                              \
-                                                                               \
+    Foam::Func(tres.ref(), f1, f2);                                            \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }
 
@@ -311,14 +278,14 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 TEMPLATE                                                                       \
 void Func                                                                      \
 (                                                                              \
-    GeometricField<ReturnType, PatchField, GeoMesh>& res,                      \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
     const dimensioned<Type1>& dt1,                                             \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 )                                                                              \
 {                                                                              \
-    Foam::Func(res.primitiveFieldRef(), dt1.value(), gf2.primitiveField());    \
-    Foam::Func(res.boundaryFieldRef(), dt1.value(), gf2.boundaryField());      \
-    res.oriented() = gf2.oriented();                                           \
+    Foam::Func(result.primitiveFieldRef(), dt1.value(), f2.primitiveField());  \
+    Foam::Func(result.boundaryFieldRef(), dt1.value(), f2.boundaryField());    \
+    result.oriented() = f2.oriented();                                         \
 }                                                                              \
                                                                                \
                                                                                \
@@ -326,26 +293,18 @@ TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
     const dimensioned<Type1>& dt1,                                             \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 )                                                                              \
 {                                                                              \
     auto tres =                                                                \
-        tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New              \
+        reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New    \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                #Func "(" + dt1.name() + ',' + gf2.name() + ')',               \
-                gf2.instance(),                                                \
-                gf2.db(),                                                      \
-                IOobject::NO_READ,                                             \
-                IOobject::NO_WRITE                                             \
-            ),                                                                 \
-            gf2.mesh(),                                                        \
-            Func(dt1.dimensions(), gf2.dimensions())                           \
+            f2,                                                                \
+            #Func "(" + dt1.name() + ',' + f2.name() + ')',                    \
+            Func(dt1.dimensions(), f2.dimensions())                            \
         );                                                                     \
                                                                                \
-    Foam::Func(tres.ref(), dt1, gf2);                                          \
-                                                                               \
+    Foam::Func(tres.ref(), dt1, f2);                                           \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -353,11 +312,11 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const Type1& t1,                                                           \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    const Type1& s1,                                                           \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 )                                                                              \
 {                                                                              \
-    return Func(dimensioned<Type1>(t1), gf2);                                  \
+    return Func(dimensioned<Type1>(s1), f2);                                   \
 }                                                                              \
                                                                                \
                                                                                \
@@ -365,23 +324,21 @@ TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
     const dimensioned<Type1>& dt1,                                             \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2                \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 )                                                                              \
 {                                                                              \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2();            \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New    \
         (                                                                      \
-            tgf2,                                                              \
-            #Func "(" + dt1.name() + gf2.name() + ',' + ')',                   \
-            Func(dt1.dimensions(), gf2.dimensions())                           \
+            tf2,                                                               \
+            #Func "(" + dt1.name() + ',' + f2.name() + ')',                    \
+            Func(dt1.dimensions(), f2.dimensions())                            \
         );                                                                     \
                                                                                \
-    Foam::Func(tres.ref(), dt1, gf2);                                          \
-                                                                               \
-    tgf2.clear();                                                              \
-                                                                               \
+    Foam::Func(tres.ref(), dt1, f2);                                           \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -389,11 +346,11 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const Type1& t1,                                                           \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2                \
+    const Type1& s1,                                                           \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 )                                                                              \
 {                                                                              \
-    return Func(dimensioned<Type1>(t1), tgf2);                                 \
+    return Func(dimensioned<Type1>(s1), tf2);                                  \
 }
 
 
@@ -402,41 +359,33 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 TEMPLATE                                                                       \
 void Func                                                                      \
 (                                                                              \
-    GeometricField<ReturnType, PatchField, GeoMesh>& res,                      \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
     const dimensioned<Type2>& dt2                                              \
 )                                                                              \
 {                                                                              \
-    Foam::Func(res.primitiveFieldRef(), gf1.primitiveField(), dt2.value());    \
-    Foam::Func(res.boundaryFieldRef(), gf1.boundaryField(), dt2.value());      \
-    res.oriented() = gf1.oriented();                                           \
+    Foam::Func(result.primitiveFieldRef(), f1.primitiveField(), dt2.value());  \
+    Foam::Func(result.boundaryFieldRef(), f1.boundaryField(), dt2.value());    \
+    result.oriented() = f1.oriented();                                         \
 }                                                                              \
                                                                                \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
     const dimensioned<Type2>& dt2                                              \
 )                                                                              \
 {                                                                              \
     auto tres =                                                                \
-        tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New              \
+        reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New    \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                #Func "(" + gf1.name() + ',' + dt2.name() + ')',               \
-                gf1.instance(),                                                \
-                gf1.db(),                                                      \
-                IOobject::NO_READ,                                             \
-                IOobject::NO_WRITE                                             \
-            ),                                                                 \
-            gf1.mesh(),                                                        \
-            Func(gf1.dimensions(), dt2.dimensions())                           \
+            f1,                                                                \
+            #Func "(" + f1.name() + ',' + dt2.name() + ')',                    \
+            Func(f1.dimensions(), dt2.dimensions())                            \
         );                                                                     \
                                                                                \
-    Foam::Func(tres.ref(), gf1, dt2);                                          \
-                                                                               \
+    Foam::Func(tres.ref(), f1, dt2);                                           \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -444,35 +393,33 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
-    const Type2& t2                                                            \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    return Func(gf1, dimensioned<Type2>(t2));                                  \
+    return Func(f1, dimensioned<Type2>(s2));                                   \
 }                                                                              \
                                                                                \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1,               \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
     const dimensioned<Type2>& dt2                                              \
 )                                                                              \
 {                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1();            \
+    const auto& f1 = tf1();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New    \
         (                                                                      \
-            tgf1,                                                              \
-            #Func "(" + gf1.name() + ',' + dt2.name() + ')',                   \
-            Func(gf1.dimensions(), dt2.dimensions())                           \
+            tf1,                                                               \
+            #Func "(" + f1.name() + ',' + dt2.name() + ')',                    \
+            Func(f1.dimensions(), dt2.dimensions())                            \
         );                                                                     \
                                                                                \
-    Foam::Func(tres.ref(), gf1, dt2);                                          \
-                                                                               \
-    tgf1.clear();                                                              \
-                                                                               \
+    Foam::Func(tres.ref(), f1, dt2);                                           \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -480,11 +427,11 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1,               \
-    const Type2& t2                                                            \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    return Func(tgf1, dimensioned<Type2>(t2));                                 \
+    return Func(tf1, dimensioned<Type2>(s2));                                  \
 }
 
 
@@ -500,43 +447,43 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    GeometricField<ReturnType, PatchField, GeoMesh>& res,                      \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 )                                                                              \
 {                                                                              \
     Foam::OpFunc                                                               \
-    (res.primitiveFieldRef(), gf1.primitiveField(), gf2.primitiveField());     \
+    (                                                                          \
+        result.primitiveFieldRef(),                                            \
+        f1.primitiveField(),                                                   \
+        f2.primitiveField()                                                    \
+    );                                                                         \
     Foam::OpFunc                                                               \
-    (res.boundaryFieldRef(), gf1.boundaryField(), gf2.boundaryField());        \
-    res.oriented() = gf1.oriented() Op gf2.oriented();                         \
+    (                                                                          \
+        result.boundaryFieldRef(),                                             \
+        f1.boundaryField(),                                                    \
+        f2.boundaryField()                                                     \
+    );                                                                         \
+    result.oriented() = (f1.oriented() Op f2.oriented());                      \
 }                                                                              \
                                                                                \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 )                                                                              \
 {                                                                              \
     auto tres =                                                                \
-        tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New              \
+        reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New    \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                '(' + gf1.name() + OpName + gf2.name() + ')',                  \
-                gf1.instance(),                                                \
-                gf1.db(),                                                      \
-                IOobject::NO_READ,                                             \
-                IOobject::NO_WRITE                                             \
-            ),                                                                 \
-            gf1.mesh(),                                                        \
-            gf1.dimensions() Op gf2.dimensions()                               \
+            f1,                                                                \
+            '(' + f1.name() + OpName + f2.name() + ')',                        \
+            (f1.dimensions() Op f2.dimensions())                               \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref(), gf1, gf2);                                        \
-                                                                               \
+    Foam::OpFunc(tres.ref(), f1, f2);                                          \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -544,24 +491,22 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2                \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 )                                                                              \
 {                                                                              \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2();            \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New    \
         (                                                                      \
-            tgf2,                                                              \
-            '(' + gf1.name() + OpName + gf2.name() + ')',                      \
-            gf1.dimensions() Op gf2.dimensions()                               \
+            tf2,                                                               \
+            '(' + f1.name() + OpName + f2.name() + ')',                        \
+            (f1.dimensions() Op f2.dimensions())                               \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref(), gf1, gf2);                                        \
-                                                                               \
-    tgf2.clear();                                                              \
-                                                                               \
+    Foam::OpFunc(tres.ref(), f1, f2);                                          \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -569,24 +514,22 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1,               \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 )                                                                              \
 {                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1();            \
+    const auto& f1 = tf1();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New    \
         (                                                                      \
-            tgf1,                                                              \
-            '(' + gf1.name() + OpName + gf2.name() + ')',                      \
-            gf1.dimensions() Op gf2.dimensions()                               \
+            tf1,                                                               \
+            '(' + f1.name() + OpName + f2.name() + ')',                        \
+            (f1.dimensions() Op f2.dimensions())                               \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref(), gf1, gf2);                                        \
-                                                                               \
-    tgf1.clear();                                                              \
-                                                                               \
+    Foam::OpFunc(tres.ref(), f1, f2);                                          \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -594,28 +537,26 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1,               \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2                \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 )                                                                              \
 {                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1();            \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2();            \
+    const auto& f1 = tf1();                                                    \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpTmpGeometricField                                              \
             <ReturnType, Type1, Type1, Type2, PatchField, GeoMesh>::New        \
         (                                                                      \
-            tgf1,                                                              \
-            tgf2,                                                              \
-            '(' + gf1.name() + OpName + gf2.name() + ')',                      \
-            gf1.dimensions() Op gf2.dimensions()                               \
+            tf1,                                                               \
+            tf2,                                                               \
+            '(' + f1.name() + OpName + f2.name() + ')',                        \
+            (f1.dimensions() Op f2.dimensions())                               \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref(), gf1, gf2);                                        \
-                                                                               \
-    tgf1.clear();                                                              \
-    tgf2.clear();                                                              \
-                                                                               \
+    Foam::OpFunc(tres.ref(), f1, f2);                                          \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }
 
@@ -627,14 +568,14 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    GeometricField<ReturnType, PatchField, GeoMesh>& res,                      \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
     const dimensioned<Type1>& dt1,                                             \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 )                                                                              \
 {                                                                              \
-    Foam::OpFunc(res.primitiveFieldRef(), dt1.value(), gf2.primitiveField());  \
-    Foam::OpFunc(res.boundaryFieldRef(), dt1.value(), gf2.boundaryField());    \
-    res.oriented() = gf2.oriented();                                           \
+    Foam::OpFunc(result.primitiveFieldRef(), dt1.value(), f2.primitiveField());\
+    Foam::OpFunc(result.boundaryFieldRef(), dt1.value(), f2.boundaryField());  \
+    result.oriented() = f2.oriented();                                         \
                                                                                \
 }                                                                              \
                                                                                \
@@ -642,26 +583,18 @@ TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
     const dimensioned<Type1>& dt1,                                             \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 )                                                                              \
 {                                                                              \
     auto tres =                                                                \
-        tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New              \
+        reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New    \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                '(' + dt1.name() + OpName + gf2.name() + ')',                  \
-                gf2.instance(),                                                \
-                gf2.db(),                                                      \
-                IOobject::NO_READ,                                             \
-                IOobject::NO_WRITE                                             \
-            ),                                                                 \
-            gf2.mesh(),                                                        \
-            dt1.dimensions() Op gf2.dimensions()                               \
+            f2,                                                                \
+            '(' + dt1.name() + OpName + f2.name() + ')',                       \
+            (dt1.dimensions() Op f2.dimensions())                              \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref(), dt1, gf2);                                        \
-                                                                               \
+    Foam::OpFunc(tres.ref(), dt1, f2);                                         \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -670,10 +603,10 @@ TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
     const Type1& t1,                                                           \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 )                                                                              \
 {                                                                              \
-    return dimensioned<Type1>(t1) Op gf2;                                      \
+    return dimensioned<Type1>(t1) Op f2;                                       \
 }                                                                              \
                                                                                \
                                                                                \
@@ -681,23 +614,21 @@ TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
     const dimensioned<Type1>& dt1,                                             \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2                \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 )                                                                              \
 {                                                                              \
-    const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2();            \
+    const auto& f2 = tf2();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New    \
         (                                                                      \
-            tgf2,                                                              \
-            '(' + dt1.name() + OpName + gf2.name() + ')',                      \
-            dt1.dimensions() Op gf2.dimensions()                               \
-        ) ;                                                                    \
-                                                                               \
-    Foam::OpFunc(tres.ref(), dt1, gf2);                                        \
-                                                                               \
-    tgf2.clear();                                                              \
+            tf2,                                                               \
+            '(' + dt1.name() + OpName + f2.name() + ')',                       \
+            (dt1.dimensions() Op f2.dimensions())                              \
+        );                                                                     \
                                                                                \
+    Foam::OpFunc(tres.ref(), dt1, f2);                                         \
+    tf2.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -705,11 +636,11 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const Type1& t1,                                                           \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2                \
+    const Type1& s1,                                                           \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 )                                                                              \
 {                                                                              \
-    return dimensioned<Type1>(t1) Op tgf2;                                     \
+    return dimensioned<Type1>(s1) Op tf2;                                      \
 }
 
 
@@ -718,41 +649,33 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 TEMPLATE                                                                       \
 void OpFunc                                                                    \
 (                                                                              \
-    GeometricField<ReturnType, PatchField, GeoMesh>& res,                      \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
     const dimensioned<Type2>& dt2                                              \
 )                                                                              \
 {                                                                              \
-    Foam::OpFunc(res.primitiveFieldRef(), gf1.primitiveField(), dt2.value());  \
-    Foam::OpFunc(res.boundaryFieldRef(), gf1.boundaryField(), dt2.value());    \
-    res.oriented() = gf1.oriented();                                           \
+    Foam::OpFunc(result.primitiveFieldRef(), f1.primitiveField(), dt2.value());\
+    Foam::OpFunc(result.boundaryFieldRef(), f1.boundaryField(), dt2.value());  \
+    result.oriented() = f1.oriented();                                         \
 }                                                                              \
                                                                                \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
     const dimensioned<Type2>& dt2                                              \
 )                                                                              \
 {                                                                              \
     auto tres =                                                                \
-        tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New              \
+        reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New    \
         (                                                                      \
-            IOobject                                                           \
-            (                                                                  \
-                '(' + gf1.name() + OpName + dt2.name() + ')',                  \
-                gf1.instance(),                                                \
-                gf1.db(),                                                      \
-                IOobject::NO_READ,                                             \
-                IOobject::NO_WRITE                                             \
-            ),                                                                 \
-            gf1.mesh(),                                                        \
-            gf1.dimensions() Op dt2.dimensions()                               \
+            f1,                                                                \
+            '(' + f1.name() + OpName + dt2.name() + ')',                       \
+            (f1.dimensions() Op dt2.dimensions())                              \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref(), gf1, dt2);                                        \
-                                                                               \
+    Foam::OpFunc(tres.ref(), f1, dt2);                                         \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -760,35 +683,33 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1,                     \
-    const Type2& t2                                                            \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    return gf1 Op dimensioned<Type2>(t2);                                      \
+    return f1 Op dimensioned<Type2>(s2);                                       \
 }                                                                              \
                                                                                \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1,               \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
     const dimensioned<Type2>& dt2                                              \
 )                                                                              \
 {                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1();            \
+    const auto& f1 = tf1();                                                    \
                                                                                \
     auto tres =                                                                \
         reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New    \
         (                                                                      \
-            tgf1,                                                              \
-            '(' + gf1.name() + OpName + dt2.name() + ')',                      \
-            gf1.dimensions() Op dt2.dimensions()                               \
+            tf1,                                                               \
+            '(' + f1.name() + OpName + dt2.name() + ')',                       \
+            (f1.dimensions() Op dt2.dimensions())                              \
         );                                                                     \
                                                                                \
-    Foam::OpFunc(tres.ref(), gf1, dt2);                                        \
-                                                                               \
-    tgf1.clear();                                                              \
-                                                                               \
+    Foam::OpFunc(tres.ref(), f1, dt2);                                         \
+    tf1.clear();                                                               \
     return tres;                                                               \
 }                                                                              \
                                                                                \
@@ -796,11 +717,11 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1,               \
-    const Type2& t2                                                            \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    return tgf1 Op dimensioned<Type2>(t2);                                     \
+    return tf1 Op dimensioned<Type2>(s2);                                      \
 }
 
 
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.H b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.H
index 83109528dd..0af9f5159d 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.H
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.H
@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -30,32 +31,46 @@ License
 #define UNARY_FUNCTION(ReturnType, Type1, Func, Dfunc)                         \
                                                                                \
 TEMPLATE                                                                       \
-tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+void Func                                                                      \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& df                       \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1                       \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1                \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1                       \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1                 \
 );
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define UNARY_OPERATOR(ReturnType, Type1, Op, opFunc, Dfunc)                   \
+#define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc, Dfunc)                   \
                                                                                \
 TEMPLATE                                                                       \
-tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
+void OpFunc                                                                    \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& df1                      \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1                       \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1                \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1                       \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1                 \
 );
 
 
@@ -64,6 +79,14 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 #define BINARY_FUNCTION(ReturnType, Type1, Type2, Func)                        \
                                                                                \
 TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
     const GeometricField<Type1, PatchField, GeoMesh>& df1,                     \
@@ -73,22 +96,22 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& df1,                     \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2                \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1,               \
-    const GeometricField<Type2, PatchField, GeoMesh>& df2                      \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1,               \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2                \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 );
 
 
@@ -97,62 +120,78 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 #define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func)                \
                                                                                \
 TEMPLATE                                                                       \
-tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+void Func                                                                      \
 (                                                                              \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
     const dimensioned<Type1>& dt1,                                             \
-    const GeometricField<Type2, PatchField, GeoMesh>& df2                      \
-);                                                                             \
-                                                                               \
-TEMPLATE                                                                       \
-tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
-(                                                                              \
-    const Type1& t1,                                                           \
-    const GeometricField<Type2, PatchField, GeoMesh>& df2                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
     const dimensioned<Type1>& dt1,                                             \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2                \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const Type1& t1,                                                           \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2                \
+    const Type1& s1,                                                           \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const dimensioned<Type1>& dt1,                                             \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const Type1& s1,                                                           \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 );
 
 
 #define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)                \
                                                                                \
 TEMPLATE                                                                       \
-tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+void Func                                                                      \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& df1,                     \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
     const dimensioned<Type2>& dt2                                              \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& df1,                     \
-    const Type2& t2                                                            \
-);                                                                             \
-                                                                               \
-TEMPLATE                                                                       \
-tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
-(                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1,               \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
     const dimensioned<Type2>& dt2                                              \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf2,               \
-    const Type2& t2                                                            \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const Type2& s2                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const dimensioned<Type2>& dt2                                              \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const Type2& s2                                                            \
 );
 
 
@@ -166,95 +205,119 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
 #define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc)          \
                                                                                \
 TEMPLATE                                                                       \
-tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
+void OpFunc                                                                    \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& df1,                     \
-    const GeometricField<Type2, PatchField, GeoMesh>& df2                      \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& df1,                     \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2                \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1,               \
-    const GeometricField<Type2, PatchField, GeoMesh>& df2                      \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1,               \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2                \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 );
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
+#define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc)  \
                                                                                \
 TEMPLATE                                                                       \
-tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
+void OpFunc                                                                    \
 (                                                                              \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
     const dimensioned<Type1>& dt1,                                             \
-    const GeometricField<Type2, PatchField, GeoMesh>& df2                      \
-);                                                                             \
-                                                                               \
-TEMPLATE                                                                       \
-tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
-(                                                                              \
-    const Type1& t1,                                                           \
-    const GeometricField<Type2, PatchField, GeoMesh>& df2                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
     const dimensioned<Type1>& dt1,                                             \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2                \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const Type1& t1,                                                           \
-    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2                \
+    const Type1& s1,                                                           \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2                       \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
+(                                                                              \
+    const dimensioned<Type1>& dt1,                                             \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
+(                                                                              \
+    const Type1& s1,                                                           \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2                 \
 );
 
 
-#define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
+#define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc)  \
                                                                                \
 TEMPLATE                                                                       \
-tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
+void OpFunc                                                                    \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& df1,                     \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
     const dimensioned<Type2>& dt2                                              \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const GeometricField<Type1, PatchField, GeoMesh>& df1,                     \
-    const Type2& t2                                                            \
-);                                                                             \
-                                                                               \
-TEMPLATE                                                                       \
-tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
-(                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1,               \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
     const dimensioned<Type2>& dt2                                              \
 );                                                                             \
                                                                                \
 TEMPLATE                                                                       \
 tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 (                                                                              \
-    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1,               \
-    const Type2& t2                                                            \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const Type2& s2                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const dimensioned<Type2>& dt2                                              \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const Type2& s2                                                            \
 );
 
 
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldReuseFunctions.H b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldReuseFunctions.H
index a2c2fe3f56..afe8d4b65b 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldReuseFunctions.H
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldReuseFunctions.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2022 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -76,6 +76,7 @@ inline bool reusable
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// One-parameter versions
 
 template
 <
@@ -86,24 +87,46 @@ template
 >
 struct reuseTmpGeometricField
 {
+    //- Pass-through to New GeometricField
     static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
     (
-        const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1,
+        const GeometricField<Type1, PatchField, GeoMesh>& f1,
         const word& name,
         const dimensionSet& dimensions
     )
     {
-        const auto& gf1 = tgf1();
+        return tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New
+        (
+            IOobject
+            (
+                name,
+                f1.instance(),
+                f1.db()
+            ),
+            f1.mesh(),
+            dimensions
+        );
+    }
+
+    //- Dissimilar types: return new field
+    static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
+    (
+        const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,
+        const word& name,
+        const dimensionSet& dimensions
+    )
+    {
+        const auto& f1 = tf1();
 
         return tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New
         (
             IOobject
             (
                 name,
-                gf1.instance(),
-                gf1.db()
+                f1.instance(),
+                f1.db()
             ),
-            gf1.mesh(),
+            f1.mesh(),
             dimensions
         );
     }
@@ -117,41 +140,41 @@ struct reuseTmpGeometricField<TypeR, TypeR, PatchField, GeoMesh>
     //- for identical input and output types
     static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
     (
-        const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1,
+        const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf1,
         const word& name,
         const dimensionSet& dimensions,
         const bool initCopy = false
     )
     {
-        if (Detail::reusable(tgf1))
+        if (Detail::reusable(tf1))
         {
-            auto& gf1 = tgf1.constCast();
+            auto& f1 = tf1.constCast();
 
-            gf1.rename(name);
-            gf1.dimensions().reset(dimensions);
-            return tgf1;
+            f1.rename(name);
+            f1.dimensions().reset(dimensions);
+            return tf1;
         }
 
-        const auto& gf1 = tgf1();
+        const auto& f1 = tf1();
 
-        auto rtgf = tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New
+        auto tresult = tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New
         (
             IOobject
             (
                 name,
-                gf1.instance(),
-                gf1.db()
+                f1.instance(),
+                f1.db()
             ),
-            gf1.mesh(),
+            f1.mesh(),
             dimensions
         );
 
         if (initCopy)
         {
-            rtgf.ref() == gf1;
+            tresult.ref() == f1;
         }
 
-        return rtgf;
+        return tresult;
     }
 };
 
@@ -163,7 +186,7 @@ tmp
     GeometricField<TypeR, PatchField, GeoMesh>
 > New
 (
-    const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1,
+    const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf1,
     const word& name,
     const dimensionSet& dimensions,
     const bool initCopy = false
@@ -171,7 +194,7 @@ tmp
 {
     return reuseTmpGeometricField<TypeR, TypeR, PatchField, GeoMesh>::New
     (
-        tgf1,
+        tf1,
         name,
         dimensions,
         initCopy
@@ -192,23 +215,23 @@ struct reuseTmpTmpGeometricField
 {
     static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
     (
-        const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1,
-        const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2,
+        const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,
+        const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,
         const word& name,
         const dimensionSet& dimensions
     )
     {
-        const auto& gf1 = tgf1();
+        const auto& f1 = tf1();
 
         return tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New
         (
             IOobject
             (
                 name,
-                gf1.instance(),
-                gf1.db()
+                f1.instance(),
+                f1.db()
             ),
-            gf1.mesh(),
+            f1.mesh(),
             dimensions
         );
     }
@@ -230,32 +253,32 @@ struct reuseTmpTmpGeometricField
 {
     static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
     (
-        const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1,
-        const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf2,
+        const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,
+        const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf2,
         const word& name,
         const dimensionSet& dimensions
     )
     {
-        if (Detail::reusable(tgf2))
+        if (Detail::reusable(tf2))
         {
-            auto& gf2 = tgf2.constCast();
+            auto& f2 = tf2.constCast();
 
-            gf2.rename(name);
-            gf2.dimensions().reset(dimensions);
-            return tgf2;
+            f2.rename(name);
+            f2.dimensions().reset(dimensions);
+            return tf2;
         }
 
-        const auto& gf1 = tgf1();
+        const auto& f1 = tf1();
 
         return tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New
         (
             IOobject
             (
                 name,
-                gf1.instance(),
-                gf1.db()
+                f1.instance(),
+                f1.db()
             ),
-            gf1.mesh(),
+            f1.mesh(),
             dimensions
         );
     }
@@ -276,32 +299,32 @@ struct reuseTmpTmpGeometricField
 {
     static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
     (
-        const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1,
-        const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2,
+        const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf1,
+        const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,
         const word& name,
         const dimensionSet& dimensions
     )
     {
-        if (Detail::reusable(tgf1))
+        if (Detail::reusable(tf1))
         {
-            auto& gf1 = tgf1.constCast();
+            auto& f1 = tf1.constCast();
 
-            gf1.rename(name);
-            gf1.dimensions().reset(dimensions);
-            return tgf1;
+            f1.rename(name);
+            f1.dimensions().reset(dimensions);
+            return tf1;
         }
 
-        const auto& gf1 = tgf1();
+        const auto& f1 = tf1();
 
         return tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New
         (
             IOobject
             (
                 name,
-                gf1.instance(),
-                gf1.db()
+                f1.instance(),
+                f1.db()
             ),
-            gf1.mesh(),
+            f1.mesh(),
             dimensions
         );
     }
@@ -316,47 +339,46 @@ struct reuseTmpTmpGeometricField
 {
     static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
     (
-        const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1,
-        const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf2,
+        const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf1,
+        const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf2,
         const word& name,
         const dimensionSet& dimensions
     )
     {
-        if (Detail::reusable(tgf1))
+        if (Detail::reusable(tf1))
         {
-            auto& gf1 = tgf1.constCast();
+            auto& f1 = tf1.constCast();
 
-            gf1.rename(name);
-            gf1.dimensions().reset(dimensions);
-            return tgf1;
+            f1.rename(name);
+            f1.dimensions().reset(dimensions);
+            return tf1;
         }
-        if (Detail::reusable(tgf2))
+        if (Detail::reusable(tf2))
         {
-            auto& gf2 = tgf2.constCast();
+            auto& f2 = tf2.constCast();
 
-            gf2.rename(name);
-            gf2.dimensions().reset(dimensions);
-            return tgf2;
+            f2.rename(name);
+            f2.dimensions().reset(dimensions);
+            return tf2;
         }
 
-        const auto& gf1 = tgf1();
+        const auto& f1 = tf1();
 
         return tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New
         (
             IOobject
             (
                 name,
-                gf1.instance(),
-                gf1.db()
+                f1.instance(),
+                f1.db()
             ),
-            gf1.mesh(),
+            f1.mesh(),
             dimensions
         );
     }
 };
 
 
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

From ab10b4a05cfdba1a27b0abedb3c6c033e5a80c1b Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@esi-group.com>
Date: Sat, 21 Jan 2023 22:30:33 +0100
Subject: [PATCH 04/11] EHN: add FieldFunction interface for 0/1 clamping

- enables clamp(field, zero_one{}) returning a tmp Field
---
 applications/test/minMax2/Test-minMax2.C      |  6 +-
 .../DimensionedFieldFunctions.C               | 67 +++++++++++++++++-
 .../DimensionedFieldFunctions.H               | 31 ++++++++-
 .../FieldField/FieldFieldFunctions.C          |  1 +
 .../FieldField/FieldFieldFunctions.H          |  1 +
 .../fields/Fields/Field/FieldFunctions.C      | 26 +++++++
 .../fields/Fields/Field/FieldFunctions.H      |  1 +
 .../GeometricField/GeometricFieldFunctions.C  | 68 +++++++++++++++++++
 .../GeometricField/GeometricFieldFunctions.H  | 30 ++++++++
 .../primitives/ranges/MinMax/MinMax.H         |  3 +-
 10 files changed, 227 insertions(+), 7 deletions(-)

diff --git a/applications/test/minMax2/Test-minMax2.C b/applications/test/minMax2/Test-minMax2.C
index 531235e6f5..136681d75c 100644
--- a/applications/test/minMax2/Test-minMax2.C
+++ b/applications/test/minMax2/Test-minMax2.C
@@ -152,13 +152,13 @@ int main(int argc, char *argv[])
         Info<< nl
             << "field: " << flatOutput(someField) << nl;
         Info<< "clamp01: "
-            << flatOutput(clamp(someField, scalarMinMax(zero_one{}))()) << nl;
+            << flatOutput(clamp(someField, zero_one{})()) << nl;
 
         Info<< "clamp01: "
-            << clamp(tmp<scalarField>(someField), scalarMinMax(zero_one{}))<< nl;
+            << clamp(tmp<scalarField>(someField), zero_one{})<< nl;
 
         scalarField result(10);
-        clamp(result, someField, scalarMinMax(zero_one{}));
+        clamp(result, someField, zero_one{});
 
         Info<< "result: " << result << nl;
 
diff --git a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.C b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.C
index 841324d1f2..c2217d2fd1 100644
--- a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.C
+++ b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.C
@@ -319,7 +319,72 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, min)
 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
 
-BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clip)
+
+// ------------------------------------------------------------------------- //
+
+// Clamp Methods
+
+template<class Type, class GeoMesh>
+void clamp
+(
+    DimensionedField<Type, GeoMesh>& result,
+    const DimensionedField<Type, GeoMesh>& f1,
+    const Foam::zero_one
+)
+{
+    const MinMax<Type> range(Foam::zero_one{});
+
+    clamp(result.field(), f1.field(), range);
+    result.oriented() = f1.oriented();
+}
+
+template<class Type, class GeoMesh>
+tmp<DimensionedField<Type, GeoMesh>>
+clamp
+(
+    const DimensionedField<Type, GeoMesh>& f1,
+    const Foam::zero_one
+)
+{
+    auto tres =
+        reuseTmpDimensionedField<Type, Type, GeoMesh>::New
+        (
+            f1,
+            "clamp01(" + f1.name() + ')',
+            f1.dimensions()
+        );
+
+    clamp(tres.ref(), f1, Foam::zero_one{});
+
+    return tres;
+}
+
+
+template<class Type, class GeoMesh>
+tmp<DimensionedField<Type, GeoMesh>>
+clamp
+(
+    const tmp<DimensionedField<Type, GeoMesh>>& tf1,
+    const Foam::zero_one
+)
+{
+    const auto& f1 = tf1();
+
+    auto tres =
+        reuseTmpDimensionedField<Type, Type, GeoMesh>::New
+        (
+            tf1,
+            "clamp01(" + f1.name() + ')',
+            f1.dimensions()
+        );
+
+    clamp(tres.field(), f1, Foam::zero_one{});
+
+    tf1.clear();
+    return tres;
+}
+
+BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
 
 
 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.H b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.H
index 3adb4ececb..537c736624 100644
--- a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.H
+++ b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.H
@@ -137,7 +137,36 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, min)
 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
 
-BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clip)
+
+// ------------------------------------------------------------------------- //
+
+// Clamp Methods
+
+template<class Type, class GeoMesh>
+void clamp
+(
+    DimensionedField<Type, GeoMesh>& result,
+    const DimensionedField<Type, GeoMesh>& f1,
+    const Foam::zero_one
+);
+
+template<class Type, class GeoMesh>
+tmp<DimensionedField<Type, GeoMesh>>
+clamp
+(
+    const DimensionedField<Type, GeoMesh>& f1,
+    const Foam::zero_one
+);
+
+template<class Type, class GeoMesh>
+tmp<DimensionedField<Type, GeoMesh>>
+clamp
+(
+    const tmp<DimensionedField<Type, GeoMesh>>& tf1,
+    const Foam::zero_one
+);
+
+BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
 
 
 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.C b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.C
index abfeab9928..dfda7e3602 100644
--- a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.C
+++ b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.C
@@ -630,6 +630,7 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, min)
 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
 
+// Note: works with zero_one through implicit conversion to MinMax
 BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
 
 
diff --git a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.H b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.H
index b1b0501e95..9776c63c37 100644
--- a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.H
+++ b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.H
@@ -287,6 +287,7 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, min)
 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
 
+// Note: works with zero_one through implicit conversion to MinMax
 BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
 
 
diff --git a/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C b/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
index f3e136c2e9..4a4e8d1177 100644
--- a/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
+++ b/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
@@ -700,7 +700,33 @@ void clamp
     }
 }
 
+template<class Type>
+void clamp
+(
+    Field<Type>& result,
+    const UList<Type>& f1,
+    const Foam::zero_one&   // Note: macros generate a const reference
+)
+{
+    if (result.cdata() == f1.cdata())
+    {
+        // Apply in-place
+        result.clamp_range(Foam::zero_one{});
+    }
+    else
+    {
+        std::transform
+        (
+            f1.cbegin(),
+            f1.cbegin(result.size()),
+            result.begin(),
+            clampOp<Type>(Foam::zero_one{})
+        );
+    }
+}
+
 BINARY_FUNCTION_INTERFACE_FS(Type, Type, MinMax<Type>, clamp)
+BINARY_FUNCTION_INTERFACE_FS(Type, Type, Foam::zero_one, clamp)
 
 
 BINARY_FUNCTION(Type, Type, Type, max)
diff --git a/src/OpenFOAM/fields/Fields/Field/FieldFunctions.H b/src/OpenFOAM/fields/Fields/Field/FieldFunctions.H
index 57a0c5db18..9307b9d155 100644
--- a/src/OpenFOAM/fields/Fields/Field/FieldFunctions.H
+++ b/src/OpenFOAM/fields/Fields/Field/FieldFunctions.H
@@ -314,6 +314,7 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
 
 BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
+BINARY_TYPE_FUNCTION_FS(Type, Type, Foam::zero_one, clamp)
 BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clip)  // Same as clamp
 
 
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.C b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.C
index 0c686d3be2..a62fd98b54 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.C
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.C
@@ -480,6 +480,74 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
 
 
+// ------------------------------------------------------------------------- //
+
+// Clamp Methods
+
+template<class Type, template<class> class PatchField, class GeoMesh>
+void clamp
+(
+    GeometricField<Type, PatchField, GeoMesh>& result,
+    const GeometricField<Type, PatchField, GeoMesh>& f1,
+    const Foam::zero_one
+)
+{
+    const MinMax<Type> range(Foam::zero_one{});
+
+    clamp(result.primitiveFieldRef(), f1.primitiveField(), range);
+    clamp(result.boundaryFieldRef(), f1.boundaryField(), range);
+    result.oriented() = f1.oriented();
+}
+
+template<class Type, template<class> class PatchField, class GeoMesh>
+tmp<GeometricField<Type, PatchField, GeoMesh>>
+clamp
+(
+    const GeometricField<Type, PatchField, GeoMesh>& f1,
+    const Foam::zero_one
+)
+{
+    auto tres =
+        reuseTmpGeometricField<Type, Type, PatchField, GeoMesh>::New
+        (
+            f1,
+            "clamp01(" + f1.name() + ')',
+            f1.dimensions()
+        );
+
+    clamp(tres.ref(), f1, Foam::zero_one{});
+
+    return tres;
+}
+
+
+template<class Type, template<class> class PatchField, class GeoMesh>
+tmp<GeometricField<Type, PatchField, GeoMesh>>
+clamp
+(
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1,
+    const Foam::zero_one
+)
+{
+    const auto& f1 = tf1();
+
+    auto tres =
+        reuseTmpGeometricField<Type, Type, PatchField, GeoMesh>::New
+        (
+            tf1,
+            "clamp01(" + f1.name() + ')',
+            f1.dimensions()
+        );
+
+    clamp(tres.ref(), f1, Foam::zero_one{});
+
+    tf1.clear();
+    return tres;
+}
+
+BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
+
+
 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 
 UNARY_OPERATOR(Type, Type, -, negate, transform)
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.H b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.H
index 9b91dc3c07..937a07e443 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.H
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.H
@@ -273,6 +273,36 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, min)
 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
 
+// ------------------------------------------------------------------------- //
+
+// Clamp Methods
+
+template<class Type, template<class> class PatchField, class GeoMesh>
+void clamp
+(
+    GeometricField<Type, PatchField, GeoMesh>& result,
+    const GeometricField<Type, PatchField, GeoMesh>& f1,
+    const Foam::zero_one
+);
+
+template<class Type, template<class> class PatchField, class GeoMesh>
+tmp<GeometricField<Type, PatchField, GeoMesh>>
+clamp
+(
+    const GeometricField<Type, PatchField, GeoMesh>& f1,
+    const Foam::zero_one
+);
+
+template<class Type, template<class> class PatchField, class GeoMesh>
+tmp<GeometricField<Type, PatchField, GeoMesh>>
+clamp
+(
+    const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1,
+    const Foam::zero_one
+);
+
+BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
+
 
 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/primitives/ranges/MinMax/MinMax.H b/src/OpenFOAM/primitives/ranges/MinMax/MinMax.H
index 3738f8847a..be7a3ee8c8 100644
--- a/src/OpenFOAM/primitives/ranges/MinMax/MinMax.H
+++ b/src/OpenFOAM/primitives/ranges/MinMax/MinMax.H
@@ -85,6 +85,7 @@ Description
 #define Foam_MinMax_H
 
 #include "scalar.H"
+#include "zero.H"
 #include "Pair.H"
 #include "Tuple2.H"
 #include "VectorSpace.H"
@@ -97,8 +98,6 @@ namespace Foam
 
 // Forward Declarations
 template<class T> class MinMax;
-class zero;
-class zero_one;
 
 // Common min/max types
 typedef MinMax<label> labelMinMax;      //!< A label min/max range

From e1a710014c4db859be7bdd864e50e448af8f6bd5 Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@esi-group.com>
Date: Thu, 19 Jan 2023 16:03:39 +0100
Subject: [PATCH 05/11] ENH: define lerp field functions

- defined for lerp between two fields,
  either with a constant or a field of interpolation factors.

  * plain Field, DimensionedField, FieldField, GeometricFields

- using a field to lerp between two constants is not currently
  supported
---
 .../test/speed/vectorSpeed/Test-vectorSpeed.C | 200 ++++++++-
 .../DimensionedFieldFunctions.C               |   6 +
 .../DimensionedFieldFunctions.H               |   6 +
 .../DimensionedFieldFunctionsM.C              | 374 ++++++++++++++++
 .../DimensionedFieldFunctionsM.H              | 154 +++++++
 .../FieldField/FieldFieldFunctions.C          |   6 +
 .../FieldField/FieldFieldFunctions.H          |   5 +
 .../FieldField/FieldFieldFunctionsM.C         | 235 ++++++++++
 .../FieldField/FieldFieldFunctionsM.H         | 122 ++++++
 .../fields/Fields/Field/FieldFunctions.C      |   5 +
 .../fields/Fields/Field/FieldFunctions.H      |   5 +
 .../fields/Fields/Field/FieldFunctionsM.C     | 211 +++++++++
 .../fields/Fields/Field/FieldFunctionsM.H     | 132 ++++++
 .../GeometricField/GeometricFieldFunctions.C  |   6 +
 .../GeometricField/GeometricFieldFunctions.H  |   6 +
 .../GeometricField/GeometricFieldFunctionsM.C | 401 ++++++++++++++++++
 .../GeometricField/GeometricFieldFunctionsM.H | 154 +++++++
 17 files changed, 2017 insertions(+), 11 deletions(-)

diff --git a/applications/test/speed/vectorSpeed/Test-vectorSpeed.C b/applications/test/speed/vectorSpeed/Test-vectorSpeed.C
index 2ab430d34a..0acdc5d84c 100644
--- a/applications/test/speed/vectorSpeed/Test-vectorSpeed.C
+++ b/applications/test/speed/vectorSpeed/Test-vectorSpeed.C
@@ -1,3 +1,38 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    Test-vectorSpeed
+
+Description
+    Test speeds, usability of some field operations
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
 #include "primitiveFields.H"
 #include "cpuTime.H"
 #include "IOstreams.H"
@@ -5,12 +40,22 @@
 
 using namespace Foam;
 
-int main()
-{
-    const label nIter = 100;
-    const label size = 1000000;
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-    Info<< "Initialising fields" << endl;
+int main(int argc, char *argv[])
+{
+    argList::noParallel();
+    argList::addBoolOption("lerp");
+
+    argList args(argc, argv);
+
+    const label nIter = 1000;
+    const label size = (1000000);
+
+    Info<< "Initialising fields. size:" << size
+        << " max:" << labelMax << endl;
+
+    scalarField onet(size);
 
     vectorField
         vf1(size, vector::one),
@@ -18,11 +63,14 @@ int main()
         vf3(size, vector::one),
         vf4(size);
 
-    Info<< "Done\n" << endl;
+    Info<< "Start loop: " << nIter << endl;
 
+    cpuTime timing;
+
+    // Timing is mostly malloc anyhow...
+
+    if (!args.found("lerp"))
     {
-        cpuTime executionTime;
-
         Info<< "vectorField algebra" << endl;
 
         for (int j=0; j<nIter; j++)
@@ -30,12 +78,142 @@ int main()
             vf4 = vf1 + vf2 - vf3;
         }
 
-        Info<< "ExecutionTime = "
-            << executionTime.elapsedCpuTime()
-            << " s\n" << endl;
+        Info<< "Timing = " << timing.cpuTimeIncrement() << " s" << endl;
 
         Snull<< vf4[1] << endl << endl;
     }
 
+    if (args.found("lerp"))
+    {
+        Info<< nl
+            << "testing timings with lerp 0.75" << nl
+            << "Main bottlenecks: malloc and looping" << nl;
+
+        scalar t = 0.75;
+        scalarField fract(size, t);
+
+        // Basic compilation tests:
+        lerp(vf1, vf2, fract)().size();             // list list list
+        lerp(0.5*vf1, vf2, fract)().size();         // tmp  list list
+        lerp(vf1, 0.5*vf2, fract)().size();         // list tmp  list
+        lerp(vf1, vf2, 0.5*fract)().size();         // list list tmp
+        lerp(0.5*vf1, 0.5*vf2, fract)().size();     // tmp  tmp  list
+        lerp(0.5*vf1, vf2, 0.5*fract)().size();     // tmp  list tmp
+        lerp(vf1, 1.0*vf2, 0.5*fract)().size();     // list tmp  tmp
+        lerp(0.5*vf1, 0.5*vf2, 0.5*fract)().size(); // tmp  tmp  tmp
+
+        // Basic compilation tests:
+        lerp(vf1, vf2, t)().size();                 // list list scalar
+        lerp(0.5*vf1, vf2, t)().size();             // tmp  list scalar
+        lerp(vf1, 0.5*vf2, t)().size();             // list tmp  scalar
+        lerp(0.5*vf1, 0.5*vf2, t)().size();         // tmp  tmp  scalar
+        lerp(vf1, 1.0*vf2, 0.5*t)().size();         // list tmp  scalar
+
+        // Other combinations (not yet included)
+        // list scalar list...
+        // scalar list list...
+
+
+        // Probable base line of single instruction multiple data
+        for (int j=0; j<nIter; j++)
+        {
+            const label loopLen = (vf1).size();
+
+            for (label i = 0; i < loopLen; ++i)
+            {
+                vf4[i] = (1-fract[i])*vf1[i] + fract[i]*vf2[i];
+            }
+        }
+
+        Info<< "(1-t)*a + t*b : Timing (no malloc) = "
+            << timing.cpuTimeIncrement() << " s" << endl;
+
+        Snull<< vf4[1] << endl << endl;
+
+        // With all loops written out
+        // - corresponds to what we would normally have
+        for (int j=0; j<nIter; j++)
+        {
+            const label loopLen = (vf1).size();
+
+            for (label i = 0; i < loopLen; ++i)
+            {
+                onet[i] = (1-fract[i]);
+            }
+
+            for (label i = 0; i < loopLen; ++i)
+            {
+                vf3[i] = (fract[i] * vf2[i]);
+            }
+
+            for (label i = 0; i < loopLen; ++i)
+            {
+                vf4[i] = onet[i] * vf1[i];
+            }
+
+            for (label i = 0; i < loopLen; ++i)
+            {
+                vf4[i] += vf3[i];
+            }
+        }
+
+        Info<< "(1-t)*a + t*b : Looping (no malloc) = "
+            << timing.cpuTimeIncrement() << " s" << endl;
+
+        Snull<< vf4[1] << endl << endl;
+
+        for (int j=0; j<nIter; j++)
+        {
+            lerp(vf4, vf1, vf2, fract);
+        }
+
+        Info<< "lerp(a, b, t) : Timing (no malloc) = "
+            << timing.cpuTimeIncrement() << " s" << endl;
+
+        Snull<< vf4[1] << endl << endl;
+
+        Info<< nl;
+
+        // Now with tmp fields
+        // ~~~~~~~~~~~~~~~~~~~
+
+        for (int j=0; j<nIter; j++)
+        {
+            vf4 = (1-fract)*vf1 + fract*vf2;
+        }
+
+        Info<< "(1-t)*a + t*b : Timing (with malloc) = "
+            << timing.cpuTimeIncrement() << " s" << endl;
+
+        Snull<< vf4[1] << endl << endl;
+
+        for (int j=0; j<nIter; j++)
+        {
+            // With field 't'
+            vf4 = lerp(vf1, vf2, fract);
+        }
+
+        Info<< "lerp(a, b, t) : Timing (with malloc) = "
+            << timing.cpuTimeIncrement() << " s" << endl;
+
+        Snull<< vf4[1] << endl << endl;
+
+        for (int j=0; j<nIter; j++)
+        {
+            // With scalar 't'
+            vf4 = lerp(vf1, vf2, t);
+        }
+
+        Info<< "lerp(a, b, t) : Timing (with malloc) scalar = "
+            << timing.cpuTimeIncrement() << " s" << endl;
+
+        Snull<< vf4[1] << endl << endl;
+    }
+
+
+    Info<< nl << "Done" << nl << endl;
     return 0;
 }
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.C b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.C
index c2217d2fd1..621b49200f 100644
--- a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.C
+++ b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.C
@@ -387,6 +387,12 @@ clamp
 BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
+TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
+
+
 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 
 UNARY_OPERATOR(Type, Type, -, negate, transform)
diff --git a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.H b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.H
index 537c736624..e444690399 100644
--- a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.H
+++ b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.H
@@ -169,6 +169,12 @@ clamp
 BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
+TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
+
+
 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 
 UNARY_OPERATOR(Type, Type, -, negate, transform)
diff --git a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.C b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.C
index e8ee293203..c748949715 100644
--- a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.C
+++ b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.C
@@ -694,4 +694,378 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
     BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc)
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func)                \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const DimensionedField<Type3, GeoMesh>& f3                                 \
+)                                                                              \
+{                                                                              \
+    /* TBD: reset dimensions? */                                               \
+    Func(result.field(), f1.field(), f2.field(), f3.field());                  \
+    result.oriented() = Func(f1.oriented(), f2.oriented());                    \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const DimensionedField<Type3, GeoMesh>& f3                                 \
+)                                                                              \
+{                                                                              \
+    auto tres =                                                                \
+        reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New              \
+        (                                                                      \
+            f1,                                                                \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + f3.name() + ')',   \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Func(tres.ref(), f1, f2, f3);                                              \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const DimensionedField<Type3, GeoMesh>& f3                                 \
+)                                                                              \
+{                                                                              \
+    const auto& f1 = tf1();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New              \
+        (                                                                      \
+            tf1,                                                               \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + f3.name() + ')',   \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Func(tres.ref(), f1, f2, f3);                                              \
+    tf1.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2,                          \
+    const DimensionedField<Type3, GeoMesh>& f3                                 \
+)                                                                              \
+{                                                                              \
+    const auto& f2 = tf2();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New              \
+        (                                                                      \
+            tf2,                                                               \
+            #Func "(" + f1.name() +','+ f2.name() +','+ f3.name() +')',        \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Func(tres.ref(), f1, f2, f3);                                              \
+    tf2.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const tmp<DimensionedField<Type3, GeoMesh>>& tf3                           \
+)                                                                              \
+{                                                                              \
+    const auto& f3 = tf3();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpDimensionedField<ReturnType, Type3, GeoMesh>::New              \
+        (                                                                      \
+            tf3,                                                               \
+            #Func "(" + f1.name() +','+ f2.name() +','+ f3.name() +')',        \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Func(tres.ref(), f1, f2, f3);                                              \
+    tf3.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2,                          \
+    const DimensionedField<Type3, GeoMesh>& f3                                 \
+)                                                                              \
+{                                                                              \
+    const auto& f1 = tf1();                                                    \
+    const auto& f2 = tf2();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpTmpDimensionedField                                            \
+        <ReturnType, Type1, Type1, Type2, GeoMesh>::New                        \
+        (                                                                      \
+            tf1,                                                               \
+            tf2,                                                               \
+            #Func "(" + f1.name() +','+ f2.name() +','+ f3.name() +')',        \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Func(tres.ref(), f1, f2, f3);                                              \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const tmp<DimensionedField<Type3, GeoMesh>>& tf3                           \
+)                                                                              \
+{                                                                              \
+    const auto& f1 = tf1();                                                    \
+    const auto& f3 = tf3();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpTmpDimensionedField                                            \
+        <ReturnType, Type1, Type1, Type3, GeoMesh>::New                        \
+        (                                                                      \
+            tf1,                                                               \
+            tf3,                                                               \
+            #Func "(" + f1.name() +','+ f2.name() +','+ f3.name() +')',        \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Func(tres.ref(), f1, f2, f3);                                              \
+    tf1.clear();                                                               \
+    tf3.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2,                          \
+    const tmp<DimensionedField<Type3, GeoMesh>>& tf3                           \
+)                                                                              \
+{                                                                              \
+    const auto& f2 = tf2();                                                    \
+    const auto& f3 = tf3();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpTmpDimensionedField                                            \
+        <ReturnType, Type2, Type2, Type3, GeoMesh>::New                        \
+        (                                                                      \
+            tf2,                                                               \
+            tf3,                                                               \
+            #Func "(" + f1.name() +','+ f2.name() +','+ f3.name() +')',        \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Func(tres.ref(), f1, f2, f3);                                              \
+    tf2.clear();                                                               \
+    tf3.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2,                          \
+    const tmp<DimensionedField<Type3, GeoMesh>>& tf3                           \
+)                                                                              \
+{                                                                              \
+    const auto& f1 = tf1();                                                    \
+    const auto& f2 = tf2();                                                    \
+    const auto& f3 = tf3();                                                    \
+                                                                               \
+    /* TBD: check all three types? */                                          \
+    auto tres =                                                                \
+        reuseTmpTmpDimensionedField                                            \
+        <ReturnType, Type1, Type1, Type2, GeoMesh>::New                        \
+        (                                                                      \
+            tf1,                                                               \
+            tf2,                                                               \
+            #Func "(" + f1.name() +','+ f2.name() +','+ f3.name() +')',        \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Func(tres.ref(), f1, f2, f3);                                              \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
+    tf3.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+
+
+#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func)       \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const dimensioned<Type3>& dt3                                              \
+)                                                                              \
+{                                                                              \
+    /* TBD: reset dimensions? */                                               \
+    Func(result.field(), f1.field(), f2.field(), dt3.value());                 \
+    result.oriented() = Func(f1.oriented(), f2.oriented());                    \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const dimensioned<Type3>& dt3                                              \
+)                                                                              \
+{                                                                              \
+    auto tres =                                                                \
+        reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New              \
+        (                                                                      \
+            f1,                                                                \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + dt3.name() + ')',  \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Func(tres.ref(), f1, f2, dt3);                                             \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    return Func(f1, f2, dimensioned<Type3>(s3));                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const dimensioned<Type3>& dt3                                              \
+)                                                                              \
+{                                                                              \
+    const auto& f1 = tf1();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New              \
+        (                                                                      \
+            tf1,                                                               \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + dt3.name() + ')',  \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Func(tres.ref(), f1, f2, dt3);                                             \
+    tf1.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    return Func(tf1, f2, dimensioned<Type3>(s3));                              \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2,                          \
+    const dimensioned<Type3>& dt3                                              \
+)                                                                              \
+{                                                                              \
+    const auto& f2 = tf2();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New              \
+        (                                                                      \
+            tf2,                                                               \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + dt3.name() + ')',  \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Func(tres.ref(), f1, f2, dt3);                                             \
+    tf2.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2,                          \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    return Func(f1, tf2, dimensioned<Type3>(s3));                              \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2,                          \
+    const dimensioned<Type3>& dt3                                              \
+)                                                                              \
+{                                                                              \
+    const auto& f1 = tf1();                                                    \
+    const auto& f2 = tf2();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpTmpDimensionedField                                            \
+        <ReturnType, Type1, Type1, Type2, GeoMesh>::New                        \
+        (                                                                      \
+            tf1,                                                               \
+            tf2,                                                               \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + dt3.name() + ')',  \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Func(tres.ref(), f1, f2, dt3);                                             \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2,                          \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    return Func(tf1, tf2, dimensioned<Type3>(s3));                             \
+}
+
+
 // ************************************************************************* //
diff --git a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.H b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.H
index a3157242f2..7c1d81c6df 100644
--- a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.H
+++ b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.H
@@ -326,4 +326,158 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op                         \
     BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc)
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func)                \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const DimensionedField<Type3, GeoMesh>& f3                                 \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const DimensionedField<Type3, GeoMesh>& f3                                 \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const DimensionedField<Type3, GeoMesh>& f3                                 \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2,                          \
+    const DimensionedField<Type3, GeoMesh>& f3                                 \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const tmp<DimensionedField<Type3, GeoMesh>>& tf3                           \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2,                          \
+    const DimensionedField<Type3, GeoMesh>& f3                                 \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const tmp<DimensionedField<Type3, GeoMesh>>& tf3                           \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2,                          \
+    const tmp<DimensionedField<Type3, GeoMesh>>& tf3                           \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2,                          \
+    const tmp<DimensionedField<Type3, GeoMesh>>& tf3                           \
+);
+
+
+#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func)       \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    DimensionedField<ReturnType, GeoMesh>& result,                             \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const dimensioned<Type3>& dt3                                              \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const dimensioned<Type3>& dt3                                              \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const Type3& s3                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const dimensioned<Type3>& dt3                                              \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const DimensionedField<Type2, GeoMesh>& f2,                                \
+    const Type3& s3                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2,                          \
+    const dimensioned<Type3>& dt3                                              \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const DimensionedField<Type1, GeoMesh>& f1,                                \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2,                          \
+    const Type3& s3                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2,                          \
+    const dimensioned<Type3>& dt3                                              \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<DimensionedField<ReturnType, GeoMesh>> Func                                \
+(                                                                              \
+    const tmp<DimensionedField<Type1, GeoMesh>>& tf1,                          \
+    const tmp<DimensionedField<Type2, GeoMesh>>& tf2,                          \
+    const Type3& s3                                                            \
+);
+
+
 // ************************************************************************* //
diff --git a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.C b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.C
index dfda7e3602..54a489deac 100644
--- a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.C
+++ b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.C
@@ -634,6 +634,12 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
 BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
+TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
+
+
 /* * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * */
 
 UNARY_OPERATOR(Type, Type, -, negate)
diff --git a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.H b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.H
index 9776c63c37..843bf67c58 100644
--- a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.H
+++ b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.H
@@ -290,6 +290,11 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
 // Note: works with zero_one through implicit conversion to MinMax
 BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
+TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
+
 
 /* * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * */
 
diff --git a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.C b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.C
index d2dc88ce0b..5becaa4753 100644
--- a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.C
+++ b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.C
@@ -459,4 +459,239 @@ tmp<FieldField<Field, ReturnType>> operator Op                                 \
     BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc)
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func)                \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    FieldField<Field, ReturnType>& result,                                     \
+    const FieldField<Field, Type1>& f1,                                        \
+    const FieldField<Field, Type2>& f2,                                        \
+    const FieldField<Field, Type3>& f3                                         \
+)                                                                              \
+{                                                                              \
+    const label loopLen = (result).size();                                     \
+                                                                               \
+    for (label i = 0; i < loopLen; ++i)                                        \
+    {                                                                          \
+        Func(result[i], f1[i], f2[i], f3[i]);                                  \
+    }                                                                          \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const FieldField<Field, Type1>& f1,                                        \
+    const FieldField<Field, Type2>& f2,                                        \
+    const FieldField<Field, Type3>& f3                                         \
+)                                                                              \
+{                                                                              \
+    auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f1);          \
+    Func(tres.ref(), f1, f2, f3);                                              \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const tmp<FieldField<Field, Type1>>& tf1,                                  \
+    const FieldField<Field, Type2>& f2,                                        \
+    const FieldField<Field, Type3>& f3                                         \
+)                                                                              \
+{                                                                              \
+    auto tres = reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1);        \
+    Func(tres.ref(), tf1(), f2, f3);                                           \
+    tf1.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const FieldField<Field, Type1>& f1,                                        \
+    const tmp<FieldField<Field, Type2>>& tf2,                                  \
+    const FieldField<Field, Type3>& f3                                         \
+)                                                                              \
+{                                                                              \
+    auto tres = reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2);        \
+    Func(tres.ref(), f1, tf2(), f3);                                           \
+    tf2.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const FieldField<Field, Type1>& f1,                                        \
+    const FieldField<Field, Type2>& f2,                                        \
+    const tmp<FieldField<Field, Type3>>& tf3                                   \
+)                                                                              \
+{                                                                              \
+    auto tres = reuseTmpFieldField<Field, ReturnType, Type3>::New(tf3);        \
+    Func(tres.ref(), f1, f2, tf3());                                           \
+    tf3.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const tmp<FieldField<Field, Type1>>& tf1,                                  \
+    const tmp<FieldField<Field, Type2>>& tf2,                                  \
+    const FieldField<Field, Type3>& f3                                         \
+)                                                                              \
+{                                                                              \
+    tmp<FieldField<Field, ReturnType>> tres                                    \
+    (                                                                          \
+        reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>::        \
+            New(tf1, tf2)                                                      \
+    );                                                                         \
+    Func(tres.ref(), tf1(), tf2(), f3);                                        \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const tmp<FieldField<Field, Type1>>& tf1,                                  \
+    const FieldField<Field, Type2>& f2,                                        \
+    const tmp<FieldField<Field, Type3>>& tf3                                   \
+)                                                                              \
+{                                                                              \
+    tmp<FieldField<Field, ReturnType>> tres                                    \
+    (                                                                          \
+        reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type3>::        \
+            New(tf1, tf3)                                                      \
+    );                                                                         \
+    Func(tres.ref(), tf1(), f2, tf3());                                        \
+    tf1.clear();                                                               \
+    tf3.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const FieldField<Field, Type1>& f1,                                        \
+    const tmp<FieldField<Field, Type2>>& tf2,                                  \
+    const tmp<FieldField<Field, Type3>>& tf3                                   \
+)                                                                              \
+{                                                                              \
+    tmp<FieldField<Field, ReturnType>> tres                                    \
+    (                                                                          \
+        reuseTmpTmpFieldField<Field, ReturnType, Type2, Type2, Type3>::        \
+            New(tf2, tf3)                                                      \
+    );                                                                         \
+    Func(tres.ref(), f1, tf2(), tf3());                                        \
+    tf2.clear();                                                               \
+    tf3.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const tmp<FieldField<Field, Type1>>& tf1,                                  \
+    const tmp<FieldField<Field, Type2>>& tf2,                                  \
+    const tmp<FieldField<Field, Type3>>& tf3                                   \
+)                                                                              \
+{                                                                              \
+    /* TBD: check all three types? */                                          \
+    tmp<FieldField<Field, ReturnType>> tres                                    \
+    (                                                                          \
+        reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>::        \
+            New(tf1, tf2)                                                      \
+    );                                                                         \
+    Func(tres.ref(), tf1(), tf2(), tf3());                                     \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
+    tf3.clear();                                                               \
+    return tres;                                                               \
+}
+
+
+#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func)       \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    FieldField<Field, ReturnType>& result,                                     \
+    const FieldField<Field, Type1>& f1,                                        \
+    const FieldField<Field, Type2>& f2,                                        \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    const label loopLen = (result).size();                                     \
+                                                                               \
+    for (label i = 0; i < loopLen; ++i)                                        \
+    {                                                                          \
+        Func(result[i], f1[i], f2[i], s3);                                     \
+    }                                                                          \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const FieldField<Field, Type1>& f1,                                        \
+    const FieldField<Field, Type2>& f2,                                        \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f1);          \
+    Func(tres.ref(), f1, f2, s3);                                              \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const tmp<FieldField<Field, Type1>>& tf1,                                  \
+    const FieldField<Field, Type2>& f2,                                        \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    auto tres = reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1);        \
+    Func(tres.ref(), tf1(), f2, s3);                                           \
+    tf1.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const FieldField<Field, Type1>& f1,                                        \
+    const tmp<FieldField<Field, Type2>>& tf2,                                  \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    auto tres = reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2);        \
+    Func(tres.ref(), f1, tf2(), s3);                                           \
+    tf2.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const tmp<FieldField<Field, Type1>>& tf1,                                  \
+    const tmp<FieldField<Field, Type2>>& tf2,                                  \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    tmp<FieldField<Field, ReturnType>> tres                                    \
+    (                                                                          \
+        reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>::        \
+            New(tf1, tf2)                                                      \
+    );                                                                         \
+    Func(tres.ref(), tf1(), tf2(), s3);                                        \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
+    return tres;                                                               \
+}
+
+
 // ************************************************************************* //
diff --git a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.H b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.H
index 1e3b0501e8..81aac62600 100644
--- a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.H
+++ b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.H
@@ -273,4 +273,126 @@ tmp<FieldField<Field, ReturnType>> operator Op                                 \
     BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc)
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func)                \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    FieldField<Field, ReturnType>& result,                                     \
+    const FieldField<Field, Type1>& f1,                                        \
+    const FieldField<Field, Type2>& f2,                                        \
+    const FieldField<Field, Type3>& f3                                         \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const FieldField<Field, Type1>& f1,                                        \
+    const FieldField<Field, Type2>& f2,                                        \
+    const FieldField<Field, Type3>& f3                                         \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const tmp<FieldField<Field, Type1>>& tf1,                                  \
+    const FieldField<Field, Type2>& f2,                                        \
+    const FieldField<Field, Type3>& f3                                         \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const FieldField<Field, Type1>& f1,                                        \
+    const tmp<FieldField<Field, Type2>>& tf2,                                  \
+    const FieldField<Field, Type3>& f3                                         \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const FieldField<Field, Type1>& f1,                                        \
+    const FieldField<Field, Type2>& f2,                                        \
+    const tmp<FieldField<Field, Type3>>& tf3                                   \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const tmp<FieldField<Field, Type1>>& tf1,                                  \
+    const tmp<FieldField<Field, Type2>>& tf2,                                  \
+    const FieldField<Field, Type3>& f3                                         \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const tmp<FieldField<Field, Type1>>& tf1,                                  \
+    const FieldField<Field, Type2>& f2,                                        \
+    const tmp<FieldField<Field, Type3>>& tf3                                   \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const FieldField<Field, Type1>& f1,                                        \
+    const tmp<FieldField<Field, Type2>>& tf2,                                  \
+    const tmp<FieldField<Field, Type3>>& tf3                                   \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const tmp<FieldField<Field, Type1>>& tf1,                                  \
+    const tmp<FieldField<Field, Type2>>& tf2,                                  \
+    const tmp<FieldField<Field, Type3>>& tf3                                   \
+);
+
+
+#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func)       \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    FieldField<Field, ReturnType>& result,                                     \
+    const FieldField<Field, Type1>& f1,                                        \
+    const FieldField<Field, Type2>& f2,                                        \
+    const Type3& s3                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const FieldField<Field, Type1>& f1,                                        \
+    const FieldField<Field, Type2>& f2,                                        \
+    const Type3& s3                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const tmp<FieldField<Field, Type1>>& tf1,                                  \
+    const FieldField<Field, Type2>& f2,                                        \
+    const Type3& s3                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const FieldField<Field, Type1>& f1,                                        \
+    const tmp<FieldField<Field, Type2>>& tf2,                                  \
+    const Type3& s3                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<FieldField<Field, ReturnType>> Func                                        \
+(                                                                              \
+    const tmp<FieldField<Field, Type1>>& tf1,                                  \
+    const tmp<FieldField<Field, Type2>>& tf2,                                  \
+    const Type3& s3                                                            \
+);
+
+
 // ************************************************************************* //
diff --git a/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C b/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
index 4a4e8d1177..583c443971 100644
--- a/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
+++ b/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
@@ -741,6 +741,11 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
 
 BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clip)  // Same as clamp
 
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
+TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
+
 
 /* * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * */
 
diff --git a/src/OpenFOAM/fields/Fields/Field/FieldFunctions.H b/src/OpenFOAM/fields/Fields/Field/FieldFunctions.H
index 9307b9d155..6ed4076872 100644
--- a/src/OpenFOAM/fields/Fields/Field/FieldFunctions.H
+++ b/src/OpenFOAM/fields/Fields/Field/FieldFunctions.H
@@ -317,6 +317,11 @@ BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
 BINARY_TYPE_FUNCTION_FS(Type, Type, Foam::zero_one, clamp)
 BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clip)  // Same as clamp
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
+TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
+
 
 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.C b/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.C
index e82f2e6345..39829843ab 100644
--- a/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.C
+++ b/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.C
@@ -438,4 +438,215 @@ tmp<Field<ReturnType>> operator Op                                             \
     BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc)
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func)                \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    Field<ReturnType>& result,                                                 \
+    const UList<Type1>& f1,                                                    \
+    const UList<Type2>& f2,                                                    \
+    const UList<Type3>& f3                                                     \
+)                                                                              \
+{                                                                              \
+    TFOR_ALL_F_OP_FUNC_F_F_F                                                   \
+    (                                                                          \
+        ReturnType, result, =, ::Foam::Func, Type1, f1, Type2, f2, Type3, f3   \
+    )                                                                          \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const UList<Type1>& f1,                                                    \
+    const UList<Type2>& f2,                                                    \
+    const UList<Type3>& f3                                                     \
+)                                                                              \
+{                                                                              \
+    auto tres = tmp<Field<ReturnType>>::New(f1.size());                        \
+    Func(tres.ref(), f1, f2, f3);                                              \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const tmp<Field<Type1>>& tf1,                                              \
+    const UList<Type2>& f2,                                                    \
+    const UList<Type3>& f3                                                     \
+)                                                                              \
+{                                                                              \
+    auto tres = reuseTmp<ReturnType, Type1>::New(tf1);                         \
+    Func(tres.ref(), tf1(), f2, f3);                                           \
+    tf1.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const UList<Type1>& f1,                                                    \
+    const tmp<Field<Type2>>& tf2,                                              \
+    const UList<Type3>& f3                                                     \
+)                                                                              \
+{                                                                              \
+    auto tres = reuseTmp<ReturnType, Type2>::New(tf2);                         \
+    Func(tres.ref(), f1, tf2(), f3);                                           \
+    tf2.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const UList<Type1>& f1,                                                    \
+    const UList<Type2>& f2,                                                    \
+    const tmp<Field<Type3>>& tf3                                               \
+)                                                                              \
+{                                                                              \
+    auto tres = reuseTmp<ReturnType, Type3>::New(tf3);                         \
+    Func(tres.ref(), f1, f2, tf3());                                           \
+    tf3.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const tmp<Field<Type1>>& tf1,                                              \
+    const tmp<Field<Type2>>& tf2,                                              \
+    const UList<Type3>& f3                                                     \
+)                                                                              \
+{                                                                              \
+    auto tres = reuseTmpTmp<ReturnType, Type1, Type1, Type2>::New(tf1, tf2);   \
+    Func(tres.ref(), tf1(), tf2(), f3);                                        \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const tmp<Field<Type1>>& tf1,                                              \
+    const UList<Type2>& f2,                                                    \
+    const tmp<Field<Type3>>& tf3                                               \
+)                                                                              \
+{                                                                              \
+    auto tres = reuseTmpTmp<ReturnType, Type1, Type1, Type3>::New(tf1, tf3);   \
+    Func(tres.ref(), tf1(), f2, tf3());                                        \
+    tf1.clear();                                                               \
+    tf3.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const UList<Type1>& f1,                                                    \
+    const tmp<Field<Type2>>& tf2,                                              \
+    const tmp<Field<Type3>>& tf3                                               \
+)                                                                              \
+{                                                                              \
+    auto tres = reuseTmpTmp<ReturnType, Type2, Type2, Type3>::New(tf2, tf3);   \
+    Func(tres.ref(), f1, tf2(), tf3());                                        \
+    tf2.clear();                                                               \
+    tf3.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const tmp<Field<Type1>>& tf1,                                              \
+    const tmp<Field<Type2>>& tf2,                                              \
+    const tmp<Field<Type3>>& tf3                                               \
+)                                                                              \
+{                                                                              \
+    /* TBD: check all three types? */                                          \
+    auto tres = reuseTmpTmp<ReturnType, Type1, Type1, Type2>::New(tf1, tf2);   \
+    Func(tres.ref(), tf1(), tf2(), tf3());                                     \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
+    tf3.clear();                                                               \
+    return tres;                                                               \
+}
+
+
+#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func)       \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    Field<ReturnType>& result,                                                 \
+    const UList<Type1>& f1,                                                    \
+    const UList<Type2>& f2,                                                    \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    TFOR_ALL_F_OP_FUNC_F_F_S                                                   \
+    (                                                                          \
+        ReturnType, result, =, ::Foam::Func, Type1, f1, Type2, f2, Type3, s3   \
+    )                                                                          \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const UList<Type1>& f1,                                                    \
+    const UList<Type2>& f2,                                                    \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    auto tres = tmp<Field<ReturnType>>::New(f1.size());                        \
+    Func(tres.ref(), f1, f2, s3);                                              \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const tmp<Field<Type1>>& tf1,                                              \
+    const UList<Type2>& f2,                                                    \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    auto tres = reuseTmp<ReturnType, Type1>::New(tf1);                         \
+    Func(tres.ref(), tf1(), f2, s3);                                           \
+    tf1.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const UList<Type1>& f1,                                                    \
+    const tmp<Field<Type2>>& tf2,                                              \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    auto tres = reuseTmp<ReturnType, Type2>::New(tf2);                         \
+    Func(tres.ref(), f1, tf2(), s3);                                           \
+    tf2.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const tmp<Field<Type1>>& tf1,                                              \
+    const tmp<Field<Type2>>& tf2,                                              \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    auto tres = reuseTmpTmp<ReturnType, Type1, Type1, Type2>::New(tf1, tf2);   \
+    Func(tres.ref(), tf1(), tf2(), s3);                                        \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
+    return tres;                                                               \
+}
+
+
 // ************************************************************************* //
diff --git a/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.H b/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.H
index 1730ad22ba..e8fcb52c5e 100644
--- a/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.H
+++ b/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.H
@@ -270,4 +270,136 @@ tmp<Field<ReturnType>> operator Op                                             \
     BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc)
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func)                \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    Field<ReturnType>& result,                                                 \
+    const UList<Type1>& f1,                                                    \
+    const UList<Type2>& f2,                                                    \
+    const UList<Type3>& f3                                                     \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const UList<Type1>& f1,                                                    \
+    const UList<Type2>& f2,                                                    \
+    const UList<Type3>& f3                                                     \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const tmp<Field<Type1>>& tf1,                                              \
+    const UList<Type2>& f2,                                                    \
+    const UList<Type3>& f3                                                     \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const UList<Type1>& f1,                                                    \
+    const tmp<Field<Type2>>& tf2,                                              \
+    const UList<Type3>& f3                                                     \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const UList<Type1>& f1,                                                    \
+    const UList<Type2>& f2,                                                    \
+    const tmp<Field<Type3>>& tf3                                               \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const tmp<Field<Type1>>& tf1,                                              \
+    const tmp<Field<Type2>>& tf2,                                              \
+    const UList<Type3>& f3                                                     \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const tmp<Field<Type1>>& tf1,                                              \
+    const UList<Type2>& f2,                                                    \
+    const tmp<Field<Type3>>& tf3                                               \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const UList<Type1>& f1,                                                    \
+    const tmp<Field<Type2>>& tf2,                                              \
+    const tmp<Field<Type3>>& tf3                                               \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const tmp<Field<Type1>>& tf1,                                              \
+    const tmp<Field<Type2>>& tf2,                                              \
+    const tmp<Field<Type3>>& tf3                                               \
+);
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Permutations of ternary functions taking non-field argument(s)
+//
+// FFS (defined)
+// FSF (not defined)
+// SFF (not defined)
+// SSF (not defined)
+// SFS (not defined)
+// FSS (not defined)
+
+#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func)       \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    Field<ReturnType>& result,                                                 \
+    const UList<Type1>& f1,                                                    \
+    const UList<Type2>& f2,                                                    \
+    const Type3& s3                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const UList<Type1>& f1,                                                    \
+    const UList<Type2>& f2,                                                    \
+    const Type3& s3                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const tmp<Field<Type1>>& tf1,                                              \
+    const UList<Type2>& f2,                                                    \
+    const Type3& s3                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const UList<Type1>& f1,                                                    \
+    const tmp<Field<Type2>>& tf2,                                              \
+    const Type3& s3                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<Field<ReturnType>> Func                                                    \
+(                                                                              \
+    const tmp<Field<Type1>>& tf1,                                              \
+    const tmp<Field<Type2>>& tf2,                                              \
+    const Type3& s3                                                            \
+);
+
+
 // ************************************************************************* //
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.C b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.C
index a62fd98b54..18d2b0cdeb 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.C
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.C
@@ -548,6 +548,12 @@ clamp
 BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
+TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
+
+
 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 
 UNARY_OPERATOR(Type, Type, -, negate, transform)
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.H b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.H
index 937a07e443..65863a90c0 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.H
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.H
@@ -304,6 +304,12 @@ clamp
 BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
+TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
+
+
 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 
 UNARY_OPERATOR(Type, Type, -, negate, transform)
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.C b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.C
index 97b916586a..d8e5ec5b92 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.C
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.C
@@ -732,6 +732,407 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func)                \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const GeometricField<Type3, PatchField, GeoMesh>& f3                       \
+)                                                                              \
+{                                                                              \
+    Foam::Func                                                                 \
+    (                                                                          \
+        result.primitiveFieldRef(),                                            \
+        f1.primitiveField(),                                                   \
+        f2.primitiveField(),                                                   \
+        f3.primitiveField()                                                    \
+    );                                                                         \
+    Foam::Func                                                                 \
+    (                                                                          \
+        result.boundaryFieldRef(),                                             \
+        f1.boundaryField(),                                                    \
+        f2.boundaryField(),                                                    \
+        f3.boundaryField()                                                     \
+    );                                                                         \
+    result.oriented() = Func(f1.oriented(), f2.oriented());                    \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const GeometricField<Type3, PatchField, GeoMesh>& f3                       \
+)                                                                              \
+{                                                                              \
+    auto tres =                                                                \
+        reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New    \
+        (                                                                      \
+            f1,                                                                \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + f3.name() + ')',   \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Foam::Func(tres.ref(), f1, f2, f3);                                        \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const GeometricField<Type3, PatchField, GeoMesh>& f3                       \
+)                                                                              \
+{                                                                              \
+    const auto& f1 = tf1();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New    \
+        (                                                                      \
+            f1,                                                                \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + f3.name() + ')',   \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Foam::Func(tres.ref(), f1, f2, f3);                                        \
+    tf1.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,                \
+    const GeometricField<Type3, PatchField, GeoMesh>& f3                       \
+)                                                                              \
+{                                                                              \
+    const auto& f2 = tf2();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New    \
+        (                                                                      \
+            f2,                                                                \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + f3.name() + ')',   \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Foam::Func(tres.ref(), f1, f2, f3);                                        \
+    tf2.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const tmp<GeometricField<Type3, PatchField, GeoMesh>>& tf3                 \
+)                                                                              \
+{                                                                              \
+    const auto& f3 = tf3();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpGeometricField<ReturnType, Type3, PatchField, GeoMesh>::New    \
+        (                                                                      \
+            f3,                                                                \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + f3.name() + ')',   \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Foam::Func(tres.ref(), f1, f2, f3);                                        \
+    tf3.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,                \
+    const GeometricField<Type3, PatchField, GeoMesh>& f3                       \
+)                                                                              \
+{                                                                              \
+    const auto& f1 = tf1();                                                    \
+    const auto& f2 = tf2();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpTmpGeometricField                                              \
+            <ReturnType, Type1, Type1, Type2, PatchField, GeoMesh>             \
+        ::New                                                                  \
+        (                                                                      \
+            tf1,                                                               \
+            tf2,                                                               \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + f3.name() + ')',   \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Foam::Func(tres.ref(), f1, f2, f3);                                        \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const tmp<GeometricField<Type3, PatchField, GeoMesh>>& tf3                 \
+)                                                                              \
+{                                                                              \
+    const auto& f1 = tf1();                                                    \
+    const auto& f3 = tf3();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpTmpGeometricField                                              \
+            <ReturnType, Type1, Type1, Type3, PatchField, GeoMesh>             \
+        ::New                                                                  \
+        (                                                                      \
+            tf1,                                                               \
+            tf3,                                                               \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + f3.name() + ')',   \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Foam::Func(tres.ref(), f1, f2, f3);                                        \
+    tf1.clear();                                                               \
+    tf3.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,                \
+    const tmp<GeometricField<Type3, PatchField, GeoMesh>>& tf3                 \
+)                                                                              \
+{                                                                              \
+    const auto& f2 = tf2();                                                    \
+    const auto& f3 = tf3();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpTmpGeometricField                                              \
+            <ReturnType, Type2, Type2, Type3, PatchField, GeoMesh>             \
+        ::New                                                                  \
+        (                                                                      \
+            tf2,                                                               \
+            tf3,                                                               \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + f3.name() + ')',   \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Foam::Func(tres.ref(), f1, f2, f3);                                        \
+    tf2.clear();                                                               \
+    tf3.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,                \
+    const tmp<GeometricField<Type3, PatchField, GeoMesh>>& tf3                 \
+)                                                                              \
+{                                                                              \
+    const auto& f1 = tf1();                                                    \
+    const auto& f2 = tf2();                                                    \
+    const auto& f3 = tf3();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpTmpGeometricField                                              \
+            <ReturnType, Type1, Type1, Type2, PatchField, GeoMesh>             \
+        ::New                                                                  \
+        (                                                                      \
+            tf1,                                                               \
+            tf2,                                                               \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + f3.name() + ')',   \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Foam::Func(tres.ref(), f1, f2, f3);                                        \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
+    tf3.clear();                                                               \
+    return tres;                                                               \
+}
+
+
+#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func)       \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    GeometricField<ReturnType, PatchField, GeoMesh>& result,                   \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const dimensioned<Type3>& dt3                                              \
+)                                                                              \
+{                                                                              \
+    Foam::Func                                                                 \
+    (                                                                          \
+        result.primitiveFieldRef(),                                            \
+        f1.primitiveField(),                                                   \
+        f2.primitiveField(),                                                   \
+        dt3.value()                                                            \
+    );                                                                         \
+    Foam::Func                                                                 \
+    (                                                                          \
+        result.boundaryFieldRef(),                                             \
+        f1.boundaryField(),                                                    \
+        f2.boundaryField(),                                                    \
+        dt3.value()                                                            \
+    );                                                                         \
+    result.oriented() = Func(f1.oriented(), f2.oriented());                    \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const dimensioned<Type3>& dt3                                              \
+)                                                                              \
+{                                                                              \
+    auto tres =                                                                \
+        reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New    \
+        (                                                                      \
+            f1,                                                                \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + dt3.name() + ')',  \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Foam::Func(tres.ref(), f1, f2, dt3.value());                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    return Foam::Func(f1, f2, dimensioned<Type>(s3));                          \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const dimensioned<Type3>& dt3                                              \
+)                                                                              \
+{                                                                              \
+    const auto& f1 = tf1();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New    \
+        (                                                                      \
+            f1,                                                                \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + dt3.name() + ')',  \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Foam::Func(tres.ref(), f1, f2, dt3.value());                               \
+    tf1.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    return Foam::Func(tf1, f2, dimensioned<Type>(s3));                         \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,                \
+    const dimensioned<Type3>& dt3                                              \
+)                                                                              \
+{                                                                              \
+    const auto& f2 = tf2();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New    \
+        (                                                                      \
+            tf2,                                                               \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + dt3.name() + ')',  \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Foam::Func(tres.ref(), f1, f2, dt3.value());                               \
+    tf2.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,                \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    return Foam::Func(f1, tf2, dimensioned<Type>(s3));                         \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,                \
+    const dimensioned<Type3>& dt3                                              \
+)                                                                              \
+{                                                                              \
+    const auto& f1 = tf1();                                                    \
+    const auto& f2 = tf2();                                                    \
+                                                                               \
+    auto tres =                                                                \
+        reuseTmpTmpGeometricField                                              \
+            <ReturnType, Type1, Type1, Type2, PatchField, GeoMesh>             \
+        ::New                                                                  \
+        (                                                                      \
+            tf1,                                                               \
+            tf2,                                                               \
+            #Func "(" + f1.name() + ',' + f2.name() + ',' + dt3.name() + ')',  \
+            Func(f1.dimensions(), f2.dimensions())                             \
+        );                                                                     \
+                                                                               \
+    Foam::Func(tres.ref(), f1, f2, dt3.value());                               \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
+    return tres;                                                               \
+}                                                                              \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,                \
+    const Type3& s3                                                            \
+)                                                                              \
+{                                                                              \
+    return Foam::Func(tf1, tf2, dimensioned<Type>(s3));                        \
+}
+
+
+// ************************************************************************* //
+
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.H b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.H
index 0af9f5159d..259e1cbea0 100644
--- a/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.H
+++ b/src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.H
@@ -326,4 +326,158 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op               \
     BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc)
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func)                \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    GeometricField<Type1, PatchField, GeoMesh>& result,                        \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const GeometricField<Type3, PatchField, GeoMesh>& f3                       \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const GeometricField<Type3, PatchField, GeoMesh>& f3                       \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const GeometricField<Type3, PatchField, GeoMesh>& f3                       \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,                \
+    const GeometricField<Type3, PatchField, GeoMesh>& f3                       \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const tmp<GeometricField<Type3, PatchField, GeoMesh>>& tf3                 \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,                \
+    const GeometricField<Type3, PatchField, GeoMesh>& f3                       \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const tmp<GeometricField<Type3, PatchField, GeoMesh>>& tf3                 \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,                \
+    const tmp<GeometricField<Type3, PatchField, GeoMesh>>& tf3                 \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,                \
+    const tmp<GeometricField<Type3, PatchField, GeoMesh>>& tf3                 \
+);
+
+
+#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func)       \
+                                                                               \
+TEMPLATE                                                                       \
+void Func                                                                      \
+(                                                                              \
+    GeometricField<Type1, PatchField, GeoMesh>& result,                        \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const dimensioned<Type3>& dt3                                              \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const dimensioned<Type3>& dt3                                              \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const Type3& s3                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const dimensioned<Type3>& dt3                                              \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const GeometricField<Type2, PatchField, GeoMesh>& f2,                      \
+    const Type3& s3                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,                \
+    const dimensioned<Type3>& dt3                                              \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const GeometricField<Type1, PatchField, GeoMesh>& f1,                      \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,                \
+    const Type3& s3                                                            \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,                \
+    const dimensioned<Type3>& dt3                                              \
+);                                                                             \
+                                                                               \
+TEMPLATE                                                                       \
+tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func                      \
+(                                                                              \
+    const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,                \
+    const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,                \
+    const Type3& s3                                                            \
+);
+
+
 // ************************************************************************* //

From 70d526cd82f2788886bbe7b7802c9555e22c35a1 Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@esi-group.com>
Date: Thu, 19 Jan 2023 16:12:49 +0100
Subject: [PATCH 06/11] ENH: neg(x) instead of '1 - pos0(x)' for less-than 0
 check

- fewer operations

ENH: replace 'neg(x)*a + pos0(x)*b' with 'lerp(a, b, pos0(x))'

- uses pos0 as a 0-1 selector. Fewer operations.
---
 etc/codeTemplates/BC/BC.C                                | 2 +-
 .../DES/SpalartAllmarasIDDES/SpalartAllmarasIDDES.C      | 4 ++--
 .../turbulenceModels/DES/kOmegaSSTIDDES/kOmegaSSTIDDES.C | 4 ++--
 ...tMixingLengthDissipationRateInletFvPatchScalarField.C | 2 +-
 ...rbulentMixingLengthFrequencyInletFvPatchScalarField.C | 2 +-
 .../derived/inletOutlet/inletOutletFaPatchField.C        | 2 +-
 .../SRFFreestreamVelocityFvPatchVectorField.C            | 2 +-
 .../derived/inletOutlet/inletOutletFvPatchField.C        | 2 +-
 .../inletOutletTotalTemperatureFvPatchScalarField.C      | 4 ++--
 .../plenumPressure/plenumPressureFvPatchScalarField.C    | 9 +++++++--
 ...essureDirectedInletOutletVelocityFvPatchVectorField.C | 2 +-
 ...ressureInletOutletParSlipVelocityFvPatchVectorField.C | 2 +-
 ...pressureNormalInletOutletVelocityFvPatchVectorField.C | 2 +-
 ...PermeableAlphaInletOutletVelocityFvPatchVectorField.C | 2 +-
 .../prghPermeableAlphaTotalPressureFvPatchScalarField.C  | 2 +-
 .../prghTotalHydrostaticPressureFvPatchScalarField.C     | 2 +-
 .../prghTotalPressureFvPatchScalarField.C                | 2 +-
 .../totalPressure/totalPressureFvPatchScalarField.C      | 8 ++++----
 .../totalTemperatureFvPatchScalarField.C                 | 2 +-
 ...bulentIntensityKineticEnergyInletFvPatchScalarField.C | 2 +-
 .../uniformInletOutlet/uniformInletOutletFvPatchField.C  | 2 +-
 .../uniformTotalPressureFvPatchScalarField.C             | 8 ++++----
 .../geometricVoF/cellCuts/cutFace/cutFaceAdvect.C        | 8 ++++----
 23 files changed, 41 insertions(+), 36 deletions(-)

diff --git a/etc/codeTemplates/BC/BC.C b/etc/codeTemplates/BC/BC.C
index 7c1bb0e8d6..7dc8098b37 100644
--- a/etc/codeTemplates/BC/BC.C
+++ b/etc/codeTemplates/BC/BC.C
@@ -207,7 +207,7 @@ void Foam::CLASS::updateCoeffs()
     const scalarField& phip =
         this->patch().template lookupPatchField<surfaceScalarField>("phi");
 
-    this->valueFraction() = 1.0 - pos0(phip);
+    this->valueFraction() = neg(phip);
 
     PARENT::updateCoeffs();
 }
diff --git a/src/TurbulenceModels/turbulenceModels/DES/SpalartAllmarasIDDES/SpalartAllmarasIDDES.C b/src/TurbulenceModels/turbulenceModels/DES/SpalartAllmarasIDDES/SpalartAllmarasIDDES.C
index 514c894e5a..f930a4c3cb 100644
--- a/src/TurbulenceModels/turbulenceModels/DES/SpalartAllmarasIDDES/SpalartAllmarasIDDES.C
+++ b/src/TurbulenceModels/turbulenceModels/DES/SpalartAllmarasIDDES/SpalartAllmarasIDDES.C
@@ -113,7 +113,7 @@ tmp<volScalarField> SpalartAllmarasIDDES<BasicTurbulenceModel>::dTilda
     if (fe_)
     {
         tmp<volScalarField> fe1 =
-            2*(pos0(alpha)*pow(expTerm, -11.09) + neg(alpha)*pow(expTerm, -9.));
+            2*lerp(pow(expTerm, -9.), pow(expTerm, -11.09), pos0(alpha));
         tmp<volScalarField> fe2 = 1 - max(ft(magGradU), fl(magGradU));
         tmp<volScalarField> fe = max(fe1 - 1, scalar(0))*psi*fe2;
 
@@ -129,7 +129,7 @@ tmp<volScalarField> SpalartAllmarasIDDES<BasicTurbulenceModel>::dTilda
     // Simplified formulation from Gritskevich et al. paper (2011) where fe = 0
     return max
     (
-        fdTilda*lRAS + (1 - fdTilda)*lLES,
+        lerp(lLES, lRAS, fdTilda),
         dimensionedScalar("SMALL", dimLength, SMALL)
     );
 }
diff --git a/src/TurbulenceModels/turbulenceModels/DES/kOmegaSSTIDDES/kOmegaSSTIDDES.C b/src/TurbulenceModels/turbulenceModels/DES/kOmegaSSTIDDES/kOmegaSSTIDDES.C
index 42c5691e26..be6e5cafd2 100644
--- a/src/TurbulenceModels/turbulenceModels/DES/kOmegaSSTIDDES/kOmegaSSTIDDES.C
+++ b/src/TurbulenceModels/turbulenceModels/DES/kOmegaSSTIDDES/kOmegaSSTIDDES.C
@@ -109,7 +109,7 @@ tmp<volScalarField> kOmegaSSTIDDES<BasicTurbulenceModel>::dTilda
     if (fe_)
     {
         tmp<volScalarField> fe1 =
-            2*(pos0(alpha)*pow(expTerm, -11.09) + neg(alpha)*pow(expTerm, -9.));
+            2*lerp(pow(expTerm, -9.), pow(expTerm, -11.09), pos0(alpha));
         tmp<volScalarField> fe2 = 1 - max(ft(magGradU), fl(magGradU));
         tmp<volScalarField> fe = max(fe1 - 1, scalar(0))*fe2;
 
@@ -124,7 +124,7 @@ tmp<volScalarField> kOmegaSSTIDDES<BasicTurbulenceModel>::dTilda
     // Simplified formulation from Gritskevich et al. paper (2011) where fe = 0
     return max
     (
-        fdTilda*lRAS + (1 - fdTilda)*lLES,
+        lerp(lLES, lRAS, fdTilda),
         dimensionedScalar(dimLength, SMALL)
     );
 }
diff --git a/src/TurbulenceModels/turbulenceModels/RAS/derivedFvPatchFields/turbulentMixingLengthDissipationRateInlet/turbulentMixingLengthDissipationRateInletFvPatchScalarField.C b/src/TurbulenceModels/turbulenceModels/RAS/derivedFvPatchFields/turbulentMixingLengthDissipationRateInlet/turbulentMixingLengthDissipationRateInletFvPatchScalarField.C
index 2266a1430a..dfdff55615 100644
--- a/src/TurbulenceModels/turbulenceModels/RAS/derivedFvPatchFields/turbulentMixingLengthDissipationRateInlet/turbulentMixingLengthDissipationRateInletFvPatchScalarField.C
+++ b/src/TurbulenceModels/turbulenceModels/RAS/derivedFvPatchFields/turbulentMixingLengthDissipationRateInlet/turbulentMixingLengthDissipationRateInletFvPatchScalarField.C
@@ -157,7 +157,7 @@ void turbulentMixingLengthDissipationRateInletFvPatchScalarField::updateCoeffs()
         patch().lookupPatchField<surfaceScalarField>(this->phiName_);
 
     this->refValue() = (Cmu75/mixingLength_)*pow(kp, 1.5);
-    this->valueFraction() = 1.0 - pos0(phip);
+    this->valueFraction() = neg(phip);
 
     inletOutletFvPatchScalarField::updateCoeffs();
 }
diff --git a/src/TurbulenceModels/turbulenceModels/RAS/derivedFvPatchFields/turbulentMixingLengthFrequencyInlet/turbulentMixingLengthFrequencyInletFvPatchScalarField.C b/src/TurbulenceModels/turbulenceModels/RAS/derivedFvPatchFields/turbulentMixingLengthFrequencyInlet/turbulentMixingLengthFrequencyInletFvPatchScalarField.C
index 084965c11c..1fec48c218 100644
--- a/src/TurbulenceModels/turbulenceModels/RAS/derivedFvPatchFields/turbulentMixingLengthFrequencyInlet/turbulentMixingLengthFrequencyInletFvPatchScalarField.C
+++ b/src/TurbulenceModels/turbulenceModels/RAS/derivedFvPatchFields/turbulentMixingLengthFrequencyInlet/turbulentMixingLengthFrequencyInletFvPatchScalarField.C
@@ -146,7 +146,7 @@ void turbulentMixingLengthFrequencyInletFvPatchScalarField::updateCoeffs()
         patch().lookupPatchField<surfaceScalarField>(this->phiName_);
 
     this->refValue() = sqrt(kp)/(Cmu25*mixingLength_);
-    this->valueFraction() = 1.0 - pos0(phip);
+    this->valueFraction() = neg(phip);
 
     inletOutletFvPatchScalarField::updateCoeffs();
 }
diff --git a/src/finiteArea/fields/faPatchFields/derived/inletOutlet/inletOutletFaPatchField.C b/src/finiteArea/fields/faPatchFields/derived/inletOutlet/inletOutletFaPatchField.C
index cf93fde241..9c9749be92 100644
--- a/src/finiteArea/fields/faPatchFields/derived/inletOutlet/inletOutletFaPatchField.C
+++ b/src/finiteArea/fields/faPatchFields/derived/inletOutlet/inletOutletFaPatchField.C
@@ -126,7 +126,7 @@ void Foam::inletOutletFaPatchField<Type>::updateCoeffs()
     const Field<scalar>& phip =
         this->patch().template lookupPatchField<edgeScalarField>(phiName_);
 
-    this->valueFraction() = 1.0 - pos(phip);
+    this->valueFraction() = neg(phip);
 
     mixedFaPatchField<Type>::updateCoeffs();
 }
diff --git a/src/finiteVolume/cfdTools/general/SRF/derivedFvPatchFields/SRFFreestreamVelocityFvPatchVectorField/SRFFreestreamVelocityFvPatchVectorField.C b/src/finiteVolume/cfdTools/general/SRF/derivedFvPatchFields/SRFFreestreamVelocityFvPatchVectorField/SRFFreestreamVelocityFvPatchVectorField.C
index bdd1de4779..da50a57f7e 100644
--- a/src/finiteVolume/cfdTools/general/SRF/derivedFvPatchFields/SRFFreestreamVelocityFvPatchVectorField/SRFFreestreamVelocityFvPatchVectorField.C
+++ b/src/finiteVolume/cfdTools/general/SRF/derivedFvPatchFields/SRFFreestreamVelocityFvPatchVectorField/SRFFreestreamVelocityFvPatchVectorField.C
@@ -152,7 +152,7 @@ void Foam::SRFFreestreamVelocityFvPatchVectorField::updateCoeffs()
     }
 
     // Set the inlet-outlet choice based on the direction of the freestream
-    valueFraction() = 1.0 - pos0(refValue() & patch().Sf());
+    valueFraction() = neg(refValue() & patch().Sf());
 
     mixedFvPatchField<vector>::updateCoeffs();
 }
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/inletOutlet/inletOutletFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/derived/inletOutlet/inletOutletFvPatchField.C
index cce6c7b6af..459620bf6b 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/inletOutlet/inletOutletFvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/inletOutlet/inletOutletFvPatchField.C
@@ -128,7 +128,7 @@ void Foam::inletOutletFvPatchField<Type>::updateCoeffs()
     const Field<scalar>& phip =
         this->patch().template lookupPatchField<surfaceScalarField>(phiName_);
 
-    this->valueFraction() = 1.0 - pos0(phip);
+    this->valueFraction() = neg(phip);
 
     mixedFvPatchField<Type>::updateCoeffs();
 }
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/inletOutletTotalTemperature/inletOutletTotalTemperatureFvPatchScalarField.C b/src/finiteVolume/fields/fvPatchFields/derived/inletOutletTotalTemperature/inletOutletTotalTemperatureFvPatchScalarField.C
index 84198f6e2e..4e25428a0b 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/inletOutletTotalTemperature/inletOutletTotalTemperatureFvPatchScalarField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/inletOutletTotalTemperature/inletOutletTotalTemperatureFvPatchScalarField.C
@@ -181,8 +181,8 @@ void Foam::inletOutletTotalTemperatureFvPatchScalarField::updateCoeffs()
     scalar gM1ByG = (gamma_ - 1.0)/gamma_;
 
     this->refValue() =
-        T0_/(1.0 + 0.5*psip*gM1ByG*(1.0 - pos0(phip))*magSqr(Up));
-    this->valueFraction() = 1.0 - pos0(phip);
+        T0_/(1.0 + 0.5*psip*gM1ByG*(neg(phip))*magSqr(Up));
+    this->valueFraction() = neg(phip);
 
     inletOutletFvPatchScalarField::updateCoeffs();
 }
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/plenumPressure/plenumPressureFvPatchScalarField.C b/src/finiteVolume/fields/fvPatchFields/derived/plenumPressure/plenumPressureFvPatchScalarField.C
index 67de38f255..364e24d3aa 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/plenumPressure/plenumPressureFvPatchScalarField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/plenumPressure/plenumPressureFvPatchScalarField.C
@@ -272,7 +272,12 @@ void Foam::plenumPressureFvPatchScalarField::updateCoeffs()
     // Limit to prevent outflow
     const scalarField p_new
     (
-        (1.0 - pos0(phi))*t*plenumPressure + pos0(phi)*max(p, plenumPressure)
+        lerp
+        (
+            t*plenumPressure,           // Negative phi
+            max(p, plenumPressure),     // Positive phi
+            pos0(phi)                   // 0-1 selector
+        )
     );
 
     // Relaxation fraction
@@ -280,7 +285,7 @@ void Foam::plenumPressureFvPatchScalarField::updateCoeffs()
     const scalar fraction = oneByFraction < 1.0 ? 1.0 : 1.0/oneByFraction;
 
     // Set the new value
-    operator==((1.0 - fraction)*p_old + fraction*p_new);
+    operator==(lerp(p_old, p_new, fraction));
     fixedValueFvPatchScalarField::updateCoeffs();
 }
 
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/pressureDirectedInletOutletVelocity/pressureDirectedInletOutletVelocityFvPatchVectorField.C b/src/finiteVolume/fields/fvPatchFields/derived/pressureDirectedInletOutletVelocity/pressureDirectedInletOutletVelocityFvPatchVectorField.C
index 4f1f1b5a4e..db7d962d81 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/pressureDirectedInletOutletVelocity/pressureDirectedInletOutletVelocityFvPatchVectorField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/pressureDirectedInletOutletVelocity/pressureDirectedInletOutletVelocityFvPatchVectorField.C
@@ -176,7 +176,7 @@ void Foam::pressureDirectedInletOutletVelocityFvPatchVectorField::updateCoeffs()
             << exit(FatalError);
     }
 
-    valueFraction() = 1.0 - pos0(phip);
+    valueFraction() = neg(phip);
 
     mixedFvPatchVectorField::updateCoeffs();
 }
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/pressureInletOutletParSlipVelocity/pressureInletOutletParSlipVelocityFvPatchVectorField.C b/src/finiteVolume/fields/fvPatchFields/derived/pressureInletOutletParSlipVelocity/pressureInletOutletParSlipVelocityFvPatchVectorField.C
index 6676732f48..d3b2100080 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/pressureInletOutletParSlipVelocity/pressureInletOutletParSlipVelocityFvPatchVectorField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/pressureInletOutletParSlipVelocity/pressureInletOutletParSlipVelocityFvPatchVectorField.C
@@ -150,7 +150,7 @@ void Foam::pressureInletOutletParSlipVelocityFvPatchVectorField::updateCoeffs()
             << exit(FatalError);
     }
 
-    valueFraction() = 1.0 - pos0(phip);
+    valueFraction() = neg(phip);
 
     mixedFvPatchVectorField::updateCoeffs();
 }
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/pressureNormalInletOutletVelocity/pressureNormalInletOutletVelocityFvPatchVectorField.C b/src/finiteVolume/fields/fvPatchFields/derived/pressureNormalInletOutletVelocity/pressureNormalInletOutletVelocityFvPatchVectorField.C
index 4b316b0e67..e6d254f67d 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/pressureNormalInletOutletVelocity/pressureNormalInletOutletVelocityFvPatchVectorField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/pressureNormalInletOutletVelocity/pressureNormalInletOutletVelocityFvPatchVectorField.C
@@ -146,7 +146,7 @@ void Foam::pressureNormalInletOutletVelocityFvPatchVectorField::updateCoeffs()
             << exit(FatalError);
     }
 
-    valueFraction() = 1.0 - pos0(phip);
+    valueFraction() = neg(phip);
 
     mixedFvPatchVectorField::updateCoeffs();
 }
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/pressurePermeableAlphaInletOutletVelocity/pressurePermeableAlphaInletOutletVelocityFvPatchVectorField.C b/src/finiteVolume/fields/fvPatchFields/derived/pressurePermeableAlphaInletOutletVelocity/pressurePermeableAlphaInletOutletVelocityFvPatchVectorField.C
index 5bfce07557..30fdd16204 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/pressurePermeableAlphaInletOutletVelocity/pressurePermeableAlphaInletOutletVelocityFvPatchVectorField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/pressurePermeableAlphaInletOutletVelocity/pressurePermeableAlphaInletOutletVelocityFvPatchVectorField.C
@@ -155,7 +155,7 @@ updateCoeffs()
             << exit(FatalError);
     }
 
-    valueFraction() = 1.0 - pos0(phip);
+    valueFraction() = neg(phip);
 
     if (alphaName_ != "none")
     {
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/prghPermeableAlphaTotalPressure/prghPermeableAlphaTotalPressureFvPatchScalarField.C b/src/finiteVolume/fields/fvPatchFields/derived/prghPermeableAlphaTotalPressure/prghPermeableAlphaTotalPressureFvPatchScalarField.C
index 6bc84ada0d..ecd795af13 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/prghPermeableAlphaTotalPressure/prghPermeableAlphaTotalPressureFvPatchScalarField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/prghPermeableAlphaTotalPressure/prghPermeableAlphaTotalPressureFvPatchScalarField.C
@@ -215,7 +215,7 @@ void Foam::prghPermeableAlphaTotalPressureFvPatchScalarField::updateSnGrad
     tmp<scalarField> p
     (
         p0_->value(t)
-      - 0.5*rhop*(1.0 - pos0(phip))*magSqr(Up)
+      - 0.5*rhop*(neg(phip))*magSqr(Up)
       - rhop*((g.value() & patch().Cf()) - ghRef.value())
     );
 
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/prghTotalHydrostaticPressure/prghTotalHydrostaticPressureFvPatchScalarField.C b/src/finiteVolume/fields/fvPatchFields/derived/prghTotalHydrostaticPressure/prghTotalHydrostaticPressureFvPatchScalarField.C
index 53fa406082..2360322800 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/prghTotalHydrostaticPressure/prghTotalHydrostaticPressureFvPatchScalarField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/prghTotalHydrostaticPressure/prghTotalHydrostaticPressureFvPatchScalarField.C
@@ -136,7 +136,7 @@ void Foam::prghTotalHydrostaticPressureFvPatchScalarField::updateCoeffs()
     operator==
     (
         ph_rghp
-      - 0.5*rhop*(1.0 - pos0(phip))*magSqr(Up)
+      - 0.5*rhop*(neg(phip))*magSqr(Up)
     );
 
     fixedValueFvPatchScalarField::updateCoeffs();
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/prghTotalPressure/prghTotalPressureFvPatchScalarField.C b/src/finiteVolume/fields/fvPatchFields/derived/prghTotalPressure/prghTotalPressureFvPatchScalarField.C
index 41fe07eee8..4e442c6c4e 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/prghTotalPressure/prghTotalPressureFvPatchScalarField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/prghTotalPressure/prghTotalPressureFvPatchScalarField.C
@@ -178,7 +178,7 @@ void Foam::prghTotalPressureFvPatchScalarField::updateCoeffs()
     operator==
     (
         p0_
-      - 0.5*rhop*(1.0 - pos0(phip))*magSqr(Up)
+      - 0.5*rhop*(neg(phip))*magSqr(Up)
       - rhop*((g.value() & patch().Cf()) - ghRef.value())
     );
 
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/totalPressure/totalPressureFvPatchScalarField.C b/src/finiteVolume/fields/fvPatchFields/derived/totalPressure/totalPressureFvPatchScalarField.C
index b3bcd97273..0bf923b69a 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/totalPressure/totalPressureFvPatchScalarField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/totalPressure/totalPressureFvPatchScalarField.C
@@ -178,7 +178,7 @@ void Foam::totalPressureFvPatchScalarField::updateCoeffs
             const auto& rho =
                 patch().lookupPatchField<volScalarField>(rhoName_);
 
-            operator==(p0p - 0.5*rho*(1.0 - pos0(phip))*magSqr(Up));
+            operator==(p0p - 0.5*rho*(neg(phip))*magSqr(Up));
         }
         else
         {
@@ -196,14 +196,14 @@ void Foam::totalPressureFvPatchScalarField::updateCoeffs
                     p0p
                    /pow
                     (
-                        (1.0 + 0.5*psip*gM1ByG*(1.0 - pos0(phip))*magSqr(Up)),
+                        (1.0 + 0.5*psip*gM1ByG*(neg(phip))*magSqr(Up)),
                         1.0/gM1ByG
                     )
                 );
             }
             else
             {
-                operator==(p0p/(1.0 + 0.5*psip*(1.0 - pos0(phip))*magSqr(Up)));
+                operator==(p0p/(1.0 + 0.5*psip*(neg(phip))*magSqr(Up)));
             }
         }
 
@@ -211,7 +211,7 @@ void Foam::totalPressureFvPatchScalarField::updateCoeffs
     else if (internalField().dimensions() == dimPressure/dimDensity)
     {
         // Incompressible flow
-        operator==(p0p - 0.5*(1.0 - pos0(phip))*magSqr(Up));
+        operator==(p0p - 0.5*(neg(phip))*magSqr(Up));
     }
     else
     {
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/totalTemperature/totalTemperatureFvPatchScalarField.C b/src/finiteVolume/fields/fvPatchFields/derived/totalTemperature/totalTemperatureFvPatchScalarField.C
index b6ad51dd07..b9cabaefc5 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/totalTemperature/totalTemperatureFvPatchScalarField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/totalTemperature/totalTemperatureFvPatchScalarField.C
@@ -170,7 +170,7 @@ void Foam::totalTemperatureFvPatchScalarField::updateCoeffs()
 
     operator==
     (
-        T0_/(1.0 + 0.5*psip*gM1ByG*(1.0 - pos0(phip))*magSqr(Up))
+        T0_/(1.0 + 0.5*psip*gM1ByG*(neg(phip))*magSqr(Up))
     );
 
     fixedValueFvPatchScalarField::updateCoeffs();
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/turbulentIntensityKineticEnergyInlet/turbulentIntensityKineticEnergyInletFvPatchScalarField.C b/src/finiteVolume/fields/fvPatchFields/derived/turbulentIntensityKineticEnergyInlet/turbulentIntensityKineticEnergyInletFvPatchScalarField.C
index 453e96a5f2..06f5809c0d 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/turbulentIntensityKineticEnergyInlet/turbulentIntensityKineticEnergyInletFvPatchScalarField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/turbulentIntensityKineticEnergyInlet/turbulentIntensityKineticEnergyInletFvPatchScalarField.C
@@ -140,7 +140,7 @@ updateCoeffs()
         patch().lookupPatchField<surfaceScalarField>(this->phiName_);
 
     this->refValue() = 1.5*sqr(intensity_)*magSqr(Up);
-    this->valueFraction() = 1.0 - pos0(phip);
+    this->valueFraction() = neg(phip);
 
     inletOutletFvPatchScalarField::updateCoeffs();
 }
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/uniformInletOutlet/uniformInletOutletFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/derived/uniformInletOutlet/uniformInletOutletFvPatchField.C
index d981820e78..3a54b9ce6e 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/uniformInletOutlet/uniformInletOutletFvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/uniformInletOutlet/uniformInletOutletFvPatchField.C
@@ -157,7 +157,7 @@ void Foam::uniformInletOutletFvPatchField<Type>::updateCoeffs()
             phiName_
         );
 
-    this->valueFraction() = 1.0 - pos0(phip);
+    this->valueFraction() = neg(phip);
 
     mixedFvPatchField<Type>::updateCoeffs();
 }
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/uniformTotalPressure/uniformTotalPressureFvPatchScalarField.C b/src/finiteVolume/fields/fvPatchFields/derived/uniformTotalPressure/uniformTotalPressureFvPatchScalarField.C
index 1ebfba5288..833c5e819b 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/uniformTotalPressure/uniformTotalPressureFvPatchScalarField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/uniformTotalPressure/uniformTotalPressureFvPatchScalarField.C
@@ -166,7 +166,7 @@ void Foam::uniformTotalPressureFvPatchScalarField::updateCoeffs
             const auto& rho =
                 patch().lookupPatchField<volScalarField>(rhoName_);
 
-            operator==(p0 - 0.5*rho*(1.0 - pos0(phip))*magSqr(Up));
+            operator==(p0 - 0.5*rho*(neg(phip))*magSqr(Up));
         }
         else
         {
@@ -184,14 +184,14 @@ void Foam::uniformTotalPressureFvPatchScalarField::updateCoeffs
                     p0
                    /pow
                     (
-                        (1.0 + 0.5*psip*gM1ByG*(1.0 - pos0(phip))*magSqr(Up)),
+                        (1.0 + 0.5*psip*gM1ByG*(neg(phip))*magSqr(Up)),
                         1.0/gM1ByG
                     )
                 );
             }
             else
             {
-                operator==(p0/(1.0 + 0.5*psip*(1.0 - pos0(phip))*magSqr(Up)));
+                operator==(p0/(1.0 + 0.5*psip*(neg(phip))*magSqr(Up)));
             }
         }
 
@@ -199,7 +199,7 @@ void Foam::uniformTotalPressureFvPatchScalarField::updateCoeffs
     else if (internalField().dimensions() == dimPressure/dimDensity)
     {
         // Incompressible flow
-        operator==(p0 - 0.5*(1.0 - pos0(phip))*magSqr(Up));
+        operator==(p0 - 0.5*(neg(phip))*magSqr(Up));
     }
     else
     {
diff --git a/src/transportModels/geometricVoF/cellCuts/cutFace/cutFaceAdvect.C b/src/transportModels/geometricVoF/cellCuts/cutFace/cutFaceAdvect.C
index 0f7dde785f..79b023edfe 100644
--- a/src/transportModels/geometricVoF/cellCuts/cutFace/cutFaceAdvect.C
+++ b/src/transportModels/geometricVoF/cellCuts/cutFace/cutFaceAdvect.C
@@ -412,7 +412,7 @@ Foam::scalar Foam::cutFaceAdvect::timeIntegratedArea
         // If all cuttings are in the future but non of them within [0,dt] then
         // if cell is filling up (Un0 > 0) face must be empty during whole time
         // interval
-        tIntArea = magSf * dt * (1 - pos0(Un0));
+        tIntArea = magSf * dt * neg(Un0);
         return tIntArea;
     }
 
@@ -437,7 +437,7 @@ Foam::scalar Foam::cutFaceAdvect::timeIntegratedArea
         // If Un0 > 0 cell is filling up and it must initially be empty.
         // If Un0 < 0 cell must initially be full(y immersed in fluid A).
         time = firstTime;
-        initialArea = magSf * (1.0 - pos0(Un0));
+        initialArea = magSf * neg(Un0);
         tIntArea = initialArea * time;
         cutPoints(fPts, pTimes, time, FIIL);
     }
@@ -669,7 +669,7 @@ Foam::scalar Foam::cutFaceAdvect::timeIntegratedArea
         // If all cuttings are in the future but non of them within [0,dt] then
         // if cell is filling up (Un0 > 0) face must be empty during whole time
         // interval
-        tIntArea = magSf * dt * (1 - pos0(Un0));
+        tIntArea = magSf * dt * neg(Un0);
         return tIntArea;
     }
 
@@ -694,7 +694,7 @@ Foam::scalar Foam::cutFaceAdvect::timeIntegratedArea
         // If Un0 > 0 cell is filling up and it must initially be empty.
         // If Un0 < 0 cell must initially be full(y immersed in fluid A).
         time = firstTime;
-        initialArea = magSf * (1.0 - pos0(Un0));
+        initialArea = magSf * neg(Un0);
         tIntArea = initialArea * time;
         cutPoints(faceI, time, FIIL);
     }

From 128516b8744b7aaf1b41d7ec1069e360632fa184 Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@esi-group.com>
Date: Thu, 19 Jan 2023 17:48:16 +0100
Subject: [PATCH 07/11] ENH: use lerp for valueFraction (mixed BCs) and field
 relaxation

Note:
  in some borderline cases (eg, PDRFoam) the multiplication order
  and rounding imposed by the lerp function may affect the
  results slightly.

  eg,  (valueFraction_ * this->patch().deltaCoeffs()*refValue_)
  vs.  (valueFraction_ * (this->patch().deltaCoeffs()*refValue_))
---
 .../basic/mixed/mixedFaPatchField.C           | 36 ++++++++++--------
 .../fvPatchFields/exprMixedFvPatchField.C     | 17 ++-------
 .../basic/mixed/mixedFvPatchField.C           | 38 +++++++++++--------
 .../derived/fixedJump/fixedJumpFvPatchField.C |  2 +-
 .../partialSlip/partialSlipFvPatchField.C     | 18 ++++++---
 ...aseHydrostaticPressureFvPatchScalarField.C |  2 +-
 ...tedInletOutletVelocityFvPatchVectorField.C |  5 +--
 ...malInletOutletVelocityFvPatchVectorField.C |  7 ++--
 ...phaInletOutletVelocityFvPatchVectorField.C |  5 +--
 ...allHeatFluxTemperatureFvPatchScalarField.C | 14 +++----
 10 files changed, 75 insertions(+), 69 deletions(-)

diff --git a/src/finiteArea/fields/faPatchFields/basic/mixed/mixedFaPatchField.C b/src/finiteArea/fields/faPatchFields/basic/mixed/mixedFaPatchField.C
index 226a11b02d..b1216ad42f 100644
--- a/src/finiteArea/fields/faPatchFields/basic/mixed/mixedFaPatchField.C
+++ b/src/finiteArea/fields/faPatchFields/basic/mixed/mixedFaPatchField.C
@@ -198,12 +198,11 @@ void Foam::mixedFaPatchField<Type>::evaluate(const Pstream::commsTypes)
 
     Field<Type>::operator=
     (
-        valueFraction_*refValue_
-      +
-        (1.0 - valueFraction_)*
+        lerp
         (
-            this->patchInternalField()
-          + refGrad_/this->patch().deltaCoeffs()
+            this->patchInternalField() + refGrad_/this->patch().deltaCoeffs(),
+            refValue_,
+            valueFraction_
         )
     );
 
@@ -214,11 +213,12 @@ void Foam::mixedFaPatchField<Type>::evaluate(const Pstream::commsTypes)
 template<class Type>
 Foam::tmp<Foam::Field<Type>> Foam::mixedFaPatchField<Type>::snGrad() const
 {
-    return
+    return lerp
+    (
+        refGrad_,
+        (refValue_ - this->patchInternalField())*this->patch().deltaCoeffs(),
         valueFraction_
-       *(refValue_ - this->patchInternalField())
-       *this->patch().deltaCoeffs()
-      + (1.0 - valueFraction_)*refGrad_;
+    );
 }
 
 
@@ -238,9 +238,12 @@ Foam::tmp<Foam::Field<Type>> Foam::mixedFaPatchField<Type>::valueBoundaryCoeffs
     const tmp<scalarField>&
 ) const
 {
-    return
-         valueFraction_*refValue_
-       + (1.0 - valueFraction_)*refGrad_/this->patch().deltaCoeffs();
+    return lerp
+    (
+        refGrad_/this->patch().deltaCoeffs(),
+        refValue_,
+        valueFraction_
+    );
 }
 
 
@@ -256,9 +259,12 @@ template<class Type>
 Foam::tmp<Foam::Field<Type>>
 Foam::mixedFaPatchField<Type>::gradientBoundaryCoeffs() const
 {
-    return
-        valueFraction_*this->patch().deltaCoeffs()*refValue_
-      + (1.0 - valueFraction_)*refGrad_;
+    return lerp
+    (
+        refGrad_,
+        this->patch().deltaCoeffs()*refValue_,
+        valueFraction_
+    );
 }
 
 
diff --git a/src/finiteVolume/expressions/fields/fvPatchFields/exprMixedFvPatchField.C b/src/finiteVolume/expressions/fields/fvPatchFields/exprMixedFvPatchField.C
index 10394092a8..acfa22fd2c 100644
--- a/src/finiteVolume/expressions/fields/fvPatchFields/exprMixedFvPatchField.C
+++ b/src/finiteVolume/expressions/fields/fvPatchFields/exprMixedFvPatchField.C
@@ -234,25 +234,14 @@ Foam::exprMixedFvPatchField<Type>::exprMixedFvPatchField
     }
     else
     {
-        // Emulate mixedFvPatchField<Type>::evaluate,
+        // Like mixedFvPatchField<Type>::evaluate()
         // but avoid our own updateCoeffs
         if (!this->updated())
         {
-            this->parent_bctype::updateCoeffs();
+            mixedFvPatchField<Type>::updateCoeffs();
         }
 
-        Field<Type>::operator=
-        (
-            this->valueFraction()*this->refValue()
-          +
-            (1.0 - this->valueFraction())*
-            (
-                this->patchInternalField()
-              + this->refGrad()/this->patch().deltaCoeffs()
-            )
-        );
-
-        fvPatchField<Type>::evaluate();
+        mixedFvPatchField<Type>::evaluate();
     }
 }
 
diff --git a/src/finiteVolume/fields/fvPatchFields/basic/mixed/mixedFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/basic/mixed/mixedFvPatchField.C
index 3aa783d5b6..4be6c72ed6 100644
--- a/src/finiteVolume/fields/fvPatchFields/basic/mixed/mixedFvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/basic/mixed/mixedFvPatchField.C
@@ -209,7 +209,6 @@ void Foam::mixedFvPatchField<Type>::rmap
 template<class Type>
 void Foam::mixedFvPatchField<Type>::evaluate(const Pstream::commsTypes)
 {
-
     if (!this->updated())
     {
         this->updateCoeffs();
@@ -217,11 +216,11 @@ void Foam::mixedFvPatchField<Type>::evaluate(const Pstream::commsTypes)
 
     Field<Type>::operator=
     (
-        valueFraction_*refValue_
-      + (1.0 - valueFraction_)
-       *(
-            this->patchInternalField()
-          + refGrad_/this->patch().deltaCoeffs()
+        lerp
+        (
+            this->patchInternalField() + refGrad_/this->patch().deltaCoeffs(),
+            refValue_,
+            valueFraction_
         )
     );
 
@@ -233,11 +232,12 @@ template<class Type>
 Foam::tmp<Foam::Field<Type>>
 Foam::mixedFvPatchField<Type>::snGrad() const
 {
-    return
+    return lerp
+    (
+        refGrad_,
+        (refValue_ - this->patchInternalField())*this->patch().deltaCoeffs(),
         valueFraction_
-       *(refValue_ - this->patchInternalField())
-       *this->patch().deltaCoeffs()
-      + (1.0 - valueFraction_)*refGrad_;
+    );
 }
 
 
@@ -259,9 +259,12 @@ Foam::mixedFvPatchField<Type>::valueBoundaryCoeffs
     const tmp<scalarField>&
 ) const
 {
-    return
-        valueFraction_*refValue_
-      + (1.0 - valueFraction_)*refGrad_/this->patch().deltaCoeffs();
+    return lerp
+    (
+        refGrad_/this->patch().deltaCoeffs(),
+        refValue_,
+        valueFraction_
+    );
 }
 
 
@@ -277,9 +280,12 @@ template<class Type>
 Foam::tmp<Foam::Field<Type>>
 Foam::mixedFvPatchField<Type>::gradientBoundaryCoeffs() const
 {
-    return
-        valueFraction_*this->patch().deltaCoeffs()*refValue_
-      + (1.0 - valueFraction_)*refGrad_;
+    return lerp
+    (
+        refGrad_,
+        this->patch().deltaCoeffs()*refValue_,
+        valueFraction_
+    );
 }
 
 
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/fixedJump/fixedJumpFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/derived/fixedJump/fixedJumpFvPatchField.C
index 0f38fdc737..e938771640 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/fixedJump/fixedJumpFvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/fixedJump/fixedJumpFvPatchField.C
@@ -212,7 +212,7 @@ void Foam::fixedJumpFvPatchField<Type>::relax()
         return;
     }
 
-    jump_ = relaxFactor_*jump_ + (1 - relaxFactor_)*jump0_;
+    jump_ = lerp(jump0_, jump_, relaxFactor_);
 
     if (timeIndex_ != this->db().time().timeIndex())
     {
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/partialSlip/partialSlipFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/derived/partialSlip/partialSlipFvPatchField.C
index 7f26c14fa9..0d343a904a 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/partialSlip/partialSlipFvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/partialSlip/partialSlipFvPatchField.C
@@ -153,8 +153,12 @@ Foam::partialSlipFvPatchField<Type>::snGrad() const
 
     return
     (
-        valueFraction_*refValue_
-      + (1.0 - valueFraction_)*transform(I - sqr(nHat), pif) - pif
+        lerp
+        (
+            transform(I - sqr(nHat), pif),
+            refValue_,
+            valueFraction_
+        ) - pif
     )*this->patch().deltaCoeffs();
 }
 
@@ -174,10 +178,12 @@ void Foam::partialSlipFvPatchField<Type>::evaluate
 
     Field<Type>::operator=
     (
-        valueFraction_*refValue_
-      +
-        (1.0 - valueFraction_)
-       *transform(I - sqr(nHat), this->patchInternalField())
+        lerp
+        (
+            transform(I - sqr(nHat), this->patchInternalField()),
+            refValue_,
+            valueFraction_
+        )
     );
 
     parent_bctype::evaluate();
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/phaseHydrostaticPressure/phaseHydrostaticPressureFvPatchScalarField.C b/src/finiteVolume/fields/fvPatchFields/derived/phaseHydrostaticPressure/phaseHydrostaticPressureFvPatchScalarField.C
index 1b6a532d22..a234a37342 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/phaseHydrostaticPressure/phaseHydrostaticPressureFvPatchScalarField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/phaseHydrostaticPressure/phaseHydrostaticPressureFvPatchScalarField.C
@@ -180,7 +180,7 @@ void Foam::phaseHydrostaticPressureFvPatchScalarField::operator=
 {
     fvPatchScalarField::operator=
     (
-        valueFraction()*refValue() + (1 - valueFraction())*ptf
+        lerp(ptf, refValue(), valueFraction())
     );
 }
 
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/pressureDirectedInletOutletVelocity/pressureDirectedInletOutletVelocityFvPatchVectorField.C b/src/finiteVolume/fields/fvPatchFields/derived/pressureDirectedInletOutletVelocity/pressureDirectedInletOutletVelocityFvPatchVectorField.C
index db7d962d81..b2cef93cf2 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/pressureDirectedInletOutletVelocity/pressureDirectedInletOutletVelocityFvPatchVectorField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/pressureDirectedInletOutletVelocity/pressureDirectedInletOutletVelocityFvPatchVectorField.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2017-2020 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -204,8 +204,7 @@ void Foam::pressureDirectedInletOutletVelocityFvPatchVectorField::operator=
 {
     fvPatchField<vector>::operator=
     (
-        valueFraction()*(inletDir_*(inletDir_ & pvf))
-      + (1 - valueFraction())*pvf
+        lerp(pvf, inletDir_*(inletDir_ & pvf), valueFraction())
     );
 }
 
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/pressureNormalInletOutletVelocity/pressureNormalInletOutletVelocityFvPatchVectorField.C b/src/finiteVolume/fields/fvPatchFields/derived/pressureNormalInletOutletVelocity/pressureNormalInletOutletVelocityFvPatchVectorField.C
index e6d254f67d..e0ea49b05d 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/pressureNormalInletOutletVelocity/pressureNormalInletOutletVelocityFvPatchVectorField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/pressureNormalInletOutletVelocity/pressureNormalInletOutletVelocityFvPatchVectorField.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2017-2020 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -171,10 +171,11 @@ void Foam::pressureNormalInletOutletVelocityFvPatchVectorField::operator=
     const fvPatchField<vector>& pvf
 )
 {
+    tmp<vectorField> n = patch().nf();
+
     fvPatchField<vector>::operator=
     (
-        valueFraction()*(patch().nf()*(patch().nf() & pvf))
-      + (1 - valueFraction())*pvf
+        lerp(pvf, n()*(n() & pvf), valueFraction())
     );
 }
 
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/pressurePermeableAlphaInletOutletVelocity/pressurePermeableAlphaInletOutletVelocityFvPatchVectorField.C b/src/finiteVolume/fields/fvPatchFields/derived/pressurePermeableAlphaInletOutletVelocity/pressurePermeableAlphaInletOutletVelocityFvPatchVectorField.C
index 30fdd16204..0a23414a40 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/pressurePermeableAlphaInletOutletVelocity/pressurePermeableAlphaInletOutletVelocityFvPatchVectorField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/pressurePermeableAlphaInletOutletVelocity/pressurePermeableAlphaInletOutletVelocityFvPatchVectorField.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021 OpenCFD Ltd.
+    Copyright (C) 2021-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -202,8 +202,7 @@ void Foam::pressurePermeableAlphaInletOutletVelocityFvPatchVectorField
 
     fvPatchField<vector>::operator=
     (
-        valueFraction()*(n()*(n() & pvf))
-      + (1 - valueFraction())*pvf
+        lerp(pvf, n()*(n() & pvf), valueFraction())
     );
 }
 
diff --git a/src/thermoTools/derivedFvPatchFields/externalWallHeatFluxTemperature/externalWallHeatFluxTemperatureFvPatchScalarField.C b/src/thermoTools/derivedFvPatchFields/externalWallHeatFluxTemperature/externalWallHeatFluxTemperatureFvPatchScalarField.C
index 90fc37d1e2..a409459da4 100644
--- a/src/thermoTools/derivedFvPatchFields/externalWallHeatFluxTemperature/externalWallHeatFluxTemperatureFvPatchScalarField.C
+++ b/src/thermoTools/derivedFvPatchFields/externalWallHeatFluxTemperature/externalWallHeatFluxTemperatureFvPatchScalarField.C
@@ -317,11 +317,12 @@ void Foam::externalWallHeatFluxTemperatureFvPatchScalarField::updateCoeffs()
     scalarField qr(Tp.size(), Zero);
     if (qrName_ != "none")
     {
-        qr =
+        qr = lerp
+        (
+            qrPrevious_,
+            patch().lookupPatchField<volScalarField>(qrName_),
             qrRelaxation_
-           *patch().lookupPatchField<volScalarField>(qrName_)
-          + (1 - qrRelaxation_)*qrPrevious_;
-
+        );
         qrPrevious_ = qr;
     }
 
@@ -454,9 +455,8 @@ void Foam::externalWallHeatFluxTemperatureFvPatchScalarField::updateCoeffs()
         }
     }
 
-    valueFraction() =
-        relaxation_*valueFraction() + (1 - relaxation_)*valueFraction0;
-    refValue() = relaxation_*refValue() + (1 - relaxation_)*refValue0;
+    valueFraction() = lerp(valueFraction0, valueFraction(), relaxation_);
+    refValue() = lerp(refValue0, refValue(), relaxation_);
 
     mixedFvPatchScalarField::updateCoeffs();
 

From 4d45cfd5a94a2117bb91bf6276453074b1ef0fe0 Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@esi-group.com>
Date: Fri, 20 Jan 2023 11:55:12 +0100
Subject: [PATCH 08/11] ENH: lerp for patch/neighbour weights

---
 .../basic/coupled/coupledFaPatchField.C             |  8 ++++++--
 .../edgeInterpolation/schemes/Gamma/Gamma.H         |  2 +-
 .../basic/coupled/coupledFvPatchField.C             |  8 ++++++--
 .../surfaceInterpolationScheme.C                    | 13 +++++++++----
 .../surface/isoSurface/isoSurfacePointTemplates.C   | 11 ++++++-----
 5 files changed, 28 insertions(+), 14 deletions(-)

diff --git a/src/finiteArea/fields/faPatchFields/basic/coupled/coupledFaPatchField.C b/src/finiteArea/fields/faPatchFields/basic/coupled/coupledFaPatchField.C
index 5a029c1d5c..8ac312d804 100644
--- a/src/finiteArea/fields/faPatchFields/basic/coupled/coupledFaPatchField.C
+++ b/src/finiteArea/fields/faPatchFields/basic/coupled/coupledFaPatchField.C
@@ -130,8 +130,12 @@ void Foam::coupledFaPatchField<Type>::evaluate(const Pstream::commsTypes)
 {
     Field<Type>::operator=
     (
-        this->patch().weights()*this->patchInternalField()
-      + (1.0 - this->patch().weights())*patchNeighbourField()
+        lerp
+        (
+            this->patchNeighbourField(),
+            this->patchInternalField(),
+            this->patch().weights()
+        )
     );
 }
 
diff --git a/src/finiteArea/interpolation/edgeInterpolation/schemes/Gamma/Gamma.H b/src/finiteArea/interpolation/edgeInterpolation/schemes/Gamma/Gamma.H
index c4bd351639..d8de90a17e 100644
--- a/src/finiteArea/interpolation/edgeInterpolation/schemes/Gamma/Gamma.H
+++ b/src/finiteArea/interpolation/edgeInterpolation/schemes/Gamma/Gamma.H
@@ -112,7 +112,7 @@ public:
         scalar phict = 1 - 0.5*gradf/gradcf;
         scalar limiter = min(max(phict/k_, 0), 1);
 
-        return limiter*cdWeight + (1 - limiter)*udWeight;
+        return lerp(udWeight, cdWeight, limiter);
     }
 };
 
diff --git a/src/finiteVolume/fields/fvPatchFields/basic/coupled/coupledFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/basic/coupled/coupledFvPatchField.C
index c68079214a..389b562632 100644
--- a/src/finiteVolume/fields/fvPatchFields/basic/coupled/coupledFvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/basic/coupled/coupledFvPatchField.C
@@ -139,8 +139,12 @@ void Foam::coupledFvPatchField<Type>::evaluate(const Pstream::commsTypes)
 
     Field<Type>::operator=
     (
-        this->patch().weights()*this->patchInternalField()
-      + (1.0 - this->patch().weights())*this->patchNeighbourField()
+        lerp
+        (
+            this->patchNeighbourField(),
+            this->patchInternalField(),
+            this->patch().weights()
+        )
     );
 
     fvPatchField<Type>::evaluate();
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/surfaceInterpolationScheme/surfaceInterpolationScheme.C b/src/finiteVolume/interpolation/surfaceInterpolation/surfaceInterpolationScheme/surfaceInterpolationScheme.C
index 69a88da168..f7f8669492 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/surfaceInterpolationScheme/surfaceInterpolationScheme.C
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/surfaceInterpolationScheme/surfaceInterpolationScheme.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -264,6 +264,9 @@ Foam::surfaceInterpolationScheme<Type>::dotInterpolate
 
     for (label fi=0; fi<P.size(); fi++)
     {
+        // Same as:
+        // sfi[fi] = Sfi[fi] & lerp(vfi[N[fi]], vfi[P[fi]], lambda[fi]);
+        // but maybe the compiler notices the fused multiply add form
         sfi[fi] = Sfi[fi] & (lambda[fi]*(vfi[P[fi]] - vfi[N[fi]]) + vfi[N[fi]]);
     }
 
@@ -282,9 +285,11 @@ Foam::surfaceInterpolationScheme<Type>::dotInterpolate
         {
             psf =
                 pSf
-              & (
-                    pLambda*vf.boundaryField()[pi].patchInternalField()
-                  + (1.0 - pLambda)*vf.boundaryField()[pi].patchNeighbourField()
+              & lerp
+                (
+                    vf.boundaryField()[pi].patchNeighbourField(),
+                    vf.boundaryField()[pi].patchInternalField(),
+                    pLambda
                 );
         }
         else
diff --git a/src/sampling/surface/isoSurface/isoSurfacePointTemplates.C b/src/sampling/surface/isoSurface/isoSurfacePointTemplates.C
index 8f077680ac..a4bf332ae3 100644
--- a/src/sampling/surface/isoSurface/isoSurfacePointTemplates.C
+++ b/src/sampling/surface/isoSurface/isoSurfacePointTemplates.C
@@ -111,11 +111,12 @@ Foam::isoSurfacePoint::adaptPatchFields
                 sliceFldBf[patchi]
             );
 
-            const scalarField& w = mesh.weights().boundaryField()[patchi];
-
-            tmp<Field<Type>> f =
-                w*pfld.patchInternalField()
-              + (1.0-w)*pfld.patchNeighbourField();
+            tmp<Field<Type>> f = lerp
+            (
+                pfld.patchNeighbourField(),
+                pfld.patchInternalField(),
+                mesh.weights().boundaryField()[patchi]
+            );
 
             bitSet isCollocated
             (

From ba6667a344aac2603c8313c90f6fd2646c58ed45 Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@esi-group.com>
Date: Wed, 1 Feb 2023 18:39:19 +0100
Subject: [PATCH 09/11] STYLE: use clamp/clamp_range instead of max(min(...,
 upper), lower)

---
 .../multiphase/cavitatingFoam/alphavPsi.H     | 11 +----
 .../setAlphaField/setAlphaField.C             |  2 +-
 .../uniformInterpolationTable.C               |  2 +-
 .../functions/Function1/ramp/ramp.H           |  2 +-
 .../RAS/kOmegaSSTLM/kOmegaSSTLM.C             |  2 +-
 src/combustionModels/EDC/EDC.C                |  4 +-
 src/engine/include/StCorr.H                   |  2 +-
 .../activeBaffleVelocityFvPatchVectorField.C  | 20 ++++-----
 ...ureForceBaffleVelocityFvPatchVectorField.C | 27 ++++--------
 ...aseHydrostaticPressureFvPatchScalarField.C |  4 +-
 .../averageNeighbourFvGeometryScheme.C        | 21 +++------
 .../highAspectRatioFvGeometryScheme.C         | 11 +----
 .../limitedSchemes/MUSCL/MUSCL.H              |  2 +-
 .../limitedSchemes/Minmod/Minmod.H            |  2 +-
 .../limitedSchemes/Phi/Phi.H                  |  2 +-
 .../limitedSchemes/QUICK/QUICK.H              |  2 +-
 .../limitedSchemes/QUICK/QUICKV.H             |  2 +-
 .../filteredLinear/filteredLinear.H           |  2 +-
 .../filteredLinear2/filteredLinear2.H         |  2 +-
 .../filteredLinear2/filteredLinear2V.H        |  2 +-
 .../filteredLinear3/filteredLinear3.H         |  2 +-
 .../filteredLinear3/filteredLinear3V.H        |  2 +-
 .../limitedCubic/limitedCubic.H               |  4 +-
 .../limitedCubic/limitedCubicV.H              |  2 +-
 .../limitedLinear/limitedLinear.H             |  2 +-
 .../schemes/CoBlended/CoBlended.H             | 18 +++-----
 .../schemes/cellCoBlended/cellCoBlended.H     | 10 ++---
 .../schemes/clippedLinear/clippedLinear.H     | 43 +++++++------------
 .../spray/submodels/BreakupModel/ETAB/ETAB.C  |  2 +-
 .../spray/submodels/BreakupModel/TAB/TAB.C    |  2 +-
 .../lineSearch/lineSearch/lineSearch.C        |  2 +-
 .../MassTransferPhaseSystem.C                 |  4 +-
 .../TDNBModels/Shirai/Shirai.C                |  2 +-
 .../TolubinskiKostanchuk.C                    |  6 ++-
 .../curvatureSeparation/curvatureSeparation.C |  2 +-
 .../curvatureSeparation/curvatureSeparation.C |  2 +-
 .../plicSchemes/plicRDF/plicRDF.C             |  2 +-
 ...haContactAngleTwoPhaseFvPatchScalarField.C |  9 ++--
 38 files changed, 89 insertions(+), 151 deletions(-)

diff --git a/applications/solvers/multiphase/cavitatingFoam/alphavPsi.H b/applications/solvers/multiphase/cavitatingFoam/alphavPsi.H
index ed799ae4b4..51f3eecd20 100644
--- a/applications/solvers/multiphase/cavitatingFoam/alphavPsi.H
+++ b/applications/solvers/multiphase/cavitatingFoam/alphavPsi.H
@@ -1,14 +1,5 @@
 {
-    alphav =
-        max
-        (
-            min
-            (
-                (rho - rholSat)/(rhovSat - rholSat),
-                scalar(1)
-            ),
-            scalar(0)
-        );
+    alphav = clamp((rho - rholSat)/(rhovSat - rholSat), zero_one{});
     alphal = 1.0 - alphav;
 
     Info<< "max-min alphav: " << max(alphav).value()
diff --git a/applications/utilities/preProcessing/setAlphaField/setAlphaField.C b/applications/utilities/preProcessing/setAlphaField/setAlphaField.C
index 44a67715ab..1db1a547f4 100644
--- a/applications/utilities/preProcessing/setAlphaField/setAlphaField.C
+++ b/applications/utilities/preProcessing/setAlphaField/setAlphaField.C
@@ -108,7 +108,7 @@ void setAlpha
     {
         cutCell.calcSubCell(cellI, 0.0);
 
-        alpha1[cellI] = max(min(cutCell.VolumeOfFluid(), 1), 0);
+        alpha1[cellI] = clamp(cutCell.VolumeOfFluid(), 0, 1);
 
         if (writeOBJ && (mag(cutCell.faceArea()) >= 1e-14))
         {
diff --git a/src/OpenFOAM/interpolations/uniformInterpolationTable/uniformInterpolationTable.C b/src/OpenFOAM/interpolations/uniformInterpolationTable/uniformInterpolationTable.C
index 24cae2e413..fa121c73f1 100644
--- a/src/OpenFOAM/interpolations/uniformInterpolationTable/uniformInterpolationTable.C
+++ b/src/OpenFOAM/interpolations/uniformInterpolationTable/uniformInterpolationTable.C
@@ -149,7 +149,7 @@ Type Foam::uniformInterpolationTable<Type>::interpolate(scalar x) const
 {
     if (bound_)
     {
-        x = max(min(xMax() - SMALL*dx_, x), x0_);
+        x = clamp(x, x0_, (xMax() - SMALL*dx_));
     }
     else
     {
diff --git a/src/OpenFOAM/primitives/functions/Function1/ramp/ramp.H b/src/OpenFOAM/primitives/functions/Function1/ramp/ramp.H
index cda3b71016..2dc4e26c17 100644
--- a/src/OpenFOAM/primitives/functions/Function1/ramp/ramp.H
+++ b/src/OpenFOAM/primitives/functions/Function1/ramp/ramp.H
@@ -100,7 +100,7 @@ protected:
         //- that forms the basis of many more complex ramp functions
         inline scalar linearRamp(const scalar t) const
         {
-            return max(min((t - start_)/duration_, 1), 0);
+            return clamp((t - start_)/duration_, 0, 1);
         }
 
 
diff --git a/src/TurbulenceModels/turbulenceModels/RAS/kOmegaSSTLM/kOmegaSSTLM.C b/src/TurbulenceModels/turbulenceModels/RAS/kOmegaSSTLM/kOmegaSSTLM.C
index 8c30e1a403..c4a6af700a 100644
--- a/src/TurbulenceModels/turbulenceModels/RAS/kOmegaSSTLM/kOmegaSSTLM.C
+++ b/src/TurbulenceModels/turbulenceModels/RAS/kOmegaSSTLM/kOmegaSSTLM.C
@@ -310,7 +310,7 @@ tmp<volScalarField::Internal> kOmegaSSTLM<BasicTurbulenceModel>::ReThetat0
             }
 
             lambda = sqr(thetat)/nu[celli]*dUsds[celli];
-            lambda = max(min(lambda, 0.1), -0.1);
+            lambda = clamp(lambda, -0.1, 0.1);
 
             lambdaErr = mag(lambda - lambda0);
 
diff --git a/src/combustionModels/EDC/EDC.C b/src/combustionModels/EDC/EDC.C
index 879ac19628..66ac5e9780 100644
--- a/src/combustionModels/EDC/EDC.C
+++ b/src/combustionModels/EDC/EDC.C
@@ -109,13 +109,13 @@ void Foam::combustionModels::EDC<ReactionThermo>::correct()
                 const scalar nu = mu[i]/(rho[i] + SMALL);
 
                 const scalar Da =
-                    max(min(sqrt(nu/(epsilon[i] + SMALL))/tc[i], 10), 1e-10);
+                    clamp(sqrt(nu/(epsilon[i] + SMALL))/tc[i], 1e-10, 10);
 
                 const scalar ReT = sqr(k[i])/(nu*epsilon[i] + SMALL);
                 const scalar CtauI = min(C1_/(Da*sqrt(ReT + 1)), 2.1377);
 
                 const scalar CgammaI =
-                    max(min(C2_*sqrt(Da*(ReT + 1)), 5), 0.4082);
+                    clamp(C2_*sqrt(Da*(ReT + 1)), 0.4082, 5);
 
                 const scalar gammaL =
                     CgammaI*pow025(nu*epsilon[i]/(sqr(k[i]) + SMALL));
diff --git a/src/engine/include/StCorr.H b/src/engine/include/StCorr.H
index 735bd090f2..b91e79ba41 100644
--- a/src/engine/include/StCorr.H
+++ b/src/engine/include/StCorr.H
@@ -80,7 +80,7 @@
             );
             dimensionedScalar AkEst = gSum(mgb*mesh.V().field());
 
-            StCorr.value() = max(min((Ak/AkEst).value(), 10.0), 1.0);
+            StCorr.value() = clamp((Ak/AkEst).value(), 1, 10);
 
             Info<< "StCorr = " << StCorr.value() << endl;
         }
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/activeBaffleVelocity/activeBaffleVelocityFvPatchVectorField.C b/src/finiteVolume/fields/fvPatchFields/derived/activeBaffleVelocity/activeBaffleVelocityFvPatchVectorField.C
index c894f8d5af..7de63c424d 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/activeBaffleVelocity/activeBaffleVelocityFvPatchVectorField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/activeBaffleVelocity/activeBaffleVelocityFvPatchVectorField.C
@@ -249,22 +249,18 @@ void Foam::activeBaffleVelocityFvPatchVectorField::updateCoeffs()
         }
 
         openFraction_ =
-            max
             (
-                min
+                openFraction_
+              + min
                 (
-                    openFraction_
-                  + min
-                    (
-                        this->db().time().deltaTValue()/openingTime_,
-                        maxOpenFractionDelta_
-                    )
-                   *(orientation_*sign(forceDiff)),
-                    1 - 1e-6
-                ),
-                1e-6
+                    this->db().time().deltaTValue()/openingTime_,
+                    maxOpenFractionDelta_
+                )
+                *(orientation_*sign(forceDiff))
             );
 
+        openFraction_ = clamp(openFraction_, 1e-6, 1 - 1e-6);
+
         Info<< "openFraction = " << openFraction_ << endl;
 
         vectorField::subField Sfw = this->patch().patch().faceAreas();
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/activePressureForceBaffleVelocity/activePressureForceBaffleVelocityFvPatchVectorField.C b/src/finiteVolume/fields/fvPatchFields/derived/activePressureForceBaffleVelocity/activePressureForceBaffleVelocityFvPatchVectorField.C
index 275cd38151..c69104703d 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/activePressureForceBaffleVelocity/activePressureForceBaffleVelocityFvPatchVectorField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/activePressureForceBaffleVelocity/activePressureForceBaffleVelocityFvPatchVectorField.C
@@ -299,27 +299,18 @@ void Foam::activePressureForceBaffleVelocityFvPatchVectorField::updateCoeffs()
         if (mag(valueDiff) > mag(minThresholdValue_) || baffleActivated_)
         {
             openFraction_ =
-                max
+            (
+                openFraction_
+              + min
                 (
-                    min
-                    (
-                        openFraction_
-                      + min
-                        (
-                          this->db().time().deltaT().value()/openingTime_,
-                          maxOpenFractionDelta_
-                        ),
-                        1 - 1e-6
-                    ),
-                    1e-6
-                );
+                    this->db().time().deltaT().value()/openingTime_,
+                    maxOpenFractionDelta_
+                )
+            );
 
-             baffleActivated_ = true;
-        }
-        else
-        {
-            openFraction_ = max(min(1 - 1e-6, openFraction_), 1e-6);
+            baffleActivated_ = true;
         }
+        openFraction_ = clamp(openFraction_, 1e-6, 1 - 1e-6);
 
         if (Pstream::master())
         {
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/phaseHydrostaticPressure/phaseHydrostaticPressureFvPatchScalarField.C b/src/finiteVolume/fields/fvPatchFields/derived/phaseHydrostaticPressure/phaseHydrostaticPressureFvPatchScalarField.C
index a234a37342..d3ddb15c90 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/phaseHydrostaticPressure/phaseHydrostaticPressureFvPatchScalarField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/phaseHydrostaticPressure/phaseHydrostaticPressureFvPatchScalarField.C
@@ -148,9 +148,9 @@ void Foam::phaseHydrostaticPressureFvPatchScalarField::updateCoeffs()
         meshObjects::gravity::New(db().time());
 
     // scalar rhor = 1000;
-    // scalarField alphap1 = max(min(alphap, scalar(1)), scalar(0));
+    // scalarField alphap1 = clamp(alphap, zero_one{});
     // valueFraction() = alphap1/(alphap1 + rhor*(1.0 - alphap1));
-    valueFraction() = max(min(alphap, scalar(1)), scalar(0));
+    valueFraction() = clamp(alphap, zero_one{});
 
     refValue() =
         pRefValue_
diff --git a/src/finiteVolume/fvMesh/fvGeometryScheme/averageNeighbour/averageNeighbourFvGeometryScheme.C b/src/finiteVolume/fvMesh/fvGeometryScheme/averageNeighbour/averageNeighbourFvGeometryScheme.C
index a33c5b99a2..8476a24df4 100644
--- a/src/finiteVolume/fvMesh/fvGeometryScheme/averageNeighbour/averageNeighbourFvGeometryScheme.C
+++ b/src/finiteVolume/fvMesh/fvGeometryScheme/averageNeighbour/averageNeighbourFvGeometryScheme.C
@@ -512,22 +512,11 @@ void Foam::averageNeighbourFvGeometryScheme::makeNonOrthoWeights
     scalarField& faceWeights
 ) const
 {
-    cosAngles =
-        max
-        (
-            scalar(0),
-            min
-            (
-                scalar(1),
-                polyMeshTools::faceOrthogonality
-                (
-                    mesh_,
-                    faceNormals,
-                    cellCentres
-                )
-            )
-        );
-
+    cosAngles = clamp
+    (
+        polyMeshTools::faceOrthogonality(mesh_, faceNormals, cellCentres),
+        zero_one{}
+    );
 
     // Make weight: 0 for ortho faces, 1 for 90degrees non-ortho
     //const scalarField faceWeights(scalar(1)-cosAngles);
diff --git a/src/finiteVolume/fvMesh/fvGeometryScheme/highAspectRatio/highAspectRatioFvGeometryScheme.C b/src/finiteVolume/fvMesh/fvGeometryScheme/highAspectRatio/highAspectRatioFvGeometryScheme.C
index 1202b80880..84c3eb064a 100644
--- a/src/finiteVolume/fvMesh/fvGeometryScheme/highAspectRatio/highAspectRatioFvGeometryScheme.C
+++ b/src/finiteVolume/fvMesh/fvGeometryScheme/highAspectRatio/highAspectRatioFvGeometryScheme.C
@@ -192,16 +192,7 @@ void Foam::highAspectRatioFvGeometryScheme::calcAspectRatioWeights
         delta = SMALL;
     }
 
-    cellWeight =
-    max
-    (
-        scalar(0),
-        min
-        (
-            scalar(1),
-            (aratio-minAspect_)/delta
-        )
-    );
+    cellWeight = clamp((aratio-minAspect_)/delta, zero_one{});
 
     faceWeight.setSize(mesh_.nFaces());
 
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/MUSCL/MUSCL.H b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/MUSCL/MUSCL.H
index 9e0d97b83a..55d13e373b 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/MUSCL/MUSCL.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/MUSCL/MUSCL.H
@@ -81,7 +81,7 @@ public:
             faceFlux, phiP, phiN, gradcP, gradcN, d
         );
 
-        return max(min(min(2*r, 0.5*r + 0.5), 2), 0);
+        return clamp(min(2*r, 0.5*r + 0.5), 0, 2);
     }
 };
 
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/Minmod/Minmod.H b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/Minmod/Minmod.H
index 6c34e5928b..91d05ea146 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/Minmod/Minmod.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/Minmod/Minmod.H
@@ -81,7 +81,7 @@ public:
             faceFlux, phiP, phiN, gradcP, gradcN, d
         );
 
-        return max(min(r, 1), 0);
+        return clamp(r, 0, 1);
     }
 };
 
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/Phi/Phi.H b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/Phi/Phi.H
index 24c44f4d77..2b3ef8f7da 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/Phi/Phi.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/Phi/Phi.H
@@ -107,7 +107,7 @@ public:
             ((faceFlux - phiU)/stabilise(phiCD - phiU, SMALL) + k_);
 
         // Limit the limiter between upwind and central
-        return max(min(PLimiter, 1), 0);
+        return clamp(PLimiter, 0, 1);
     }
 };
 
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/QUICK/QUICK.H b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/QUICK/QUICK.H
index 8512576f2f..ae66624997 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/QUICK/QUICK.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/QUICK/QUICK.H
@@ -100,7 +100,7 @@ public:
         scalar QLimiter = (phif - phiU)/stabilise(phiCD - phiU, SMALL);
 
         // Limit the limiter between upwind and downwind
-        return max(min(QLimiter, 2), 0);
+        return clamp(QLimiter, 0, 2);
     }
 };
 
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/QUICK/QUICKV.H b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/QUICK/QUICKV.H
index f71e54f197..fe6f9b011a 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/QUICK/QUICKV.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/QUICK/QUICKV.H
@@ -99,7 +99,7 @@ public:
         scalar QLimiter = (phif - phiU)/stabilise(phiCD - phiU, SMALL);
 
         // Limit the limiter between upwind and downwind
-        return max(min(QLimiter, 2), 0);
+        return clamp(QLimiter, 0, 2);
     }
 };
 
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear/filteredLinear.H b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear/filteredLinear.H
index 6e563156ae..d7ee786056 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear/filteredLinear.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear/filteredLinear.H
@@ -93,7 +93,7 @@ public:
            /(max(mag(dcP), mag(dcN)) + SMALL);
 
         // Limit the limiter between linear and 20% upwind
-        return max(min(limiter, 1), 0.8);
+        return clamp(limiter, 0.8, 1);
     }
 };
 
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear2/filteredLinear2.H b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear2/filteredLinear2.H
index a68fcbaf8e..9378fd1a01 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear2/filteredLinear2.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear2/filteredLinear2.H
@@ -141,7 +141,7 @@ public:
         }
 
         // Limit the limiter between linear and upwind
-        return max(min(limiter, 1), 0);
+        return clamp(limiter, 0, 1);
     }
 };
 
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear2/filteredLinear2V.H b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear2/filteredLinear2V.H
index 2a035c1e39..e8dcf7a6aa 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear2/filteredLinear2V.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear2/filteredLinear2V.H
@@ -143,7 +143,7 @@ public:
         }
 
         // Limit the limiter between linear and upwind
-        return max(min(limiter, 1), 0);
+        return clamp(limiter, 0, 1);
     }
 };
 
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear3/filteredLinear3.H b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear3/filteredLinear3.H
index 48105a0b34..043a0e5630 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear3/filteredLinear3.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear3/filteredLinear3.H
@@ -108,7 +108,7 @@ public:
         scalar limiter = 1 - k_*(dN - df)*(dP - df)/max(sqr(dN + dP), SMALL);
 
         // Limit the limiter between linear and upwind
-        return max(min(limiter, 1), 0);
+        return clamp(limiter, 0, 1);
     }
 };
 
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear3/filteredLinear3V.H b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear3/filteredLinear3V.H
index 9c2f596b86..d69562b2e5 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear3/filteredLinear3V.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/filteredLinear3/filteredLinear3V.H
@@ -110,7 +110,7 @@ public:
         scalar limiter = 1 - k_*(dN - df)*(dP - df)/max(sqr(dN + dP), SMALL);
 
         // Limit the limiter between linear and upwind
-        return max(min(limiter, 1), 0);
+        return clamp(limiter, 0, 1);
     }
 };
 
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/limitedCubic/limitedCubic.H b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/limitedCubic/limitedCubic.H
index 2a9408ce0e..5ca1cbb0c7 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/limitedCubic/limitedCubic.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/limitedCubic/limitedCubic.H
@@ -124,11 +124,11 @@ public:
             cubicLimiter = twor;
         }
 
-        return max(min(cubicLimiter, 2), 0);
+        return clamp(cubicLimiter, 0, 2);
         */
 
         // Limit the limiter to obey the TVD constraint
-        return max(min(min(twor, cubicLimiter), 2), 0);
+        return clamp(min(twor, cubicLimiter), 0, 2);
     }
 };
 
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/limitedCubic/limitedCubicV.H b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/limitedCubic/limitedCubicV.H
index 3efede0496..b67b474765 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/limitedCubic/limitedCubicV.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/limitedCubic/limitedCubicV.H
@@ -122,7 +122,7 @@ public:
             (fVphif - fVphiU)/stabilise(fVphiCD - fVphiU, SMALL);
 
         // Limit the limiter to obey the TVD constraint
-        return max(min(min(twor, cubicLimiter), 2), 0);
+        return clamp(min(twor, cubicLimiter), 0, 2);
     }
 };
 
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/limitedLinear/limitedLinear.H b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/limitedLinear/limitedLinear.H
index 819ddd8af8..159bcc695e 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/limitedLinear/limitedLinear.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/limitedLinear/limitedLinear.H
@@ -97,7 +97,7 @@ public:
             faceFlux, phiP, phiN, gradcP, gradcN, d
         );
 
-        return max(min(twoByk_*r, 1), 0);
+        return clamp(twoByk_*r, 0, 1);
     }
 };
 
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/schemes/CoBlended/CoBlended.H b/src/finiteVolume/interpolation/surfaceInterpolation/schemes/CoBlended/CoBlended.H
index aa1f10e44d..80bd3add72 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/schemes/CoBlended/CoBlended.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/schemes/CoBlended/CoBlended.H
@@ -36,7 +36,7 @@ Description
     face-based Courant number and the lower and upper Courant number limits
     supplied:
     \f[
-        weight = 1 - max(min((Co - Co1)/(Co2 - Co1), 1), 0)
+        weight = 1 - clamp((Co - Co1)/(Co2 - Co1), 0, 1)
     \f]
     where
     \vartable
@@ -222,18 +222,14 @@ public:
                 (
                     vf.name() + "BlendingFactor",
                     scalar(1)
-                  - max
+                  - clamp
                     (
-                        min
                         (
-                            (
-                                mesh.time().deltaT()*mesh.deltaCoeffs()
-                               *mag(tUflux)/mesh.magSf()
-                              - Co1_
-                            )/(Co2_ - Co1_),
-                            scalar(1)
-                        ),
-                        scalar(0)
+                            mesh.time().deltaT()*mesh.deltaCoeffs()
+                            *mag(tUflux)/mesh.magSf()
+                          - Co1_
+                        )/(Co2_ - Co1_),
+                        zero_one{}
                     )
                 )
             );
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/schemes/cellCoBlended/cellCoBlended.H b/src/finiteVolume/interpolation/surfaceInterpolation/schemes/cellCoBlended/cellCoBlended.H
index 488713445a..d9ca8e77a3 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/schemes/cellCoBlended/cellCoBlended.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/schemes/cellCoBlended/cellCoBlended.H
@@ -253,14 +253,10 @@ public:
                 (
                     vf.name() + "BlendingFactor",
                     scalar(1)
-                  - max
+                  - clamp
                     (
-                        min
-                        (
-                            (fvc::interpolate(Co) - Co1_)/(Co2_ - Co1_),
-                            scalar(1)
-                        ),
-                        scalar(0)
+                        (fvc::interpolate(Co) - Co1_)/(Co2_ - Co1_),
+                        zero_one{}
                     )
                 )
             );
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/schemes/clippedLinear/clippedLinear.H b/src/finiteVolume/interpolation/surfaceInterpolation/schemes/clippedLinear/clippedLinear.H
index e2f10a660c..4ed0fd576d 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/schemes/clippedLinear/clippedLinear.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/schemes/clippedLinear/clippedLinear.H
@@ -58,25 +58,24 @@ class clippedLinear
 :
     public surfaceInterpolationScheme<Type>
 {
-    // Private data
+    // Private Data
 
-        const scalar cellSizeRatio_;
         scalar wfLimit_;
 
 
     // Private Member Functions
 
-        void calcWfLimit()
+        static scalar calcWfLimit(scalar cellSizeRatio)
         {
-            if (cellSizeRatio_ <= 0 || cellSizeRatio_ > 1)
+            if (cellSizeRatio <= 0 || cellSizeRatio > 1)
             {
                 FatalErrorInFunction
-                    << "Given cellSizeRatio of " << cellSizeRatio_
+                    << "Given cellSizeRatio of " << cellSizeRatio
                     << " is not between 0 and 1"
                     << exit(FatalError);
             }
 
-            wfLimit_ = cellSizeRatio_/(1.0 + cellSizeRatio_);
+            return cellSizeRatio/(1.0 + cellSizeRatio);
         }
 
 
@@ -96,19 +95,15 @@ public:
         clippedLinear(const fvMesh& mesh, const scalar cellSizeRatio)
         :
             surfaceInterpolationScheme<Type>(mesh),
-            cellSizeRatio_(cellSizeRatio)
-        {
-            calcWfLimit();
-        }
+            wfLimit_(calcWfLimit(cellSizeRatio))
+        {}
 
         //- Construct from Istream
         clippedLinear(const fvMesh& mesh, Istream& is)
         :
             surfaceInterpolationScheme<Type>(mesh),
-            cellSizeRatio_(readScalar(is))
-        {
-            calcWfLimit();
-        }
+            wfLimit_(calcWfLimit(readScalar(is)))
+        {}
 
         //- Construct from faceFlux and Istream
         clippedLinear
@@ -119,10 +114,8 @@ public:
         )
         :
             surfaceInterpolationScheme<Type>(mesh),
-            cellSizeRatio_(readScalar(is))
-        {
-            calcWfLimit();
-        }
+            wfLimit_(calcWfLimit(readScalar(is)))
+        {}
 
 
     // Member Functions
@@ -141,6 +134,8 @@ public:
             );
             const surfaceScalarField& cdWeights = tcdWeights();
 
+            const scalarMinMax bounds(wfLimit_, 1 - wfLimit_);
+
             tmp<surfaceScalarField> tclippedLinearWeights
             (
                 new surfaceScalarField
@@ -159,7 +154,7 @@ public:
                 tclippedLinearWeights.ref();
 
             clippedLinearWeights.primitiveFieldRef() =
-                max(min(cdWeights.primitiveField(), 1 - wfLimit_), wfLimit_);
+                clamp(cdWeights.primitiveField(), bounds);
 
             surfaceScalarField::Boundary& clwbf =
                 clippedLinearWeights.boundaryFieldRef();
@@ -169,15 +164,7 @@ public:
                 if (clwbf[patchi].coupled())
                 {
                     clwbf[patchi] =
-                        max
-                        (
-                            min
-                            (
-                                cdWeights.boundaryField()[patchi],
-                                1 - wfLimit_
-                            ),
-                            wfLimit_
-                        );
+                        clamp(cdWeights.boundaryField()[patchi], bounds);
                 }
                 else
                 {
diff --git a/src/lagrangian/spray/submodels/BreakupModel/ETAB/ETAB.C b/src/lagrangian/spray/submodels/BreakupModel/ETAB/ETAB.C
index 5d6bdb0172..c642019c79 100644
--- a/src/lagrangian/spray/submodels/BreakupModel/ETAB/ETAB.C
+++ b/src/lagrangian/spray/submodels/BreakupModel/ETAB/ETAB.C
@@ -131,7 +131,7 @@ bool Foam::ETAB<CloudType>::update
             scalar phic = y1/a;
 
             // constrain phic within -1 to 1
-            phic = max(min(phic, 1), -1);
+            phic = clamp(phic, -1, 1);
 
             scalar phit = acos(phic);
             scalar phi = phit;
diff --git a/src/lagrangian/spray/submodels/BreakupModel/TAB/TAB.C b/src/lagrangian/spray/submodels/BreakupModel/TAB/TAB.C
index 97202f99c2..f7d552949a 100644
--- a/src/lagrangian/spray/submodels/BreakupModel/TAB/TAB.C
+++ b/src/lagrangian/spray/submodels/BreakupModel/TAB/TAB.C
@@ -143,7 +143,7 @@ bool Foam::TAB<CloudType>::update
             scalar phic = y1/a;
 
             // constrain phic within -1 to 1
-            phic = max(min(phic, 1), -1);
+            phic = clamp(phic, -1, 1);
 
             scalar phit = acos(phic);
             scalar phi = phit;
diff --git a/src/optimisation/adjointOptimisation/adjoint/optimisation/lineSearch/lineSearch/lineSearch.C b/src/optimisation/adjointOptimisation/adjoint/optimisation/lineSearch/lineSearch/lineSearch.C
index 571adab467..ef4a26bfee 100644
--- a/src/optimisation/adjointOptimisation/adjoint/optimisation/lineSearch/lineSearch/lineSearch.C
+++ b/src/optimisation/adjointOptimisation/adjoint/optimisation/lineSearch/lineSearch/lineSearch.C
@@ -167,7 +167,7 @@ void Foam::lineSearch::reset()
         // step_ = 2*(oldMeritValue_-prevMeritValue_)/directionalDeriv_;
         // Interpolate in order to get same improvement with the previous
         // optimisation cycle
-        step_ = max(min(step_*prevMeritDeriv_/directionalDeriv_, 1.), minStep_);
+        step_ = clamp(step_*prevMeritDeriv_/directionalDeriv_, minStep_, 1);
         Info<< "\n------- Computing initial step-------" << endl;
         Info<< "old dphi(0) "  << prevMeritDeriv_ << endl;
         Info<< "dphi(0) "      << directionalDeriv_ << endl;
diff --git a/src/phaseSystemModels/multiphaseInter/phasesSystem/MassTransferPhaseSystem/MassTransferPhaseSystem.C b/src/phaseSystemModels/multiphaseInter/phasesSystem/MassTransferPhaseSystem/MassTransferPhaseSystem.C
index 559fee3e63..e9039e3971 100644
--- a/src/phaseSystemModels/multiphaseInter/phasesSystem/MassTransferPhaseSystem/MassTransferPhaseSystem.C
+++ b/src/phaseSystemModels/multiphaseInter/phasesSystem/MassTransferPhaseSystem/MassTransferPhaseSystem.C
@@ -617,7 +617,7 @@ void Foam::MassTransferPhaseSystem<BasePhaseSystem>::alphaTransfer
             scalar dmdt21 = dmdtNet[celli];
             scalar coeffs12Cell = coeffs12[celli];
 
-            scalar alpha1Limited = max(min(alpha1[celli], 1.0), 0.0);
+            scalar alpha1Limited = clamp(alpha1[celli], 0, 1);
 
             // exp.
             SuPhase1[celli] += coeffs1[celli]*dmdt21;
@@ -660,7 +660,7 @@ void Foam::MassTransferPhaseSystem<BasePhaseSystem>::alphaTransfer
             scalar dmdt12 = -dmdtNet[celli];
             scalar coeffs21Cell = -coeffs12[celli];
 
-            scalar alpha2Limited = max(min(alpha2[celli], 1.0), 0.0);
+            scalar alpha2Limited = clamp(alpha2[celli], 0, 1);
 
             // exp
             SuPhase2[celli] += coeffs2[celli]*dmdt12;
diff --git a/src/phaseSystemModels/reactingEuler/multiphaseSystem/derivedFvPatchFields/wallBoilingSubModels/TDNBModels/Shirai/Shirai.C b/src/phaseSystemModels/reactingEuler/multiphaseSystem/derivedFvPatchFields/wallBoilingSubModels/TDNBModels/Shirai/Shirai.C
index d8e1700687..d446b54588 100644
--- a/src/phaseSystemModels/reactingEuler/multiphaseSystem/derivedFvPatchFields/wallBoilingSubModels/TDNBModels/Shirai/Shirai.C
+++ b/src/phaseSystemModels/reactingEuler/multiphaseSystem/derivedFvPatchFields/wallBoilingSubModels/TDNBModels/Shirai/Shirai.C
@@ -75,7 +75,7 @@ Foam::wallBoilingModels::TDNBModels::Shirai::TDNB
 {
     tmp<scalarField> tp = liquid.thermo().p().boundaryField()[patchi];
 
-    const scalarField pRatio(max(min(tp/Pc_, scalar(1)), scalar(0)));
+    const scalarField pRatio(clamp(tp/Pc_, zero_one{}));
 
     return
     (
diff --git a/src/phaseSystemModels/reactingEuler/multiphaseSystem/derivedFvPatchFields/wallBoilingSubModels/departureDiameterModels/TolubinskiKostanchuk/TolubinskiKostanchuk.C b/src/phaseSystemModels/reactingEuler/multiphaseSystem/derivedFvPatchFields/wallBoilingSubModels/departureDiameterModels/TolubinskiKostanchuk/TolubinskiKostanchuk.C
index 9ee761d938..f724b50bdb 100644
--- a/src/phaseSystemModels/reactingEuler/multiphaseSystem/derivedFvPatchFields/wallBoilingSubModels/departureDiameterModels/TolubinskiKostanchuk/TolubinskiKostanchuk.C
+++ b/src/phaseSystemModels/reactingEuler/multiphaseSystem/derivedFvPatchFields/wallBoilingSubModels/departureDiameterModels/TolubinskiKostanchuk/TolubinskiKostanchuk.C
@@ -78,7 +78,11 @@ TolubinskiKostanchuk::dDeparture
     const scalarField& L
 ) const
 {
-    return max(min(dRef_*exp(-(Tsatw - Tl)/scalar(45)), dMax_), dMin_);
+    return clamp
+    (
+        dRef_*exp(-(Tsatw - Tl)/scalar(45)),
+        scalarMinMax(dMin_, dMax_)
+    );
 }
 
 
diff --git a/src/regionFaModels/liquidFilm/subModels/kinematic/injectionModel/curvatureSeparation/curvatureSeparation.C b/src/regionFaModels/liquidFilm/subModels/kinematic/injectionModel/curvatureSeparation/curvatureSeparation.C
index ee40e48424..77b628724c 100644
--- a/src/regionFaModels/liquidFilm/subModels/kinematic/injectionModel/curvatureSeparation/curvatureSeparation.C
+++ b/src/regionFaModels/liquidFilm/subModels/kinematic/injectionModel/curvatureSeparation/curvatureSeparation.C
@@ -148,7 +148,7 @@ tmp<scalarField> curvatureSeparation::calcCosAngle
         volCosAngle.write();
     }
 
-    return max(min(cosAngle, scalar(1)), scalar(-1));
+    return clamp(cosAngle, scalarMinMax(-1, 1));
 }
 
 
diff --git a/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/curvatureSeparation/curvatureSeparation.C b/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/curvatureSeparation/curvatureSeparation.C
index d46e00a9f9..a5474ef420 100644
--- a/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/curvatureSeparation/curvatureSeparation.C
+++ b/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/curvatureSeparation/curvatureSeparation.C
@@ -215,7 +215,7 @@ tmp<scalarField> curvatureSeparation::calcCosAngle
         volCosAngle.write();
     }
 
-    return max(min(cosAngle, scalar(1)), scalar(-1));
+    return clamp(cosAngle, scalarMinMax(-1, 1));
 }
 
 
diff --git a/src/transportModels/geometricVoF/reconstructionSchemes/plicSchemes/plicRDF/plicRDF.C b/src/transportModels/geometricVoF/reconstructionSchemes/plicSchemes/plicRDF/plicRDF.C
index 10fe2c055a..62db3416f8 100644
--- a/src/transportModels/geometricVoF/reconstructionSchemes/plicSchemes/plicRDF/plicRDF.C
+++ b/src/transportModels/geometricVoF/reconstructionSchemes/plicSchemes/plicRDF/plicRDF.C
@@ -279,7 +279,7 @@ void Foam::reconstruction::plicRDF::calcResidual
             if (mag(normal) != 0 && j != 0)
             {
                 vector n = normal/mag(normal);
-                scalar cosAngle = max(min((cellNormal & n), 1), -1);
+                scalar cosAngle = clamp((cellNormal & n), -1, 1);
                 avgDiffNormal += acos(cosAngle) * mag(normal);
                 weight += mag(normal);
                 if (cosAngle < maxDiffNormal)
diff --git a/src/transportModels/interfaceProperties/alphaContactAngle/alphaContactAngleTwoPhaseFvPatchScalarField.C b/src/transportModels/interfaceProperties/alphaContactAngle/alphaContactAngleTwoPhaseFvPatchScalarField.C
index 580b4e7310..401b53ab91 100644
--- a/src/transportModels/interfaceProperties/alphaContactAngle/alphaContactAngleTwoPhaseFvPatchScalarField.C
+++ b/src/transportModels/interfaceProperties/alphaContactAngle/alphaContactAngleTwoPhaseFvPatchScalarField.C
@@ -133,11 +133,8 @@ void Foam::alphaContactAngleTwoPhaseFvPatchScalarField::evaluate
         gradient() =
         patch().deltaCoeffs()
        *(
-           max(min
-           (
-               *this + gradient()/patch().deltaCoeffs(),
-               scalar(1)), scalar(0)
-           ) - *this
+           clamp(*this + gradient()/patch().deltaCoeffs(), zero_one{})
+         - *this
        );
     }
     else if (limit_ == lcZeroGradient)
@@ -149,7 +146,7 @@ void Foam::alphaContactAngleTwoPhaseFvPatchScalarField::evaluate
 
     if (limit_ == lcAlpha)
     {
-        scalarField::operator=(max(min(*this, scalar(1)), scalar(0)));
+        scalarField::operator=(clamp(*this, zero_one{}));
     }
 }
 

From 1cc72ea7e3493a26e09d5dd07cdfd5e1164d6678 Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@esi-group.com>
Date: Wed, 1 Feb 2023 18:39:19 +0100
Subject: [PATCH 10/11] STYLE: use clamp/clamp_range instead of min(max(...,
 upper), lower)

---
 applications/solvers/combustion/XiFoam/bEqn.H |  2 +-
 .../constant/constant.C                       | 57 +++++++------------
 .../interfaceHeatResistance.C                 | 14 +----
 .../twoPhaseMixtureEThermo.C                  | 44 ++++++--------
 .../phaseChangeTwoPhaseMixtures/Kunz/Kunz.C   |  4 +-
 .../Merkle/Merkle.C                           |  2 +-
 .../SchnerrSauer/SchnerrSauer.C               |  6 +-
 .../vectorTools/vectorTools.H                 |  4 +-
 .../adaptiveSolver/adaptiveSolver.C           |  2 +-
 src/OpenFOAM/meshes/meshShapes/face/face.C    |  4 +-
 .../polyMesh/polyMeshCheck/polyMeshCheck.C    |  6 +-
 .../primitiveShapes/triangle/triangleI.H      |  2 +-
 .../InputValueMapper/InputValueMapperI.H      |  6 +-
 src/OpenFOAM/primitives/triad/triad.C         |  2 +-
 .../RAS/kOmegaSSTLM/kOmegaSSTLM.C             |  2 +-
 .../RAS/realizableKE/realizableKE.C           |  2 +-
 .../edgeInterpolation/edgeInterpolation.C     |  6 +-
 .../edgeInterpolation/schemes/Gamma/Gamma.H   |  2 +-
 .../limitedSchemes/Gamma/Gamma.H              |  2 +-
 .../limitedSchemes/SFCD/SFCD.H                |  2 +-
 .../surfaceFieldValue/surfaceFieldValue.C     |  4 +-
 .../stabilityBlendingFactor.C                 |  2 +-
 .../stabilityBlendingFactor.H                 |  2 +-
 .../solidificationMeltingSource.C             |  2 +-
 .../multiNormal/multiNormal.C                 |  2 +-
 .../distributionModels/normal/normal.C        |  2 +-
 .../Templates/ThermoParcel/ThermoParcel.C     |  2 +-
 .../DistortedSphereDragForce.C                |  2 +-
 .../Templates/SprayParcel/SprayParcel.C       |  4 +-
 .../spray/submodels/BreakupModel/ETAB/ETAB.C  |  3 +-
 .../cyclicACMIPolyPatch/cyclicACMIPolyPatch.C |  4 +-
 .../searchableCone/searchableCone.C           |  4 +-
 .../faceTriangulation/faceTriangulation.C     |  2 +-
 .../MassTransferPhaseSystem.C                 |  7 +--
 .../phasesSystem/massTransferModels/Lee/Lee.C | 14 ++---
 .../multiphaseInterSystem.C                   |  8 +--
 .../multiphaseSystem/multiphaseSystem.C       |  3 +-
 .../virtualMassModels/Lamb/Lamb.C             |  2 +-
 .../SinclairJackson/SinclairJacksonRadial.C   |  6 +-
 .../SinclairJackson/SinclairJacksonRadial.C   |  6 +-
 .../virtualMassModels/Lamb/Lamb.C             |  2 +-
 ...gidBodyDisplacementPointPatchVectorField.C |  2 +-
 .../sixDoFRigidBodyMotionSolver.C             |  2 +-
 ...ppedUniformInletHeatAdditionFvPatchField.C |  2 +-
 .../specie/thermo/janaf/janafThermoI.H        |  8 +--
 .../isoAdvection/isoAdvection.C               |  2 +-
 .../incompressibleTwoPhaseMixture.C           |  8 +--
 .../interfaceCompression.H                    |  7 ++-
 .../waveMakerPointPatchVectorField.C          |  2 +-
 .../irregularWaveModel/irregularWaveModel.C   |  2 +-
 50 files changed, 122 insertions(+), 167 deletions(-)

diff --git a/applications/solvers/combustion/XiFoam/bEqn.H b/applications/solvers/combustion/XiFoam/bEqn.H
index 38740d0dd5..91d211ae2a 100644
--- a/applications/solvers/combustion/XiFoam/bEqn.H
+++ b/applications/solvers/combustion/XiFoam/bEqn.H
@@ -215,7 +215,7 @@ if (ign.ignited())
           + (
                 scalar(1)
               + (2*XiShapeCoef)
-               *(scalar(0.5) - min(max(b, scalar(0)), scalar(1)))
+               *(scalar(0.5) - clamp(b, zero_one{}))
             )*(XiEqStar - scalar(1.001))
         );
 
diff --git a/applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/constant/constant.C b/applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/constant/constant.C
index 36342d9393..78400b60ff 100644
--- a/applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/constant/constant.C
+++ b/applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/constant/constant.C
@@ -99,17 +99,6 @@ Foam::temperaturePhaseChangeTwoPhaseMixtures::constant::mDotAlphal() const
 Foam::Pair<Foam::tmp<Foam::volScalarField>>
 Foam::temperaturePhaseChangeTwoPhaseMixtures::constant::mDot() const
 {
-
-    volScalarField limitedAlpha1
-    (
-        min(max(mixture_.alpha1(), scalar(0)), scalar(1))
-    );
-
-    volScalarField limitedAlpha2
-    (
-        min(max(mixture_.alpha2(), scalar(0)), scalar(1))
-    );
-
     const volScalarField& T = mesh_.lookupObject<volScalarField>("T");
 
     const twoPhaseMixtureEThermo& thermo =
@@ -124,11 +113,15 @@ Foam::temperaturePhaseChangeTwoPhaseMixtures::constant::mDot() const
 
     volScalarField mDotE
     (
-        "mDotE", coeffE_*mixture_.rho1()*limitedAlpha1*max(T - TSat, T0)
+        "mDotE",
+        coeffE_*mixture_.rho1()*clamp(mixture_.alpha1(), zero_one{})
+      * max(T - TSat, T0)
     );
     volScalarField mDotC
     (
-        "mDotC", coeffC_*mixture_.rho2()*limitedAlpha2*max(TSat - T, T0)
+        "mDotC",
+        coeffC_*mixture_.rho2()*clamp(mixture_.alpha2(), zero_one{})
+      * max(TSat - T, T0)
     );
 
     if (mesh_.time().outputTime())
@@ -148,16 +141,6 @@ Foam::temperaturePhaseChangeTwoPhaseMixtures::constant::mDot() const
 Foam::Pair<Foam::tmp<Foam::volScalarField>>
 Foam::temperaturePhaseChangeTwoPhaseMixtures::constant::mDotDeltaT() const
 {
-    volScalarField limitedAlpha1
-    (
-        min(max(mixture_.alpha1(), scalar(0)), scalar(1))
-    );
-
-    volScalarField limitedAlpha2
-    (
-        min(max(mixture_.alpha2(), scalar(0)), scalar(1))
-    );
-
     const volScalarField& T = mesh_.lookupObject<volScalarField>("T");
 
     const twoPhaseMixtureEThermo& thermo =
@@ -170,8 +153,14 @@ Foam::temperaturePhaseChangeTwoPhaseMixtures::constant::mDotDeltaT() const
 
     return Pair<tmp<volScalarField>>
     (
-        coeffC_*mixture_.rho2()*limitedAlpha2*pos(TSat - T),
-        coeffE_*mixture_.rho1()*limitedAlpha1*pos(T - TSat)
+        (
+            coeffC_*mixture_.rho2()*clamp(mixture_.alpha2(), zero_one{})
+          * pos(TSat - T)
+        ),
+        (
+            coeffE_*mixture_.rho1()*clamp(mixture_.alpha1(), zero_one{})
+          * pos(T - TSat)
+        )
     );
 }
 
@@ -201,25 +190,17 @@ Foam::temperaturePhaseChangeTwoPhaseMixtures::constant::TSource() const
 
     const dimensionedScalar& TSat = thermo.TSat();
 
-    dimensionedScalar L = mixture_.Hf2() - mixture_.Hf1();
-
-    volScalarField limitedAlpha1
-    (
-        min(max(mixture_.alpha1(), scalar(0)), scalar(1))
-    );
-
-    volScalarField limitedAlpha2
-    (
-        min(max(mixture_.alpha2(), scalar(0)), scalar(1))
-    );
+    const dimensionedScalar L = mixture_.Hf2() - mixture_.Hf1();
 
     const volScalarField Vcoeff
     (
-        coeffE_*mixture_.rho1()*limitedAlpha1*L*pos(T - TSat)
+        coeffE_*mixture_.rho1()*clamp(mixture_.alpha1(), zero_one{})
+      * L*pos(T - TSat)
     );
     const volScalarField Ccoeff
     (
-        coeffC_*mixture_.rho2()*limitedAlpha2*L*pos(TSat - T)
+        coeffC_*mixture_.rho2()*clamp(mixture_.alpha2(), zero_one{})
+      * L*pos(TSat - T)
     );
 
     TSource =
diff --git a/applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/interfaceHeatResistance/interfaceHeatResistance.C b/applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/interfaceHeatResistance/interfaceHeatResistance.C
index 3961c127bd..f59700f556 100644
--- a/applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/interfaceHeatResistance/interfaceHeatResistance.C
+++ b/applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/interfaceHeatResistance/interfaceHeatResistance.C
@@ -167,20 +167,10 @@ Foam::Pair<Foam::tmp<Foam::volScalarField>>
 Foam::temperaturePhaseChangeTwoPhaseMixtures::interfaceHeatResistance::
 mDotAlphal() const
 {
-    volScalarField limitedAlpha1
-    (
-        min(max(mixture_.alpha1(), scalar(0)), scalar(1))
-    );
-
-    volScalarField limitedAlpha2
-    (
-        min(max(mixture_.alpha2(), scalar(0)), scalar(1))
-    );
-
     return Pair<tmp<volScalarField>>
     (
-        (mDotc_/(limitedAlpha2 + SMALL)),
-       -(mDote_/(limitedAlpha1 + SMALL))
+        (mDotc_/clamp(mixture_.alpha2(), scalarMinMax(SMALL, 1))),
+       -(mDote_/clamp(mixture_.alpha1(), scalarMinMax(SMALL, 1)))
     );
 }
 
diff --git a/applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/twoPhaseMixtureEThermo/twoPhaseMixtureEThermo.C b/applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/twoPhaseMixtureEThermo/twoPhaseMixtureEThermo.C
index 26b975263e..0cf652dbf5 100644
--- a/applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/twoPhaseMixtureEThermo/twoPhaseMixtureEThermo.C
+++ b/applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/twoPhaseMixtureEThermo/twoPhaseMixtureEThermo.C
@@ -155,7 +155,7 @@ Foam::tmp<Foam::volScalarField> Foam::twoPhaseMixtureEThermo::Cp() const
 {
     const volScalarField limitedAlpha1
     (
-        min(max(alpha1_, scalar(0)), scalar(1))
+        clamp(alpha1_, zero_one{})
     );
 
     return tmp<volScalarField>
@@ -176,13 +176,11 @@ Foam::tmp<Foam::scalarField> Foam::twoPhaseMixtureEThermo::Cp
     const label patchi
 ) const
 {
-    const volScalarField limitedAlpha1
+    const scalarField alpha1p
     (
-        min(max(alpha1_, scalar(0)), scalar(1))
+        clamp(alpha1_.boundaryField()[patchi], zero_one{})
     );
 
-    const scalarField& alpha1p = limitedAlpha1.boundaryField()[patchi];
-
     return
     (
         alpha1p*Cp1().value() + (scalar(1) - alpha1p)*Cp2().value()
@@ -194,7 +192,7 @@ Foam::tmp<Foam::volScalarField> Foam::twoPhaseMixtureEThermo::rho() const
 {
     const volScalarField limitedAlpha1
     (
-        min(max(alpha1_, scalar(0)), scalar(1))
+        clamp(alpha1_, zero_one{})
     );
 
     return tmp<volScalarField>
@@ -214,13 +212,11 @@ Foam::tmp<Foam::scalarField> Foam::twoPhaseMixtureEThermo::rho
     const label patchi
 ) const
 {
-    const volScalarField limitedAlpha1
+    const scalarField alpha1p
     (
-        min(max(alpha1_, scalar(0)), scalar(1))
+        clamp(alpha1_.boundaryField()[patchi], zero_one{})
     );
 
-    const scalarField& alpha1p = limitedAlpha1.boundaryField()[patchi];
-
     return
     (
         alpha1p*rho1().value() + (scalar(1) - alpha1p)*rho2().value()
@@ -232,7 +228,7 @@ Foam::tmp<Foam::volScalarField> Foam::twoPhaseMixtureEThermo::Cv() const
 {
     const volScalarField limitedAlpha1
     (
-        min(max(alpha1_, scalar(0)), scalar(1))
+        clamp(alpha1_, zero_one{})
     );
 
     return tmp<volScalarField>
@@ -253,13 +249,11 @@ Foam::tmp<Foam::scalarField> Foam::twoPhaseMixtureEThermo::Cv
     const label patchi
 ) const
 {
-    const volScalarField limitedAlpha1
+    const scalarField alpha1p
     (
-        min(max(alpha1_, scalar(0)), scalar(1))
+        clamp(alpha1_.boundaryField()[patchi], zero_one{})
     );
 
-    const scalarField& alpha1p = limitedAlpha1.boundaryField()[patchi];
-
     return
     (
         alpha1p*Cv1().value() + (scalar(1) - alpha1p)*Cv2().value()
@@ -339,7 +333,7 @@ Foam::tmp<Foam::volScalarField> Foam::twoPhaseMixtureEThermo::kappa() const
 {
     const volScalarField limitedAlpha1
     (
-        min(max(alpha1_, scalar(0)), scalar(1))
+        clamp(alpha1_, zero_one{})
     );
 
     return tmp<volScalarField>
@@ -358,13 +352,11 @@ Foam::tmp<Foam::scalarField> Foam::twoPhaseMixtureEThermo::kappa
     const label patchi
 ) const
 {
-    const volScalarField limitedAlpha1
+    const scalarField alpha1p
     (
-        min(max(alpha1_, scalar(0)), scalar(1))
+        clamp(alpha1_.boundaryField()[patchi], zero_one{})
     );
 
-    const scalarField& alpha1p = limitedAlpha1.boundaryField()[patchi];
-
     return (alpha1p*kappa1().value() + (1 - alpha1p)*kappa2().value());
 }
 
@@ -402,13 +394,11 @@ Foam::tmp<Foam::scalarField> Foam::twoPhaseMixtureEThermo::kappaEff
     const label patchi
 ) const
 {
-    const volScalarField limitedAlpha1
+    const scalarField alpha1p
     (
-        min(max(alpha1_, scalar(0)), scalar(1))
+        clamp(alpha1_.boundaryField()[patchi], zero_one{})
     );
 
-    const scalarField& alpha1p = limitedAlpha1.boundaryField()[patchi];
-
     return
         (alpha1p*kappa1().value() + (1 - alpha1p)*kappa2().value()) + kappat;
 
@@ -435,13 +425,11 @@ Foam::tmp<Foam::scalarField> Foam::twoPhaseMixtureEThermo::alphaEff
     const label patchi
 ) const
 {
-    const volScalarField limitedAlpha1
+    const scalarField alpha1p
     (
-        min(max(alpha1_, scalar(0)), scalar(1))
+        clamp(alpha1_.boundaryField()[patchi], zero_one{})
     );
 
-    const scalarField& alpha1p = limitedAlpha1.boundaryField()[patchi];
-
     const scalarField rho
     (
         alpha1p*rho1().value() + (1.0 - alpha1p)*rho2().value()
diff --git a/applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/Kunz/Kunz.C b/applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/Kunz/Kunz.C
index ce32f5a5ea..ad6fe801d9 100644
--- a/applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/Kunz/Kunz.C
+++ b/applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/Kunz/Kunz.C
@@ -70,7 +70,7 @@ Foam::Pair<Foam::tmp<Foam::volScalarField>>
 Foam::phaseChangeTwoPhaseMixtures::Kunz::mDotAlphal() const
 {
     const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p");
-    volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1)));
+    volScalarField limitedAlpha1(clamp(alpha1_, zero_one{}));
 
     return Pair<tmp<volScalarField>>
     (
@@ -85,7 +85,7 @@ Foam::Pair<Foam::tmp<Foam::volScalarField>>
 Foam::phaseChangeTwoPhaseMixtures::Kunz::mDotP() const
 {
     const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p");
-    volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1)));
+    volScalarField limitedAlpha1(clamp(alpha1_, zero_one{}));
 
     return Pair<tmp<volScalarField>>
     (
diff --git a/applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/Merkle/Merkle.C b/applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/Merkle/Merkle.C
index ff323e83bb..75d5964db6 100644
--- a/applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/Merkle/Merkle.C
+++ b/applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/Merkle/Merkle.C
@@ -82,7 +82,7 @@ Foam::Pair<Foam::tmp<Foam::volScalarField>>
 Foam::phaseChangeTwoPhaseMixtures::Merkle::mDotP() const
 {
     const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p");
-    volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1)));
+    volScalarField limitedAlpha1(clamp(alpha1_, zero_one{}));
 
     return Pair<tmp<volScalarField>>
     (
diff --git a/applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/SchnerrSauer/SchnerrSauer.C b/applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/SchnerrSauer/SchnerrSauer.C
index b1e1d3e7a0..c65d51185b 100644
--- a/applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/SchnerrSauer/SchnerrSauer.C
+++ b/applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/SchnerrSauer/SchnerrSauer.C
@@ -99,7 +99,7 @@ Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer::pCoeff
     const volScalarField& p
 ) const
 {
-    volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1)));
+    volScalarField limitedAlpha1(clamp(alpha1_, zero_one{}));
     volScalarField rho
     (
         limitedAlpha1*rho1() + (scalar(1) - limitedAlpha1)*rho2()
@@ -117,7 +117,7 @@ Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer::mDotAlphal() const
     const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p");
     volScalarField pCoeff(this->pCoeff(p));
 
-    volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1)));
+    volScalarField limitedAlpha1(clamp(alpha1_, zero_one{}));
 
     return Pair<tmp<volScalarField>>
     (
@@ -134,7 +134,7 @@ Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer::mDotP() const
     const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p");
     volScalarField pCoeff(this->pCoeff(p));
 
-    volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1)));
+    volScalarField limitedAlpha1(clamp(alpha1_, zero_one{}));
     volScalarField apCoeff(limitedAlpha1*pCoeff);
 
     return Pair<tmp<volScalarField>>
diff --git a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/vectorTools/vectorTools.H b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/vectorTools/vectorTools.H
index dee620181c..45594daba1 100644
--- a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/vectorTools/vectorTools.H
+++ b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/vectorTools/vectorTools.H
@@ -114,7 +114,7 @@ namespace vectorTools
         scalar cosPhi = (a & b)/(mag(a)*mag(b) + tolerance);
 
         // Enforce bounding between -1 and 1
-        return min(max(cosPhi, -1), 1);
+        return clamp(cosPhi, -1, 1);
     }
 
     //- Calculate angle between a and b in radians
@@ -129,7 +129,7 @@ namespace vectorTools
         scalar cosPhi = (a & b)/(mag(a)*mag(b) + tolerance);
 
         // Enforce bounding between -1 and 1
-        return acos( min(max(cosPhi, -1), 1) );
+        return acos(clamp(cosPhi, -1, 1));
     }
 
     //- Calculate angle between a and b in degrees
diff --git a/src/ODE/ODESolvers/adaptiveSolver/adaptiveSolver.C b/src/ODE/ODESolvers/adaptiveSolver/adaptiveSolver.C
index 126b0cbc1e..04be67825b 100644
--- a/src/ODE/ODESolvers/adaptiveSolver/adaptiveSolver.C
+++ b/src/ODE/ODESolvers/adaptiveSolver/adaptiveSolver.C
@@ -101,7 +101,7 @@ void Foam::adaptiveSolver::solve
     if (err > pow(maxScale_/safeScale_, -1.0/alphaInc_))
     {
         dxTry =
-            min(max(safeScale_*pow(err, -alphaInc_), minScale_), maxScale_)*dx;
+            clamp(safeScale_*pow(err, -alphaInc_), minScale_, maxScale_)*dx;
     }
     else
     {
diff --git a/src/OpenFOAM/meshes/meshShapes/face/face.C b/src/OpenFOAM/meshes/meshShapes/face/face.C
index 470e4b7b47..bf646864a7 100644
--- a/src/OpenFOAM/meshes/meshShapes/face/face.C
+++ b/src/OpenFOAM/meshes/meshShapes/face/face.C
@@ -76,7 +76,7 @@ Foam::label Foam::face::mostConcaveAngle
 
         // NOTE: is -ve angle since left edge pointing in other direction
         scalar edgeCos = (leftEdge & rightEdge);
-        scalar edgeAngle = acos(max(-1.0, min(1.0, edgeCos)));
+        scalar edgeAngle = acos(clamp(edgeCos, -1, 1));
 
         scalar angle;
 
@@ -205,7 +205,7 @@ Foam::label Foam::face::split
             splitEdge.normalise();
 
             const scalar splitCos = splitEdge & rightEdge;
-            const scalar splitAngle = acos(max(-1.0, min(1.0, splitCos)));
+            const scalar splitAngle = acos(clamp(splitCos, -1, 1));
             const scalar angleDiff = fabs(splitAngle - bisectAngle);
 
             if (angleDiff < minDiff)
diff --git a/src/OpenFOAM/meshes/polyMesh/polyMeshCheck/polyMeshCheck.C b/src/OpenFOAM/meshes/polyMesh/polyMeshCheck/polyMeshCheck.C
index 04fc7a63b7..255335aafa 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyMeshCheck/polyMeshCheck.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyMeshCheck/polyMeshCheck.C
@@ -101,7 +101,7 @@ bool Foam::polyMesh::checkFaceOrthogonality
                         << " between cells " << own[facei]
                         << " and " << nei[facei]
                         << ": Angle = "
-                        << radToDeg(::acos(min(1.0, max(-1.0, ortho[facei]))))
+                        << radToDeg(::acos(clamp(ortho[facei], -1, 1)))
                         << " deg." << endl;
                 }
 
@@ -130,9 +130,9 @@ bool Foam::polyMesh::checkFaceOrthogonality
             if (debug || report)
             {
                 Info<< "    Mesh non-orthogonality Max: "
-                    << radToDeg(::acos(min(1.0, max(-1.0, minDDotS))))
+                    << radToDeg(::acos(clamp(minDDotS, -1, 1)))
                     << " average: "
-                    << radToDeg(::acos(min(1.0, max(-1.0, sumDDotS/nSummed))))
+                    << radToDeg(::acos(clamp(sumDDotS/nSummed, -1, 1)))
                     << endl;
             }
         }
diff --git a/src/OpenFOAM/meshes/primitiveShapes/triangle/triangleI.H b/src/OpenFOAM/meshes/primitiveShapes/triangle/triangleI.H
index 70f5f177b9..212cdcdc3b 100644
--- a/src/OpenFOAM/meshes/primitiveShapes/triangle/triangleI.H
+++ b/src/OpenFOAM/meshes/primitiveShapes/triangle/triangleI.H
@@ -334,7 +334,7 @@ inline Foam::scalar Foam::triangle<Point, PointRef>::circumRadius() const
     }
 
     const scalar a = (d1 + d2)*(d2 + d3)*(d3 + d1) / denom;
-    return 0.5*Foam::sqrt(min(GREAT, max(0, a)));
+    return 0.5*Foam::sqrt(clamp(a, 0, GREAT));
 }
 
 
diff --git a/src/OpenFOAM/primitives/functions/Function1/InputValueMapper/InputValueMapperI.H b/src/OpenFOAM/primitives/functions/Function1/InputValueMapper/InputValueMapperI.H
index 8b769ac647..7fee35bec8 100644
--- a/src/OpenFOAM/primitives/functions/Function1/InputValueMapper/InputValueMapperI.H
+++ b/src/OpenFOAM/primitives/functions/Function1/InputValueMapper/InputValueMapperI.H
@@ -47,7 +47,7 @@ inline Type Foam::Function1Types::InputValueMapper<Type>::value
         }
         case mappingMode::MINMAX:
         {
-            scalar tlim = min(max(t, min_), max_);
+            scalar tlim = clamp(t, min_, max_);
 
             return value_->value(tlim);
         }
@@ -86,8 +86,8 @@ Type Foam::Function1Types::InputValueMapper<Type>::integrate
         }
         case mappingMode::MINMAX:
         {
-            scalar xlim0 = min(max(x1, min_), max_);
-            scalar xlim1 = min(max(x2, min_), max_);
+            scalar xlim0 = clamp(x1, min_, max_);
+            scalar xlim1 = clamp(x2, min_, max_);
 
             Type intValue = value_->integrate(xlim0, xlim1);
 
diff --git a/src/OpenFOAM/primitives/triad/triad.C b/src/OpenFOAM/primitives/triad/triad.C
index c4dccf9929..53e362c5c1 100644
--- a/src/OpenFOAM/primitives/triad/triad.C
+++ b/src/OpenFOAM/primitives/triad/triad.C
@@ -395,7 +395,7 @@ Foam::scalar Foam::diff(const triad& A, const triad& B)
             (tmpA[dir] & tmpB[dir])
            /(Foam::mag(tmpA[dir])*Foam::mag(tmpA[dir]) + SMALL);
 
-        cosPhi = min(max(cosPhi, -1), 1);
+        cosPhi = clamp(cosPhi, -1, 1);
 
         sumDifference += mag(cosPhi - 1);
     }
diff --git a/src/TurbulenceModels/turbulenceModels/RAS/kOmegaSSTLM/kOmegaSSTLM.C b/src/TurbulenceModels/turbulenceModels/RAS/kOmegaSSTLM/kOmegaSSTLM.C
index c4a6af700a..d78511df8d 100644
--- a/src/TurbulenceModels/turbulenceModels/RAS/kOmegaSSTLM/kOmegaSSTLM.C
+++ b/src/TurbulenceModels/turbulenceModels/RAS/kOmegaSSTLM/kOmegaSSTLM.C
@@ -70,7 +70,7 @@ tmp<volScalarField::Internal> kOmegaSSTLM<BasicTurbulenceModel>::epsilonByk
 ) const
 {
     return
-        min(max(gammaIntEff_, scalar(0.1)), scalar(1))
+        clamp(gammaIntEff_, scalarMinMax(0.1, 1))
        *kOmegaSST<BasicTurbulenceModel>::epsilonByk(F1, gradU);
 }
 
diff --git a/src/TurbulenceModels/turbulenceModels/RAS/realizableKE/realizableKE.C b/src/TurbulenceModels/turbulenceModels/RAS/realizableKE/realizableKE.C
index a579204d0e..f519ce37f0 100644
--- a/src/TurbulenceModels/turbulenceModels/RAS/realizableKE/realizableKE.C
+++ b/src/TurbulenceModels/turbulenceModels/RAS/realizableKE/realizableKE.C
@@ -63,7 +63,7 @@ tmp<volScalarField> realizableKE<BasicTurbulenceModel>::rCmu
 
     volScalarField phis
     (
-        (1.0/3.0)*acos(min(max(sqrt(6.0)*W, -scalar(1)), scalar(1)))
+        (1.0/3.0)*acos(clamp(sqrt(6.0)*W, scalarMinMax(-1, 1)))
     );
     volScalarField As(sqrt(6.0)*cos(phis));
     volScalarField Us(sqrt(S2/2.0 + magSqr(skew(gradU))));
diff --git a/src/finiteArea/interpolation/edgeInterpolation/edgeInterpolation.C b/src/finiteArea/interpolation/edgeInterpolation/edgeInterpolation.C
index a75f322260..0e5f0b25f5 100644
--- a/src/finiteArea/interpolation/edgeInterpolation/edgeInterpolation.C
+++ b/src/finiteArea/interpolation/edgeInterpolation/edgeInterpolation.C
@@ -529,11 +529,7 @@ void Foam::edgeInterpolation::makeCorrectionVectors() const
     if (owner.size() > 0)
     {
         scalarField sinAlpha(deltaCoeffs*mag(CorrVecs.internalField()));
-
-        forAll(sinAlpha, edgeI)
-        {
-            sinAlpha[edgeI] = max(-1, min(sinAlpha[edgeI], 1));
-        }
+        sinAlpha.clamp_range(-1, 1);
 
         NonOrthogCoeff = max(Foam::asin(sinAlpha)*180.0/M_PI);
     }
diff --git a/src/finiteArea/interpolation/edgeInterpolation/schemes/Gamma/Gamma.H b/src/finiteArea/interpolation/edgeInterpolation/schemes/Gamma/Gamma.H
index d8de90a17e..80b118a7e4 100644
--- a/src/finiteArea/interpolation/edgeInterpolation/schemes/Gamma/Gamma.H
+++ b/src/finiteArea/interpolation/edgeInterpolation/schemes/Gamma/Gamma.H
@@ -110,7 +110,7 @@ public:
         gradcf = stabilise(gradcf, SMALL);
 
         scalar phict = 1 - 0.5*gradf/gradcf;
-        scalar limiter = min(max(phict/k_, 0), 1);
+        scalar limiter = clamp(phict/k_, 0, 1);
 
         return lerp(udWeight, cdWeight, limiter);
     }
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/Gamma/Gamma.H b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/Gamma/Gamma.H
index fc1f89eaae..5996e45d4b 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/Gamma/Gamma.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/Gamma/Gamma.H
@@ -97,7 +97,7 @@ public:
             faceFlux, phiP, phiN, gradcP, gradcN, d
         );
 
-        return min(max(phict/k_, 0), 1);
+        return clamp(phict/k_, 0, 1);
     }
 };
 
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/SFCD/SFCD.H b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/SFCD/SFCD.H
index c6aa9920af..a9298c1214 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/SFCD/SFCD.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/SFCD/SFCD.H
@@ -82,7 +82,7 @@ public:
             faceFlux, phiP, phiN, gradcP, gradcN, d
         );
 
-        scalar limitPhict = min(max(phict, 0), 0.5);
+        scalar limitPhict = clamp(phict, 0, 0.5);
         return limitPhict/(1 - limitPhict);
     }
 };
diff --git a/src/functionObjects/field/fieldValues/surfaceFieldValue/surfaceFieldValue.C b/src/functionObjects/field/fieldValues/surfaceFieldValue/surfaceFieldValue.C
index 22d691e199..e4091007a8 100644
--- a/src/functionObjects/field/fieldValues/surfaceFieldValue/surfaceFieldValue.C
+++ b/src/functionObjects/field/fieldValues/surfaceFieldValue/surfaceFieldValue.C
@@ -670,7 +670,7 @@ Foam::functionObjects::fieldValues::surfaceFieldValue::processValues
             // Uniformity index
             const scalar ui = 1 - numer/(2*mag(mean*areaTotal) + ROOTVSMALL);
 
-            return min(max(ui, 0), 1);
+            return clamp(ui, 0, 1);
         }
 
         default:
@@ -756,7 +756,7 @@ Foam::functionObjects::fieldValues::surfaceFieldValue::processValues
             // Uniformity index
             const scalar ui = 1 - numer/(2*mag(mean*areaTotal) + ROOTVSMALL);
 
-            return vector(min(max(ui, 0), 1), 0, 0);
+            return vector(clamp(ui, 0, 1), 0, 0);
         }
 
         default:
diff --git a/src/functionObjects/field/stabilityBlendingFactor/stabilityBlendingFactor.C b/src/functionObjects/field/stabilityBlendingFactor/stabilityBlendingFactor.C
index 8837f3784d..7839740c32 100644
--- a/src/functionObjects/field/stabilityBlendingFactor/stabilityBlendingFactor.C
+++ b/src/functionObjects/field/stabilityBlendingFactor/stabilityBlendingFactor.C
@@ -417,7 +417,7 @@ bool Foam::functionObjects::stabilityBlendingFactor::init(bool first)
             max
             (
                 indicator,
-                min(max(scalar(0), (Co - Co1_)/(Co2_ - Co1_)), scalar(1))
+                clamp((Co - Co1_)/(Co2_ - Co1_), zero_one{})
             );
 
         if (first)
diff --git a/src/functionObjects/field/stabilityBlendingFactor/stabilityBlendingFactor.H b/src/functionObjects/field/stabilityBlendingFactor/stabilityBlendingFactor.H
index 5823e65495..541553c734 100644
--- a/src/functionObjects/field/stabilityBlendingFactor/stabilityBlendingFactor.H
+++ b/src/functionObjects/field/stabilityBlendingFactor/stabilityBlendingFactor.H
@@ -152,7 +152,7 @@ Description
     For option 6, the following relation is used:
 
     \f[
-        fCoWeight = min(max((Co - Co1)/(Co2 - Co1), 0), 1)
+        fCoWeight = clamp((Co - Co1)/(Co2 - Co1), 0, 1)
     \f]
 
     where
diff --git a/src/fvOptions/sources/derived/solidificationMeltingSource/solidificationMeltingSource.C b/src/fvOptions/sources/derived/solidificationMeltingSource/solidificationMeltingSource.C
index d8fff9fb1d..2154433865 100644
--- a/src/fvOptions/sources/derived/solidificationMeltingSource/solidificationMeltingSource.C
+++ b/src/fvOptions/sources/derived/solidificationMeltingSource/solidificationMeltingSource.C
@@ -147,7 +147,7 @@ void Foam::fv::solidificationMeltingSource::update(const volScalarField& Cp)
         scalar Cpc = Cp[celli];
         scalar alpha1New = alpha1_[celli] + relax_*Cpc*(Tc - Tmelt_)/L_;
 
-        alpha1_[celli] = max(0, min(alpha1New, 1));
+        alpha1_[celli] = clamp(alpha1New, 0, 1);
         deltaT_[i] = Tc - Tmelt_;
     }
 
diff --git a/src/lagrangian/distributionModels/multiNormal/multiNormal.C b/src/lagrangian/distributionModels/multiNormal/multiNormal.C
index 43761f9326..8067ca5feb 100644
--- a/src/lagrangian/distributionModels/multiNormal/multiNormal.C
+++ b/src/lagrangian/distributionModels/multiNormal/multiNormal.C
@@ -168,7 +168,7 @@ Foam::scalar Foam::distributionModels::multiNormal::sample
     // Note: numerical approximation of the inverse function yields slight
     //       inaccuracies
 
-    return min(max(x, minValue_), maxValue_);
+    return clamp(x, minValue_, maxValue_);
 }
 
 
diff --git a/src/lagrangian/distributionModels/normal/normal.C b/src/lagrangian/distributionModels/normal/normal.C
index 203dc1a3a1..a3b27ae2a2 100644
--- a/src/lagrangian/distributionModels/normal/normal.C
+++ b/src/lagrangian/distributionModels/normal/normal.C
@@ -108,7 +108,7 @@ Foam::scalar Foam::distributionModels::normal::sample() const
     // Note: numerical approximation of the inverse function yields slight
     //       inaccuracies
 
-    return min(max(x, minValue_), maxValue_);
+    return clamp(x, minValue_, maxValue_);
 }
 
 
diff --git a/src/lagrangian/intermediate/parcels/Templates/ThermoParcel/ThermoParcel.C b/src/lagrangian/intermediate/parcels/Templates/ThermoParcel/ThermoParcel.C
index 7d507350a9..013fa5b954 100644
--- a/src/lagrangian/intermediate/parcels/Templates/ThermoParcel/ThermoParcel.C
+++ b/src/lagrangian/intermediate/parcels/Templates/ThermoParcel/ThermoParcel.C
@@ -300,7 +300,7 @@ Foam::scalar Foam::ThermoParcel<ParcelType>::calcHeatTransfer
 
     // Calculate the new temperature and the enthalpy transfer terms
     scalar Tnew = T_ + deltaT;
-    Tnew = min(max(Tnew, cloud.constProps().TMin()), cloud.constProps().TMax());
+    Tnew = clamp(Tnew, cloud.constProps().TMin(), cloud.constProps().TMax());
 
     dhsTrans -= m*Cp_*deltaTcp;
 
diff --git a/src/lagrangian/intermediate/submodels/Kinematic/ParticleForces/Drag/DistortedSphereDrag/DistortedSphereDragForce.C b/src/lagrangian/intermediate/submodels/Kinematic/ParticleForces/Drag/DistortedSphereDrag/DistortedSphereDragForce.C
index 1a71c63e05..5d4502bade 100644
--- a/src/lagrangian/intermediate/submodels/Kinematic/ParticleForces/Drag/DistortedSphereDrag/DistortedSphereDragForce.C
+++ b/src/lagrangian/intermediate/submodels/Kinematic/ParticleForces/Drag/DistortedSphereDrag/DistortedSphereDragForce.C
@@ -84,7 +84,7 @@ Foam::forceSuSp Foam::DistortedSphereDragForce<CloudType>::calcCoupled
 ) const
 {
     // Limit the drop distortion to y=0 (sphere) and y=1 (disk)
-    const scalar y = min(max(p.y(), scalar(0)), scalar(1));
+    const scalar y = clamp(p.y(), 0, 1);
 
     // (LMR:Eq. 10)
     return
diff --git a/src/lagrangian/spray/parcels/Templates/SprayParcel/SprayParcel.C b/src/lagrangian/spray/parcels/Templates/SprayParcel/SprayParcel.C
index 0968e7a077..8c3809b23e 100644
--- a/src/lagrangian/spray/parcels/Templates/SprayParcel/SprayParcel.C
+++ b/src/lagrangian/spray/parcels/Templates/SprayParcel/SprayParcel.C
@@ -361,9 +361,7 @@ Foam::scalar Foam::SprayParcel<ParcelType>::chi
         }
     }
 
-    chi = min(1.0, max(chi, 0.0));
-
-    return chi;
+    return clamp(chi, 0, 1);
 }
 
 
diff --git a/src/lagrangian/spray/submodels/BreakupModel/ETAB/ETAB.C b/src/lagrangian/spray/submodels/BreakupModel/ETAB/ETAB.C
index c642019c79..fe5d8468c5 100644
--- a/src/lagrangian/spray/submodels/BreakupModel/ETAB/ETAB.C
+++ b/src/lagrangian/spray/submodels/BreakupModel/ETAB/ETAB.C
@@ -177,8 +177,7 @@ bool Foam::ETAB<CloudType>::update
                     Kbr =k2_*omega*sqrtWe;
                 }
 
-                scalar rWetmp = 1.0/Wetmp;
-                scalar cosdtbu = max(-1.0, min(1.0, 1.0 - rWetmp));
+                scalar cosdtbu = clamp((1.0 - 1.0/Wetmp), -1, 1);
                 scalar dtbu = romega*acos(cosdtbu);
                 scalar decay = exp(-Kbr*dtbu);
 
diff --git a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.C b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.C
index 2bc115e61c..c0af94ad08 100644
--- a/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.C
+++ b/src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.C
@@ -326,8 +326,8 @@ void Foam::cyclicACMIPolyPatch::resetAMI(const UList<point>& points) const
     // Note:
     // - assumes that the non-overlap patches are decomposed using the same
     //   decomposition as the coupled patches (per side)
-    srcMask_ = min(scalar(1), max(scalar(0), AMI.srcWeightsSum()));
-    tgtMask_ = min(scalar(1), max(scalar(0), AMI.tgtWeightsSum()));
+    srcMask_ = clamp(AMI.srcWeightsSum(), zero_one{});
+    tgtMask_ = clamp(AMI.tgtWeightsSum(), zero_one{});
 
     if (debug)
     {
diff --git a/src/meshTools/searchableSurfaces/searchableCone/searchableCone.C b/src/meshTools/searchableSurfaces/searchableCone/searchableCone.C
index 4e47cb144f..379eaacf92 100644
--- a/src/meshTools/searchableSurfaces/searchableCone/searchableCone.C
+++ b/src/meshTools/searchableSurfaces/searchableCone/searchableCone.C
@@ -113,11 +113,11 @@ void Foam::searchableCone::findNearestAndNormal
     v.normalise();
 
     // Nearest and normal on disk at point1
-    point disk1Point(point1_ + min(max(magV, innerRadius1_), radius1_)*v);
+    point disk1Point(point1_ + clamp(magV, innerRadius1_, radius1_)*v);
     vector disk1Normal(-unitDir_);
 
     // Nearest and normal on disk at point2
-    point disk2Point(point2_ + min(max(magV, innerRadius2_), radius2_)*v);
+    point disk2Point(point2_ + clamp(magV, innerRadius2_, radius2_)*v);
     vector disk2Normal(unitDir_);
 
     // Nearest and normal on cone. Initialise to far-away point so if not
diff --git a/src/meshTools/triSurface/faceTriangulation/faceTriangulation.C b/src/meshTools/triSurface/faceTriangulation/faceTriangulation.C
index f6cac88650..aab6832a25 100644
--- a/src/meshTools/triSurface/faceTriangulation/faceTriangulation.C
+++ b/src/meshTools/triSurface/faceTriangulation/faceTriangulation.C
@@ -83,7 +83,7 @@ void Foam::faceTriangulation::calcHalfAngle
 )
 {
     // truncate cos to +-1 to prevent negative numbers
-    scalar cos = max(-1, min(1, e0 & e1));
+    scalar cos = clamp((e0 & e1), -1, 1);
 
     scalar sin = (e0 ^ e1) & normal;
 
diff --git a/src/phaseSystemModels/multiphaseInter/phasesSystem/MassTransferPhaseSystem/MassTransferPhaseSystem.C b/src/phaseSystemModels/multiphaseInter/phasesSystem/MassTransferPhaseSystem/MassTransferPhaseSystem.C
index e9039e3971..df41e3555b 100644
--- a/src/phaseSystemModels/multiphaseInter/phasesSystem/MassTransferPhaseSystem/MassTransferPhaseSystem.C
+++ b/src/phaseSystemModels/multiphaseInter/phasesSystem/MassTransferPhaseSystem/MassTransferPhaseSystem.C
@@ -600,11 +600,8 @@ void Foam::MassTransferPhaseSystem<BasePhaseSystem>::alphaTransfer
 
         if (includeDivU)
         {
-            SuPhase1 +=
-                fvc::div(phi)*min(max(alpha1, scalar(0)), scalar(1));
-
-            SuPhase2 +=
-                fvc::div(phi)*min(max(alpha2, scalar(0)), scalar(1));
+            SuPhase1 += fvc::div(phi)*clamp(alpha1, zero_one{});
+            SuPhase2 += fvc::div(phi)*clamp(alpha2, zero_one{});
         }
 
         // NOTE: dmdtNet is distributed in terms =
diff --git a/src/phaseSystemModels/multiphaseInter/phasesSystem/massTransferModels/Lee/Lee.C b/src/phaseSystemModels/multiphaseInter/phasesSystem/massTransferModels/Lee/Lee.C
index d0cde4679e..61cf147853 100644
--- a/src/phaseSystemModels/multiphaseInter/phasesSystem/massTransferModels/Lee/Lee.C
+++ b/src/phaseSystemModels/multiphaseInter/phasesSystem/massTransferModels/Lee/Lee.C
@@ -57,7 +57,7 @@ Foam::meltingEvaporationModels::Lee<Thermo, OtherThermo>::Kexp
     {
         const volScalarField from
         (
-            min(max(this->pair().from(), scalar(0)), scalar(1))
+            clamp(this->pair().from(), zero_one{})
         );
 
         const volScalarField coeff
@@ -95,9 +95,9 @@ Foam::meltingEvaporationModels::Lee<Thermo, OtherThermo>::KSp
 {
     if (this->modelVariable_ == variable)
     {
-        volScalarField from
+        const volScalarField from
         (
-            min(max(this->pair().from(), scalar(0)), scalar(1))
+            clamp(this->pair().from(), zero_one{})
         );
 
         const volScalarField coeff
@@ -123,7 +123,7 @@ Foam::meltingEvaporationModels::Lee<Thermo, OtherThermo>::KSp
     }
     else
     {
-        return tmp<volScalarField> ();
+        return nullptr;
     }
 }
 
@@ -138,9 +138,9 @@ Foam::meltingEvaporationModels::Lee<Thermo, OtherThermo>::KSu
 {
     if (this->modelVariable_ == variable)
     {
-        volScalarField from
+        const volScalarField from
         (
-            min(max(this->pair().from(), scalar(0)), scalar(1))
+            clamp(this->pair().from(), zero_one{})
         );
 
         const volScalarField coeff
@@ -165,7 +165,7 @@ Foam::meltingEvaporationModels::Lee<Thermo, OtherThermo>::KSu
     }
     else
     {
-        return tmp<volScalarField> ();
+        return nullptr;
     }
 }
 
diff --git a/src/phaseSystemModels/multiphaseInter/phasesSystem/multiphaseInterSystem/multiphaseInterSystem.C b/src/phaseSystemModels/multiphaseInter/phasesSystem/multiphaseInterSystem/multiphaseInterSystem.C
index 3df86d343a..fc654b05c1 100644
--- a/src/phaseSystemModels/multiphaseInter/phasesSystem/multiphaseInterSystem/multiphaseInterSystem.C
+++ b/src/phaseSystemModels/multiphaseInter/phasesSystem/multiphaseInterSystem/multiphaseInterSystem.C
@@ -1277,12 +1277,12 @@ Foam::tmp<Foam::volVectorField> Foam::multiphaseInterSystem::nVolHatfv
 {
     const volScalarField alpha1m
     (
-        min(max(alpha1, scalar(0)), scalar(1))
+        clamp(alpha1, zero_one{})
     );
 
     const volScalarField alpha2m
     (
-        min(max(alpha2, scalar(0)), scalar(1))
+        clamp(alpha2, zero_one{})
     );
 
     const volVectorField gradAlphaf
@@ -1311,12 +1311,12 @@ Foam::tmp<Foam::surfaceVectorField> Foam::multiphaseInterSystem::nHatfv
 
     const volScalarField alpha1b
     (
-        min(max(alpha1, scalar(0)), scalar(1))
+        clamp(alpha1, zero_one{})
     );
 
     const volScalarField alpha2b
     (
-        min(max(alpha2, scalar(0)), scalar(1))
+        clamp(alpha2, zero_one{})
     );
 
     surfaceVectorField gradAlphaf
diff --git a/src/phaseSystemModels/multiphaseInter/phasesSystem/multiphaseSystem/multiphaseSystem.C b/src/phaseSystemModels/multiphaseInter/phasesSystem/multiphaseSystem/multiphaseSystem.C
index ffda1f535a..7758370b7f 100644
--- a/src/phaseSystemModels/multiphaseInter/phasesSystem/multiphaseSystem/multiphaseSystem.C
+++ b/src/phaseSystemModels/multiphaseInter/phasesSystem/multiphaseSystem/multiphaseSystem.C
@@ -286,8 +286,7 @@ void Foam::multiphaseInter::multiphaseSystem::solveAlphas()
 
             // Add alpha*div(U)
             //const volScalarField& alpha = phase;
-            //Su_[phase.name()] +=
-            //    fvc::div(phi)*min(max(alpha, scalar(0)), scalar(1));
+            //Su_[phase.name()] += fvc::div(phi)*clamp(alpha, zero_one{});
         }
 
         // Fill Su and Sp
diff --git a/src/phaseSystemModels/reactingEuler/multiphaseSystem/interfacialModels/virtualMassModels/Lamb/Lamb.C b/src/phaseSystemModels/reactingEuler/multiphaseSystem/interfacialModels/virtualMassModels/Lamb/Lamb.C
index ee9c252ce4..5743794240 100644
--- a/src/phaseSystemModels/reactingEuler/multiphaseSystem/interfacialModels/virtualMassModels/Lamb/Lamb.C
+++ b/src/phaseSystemModels/reactingEuler/multiphaseSystem/interfacialModels/virtualMassModels/Lamb/Lamb.C
@@ -69,7 +69,7 @@ Foam::virtualMassModels::Lamb::~Lamb()
 
 Foam::tmp<Foam::volScalarField> Foam::virtualMassModels::Lamb::Cvm() const
 {
-    volScalarField E(min(max(pair_.E(), SMALL), 1 - SMALL));
+    volScalarField E(clamp(pair_.E(), scalarMinMax(SMALL, 1 - SMALL)));
     volScalarField rtOmEsq(sqrt(1 - sqr(E)));
 
     return
diff --git a/src/phaseSystemModels/reactingEuler/twoPhaseCompressibleTurbulenceModels/kineticTheoryModels/radialModel/SinclairJackson/SinclairJacksonRadial.C b/src/phaseSystemModels/reactingEuler/twoPhaseCompressibleTurbulenceModels/kineticTheoryModels/radialModel/SinclairJackson/SinclairJacksonRadial.C
index 4e7ffdb7c1..e0e840b418 100644
--- a/src/phaseSystemModels/reactingEuler/twoPhaseCompressibleTurbulenceModels/kineticTheoryModels/radialModel/SinclairJackson/SinclairJacksonRadial.C
+++ b/src/phaseSystemModels/reactingEuler/twoPhaseCompressibleTurbulenceModels/kineticTheoryModels/radialModel/SinclairJackson/SinclairJacksonRadial.C
@@ -90,7 +90,11 @@ Foam::kineticTheoryModels::radialModels::SinclairJackson::g0prime
 {
     volScalarField aByaMax
     (
-        cbrt(min(max(alpha, scalar(1e-3)), alphaMinFriction)/alphaMax)
+        cbrt
+        (
+            clamp(alpha, scalarMinMax(1e-3, alphaMinFriction.value()))
+          / alphaMax
+        )
     );
 
     return (1.0/(3*alphaMax))/sqr(aByaMax - sqr(aByaMax));
diff --git a/src/phaseSystemModels/twoPhaseEuler/phaseCompressibleTurbulenceModels/kineticTheoryModels/radialModel/SinclairJackson/SinclairJacksonRadial.C b/src/phaseSystemModels/twoPhaseEuler/phaseCompressibleTurbulenceModels/kineticTheoryModels/radialModel/SinclairJackson/SinclairJacksonRadial.C
index d8560e28a1..19eca49367 100644
--- a/src/phaseSystemModels/twoPhaseEuler/phaseCompressibleTurbulenceModels/kineticTheoryModels/radialModel/SinclairJackson/SinclairJacksonRadial.C
+++ b/src/phaseSystemModels/twoPhaseEuler/phaseCompressibleTurbulenceModels/kineticTheoryModels/radialModel/SinclairJackson/SinclairJacksonRadial.C
@@ -90,7 +90,11 @@ Foam::kineticTheoryModels::radialModels::SinclairJackson::g0prime
 {
     volScalarField aByaMax
     (
-        cbrt(min(max(alpha, scalar(1e-3)), alphaMinFriction)/alphaMax)
+        cbrt
+        (
+            clamp(alpha, scalarMinMax(1e-3, alphaMinFriction.value()))
+          / alphaMax
+        )
     );
 
     return (1.0/(3*alphaMax))/sqr(aByaMax - sqr(aByaMax));
diff --git a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/interfacialModels/virtualMassModels/Lamb/Lamb.C b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/interfacialModels/virtualMassModels/Lamb/Lamb.C
index c08f64a232..1ce201fde8 100644
--- a/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/interfacialModels/virtualMassModels/Lamb/Lamb.C
+++ b/src/phaseSystemModels/twoPhaseEuler/twoPhaseSystem/interfacialModels/virtualMassModels/Lamb/Lamb.C
@@ -69,7 +69,7 @@ Foam::virtualMassModels::Lamb::~Lamb()
 
 Foam::tmp<Foam::volScalarField> Foam::virtualMassModels::Lamb::Cvm() const
 {
-    volScalarField E(min(max(pair_.E(), SMALL), 1 - SMALL));
+    volScalarField E(clamp(pair_.E(), scalarMinMax(SMALL, 1 - SMALL)));
     volScalarField rtOmEsq(sqrt(1 - sqr(E)));
 
     return
diff --git a/src/sixDoFRigidBodyMotion/pointPatchFields/derived/sixDoFRigidBodyDisplacement/sixDoFRigidBodyDisplacementPointPatchVectorField.C b/src/sixDoFRigidBodyMotion/pointPatchFields/derived/sixDoFRigidBodyDisplacement/sixDoFRigidBodyDisplacementPointPatchVectorField.C
index e804362b8b..ee455f158a 100644
--- a/src/sixDoFRigidBodyMotion/pointPatchFields/derived/sixDoFRigidBodyDisplacement/sixDoFRigidBodyDisplacementPointPatchVectorField.C
+++ b/src/sixDoFRigidBodyMotion/pointPatchFields/derived/sixDoFRigidBodyDisplacement/sixDoFRigidBodyDisplacementPointPatchVectorField.C
@@ -233,7 +233,7 @@ void sixDoFRigidBodyDisplacementPointPatchVectorField::updateCoeffs()
         g_ = g.value();
     }
 
-    // scalar ramp = min(max((t.value() - 5)/10, 0), 1);
+    // scalar ramp = clamp((t.value() - 5)/10, 0, 1);
     scalar ramp = 1.0;
 
     motion_.update
diff --git a/src/sixDoFRigidBodyMotion/sixDoFRigidBodyMotionSolver/sixDoFRigidBodyMotionSolver.C b/src/sixDoFRigidBodyMotion/sixDoFRigidBodyMotionSolver/sixDoFRigidBodyMotionSolver.C
index eb6d00851c..d3559f4ea9 100644
--- a/src/sixDoFRigidBodyMotion/sixDoFRigidBodyMotionSolver/sixDoFRigidBodyMotionSolver.C
+++ b/src/sixDoFRigidBodyMotion/sixDoFRigidBodyMotionSolver/sixDoFRigidBodyMotionSolver.C
@@ -219,7 +219,7 @@ void Foam::sixDoFRigidBodyMotionSolver::solve()
         coeffDict().readIfPresent("g", g);
     }
 
-    // const scalar ramp = min(max((this->db().time().value() - 5)/10, 0), 1);
+    // const scalar ramp = clamp((this->db().time().value() - 5)/10, 0, 1);
     const scalar ramp = 1.0;
 
     if (test_)
diff --git a/src/thermoTools/derivedFvPatchFields/outletMappedUniformInletHeatAddition/outletMappedUniformInletHeatAdditionFvPatchField.C b/src/thermoTools/derivedFvPatchFields/outletMappedUniformInletHeatAddition/outletMappedUniformInletHeatAdditionFvPatchField.C
index 5e7b8daa3a..900c93ad25 100644
--- a/src/thermoTools/derivedFvPatchFields/outletMappedUniformInletHeatAddition/outletMappedUniformInletHeatAdditionFvPatchField.C
+++ b/src/thermoTools/derivedFvPatchFields/outletMappedUniformInletHeatAddition/outletMappedUniformInletHeatAdditionFvPatchField.C
@@ -170,7 +170,7 @@ void Foam::outletMappedUniformInletHeatAdditionFvPatchField::updateCoeffs()
 
         scalar totalPhiCp = gSum(outletPatchPhi)*gAverage(Cpf);
 
-        operator==(min(max(averageOutletField + Q_/totalPhiCp, TMin_), TMax_));
+        operator==(clamp(averageOutletField + Q_/totalPhiCp, TMin_, TMax_));
     }
     else
     {
diff --git a/src/thermophysicalModels/specie/thermo/janaf/janafThermoI.H b/src/thermophysicalModels/specie/thermo/janaf/janafThermoI.H
index 919b1454dc..587907582c 100644
--- a/src/thermophysicalModels/specie/thermo/janaf/janafThermoI.H
+++ b/src/thermophysicalModels/specie/thermo/janaf/janafThermoI.H
@@ -123,12 +123,10 @@ inline Foam::scalar Foam::janafThermo<EquationOfState>::limit
             << Tlow_ << " -> " << Thigh_ << ";  T = " << T
             << endl;
 
-        return min(max(T, Tlow_), Thigh_);
-    }
-    else
-    {
-        return T;
+        return clamp(T, Tlow_, Thigh_);
     }
+
+    return T;
 }
 
 
diff --git a/src/transportModels/geometricVoF/advectionSchemes/isoAdvection/isoAdvection.C b/src/transportModels/geometricVoF/advectionSchemes/isoAdvection/isoAdvection.C
index 344901b84e..fc9e8746a3 100644
--- a/src/transportModels/geometricVoF/advectionSchemes/isoAdvection/isoAdvection.C
+++ b/src/transportModels/geometricVoF/advectionSchemes/isoAdvection/isoAdvection.C
@@ -631,7 +631,7 @@ void Foam::isoAdvection::applyBruteForceBounding()
 
     if (dict_.getOrDefault("clip", true))
     {
-        alpha1_ = min(scalar(1), max(scalar(0), alpha1_));
+        alpha1_.clamp_range(zero_one{});
         alpha1Changed = true;
     }
 
diff --git a/src/transportModels/incompressible/incompressibleTwoPhaseMixture/incompressibleTwoPhaseMixture.C b/src/transportModels/incompressible/incompressibleTwoPhaseMixture/incompressibleTwoPhaseMixture.C
index ba81228b88..4ad68c9825 100644
--- a/src/transportModels/incompressible/incompressibleTwoPhaseMixture/incompressibleTwoPhaseMixture.C
+++ b/src/transportModels/incompressible/incompressibleTwoPhaseMixture/incompressibleTwoPhaseMixture.C
@@ -48,7 +48,7 @@ void Foam::incompressibleTwoPhaseMixture::calcNu()
     const volScalarField limitedAlpha1
     (
         "limitedAlpha1",
-        min(max(alpha1_, scalar(0)), scalar(1))
+        clamp(alpha1_, zero_one{})
     );
 
     // Average kinematic viscosity calculated from dynamic viscosity
@@ -128,7 +128,7 @@ Foam::incompressibleTwoPhaseMixture::mu() const
 {
     const volScalarField limitedAlpha1
     (
-        min(max(alpha1_, scalar(0)), scalar(1))
+        clamp(alpha1_, zero_one{})
     );
 
     return tmp<volScalarField>::New
@@ -153,7 +153,7 @@ Foam::incompressibleTwoPhaseMixture::muf() const
 {
     const surfaceScalarField alpha1f
     (
-        min(max(fvc::interpolate(alpha1_), scalar(0)), scalar(1))
+        clamp(fvc::interpolate(alpha1_), zero_one{})
     );
 
     return tmp<surfaceScalarField>::New
@@ -170,7 +170,7 @@ Foam::incompressibleTwoPhaseMixture::nuf() const
 {
     const surfaceScalarField alpha1f
     (
-        min(max(fvc::interpolate(alpha1_), scalar(0)), scalar(1))
+        clamp(fvc::interpolate(alpha1_), zero_one{})
     );
 
     return tmp<surfaceScalarField>::New
diff --git a/src/transportModels/interfaceProperties/interfaceCompression/interfaceCompression.H b/src/transportModels/interfaceProperties/interfaceCompression/interfaceCompression.H
index bfc7d5e999..52a24a45cf 100644
--- a/src/transportModels/interfaceProperties/interfaceCompression/interfaceCompression.H
+++ b/src/transportModels/interfaceProperties/interfaceCompression/interfaceCompression.H
@@ -71,10 +71,11 @@ public:
         //return min(max(4*min(phiP*(1 - phiP), phiN*(1 - phiN)), 0), 1);
 
         // Quartic compression scheme
-        return
-            min(max(
+        return clamp
+        (
             1 - max(sqr(1 - 4*phiP*(1 - phiP)), sqr(1 - 4*phiN*(1 - phiN))),
-            0), 1);
+            0, 1
+        );
     }
 };
 
diff --git a/src/waveModels/derivedPointPatchFields/waveMaker/waveMakerPointPatchVectorField.C b/src/waveModels/derivedPointPatchFields/waveMaker/waveMakerPointPatchVectorField.C
index be8cbfb7c3..c4168f0969 100644
--- a/src/waveModels/derivedPointPatchFields/waveMaker/waveMakerPointPatchVectorField.C
+++ b/src/waveModels/derivedPointPatchFields/waveMaker/waveMakerPointPatchVectorField.C
@@ -89,7 +89,7 @@ Foam::scalar Foam::waveMakerPointPatchVectorField::timeCoeff
     const scalar t
 ) const
 {
-    return max(0, min(t/rampTime_, 1));
+    return clamp(t/rampTime_, 0, 1);
 }
 
 
diff --git a/src/waveModels/waveGenerationModels/base/irregularWaveModel/irregularWaveModel.C b/src/waveModels/waveGenerationModels/base/irregularWaveModel/irregularWaveModel.C
index 059a4e498e..aac185602f 100644
--- a/src/waveModels/waveGenerationModels/base/irregularWaveModel/irregularWaveModel.C
+++ b/src/waveModels/waveGenerationModels/base/irregularWaveModel/irregularWaveModel.C
@@ -46,7 +46,7 @@ Foam::scalar Foam::waveModels::irregularWaveModel::timeCoeff
     const scalar t
 ) const
 {
-    return max(0, min(t/rampTime_, 1));
+    return clamp(t/rampTime_, 0, 1);
 }
 
 

From f180740b030602906fe620d4f9c943d5c4e5f64a Mon Sep 17 00:00:00 2001
From: Mark Olesen <Mark.Olesen@esi-group.com>
Date: Wed, 1 Feb 2023 18:39:19 +0100
Subject: [PATCH 11/11] STYLE: lerp and emplace_back to simplify streamline
 coding

---
 .../field/streamLine/streamLineBase.C         | 87 ++++++++-----------
 .../field/streamLine/streamLineParticle.C     | 21 ++---
 .../wallBoundedStreamLineParticleTemplates.C  | 11 +--
 3 files changed, 49 insertions(+), 70 deletions(-)

diff --git a/src/functionObjects/field/streamLine/streamLineBase.C b/src/functionObjects/field/streamLine/streamLineBase.C
index 512fff95e1..e5fa1db6d9 100644
--- a/src/functionObjects/field/streamLine/streamLineBase.C
+++ b/src/functionObjects/field/streamLine/streamLineBase.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2015 OpenFOAM Foundation
-    Copyright (C) 2015-2022 OpenCFD Ltd.
+    Copyright (C) 2015-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -272,33 +272,29 @@ void Foam::functionObjects::streamLineBase::storePoint
     DynamicList<vectorList>& newVectors
 ) const
 {
-    const label sz = newTrack.size();
-
     const List<point>& track = allTracks_[tracki];
 
-    newTrack.append((1.0-w)*track[lefti] + w*track[righti]);
+    newTrack.push_back(lerp(track[lefti], track[righti], w));
 
     // Scalars
     {
-        newScalars.append(scalarList(allScalars_.size()));
-        scalarList& newVals = newScalars[sz];
+        scalarList& newVals = newScalars.emplace_back(allScalars_.size());
 
-        forAll(allScalars_, scalari)
+        forAll(allScalars_, i)
         {
-            const scalarList& trackVals = allScalars_[scalari][tracki];
-            newVals[scalari] = (1.0-w)*trackVals[lefti] + w*trackVals[righti];
+            const scalarList& trackVals = allScalars_[i][tracki];
+            newVals[i] = lerp(trackVals[lefti], trackVals[righti], w);
         }
     }
 
     // Vectors
     {
-        newVectors.append(vectorList(allVectors_.size()));
-        vectorList& newVals = newVectors[sz];
+        vectorList& newVals = newVectors.emplace_back(allVectors_.size());
 
-        forAll(allVectors_, vectori)
+        forAll(allVectors_, i)
         {
-            const vectorList& trackVals = allVectors_[vectori][tracki];
-            newVals[vectori] = (1.0-w)*trackVals[lefti] + w*trackVals[righti];
+            const vectorList& trackVals = allVectors_[i][tracki];
+            newVals[i] = lerp(trackVals[lefti], trackVals[righti], w);
         }
     }
 }
@@ -343,9 +339,9 @@ void Foam::functionObjects::streamLineBase::trimToBox
                         segmenti-1,
                         segmenti,
 
-                        newTracks.last(),
-                        newScalars.last(),
-                        newVectors.last()
+                        newTracks.back(),
+                        newScalars.back(),
+                        newVectors.back()
                     );
 
                     if (!bb.contains(endPt))
@@ -363,14 +359,14 @@ void Foam::functionObjects::streamLineBase::trimToBox
                                 segmenti-1,
                                 segmenti,
 
-                                newTracks.last(),
-                                newScalars.last(),
-                                newVectors.last()
+                                newTracks.back(),
+                                newScalars.back(),
+                                newVectors.back()
                             );
 
-                            newTracks.last().shrink();
-                            newScalars.last().shrink();
-                            newVectors.last().shrink();
+                            newTracks.back().shrink();
+                            newScalars.back().shrink();
+                            newVectors.back().shrink();
                         }
                     }
                 }
@@ -382,18 +378,7 @@ void Foam::functionObjects::streamLineBase::trimToBox
                     if (bb.intersects(startPt, endPt, clipPt))
                     {
                         // New track
-                        newTracks.append
-                        (
-                            new DynamicList<point>(track.size()/10)
-                        );
-                        newScalars.append
-                        (
-                            new DynamicList<scalarList>(track.size()/10)
-                        );
-                        newVectors.append
-                        (
-                            new DynamicList<vectorList>(track.size()/10)
-                        );
+                        const label defltCapacity(track.size()/10);
 
                         // Store point and interpolated values
                         storePoint
@@ -404,9 +389,9 @@ void Foam::functionObjects::streamLineBase::trimToBox
                             segmenti-1,
                             segmenti,
 
-                            newTracks.last(),
-                            newScalars.last(),
-                            newVectors.last()
+                            newTracks.emplace_back(defltCapacity),
+                            newScalars.emplace_back(defltCapacity),
+                            newVectors.emplace_back(defltCapacity)
                         );
 
                         if (!bb.contains(endPt))
@@ -427,14 +412,14 @@ void Foam::functionObjects::streamLineBase::trimToBox
                                 segmenti-1,
                                 segmenti,
 
-                                newTracks.last(),
-                                newScalars.last(),
-                                newVectors.last()
+                                newTracks.back(),
+                                newScalars.back(),
+                                newVectors.back()
                             );
 
-                            newTracks.last().shrink();
-                            newScalars.last().shrink();
-                            newVectors.last().shrink();
+                            newTracks.back().shrink();
+                            newScalars.back().shrink();
+                            newVectors.back().shrink();
                         }
                     }
                 }
@@ -442,7 +427,7 @@ void Foam::functionObjects::streamLineBase::trimToBox
         }
 
         // Last point
-        if (bb.contains(track.last()))
+        if (bb.contains(track.back()))
         {
             storePoint
             (
@@ -452,9 +437,9 @@ void Foam::functionObjects::streamLineBase::trimToBox
                 track.size()-2,
                 track.size()-1,
 
-                newTracks.last(),
-                newScalars.last(),
-                newVectors.last()
+                newTracks.back(),
+                newScalars.back(),
+                newVectors.back()
             );
         }
     }
@@ -476,9 +461,9 @@ void Foam::functionObjects::streamLineBase::trimToBox(const treeBoundBox& bb)
         if (track.size())
         {
             // New track. Assume it consists of the whole track
-            newTracks.append(new DynamicList<point>(track.size()));
-            newScalars.append(new DynamicList<scalarList>(track.size()));
-            newVectors.append(new DynamicList<vectorList>(track.size()));
+            newTracks.emplace_back(track.size());
+            newScalars.emplace_back(track.size());
+            newVectors.emplace_back(track.size());
 
             // Trim, split and append to newTracks
             trimToBox(bb, tracki, newTracks, newScalars, newVectors);
diff --git a/src/functionObjects/field/streamLine/streamLineParticle.C b/src/functionObjects/field/streamLine/streamLineParticle.C
index ed61271c1a..41c2bb8e8d 100644
--- a/src/functionObjects/field/streamLine/streamLineParticle.C
+++ b/src/functionObjects/field/streamLine/streamLineParticle.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2019-2022 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -57,17 +57,17 @@ Foam::vector Foam::streamLineParticle::interpolateFields
     if
     (
         sampledPositions_.empty()
-     || magSqr(sampledPositions_.last() - position) > Foam::sqr(SMALL)
+     || sampledPositions_.back().distSqr(position) > Foam::sqr(SMALL)
     )
     {
         // Store new location
-        sampledPositions_.append(position);
+        sampledPositions_.push_back(position);
 
         // Scalar fields
         sampledScalars_.resize(td.vsInterp_.size());
         forAll(td.vsInterp_, i)
         {
-            sampledScalars_[i].append
+            sampledScalars_[i].push_back
             (
                 td.vsInterp_[i].interpolate(tetCoords, tetIs, tetIs.face())
             );
@@ -77,7 +77,7 @@ Foam::vector Foam::streamLineParticle::interpolateFields
         sampledVectors_.resize(td.vvInterp_.size());
         forAll(td.vvInterp_, i)
         {
-            sampledVectors_[i].append
+            sampledVectors_[i].push_back
             (
                 td.vvInterp_[i].interpolate(tetCoords, tetIs, tetIs.face())
             );
@@ -85,7 +85,7 @@ Foam::vector Foam::streamLineParticle::interpolateFields
             if (td.vvInterp_.get(i) == &(td.UInterp_))
             {
                 foundU = true;
-                U = sampledVectors_[i].last();
+                U = sampledVectors_[i].back();
             }
         }
     }
@@ -272,19 +272,16 @@ bool Foam::streamLineParticle::move
 
         // Transfer particle data into trackingData.
         {
-            td.allPositions_.append(vectorList());
-            td.allPositions_.last().transfer(sampledPositions_);
+            td.allPositions_.emplace_back().transfer(sampledPositions_);
         }
 
         forAll(sampledScalars_, i)
         {
-            td.allScalars_[i].append(scalarList());
-            td.allScalars_[i].last().transfer(sampledScalars_[i]);
+            td.allScalars_[i].emplace_back().transfer(sampledScalars_[i]);
         }
         forAll(sampledVectors_, i)
         {
-            td.allVectors_[i].append(vectorList());
-            td.allVectors_[i].last().transfer(sampledVectors_[i]);
+            td.allVectors_[i].emplace_back().transfer(sampledVectors_[i]);
         }
     }
 
diff --git a/src/functionObjects/field/wallBoundedStreamLine/wallBoundedStreamLineParticleTemplates.C b/src/functionObjects/field/wallBoundedStreamLine/wallBoundedStreamLineParticleTemplates.C
index 46b136d101..c69f1a18c1 100644
--- a/src/functionObjects/field/wallBoundedStreamLine/wallBoundedStreamLineParticleTemplates.C
+++ b/src/functionObjects/field/wallBoundedStreamLine/wallBoundedStreamLineParticleTemplates.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -117,19 +117,16 @@ bool Foam::wallBoundedStreamLineParticle::move
 
         // Transfer particle data into trackingData.
         {
-            td.allPositions_.append(vectorList());
-            td.allPositions_.last().transfer(sampledPositions_);
+            td.allPositions_.emplace_back().transfer(sampledPositions_);
         }
 
         forAll(sampledScalars_, i)
         {
-            td.allScalars_[i].append(scalarList());
-            td.allScalars_[i].last().transfer(sampledScalars_[i]);
+            td.allScalars_[i].emplace_back().transfer(sampledScalars_[i]);
         }
         forAll(sampledVectors_, i)
         {
-            td.allVectors_[i].append(vectorList());
-            td.allVectors_[i].last().transfer(sampledVectors_[i]);
+            td.allVectors_[i].emplace_back().transfer(sampledVectors_[i]);
         }
     }