ENH: functionObjects: add optional flag to suppress warnings for missing patches

ENH: solver function objects: add outer-loop convergence checks

See merge request Development/openfoam!699

applications/utilities/mesh/conversion/vtkUnstructuredToFoam/Make/options

@@ -1,5 +1,7 @@
 EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/fileFormats/lnInclude
 
 EXE_LIBS = \
+    -lfiniteVolume \
     -lfileFormats

applications/utilities/mesh/conversion/vtkUnstructuredToFoam/vtkUnstructuredToFoam.C

@@ -34,23 +34,84 @@ Description
     Convert legacy VTK file (ascii) containing an unstructured grid
     to an OpenFOAM mesh without boundary information.
 
+Usage
+    \b vtkUnstructuredToFoam \<XXX.vtk\>
+
+    Options:
+      - \par -no-fields
+        Do not attempt to recreate volFields
+
 Note
     The .vtk format does not contain any boundary information.
-    It is purely a description of the internal mesh.
+    It is purely a description of the internal mesh. This also limits the
+    usefulness of reconstructing the volFields.
+
     Not extensively tested.
 
 \*---------------------------------------------------------------------------*/
 
 #include "argList.H"
 #include "Time.H"
-#include "polyMesh.H"
+#include "fvMesh.H"
 #include "IFstream.H"
 #include "vtkUnstructuredReader.H"
 
+#include "columnFvMesh.H"
+#include "scalarIOField.H"
+#include "vectorIOField.H"
+#include "volFields.H"
+
 using namespace Foam;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+template<class Type>
+void constructVolFields(fvMesh& mesh, const vtkUnstructuredReader& reader)
+{
+    const auto fields(reader.cellData().csorted<IOField<Type>>());
+    for (const auto& field : fields)
+    {
+        Info<< "Constructing volField " << field.name() << endl;
+
+        // field is
+        //  - cell data followed by
+        //  - boundary face data
+
+
+        auto tfld = GeometricField<Type, fvPatchField, volMesh>::New
+        (
+            field.name(),
+            mesh,
+            dimless
+        );
+        auto& fld = tfld.ref();
+        fld.instance() = mesh.time().timeName();
+        fld.writeOpt() = IOobject::AUTO_WRITE;
+
+        // Fill cell values
+        fld.internalFieldRef().field() =
+            UIndirectList<Type>(field, reader.cellMap());
+
+        // Fill boundary values
+        const auto& map = reader.faceMap();
+        if (map.size())
+        {
+            for (auto& pfld : fld.boundaryFieldRef())
+            {
+                const auto& pp = pfld.patch();
+
+                forAll(pfld, i)
+                {
+                    const label bFacei = pp.patch().offset()+i;
+                    pfld[i] = field[map[bFacei]];
+                }
+            }
+        }
+
+        regIOobject::store(std::move(tfld));
+    }
+}
+
 
 int main(int argc, char *argv[])
 {
@@ -61,11 +122,14 @@ int main(int argc, char *argv[])
     );
 
     argList::noParallel();
+    argList::addOptionCompat("no-fields", {"noFields", 2106});
     argList::addArgument("vtk-file", "The input legacy ascii vtk file");
 
     #include "setRootCase.H"
     #include "createTime.H"
 
+    const bool doFields = !args.found("no-fields");
+
     IFstream mshStream(args.get<fileName>(1));
 
     vtkUnstructuredReader reader(runTime, mshStream);
@@ -96,6 +160,24 @@ int main(int argc, char *argv[])
     mesh.removeFiles();
     mesh.write();
 
+
+    if (doFields)
+    {
+        // Re-read mesh as fvMesh so we can have fields
+        Info<< "Re-reading mesh ..." << endl;
+        #include "createMesh.H"
+
+        constructVolFields<scalar>(mesh, reader);
+        constructVolFields<vector>(mesh, reader);
+        constructVolFields<sphericalTensor>(mesh, reader);
+        constructVolFields<symmTensor>(mesh, reader);
+        constructVolFields<tensor>(mesh, reader);
+
+        // No need to write the mesh, only fields
+        mesh.thisDb().write();
+    }
+
+
     Info<< "End\n" << endl;
 
     return 0;

applications/utilities/mesh/manipulation/transformPoints/transformPoints.C

@@ -83,6 +83,10 @@ Note
     pitch (rotation about y)
     yaw (rotation about z)
 
+    - with -rotate and two exactly opposing vectors it will actually mirror
+    the geometry. Use any of the other rotation options instead or use
+    two steps, each 90 degrees.
+
 \*---------------------------------------------------------------------------*/
 
 #include "argList.H"

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

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2024 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -40,15 +40,6 @@ namespace Foam
 template<class TypeR, class Type1, class GeoMesh>
 struct reuseTmpDimensionedField
 {
-    //- Dissimilar types: non-reusable
-    static bool reusable
-    (
-        const tmp<DimensionedField<Type1, GeoMesh>>& tf1
-    )
-    {
-        return false;
-    }
-
     //- Pass-through to New DimensionedField
     static tmp<DimensionedField<TypeR, GeoMesh>> New
     (
@@ -88,15 +79,6 @@ struct reuseTmpDimensionedField
 template<class TypeR, class GeoMesh>
 struct reuseTmpDimensionedField<TypeR, TypeR, GeoMesh>
 {
-    //- Identical types: possibly reusable
-    static bool reusable
-    (
-        const tmp<DimensionedField<TypeR, GeoMesh>>& tf1
-    )
-    {
-        return tf1.movable();
-    }
-
     //- Allow optional copy assignment of the initial content
     //- for identical input and output types
     static tmp<DimensionedField<TypeR, GeoMesh>> New
@@ -155,22 +137,9 @@ tmp<DimensionedField<TypeR, GeoMesh>> New
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-// Two-parameter versions
-
 template<class TypeR, class Type1, class Type12, class Type2, class GeoMesh>
 struct reuseTmpTmpDimensionedField
 {
-    //- Dissimilar types: non-reusable
-    static bool reusable
-    (
-        const tmp<DimensionedField<Type1, GeoMesh>>& tf1,
-        const tmp<DimensionedField<Type2, GeoMesh>>& tf2
-    )
-    {
-        return false;
-    }
-
     static tmp<DimensionedField<TypeR, GeoMesh>> New
     (
         const tmp<DimensionedField<Type1, GeoMesh>>& tf1,
@@ -194,17 +163,6 @@ struct reuseTmpTmpDimensionedField
 template<class TypeR, class Type1, class Type12, class GeoMesh>
 struct reuseTmpTmpDimensionedField<TypeR, Type1, Type12, TypeR, GeoMesh>
 {
-    //- Second input has return type: possibly reusable
-    static bool reusable
-    (
-        const tmp<DimensionedField<Type1, GeoMesh>>& tf1,
-        const tmp<DimensionedField<TypeR, GeoMesh>>& tf2
-    )
-    {
-        return tf2.movable();
-    }
-
-    //- Second input has return type
     static tmp<DimensionedField<TypeR, GeoMesh>> New
     (
         const tmp<DimensionedField<Type1, GeoMesh>>& tf1,
@@ -237,17 +195,6 @@ struct reuseTmpTmpDimensionedField<TypeR, Type1, Type12, TypeR, GeoMesh>
 template<class TypeR, class Type2, class GeoMesh>
 struct reuseTmpTmpDimensionedField<TypeR, TypeR, TypeR, Type2, GeoMesh>
 {
-    //- First input has return type: possibly reusable
-    static bool reusable
-    (
-        const tmp<DimensionedField<TypeR, GeoMesh>>& tf1,
-        const tmp<DimensionedField<Type2, GeoMesh>>& tf2
-    )
-    {
-        return tf1.movable();
-    }
-
-    //- First input has return type
     static tmp<DimensionedField<TypeR, GeoMesh>> New
     (
         const tmp<DimensionedField<TypeR, GeoMesh>>& tf1,
@@ -280,17 +227,6 @@ struct reuseTmpTmpDimensionedField<TypeR, TypeR, TypeR, Type2, GeoMesh>
 template<class TypeR, class GeoMesh>
 struct reuseTmpTmpDimensionedField<TypeR, TypeR, TypeR, TypeR, GeoMesh>
 {
-    //- Both inputs have return type: possibly reusable
-    static bool reusable
-    (
-        const tmp<DimensionedField<TypeR, GeoMesh>>& tf1,
-        const tmp<DimensionedField<TypeR, GeoMesh>>& tf2
-    )
-    {
-        return (tf1.movable() || tf2.movable());
-    }
-
-    //- Both inputs have return type
     static tmp<DimensionedField<TypeR, GeoMesh>> New
     (
         const tmp<DimensionedField<TypeR, GeoMesh>>& tf1,

src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.C

@@ -47,9 +47,9 @@ void component
     const direction d
 )
 {
-    const label loop_len = (sf).size();
+    const label loopLen = (sf).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         component(sf[i], f[i], d);
     }
@@ -59,9 +59,9 @@ void component
 template<template<class> class Field, class Type>
 void T(FieldField<Field, Type>& f1, const FieldField<Field, Type>& f2)
 {
-    const label loop_len = (f1).size();
+    const label loopLen = (f1).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         T(f1[i], f2[i]);
     }
@@ -75,9 +75,9 @@ void pow
     const FieldField<Field, Type>& vf
 )
 {
-    const label loop_len = (f).size();
+    const label loopLen = (f).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         pow(f[i], vf[i]);
     }
@@ -122,9 +122,9 @@ void sqr
     const FieldField<Field, Type>& vf
 )
 {
-    const label loop_len = (f).size();
+    const label loopLen = (f).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         sqr(f[i], vf[i]);
     }
@@ -163,9 +163,9 @@ void magSqr
     const FieldField<Field, Type>& f
 )
 {
-    const label loop_len = (sf).size();
+    const label loopLen = (sf).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         magSqr(sf[i], f[i]);
     }
@@ -204,9 +204,9 @@ void mag
     const FieldField<Field, Type>& f
 )
 {
-    const label loop_len = (sf).size();
+    const label loopLen = (sf).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         mag(sf[i], f[i]);
     }
@@ -245,9 +245,9 @@ void cmptMax
     const FieldField<Field, Type>& f
 )
 {
-    const label loop_len = (cf).size();
+    const label loopLen = (cf).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         cmptMax(cf[i], f[i]);
     }
@@ -290,9 +290,9 @@ void cmptMin
     const FieldField<Field, Type>& f
 )
 {
-    const label loop_len = (cf).size();
+    const label loopLen = (cf).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         cmptMin(cf[i], f[i]);
     }
@@ -335,9 +335,9 @@ void cmptAv
     const FieldField<Field, Type>& f
 )
 {
-    const label loop_len = (cf).size();
+    const label loopLen = (cf).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         cmptAv(cf[i], f[i]);
     }
@@ -380,9 +380,9 @@ void cmptMag
     const FieldField<Field, Type>& f
 )
 {
-    const label loop_len = (cf).size();
+    const label loopLen = (cf).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         cmptMag(cf[i], f[i]);
     }
@@ -428,9 +428,9 @@ Type max(const FieldField<Field, Type>& f)
 {
     Type result = pTraits<Type>::min;
 
-    const label loop_len = (f).size();
+    const label loopLen = (f).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         if (f[i].size())
         {
@@ -450,9 +450,9 @@ Type min(const FieldField<Field, Type>& f)
 {
     Type result = pTraits<Type>::max;
 
-    const label loop_len = (f).size();
+    const label loopLen = (f).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         if (f[i].size())
         {
@@ -471,9 +471,9 @@ Type sum(const FieldField<Field, Type>& f)
 {
     Type result = Zero;
 
-    const label loop_len = (f).size();
+    const label loopLen = (f).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         result += sum(f[i]);
     }
@@ -490,9 +490,9 @@ typename typeOfMag<Type>::type sumMag(const FieldField<Field, Type>& f)
 
     resultType result = Zero;
 
-    const label loop_len = (f).size();
+    const label loopLen = (f).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         result += sumMag(f[i]);
     }
@@ -507,9 +507,9 @@ Type average(const FieldField<Field, Type>& f)
 {
     label n = 0;
 
-    const label loop_len = (f).size();
+    const label loopLen = (f).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         n += f[i].size();
     }
@@ -535,9 +535,9 @@ MinMax<Type> minMax(const FieldField<Field, Type>& f)
 {
     MinMax<Type> result;
 
-    const label loop_len = (f).size();
+    const label loopLen = (f).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         result += minMax(f[i]);
     }
@@ -552,9 +552,9 @@ scalarMinMax minMaxMag(const FieldField<Field, Type>& f)
 {
     scalarMinMax result;
 
-    const label loop_len = (f).size();
+    const label loopLen = (f).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         result += minMaxMag(f[i]);
     }
@@ -593,9 +593,9 @@ Type gAverage(const FieldField<Field, Type>& f)
 {
     label n = 0;
 
-    const label loop_len = (f).size();
+    const label loopLen = (f).size();
 
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         n += f[i].size();
     }
@@ -672,9 +672,9 @@ void OpFunc                                                                    \
     const FieldField<Field2, Type2>& f2                                        \
 )                                                                              \
 {                                                                              \
-    const label loop_len = (f).size();                                         \
+    const label loopLen = (f).size();                                          \
                                                                                \
-    for (label i = 0; i < loop_len; ++i)                                       \
+    for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
         OpFunc(f[i], f1[i], f2[i]);                                            \
     }                                                                          \
@@ -798,9 +798,9 @@ void OpFunc                                                                    \
     const VectorSpace<Form,Cmpt,nCmpt>& vs                                     \
 )                                                                              \
 {                                                                              \
-    const label loop_len = (result).size();                                    \
+    const label loopLen = (result).size();                                     \
                                                                                \
-    for (label i = 0; i < loop_len; ++i)                                       \
+    for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
         OpFunc(result[i], f1[i], vs);                                          \
     }                                                                          \
@@ -864,9 +864,9 @@ void OpFunc                                                                    \
     const FieldField<Field, Type>& f1                                          \
 )                                                                              \
 {                                                                              \
-    const label loop_len = (result).size();                                    \
+    const label loopLen = (result).size();                                     \
                                                                                \
-    for (label i = 0; i < loop_len; ++i)                                       \
+    for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
         OpFunc(result[i], vs, f1[i]);                                          \
     }                                                                          \

src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2022-2024 OpenCFD Ltd.
+    Copyright (C) 2022-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -40,9 +40,9 @@ void Func                                                                      \
     const FieldField<Field, Type1>& f1                                         \
 )                                                                              \
 {                                                                              \
-    const label loop_len = (result).size();                                    \
+    const label loopLen = (result).size();                                     \
                                                                                \
-    for (label i = 0; i < loop_len; ++i)                                       \
+    for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
         Func(result[i], f1[i]);                                                \
     }                                                                          \
@@ -83,9 +83,9 @@ void OpFunc                                                                    \
     const FieldField<Field, Type1>& f1                                         \
 )                                                                              \
 {                                                                              \
-    const label loop_len = (result).size();                                    \
+    const label loopLen = (result).size();                                     \
                                                                                \
-    for (label i = 0; i < loop_len; ++i)                                       \
+    for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
         OpFunc(result[i], f1[i]);                                              \
     }                                                                          \
@@ -127,9 +127,9 @@ void Func                                                                      \
     const FieldField<Field, Type2>& f2                                         \
 )                                                                              \
 {                                                                              \
-    const label loop_len = (result).size();                                    \
+    const label loopLen = (result).size();                                     \
                                                                                \
-    for (label i = 0; i < loop_len; ++i)                                       \
+    for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
         Func(result[i], f1[i], f2[i]);                                         \
     }                                                                          \
@@ -204,9 +204,9 @@ void Func                                                                      \
     const FieldField<Field, Type2>& f2                                         \
 )                                                                              \
 {                                                                              \
-    const label loop_len = (result).size();                                    \
+    const label loopLen = (result).size();                                     \
                                                                                \
-    for (label i = 0; i < loop_len; ++i)                                       \
+    for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
         Func(result[i], s1, f2[i]);                                            \
     }                                                                          \
@@ -248,9 +248,9 @@ void Func                                                                      \
     const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    const label loop_len = (result).size();                                    \
+    const label loopLen = (result).size();                                     \
                                                                                \
-    for (label i = 0; i < loop_len; ++i)                                       \
+    for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
         Func(result[i], f1[i], s2);                                            \
     }                                                                          \
@@ -299,9 +299,9 @@ void OpFunc                                                                    \
     const FieldField<Field, Type2>& f2                                         \
 )                                                                              \
 {                                                                              \
-    const label loop_len = (result).size();                                    \
+    const label loopLen = (result).size();                                     \
                                                                                \
-    for (label i = 0; i < loop_len; ++i)                                       \
+    for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
         OpFunc(result[i], f1[i], f2[i]);                                       \
     }                                                                          \
@@ -376,9 +376,9 @@ void OpFunc                                                                    \
     const FieldField<Field, Type2>& f2                                         \
 )                                                                              \
 {                                                                              \
-    const label loop_len = (result).size();                                    \
+    const label loopLen = (result).size();                                     \
                                                                                \
-    for (label i = 0; i < loop_len; ++i)                                       \
+    for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
         OpFunc(result[i], s1, f2[i]);                                          \
     }                                                                          \
@@ -420,9 +420,9 @@ void OpFunc                                                                    \
     const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    const label loop_len = (result).size();                                    \
+    const label loopLen = (result).size();                                     \
                                                                                \
-    for (label i = 0; i < loop_len; ++i)                                       \
+    for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
         OpFunc(result[i], f1[i], s2);                                          \
     }                                                                          \
@@ -472,9 +472,9 @@ void Func                                                                      \
     const FieldField<Field, Type3>& f3                                         \
 )                                                                              \
 {                                                                              \
-    const label loop_len = (result).size();                                    \
+    const label loopLen = (result).size();                                     \
                                                                                \
-    for (label i = 0; i < loop_len; ++i)                                       \
+    for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
         Func(result[i], f1[i], f2[i], f3[i]);                                  \
     }                                                                          \
@@ -625,9 +625,9 @@ void Func                                                                      \
     const Type3& s3                                                            \
 )                                                                              \
 {                                                                              \
-    const label loop_len = (result).size();                                    \
+    const label loopLen = (result).size();                                     \
                                                                                \
-    for (label i = 0; i < loop_len; ++i)                                       \
+    for (label i = 0; i < loopLen; ++i)                                        \
     {                                                                          \
         Func(result[i], f1[i], f2[i], s3);                                     \
     }                                                                          \

src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldReuseFunctions.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2024 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -40,15 +40,6 @@ namespace Foam
 template<template<class> class Field, class TypeR, class Type1>
 struct reuseTmpFieldField
 {
-    //- Dissimilar types: non-reusable
-    static bool reusable
-    (
-        const tmp<FieldField<Field, Type1>>& tf1
-    )
-    {
-        return false;
-    }
-
     //- Pass-through to NewCalculatedType
     static tmp<FieldField<Field, TypeR>> New
     (
@@ -72,15 +63,6 @@ struct reuseTmpFieldField
 template<template<class> class Field, class TypeR>
 struct reuseTmpFieldField<Field, TypeR, TypeR>
 {
-    //- Identical types: possibly reusable
-    static bool reusable
-    (
-        const tmp<FieldField<Field, TypeR>>& tf1
-    )
-    {
-        return tf1.movable();
-    }
-
     //- Identical input and return types:
     //- allow optional copy assignment of the initial content
     static tmp<FieldField<Field, TypeR>> New
@@ -94,13 +76,11 @@ struct reuseTmpFieldField<Field, TypeR, TypeR>
             return tf1;
         }
 
-        const auto& f1 = tf1();
-
-        auto tresult = FieldField<Field, TypeR>::NewCalculatedType(f1);
+        auto tresult = FieldField<Field, TypeR>::NewCalculatedType(tf1());
 
         if (initCopy)
         {
-            tresult.ref() = f1;
+            tresult.ref() = tf1();
         }
 
         return tresult;
@@ -133,16 +113,6 @@ template
 >
 struct reuseTmpTmpFieldField
 {
-    //- Dissimilar types: non-reusable
-    static bool reusable
-    (
-        const tmp<FieldField<Field, Type1>>& tf1,
-        const tmp<FieldField<Field, Type2>>& tf2
-    )
-    {
-        return false;
-    }
-
     //- Dissimilar types: just use size
     static tmp<FieldField<Field, TypeR>> New
     (
@@ -158,16 +128,6 @@ 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: possibly reusable
-    static bool movable
-    (
-        const tmp<FieldField<Field, Type1>>& tf1,
-        const tmp<FieldField<Field, TypeR>>& tf2
-    )
-    {
-        return tf2.movable();
-    }
-
     //- Second input has return type
     static tmp<FieldField<Field, TypeR>> New
     (
@@ -188,16 +148,6 @@ 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: possibly reusable
-    static bool reusable
-    (
-        const tmp<FieldField<Field, TypeR>>& tf1,
-        const tmp<FieldField<Field, Type2>>& tf2
-    )
-    {
-        return tf1.movable();
-    }
-
     //- First input has return type
     static tmp<FieldField<Field, TypeR>> New
     (
@@ -218,16 +168,6 @@ 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: possibly reusable
-    static bool reusable
-    (
-        const tmp<FieldField<Field, TypeR>>& tf1,
-        const tmp<FieldField<Field, TypeR>>& tf2
-    )
-    {
-        return (tf1.movable() || tf2.movable());
-    }
-
     //- Both inputs have return type
     static tmp<FieldField<Field, TypeR>> New
     (

src/OpenFOAM/fields/Fields/Field/Field.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2015-2024 OpenCFD Ltd.
+    Copyright (C) 2015-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -599,8 +599,7 @@ void Foam::Field<Type>::rmap
 template<class Type>
 void Foam::Field<Type>::negate()
 {
-    // std::for_each
-    TSEQ_FORALL_F_OP_OP_F_inplace(*this, =, -, *this)
+    TFOR_ALL_F_OP_OP_F(Type, *this, =, -, Type, *this)
 }
 
 
@@ -630,16 +629,8 @@ void Foam::Field<Type>::replace
     const UList<cmptType>& sf
 )
 {
-    if (this->cdata_bytes() == sf.cdata_bytes())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_S_F_inplace(*this, ., replace, d, sf)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_S_F(*this, ., replace, d, sf)
-    }
+    TFOR_ALL_F_OP_FUNC_S_F(Type, *this, ., replace, const direction, d,
+        cmptType, sf)
 }
 
 
@@ -662,7 +653,8 @@ void Foam::Field<Type>::replace
     const cmptType& c
 )
 {
-    TSEQ_FORALL_F_OP_FUNC_S_S(*this, ., replace, d, c)
+    TFOR_ALL_F_OP_FUNC_S_S(Type, *this, ., replace, const direction, d,
+        cmptType, c)
 }
 
 
@@ -786,7 +778,7 @@ template<class Type>
 template<class Form, class Cmpt, Foam::direction nCmpt>
 void Foam::Field<Type>::operator=(const VectorSpace<Form,Cmpt,nCmpt>& vs)
 {
-    TSEQ_FORALL_F_OP_S(*this, =, vs)
+    TFOR_ALL_F_OP_S(Type, *this, =, VSType, vs)
 }
 
 
@@ -795,16 +787,7 @@ void Foam::Field<Type>::operator=(const VectorSpace<Form,Cmpt,nCmpt>& vs)
 template<class Type>                                                           \
 void Foam::Field<Type>::operator op(const UList<TYPE>& f)                      \
 {                                                                              \
-    if (this->cdata_bytes() == f.cdata_bytes())                                \
-    {                                                                          \
-        /* std::for_each */                                                    \
-        TSEQ_FORALL_F_OP_F_inplace(*this, op, f)                               \
-    }                                                                          \
-    else                                                                       \
-    {                                                                          \
-        /* std::transform */                                                   \
-        TSEQ_FORALL_F_OP_F(*this, op, f)                                       \
-    }                                                                          \
+    TFOR_ALL_F_OP_F(Type, *this, op, TYPE, f)                                  \
 }                                                                              \
                                                                                \
 template<class Type>                                                           \
@@ -817,7 +800,7 @@ void Foam::Field<Type>::operator op(const tmp<Field<TYPE>>& tf)                \
 template<class Type>                                                           \
 void Foam::Field<Type>::operator op(const TYPE& t)                             \
 {                                                                              \
-    TSEQ_FORALL_F_OP_S(*this, op, t)                                           \
+    TFOR_ALL_F_OP_S(Type, *this, op, TYPE, t)                                  \
 }
 
 COMPUTED_ASSIGNMENT(Type, +=)

src/OpenFOAM/fields/Fields/Field/FieldFunctions.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2024 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -47,32 +47,19 @@ void component
     const direction d
 )
 {
-    if (result.cdata_bytes() == f1.cdata_bytes())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_F_FUNC_S_inplace(result, =, f1, .component, d)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_F_FUNC_S(result, =, f1, .component, d)
-    }
+    typedef typename Field<Type>::cmptType resultType;
+
+    TFOR_ALL_F_OP_F_FUNC_S
+    (
+        resultType, result, =, Type, f1, .component, const direction, d
+    )
 }
 
 
 template<class Type>
 void T(Field<Type>& result, const UList<Type>& f1)
 {
-    if (result.cdata() == f1.cdata())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_F_FUNC_inplace(result, =, f1, T)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_F_FUNC(result, =, f1, T)
-    }
+    TFOR_ALL_F_OP_F_FUNC(Type, result, =, Type, f1, T)
 }
 
 
@@ -85,19 +72,11 @@ void pow
 {
     typedef typename powProduct<Type, r>::type resultType;
 
-    if (result.cdata_bytes() == f1.cdata_bytes())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_F_S_inplace
-        (result, =, pow, f1, pTraits<resultType>::zero)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_F_S
-        (result, =, pow, f1, pTraits<resultType>::zero)
-    }
-
+    TFOR_ALL_F_OP_FUNC_F_S
+    (
+        resultType, result, =, pow, Type, f1, resultType,
+        pTraits<resultType>::zero
+    )
 }
 
 template<class Type, direction r>
@@ -137,16 +116,9 @@ void sqr
     const UList<Type>& f1
 )
 {
-    if (result.cdata_bytes() == f1.cdata_bytes())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_F_inplace(result, =, sqr, f1)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_F(result, =, sqr, f1)
-    }
+    typedef typename outerProduct<Type, Type>::type resultType;
+
+    TFOR_ALL_F_OP_FUNC_F(resultType, result, =, sqr, Type, f1)
 }
 
 template<class Type>
@@ -178,16 +150,9 @@ void magSqr
     const UList<Type>& f1
 )
 {
-    if (result.cdata_bytes() == f1.cdata_bytes())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_F_inplace(result, =, magSqr, f1)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_F(result, =, magSqr, f1)
-    }
+    typedef typename typeOfMag<Type>::type resultType;
+
+    TFOR_ALL_F_OP_FUNC_F(resultType, result, =, magSqr, Type, f1)
 }
 
 template<class Type>
@@ -221,16 +186,9 @@ void mag
     const UList<Type>& f1
 )
 {
-    if (result.cdata_bytes() == f1.cdata_bytes())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_F_inplace(result, =, mag, f1)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_F(result, =, mag, f1)
-    }
+    typedef typename typeOfMag<Type>::type resultType;
+
+    TFOR_ALL_F_OP_FUNC_F(resultType, result, =, mag, Type, f1)
 }
 
 template<class Type>
@@ -264,16 +222,9 @@ void cmptMax
     const UList<Type>& f1
 )
 {
-    if (result.cdata_bytes() == f1.cdata_bytes())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_F_inplace(result, =, cmptMax, f1)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_F(result, =, cmptMax, f1)
-    }
+    typedef typename Field<Type>::cmptType resultType;
+
+    TFOR_ALL_F_OP_FUNC_F(resultType, result, =, cmptMax, Type, f1)
 }
 
 template<class Type>
@@ -303,16 +254,9 @@ void cmptMin
     const UList<Type>& f1
 )
 {
-    if (result.cdata_bytes() == f1.cdata_bytes())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_F_inplace(result, =, cmptMin, f1)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_F(result, =, cmptMin, f1)
-    }
+    typedef typename Field<Type>::cmptType resultType;
+
+    TFOR_ALL_F_OP_FUNC_F(resultType, result, =, cmptMin, Type, f1)
 }
 
 template<class Type>
@@ -342,16 +286,9 @@ void cmptAv
     const UList<Type>& f1
 )
 {
-    if (result.cdata_bytes() == f1.cdata_bytes())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_F_inplace(result, =, cmptAv, f1)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_F(result, =, cmptAv, f1)
-    }
+    typedef typename Field<Type>::cmptType resultType;
+
+    TFOR_ALL_F_OP_FUNC_F(resultType, result, =, cmptAv, Type, f1)
 }
 
 template<class Type>
@@ -377,16 +314,7 @@ tmp<Field<typename Field<Type>::cmptType>> cmptAv(const tmp<Field<Type>>& tf1)
 template<class Type>
 void cmptMag(Field<Type>& result, const UList<Type>& f1)
 {
-    if (result.cdata_bytes() == f1.cdata_bytes())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_F_inplace(result, =, cmptMag, f1)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_F(result, =, cmptMag, f1)
-    }
+    TFOR_ALL_F_OP_FUNC_F(Type, result, =, cmptMag, Type, f1)
 }
 
 template<class Type>
@@ -410,16 +338,7 @@ tmp<Field<Type>> cmptMag(const tmp<Field<Type>>& tf1)
 template<class Type>
 void cmptMagSqr(Field<Type>& result, const UList<Type>& f1)
 {
-    if (result.cdata_bytes() == f1.cdata_bytes())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_F_inplace(result, =, cmptMagSqr, f1)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_F(result, =, cmptMagSqr, f1)
-    }
+    TFOR_ALL_F_OP_FUNC_F(Type, result, =, cmptMagSqr, Type, f1)
 }
 
 template<class Type>
@@ -456,7 +375,7 @@ Type max(const UList<Type>& f1)
     if (f1.size())
     {
         Type result(f1[0]);
-        TSEQ_FORALL_S_OP_FUNC_F_S(result, =, max, f1, result)
+        TFOR_ALL_S_OP_FUNC_F_S(Type, result, =, max, Type, f1, Type, result)
         return result;
     }
 
@@ -471,7 +390,7 @@ Type min(const UList<Type>& f1)
     if (f1.size())
     {
         Type result(f1[0]);
-        TSEQ_FORALL_S_OP_FUNC_F_S(result, =, min, f1, result)
+        TFOR_ALL_S_OP_FUNC_F_S(Type, result, =, min, Type, f1, Type, result)
         return result;
     }
 
@@ -490,7 +409,7 @@ Type sum(const UList<Type>& f1)
     if (f1.size())
     {
         // Use resultType() as functional cast
-        TSEQ_FORALL_S_OP_FUNC_F(result, +=, resultType, f1)
+        TFOR_ALL_S_OP_FUNC_F(resultType, result, +=, resultType, Type, f1)
     }
 
     return Type(result);
@@ -513,12 +432,15 @@ Type maxMagSqr(const UList<Type>& f1)
     if (f1.size())
     {
         Type result(f1[0]);
-        TSEQ_FORALL_S_OP_FUNC_F_S
+        TFOR_ALL_S_OP_FUNC_F_S
         (
+            Type,
             result,
             =,
             maxMagSqrOp<Type>(),
+            Type,
             f1,
+            Type,
             result
         )
         return result;
@@ -535,12 +457,15 @@ Type minMagSqr(const UList<Type>& f1)
     if (f1.size())
     {
         Type result(f1[0]);
-        TSEQ_FORALL_S_OP_FUNC_F_S
+        TFOR_ALL_S_OP_FUNC_F_S
         (
+            Type,
             result,
             =,
             minMagSqrOp<Type>(),
+            Type,
             f1,
+            Type,
             result
         )
         return result;
@@ -560,8 +485,7 @@ sumProd(const UList<Type>& f1, const UList<Type>& f2)
     resultType result = Zero;
     if (f1.size() && (f1.size() == f2.size()))
     {
-        // std::transform
-        TSEQ_FORALL_S_OP_F_OP_F(result, +=, f1, &&, f2)
+        TFOR_ALL_S_OP_F_OP_F(resultType, result, +=, Type, f1, &&, Type, f2)
     }
     return result;
 }
@@ -573,12 +497,15 @@ Type sumCmptProd(const UList<Type>& f1, const UList<Type>& f2)
     Type result = Zero;
     if (f1.size() && (f1.size() == f2.size()))
     {
-        TSEQ_FORALL_S_OP_FUNC_F_F
+        TFOR_ALL_S_OP_FUNC_F_F
         (
+            Type,
             result,
             +=,
             cmptMultiply,
+            Type,
             f1,
+            Type,
             f2
         )
     }
@@ -595,7 +522,7 @@ sumSqr(const UList<Type>& f1)
     resultType result = Zero;
     if (f1.size())
     {
-        TSEQ_FORALL_S_OP_FUNC_F(result, +=, sqr, f1)
+        TFOR_ALL_S_OP_FUNC_F(resultType, result, +=, sqr, Type, f1)
     }
     return result;
 }
@@ -620,7 +547,7 @@ sumMag(const UList<Type>& f1)
     resultType result = Zero;
     if (f1.size())
     {
-        TSEQ_FORALL_S_OP_FUNC_F(result, +=, mag, f1)
+        TFOR_ALL_S_OP_FUNC_F(resultType, result, +=, mag, Type, f1)
     }
     return result;
 }
@@ -634,7 +561,7 @@ Type sumCmptMag(const UList<Type>& f1)
     Type result = Zero;
     if (f1.size())
     {
-        TSEQ_FORALL_S_OP_FUNC_F(result, +=, cmptMag, f1)
+        TFOR_ALL_S_OP_FUNC_F(Type, result, +=, cmptMag, Type, f1)
     }
     return result;
 }
@@ -846,20 +773,8 @@ void OpFunc                                                                    \
     const UList<Type2>& f2                                                     \
 )                                                                              \
 {                                                                              \
-    if                                                                         \
-    (                                                                          \
-        result.cdata_bytes() == f1.cdata_bytes()                               \
-     || result.cdata_bytes() == f2.cdata_bytes()                               \
-    )                                                                          \
-    {                                                                          \
-        /* std::for_each */                                                    \
-        TSEQ_FORALL_F_OP_F_OP_F_inplace(result, =, f1, Op, f2)                 \
-    }                                                                          \
-    else                                                                       \
-    {                                                                          \
-        /* std::transform */                                                   \
-        TSEQ_FORALL_F_OP_F_OP_F(result, =, f1, Op, 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>                                             \
@@ -914,21 +829,9 @@ void OpFunc                                                                    \
     const VectorSpace<Form,Cmpt,nCmpt>& vs                                     \
 )                                                                              \
 {                                                                              \
-    if                                                                         \
-    (                                                                          \
-        result.cdata_bytes() == f1.cdata_bytes()                               \
-    )                                                                          \
-    {                                                                          \
-        /* std::for_each */                                                    \
-        TSEQ_FORALL_F_OP_F_OP_S_inplace                                        \
-        (result, =, f1, Op, static_cast<const Form&>(vs))                      \
-    }                                                                          \
-    else                                                                       \
-    {                                                                          \
-        /* std::transform */                                                   \
-        TSEQ_FORALL_F_OP_F_OP_S                                                \
-        (result, =, f1, Op, static_cast<const Form&>(vs))                      \
-    }                                                                          \
+    typedef typename product<Type, Form>::type resultType;                     \
+    TFOR_ALL_F_OP_F_OP_S                                                       \
+        (resultType, result, =,Type, f1, Op, Form, static_cast<const Form&>(vs))\
 }                                                                              \
                                                                                \
 template<class Type, class Form, class Cmpt, direction nCmpt>                  \
@@ -964,21 +867,9 @@ void OpFunc                                                                    \
     const UList<Type>& f1                                                      \
 )                                                                              \
 {                                                                              \
-    if                                                                         \
-    (                                                                          \
-        result.cdata_bytes() == f1.cdata_bytes()                               \
-    )                                                                          \
-    {                                                                          \
-        /* std::for_each */                                                    \
-        TSEQ_FORALL_F_OP_S_OP_F_inplace                                        \
-        (result, =, static_cast<const Form&>(vs), Op, f1)                      \
-    }                                                                          \
-    else                                                                       \
-    {                                                                          \
-        /* std::transform */                                                   \
-        TSEQ_FORALL_F_OP_S_OP_F                                                \
-        (result, =, static_cast<const Form&>(vs), Op, f1)                      \
-    }                                                                          \
+    typedef typename product<Form, Type>::type resultType;                     \
+    TFOR_ALL_F_OP_S_OP_F                                                       \
+        (resultType, result, =,Form,static_cast<const Form&>(vs), Op, Type, f1)\
 }                                                                              \
                                                                                \
 template<class Form, class Cmpt, direction nCmpt, class Type>                  \

src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.C

@@ -40,14 +40,7 @@ void Func                                                                      \
     const UList<Type1>& f1                                                     \
 )                                                                              \
 {                                                                              \
-    if (result.cdata_bytes() == f1.cdata_bytes())                              \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_FUNC_F_inplace(result, =, ::Foam::Func, f1)           \
-    }                                                                          \
-    else                                                                       \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_FUNC_F(result, =, ::Foam::Func, f1)                   \
-    }                                                                          \
+    TFOR_ALL_F_OP_FUNC_F(ReturnType, result, =, ::Foam::Func, Type1, f1)       \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
@@ -85,14 +78,7 @@ void OpFunc                                                                    \
     const UList<Type1>& f1                                                     \
 )                                                                              \
 {                                                                              \
-    if (result.cdata_bytes() == f1.cdata_bytes())                              \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_OP_F_inplace(result, =, Op, f1)                       \
-    }                                                                          \
-    else                                                                       \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_OP_F(result, =, Op, f1)                               \
-    }                                                                          \
+    TFOR_ALL_F_OP_OP_F(ReturnType, result, =, Op, Type1, f1)                   \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
@@ -131,18 +117,10 @@ void Func                                                                      \
     const UList<Type2>& f2                                                     \
 )                                                                              \
 {                                                                              \
-    if                                                                         \
+    TFOR_ALL_F_OP_FUNC_F_F                                                     \
     (                                                                          \
-        result.cdata_bytes() == f1.cdata_bytes()                               \
-     || result.cdata_bytes() == f2.cdata_bytes()                               \
+        ReturnType, result, =, ::Foam::Func, Type1, f1, Type2, f2              \
     )                                                                          \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_FUNC_F_F_inplace(result, =, ::Foam::Func, f1, f2)     \
-    }                                                                          \
-    else                                                                       \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_FUNC_F_F(result, =, ::Foam::Func, f1, f2)             \
-    }                                                                          \
 }
 
 #define BINARY_FUNCTION_INTERFACE(ReturnType, Type1, Type2, Func)              \
@@ -216,14 +194,10 @@ void Func                                                                      \
     const UList<Type2>& f2                                                     \
 )                                                                              \
 {                                                                              \
-    if (result.cdata_bytes() == f2.cdata_bytes())                              \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_FUNC_S_F_inplace(result, =, ::Foam::Func, s1, f2)     \
-    }                                                                          \
-    else                                                                       \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_FUNC_S_F(result, =, ::Foam::Func, s1, f2)             \
-    }                                                                          \
+    TFOR_ALL_F_OP_FUNC_S_F                                                     \
+    (                                                                          \
+        ReturnType, result, =, ::Foam::Func, Type1, s1, Type2, f2              \
+    )                                                                          \
 }
 
 #define BINARY_FUNCTION_INTERFACE_SF(ReturnType, Type1, Type2, Func)           \
@@ -268,14 +242,10 @@ void Func                                                                      \
     const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    if (result.cdata_bytes() == f1.cdata_bytes())                              \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_FUNC_F_S_inplace(result, =, ::Foam::Func, f1, s2)     \
-    }                                                                          \
-    else                                                                       \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_FUNC_F_S(result, =, ::Foam::Func, f1, s2)             \
-    }                                                                          \
+    TFOR_ALL_F_OP_FUNC_F_S                                                     \
+    (                                                                          \
+        ReturnType, result, =, ::Foam::Func, Type1, f1, Type2, s2              \
+    )                                                                          \
 }
 
 #define BINARY_FUNCTION_INTERFACE_FS(ReturnType, Type1, Type2, Func)           \
@@ -327,18 +297,7 @@ void OpFunc                                                                    \
     const UList<Type2>& f2                                                     \
 )                                                                              \
 {                                                                              \
-    if                                                                         \
-    (                                                                          \
-        result.cdata_bytes() == f1.cdata_bytes()                               \
-     || result.cdata_bytes() == f2.cdata_bytes()                               \
-    )                                                                          \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_F_OP_F_inplace(result, =, f1, Op, f2)                 \
-    }                                                                          \
-    else                                                                       \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_F_OP_F(result, =, f1, Op, f2)                         \
-    }                                                                          \
+    TFOR_ALL_F_OP_F_OP_F(ReturnType, result, =, Type1, f1, Op, Type2, f2)      \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
@@ -406,14 +365,7 @@ void OpFunc                                                                    \
     const UList<Type2>& f2                                                     \
 )                                                                              \
 {                                                                              \
-    if (result.cdata_bytes() == f2.cdata_bytes())                              \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_S_OP_F_inplace(result, =, s1, Op, f2)                 \
-    }                                                                          \
-    else                                                                       \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_S_OP_F(result, =, s1, Op, f2)                         \
-    }                                                                          \
+    TFOR_ALL_F_OP_S_OP_F(ReturnType, result, =, Type1, s1, Op, Type2, f2)      \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
@@ -452,14 +404,7 @@ void OpFunc                                                                    \
     const Type2& s2                                                            \
 )                                                                              \
 {                                                                              \
-    if (result.cdata_bytes() == f1.cdata_bytes())                              \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_F_OP_S_inplace(result, =, f1, Op, s2)                 \
-    }                                                                          \
-    else                                                                       \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_F_OP_S(result, =, f1, Op, s2)                         \
-    }                                                                          \
+    TFOR_ALL_F_OP_F_OP_S(ReturnType, result, =, Type1, f1, Op, Type2, s2)      \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
@@ -506,21 +451,10 @@ void Func                                                                      \
     const UList<Type3>& f3                                                     \
 )                                                                              \
 {                                                                              \
-    if                                                                         \
+    TFOR_ALL_F_OP_FUNC_F_F_F                                                   \
     (                                                                          \
-        result.cdata_bytes() == f1.cdata_bytes()                               \
-     || result.cdata_bytes() == f2.cdata_bytes()                               \
-     || result.cdata_bytes() == f3.cdata_bytes()                               \
+        ReturnType, result, =, ::Foam::Func, Type1, f1, Type2, f2, Type3, f3   \
     )                                                                          \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_FUNC_F_F_F_inplace                                    \
-        (result, =, ::Foam::Func, f1, f2, f3)                                  \
-    }                                                                          \
-    else                                                                       \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_FUNC_F_F_F                                            \
-        (result, =, ::Foam::Func, f1, f2, f3)                                  \
-    }                                                                          \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
@@ -652,20 +586,10 @@ void Func                                                                      \
     const Type3& s3                                                            \
 )                                                                              \
 {                                                                              \
-    if                                                                         \
+    TFOR_ALL_F_OP_FUNC_F_F_S                                                   \
     (                                                                          \
-        result.cdata_bytes() == f1.cdata_bytes()                               \
-     || result.cdata_bytes() == f2.cdata_bytes()                               \
+        ReturnType, result, =, ::Foam::Func, Type1, f1, Type2, f2, Type3, s3   \
     )                                                                          \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_FUNC_F_F_S_inplace                                    \
-        (result, =, ::Foam::Func, f1, f2, s3)                                  \
-    }                                                                          \
-    else                                                                       \
-    {                                                                          \
-        TSEQ_FORALL_F_OP_FUNC_F_F_S                                            \
-        (result, =, ::Foam::Func, f1, f2, s3)                                  \
-    }                                                                          \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \

src/OpenFOAM/fields/Fields/Field/FieldM.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2022-2024 OpenCFD Ltd.
+    Copyright (C) 2022-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -32,8 +32,8 @@ Description
 #ifndef Foam_FieldM_H
 #define Foam_FieldM_H
 
-#include "errorCheckFields.H"   // Field size checks (fulldebug mode)
-#include "ListLoopM.H"          // List access macros
+#include "error.H"
+#include "ListLoopM.H"  // For list access macros
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -42,20 +42,126 @@ namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-// ------------
+#ifdef FULLDEBUG
+
+template<class Type1, class Type2>
+void checkFields
+(
+    const UList<Type1>& f1,
+    const UList<Type2>& f2,
+    const char* op
+)
+{
+    if (f1.size() != f2.size())
+    {
+        FatalErrorInFunction
+            << " Field<"<<pTraits<Type1>::typeName<<"> f1("<<f1.size()<<')'
+            << " and Field<"<<pTraits<Type2>::typeName<<"> f2("<<f2.size()<<')'
+            << endl
+            << " for operation " << op
+            << abort(FatalError);
+    }
+}
+
+template<class Type1, class Type2, class Type3>
+void checkFields
+(
+    const UList<Type1>& f1,
+    const UList<Type2>& f2,
+    const UList<Type3>& f3,
+    const char* op
+)
+{
+    if (f1.size() != f2.size() || f1.size() != f3.size())
+    {
+        FatalErrorInFunction
+            << " Field<"<<pTraits<Type1>::typeName<<"> f1("<<f1.size()<<')'
+            << ", Field<"<<pTraits<Type2>::typeName<<"> f2("<<f2.size()<<')'
+            << " and Field<"<<pTraits<Type3>::typeName<<"> f3("<<f3.size()<<')'
+            << endl
+            << "    for operation " << op
+            << abort(FatalError);
+    }
+}
+
+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>
+void checkFields
+(
+    const UList<Type1>&,
+    const UList<Type2>&,
+    const char*
+)
+{}
+
+template<class Type1, class Type2, class Type3>
+void checkFields
+(
+    const UList<Type1>&,
+    const UList<Type2>&,
+    const UList<Type3>&,
+    const char*
+)
+{}
+
+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
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 // Unary Free Function : f1 OP Func(f2)
 
-#define TSEQ_FORALL_F_OP_FUNC_F_impl(f1, OP, FUNC, f2, Restrict)               \
+#define TFOR_ALL_F_OP_FUNC_F(typeF1, f1, OP, FUNC, typeF2, f2)                 \
 {                                                                              \
     /* Check fields have same size */                                          \
     checkFields(f1, f2, "f1 " #OP " " #FUNC "(f2)");                           \
                                                                                \
     /* Field access */                                                         \
-    TFOR_List_ACCESS(f1, f1P, Restrict);                                       \
-    TFOR_List_CONST_ACCESS(f2, f2P, Restrict);                                 \
-    TFOR_List_LENGTH(f1, loop_len);                                            \
+    List_ACCESS(typeF1, f1, f1P);                                              \
+    List_CONST_ACCESS(typeF2, f2, f2P);                                        \
                                                                                \
     /* Loop: f1 OP FUNC(f2) */                                                 \
+    const label loop_len = (f1).size();                                        \
                                                                                \
     /* pragmas... */                                                           \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -64,32 +170,20 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_F_OP_FUNC_F(f1, OP, FUNC, f2) \
-        TSEQ_FORALL_F_OP_FUNC_F_impl(f1, OP, FUNC, f2, __restrict__)
 
-#define TSEQ_FORALL_F_OP_FUNC_F_inplace(f1, OP, FUNC, f2) \
-        TSEQ_FORALL_F_OP_FUNC_F_impl(f1, OP, FUNC, f2,)
-
-// old-style
-#define TFOR_ALL_F_OP_FUNC_F(typeF1, f1, OP, FUNC, typeF2, f2) \
-     TSEQ_FORALL_F_OP_FUNC_F_impl(f1, OP, FUNC, f2, __restrict__)
-
-
-// ------------
 // Nullary Member Function : f1 OP f2.FUNC()
-// NB: the '.' is not passed in the func parameter
 
-#define TSEQ_FORALL_F_OP_F_FUNC_impl(f1, OP, f2, FUNC, Restrict)               \
+#define TFOR_ALL_F_OP_F_FUNC(typeF1, f1, OP, typeF2, f2, FUNC)                 \
 {                                                                              \
     /* Check fields have same size */                                          \
-    checkFields(f1, f2, "f1 " #OP " f2 ." #FUNC "()");                         \
+    checkFields(f1, f2, "f1 " #OP " f2" #FUNC);                                \
                                                                                \
     /* Field access */                                                         \
-    TFOR_List_ACCESS(f1, f1P, Restrict);                                       \
-    TFOR_List_CONST_ACCESS(f2, f2P, Restrict);                                 \
-    TFOR_List_LENGTH(f1, loop_len);                                            \
+    List_ACCESS(typeF1, f1, f1P);                                              \
+    List_CONST_ACCESS(typeF2, f2, f2P);                                        \
                                                                                \
     /* Loop: f1 OP f2.FUNC() */                                                \
+    const label loop_len = (f1).size();                                        \
                                                                                \
     /* pragmas... */                                                           \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -98,32 +192,21 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_F_OP_F_FUNC(f1, OP, f2, FUNC) \
-        TSEQ_FORALL_F_OP_F_FUNC_impl(f1, OP, f2, FUNC, __restrict__)
 
-#define TSEQ_FORALL_F_OP_F_FUNC_inplace(f1, OP, f2, FUNC) \
-        TSEQ_FORALL_F_OP_F_FUNC_impl(f1, OP, f2, FUNC,)
-
-// old-style
-#define TFOR_ALL_F_OP_F_FUNC(typeF1, f1, OP, typeF2, f2, FUNC) \
-     TSEQ_FORALL_F_OP_F_FUNC_impl(f1, OP, f2, FUNC, __restrict__)
-
-
-// ------------
 // Binary Free Function : f1 OP FUNC(f2, f3)
 
-#define TSEQ_FORALL_F_OP_FUNC_F_F_impl(f1, OP, FUNC, f2, f3, Restrict)         \
+#define TFOR_ALL_F_OP_FUNC_F_F(typeF1, f1, OP, FUNC, typeF2, f2, typeF3, f3)   \
 {                                                                              \
     /* Check fields have same size */                                          \
     checkFields(f1, f2, f3, "f1 " #OP " " #FUNC "(f2, f3)");                   \
                                                                                \
     /* Field access */                                                         \
-    TFOR_List_ACCESS(f1, f1P, Restrict);                                       \
-    TFOR_List_CONST_ACCESS(f2, f2P, Restrict);                                 \
-    TFOR_List_CONST_ACCESS(f3, f3P, Restrict);                                 \
-    TFOR_List_LENGTH(f1, loop_len);                                            \
+    List_ACCESS(typeF1, f1, f1P);                                              \
+    List_CONST_ACCESS(typeF2, f2, f2P);                                        \
+    List_CONST_ACCESS(typeF3, f3, f3P);                                        \
                                                                                \
     /* Loop: f1 OP FUNC(f2, f3) */                                             \
+    const label loop_len = (f1).size();                                        \
                                                                                \
     /* pragmas... */                                                           \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -132,31 +215,20 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_F_OP_FUNC_F_F(f1, OP, FUNC, f2, f3) \
-        TSEQ_FORALL_F_OP_FUNC_F_F_impl(f1, OP, FUNC, f2, f3, __restrict__)
 
-#define TSEQ_FORALL_F_OP_FUNC_F_F_inplace(f1, OP, FUNC, f2, f3) \
-        TSEQ_FORALL_F_OP_FUNC_F_F_impl(f1, OP, FUNC, f2, f3,)
-
-// old-style
-#define TFOR_ALL_F_OP_FUNC_F_F(typeF1, f1, OP, FUNC, typeF2, f2, typeF3, f3) \
-     TSEQ_FORALL_F_OP_FUNC_F_F_impl(f1, OP, FUNC, f2, f3, __restrict__)
-
-
-// ------------
 // [reduction] Binary Free Function : s OP FUNC(f1, f2)
 
-#define TSEQ_FORALL_S_OP_FUNC_F_F_impl(s, OP, FUNC, f1, f2, Unused)            \
+#define TFOR_ALL_S_OP_FUNC_F_F(typeS, s, OP, FUNC, typeF1, f1, typeF2, f2)     \
 {                                                                              \
     /* Check fields have same size */                                          \
     checkFields(f1, f2, "s " #OP " " #FUNC "(f1, f2)");                        \
                                                                                \
     /* Field access */                                                         \
-    TFOR_List_CONST_ACCESS(f1, f1P, __restrict__);                             \
-    TFOR_List_CONST_ACCESS(f2, f2P, __restrict__);                             \
-    TFOR_List_LENGTH(f1, loop_len);                                            \
+    List_CONST_ACCESS(typeF1, f1, f1P);                                        \
+    List_CONST_ACCESS(typeF2, f2, f2P);                                        \
                                                                                \
     /* Loop: s OP FUNC(f1, f2) */                                              \
+    const label loop_len = (f1).size();                                        \
                                                                                \
     /* pragmas, reduction... */                                                \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -165,31 +237,20 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_S_OP_FUNC_F_F(s, OP, FUNC, f1, f2) \
-        TSEQ_FORALL_S_OP_FUNC_F_F_impl(s, OP, FUNC, f1, f2, __restrict__)
 
-#define TSEQ_FORALL_S_OP_FUNC_F_F_inplace(s, OP, FUNC, f1, f2) \
-        TSEQ_FORALL_S_OP_FUNC_F_F_impl(s, OP, FUNC, f1, f2,)
-
-// old-style
-#define TFOR_ALL_S_OP_FUNC_F_F(typeS, s, OP, FUNC, typeF1, f1, typeF2, f2) \
-     TSEQ_FORALL_S_OP_FUNC_F_F_impl(s, OP, FUNC, f1, f2, __restrict__)
-
-
-// ------------
 // Binary Free Function : f1 OP FUNC(f2, s)
 
-#define TSEQ_FORALL_F_OP_FUNC_F_S_impl(f1, OP, FUNC, f2, s, Restrict)          \
+#define TFOR_ALL_F_OP_FUNC_F_S(typeF1, f1, OP, FUNC, typeF2, f2, typeS, s)     \
 {                                                                              \
     /* Check fields have same size */                                          \
     checkFields(f1, f2, "f1 " #OP " " #FUNC "(f2, s)");                        \
                                                                                \
     /* Field access */                                                         \
-    TFOR_List_ACCESS(f1, f1P, Restrict);                                       \
-    TFOR_List_CONST_ACCESS(f2, f2P, Restrict);                                 \
-    TFOR_List_LENGTH(f1, loop_len);                                            \
+    List_ACCESS(typeF1, f1, f1P);                                              \
+    List_CONST_ACCESS(typeF2, f2, f2P);                                        \
                                                                                \
     /* Loop: f1 OP FUNC(f2, s) */                                              \
+    const label loop_len = (f1).size();                                        \
                                                                                \
     /* pragmas... */                                                           \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -198,27 +259,16 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_F_OP_FUNC_F_S(f1, OP, FUNC, f2, s) \
-        TSEQ_FORALL_F_OP_FUNC_F_S_impl(f1, OP, FUNC, f2, s, __restrict__)
 
-#define TSEQ_FORALL_F_OP_FUNC_F_S_inplace(f1, OP, FUNC, f2, s) \
-        TSEQ_FORALL_F_OP_FUNC_F_S_impl(f1, OP, FUNC, f2, s,)
-
-// old-style
-#define TFOR_ALL_F_OP_FUNC_F_S(typeF1, f1, OP, FUNC, typeF2, f2, typeS, s) \
-     TSEQ_FORALL_F_OP_FUNC_F_S_impl(f1, OP, FUNC, f2, s, __restrict__)
-
-
-// ------------
 // [reduction] Binary Free Function : s1 OP FUNC(f, s2)
 
-#define TSEQ_FORALL_S_OP_FUNC_F_S_impl(s1, OP, FUNC, f, s2, Unused)            \
+#define TFOR_ALL_S_OP_FUNC_F_S(typeS1, s1, OP, FUNC, typeF, f, typeS2, s2)     \
 {                                                                              \
     /* Field access */                                                         \
-    TFOR_List_CONST_ACCESS(f, fP, __restrict__);                               \
-    TFOR_List_LENGTH(f, loop_len);                                             \
+    List_CONST_ACCESS(typeF, f, fP);                                           \
                                                                                \
     /* Loop: s1 OP FUNC(f, s2) */                                              \
+    const label loop_len = (f).size();                                         \
                                                                                \
     /* pragmas, reduction... */                                                \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -227,31 +277,20 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_S_OP_FUNC_F_S(s1, OP, FUNC, f, s2) \
-        TSEQ_FORALL_S_OP_FUNC_F_S_impl(s1, OP, FUNC, f, s2, __restrict__)
 
-#define TSEQ_FORALL_S_OP_FUNC_F_S_inplace(s1, OP, FUNC, f, s2) \
-        TSEQ_FORALL_S_OP_FUNC_F_S_impl(s1, OP, FUNC, f, s2,)
-
-// old-style
-#define TFOR_ALL_S_OP_FUNC_F_S(typeS1, s1, OP, FUNC, typeF, f, typeS2, s2) \
-     TSEQ_FORALL_S_OP_FUNC_F_S_impl(s1, OP, FUNC, f, s2, __restrict__)
-
-
-// ------------
 // Binary Free Function : f1 OP FUNC(s, f2)
 
-#define TSEQ_FORALL_F_OP_FUNC_S_F_impl(f1, OP, FUNC, s, f2, Restrict)          \
+#define TFOR_ALL_F_OP_FUNC_S_F(typeF1, f1, OP, FUNC, typeS, s, typeF2, f2)     \
 {                                                                              \
     /* Check fields have same size */                                          \
     checkFields(f1, f2, "f1 " #OP " " #FUNC "(s, f2)");                        \
                                                                                \
     /* Field access */                                                         \
-    TFOR_List_ACCESS(f1, f1P, Restrict);                                       \
-    TFOR_List_CONST_ACCESS(f2, f2P, Restrict);                                 \
-    TFOR_List_LENGTH(f1, loop_len);                                            \
+    List_ACCESS(typeF1, f1, f1P);                                              \
+    List_CONST_ACCESS(typeF2, f2, f2P);                                        \
                                                                                \
     /* Loop: f1 OP1 f2 OP2 f3 */                                               \
+    const label loop_len = (f1).size();                                        \
                                                                                \
     /* pragmas... */                                                           \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -260,27 +299,16 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_F_OP_FUNC_S_F(f1, OP, FUNC, s, f2) \
-        TSEQ_FORALL_F_OP_FUNC_S_F_impl(f1, OP, FUNC, s, f2, __restrict__)
 
-#define TSEQ_FORALL_F_OP_FUNC_S_F_inplace(f1, OP, FUNC, s, f2) \
-        TSEQ_FORALL_F_OP_FUNC_S_F_impl(f1, OP, FUNC, s, f2,)
-
-// old-style
-#define TFOR_ALL_F_OP_FUNC_S_F(typeF1, f1, OP, FUNC, typeS, s, typeF2, f2) \
-     TSEQ_FORALL_F_OP_FUNC_S_F_impl(f1, OP, FUNC, s, f2, __restrict__)
-
-
-// ------------
 // Binary Free Function : f1 OP FUNC(s1, s2)
 
-#define TSEQ_FORALL_F_OP_FUNC_S_S_impl(f1, OP, FUNC, s1, s2, Unused)           \
+#define TFOR_ALL_F_OP_FUNC_S_S(typeF1, f1, OP, FUNC, typeS1, s1, typeS2, s2)   \
 {                                                                              \
     /* Field access */                                                         \
-    TFOR_List_ACCESS(f1, f1P, __restrict__);                                   \
-    TFOR_List_LENGTH(f1, loop_len);                                            \
+    List_ACCESS(typeF1, f1, f1P);                                              \
                                                                                \
     /* Loop: f1 OP FUNC(s1, s2) */                                             \
+    const label loop_len = (f1).size();                                        \
                                                                                \
     /* pragmas... */                                                           \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -289,32 +317,20 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_F_OP_FUNC_S_S(f1, OP, FUNC, s1, s2) \
-        TSEQ_FORALL_F_OP_FUNC_S_S_impl(f1, OP, FUNC, s1, s2, __restrict__)
 
-#define TSEQ_FORALL_F_OP_FUNC_S_S_inplace(f1, OP, FUNC, s1, s2) \
-        TSEQ_FORALL_F_OP_FUNC_S_S_impl(f1, OP, FUNC, s1, s2,)
+// Unary Member Function : f1 OP f2 FUNC(s)
 
-// old-style
-#define TFOR_ALL_F_OP_FUNC_S_S(typeF1, f1, OP, FUNC, typeS1, s1, typeS2, s2) \
-     TSEQ_FORALL_F_OP_FUNC_S_S_impl(f1, OP, FUNC, s1, s2, __restrict__)
-
-
-// ------------
-// Unary Member Function : f1 OP f2.FUNC(s)
-// NB: the '.' is passed in the func parameter
-
-#define TSEQ_FORALL_F_OP_F_FUNC_S_impl(f1, OP, f2, FUNC, s, Restrict)          \
+#define TFOR_ALL_F_OP_F_FUNC_S(typeF1, f1, OP, typeF2, f2, FUNC, typeS, s)     \
 {                                                                              \
     /* Check fields have same size */                                          \
     checkFields(f1, f2, "f1 " #OP " f2 " #FUNC "(s)");                         \
                                                                                \
     /* Field access */                                                         \
-    TFOR_List_ACCESS(f1, f1P, Restrict);                                       \
-    TFOR_List_CONST_ACCESS(f2, f2P, Restrict);                                 \
-    TFOR_List_LENGTH(f1, loop_len);                                            \
+    List_ACCESS(typeF1, f1, f1P);                                              \
+    List_CONST_ACCESS(typeF2, f2, f2P);                                        \
                                                                                \
     /* Loop: f1 OP f2 FUNC(s) */                                               \
+    const label loop_len = (f1).size();                                        \
                                                                                \
     /* pragmas... */                                                           \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -323,35 +339,25 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_F_OP_F_FUNC_S(f1, OP, f2, FUNC, s) \
-        TSEQ_FORALL_F_OP_F_FUNC_S_impl(f1, OP, f2, FUNC, s, __restrict__)
-
-#define TSEQ_FORALL_F_OP_F_FUNC_S_inplace(f1, OP, f2, FUNC, s) \
-        TSEQ_FORALL_F_OP_F_FUNC_S_impl(f1, OP, f2, FUNC, s,)
-
-// old-style
-#define TFOR_ALL_F_OP_F_FUNC_S(typeF1, f1, OP, typeF2, f2, FUNC, typeS, s) \
-     TSEQ_FORALL_F_OP_F_FUNC_S_impl(f1, OP, f2, FUNC, s, __restrict__)
-
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-// ------------
 // Ternary Free Function : f1 OP FUNC(f2, f3, f4)
 
-#define TSEQ_FORALL_F_OP_FUNC_F_F_F_impl(f1, OP, FUNC, f2, f3, f4, Restrict)   \
+#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 */                                                         \
-    TFOR_List_ACCESS(f1, f1P, Restrict);                                       \
-    TFOR_List_CONST_ACCESS(f2, f2P, Restrict);                                 \
-    TFOR_List_CONST_ACCESS(f3, f3P, Restrict);                                 \
-    TFOR_List_CONST_ACCESS(f4, f4P, Restrict);                                 \
-    TFOR_List_LENGTH(f1, loop_len);                                            \
+    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 loop_len = (f1).size();                                        \
                                                                                \
     /* pragmas... */                                                           \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -360,32 +366,21 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_F_OP_FUNC_F_F_F(f1, OP, FUNC, f2, f3, f4) \
-        TSEQ_FORALL_F_OP_FUNC_F_F_F_impl(f1, OP, FUNC, f2, f3, f4, __restrict__)
-
-#define TSEQ_FORALL_F_OP_FUNC_F_F_F_inplace(f1, OP, FUNC, f2, f3, f4) \
-        TSEQ_FORALL_F_OP_FUNC_F_F_F_impl(f1, OP, FUNC, f2, f3, f4,)
-
-// old-style
-#define TFOR_ALL_F_OP_FUNC_F_F_F(type1, f1, OP, FUNC, type2, f2, type3, f3, type4, f4) \
-     TSEQ_FORALL_F_OP_FUNC_F_F_F_impl(f1, OP, FUNC, f2, f3, f4, __restrict__)
-
-
-// ------------
 // Ternary Free Function : f1 OP FUNC(f2, f3, s4)
 
-#define TSEQ_FORALL_F_OP_FUNC_F_F_S_impl(f1, OP, FUNC, f2, f3, s4, Restrict)   \
+#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 */                                                         \
-    TFOR_List_ACCESS(f1, f1P, Restrict);                                       \
-    TFOR_List_CONST_ACCESS(f2, f2P, Restrict);                                 \
-    TFOR_List_CONST_ACCESS(f3, f3P, Restrict);                                 \
-    TFOR_List_LENGTH(f1, loop_len);                                            \
+    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 loop_len = (f1).size();                                        \
                                                                                \
     /* pragmas... */                                                           \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -394,34 +389,23 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_F_OP_FUNC_F_F_S(f1, OP, FUNC, f2, f3, s4) \
-        TSEQ_FORALL_F_OP_FUNC_F_F_S_impl(f1, OP, FUNC, f2, f3, s4, __restrict__)
-
-#define TSEQ_FORALL_F_OP_FUNC_F_F_S_inplace(f1, OP, FUNC, f2, f3, s4) \
-        TSEQ_FORALL_F_OP_FUNC_F_F_S_impl(f1, OP, FUNC, f2, f3, s4,)
-
-// old-style
-#define TFOR_ALL_F_OP_FUNC_F_F_S(type1, f1, OP, FUNC, type2, f2, type3, f3, type4, s4) \
-     TSEQ_FORALL_F_OP_FUNC_F_F_S_impl(f1, OP, FUNC, f2, f3, s4, __restrict__)
-
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-// ------------
 // Member operator : this field f1 OP1 f2 OP2 f3
 
-#define TSEQ_FORALL_F_OP_F_OP_F_impl(f1, OP1, f2, OP2, f3, Restrict)           \
+#define TFOR_ALL_F_OP_F_OP_F(typeF1, f1, OP1, typeF2, f2, OP2, typeF3, f3)     \
 {                                                                              \
     /* Check fields have same size */                                          \
     checkFields(f1, f2, f3, "f1 " #OP1 " f2 " #OP2 " f3");                     \
                                                                                \
     /* Field access */                                                         \
-    TFOR_List_ACCESS(f1, f1P, Restrict);                                       \
-    TFOR_List_CONST_ACCESS(f2, f2P, Restrict);                                 \
-    TFOR_List_CONST_ACCESS(f3, f3P, Restrict);                                 \
-    TFOR_List_LENGTH(f1, loop_len);                                            \
+    List_ACCESS(typeF1, f1, f1P);                                              \
+    List_CONST_ACCESS(typeF2, f2, f2P);                                        \
+    List_CONST_ACCESS(typeF3, f3, f3P);                                        \
                                                                                \
     /* Loop: f1 OP1 f2 OP2 f3 */                                               \
+    const label loop_len = (f1).size();                                        \
                                                                                \
     /* pragmas... */                                                           \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -430,31 +414,20 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_F_OP_F_OP_F(f1, OP1, f2, OP2, f3) \
-        TSEQ_FORALL_F_OP_F_OP_F_impl(f1, OP1, f2, OP2, f3, __restrict__)
 
-#define TSEQ_FORALL_F_OP_F_OP_F_inplace(f1, OP1, f2, OP2, f3) \
-        TSEQ_FORALL_F_OP_F_OP_F_impl(f1, OP1, f2, OP2, f3,)
-
-// old-style
-#define TFOR_ALL_F_OP_F_OP_F(type1, f1, OP1, type2, f2, OP2, type3, f3) \
-     TSEQ_FORALL_F_OP_F_OP_F_impl(f1, OP1, f2, OP2, f3, __restrict__)
-
-
-// ------------
 // Member operator : this field f1 OP1 s OP2 f2
 
-#define TSEQ_FORALL_F_OP_S_OP_F_impl(f1, OP1, s, OP2, f2, Restrict)            \
+#define TFOR_ALL_F_OP_S_OP_F(typeF1, f1, OP1, typeS, s, OP2, typeF2, f2)       \
 {                                                                              \
     /* Check fields have same size */                                          \
     checkFields(f1, f2, "f1 " #OP1 " s " #OP2 " f2");                          \
                                                                                \
     /* Field access */                                                         \
-    TFOR_List_ACCESS(f1, f1P, Restrict);                                       \
-    TFOR_List_CONST_ACCESS(f2, f2P, Restrict);                                 \
-    TFOR_List_LENGTH(f1, loop_len);                                            \
+    List_ACCESS(typeF1, f1, f1P);                                              \
+    List_CONST_ACCESS(typeF2, f2, f2P);                                        \
                                                                                \
     /* Loop: f1 OP1 s OP2 f2 */                                                \
+    const label loop_len = (f1).size();                                        \
                                                                                \
     /* pragmas... */                                                           \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -463,31 +436,20 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_F_OP_S_OP_F(f1, OP1, s, OP2, f2) \
-        TSEQ_FORALL_F_OP_S_OP_F_impl(f1, OP1, s, OP2, f2, __restrict__)
 
-#define TSEQ_FORALL_F_OP_S_OP_F_inplace(f1, OP1, s, OP2, f2) \
-        TSEQ_FORALL_F_OP_S_OP_F_impl(f1, OP1, s, OP2, f2,)
-
-// old-style
-#define TFOR_ALL_F_OP_S_OP_F(type1, f1, OP1, typeS, s, OP2, type2, f2) \
-    TSEQ_FORALL_F_OP_S_OP_F_impl(f1, OP1, s, OP2, f2, __restrict__)
-
-
-// ------------
 // Member operator : this field f1 OP1 f2 OP2 s
 
-#define TSEQ_FORALL_F_OP_F_OP_S_impl(f1, OP1, f2, OP2, s, Restrict)            \
+#define TFOR_ALL_F_OP_F_OP_S(typeF1, f1, OP1, typeF2, f2, OP2, typeS, s)       \
 {                                                                              \
     /* Check fields have same size */                                          \
     checkFields(f1, f2, "f1 " #OP1 " f2 " #OP2 " s");                          \
                                                                                \
     /* Field access */                                                         \
-    TFOR_List_ACCESS(f1, f1P, Restrict);                                       \
-    TFOR_List_CONST_ACCESS(f2, f2P, Restrict);                                 \
-    TFOR_List_LENGTH(f1, loop_len);                                            \
+    List_ACCESS(typeF1, f1, f1P);                                              \
+    List_CONST_ACCESS(typeF2, f2, f2P);                                        \
                                                                                \
     /* Loop f1 OP1 s OP2 f2 */                                                 \
+    const label loop_len = (f1).size();                                        \
                                                                                \
     /* pragmas... */                                                           \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -496,31 +458,20 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_F_OP_F_OP_S(f1, OP1, f2, OP2, s) \
-        TSEQ_FORALL_F_OP_F_OP_S_impl(f1, OP1, f2, OP2, s, __restrict__)
 
-#define TSEQ_FORALL_F_OP_F_OP_S_inplace(f1, OP1, f2, OP2, s) \
-        TSEQ_FORALL_F_OP_F_OP_S_impl(f1, OP1, f2, OP2, s,)
-
-// old-style
-#define TFOR_ALL_F_OP_F_OP_S(type1, f1, OP1, type2, f2, OP2, typeS, s) \
-     TSEQ_FORALL_F_OP_F_OP_S_impl(f1, OP1, f2, OP2, s, __restrict__)
-
-
-// ------------
 // Member operator : this field f1 OP f2
 
-#define TSEQ_FORALL_F_OP_F_impl(f1, OP, f2, Restrict)                          \
+#define TFOR_ALL_F_OP_F(typeF1, f1, OP, typeF2, f2)                            \
 {                                                                              \
     /* Check fields have same size */                                          \
     checkFields(f1, f2, "f1 " #OP " f2");                                      \
                                                                                \
     /* Field access */                                                         \
-    TFOR_List_ACCESS(f1, f1P, Restrict);                                       \
-    TFOR_List_CONST_ACCESS(f2, f2P, Restrict);                                 \
-    TFOR_List_LENGTH(f1, loop_len);                                            \
+    List_ACCESS(typeF1, f1, f1P);                                              \
+    List_CONST_ACCESS(typeF2, f2, f2P);                                        \
                                                                                \
     /* Loop: f1 OP f2 */                                                       \
+    const label loop_len = (f1).size();                                        \
                                                                                \
     /* pragmas... */                                                           \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -529,31 +480,20 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_F_OP_F(f1, OP, f2) \
-        TSEQ_FORALL_F_OP_F_impl(f1, OP, f2, __restrict__)
 
-#define TSEQ_FORALL_F_OP_F_inplace(f1, OP, f2) \
-        TSEQ_FORALL_F_OP_F_impl(f1, OP, f2,)
-
-// old-style
-#define TFOR_ALL_F_OP_F(type1, f1, OP, type2, f2) \
-     TSEQ_FORALL_F_OP_F_impl(f1, OP, f2, __restrict__)
-
-
-// ------------
 // Member operator : this field f1 OP1 OP2 f2
 
-#define TSEQ_FORALL_F_OP_OP_F_impl(f1, OP1, OP2, f2, Restrict)                 \
+#define TFOR_ALL_F_OP_OP_F(typeF1, f1, OP1, OP2, typeF2, f2)                   \
 {                                                                              \
     /* Check fields have same size */                                          \
     checkFields(f1, f2, #OP1 " " #OP2 " f2");                                  \
                                                                                \
     /* Field access */                                                         \
-    TFOR_List_ACCESS(f1, f1P, Restrict);                                       \
-    TFOR_List_CONST_ACCESS(f2, f2P, Restrict);                                 \
-    TFOR_List_LENGTH(f1, loop_len);                                            \
+    List_ACCESS(typeF1, f1, f1P);                                              \
+    List_CONST_ACCESS(typeF2, f2, f2P);                                        \
                                                                                \
     /* Loop: f1 OP1 OP2 f2 */                                                  \
+    const label loop_len = (f1).size();                                        \
                                                                                \
     /* pragmas... */                                                           \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -562,27 +502,16 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_F_OP_OP_F(f1, OP1, OP2, f2) \
-        TSEQ_FORALL_F_OP_OP_F_impl(f1, OP1, OP2, f2, __restrict__)
 
-#define TSEQ_FORALL_F_OP_OP_F_inplace(f1, OP1, OP2, f2) \
-        TSEQ_FORALL_F_OP_OP_F_impl(f1, OP1, OP2, f2,)
-
-// old-style
-#define TFOR_ALL_F_OP_OP_F(typeF1, f1, OP1, OP2, typeF2, f2) \
-     TSEQ_FORALL_F_OP_OP_F_impl(f1, OP1, OP2, f2, __restrict__)
-
-
-// ------------
 // Member operator : this field f OP s
 
-#define TSEQ_FORALL_F_OP_S_impl(f, OP, s, Unused)                              \
+#define TFOR_ALL_F_OP_S(typeF, f, OP, typeS, s)                                \
 {                                                                              \
     /* Field access */                                                         \
-    TFOR_List_ACCESS(f, fP, __restrict__);                                     \
-    TFOR_List_LENGTH(f, loop_len);                                             \
+    List_ACCESS(typeF, f, fP);                                                 \
                                                                                \
     /* Loop: f OP s */                                                         \
+    const label loop_len = (f).size();                                         \
                                                                                \
     /* pragmas... */                                                           \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -591,29 +520,18 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_F_OP_S(f, OP, s) \
-        TSEQ_FORALL_F_OP_S_impl(f, OP, s, __restrict__)
-
-#define TSEQ_FORALL_F_OP_S_inplace(f, OP, s) \
-        TSEQ_FORALL_F_OP_S_impl(f, OP, s,)
-
-// old-style
-#define TFOR_ALL_F_OP_S(typeF, f, OP, typeS, s) \
-     TSEQ_FORALL_F_OP_S_impl(f, OP, s, __restrict__)
-
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-// ------------
-// Friend operator function : s OP f
+// Friend operator function : s OP f, allocates storage for s
 
-#define TSEQ_FORALL_S_OP_F_impl(s, OP, f, Unused)                              \
+#define TFOR_ALL_S_OP_F(typeS, s, OP, typeF, f)                                \
 {                                                                              \
     /* Field access */                                                         \
-    TFOR_List_CONST_ACCESS(f, fP, __restrict__);                               \
-    TFOR_List_LENGTH(f, loop_len);                                             \
+    List_CONST_ACCESS(typeF, f, fP);                                           \
                                                                                \
     /* Loop: s OP f */                                                         \
+    const label loop_len = (f).size();                                         \
                                                                                \
     /* pragmas, reduction... */                                                \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -622,28 +540,17 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_S_OP_F(s, OP, f) \
-        TSEQ_FORALL_S_OP_F_impl(s, OP, f, __restrict__)
 
-#define TSEQ_FORALL_S_OP_F_inplace(s, OP, f) \
-        TSEQ_FORALL_S_OP_F_impl(s, OP, f,)
+// Friend operator function : s OP1 f1 OP2 f2, allocates storage for s
 
-// old-style
-#define TFOR_ALL_S_OP_F(typeS, s, OP, typeF, f) \
-     TSEQ_FORALL_S_OP_F_impl(s, OP, f, __restrict__)
-
-
-// ------------
-// Friend operator function : s OP1 f1 OP2 f2
-
-#define TSEQ_FORALL_S_OP_F_OP_F_impl(s, OP1, f1, OP2, f2, Unused)              \
+#define TFOR_ALL_S_OP_F_OP_F(typeS, s, OP1, typeF1, f1, OP2, typeF2, f2)       \
 {                                                                              \
     /* Field access */                                                         \
-    TFOR_List_ACCESS(f1, f1P, __restrict__);                                   \
-    TFOR_List_CONST_ACCESS(f2, f2P, __restrict__);                             \
-    TFOR_List_LENGTH(f1, loop_len);                                            \
+    List_CONST_ACCESS(typeF1, f1, f1P);                                        \
+    List_CONST_ACCESS(typeF2, f2, f2P);                                        \
                                                                                \
     /* Loop: s OP1 f1 OP2 f2 */                                                \
+    const label loop_len = (f1).size();                                        \
                                                                                \
     /* pragmas, reduction... */                                                \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -652,27 +559,15 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_S_OP_F_OP_F(s, OP1, f1, OP2, f2) \
-        TSEQ_FORALL_S_OP_F_OP_F_impl(s, OP1, f1, OP2, f2, __restrict__)
 
-#define TSEQ_FORALL_S_OP_F_OP_F_inplace(s, OP1, f1, OP2, f2) \
-        TSEQ_FORALL_S_OP_F_OP_F_impl(s, OP1, f1, OP2, f2,)
-
-// old-style
-#define TFOR_ALL_S_OP_F_OP_F(typeS, s, OP1, type1, f1, OP2, type2, f2) \
-     TSEQ_FORALL_S_OP_F_OP_F_impl(s, OP1, f1, OP2, f2, __restrict__)
-
-
-// ------------
-// Friend operator function : s OP FUNC(f)
-
-#define TSEQ_FORALL_S_OP_FUNC_F_impl(s, OP, FUNC, f, Unused)                   \
+// Friend operator function : s OP FUNC(f), allocates storage for s
+#define TFOR_ALL_S_OP_FUNC_F(typeS, s, OP, FUNC, typeF, f)                     \
 {                                                                              \
     /* Field access */                                                         \
-    TFOR_List_CONST_ACCESS(f, fP, __restrict__);                               \
-    TFOR_List_LENGTH(f, loop_len);                                             \
+    List_CONST_ACCESS(typeF, f, fP);                                           \
                                                                                \
     /* Loop: s OP FUNC(f) */                                                   \
+    const label loop_len = (f).size();                                         \
                                                                                \
     /* pragmas, reduction... */                                                \
     for (label i = 0; i < loop_len; ++i)                                       \
@@ -681,16 +576,6 @@ namespace Foam
     }                                                                          \
 }
 
-#define TSEQ_FORALL_S_OP_FUNC_F(s, OP, FUNC, f) \
-        TSEQ_FORALL_S_OP_FUNC_F_impl(s, OP, FUNC, f, __restrict__)
-
-#define TSEQ_FORALL_S_OP_FUNC_F_inplace(s, OP, FUNC, f) \
-        TSEQ_FORALL_S_OP_FUNC_F_impl(s, OP, FUNC, f,)
-
-// old-style
-#define TFOR_ALL_S_OP_FUNC_F(typeS, s, OP, FUNC, typeF, f) \
-     TSEQ_FORALL_S_OP_FUNC_F_impl(s, OP, FUNC, f, __restrict__)
-
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/OpenFOAM/fields/Fields/Field/FieldReuseFunctions.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2024 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -40,15 +40,6 @@ namespace Foam
 template<class TypeR, class Type1>
 struct reuseTmp
 {
-    //- Dissimilar types: non-reusable
-    static bool reusable
-    (
-        const tmp<Field<Type1>>& tf1
-    )
-    {
-        return false;
-    }
-
     //- Pass-through to tmp New
     static tmp<Field<TypeR>> New(const Field<Type1>& f1)
     {
@@ -66,15 +57,6 @@ struct reuseTmp
 template<class TypeR>
 struct reuseTmp<TypeR, TypeR>
 {
-    //- Identical types: possibly reusable
-    static bool reusable
-    (
-        const tmp<Field<TypeR>>& tf1
-    )
-    {
-        return tf1.movable();
-    }
-
     //- Identical input and return types:
     //- allow optional copy assignment of the initial content
     static tmp<Field<TypeR>> New
@@ -117,16 +99,6 @@ template<class TypeR> tmp<Field<TypeR>> New
 template<class TypeR, class Type1, class Type12, class Type2>
 struct reuseTmpTmp
 {
-    //- Dissimilar types: non-reusable
-    static bool reusable
-    (
-        const tmp<Field<Type1>>& tf1,
-        const tmp<Field<Type2>>& tf2
-    )
-    {
-        return false;
-    }
-
     //- Dissimilar types: just use size
     static tmp<Field<TypeR>> New
     (
@@ -142,16 +114,6 @@ struct reuseTmpTmp
 template<class TypeR, class Type1, class Type12>
 struct reuseTmpTmp<TypeR, Type1, Type12, TypeR>
 {
-    //- Second input has return type: possibly reusable
-    static bool reusable
-    (
-        const tmp<Field<Type1>>& tf1,
-        const tmp<Field<TypeR>>& tf2
-    )
-    {
-        return tf2.movable();
-    }
-
     //- Second input has return type
     static tmp<Field<TypeR>> New
     (
@@ -172,16 +134,6 @@ struct reuseTmpTmp<TypeR, Type1, Type12, TypeR>
 template<class TypeR, class Type2>
 struct reuseTmpTmp<TypeR, TypeR, TypeR, Type2>
 {
-    //- First input has return type: possibly reusable
-    static bool reusable
-    (
-        const tmp<Field<TypeR>>& tf1,
-        const tmp<Field<Type2>>& tf2
-    )
-    {
-        return tf1.movable();
-    }
-
     //- First input has return type
     static tmp<Field<TypeR>> New
     (
@@ -202,16 +154,6 @@ struct reuseTmpTmp<TypeR, TypeR, TypeR, Type2>
 template<class TypeR>
 struct reuseTmpTmp<TypeR, TypeR, TypeR, TypeR>
 {
-    //- Both inputs have return type: possibly reusable
-    static bool reusable
-    (
-        const tmp<Field<TypeR>>& tf1,
-        const tmp<Field<TypeR>>& tf2
-    )
-    {
-        return (tf1.movable() || tf2.movable());
-    }
-
     //- Both inputs have return type
     static tmp<Field<TypeR>> New
     (

src/OpenFOAM/fields/Fields/Field/ListLoopM.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2017-2024 OpenCFD Ltd.
+    Copyright (C) 2017 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -32,22 +32,6 @@ Description
 #ifndef Foam_ListLoopM_H
 #define Foam_ListLoopM_H
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-// Element access looping
-
-// The List size
-#define TFOR_List_LENGTH(f, n)                  \
-    const Foam::label n = (f).size()
-
-// List begin, non-const access with __restrict__ (or not)
-#define TFOR_List_ACCESS(f, fp, Restrict)       \
-    auto* const Restrict fp = (f).begin()
-
-// List begin, const access with __restrict__ (or not)
-#define TFOR_List_CONST_ACCESS(f, fp, Restrict) \
-    const auto* const Restrict fp = (f).begin()
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 // Element access looping
 
@@ -61,8 +45,8 @@ Description
 
 // Loop over all elements
 #define List_FOR_ALL(f, i)                      \
-        const Foam::label _n##i = (f).size();   \
-        for (Foam::label i = 0; i < _n##i; ++i)
+        const label _n##i = (f).size();         \
+        for (label i=0; i<_n##i; ++i)
 
 // Current element (non-const access)
 #define List_ELEM(fp, i)  (fp[i])

src/OpenFOAM/fields/Fields/Field/errorCheckFields.H

@@ -1,133 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2011 OpenFOAM Foundation
-    Copyright (C) 2024 OpenCFD Ltd.
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Description
-    Field size checks for field operations
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef Foam_errorCheckFields_H
-#define Foam_errorCheckFields_H
-
-#include "error.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-template<class Type1, class Type2>
-void checkFields
-(
-    const UList<Type1>& f1,
-    const UList<Type2>& f2,
-    const char* op
-)
-{
-    #ifdef FULLDEBUG
-    if (f1.size() != f2.size())
-    {
-        FatalErrorInFunction
-            << " Field<"<<pTraits<Type1>::typeName<<"> f1("<<f1.size()<<')'
-            << " and Field<"<<pTraits<Type2>::typeName<<"> f2("<<f2.size()<<')'
-            << nl
-            << " for operation " << op << endl
-            << abort(FatalError);
-    }
-    #endif
-}
-
-
-template<class Type1, class Type2, class Type3>
-void checkFields
-(
-    const UList<Type1>& f1,
-    const UList<Type2>& f2,
-    const UList<Type3>& f3,
-    const char* op
-)
-{
-    #ifdef FULLDEBUG
-    if
-    (
-        f1.size() != f2.size()
-     || f1.size() != f3.size()
-    )
-    {
-        FatalErrorInFunction
-            << " Field<"<<pTraits<Type1>::typeName<<"> f1("<<f1.size()<<')'
-            << ", Field<"<<pTraits<Type2>::typeName<<"> f2("<<f2.size()<<')'
-            << " and Field<"<<pTraits<Type3>::typeName<<"> f3("<<f3.size()<<')'
-            << nl
-            << " for operation " << op << endl
-            << abort(FatalError);
-    }
-    #endif
-}
-
-
-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
-)
-{
-    #ifdef FULLDEBUG
-    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()<<')'
-            << nl
-            << " for operation " << op << endl
-            << abort(FatalError);
-    }
-    #endif
-}
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

src/OpenFOAM/fields/Fields/boolField/boolField.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2019-2024 OpenCFD Ltd.
+    Copyright (C) 2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -45,7 +45,7 @@ template<>
 void boolField::negate()
 {
     // std::for_each, std::logical_not
-    TSEQ_FORALL_F_OP_OP_F_inplace(*this, =, !, *this)
+    TFOR_ALL_F_OP_OP_F(bool, *this, =, !, bool, *this)
 }
 
 

src/OpenFOAM/fields/Fields/complex/complexField.C

@@ -255,7 +255,7 @@ complex sumProd(const UList<complex>& f1, const UList<complex>& f2)
     if (f1.size() && (f1.size() == f2.size()))
     {
         // std::inner_product
-        TSEQ_FORALL_S_OP_F_OP_F(result, +=, f1, *, f2)
+        TFOR_ALL_S_OP_F_OP_F(complex, result, +=, complex, f1, *, complex, f2)
     }
     return result;
 }

src/OpenFOAM/fields/Fields/scalarField/scalarField.C

@@ -68,16 +68,11 @@ void scalarField::replace(const direction, const scalar& s)
 
 void stabilise(scalarField& res, const UList<scalar>& sf, const scalar s)
 {
-    if (res.cdata() == sf.cdata())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_S_F_inplace(res, =, ::Foam::stabilise, s, sf)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_S_F(res, =, ::Foam::stabilise, s, sf)
-    }
+    // std::transform
+    TFOR_ALL_F_OP_FUNC_S_F
+    (
+        scalar, res, =, ::Foam::stabilise, scalar, s, scalar, sf
+    )
 }
 
 tmp<scalarField> stabilise(const UList<scalar>& sf, const scalar s)
@@ -101,11 +96,11 @@ tmp<scalarField> stabilise(const tmp<scalarField>& tsf, const scalar s)
 template<>
 float sumProd(const UList<float>& f1, const UList<float>& f2)
 {
-    float result(0);
+    float result = 0.0;
     if (f1.size() && (f1.size() == f2.size()))
     {
         // std::inner_product
-        TSEQ_FORALL_S_OP_F_OP_F(result, +=, f1, *, f2)
+        TFOR_ALL_S_OP_F_OP_F(float, result, +=, float, f1, *, float, f2)
     }
     return result;
 }
@@ -114,11 +109,11 @@ float sumProd(const UList<float>& f1, const UList<float>& f2)
 template<>
 double sumProd(const UList<double>& f1, const UList<double>& f2)
 {
-    double result(0);
+    double result = 0.0;
     if (f1.size() && (f1.size() == f2.size()))
     {
         // std::inner_product
-        TSEQ_FORALL_S_OP_F_OP_F(result, +=, f1, *, f2)
+        TFOR_ALL_S_OP_F_OP_F(double, result, +=, double, f1, *, double, f2)
     }
     return result;
 }
@@ -193,16 +188,7 @@ UNARY_FUNCTION(scalar, scalar, paToBar)
 #define BesselFunc(func)                                                       \
 void func(scalarField& res, const int n, const UList<scalar>& sf)              \
 {                                                                              \
-    if (res.cdata() == sf.cdata())                                             \
-    {                                                                          \
-        /* std::for_each */                                                    \
-        TSEQ_FORALL_F_OP_FUNC_S_F_inplace(res, =, ::Foam::func, n, sf)         \
-    }                                                                          \
-    else                                                                       \
-    {                                                                          \
-        /* std::transform */                                                   \
-        TSEQ_FORALL_F_OP_FUNC_S_F(res, =, ::Foam::func, n, sf)                 \
-    }                                                                          \
+    TFOR_ALL_F_OP_FUNC_S_F(scalar, res, =, ::Foam::func, int, n, scalar, sf)   \
 }                                                                              \
                                                                                \
 tmp<scalarField> func(const int n, const UList<scalar>& sf)                    \

src/OpenFOAM/fields/Fields/symmTensorField/symmTensorField.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2024 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -54,16 +54,8 @@ UNARY_FUNCTION(symmTensor, symmTensor, cof)
 void inv(Field<symmTensor>& result, const UList<symmTensor>& f1)
 {
     // With 'failsafe' invert
-    if (result.cdata() == f1.cdata())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_F_FUNC_inplace(result, =, f1, safeInv)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_F_FUNC(result, =, f1, safeInv)
-    }
+    // std::transform
+    TFOR_ALL_F_OP_F_FUNC(symmTensor, result, =, symmTensor, f1, safeInv)
 }
 
 tmp<symmTensorField> inv(const UList<symmTensor>& tf)

src/OpenFOAM/fields/Fields/symmTransformField/symmTransformField.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2023-2024 OpenCFD Ltd.
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -39,16 +39,11 @@ void Foam::transform
     const Field<Type>& fld
 )
 {
-    if (result.cdata() == fld.cdata())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_S_F_inplace(result, =, transform, rot, fld)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_S_F(result, =, transform, rot, fld)
-    }
+    // std::transform
+    TFOR_ALL_F_OP_FUNC_S_F
+    (
+        Type, result, =, transform, symmTensor, rot, Type, fld
+    );
 }
 
 
@@ -60,23 +55,16 @@ void Foam::transform
     const Field<Type>& fld
 )
 {
-    // Does not handle corner case where result and rot are identical...
-
     if (rot.size() == 1)
     {
         return transform(result, rot.front(), fld);
     }
 
-    if (result.cdata() == fld.cdata())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_F_F_inplace(result, =, transform, rot, fld)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_F_F(result, =, transform, rot, fld)
-    }
+    // std::transform
+    TFOR_ALL_F_OP_FUNC_F_F
+    (
+        Type, result, =, transform, symmTensor, rot, Type, fld
+    );
 }
 
 

src/OpenFOAM/fields/Fields/tensorField/tensorField.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2024 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -55,16 +55,8 @@ UNARY_FUNCTION(tensor, tensor, cof)
 void inv(Field<tensor>& result, const UList<tensor>& f1)
 {
     // With 'failsafe' invert
-    if (result.cdata() == f1.cdata())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_F_FUNC_inplace(result, =, f1, safeInv)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_F_FUNC(result, =, f1, safeInv)
-    }
+    // std::transform
+    TFOR_ALL_F_OP_F_FUNC(tensor, result, =, tensor, f1, safeInv)
 }
 
 tmp<tensorField> inv(const UList<tensor>& tf)
@@ -96,7 +88,7 @@ tmp<Field<tensor>> transformFieldMask<tensor>
 {
     auto tres = tmp<tensorField>::New(stf.size());
     auto& res = tres.ref();
-    TSEQ_FORALL_F_OP_F(res, =, stf)
+    TFOR_ALL_F_OP_F(tensor, res, =, symmTensor, stf)
     return tres;
 }
 

src/OpenFOAM/fields/Fields/transformField/transformField.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2024 OpenCFD Ltd.
+    Copyright (C) 2018 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -34,22 +34,14 @@ License
 
 void Foam::transform
 (
-    vectorField& result,
+    vectorField& rtf,
     const quaternion& q,
-    const vectorField& fld
+    const vectorField& tf
 )
 {
     const tensor rot = q.R();
-    if (result.cdata() == fld.cdata())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_S_F_inplace(result, =, transform, rot, fld)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_S_F(result, =, transform, rot, fld)
-    }
+    // std::transform
+    TFOR_ALL_F_OP_FUNC_S_F(vector, rtf, =, transform, tensor, rot, vector, tf)
 }
 
 
@@ -90,16 +82,8 @@ void Foam::transformPoints
     // Check if any translation
     if (mag(trans) > VSMALL)
     {
-        if (result.cdata() == fld.cdata())
-        {
-            // std::for_each
-            TSEQ_FORALL_F_OP_F_OP_S_inplace(result, =, fld, -, trans)
-        }
-        else
-        {
-            // std::transform
-            TSEQ_FORALL_F_OP_F_OP_S(result, =, fld, -, trans)
-        }
+        // std::transform
+        TFOR_ALL_F_OP_F_OP_S(vector, result, =, vector, fld, -, vector, trans);
     }
     else
     {

src/OpenFOAM/fields/Fields/transformField/transformFieldTemplates.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2024 OpenCFD Ltd.
+    Copyright (C) 2018 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -39,16 +39,11 @@ void Foam::transform
     const Field<Type>& fld
 )
 {
-    if (result.cdata() == fld.cdata())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_S_F_inplace(result, =, transform, rot, fld)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_S_F(result, =, transform, rot, fld)
-    }
+    // std::transform
+    TFOR_ALL_F_OP_FUNC_S_F
+    (
+        Type, result, =, transform, tensor, rot, Type, fld
+    );
 }
 
 
@@ -60,23 +55,16 @@ void Foam::transform
     const Field<Type>& fld
 )
 {
-    // Does not handle corner case where result and rot are identical...
-
     if (rot.size() == 1)
     {
         return transform(result, rot.front(), fld);
     }
 
-    if (result.cdata() == fld.cdata())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_F_F_inplace(result, =, transform, rot, fld)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_F_F(result, =, transform, rot, fld)
-    }
+    // std::transform
+    TFOR_ALL_F_OP_FUNC_F_F
+    (
+        Type, result, =, transform, tensor, rot, Type, fld
+    );
 }
 
 
@@ -177,16 +165,11 @@ void Foam::invTransform
     const Field<Type>& fld
 )
 {
-    if (result.cdata() == fld.cdata())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_S_F_inplace(result, =, invTransform, rot, fld)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_S_F(result, =, invTransform, rot, fld)
-    }
+    // std::transform
+    TFOR_ALL_F_OP_FUNC_S_F
+    (
+        Type, result, =, invTransform, tensor, rot, Type, fld
+    );
 }
 
 
@@ -203,16 +186,11 @@ void Foam::invTransform
         return invTransform(result, rot.front(), fld);
     }
 
-    if (result.cdata() == fld.cdata())
-    {
-        // std::for_each
-        TSEQ_FORALL_F_OP_FUNC_F_F_inplace(result, =, invTransform, rot, fld)
-    }
-    else
-    {
-        // std::transform
-        TSEQ_FORALL_F_OP_FUNC_F_F(result, =, invTransform, rot, fld)
-    }
+    // std::transform
+    TFOR_ALL_F_OP_FUNC_F_F
+    (
+        Type, result, =, invTransform, tensor, rot, Type, fld
+    );
 }
 
 

src/OpenFOAM/fields/Fields/transformList/transformList.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2018-2024 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -37,12 +37,12 @@ Foam::List<T> Foam::transform
     const UList<T>& field
 )
 {
-    const label loop_len = field.size();
+    const label loopLen = field.size();
 
-    List<T> result(loop_len);
+    List<T> result(loopLen);
 
     /* pragmas... */
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         result[i] = transform(rotTensor, field[i]);
     }
@@ -54,10 +54,10 @@ Foam::List<T> Foam::transform
 template<class T>
 void Foam::transformList(const tensor& rotTensor, UList<T>& field)
 {
-    const label loop_len = field.size();
+    const label loopLen = field.size();
 
     /* pragmas... */
-    for (label i = 0; i < loop_len; ++i)
+    for (label i = 0; i < loopLen; ++i)
     {
         field[i] = transform(rotTensor, field[i]);
     }
@@ -73,10 +73,10 @@ void Foam::transformList(const tensorField& rotTensor, UList<T>& field)
     }
     else if (rotTensor.size() == field.size())
     {
-        const label loop_len = field.size();
+        const label loopLen = field.size();
 
         /* pragmas... */
-        for (label i = 0; i < loop_len; ++i)
+        for (label i = 0; i < loopLen; ++i)
         {
             field[i] = transform(rotTensor[i], field[i]);
         }
@@ -96,7 +96,7 @@ void Foam::transformList(const tensor& rotTensor, Map<T>& field)
 {
     forAllIters(field, iter)
     {
-        auto& value = iter.val();
+        T& value = iter.val();
         value = transform(rotTensor, value);
     }
 }
@@ -124,7 +124,7 @@ void Foam::transformList(const tensor& rotTensor, EdgeMap<T>& field)
 {
     forAllIters(field, iter)
     {
-        auto& value = iter.val();
+        T& value = iter.val();
         value = transform(rotTensor, value);
     }
 }

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

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2024 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -87,15 +87,6 @@ template
 >
 struct reuseTmpGeometricField
 {
-    //- Dissimilar types: non-reusable
-    static bool reusable
-    (
-        const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1
-    )
-    {
-        return false;
-    }
-
     //- Pass-through to New GeometricField
     static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
     (
@@ -135,15 +126,6 @@ struct reuseTmpGeometricField
 template<class TypeR, template<class> class PatchField, class GeoMesh>
 struct reuseTmpGeometricField<TypeR, TypeR, PatchField, GeoMesh>
 {
-    //- Identical types: possibly reusable
-    static bool reusable
-    (
-        const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf1
-    )
-    {
-        return Detail::reusable(tf1);
-    }
-
     //- Allow optional copy assignment of the initial content
     //- for identical input and output types
     static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
@@ -174,7 +156,7 @@ struct reuseTmpGeometricField<TypeR, TypeR, PatchField, GeoMesh>
 
         if (initCopy)
         {
-            tresult.ref() == f1;
+            tresult.ref() == tf1();
         }
 
         return tresult;
@@ -205,9 +187,6 @@ tmp
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-// Two-parameter versions
-
 template
 <
     class TypeR,
@@ -219,16 +198,6 @@ template
 >
 struct reuseTmpTmpGeometricField
 {
-    //- Dissimilar types: non-reusable
-    static bool reusable
-    (
-        const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,
-        const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2
-    )
-    {
-        return false;
-    }
-
     static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
     (
         const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,
@@ -262,17 +231,6 @@ struct reuseTmpTmpGeometricField
     TypeR, Type1, Type12, TypeR, PatchField, GeoMesh
 >
 {
-    //- Second input has return type: possibly reusable
-    static bool reusable
-    (
-        const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,
-        const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf2
-    )
-    {
-        return Detail::reusable(tf2);
-    }
-
-    //- Second input has return type
     static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
     (
         const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,
@@ -314,17 +272,6 @@ struct reuseTmpTmpGeometricField
     TypeR, TypeR, TypeR, Type2, PatchField, GeoMesh
 >
 {
-    //- First input has return type: possibly reusable
-    static bool reusable
-    (
-        const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf1,
-        const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2
-    )
-    {
-        return Detail::reusable(tf2);
-    }
-
-    //- First input has return type
     static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
     (
         const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf1,
@@ -360,16 +307,6 @@ struct reuseTmpTmpGeometricField
     TypeR, TypeR, TypeR, TypeR, PatchField, GeoMesh
 >
 {
-    //- Both inputs have return type: possibly reusable
-    static bool reusable
-    (
-        const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf1,
-        const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf2
-    )
-    {
-        return (Detail::reusable(tf1) || Detail::reusable(tf2));
-    }
-
     static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
     (
         const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf1,

src/OpenFOAM/interpolations/interpolateSplineXY/interpolateSplineXY.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2024 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -60,11 +61,11 @@ Type Foam::interpolateSplineXY
     label n = xOld.size();
 
     // early exit if out of bounds or only one value
-    if (n == 1 || x < xOld[0])
+    if (n == 1 || x <= xOld[0])
     {
         return yOld[0];
     }
-    if (x > xOld[n - 1])
+    if (x >= xOld[n - 1])
     {
         return yOld[n - 1];
     }

src/dynamicMesh/polyTopoChange/polyTopoChange/hexRef8/hexRef8.C

@@ -2443,26 +2443,45 @@ Foam::labelList Foam::hexRef8::consistentSlowRefinement
     // Seed all boundary faces with owner value. This is to make sure that
     // they are visited (probably only important for coupled faces since
     // these need to be visited from both sides)
+    List<refinementData> nbrCellInfo;
+    syncTools::swapBoundaryCellList(mesh_, allCellInfo, nbrCellInfo);
+
     for (label facei = mesh_.nInternalFaces(); facei < mesh_.nFaces(); facei++)
     {
         // Check if face already handled in loop above
         if (!allFaceInfo[facei].valid(dummyTrackData))
         {
-            label own = faceOwner[facei];
+            const label own = faceOwner[facei];
+            const auto& nbrInfo = nbrCellInfo[facei-mesh_.nInternalFaces()];
 
-            // Seed face with transported data from owner.
-            refinementData faceData;
-            faceData.updateFace
-            (
-                mesh_,
-                facei,
-                own,
-                allCellInfo[own],
-                FaceCellWave<refinementData, int>::propagationTol(),
-                dummyTrackData
-            );
-            seedFaces.append(facei);
-            seedFacesInfo.append(faceData);
+            if (allCellInfo[own].count() > nbrInfo.count())
+            {
+                allFaceInfo[facei].updateFace
+                (
+                    mesh_,
+                    facei,
+                    own,
+                    allCellInfo[own],
+                    FaceCellWave<refinementData, int>::propagationTol(),
+                    dummyTrackData
+                );
+                seedFaces.append(facei);
+                seedFacesInfo.append(allFaceInfo[facei]);
+            }
+            else if (allCellInfo[own].count() < nbrInfo.count())
+            {
+                allFaceInfo[facei].updateFace
+                (
+                    mesh_,
+                    facei,
+                    -1,         // Lucky! neighbCelli not used!
+                    nbrInfo,
+                    FaceCellWave<refinementData, int>::propagationTol(),
+                    dummyTrackData
+                );
+                seedFaces.append(facei);
+                seedFacesInfo.append(allFaceInfo[facei]);
+            }
         }
     }
 

src/dynamicMesh/polyTopoChange/polyTopoChange/refinementData.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
-    Copyright (C) 2019-2022 OpenCFD Ltd.
+    Copyright (C) 2019-2022,2024 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -28,6 +28,13 @@ License
 
 #include "refinementData.H"
 
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::refinementData Foam::transform(const tensor&, const refinementData val)
+{
+    return val;
+}
+
 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 
 Foam::Ostream& Foam::operator<<

src/dynamicMesh/polyTopoChange/polyTopoChange/refinementData.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2020 OpenCFD Ltd.
+    Copyright (C) 2019-2020,2024 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -216,6 +216,9 @@ public:
 
 // * * * * * * * * * * * * * * * * * Traits  * * * * * * * * * * * * * * * * //
 
+//- No-op rotational transform for base types
+refinementData transform(const tensor&, const refinementData val);
+
 //- Contiguous data for refinementData
 template<> struct is_contiguous<refinementData> : std::true_type {};
 

src/finiteVolume/fvMesh/wallDist/patchDistMethods/advectionDiffusion/advectionDiffusionPatchDistMethod.C

@@ -79,7 +79,7 @@ Foam::patchDistMethods::advectionDiffusion::advectionDiffusion
     tolerance_(coeffs_.getOrDefault<scalar>("tolerance", 1e-3)),
     maxIter_(coeffs_.getOrDefault<int>("maxIter", 10)),
     predicted_(false),
-    checkAndWriteMesh_(coeffs_.getOrDefault("checkAndWriteMesh", true))
+    checkAndWriteMesh_(coeffs_.getOrDefault("checkAndWriteMesh", false))
 {}
 
 

src/functionObjects/field/Curle/Curle.C

@@ -67,7 +67,8 @@ Foam::functionObjects::Curle::Curle
     c0_(0),
     rawFilePtrs_(),
     inputSurface_(),
-    surfaceWriterPtr_(nullptr)
+    surfaceWriterPtr_(nullptr),
+    warnOnNoPatch_(true)
 {
     read(dict);
 }
@@ -85,8 +86,10 @@ bool Foam::functionObjects::Curle::read(const dictionary& dict)
     }
 
     dict.readIfPresent("p", pName_);
+    dict.readIfPresent("warnOnNoPatch", warnOnNoPatch_);
 
-    patchIDs_ = pbm.patchSet(dict.get<wordRes>("patches")).sortedToc();
+    patchIDs_ =
+        pbm.patchSet(dict.get<wordRes>("patches"), warnOnNoPatch_).sortedToc();
 
     if (patchIDs_.empty())
     {

src/functionObjects/field/Curle/Curle.H

@@ -181,6 +181,9 @@ class Curle
         //- Ouput surface when sampling a surface
         autoPtr<surfaceWriter> surfaceWriterPtr_;
 
+        //- Flag to suppress warnings for missing patches
+        bool warnOnNoPatch_;
+
 
 public:
 

src/functionObjects/field/binField/binModels/binModel/binModel.C

@@ -122,6 +122,7 @@ Foam::binModel::binModel
     mesh_(mesh),
     decomposePatchValues_(false),
     cumulative_(false),
+    warnOnNoPatch_(true),
     coordSysPtr_(nullptr),
     nBin_(1)
 {}
@@ -138,8 +139,11 @@ bool Foam::binModel::read(const dictionary& dict)
         return false;
     }
 
+    dict.readIfPresent("warnOnNoPatch", warnOnNoPatch_);
+
     // Can also use pbm.indices(), but no warnings...
-    patchIDs_ = pbm.patchSet(dict.get<wordRes>("patches")).sortedToc();
+    patchIDs_ =
+        pbm.patchSet(dict.get<wordRes>("patches"), warnOnNoPatch_).sortedToc();
     fieldNames_ = dict.get<wordHashSet>("fields").sortedToc();
 
     wordRes zoneNames;

src/functionObjects/field/binField/binModels/binModel/binModel.H

@@ -77,6 +77,9 @@ protected:
         //- increasing distance in binning direction
         bool cumulative_;
 
+        //- Flag to suppress warnings for missing patches
+        bool warnOnNoPatch_;
+
         //- Local coordinate system of bins
         autoPtr<coordinateSystem> coordSysPtr_;
 

src/functionObjects/field/columnAverage/columnAverage.C

@@ -128,7 +128,8 @@ Foam::functionObjects::columnAverage::columnAverage
 :
     fvMeshFunctionObject(name, runTime, dict),
     patchIDs_(),
-    fieldSet_(mesh_)
+    fieldSet_(mesh_),
+    warnOnNoPatch_(true)
 {
     read(dict);
 }
@@ -140,10 +141,13 @@ bool Foam::functionObjects::columnAverage::read(const dictionary& dict)
 {
     fvMeshFunctionObject::read(dict);
 
+    dict.readIfPresent("warnOnNoPatch", warnOnNoPatch_);
+
     patchIDs_ =
         mesh_.boundaryMesh().patchSet
         (
-            dict.get<wordRes>("patches")
+            dict.get<wordRes>("patches"),
+            warnOnNoPatch_
         ).sortedToc();
 
     fieldSet_.read(dict);

src/functionObjects/field/columnAverage/columnAverage.H

@@ -132,6 +132,9 @@ class columnAverage
         mutable autoPtr<globalIndex> globalPoints_;
         mutable autoPtr<meshStructure> meshStructurePtr_;
 
+        //- Flag to suppress warnings for missing patches
+        bool warnOnNoPatch_;
+
 
     // Private Member Functions
 

src/functionObjects/field/heatTransferCoeff/heatTransferCoeffModels/heatTransferCoeffModel/heatTransferCoeffModel.C

@@ -51,7 +51,8 @@ Foam::heatTransferCoeffModel::heatTransferCoeffModel
 :
     mesh_(mesh),
     TName_(TName),
-    qrName_("qr")
+    qrName_("qr"),
+    warnOnNoPatch_(true)
 {}
 
 
@@ -150,8 +151,10 @@ bool Foam::heatTransferCoeffModel::read(const dictionary& dict)
     const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
 
     dict.readIfPresent("qr", qrName_);
+    dict.readIfPresent("warnOnNoPatch", warnOnNoPatch_);
 
-    patchIDs_ = pbm.patchSet(dict.get<wordRes>("patches")).sortedToc();
+    patchIDs_ =
+        pbm.patchSet(dict.get<wordRes>("patches"), warnOnNoPatch_).sortedToc();
 
     return true;
 }

src/functionObjects/field/heatTransferCoeff/heatTransferCoeffModels/heatTransferCoeffModel/heatTransferCoeffModel.H

@@ -76,6 +76,9 @@ protected:
         //- Name of radiative heat flux field
         word qrName_;
 
+        //- Flag to suppress warnings for missing patches
+        bool warnOnNoPatch_;
+
 
     // Protected Member Functions
 

src/functionObjects/field/nearWallFields/nearWallFields.C

@@ -245,7 +245,8 @@ Foam::functionObjects::nearWallFields::nearWallFields
 )
 :
     fvMeshFunctionObject(name, runTime, dict),
-    fieldSet_()
+    fieldSet_(),
+    warnOnNoPatch_(true)
 {
     read(dict);
 }
@@ -261,9 +262,11 @@ bool Foam::functionObjects::nearWallFields::read(const dictionary& dict)
 
     dict.readEntry("fields", fieldSet_);
     dict.readEntry("distance", distance_);
+    dict.readIfPresent("warnOnNoPatch", warnOnNoPatch_);
 
     // Can also use pbm.indices(), but no warnings...
-    patchIDs_ = pbm.patchSet(dict.get<wordRes>("patches")).sortedToc();
+    patchIDs_ =
+        pbm.patchSet(dict.get<wordRes>("patches"), warnOnNoPatch_).sortedToc();
 
 
     // Clear out any previously loaded fields

src/functionObjects/field/nearWallFields/nearWallFields.H

@@ -134,6 +134,9 @@ protected:
             //- From resulting back to original field
             HashTable<word> reverseFieldMap_;
 
+            //- Flag to suppress warnings for missing patches
+            bool warnOnNoPatch_;
+
 
         // Calculated addressing
 

src/functionObjects/field/regionSizeDistribution/regionSizeDistribution.C

@@ -206,7 +206,10 @@ Foam::functionObjects::regionSizeDistribution::findPatchRegions
 
     labelHashSet patchRegions(2*regions.nRegions());
 
-    labelHashSet patchSet(mesh_.boundaryMesh().patchSet(patchNames_));
+    labelHashSet patchSet
+    (
+        mesh_.boundaryMesh().patchSet(patchNames_, warnOnNoPatch_)
+    );
 
     for (const label patchi : patchSet)
     {
@@ -369,7 +372,8 @@ Foam::functionObjects::regionSizeDistribution::regionSizeDistribution
     writeFile(obr_, name),
     alphaName_(dict.get<word>("field")),
     patchNames_(dict.get<wordRes>("patches")),
-    isoPlanes_(dict.getOrDefault("isoPlanes", false))
+    isoPlanes_(dict.getOrDefault("isoPlanes", false)),
+    warnOnNoPatch_(true)
 {
     read(dict);
 }
@@ -416,6 +420,8 @@ bool Foam::functionObjects::regionSizeDistribution::read(const dictionary& dict)
          direction_.normalise();
     }
 
+    dict.readIfPresent("warnOnNoPatch", warnOnNoPatch_);
+
     return true;
 }
 

src/functionObjects/field/regionSizeDistribution/regionSizeDistribution.H

@@ -249,6 +249,9 @@ class regionSizeDistribution
             //- Switch to enable iso-planes sampling
             bool isoPlanes_;
 
+        //- Flag to suppress warnings for missing patches
+        bool warnOnNoPatch_;
+
 
     // Private Member Functions
 

src/functionObjects/field/wallHeatFlux/wallHeatFlux.C

@@ -106,7 +106,8 @@ Foam::functionObjects::wallHeatFlux::wallHeatFlux
 :
     fvMeshFunctionObject(name, runTime, dict),
     writeFile(obr_, name, typeName, dict),
-    qrName_("qr")
+    qrName_("qr"),
+    warnOnNoPatch_(true)
 {
     read(dict);
 
@@ -144,12 +145,13 @@ bool Foam::functionObjects::wallHeatFlux::read(const dictionary& dict)
     writeFile::read(dict);
 
     dict.readIfPresent("qr", qrName_);
+    dict.readIfPresent("warnOnNoPatch", warnOnNoPatch_);
 
     wordRes patchNames;
     labelHashSet patchSet;
     if (dict.readIfPresent("patches", patchNames) && !patchNames.empty())
     {
-        patchSet = pbm.patchSet(patchNames);
+        patchSet = pbm.patchSet(patchNames, warnOnNoPatch_);
     }
 
     labelHashSet allWalls(pbm.findPatchIDs<wallPolyPatch>());

src/functionObjects/field/wallHeatFlux/wallHeatFlux.H

@@ -123,6 +123,9 @@ protected:
         //- Name of radiative heat flux name
         word qrName_;
 
+        //- Flag to suppress warnings for missing patches
+        bool warnOnNoPatch_;
+
 
     // Protected Member Functions
 

src/functionObjects/field/wallShearStress/wallShearStress.C

@@ -90,7 +90,8 @@ Foam::functionObjects::wallShearStress::wallShearStress
 :
     fvMeshFunctionObject(name, runTime, dict),
     writeFile(mesh_, name, typeName, dict),
-    writeFields_(true)  // May change in the future
+    writeFields_(true),  // May change in the future
+    warnOnNoPatch_(true)
 {
     read(dict);
 
@@ -127,6 +128,7 @@ bool Foam::functionObjects::wallShearStress::read(const dictionary& dict)
 
     writeFields_ = true;   // May change in the future
     dict.readIfPresent("writeFields", writeFields_);
+    dict.readIfPresent("warnOnNoPatch", warnOnNoPatch_);
 
     const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
 
@@ -134,7 +136,7 @@ bool Foam::functionObjects::wallShearStress::read(const dictionary& dict)
     labelHashSet patchSet;
     if (dict.readIfPresent("patches", patchNames) && !patchNames.empty())
     {
-        patchSet = pbm.patchSet(patchNames);
+        patchSet = pbm.patchSet(patchNames, warnOnNoPatch_);
     }
 
     labelHashSet allWalls(pbm.findPatchIDs<wallPolyPatch>());

src/functionObjects/field/wallShearStress/wallShearStress.H

@@ -133,6 +133,9 @@ class wallShearStress
         //- Write the shear stress field ?
         bool writeFields_;
 
+        //- Flag to suppress warnings for missing patches
+        bool warnOnNoPatch_;
+
 
 protected:
 

src/functionObjects/forces/forces/forces.C

@@ -550,7 +550,8 @@ Foam::functionObjects::forces::forces
     directForceDensity_(false),
     porosity_(false),
     writeFields_(false),
-    initialised_(false)
+    initialised_(false),
+    warnOnNoPatch_(true)
 {
     if (readFields)
     {
@@ -589,7 +590,8 @@ Foam::functionObjects::forces::forces
     directForceDensity_(false),
     porosity_(false),
     writeFields_(false),
-    initialised_(false)
+    initialised_(false),
+    warnOnNoPatch_(true)
 {
     if (readFields)
     {
@@ -613,10 +615,13 @@ bool Foam::functionObjects::forces::read(const dictionary& dict)
 
     initialised_ = false;
 
+    dict.readIfPresent("warnOnNoPatch", warnOnNoPatch_);
+
     Info<< type() << ' ' << name() << ':' << endl;
 
     // Can also use pbm.indices(), but no warnings...
-    patchIDs_ = pbm.patchSet(dict.get<wordRes>("patches")).sortedToc();
+    patchIDs_ =
+        pbm.patchSet(dict.get<wordRes>("patches"), warnOnNoPatch_).sortedToc();
 
     dict.readIfPresent("directForceDensity", directForceDensity_);
     if (directForceDensity_)

src/functionObjects/forces/forces/forces.H

@@ -264,6 +264,9 @@ protected:
             //- Flag of initialisation (internal)
             bool initialised_;
 
+            //- Flag to suppress warnings for missing patches
+            bool warnOnNoPatch_;
+
 
     // Protected Member Functions
 

src/functionObjects/solvers/electricPotential/electricPotential.C

@@ -208,6 +208,7 @@ Foam::functionObjects::electricPotential::electricPotential
         )
     ),
     fvOptions_(mesh_),
+    tol_(1),
     nCorr_(1),
     writeDerivedFields_(false),
     electricField_(false)
@@ -258,6 +259,7 @@ bool Foam::functionObjects::electricPotential::read(const dictionary& dict)
     dict.readIfPresent("sigma", sigma_);
     dict.readIfPresent("epsilonr", epsilonr_);
     dict.readIfPresent("nCorr", nCorr_);
+    dict.readIfPresent("tolerance", tol_);
     dict.readIfPresent("writeDerivedFields", writeDerivedFields_);
     dict.readIfPresent("electricField", electricField_);
 
@@ -346,6 +348,10 @@ bool Foam::functionObjects::electricPotential::execute()
 {
     Log << type() << " execute: " << name() << endl;
 
+    // Convergence monitor parameters
+    bool converged = false;
+    label iter = 0;
+
     tmp<volScalarField> tsigma = this->sigma();
     const auto& sigma = tsigma();
 
@@ -362,7 +368,9 @@ bool Foam::functionObjects::electricPotential::execute()
 
         fvOptions_.constrain(eVEqn);
 
-        eVEqn.solve();
+        ++iter;
+        converged = (eVEqn.solve().initialResidual() < tol_);
+        if (converged) break;
     }
 
     if (electricField_)
@@ -371,6 +379,14 @@ bool Foam::functionObjects::electricPotential::execute()
         E == -fvc::grad(eV);
     }
 
+    if (converged)
+    {
+        Log << type() << ": " << name() << ": "
+            << eV.name() << " is converged." << nl
+            << tab << "initial-residual tolerance: " << tol_ << nl
+            << tab << "outer iteration: " << iter << nl;
+    }
+
     Log << endl;
 
     return true;

src/functionObjects/solvers/electricPotential/electricPotential.H

@@ -124,6 +124,7 @@ Usage
         electricField         <bool>;
         E                     <word>;
         fvOptions             <dict>;
+        tolerance             <scalar>;
 
         // Inherited entries
         ...
@@ -143,6 +144,7 @@ Usage
       electricField | Flag to calculate electric field  | bool | no | false
       E    | Name of electric field           | word | no | electricPotential:E
       fvOptions | List of finite-volume options       | dict | no   | -
+      tolerance | Outer-loop initial-residual tolerance | scalar | no | 1
     \endtable
 
     The inherited entries are elaborated in:
@@ -218,6 +220,9 @@ class electricPotential
         //- Run-time selectable finite volume options
         fv::optionList fvOptions_;
 
+        //- Outer-loop initial-residual tolerance
+        scalar tol_;
+
         //- Number of corrector iterations
         int nCorr_;
 

src/functionObjects/solvers/energyTransport/energyTransport.C

@@ -26,11 +26,6 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "energyTransport.H"
-#include "surfaceFields.H"
-#include "fvmDdt.H"
-#include "fvmDiv.H"
-#include "fvmLaplacian.H"
-#include "fvmSup.H"
 #include "turbulentTransportModel.H"
 #include "turbulentFluidThermoModel.H"
 #include "addToRunTimeSelectionTable.H"
@@ -188,23 +183,6 @@ Foam::functionObjects::energyTransport::energyTransport
 )
 :
     fvMeshFunctionObject(name, runTime, dict),
-    fieldName_(dict.getOrDefault<word>("field", "T")),
-    phiName_(dict.getOrDefault<word>("phi", "phi")),
-    rhoName_(dict.getOrDefault<word>("rho", "rho")),
-    nCorr_(0),
-    schemesField_("unknown-schemesField"),
-    fvOptions_(mesh_),
-    multiphaseThermo_(dict.subOrEmptyDict("phaseThermos")),
-    Cp_("Cp", dimEnergy/dimMass/dimTemperature, 0, dict),
-    kappa_
-    (
-        "kappa",
-        dimEnergy/dimTime/dimLength/dimTemperature,
-        0,
-        dict
-    ),
-    rho_("rhoInf", dimDensity, 0, dict),
-    Prt_("Prt", dimless, 1, dict),
     rhoCp_
     (
         IOobject
@@ -218,7 +196,25 @@ Foam::functionObjects::energyTransport::energyTransport
         ),
         mesh_,
         dimensionedScalar(dimEnergy/dimTemperature/dimVolume, Zero)
-    )
+    ),
+    fvOptions_(mesh_),
+    multiphaseThermo_(dict.subOrEmptyDict("phaseThermos")),
+    Cp_("Cp", dimEnergy/dimMass/dimTemperature, 0, dict),
+    kappa_
+    (
+        "kappa",
+        dimEnergy/dimTime/dimLength/dimTemperature,
+        0,
+        dict
+    ),
+    rho_("rhoInf", dimDensity, 0, dict),
+    Prt_("Prt", dimless, 1, dict),
+    fieldName_(dict.getOrDefault<word>("field", "T")),
+    schemesField_("unknown-schemesField"),
+    phiName_(dict.getOrDefault<word>("phi", "phi")),
+    rhoName_(dict.getOrDefault<word>("rho", "rho")),
+    tol_(1),
+    nCorr_(0)
 {
     read(dict);
 
@@ -305,17 +301,14 @@ Foam::functionObjects::energyTransport::energyTransport
 }
 
 
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::functionObjects::energyTransport::~energyTransport()
-{}
-
-
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 bool Foam::functionObjects::energyTransport::read(const dictionary& dict)
 {
-    fvMeshFunctionObject::read(dict);
+    if (!fvMeshFunctionObject::read(dict))
+    {
+        return false;
+    }
 
     dict.readIfPresent("phi", phiName_);
     dict.readIfPresent("rho", rhoName_);
@@ -323,6 +316,7 @@ bool Foam::functionObjects::energyTransport::read(const dictionary& dict)
     schemesField_ = dict.getOrDefault("schemesField", fieldName_);
 
     dict.readIfPresent("nCorr", nCorr_);
+    dict.readIfPresent("tolerance", tol_);
 
     if (dict.found("fvOptions"))
     {
@@ -355,12 +349,16 @@ bool Foam::functionObjects::energyTransport::execute()
     scalar relaxCoeff = 0;
     mesh_.relaxEquation(schemesField_, relaxCoeff);
 
+    // Convergence monitor parameters
+    bool converged = false;
+    int iter = 0;
+
     if (phi.dimensions() == dimMass/dimTime)
     {
         rhoCp_ = rho()*Cp();
         const surfaceScalarField rhoCpPhi(fvc::interpolate(Cp())*phi);
 
-        for (label i = 0; i <= nCorr_; i++)
+        for (int i = 0; i <= nCorr_; ++i)
         {
             fvScalarMatrix sEqn
             (
@@ -376,7 +374,9 @@ bool Foam::functionObjects::energyTransport::execute()
 
             fvOptions_.constrain(sEqn);
 
-            sEqn.solve(schemesField_);
+            ++iter;
+            converged = (sEqn.solve(schemesField_).initialResidual() < tol_);
+            if (converged) break;
         }
     }
     else if (phi.dimensions() == dimVolume/dimTime)
@@ -393,7 +393,7 @@ bool Foam::functionObjects::energyTransport::execute()
             rhoCp
         );
 
-        for (label i = 0; i <= nCorr_; i++)
+        for (int i = 0; i <= nCorr_; ++i)
         {
             fvScalarMatrix sEqn
             (
@@ -408,7 +408,9 @@ bool Foam::functionObjects::energyTransport::execute()
 
             fvOptions_.constrain(sEqn);
 
-            sEqn.solve(schemesField_);
+            ++iter;
+            converged = (sEqn.solve(schemesField_).initialResidual() < tol_);
+            if (converged) break;
         }
     }
     else
@@ -419,6 +421,14 @@ bool Foam::functionObjects::energyTransport::execute()
             << dimVolume/dimTime << exit(FatalError);
     }
 
+    if (converged)
+    {
+        Log << type() << ": " << name() << ": "
+            << s.name() << " is converged." << nl
+            << tab << "initial-residual tolerance: " << tol_ << nl
+            << tab << "outer iteration: " << iter << nl;
+    }
+
     Log << endl;
 
     return true;

src/functionObjects/solvers/energyTransport/energyTransport.H

@@ -30,151 +30,180 @@ Group
     grpSolversFunctionObjects
 
 Description
-    Evolves a simplified energy transport equation for incompressible flows.
-    It takes into account the inertia, conduction and convection terms plus
-    a source.
+    Computes the simplified energy transport equation in single-phase or
+    two-phase flow, considering incompressible cases:
 
-    - The field name must be temperature and its BC's specified in the time
-      directory.
-    - The turbulence model should be incompressible
-    - In order to use in a incompressible multi phase a list of thermal
-      properties are needed. See below
+    \f[
+        \frac{\partial \rho \, C_p \, T}{\partial t}
+      + \nabla \cdot \left(\rho \, C_p \, \phi \, T \right)
+      - \nabla \cdot \left(\rho \, C_p \, \phi \right) \, T
+      - \nabla \cdot \left(\kappa_{eff} \, \nabla T \right)
+      = S_T
+    \f]
 
+    where:
+    \vartable
+      T       | Scalar field
+      \rho    | (Generic) Fluid density which is unity when not specified
+      C_p     | Specific heat capacity at constant pressure
+      \phi    | (Generic) Flux field
+      \kappa_{eff}  | Effective thermal conductivity
+      S_T     | Scalar field source term
+    \endvartable
 
 Usage
-    Example of function object specification to solve a energy transport
-    equation for a single phase flow plus a source term
+    Minimal example in \c system/controlDict.functions:
     \verbatim
-    functions
+    energyTransport1
     {
-        energy
-        {
-            type            energyTransport;
-            libs            (energyTransportFunctionObjects);
+        // Mandatory entries
+        type            energyTransport;
+        libs            (solverFunctionObjects);
 
-            enabled         true;
-            writeControl    writeTime;
-            writeInterval   1;
+        // Optional entries
+        field           <word>;
+        phi             <word>;
+        rho             <word>;
+        Cp              <scalar>;
+        kappa           <scalar>;
+        rhoInf          <scalar>;
+        Prt             <scalar>;
+        schemesField    <word>;
+        tolerance       <scalar>;
+        nCorr           <int>;
+        fvOptions       <dict>;
+        phaseThermos    <dict>;
 
-            field           T;
-
-            // volumetric Flux
-            phi             phi;
-
-            // Thermal properties
-            Cp              Cp    [J/kg/K]  1e3;
-            kappa           kappa [W/m/K]   0.0257;
-            rhoInf          rho   [kg/m^3]  1.2;
-
-            write           true;
-
-            fvOptions
-            {
-                viscousDissipation
-                {
-                    type            viscousDissipation;
-                    enabled         true;
-
-                    viscousDissipationCoeffs
-                    {
-                        fields          (T);
-                        rhoInf          $....rhoInf;
-                    }
-                }
-            }
-        }
+        // Inherited entries
+        ...
     }
     \endverbatim
 
-    Example of function object specification to solve a energy transport
-    equation for a multiphase phase flow plus a source term
-
-    equation:
-    \verbatim
-    functions
-    {
-        energy
-        {
-            type            energyTransport;
-            libs            (energyTransportFunctionObjects);
-
-            enabled         true;
-            writeControl    writeTime;
-            writeInterval   1;
-
-            field           T;
-
-            // rho field name
-            rho             rho;
-            // mass flux for multiphase
-            phi             rhoPhi;
-
-            write           true;
-
-            // Thermal properties of the phases
-            phaseThermos
-            {
-                alpha.air
-                {
-                    Cp          1e3;
-                    kappa       0.0243;
-                }
-                alpha.mercury
-                {
-                    Cp          140;
-                    kappa       8.2;
-                }
-                alpha.oil
-                {
-                    Cp          2e3;
-                    kappa       0.2;
-                }
-                alpha.water
-                {
-                    Cp          4e3;
-                    kappa       0.6;
-                }
-            }
-
-
-            fvOptions
-            {
-                viscousDissipation
-                {
-                    type            viscousDissipation;
-                    enabled         true;
-
-                    viscousDissipationCoeffs
-                    {
-                        fields          (T);
-                        rho             rho; //rho Field
-                    }
-                }
-            }
-        }
-    }
-    \endverbatim
-
-    Where the entries comprise:
+    where:
     \table
-        Property     | Description             | Required    | Default value
-        type         | Type name: energyTransport | yes      |
-        field        | Name of the scalar field | no         | T
-        phi          | Name of flux field      | no          | phi
-        rho          | Name of density field   | no          | rho
-        nCorr        | Number of correctors    | no          | 0
-        schemesField | Name of field to specify schemes | no | field name
-        fvOptions    | List of scalar sources  | no          |
-        Cp           | Heat capacity for single phase | no   | 0
-        rhoInf       | Density for single phase | no         | 0
-        kappa        | Thermal conductivity for single phase | no   | 0
-        Prt          | Turbulent Prandlt number | no         | 1.0
-        phaseThermos | Dictionary for multi-phase thermo |no | null
-        fvOptions    | Opotional extra sources | no          | null
+      Property  | Description                         | Type | Reqd | Deflt
+      type      | Type name: energyTransport          | word | yes  | -
+      libs      | Library name: solverFunctionObjects | word | yes  | -
+      field     | Name of the passive-scalar field    | word | no   | s
+      phi       | Name of flux field                  | word | no   | phi
+      rho       | Name of density field               | word | no   | rho
+      Cp        | Specific heat capacity at constant pressure | scalar | no | 0
+      kappa     | Thermal conductivity                | scalar | no | 0
+      rhoInf    | Fluid density                       | scalar | no | 0
+      Prt       | Turbulent Prandtl number            | scalar | no | 1
+      schemesField | Name of field to specify schemes | word   | no | field
+      tolerance | Outer-loop initial-residual tolerance | scalar | no | 1
+      nCorr     | Number of outer-loop correctors     | int    | no | 0
+      fvOptions | List of finite-volume options       | dict   | no | -
+      phaseThermos | Dictionary for multi-phase thermo | dict  | no | null
     \endtable
 
-See also
-    Foam::functionObjects::fvMeshFunctionObject
+    The inherited entries are elaborated in:
+      - \link fvMeshFunctionObject.H \endlink
+      - \link fvOption.H \endlink
+
+    An example of function object specification to solve a energy transport
+    equation for a single phase flow plus a source term:
+    \verbatim
+    energyTransport1
+    {
+        // Mandatory entries
+        type            energyTransport;
+        libs            (solverFunctionObjects);
+
+        // Optional entries
+        field           T;
+        phi             phi;
+        Cp              Cp    [J/kg/K]  1e3;
+        kappa           kappa [W/m/K]   0.0257;
+        rhoInf          rho   [kg/m^3]  1.2;
+        fvOptions
+        {
+            viscousDissipation
+            {
+                type            viscousDissipation;
+                enabled         true;
+
+                viscousDissipationCoeffs
+                {
+                    fields          (T);
+                    rhoInf          $....rhoInf;
+                }
+            }
+        }
+
+        // Inherited entries
+        enabled         true;
+        writeControl    writeTime;
+        writeInterval   1;
+    }
+    \endverbatim
+
+    An example of function object specification to solve a energy transport
+    equation for a multiphase phase flow plus a source term:
+    \verbatim
+    energyTransport1
+    {
+        // Mandatory entries
+        type            energyTransport;
+        libs            (solverFunctionObjects);
+
+        // Optional entries
+        field           T;
+        rho             rho;
+        phi             rhoPhi;
+
+        // Thermal properties of the phases
+        phaseThermos
+        {
+            alpha.air
+            {
+                Cp          1e3;
+                kappa       0.0243;
+            }
+            alpha.mercury
+            {
+                Cp          140;
+                kappa       8.2;
+            }
+            alpha.oil
+            {
+                Cp          2e3;
+                kappa       0.2;
+            }
+            alpha.water
+            {
+                Cp          4e3;
+                kappa       0.6;
+            }
+        }
+
+        fvOptions
+        {
+            viscousDissipation
+            {
+                type            viscousDissipation;
+                enabled         true;
+
+                viscousDissipationCoeffs
+                {
+                    fields          (T);
+                    rho             rho;
+                }
+            }
+        }
+
+        // Inherited entries
+        enabled         true;
+        writeControl    writeTime;
+        writeInterval   1;
+    }
+    \endverbatim
+
+Note
+  - The field name must be temperature and its boundary conditions
+    specified in the time directory.
+  - The turbulence model should be incompressible.
 
 SourceFiles
     energyTransport.C
@@ -203,22 +232,10 @@ class energyTransport
 :
     public fvMeshFunctionObject
 {
-    // Private data
+    // Private Data
 
-        //- Name of the transport field.
-        word fieldName_;
-
-        //- Name of flux field
-        word phiName_;
-
-        //- Name of density field
-        word rhoName_;
-
-        //- Number of corrector iterations (optional)
-        label nCorr_;
-
-        //- Name of field whose schemes are used (optional)
-        word schemesField_;
+        //- Volumetric heat capacity field [J/m^3/K]
+        volScalarField rhoCp_;
 
         //- Run-time selectable finite volume options, e.g. sources, constraints
         fv::optionList fvOptions_;
@@ -229,7 +246,7 @@ class energyTransport
         //- List of phase names
         wordList phaseNames_;
 
-        //- List of phase heat capacities
+        //- List of phase specific heat capacities at constant pressure
         PtrList<dimensionedScalar> Cps_;
 
         //- List of phase thermal diffusivity for temperature [J/m/s/K]
@@ -238,7 +255,7 @@ class energyTransport
         //- Unallocated phase list
         UPtrList<volScalarField> phases_;
 
-        //- Heat capacity for single phase flows
+        //- Specific heat capacity at constant pressure for single phase flows
         dimensionedScalar Cp_;
 
         //- Thermal diffusivity for temperature for single phase flows
@@ -250,8 +267,23 @@ class energyTransport
         //- Turbulent Prandt number
         dimensionedScalar Prt_;
 
-        //- rhoCp
-        volScalarField rhoCp_;
+        //- Name of the transport field
+        word fieldName_;
+
+        //- Name of field whose schemes are used
+        word schemesField_;
+
+        //- Name of flux field
+        word phiName_;
+
+        //- Name of density field
+        word rhoName_;
+
+        //- Outer-loop initial-residual tolerance
+        scalar tol_;
+
+        //- Number of corrector iterations
+        int nCorr_;
 
 
     // Private Member Functions
@@ -262,21 +294,15 @@ class energyTransport
         //- Return the diffusivity field
         tmp<volScalarField> kappaEff() const;
 
-        //- Return rho field
+        //- Return the density field, rho
         tmp<volScalarField> rho() const;
 
-        //- Return Cp
+        //- Return the specific heat capacity at constant pressure field, Cp
         tmp<volScalarField> Cp() const;
 
-        //- Return kappa
+        //- Return the thermal diffusivity field
         tmp<volScalarField> kappa() const;
 
-        //- No copy construct
-        energyTransport(const energyTransport&) = delete;
-
-        //- No copy assignment
-        void operator=(const energyTransport&) = delete;
-
 
 public:
 
@@ -296,7 +322,7 @@ public:
 
 
     //- Destructor
-    virtual ~energyTransport();
+    virtual ~energyTransport() = default;
 
 
     // Member Functions

src/functionObjects/solvers/scalarTransport/scalarTransport.C

@@ -27,11 +27,6 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "scalarTransport.H"
-#include "surfaceFields.H"
-#include "fvmDdt.H"
-#include "fvmDiv.H"
-#include "fvmLaplacian.H"
-#include "fvmSup.H"
 #include "CMULES.H"
 #include "turbulentTransportModel.H"
 #include "turbulentFluidThermoModel.H"
@@ -172,7 +167,9 @@ Foam::functionObjects::scalarTransport::scalarTransport
 )
 :
     fvMeshFunctionObject(name, runTime, dict),
+    fvOptions_(mesh_),
     fieldName_(dict.getOrDefault<word>("field", "s")),
+    schemesField_("unknown-schemesField"),
     phiName_(dict.getOrDefault<word>("phi", "phi")),
     rhoName_(dict.getOrDefault<word>("rho", "rho")),
     nutName_(dict.getOrDefault<word>("nut", "none")),
@@ -182,11 +179,12 @@ Foam::functionObjects::scalarTransport::scalarTransport
         dict.getOrDefault<word>("phasePhiCompressed", "alphaPhiUn")
     ),
     D_(0),
-    constantD_(false),
+    alphaD_(1),
+    alphaDt_(1),
+    tol_(1),
     nCorr_(0),
     resetOnStartUp_(false),
-    schemesField_("unknown-schemesField"),
-    fvOptions_(mesh_),
+    constantD_(false),
     bounded01_(dict.getOrDefault("bounded01", true))
 {
     read(dict);
@@ -202,31 +200,30 @@ Foam::functionObjects::scalarTransport::scalarTransport
 }
 
 
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::functionObjects::scalarTransport::~scalarTransport()
-{}
-
-
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 bool Foam::functionObjects::scalarTransport::read(const dictionary& dict)
 {
-    fvMeshFunctionObject::read(dict);
+    if (!fvMeshFunctionObject::read(dict))
+    {
+        return false;
+    }
 
     dict.readIfPresent("phi", phiName_);
     dict.readIfPresent("rho", rhoName_);
     dict.readIfPresent("nut", nutName_);
     dict.readIfPresent("phase", phaseName_);
-    dict.readIfPresent("bounded01", bounded01_);
+    dict.readIfPresent("phasePhiCompressed", phasePhiCompressedName_);
 
     schemesField_ = dict.getOrDefault("schemesField", fieldName_);
-    constantD_ = dict.readIfPresent("D", D_);
-    alphaD_ = dict.getOrDefault<scalar>("alphaD", 1);
-    alphaDt_ = dict.getOrDefault<scalar>("alphaDt", 1);
 
+    dict.readIfPresent("alphaD", alphaD_);
+    dict.readIfPresent("alphaDt", alphaDt_);
+    dict.readIfPresent("tolerance", tol_);
     dict.readIfPresent("nCorr", nCorr_);
     dict.readIfPresent("resetOnStartUp", resetOnStartUp_);
+    constantD_ = dict.readIfPresent("D", D_);
+    dict.readIfPresent("bounded01", bounded01_);
 
     if (dict.found("fvOptions"))
     {
@@ -256,6 +253,10 @@ bool Foam::functionObjects::scalarTransport::execute()
     scalar relaxCoeff = 0;
     mesh_.relaxEquation(schemesField_, relaxCoeff);
 
+    // Convergence monitor parameters
+    bool converged = false;
+    int iter = 0;
+
     // Two phase scalar transport
     if (phaseName_ != "none")
     {
@@ -272,7 +273,7 @@ bool Foam::functionObjects::scalarTransport::execute()
 
         // Solve
         tmp<surfaceScalarField> tTPhiUD;
-        for (label i = 0; i <= nCorr_; i++)
+        for (int i = 0; i <= nCorr_; ++i)
         {
             fvScalarMatrix sEqn
             (
@@ -285,9 +286,13 @@ bool Foam::functionObjects::scalarTransport::execute()
 
             sEqn.relax(relaxCoeff);
             fvOptions_.constrain(sEqn);
-            sEqn.solve(schemesField_);
+
+            ++iter;
+            converged = (sEqn.solve(schemesField_).initialResidual() < tol_);
 
             tTPhiUD = sEqn.flux();
+
+            if (converged) break;
         }
 
         if (bounded01_)
@@ -307,9 +312,8 @@ bool Foam::functionObjects::scalarTransport::execute()
     {
         const volScalarField& rho = lookupObject<volScalarField>(rhoName_);
 
-        for (label i = 0; i <= nCorr_; i++)
+        for (int i = 0; i <= nCorr_; ++i)
         {
-
             fvScalarMatrix sEqn
             (
                 fvm::ddt(rho, s)
@@ -323,12 +327,14 @@ bool Foam::functionObjects::scalarTransport::execute()
 
             fvOptions_.constrain(sEqn);
 
-            sEqn.solve(schemesField_);
+            ++iter;
+            converged = (sEqn.solve(schemesField_).initialResidual() < tol_);
+            if (converged) break;
         }
     }
     else if (phi.dimensions() == dimVolume/dimTime)
     {
-        for (label i = 0; i <= nCorr_; i++)
+        for (int i = 0; i <= nCorr_; ++i)
         {
             fvScalarMatrix sEqn
             (
@@ -343,7 +349,9 @@ bool Foam::functionObjects::scalarTransport::execute()
 
             fvOptions_.constrain(sEqn);
 
-            sEqn.solve(schemesField_);
+            ++iter;
+            converged = (sEqn.solve(schemesField_).initialResidual() < tol_);
+            if (converged) break;
         }
     }
     else
@@ -354,6 +362,14 @@ bool Foam::functionObjects::scalarTransport::execute()
             << dimVolume/dimTime << exit(FatalError);
     }
 
+    if (converged)
+    {
+        Log << type() << ": " << name() << ": "
+            << s.name() << " is converged." << nl
+            << tab << "initial-residual tolerance: " << tol_ << nl
+            << tab << "outer iteration: " << iter << nl;
+    }
+
     Log << endl;
 
     return true;

src/functionObjects/solvers/scalarTransport/scalarTransport.H

@@ -31,110 +31,134 @@ Group
     grpSolversFunctionObjects
 
 Description
-    Evolves a passive scalar transport equation.
+    Computes the transport equation for a passive scalar in single-phase or
+    two-phase flow, considering both incompressible and compressible cases:
 
-    - To specify the field name set the \c field entry
-    - To employ the same numerical schemes as another field set
-      the \c schemesField entry,
-    - The diffusivity can be set manually using the 'D' entry, retrieved
-      from the turbulence model or specified nut
-    - Alternatively if a turbulence model is available a turbulent diffusivity
-      may be constructed from the laminar and turbulent viscosities using the
-      optional diffusivity coefficients \c alphaD and \c alphaDt (which default
-      to 1):
-      \verbatim
-          D = alphaD*nu + alphaDt*nut
-      \endverbatim
-    - To specify a transport quantity within a phase enter phase.
-    - bounded01 bounds the transported scalar within 0 and 1.
+    \f[
+        \frac{\partial \rho \, T}{\partial t}
+      + \nabla \cdot \left( \phi_\alpha \, T \right)
+      - \nabla \cdot (D_T \, \nabla T)
+      = \alpha \, S_T
+    \f]
+
+    where:
+    \vartable
+      T       | Passive scalar field
+      \rho    | (Generic) Fluid density which is unity when not specified
+      \phi_\alpha | (Generic) Flux field
+      \alpha  | Phase fraction which is unity for single-phase flows
+      D_T     | Diffusivity representing the diffusive transport of T
+      S_T     | Passive-scalar field source term
+    \endvartable
 
 Usage
-    Example of function object specification to solve a scalar transport
-    equation:
+    Minimal example in \c system/controlDict.functions:
     \verbatim
-    functions
+    scalarTransport1
     {
-        scalar1
-        {
-            type            scalarTransport;
-            libs            (solverFunctionObjects);
+        // Mandatory entries
+        type            scalarTransport;
+        libs            (solverFunctionObjects);
 
-            resetOnStartUp  no;
-            region          cabin;
-            field           H2O;
+        // Optional entries
+        field           <word>;
+        phi             <word>;
+        rho             <word>;
+        nut             <word>;
+        phase           <word>;
+        phasePhiCompressed  <word>;
+        schemesField    <word>;
+        bounded01       <bool>;
+        D               <scalar>;
+        alphaD          <scalar>;
+        alphaDt         <scalar>;
+        tolerance       <scalar>;
+        nCorr           <int>;
+        resetOnStartUp  <bool>;
+        fvOptions       <dict>;
 
-
-            fvOptions
-            {
-                ...
-            }
-        }
+        // Inherited entries
+        ...
     }
-    \endverbatim
 
-    Example of function object specification to solve a residence time
-    in a two phase flow:
-    equation:
-    \verbatim
-    functions
-    {
-        sTransport
-        {
-            type            scalarTransport;
-            libs            (solverFunctionObjects);
-
-            enabled         true;
-            writeControl    writeTime;
-            writeInterval   1;
-
-            field           s;
-            bounded01       false;
-            phase           alpha.water;
-
-            write           true;
-
-            fvOptions
-            {
-                unitySource
-                {
-                    type            scalarSemiImplicitSource;
-                    enabled         true;
-
-                    selectionMode   all;
-                    volumeMode      specific;
-
-                    sources
-                    {
-                        s           (1 0);
-                    }
-                }
-            }
-
-            resetOnStartUp  false;
-        }
-    }
-    \endverbatim
-
-    Where the entries comprise:
+    where:
     \table
-        Property     | Description             | Required    | Default value
-        type         | Type name: scalarTransport | yes      |
-        field        | Name of the scalar field | no         | s
-        phi          | Name of flux field      | no          | phi
-        rho          | Name of density field   | no          | rho
-        phase        | Name of the phase       | no          | none
-        nut          | Name of the turbulence viscosity | no | none
-        D            | Diffusion coefficient   | no          | auto generated
-        nCorr        | Number of correctors    | no          | 0
-        resetOnStartUp | Reset scalar to zero on start-up | no | no
-        schemesField | Name of field to specify schemes | no | field name
-        fvOptions    | List of scalar sources  | no          |
-        bounded01    | Bounds scalar between 0-1 for multiphase | no | true
-        phasePhiCompressed | Compressed flux for VOF | no | alphaPhiUn
+      Property  | Description                         | Type | Reqd | Deflt
+      type      | Type name: scalarTransport          | word | yes  | -
+      libs      | Library name: solverFunctionObjects | word | yes  | -
+      field     | Name of the passive-scalar field    | word | no   | s
+      phi       | Name of flux field                  | word | no   | phi
+      rho       | Name of density field               | word | no   | rho
+      nut       | Name of the turbulence viscosity    | word | no   | none
+      phase     | Name of the phase                   | word | no   | none
+      phasePhiCompressed | Name of compressed VOF flux | word | no | alphaPhiUn
+      schemesField | Name of field to specify schemes | word  | no | field
+      bounded01 | Bounds scalar between 0-1 for multiphase  | bool | no | true
+      D         | Diffusion coefficient               | scalar | no | -
+      alphaD    | Laminar diffusivity coefficient     | scalar | no | 1
+      alphaDt   | Turbulent diffusivity coefficient   | scalar | no | 1
+      tolerance | Outer-loop initial-residual tolerance | scalar | no | 1
+      nCorr     | Number of outer-loop correctors     | int    | no | 0
+      resetOnStartUp | Flag to reset field to zero on start-up | bool | no | no
+      fvOptions | List of finite-volume options       | dict   | no | -
     \endtable
 
-See also
-    Foam::functionObjects::fvMeshFunctionObject
+    The inherited entries are elaborated in:
+      - \link fvMeshFunctionObject.H \endlink
+      - \link fvOption.H \endlink
+
+    An example of function object specification to solve a residence time
+    in a two-phase flow:
+    \verbatim
+    scalarTransport1
+    {
+        // Mandatory entries
+        type            scalarTransport;
+        libs            (solverFunctionObjects);
+
+        // Optional entries
+        field           s;
+        bounded01       false;
+        phase           alpha.water;
+        tolerance       1e-5;
+        resetOnStartUp  false;
+        fvOptions
+        {
+            unitySource
+            {
+                type            scalarSemiImplicitSource;
+                enabled         true;
+
+                selectionMode   all;
+                volumeMode      specific;
+
+                sources
+                {
+                    s           (1 0);
+                }
+            }
+        }
+
+        // Inherited entries
+        enabled         true;
+        writeControl    writeTime;
+        writeInterval   1;
+    }
+    \endverbatim
+
+Note
+  - To use the same numerical schemes as another field,
+  set the \c schemesField entry.
+  - The diffusivity can be set manually using the \c D entry, obtained
+  from the turbulence model or specified as `nut`.
+  - Alternatively, if a turbulence model is available, turbulent diffusivity
+  can be constructed from the laminar and turbulent viscosities using the
+  optional diffusivity coefficients \c alphaD and \c alphaDt
+  (which default to 1):
+
+    \f[
+        D = \alpha_D \, \nu + \alpha_{Dt} \, \nu_t
+    \f]
 
 SourceFiles
     scalarTransport.C
@@ -163,49 +187,52 @@ class scalarTransport
 :
     public fvMeshFunctionObject
 {
-    // Private data
+    // Private Data
+
+        //- Run-time selectable finite volume options, e.g. sources, constraints
+        fv::optionList fvOptions_;
 
         //- Name of the transport field.
         word fieldName_;
 
-        //- Name of flux field (optional)
+        //- Name of field whose schemes are used
+        word schemesField_;
+
+        //- Name of flux field
         word phiName_;
 
-        //- Name of density field (optional)
+        //- Name of density field
         word rhoName_;
 
-        //- Name of turbulent viscosity field (optional)
+        //- Name of turbulent viscosity field
         word nutName_;
 
-        //- Name of phase field (optional)
+        //- Name of phase field
         word phaseName_;
 
-        //- Name of phase field compressed flux (optional)
+        //- Name of phase field compressed flux
         word phasePhiCompressedName_;
 
-        //- Diffusion coefficient (optional)
+        //- Diffusion coefficient
         scalar D_;
 
-        //- Flag to indicate whether a constant, uniform D_ is specified
-        bool constantD_;
-
-        //- Laminar diffusion coefficient (optional)
+        //- Laminar diffusion coefficient
         scalar alphaD_;
 
-        //- Turbulent diffusion coefficient (optional)
+        //- Turbulent diffusion coefficient
         scalar alphaDt_;
 
-        //- Number of corrector iterations (optional)
-        label nCorr_;
+        //- Outer-loop initial-residual tolerance
+        scalar tol_;
+
+        //- Number of corrector iterations
+        int nCorr_;
 
         //- Flag to reset the scalar to zero on start-up
         bool resetOnStartUp_;
 
-        //- Name of field whose schemes are used (optional)
-        word schemesField_;
-
-        //- Run-time selectable finite volume options, e.g. sources, constraints
-        fv::optionList fvOptions_;
+        //- Flag to indicate whether a constant, uniform D_ is specified
+        bool constantD_;
 
         //- Bound scalar between 0-1 using MULES for multiphase case
         bool bounded01_;
@@ -223,12 +250,6 @@ class scalarTransport
             const surfaceScalarField& phi
         ) const;
 
-        //- No copy construct
-        scalarTransport(const scalarTransport&) = delete;
-
-        //- No copy assignment
-        void operator=(const scalarTransport&) = delete;
-
 
 public:
 
@@ -248,7 +269,7 @@ public:
 
 
     //- Destructor
-    virtual ~scalarTransport();
+    virtual ~scalarTransport() = default;
 
 
     // Member Functions

src/mesh/snappyHexMesh/meshRefinement/meshRefinement.C

@@ -2054,7 +2054,6 @@ Foam::labelList Foam::meshRefinement::intersectedPoints() const
 
     // Mark all points on faces that will become baffles
     bitSet isBoundaryPoint(mesh_.nPoints());
-    label nBoundaryPoints = 0;
 
     const labelList& surfIndex = surfaceIndex();
 
@@ -2062,15 +2061,7 @@ Foam::labelList Foam::meshRefinement::intersectedPoints() const
     {
         if (surfIndex[facei] != -1)
         {
-            const face& f = faces[facei];
-
-            forAll(f, fp)
-            {
-                if (isBoundaryPoint.set(f[fp]))
-                {
-                    nBoundaryPoints++;
-                }
-            }
+            isBoundaryPoint.set(faces[facei]);
         }
     }
 
@@ -2083,37 +2074,17 @@ Foam::labelList Foam::meshRefinement::intersectedPoints() const
     //    if (patchi != -1)
     //    {
     //        const polyPatch& pp = mesh_.boundaryMesh()[patchi];
-    //
-    //        label facei = pp.start();
-    //
     //        forAll(pp, i)
     //        {
-    //            const face& f = faces[facei];
-    //
-    //            forAll(f, fp)
-    //            {
-    //                if (isBoundaryPoint.set(f[fp]))
-    //                    nBoundaryPoints++;
-    //                }
-    //            }
-    //            facei++;
+    //            isBoundaryPoint.set(faces[pp.start()+i]);
     //        }
     //    }
     //}
 
+    // Make sure all processors have the same data
+    syncTools::syncPointList(mesh_, isBoundaryPoint, orEqOp<unsigned int>(), 0);
 
-    // Pack
-    labelList boundaryPoints(nBoundaryPoints);
-    nBoundaryPoints = 0;
-    forAll(isBoundaryPoint, pointi)
-    {
-        if (isBoundaryPoint.test(pointi))
-        {
-            boundaryPoints[nBoundaryPoints++] = pointi;
-        }
-    }
-
-    return boundaryPoints;
+    return isBoundaryPoint.sortedToc();
 }
 
 

src/meshTools/cellDist/cellDistFuncs.C

@@ -256,7 +256,7 @@ void Foam::cellDistFuncs::correctBoundaryFaceCells
             {
                 if (areaFraction && (areaFraction()[patchFacei] <= 0.5))
                 {
-                    // is mostly coupled
+                    // For cyclicACMI: more cyclic than wall
                     continue;
                 }
 
@@ -311,9 +311,9 @@ void Foam::cellDistFuncs::correctBoundaryPointCells
                 // Check cells with face on wall
                 forAll(patch, patchFacei)
                 {
-                    if (!areaFraction || (areaFraction()[patchFacei] <= 0.5))
+                    if (areaFraction && (areaFraction()[patchFacei] <= 0.5))
                     {
-                        // face mostly coupled
+                        // For cyclicACMI: more cyclic than wall
                         isWallPoint.unset(localFaces[patchFacei]);
                     }
                 }

src/overset/cellCellStencil/cellCellStencil/cellCellStencilObject.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017 OpenCFD Ltd.
+    Copyright (C) 2017,2024 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -26,7 +26,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "cellCellStencilObject.H"
-
+#include "dynamicOversetFvMesh.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -36,4 +36,25 @@ namespace Foam
 }
 
 
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::cellCellStencilObject::movePoints()
+{
+    // Update (if needed) underlying stencil
+    const bool changed = stencilPtr_().update();
+
+    if (changed)
+    {
+        const auto* oversetMeshPtr = isA<oversetFvMeshBase>(mesh());
+        if (oversetMeshPtr)
+        {
+            // Clear out any additional (ldu)addressing
+            const_cast<oversetFvMeshBase&>(*oversetMeshPtr).clearOut();
+        }
+    }
+
+    return changed;
+}
+
+
 // ************************************************************************* //

src/overset/cellCellStencil/cellCellStencil/cellCellStencilObject.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2019 OpenCFD Ltd.
+    Copyright (C) 2017-2019,2024 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -54,19 +54,9 @@ typedef MeshObject<fvMesh, MoveableMeshObject, cellCellStencilObject> Stencil;
 
 class cellCellStencilObject
 :
-    public MeshObject<fvMesh, MoveableMeshObject, cellCellStencilObject>,
+    public Stencil,
     public cellCellStencil
 {
-    // Private Typedefs
-
-        typedef MeshObject
-        <
-            fvMesh,
-            MoveableMeshObject,
-            cellCellStencilObject
-        > MeshObject_type;
-
-
     // Private Data
 
         autoPtr<cellCellStencil> stencilPtr_;
@@ -86,8 +76,7 @@ public:
             const bool update = true
         )
         :
-            MeshObject_type(mesh),
-
+            Stencil(mesh),
             cellCellStencil(mesh),
             stencilPtr_
             (
@@ -111,10 +100,7 @@ public:
     // Member Functions
 
         //- Callback for geometry motion
-        virtual bool movePoints()
-        {
-            return stencilPtr_().update();
-        }
+        virtual bool movePoints();
 
         //- Update stencils. Return false if nothing changed.
         virtual bool update()

src/overset/oversetFvMesh/dynamicOversetFvMesh/dynamicOversetFvMesh.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2022 OpenCFD Ltd.
+    Copyright (C) 2022,2024 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -65,6 +65,10 @@ bool Foam::dynamicOversetFvMesh::update()
         return false;
     }
 
+    //Note: too late to do oversetFvMeshBase::clearOut() to get it
+    //      consistent with any new cell-cell stencil since 
+    //      dynamicMotionSolverListFvMesh already triggers
+    //      meshObject::movePoints on cellCellStencilObject
     oversetFvMeshBase::update();
 
     return true;

src/overset/oversetFvMesh/oversetFvMeshBase.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2014-2022 OpenCFD Ltd.
+    Copyright (C) 2014-2022,2024 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -578,6 +578,14 @@ Foam::oversetFvMeshBase::primitiveLduAddr() const
 }
 
 
+void Foam::oversetFvMeshBase::clearOut()
+{
+    // Cell-cell stencil is already mesh object. Clear out local
+    // addressing to force rebuilding addressing
+    lduPtr_.clear();
+}
+
+
 bool Foam::oversetFvMeshBase::update()
 {
     {

src/overset/oversetFvMesh/oversetFvMeshBase.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2015-2022 OpenCFD Ltd.
+    Copyright (C) 2015-2022,2024 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -37,7 +37,6 @@ SourceFiles
 #ifndef oversetFvMeshBase_H
 #define oversetFvMeshBase_H
 
-#include "fvMeshPrimitiveLduAddressing.H"
 #include "fvMeshPrimitiveLduAddressing.H"
 #include "lduInterfaceFieldPtrsList.H"
 #include "volFieldsFwd.H"
@@ -238,6 +237,9 @@ public:
             ) const;
 
 
+        //- Clear out local storage
+        void clearOut();
+
         //- Update the mesh for both mesh motion and topology change
         virtual bool update();
 

src/rigidBodyDynamics/rigidBodySolvers/symplectic/symplectic.C

@@ -75,6 +75,7 @@ void Foam::RBD::rigidBodySolvers::symplectic::solve
     qDot() = qDot0() + 0.5*deltaT0()*qDdot();
     q() = q0() + deltaT()*qDot();
 
+    // Update joints from new locations (q, q0)
     correctQuaternionJoints();
 
     // Update the body-state prior to the evaluation of the restraints

tutorials/mesh/blockMesh/sphere/system/blockMeshDict

@@ -35,7 +35,7 @@ geometry
 }
 
 // Box size
-vo   #eval{ sqrt($outerRadius/3) };
+vo   #eval{ $outerRadius/sqrt(3) };
 
 vertices
 (

tutorials/mesh/blockMesh/sphere7/system/blockMeshDict

@@ -38,7 +38,7 @@ geometry
 }
 
 // Outer box size
-vo   #eval{ sqrt($outerRadius/3) };
+vo   #eval{ $outerRadius/sqrt(3) };
 
 // Inner box size - % of overall dimension
 vi   #eval{ $vo * $innerRatio };

tutorials/mesh/blockMesh/sphere7ProjectedEdges/system/blockMeshDict

@@ -45,7 +45,7 @@ geometry
 
 
 // Outer box size (approximate)
-vo   #eval{ sqrt($outerRadius/3) };
+vo   #eval{ $outerRadius/sqrt(3) };
 
 // Inner box size - % of overall dimension
 vi   #eval{ $vo * $innerRatio };