ENH: fvMatrix: adding setValues for patch

Speedup in offloading

.gitlab/issue_templates/bug.md

@@ -49,10 +49,10 @@
 
 <!--
   Providing details of your set-up can help us identify any issues, e.g.
-  OpenFOAM version : v2312|v2306|v2212|v2206|v2112 etc
-  Operating system : ubuntu|openSUSE|centos etc
+  OpenFOAM version : v2412|v2406|v2312|v2306|v2212 etc
+  Operating system : ubuntu|openSUSE|RedHat etc
   Hardware info    : any info that may help?
-  Compiler         : gcc|intel|clang etc
+  Compiler         : gcc|clang etc
  -->
 
 - OpenFOAM version :

.gitmodules

@@ -1,8 +1,8 @@
 [submodule "cfmesh"]
-	path = modules/cfmesh
+	path = plugins/cfmesh
 	url = https://develop.openfoam.com/Community/integration-cfmesh.git
 [submodule "avalanche"]
-	path = modules/avalanche
+	path = plugins/avalanche
 	url = https://develop.openfoam.com/Community/avalanche.git
 [submodule "adios"]
 	path = modules/adios
@@ -18,5 +18,8 @@
 	path = modules/external-solver
 	url = https://develop.openfoam.com/Modules/external-solver.git
 [submodule "turbulence-community"]
-	path = modules/turbulence-community
+	path = plugins/turbulence-community
 	url = https://gitlab.com/openfoam/community/tc-turbulence/turbulence-community.git
+[submodule "plugins/data-community"]
+	path = plugins/data-community
+	url = https://gitlab.com/openfoam/community/sig-data-modelling/data-community.git

Allwmake

@@ -68,19 +68,34 @@ src/Allwmake $targetType $*
 # OpenFOAM applications
 applications/Allwmake $targetType $*
 
+#------------------------------------------------------------------------------
+# Additional components
 
-# Additional components/modules
 case "$FOAM_MODULE_PREFIX" in
 (false | none)
     echo ========================================
     echo "OpenFOAM modules disabled (prefix=${FOAM_MODULE_PREFIX})"
+    echo "Can be built separately:"
+    echo
+    echo "    ./Allwmake-modules -prefix=..."
+    echo
+    echo ========================================
     echo
     ;;
 (*)
     # Use wmake -all instead of Allwmake to allow for overrides
     ( cd "$WM_PROJECT_DIR/modules" 2>/dev/null && wmake -all )
+
+    echo ========================================
+    echo "The optional plugins can be built separately:"
+    echo
+    echo "    ./Allwmake-plugins -prefix=..."
+    echo
+    echo ========================================
+    echo
 esac
 
+#------------------------------------------------------------------------------
 # Count files in given directory. Ignore "Test-*" binaries.
 _foamCountDirEntries()
 {

Allwmake-modules

@@ -0,0 +1,37 @@
+#!/bin/sh
+# Run from OPENFOAM top-level directory only
+cd "${0%/*}" || exit
+wmake -check-dir "$WM_PROJECT_DIR" 2>/dev/null || {
+    echo "Error (${0##*/}) : not located in \$WM_PROJECT_DIR"
+    echo "    Check your OpenFOAM environment and installation"
+    exit 1
+}
+if [ -f "$WM_PROJECT_DIR"/wmake/scripts/AllwmakeParseArguments ]
+then  . "$WM_PROJECT_DIR"/wmake/scripts/AllwmakeParseArguments -no-recursion "$@" || \
+    echo "Argument parse error"
+else
+    echo "Error (${0##*/}) : WM_PROJECT_DIR appears to be incorrect"
+    echo "    Check your OpenFOAM environment and installation"
+    exit 1
+fi
+
+#------------------------------------------------------------------------------
+# Additional components
+
+case "$FOAM_MODULE_PREFIX" in
+(false | none)
+    echo ========================================
+    echo "OpenFOAM modules disabled (prefix=${FOAM_MODULE_PREFIX})"
+    echo "Can be built separately:"
+    echo
+    echo "    ./Allwmake-modules -prefix=..."
+    echo
+    echo ========================================
+    echo
+    ;;
+(*)
+    # Use wmake -all instead of Allwmake to allow for overrides
+    ( cd "$WM_PROJECT_DIR/modules" 2>/dev/null && wmake -all )
+esac
+
+#------------------------------------------------------------------------------

Allwmake-plugins

@@ -0,0 +1,37 @@
+#!/bin/sh
+# Run from OPENFOAM top-level directory only
+cd "${0%/*}" || exit
+wmake -check-dir "$WM_PROJECT_DIR" 2>/dev/null || {
+    echo "Error (${0##*/}) : not located in \$WM_PROJECT_DIR"
+    echo "    Check your OpenFOAM environment and installation"
+    exit 1
+}
+if [ -f "$WM_PROJECT_DIR"/wmake/scripts/AllwmakeParseArguments ]
+then  . "$WM_PROJECT_DIR"/wmake/scripts/AllwmakeParseArguments -no-recursion "$@" || \
+    echo "Argument parse error"
+else
+    echo "Error (${0##*/}) : WM_PROJECT_DIR appears to be incorrect"
+    echo "    Check your OpenFOAM environment and installation"
+    exit 1
+fi
+
+#------------------------------------------------------------------------------
+# Additional components
+
+case "$FOAM_MODULE_PREFIX" in
+(false | none)
+    echo ========================================
+    echo "OpenFOAM plugins disabled (prefix=${FOAM_MODULE_PREFIX})"
+    echo "Can be built separately:"
+    echo
+    echo "    ./Allwmake-plugins -prefix=..."
+    echo
+    echo ========================================
+    echo
+    ;;
+(*)
+    # Use wmake -all instead of Allwmake to allow for overrides
+    ( cd "$WM_PROJECT_DIR/plugins" 2>/dev/null && wmake -all )
+esac
+
+#------------------------------------------------------------------------------

CONTRIBUTORS.md

@@ -27,6 +27,7 @@ It is likely incomplete...
 - Bernhard Gschaider
 - Andrew Heather
 - David Hill
+- Crist<73>bal Ib<49><62>ez
 - Yoshiaki Inoue
 - Mattijs Janssens
 - Andrew Jackson

META-INFO/api-info

@@ -1,2 +1,2 @@
-api=2402
-patch=240522
+api=2412
+patch=0

README.md

@@ -40,9 +40,9 @@ Violations of the Trademark are monitored, and will be duly prosecuted.
 
 If OpenFOAM has already been compiled on your system, simply source
 the appropriate `etc/bashrc` or `etc/cshrc` file and get started.
-For example, for the OpenFOAM-v2312 version:
+For example, for the OpenFOAM-v2412 version:
 ```
-source /installation/path/OpenFOAM-v2312/etc/bashrc
+source /installation/path/OpenFOAM-v2412/etc/bashrc
 ```
 
 ## Compiling OpenFOAM
@@ -127,8 +127,8 @@ These 3rd-party sources are normally located in a directory parallel
 to the OpenFOAM directory. For example,
 ```
 /path/parent
-|-- OpenFOAM-v2312
-\-- ThirdParty-v2312
+|-- OpenFOAM-v2412
+\-- ThirdParty-v2412
 ```
 There are, however, many cases where this simple convention is inadequate:
 
@@ -136,7 +136,7 @@ There are, however, many cases where this simple convention is inadequate:
   operating system or cluster installation provides it)
 
 * When we have changed the OpenFOAM directory name to some arbitrary
-  directory name, e.g. openfoam-sandbox2312, etc..
+  directory name, e.g. openfoam-sandbox2412, etc..
 
 * When we would like any additional 3rd party software to be located
   inside of the OpenFOAM directory to ensure that the installation is
@@ -156,9 +156,9 @@ when locating the ThirdParty directory with the following precedence:
 2. PREFIX/ThirdParty-VERSION
    * this corresponds to the traditional approach
 3. PREFIX/ThirdParty-vAPI
-   * allows for an updated value of VERSION, *eg*, `v2312-myCustom`,
+   * allows for an updated value of VERSION, *eg*, `v2412-myCustom`,
      without requiring a renamed ThirdParty. The API value would still
-     be `2312` and the original `ThirdParty-v2312/` would be found.
+     be `2412` and the original `ThirdParty-v2412/` would be found.
 4. PREFIX/ThirdParty-API
    * same as the previous example, but using an unadorned API value.
 5. PREFIX/ThirdParty-common
@@ -213,4 +213,4 @@ ThirdParty directory will contain either an `Allwmake` file or a
 - [Governance](http://www.openfoam.com/governance/), [Governance Projects](https://www.openfoam.com/governance/projects)
 - [Contacting OpenCFD](http://www.openfoam.com/contact/)
 
-Copyright 2016-2023 OpenCFD Ltd
+Copyright 2016-2024 OpenCFD Ltd

applications/solvers/combustion/reactingFoam/EEqn.H

@@ -21,6 +21,11 @@
       + fvOptions(rho, he)
     );
 
+    if (MRF.active())
+    {
+        EEqn += fvc::div(MRF.phi(), p);
+    }
+
     EEqn.relax();
 
     fvOptions.constrain(EEqn);

applications/solvers/compressible/rhoPimpleFoam/EEqn.H

@@ -20,6 +20,11 @@
         fvOptions(rho, he)
     );
 
+    if (MRF.active())
+    {
+        EEqn += fvc::div(MRF.phi(), p);
+    }
+
     EEqn.relax();
 
     fvOptions.constrain(EEqn);

applications/solvers/compressible/rhoSimpleFoam/EEqn.H

@@ -14,6 +14,11 @@
         fvOptions(rho, he)
     );
 
+    if (MRF.active())
+    {
+        EEqn += fvc::div(MRF.phi(), p);
+    }
+
     EEqn.relax();
 
     fvOptions.constrain(EEqn);

applications/solvers/compressible/sonicFoam/EEqn.H

@@ -9,6 +9,11 @@
         fvOptions(rho, e)
     );
 
+    if (MRF.active())
+    {
+        EEqn += fvc::div(MRF.phi(), p);
+    }
+
     EEqn.relax();
 
     fvOptions.constrain(EEqn);

applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionTwoPhaseEulerFoam/fluid/setRegionFluidFields.H

@@ -8,11 +8,13 @@
 
     volVectorField& U1 = phase1.URef();
     surfaceScalarField& phi1 = phase1.phiRef();
-    const surfaceScalarField& alphaPhi1 = phase1.alphaPhi();
+    const tmp<surfaceScalarField> talphaPhi1 = phase1.alphaPhi();
+    const auto& alphaPhi1 = talphaPhi1();
 
     volVectorField& U2 = phase2.URef();
     surfaceScalarField& phi2 = phase2.phiRef();
-    const surfaceScalarField& alphaPhi2 = phase2.alphaPhi();
+    const tmp<surfaceScalarField> talphaPhi2 = phase2.alphaPhi();
+    const auto& alphaPhi2 = talphaPhi2();
 
     surfaceScalarField& phi = fluid.phi();
 

applications/solvers/incompressible/pimpleFoam/overPimpleDyMFoam/continuityErrs.H

@@ -33,7 +33,12 @@ Description
 \*---------------------------------------------------------------------------*/
 
 {
-    volScalarField contErr(interpolatedCells*cellMask*fvc::div(phi));
+    const DimensionedField<scalar, volMesh> contErr
+    (
+        interpolatedCells.internalField()
+       *cellMask.internalField()
+       *fvc::div(phi)().internalField()
+    );
 
     scalar sumLocalContErr = runTime.deltaTValue()*
         mag(contErr)().weightedAverage(mesh.V()).value();

applications/solvers/incompressible/simpleFoam/Make/options

@@ -5,13 +5,17 @@ EXE_INC = \
     -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/incompressible/lnInclude \
     -I$(LIB_SRC)/transportModels \
-    -I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel
+    -I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/dynamicFvMesh/lnInclude
 
 EXE_LIBS = \
     -lfiniteVolume \
     -lfvOptions \
     -lmeshTools \
     -lsampling \
+    -ldynamicMesh \
+    -ldynamicFvMesh \
     -lturbulenceModels \
     -lincompressibleTurbulenceModels \
     -lincompressibleTransportModels \

applications/solvers/incompressible/simpleFoam/overSimpleFoam/continuityErrs.H

@@ -33,7 +33,12 @@ Description
 \*---------------------------------------------------------------------------*/
 
 {
-    volScalarField contErr(interpolatedCells*cellMask*fvc::div(phi));
+    const DimensionedField<scalar, volMesh> contErr
+    (
+        interpolatedCells.internalField()
+       *cellMask.internalField()
+       *fvc::div(phi)().internalField()
+    );
 
     scalar sumLocalContErr = runTime.deltaTValue()*
         mag(contErr)().weightedAverage(mesh.V()).value();

applications/solvers/incompressible/simpleFoam/simpleFoam.C

@@ -64,6 +64,7 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "fvCFD.H"
+#include "dynamicFvMesh.H"
 #include "singlePhaseTransportModel.H"
 #include "turbulentTransportModel.H"
 #include "simpleControl.H"
@@ -83,7 +84,7 @@ int main(int argc, char *argv[])
     #include "addCheckCaseOptions.H"
     #include "setRootCaseLists.H"
     #include "createTime.H"
-    #include "createMesh.H"
+    #include "createDynamicFvMesh.H"
     #include "createControl.H"
     #include "createFields.H"
     #include "initContinuityErrs.H"
@@ -98,6 +99,14 @@ int main(int argc, char *argv[])
     {
         Info<< "Time = " << runTime.timeName() << nl << endl;
 
+        // Do any mesh changes
+        mesh.controlledUpdate();
+
+        if (mesh.changing())
+        {
+            MRF.update();
+        }
+
         // --- Pressure-velocity SIMPLE corrector
         {
             #include "UEqn.H"

applications/solvers/multiphase/compressibleInterFoam/VoFphaseCompressibleTurbulenceModels/compressibleInterPhaseTransportModel.C

@@ -74,8 +74,11 @@ Foam::compressibleInterPhaseTransportModel::compressibleInterPhaseTransportModel
         const volScalarField& alpha1(mixture_.alpha1());
         const volScalarField& alpha2(mixture_.alpha2());
 
-        const volScalarField& rho1 = mixture_.thermo1().rho();
-        const volScalarField& rho2 = mixture_.thermo2().rho();
+        const tmp<volScalarField> trho1 = mixture_.thermo1().rho();
+        const tmp<volScalarField> trho2 = mixture_.thermo2().rho();
+
+        const auto& rho1 = trho1();
+        const auto& rho2 = trho2();
 
         alphaRhoPhi1_ =
         (
@@ -185,8 +188,8 @@ void Foam::compressibleInterPhaseTransportModel::correctPhasePhi()
 {
     if (twoPhaseTransport_)
     {
-        const volScalarField& rho1 = mixture_.thermo1().rho();
-        const volScalarField& rho2 = mixture_.thermo2().rho();
+        const tmp<volScalarField> rho1 = mixture_.thermo1().rho();
+        const tmp<volScalarField> rho2 = mixture_.thermo2().rho();
 
         alphaRhoPhi1_.ref() = fvc::interpolate(rho1)*alphaPhi10_;
         alphaRhoPhi2_.ref() = fvc::interpolate(rho2)*(phi_ - alphaPhi10_);

applications/solvers/multiphase/icoReactingMultiphaseInterFoam/icoReactingMultiphaseInterFoam.C

@@ -130,10 +130,17 @@ int main(int argc, char *argv[])
                     }
                 }
             }
-            #include "UEqn.H"
+
             #include "YEqns.H"
             #include "TEqn.H"
 
+            if (pimple.frozenFlow())
+            {
+                continue;
+            }
+
+            #include "UEqn.H"
+
             // --- Pressure corrector loop
             while (pimple.correct())
             {

applications/solvers/multiphase/interFoam/overInterDyMFoam/continuityErrs.H

@@ -33,7 +33,12 @@ Description
 \*---------------------------------------------------------------------------*/
 
 {
-    volScalarField contErr(interpolatedCells*cellMask*fvc::div(phi));
+    const DimensionedField<scalar, volMesh> contErr
+    (
+        interpolatedCells.internalField()
+       *cellMask.internalField()
+       *fvc::div(phi)().internalField()
+    );
 
     scalar sumLocalContErr = runTime.deltaTValue()*
         mag(contErr)().weightedAverage(mesh.V()).value();

applications/solvers/multiphase/reactingMultiphaseEulerFoam/EEqns.H

@@ -12,8 +12,11 @@ for (int Ecorr=0; Ecorr<nEnergyCorrectors; Ecorr++)
         phaseModel& phase = fluid.anisothermalPhases()[anisothermalPhasei];
 
         const volScalarField& alpha = phase;
-        const volScalarField& rho = phase.rho();
-        const volVectorField& U = phase.U();
+        const tmp<volScalarField> trho = phase.rho();
+        const tmp<volVectorField> tU = phase.U();
+
+        const auto& rho = trho();
+        const auto& U = tU();
 
         fvScalarMatrix EEqn
         (

applications/solvers/multiphase/reactingMultiphaseEulerFoam/YEqns.H

@@ -11,7 +11,9 @@
 
         UPtrList<volScalarField>& Y = phase.YActiveRef();
         const volScalarField& alpha = phase;
-        const volScalarField& rho = phase.rho();
+        const tmp<volScalarField> trho = phase.rho();
+
+        const auto& rho = trho();
 
         forAll(Y, i)
         {

applications/solvers/multiphase/reactingMultiphaseEulerFoam/pU/UEqns.H

@@ -14,9 +14,11 @@ PtrList<fvVectorMatrix> UEqns(phases.size());
         phaseModel& phase = fluid.movingPhases()[movingPhasei];
 
         const volScalarField& alpha = phase;
-        const volScalarField& rho = phase.rho();
+        const tmp<volScalarField> trho = phase.rho();
         volVectorField& U = phase.URef();
 
+        const auto& rho = trho();
+
         UEqns.set
         (
             phase.index(),

applications/solvers/multiphase/reactingMultiphaseEulerFoam/pUf/UEqns.H

@@ -17,9 +17,11 @@ PtrList<fvVectorMatrix> UEqns(phases.size());
         phaseModel& phase = fluid.movingPhases()[movingPhasei];
 
         const volScalarField& alpha = phase;
-        const volScalarField& rho = phase.rho();
+        const tmp<volScalarField> trho = phase.rho();
         volVectorField& U = phase.URef();
 
+        const auto& rho = trho();
+
         UEqns.set
         (
             phase.index(),

applications/solvers/multiphase/reactingTwoPhaseEulerFoam/createFieldRefs.H

@@ -6,11 +6,13 @@ const volScalarField& alpha2 = phase2;
 
 volVectorField& U1 = phase1.URef();
 surfaceScalarField& phi1 = phase1.phiRef();
-const surfaceScalarField& alphaPhi1 = phase1.alphaPhi();
+const tmp<surfaceScalarField> talphaPhi1 = phase1.alphaPhi();
+const auto& alphaPhi1 = talphaPhi1();
 
 volVectorField& U2 = phase2.URef();
 surfaceScalarField& phi2 = phase2.phiRef();
-const surfaceScalarField& alphaPhi2 = phase2.alphaPhi();
+const tmp<surfaceScalarField> talphaPhi2 = phase2.alphaPhi();
+const auto& alphaPhi2 = talphaPhi2();
 
 surfaceScalarField& phi = fluid.phi();
 

applications/solvers/multiphase/twoPhaseEulerFoam/EEqns.H

@@ -50,7 +50,7 @@
       + (
             he2.name() == thermo2.phasePropertyName("e")
           ? fvc::div(fvc::absolute(alphaPhi2, alpha2, U2), p)
-          + p*fvc::ddt(alpha1)
+          + p*fvc::ddt(alpha2)
           : -alpha2*dpdt
         )
 

applications/test/00-machine-sizes/Test-machine-sizes.cpp

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2022 OpenCFD Ltd.
+    Copyright (C) 2018-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,9 +25,12 @@ License
 
 Description
     Test the sizeof for basic types.
+    Also tests how the data mapping of OpenFOAM types to UPstream (MPI)
+    type ids are handled.
+
     Can be compiled and run without any OpenFOAM libraries.
 
-        g++ -std=c++11 -oTest-machine-sizes Test-machine-sizes.cpp
+        g++ -std=c++17 -oTest-machine-sizes Test-machine-sizes.cpp
 
 \*---------------------------------------------------------------------------*/
 
@@ -37,6 +40,114 @@ Description
 #include <iostream>
 #include <limits>
 #include <typeinfo>
+#include <type_traits>
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Partial copy from UPstream.H
+
+//- Some MPI data types
+//
+//- Mapping of some fundamental and aggregate types to MPI data types
+enum class dataTypes : int
+{
+    // Builtin Types [8]:
+    DataTypes_begin,    //!< Begin builtin types (internal use)
+    type_byte = DataTypes_begin,  // also for char, unsigned char
+    type_int32,
+    type_int64,
+    type_uint32,
+    type_uint64,
+    type_float,
+    type_double,
+    type_long_double,
+    invalid
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Partial copy from UPstreamTraits.H
+
+//- A supported UPstream data type (intrinsic or user-defined)
+template<class T>
+struct UPstream_base_dataType : std::false_type
+{
+    static constexpr auto datatype_id = dataTypes::invalid;
+};
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Specializations of the above,
+// each to match the elements of UPstream::dataTypes
+
+#undef  defineUPstreamDataTraits
+#define defineUPstreamDataTraits(TypeId, Type)                                \
+    template<> struct UPstream_base_dataType<Type> : std::true_type           \
+    {                                                                         \
+        static constexpr auto datatype_id = dataTypes::TypeId;                \
+    };
+
+
+defineUPstreamDataTraits(type_byte,   char);
+defineUPstreamDataTraits(type_byte,   unsigned char);
+defineUPstreamDataTraits(type_int32,  int32_t);
+defineUPstreamDataTraits(type_int64,  int64_t);
+defineUPstreamDataTraits(type_uint32, uint32_t);
+defineUPstreamDataTraits(type_uint64, uint64_t);
+defineUPstreamDataTraits(type_float,  float);
+defineUPstreamDataTraits(type_double, double);
+defineUPstreamDataTraits(type_long_double, long double);
+
+#undef defineUPstreamDataTraits
+
+
+//- Explicit handling of data type aliases. This is necessary since
+//- different systems map things like 'unsigned long' differently but we
+//- restrict ourselves to int32/int64 types
+template<class T>
+struct UPstream_alias_dataType
+:
+    std::bool_constant
+    <
+        // Base type (no alias needed)
+        UPstream_base_dataType<std::remove_cv_t<T>>::value ||
+        (
+            // Or some int 32/64 type to re-map
+            std::is_integral_v<T>
+         && (sizeof(T) == sizeof(int32_t) || sizeof(T) == sizeof(int64_t))
+        )
+    >
+{
+    // Is it using the base type? (no alias needed)
+    static constexpr bool is_base =
+        UPstream_base_dataType<std::remove_cv_t<T>>::value;
+
+    using base = std::conditional_t
+    <
+        UPstream_base_dataType<std::remove_cv_t<T>>::value,  // is_base
+        std::remove_cv_t<T>,
+        std::conditional_t
+        <
+            (
+                std::is_integral_v<T>
+             && (sizeof(T) == sizeof(int32_t) || sizeof(T) == sizeof(int64_t))
+            ),
+            std::conditional_t
+            <
+                (sizeof(T) == sizeof(int32_t)),
+                std::conditional_t<std::is_signed_v<T>, int32_t, uint32_t>,
+                std::conditional_t<std::is_signed_v<T>, int64_t, uint64_t>
+            >,
+            char  // Fallback value (assuming it is contiguous)
+        >
+    >;
+
+    static constexpr auto datatype_id =
+        UPstream_base_dataType<base>::datatype_id;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 template<class T>
 void print(const char* name, bool showLimits = true)
@@ -47,28 +158,78 @@ void print(const char* name, bool showLimits = true)
     if (showLimits)
     {
         std::cout
-            << " \"max\"=" << std::numeric_limits<T>::max();
+            << " max=<";
+
+        if constexpr (sizeof(T) == 1)
+        {
+            std::cout << int(std::numeric_limits<T>::max());
+        }
+        else
+        {
+            std::cout << std::numeric_limits<T>::max();
+        }
+        std::cout << '>';
+    }
+
+    // A declared or deduced MPI type, or aliased
+    std::cout
+        << " is_mpi=" << UPstream_base_dataType<T>::value
+        << " (" << int(UPstream_base_dataType<T>::datatype_id) << ")";
+
+    if (UPstream_alias_dataType<T>::value)
+    {
+        if (UPstream_alias_dataType<T>::is_base)
+        {
+            std::cout<< " is_base";
+        }
+        else
+        {
+            std::cout<< " is_alias ("
+                << int(UPstream_alias_dataType<T>::datatype_id) << ")";
+        }
+    }
+    else
+    {
+        std::cout<< " no_alias";
     }
 
     std::cout<< '\n';
 }
 
 
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 // Main program:
 
 int main(int argc, char *argv[])
 {
     std::cout<< "c++ = " << __cplusplus << '\n';
-    std::cout<< "machine sizes\n---\n\n";
+    std::cout<< "machine sizes (and some MPI traits)\n---\n\n";
 
+    print<int8_t>("int8_t");
+    print<uint8_t>("uint8_t");
+    print<int16_t>("int16_t");
+    print<uint16_t>("uint16_t");
+    print<int32_t>("int32_t");
+    print<uint32_t>("uint32_t");
+    print<int64_t>("int64_t");
+    print<uint64_t>("uint64_t");
+
+    std::cout << '\n';
+    print<char>("char");
+    print<unsigned char>("unsigned char");
     print<short>("short");
     print<int>("int");
+    print<unsigned>("unsigned");
     print<long>("long");
     print<unsigned long>("unsigned long");
-    print<std::size_t>("std::size_t");
     print<long long>("long long");
 
+    std::cout << '\n';
+    print<std::size_t>("std::size_t");
+    print<std::streamsize>("std::streamsize");
+
+    std::cout << '\n';
     print<float>("float");
     print<double>("double");
     print<long double>("long double");

applications/test/DiagTensor/Test-DiagTensor.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2020-2022 OpenCFD Ltd.
+    Copyright (C) 2020-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -38,12 +38,11 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
+#include "complex.H"
 #include "Tensor.H"
 #include "SymmTensor.H"
 #include "SphericalTensor.H"
 #include "DiagTensor.H"
-#include "scalar.H"
-#include "complex.H"
 
 using namespace Foam;
 
@@ -57,45 +56,11 @@ unsigned nTest_ = 0;
 unsigned nFail_ = 0;
 
 
-// Compare two floating point types, and print output.
-// Do ++nFail_ if values of two objects are not equal within a given tolerance.
-// The function is converted from PEP-485.
-template<class Type>
-typename std::enable_if<pTraits<Type>::rank == 0, void>::type
-cmp
-(
-    const word& msg,
-    const Type& x,
-    const Type& y,
-    const scalar relTol = 1e-8,  //<! are values the same within 8 decimals
-    const scalar absTol = 0      //<! useful for cmps near zero
-)
-{
-    Info<< msg << x << endl;
-
-    unsigned nFail = 0;
-
-    if (max(absTol, relTol*max(mag(x), mag(y))) < mag(x - y))
-    {
-        ++nFail;
-    }
-
-    if (nFail)
-    {
-        Info<< nl
-            << "        #### Fail in " << nFail << " comps ####" << nl << endl;
-        ++nFail_;
-    }
-    ++nTest_;
-}
-
-
 // Compare two containers elementwise, and print output.
 // Do ++nFail_ if two components are not equal within a given tolerance.
 // The function is converted from PEP-485
 template<class Type>
-typename std::enable_if<pTraits<Type>::rank != 0, void>::type
-cmp
+void cmp
 (
     const word& msg,
     const Type& x,
@@ -104,18 +69,37 @@ cmp
     const scalar absTol = 0
 )
 {
-    Info<< msg << x << endl;
+    const auto notEqual = [=](const auto& a, const auto& b) -> bool
+    {
+        return
+        (
+            Foam::max(absTol, relTol*Foam::max(Foam::mag(a), Foam::mag(b)))
+          < Foam::mag(a - b)
+        );
+    };
 
     unsigned nFail = 0;
 
-    for (direction i = 0; i < pTraits<Type>::nComponents; ++i)
+    if constexpr (is_vectorspace_v<Type>)
     {
-        if (max(absTol, relTol*max(mag(x[i]), mag(y[i]))) < mag(x[i] - y[i]))
+        for (direction i = 0; i < pTraits<Type>::nComponents; ++i)
+        {
+            if (notEqual(x[i], y[i]))
+            {
+                ++nFail;
+            }
+        }
+    }
+    else
+    {
+        if (notEqual(x, y))
         {
             ++nFail;
         }
     }
 
+    Info<< msg << x << endl;
+
     if (nFail)
     {
         Info<< nl
@@ -368,27 +352,26 @@ void test_global_opers(Type)
 
 // Do compile-time recursion over the given types
 template<std::size_t I = 0, typename... Tp>
-inline typename std::enable_if<I == sizeof...(Tp), void>::type
-run_tests(const std::tuple<Tp...>& types, const List<word>& typeID){}
-
-
-template<std::size_t I = 0, typename... Tp>
-inline typename std::enable_if<I < sizeof...(Tp), void>::type
-run_tests(const std::tuple<Tp...>& types, const List<word>& typeID)
+void run_tests(const std::tuple<Tp...>& types, const List<word>& names)
 {
-    Info<< nl << "    ## Test constructors: "<< typeID[I] <<" ##" << nl;
-    test_constructors(std::get<I>(types));
+    if constexpr (I < sizeof...(Tp))
+    {
+        const auto& name = names[I];
 
-    Info<< nl << "    ## Test member functions: "<< typeID[I] <<" ##" << nl;
-    test_member_funcs(std::get<I>(types));
+        Info<< nl << "    ## Test constructors: " << name << " ##" << nl;
+        test_constructors(std::get<I>(types));
 
-    Info<< nl << "    ## Test global functions: "<< typeID[I] << " ##" << nl;
-    test_global_funcs(std::get<I>(types));
+        Info<< nl << "    ## Test member functions: " << name << " ##" << nl;
+        test_member_funcs(std::get<I>(types));
 
-    Info<< nl << "    ## Test global operators: "<< typeID[I] <<" ##" << nl;
-    test_global_opers(std::get<I>(types));
+        Info<< nl << "    ## Test global functions: " << name << " ##" << nl;
+        test_global_funcs(std::get<I>(types));
 
-    run_tests<I + 1, Tp...>(types, typeID);
+        Info<< nl << "    ## Test global operators: " << name << " ##" << nl;
+        test_global_opers(std::get<I>(types));
+
+        run_tests<I + 1, Tp...>(types, names);
+    }
 }
 
 
@@ -403,8 +386,8 @@ int main()
 
     const List<word> typeID
     ({
-        "DiagTensor<floatScalar>",
-        "DiagTensor<doubleScalar>",
+        "DiagTensor<float>",
+        "DiagTensor<double>",
         "DiagTensor<complex>"
     });
 

applications/test/Dictionary/Make/files

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

applications/test/FixedList/Test-FixedList.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2019-2023 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -85,8 +85,7 @@ void compileInfo()
 
 
 template<class FixedListType>
-typename std::enable_if
-<(FixedListType::max_size() == 2), bool>::type
+std::enable_if_t<(FixedListType::max_size() == 2), bool>
 is_pair()
 {
      return true;
@@ -94,7 +93,7 @@ is_pair()
 
 
 template<class FixedListType>
-typename std::enable_if<(FixedListType::max_size() != 2), std::string>::type
+std::enable_if_t<(FixedListType::max_size() != 2), std::string>
 is_pair()
 {
      return "not really at all";

applications/test/Function1/case1/constant/function1Properties

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/Function1/case1/system/controlDict

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/GAMGAgglomeration/Test-GAMGAgglomeration.C

@@ -92,7 +92,10 @@ int main(int argc, char *argv[])
         {
             fld[celli] = cellToCoarse[celli];
         }
-        fld /= max(fld);
+        if (normalise)
+        {
+            fld /= max(fld);
+        }
         scalarAgglomeration.correctBoundaryConditions();
         scalarAgglomeration.write();
 

applications/test/Hashing1/HashFunction.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021 OpenCFD Ltd.
+    Copyright (C) 2021-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -42,9 +42,11 @@ Note
 #include "Hash.H"
 
 #ifdef FULLDEBUG
-#define HashTypeInfo(Args)  void info() { std::cerr<< "" Args << "\n"; }
+#define HashTypeInfo(Name)  \
+    static constexpr const char* name() noexcept { return Name; } \
+    void info() const { std::cerr<< name() << " hashing\n"; }
 #else
-#define HashTypeInfo(Args)  void info() {}
+#define HashTypeInfo(Name)  void info() const {}
 #endif
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -53,20 +55,36 @@ namespace Foam
 {
 
 /*---------------------------------------------------------------------------*\
-                            Class Hash Declaration
+                          Class HashFunc Declaration
 \*---------------------------------------------------------------------------*/
 
-template<class T, class SFINAEType=bool>
+template<class T>
 struct HashFun
 {
-    #ifdef FULLDEBUG
-    static constexpr const char* name() noexcept { return "default"; }
-    #endif
-    HashTypeInfo("plain hash")
+    void info() const
+    {
+        #ifdef FULLDEBUG
+        if constexpr (std::is_base_of_v<std::string, T>)
+        {
+            std::cerr<< "std::string hashing\n";
+        }
+        else
+        {
+            std::cerr<< "default hashing\n";
+        }
+        #endif
+    }
 
     unsigned operator()(const T& obj, unsigned seed=0) const
     {
-        return Foam::Hasher(&obj, sizeof(obj), seed);
+        if constexpr (std::is_base_of_v<std::string, T>)
+        {
+            return Foam::Hasher(obj.data(), obj.size(), seed);
+        }
+        else
+        {
+            return Foam::Hasher(&obj, sizeof(obj), seed);
+        }
     }
 };
 
@@ -76,45 +94,17 @@ struct HashFun
 //- Hashing for label
 template<> struct HashFun<Foam::label> : Hash<label>
 {
-    #ifdef FULLDEBUG
-    static constexpr const char* name() noexcept { return "label"; }
-    #endif
-    HashTypeInfo("hash label")
+    HashTypeInfo("label")
 };
 
 
 //- Hashing for pointers, interpret pointer as a integer type
 template<> struct HashFun<void*> : Hash<void *>
 {
-    #ifdef FULLDEBUG
-    static constexpr const char* name() noexcept { return "pointer"; }
-    #endif
-    HashTypeInfo("hash ptr")
+    HashTypeInfo("pointer")
 };
 
 
-//- Hashing for string types
-template<class StringType>
-struct HashFun
-<
-    StringType,
-    typename std::enable_if
-    <
-        std::is_base_of<std::string, StringType>::value, bool
-    >::type
->
-{
-    #ifdef FULLDEBUG
-    static constexpr const char* name() noexcept { return "string"; }
-    #endif
-    HashTypeInfo("hash string")
-
-    unsigned operator()(const std::string& obj, unsigned seed=0) const
-    {
-        return Foam::Hasher(obj.data(), obj.size(), seed);
-    }
-};
-
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -133,83 +123,56 @@ namespace Foam
 
 template<> struct HashFun<edge> : Hash<edge>
 {
-    #ifdef FULLDEBUG
-    static constexpr const char* name() noexcept { return "edge"; }
-    #endif
-    HashTypeInfo("hash edge")
+    HashTypeInfo("edge")
 };
 
 
 template<> struct HashFun<face> : Hash<face>
 {
-    #ifdef FULLDEBUG
-    static constexpr const char* name() noexcept { return "face"; }
-    #endif
-    HashTypeInfo("hash face")
+    HashTypeInfo("face")
 };
 
 
 template<> struct HashFun<triFace> : Hash<triFace>
 {
-    #ifdef FULLDEBUG
-    static constexpr const char* name() noexcept { return "triFace"; }
-    #endif
-    HashTypeInfo("hash triFace")
+    HashTypeInfo("triFace")
 };
 
 
 template<class T>
 struct HashFun<Pair<T>> : Hash<Pair<T>>
 {
-    #ifdef FULLDEBUG
-    static constexpr const char* name() noexcept { return "Pair"; }
-    #endif
-    HashTypeInfo("hash Pair")
+    HashTypeInfo("Pair")
 };
 
 template<class T1, class T2>
 struct HashFun<Tuple2<T1, T2>> : Hash<Tuple2<T1, T2>>
 {
-    #ifdef FULLDEBUG
-    static constexpr const char* name() noexcept { return "Tuple2"; }
-    #endif
-    HashTypeInfo("hash Tuple2")
+    HashTypeInfo("Tuple2")
 };
 
 
 template<class T>
 struct HashFun<List<T>> : Hash<List<T>>
 {
-    #ifdef FULLDEBUG
-    static constexpr const char* name() noexcept { return "List"; }
-    #endif
-    HashTypeInfo("hash List")
+    HashTypeInfo("List")
 };
 
 template<class T> struct HashFun<UList<T>> : Hash<UList<T>>
 {
-    #ifdef FULLDEBUG
-    static constexpr const char* name() noexcept { return "UList"; }
-    #endif
-    HashTypeInfo("hash UList")
+    HashTypeInfo("UList")
 };
 
 template<class T, int SizeMin>
 struct HashFun<DynamicList<T, SizeMin>> : Hash<DynamicList<T, SizeMin>>
 {
-    #ifdef FULLDEBUG
-    static constexpr const char* name() noexcept { return "DynamicList"; }
-    #endif
-    HashTypeInfo("hash DynamicList")
+    HashTypeInfo("DynamicList")
 };
 
 template<class T, unsigned N>
 struct HashFun<FixedList<T, N>> : Hash<FixedList<T, N>>
 {
-    #ifdef FULLDEBUG
-    static constexpr const char* name() noexcept { return "FixedList"; }
-    #endif
-    HashTypeInfo("hash FixedList")
+    HashTypeInfo("FixedList")
 };
 
 

applications/test/Hashing2/Test-Hashing2.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -81,7 +81,7 @@ void infoHashString
 
 void reportHashList(const UList<string>& list)
 {
-    Info<< "contiguous = " << is_contiguous<string>::value << nl << nl;
+    Info<< "contiguous = " << is_contiguous_v<string> << nl << nl;
 
     for (const string& val : list)
     {
@@ -94,7 +94,7 @@ void reportHashList(const UList<string>& list)
 
 void reportHashList(const UList<label>& list)
 {
-    Info<<"contiguous = " << is_contiguous<label>::value << nl << nl;
+    Info<<"contiguous = " << is_contiguous_v<label> << nl << nl;
 
     for (const label val : list)
     {
@@ -113,7 +113,7 @@ void reportHashList(const UList<label>& list)
 
 void reportHashList(const UList<face>& list)
 {
-    Info<<"contiguous = " << is_contiguous<label>::value << nl << nl;
+    Info<<"contiguous = " << is_contiguous_v<label> << nl << nl;
 
     for (const face& f : list)
     {
@@ -154,7 +154,7 @@ void reportHashList(const UList<labelList>& list)
 
 void reportHashList(const UList<wordPair>& list)
 {
-    Info<<"contiguous = " << is_contiguous<wordPair>::value << nl << nl;
+    Info<<"contiguous = " << is_contiguous_v<wordPair> << nl << nl;
 
     for (const wordPair& pr : list)
     {
@@ -179,7 +179,7 @@ void reportHashList(const UList<wordPair>& list)
 
 void reportHashList(const UList<labelPair>& list)
 {
-    Info<<"contiguous = " << is_contiguous<labelPair>::value << nl << nl;
+    Info<<"contiguous = " << is_contiguous_v<labelPair> << nl << nl;
 
     for (const labelPair& pr : list)
     {
@@ -200,7 +200,7 @@ void reportHashList(const UList<labelPair>& list)
 
 void reportHashList(const UList<labelPairPair>& list)
 {
-    Info<<"contiguous = " << is_contiguous<labelPairPair>::value << nl << nl;
+    Info<<"contiguous = " << is_contiguous_v<labelPairPair> << nl << nl;
 
     for (const labelPairPair& pr : list)
     {
@@ -221,7 +221,7 @@ void reportHashList(const UList<labelPairPair>& list)
 
 void reportHashList(const UList<edge>& list)
 {
-    Info<<"contiguous = " << is_contiguous<edge>::value << nl << nl;
+    Info<<"contiguous = " << is_contiguous_v<edge> << nl << nl;
 
     for (const edge& e : list)
     {
@@ -242,7 +242,7 @@ void reportHashList(const UList<edge>& list)
 
 void reportHashList(const UList<triFace>& list)
 {
-    Info<<"contiguous = " << is_contiguous<triFace>::value << nl << nl;
+    Info<<"contiguous = " << is_contiguous_v<triFace> << nl << nl;
 
     for (const triFace& f : list)
     {

applications/test/Hashing2/hashingTests

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/IOField/Test-IOField.cxx

@@ -213,11 +213,10 @@ int main(int argc, char *argv[])
             mesh
         );
 
-        Info<< "points path: " << io.typeFilePath<labelIOList>() << nl;
-        Info<< "points path: " << io.typeFilePath<void>() << nl;
+        Info<< "points path: " << io.typeFilePath<pointIOField>() << nl;
 
         io.resetHeader("bad-points");
-        Info<< "bad path: " << io.typeFilePath<void>() << nl;
+        Info<< "bad path: " << io.typeFilePath<labelIOList>() << nl;
     }
 
     IOobject io

applications/test/IOobject-type/Test-IOobject-type.cxx

@@ -45,7 +45,7 @@ using namespace Foam;
 template<class Type>
 word report()
 {
-    if (is_globalIOobject<Type>::value)
+    if constexpr (is_globalIOobject<Type>::value)
     {
         return "global";
     }

applications/test/List/Test-List.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2023 OpenCFD Ltd.
+    Copyright (C) 2017-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -118,7 +118,7 @@ Ostream& printListOutputType(const char* what)
 {
     Info<< what
         << " (contiguous="
-        << is_contiguous<T>::value << " no_linebreak="
+        << is_contiguous_v<T> << " no_linebreak="
         << Detail::ListPolicy::no_linebreak<T>::value
         << " short_length="
         << Detail::ListPolicy::short_length<T>::value << ')';

applications/test/MathFunctions/Test-MathFunctions.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021 OpenCFD Ltd.
+    Copyright (C) 2021-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -128,18 +128,17 @@ void test_member_funcs(Type)
 
 // Do compile-time recursion over the given types
 template<std::size_t I = 0, typename... Tp>
-inline typename std::enable_if<I == sizeof...(Tp), void>::type
-run_tests(const std::tuple<Tp...>& types, const List<word>& typeID){}
-
-
-template<std::size_t I = 0, typename... Tp>
-inline typename std::enable_if<I < sizeof...(Tp), void>::type
-run_tests(const std::tuple<Tp...>& types, const List<word>& typeID)
+void run_tests(const std::tuple<Tp...>& types, const List<word>& names)
 {
-    Info<< nl << "    ## Test member functions: "<< typeID[I] <<" ##" << nl;
-    test_member_funcs(std::get<I>(types));
+    if constexpr (I < sizeof...(Tp))
+    {
+        const auto& name = names[I];
 
-    run_tests<I + 1, Tp...>(types, typeID);
+        Info<< nl << "    ## Test member functions: " << name << " ##" << nl;
+        test_member_funcs(std::get<I>(types));
+
+        run_tests<I + 1, Tp...>(types, names);
+    }
 }
 
 

applications/test/PDRblockMesh/box0/system/PDRblockMeshDict

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/PDRblockMesh/box0/system/controlDict

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/PDRblockMesh/box0/system/fvSchemes

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/PDRblockMesh/box0/system/fvSolution

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/PatchFunction1/function1Properties

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/PtrDictionary1/Make/files

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

applications/test/PtrDictionary1/Test-PtrDictionary1.C

@@ -25,10 +25,10 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Application
-    Test-Dictionary
+    Test-PtrDictionary1
 
 Description
-    Tests for Dictionary (not dictionary)
+    Tests for Dictionary (not dictionary) and PtrDictionary
 
 \*---------------------------------------------------------------------------*/
 
@@ -185,7 +185,7 @@ int main(int argc, char *argv[])
     }
 
     std::cout<< "iter type: "
-        << typeid(stdFoam::begin(scalarDict2)).name() << '\n';
+        << typeid(std::begin(scalarDict2)).name() << '\n';
 
     scalarDict.transfer(scalarDict2);
 

applications/test/SphericalTensor/Test-SphericalTensor.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2020-2022 OpenCFD Ltd.
+    Copyright (C) 2020-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -38,12 +38,11 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
+#include "complex.H"
 #include "Tensor.H"
 #include "SymmTensor.H"
 #include "SphericalTensor.H"
 #include "DiagTensor.H"
-#include "scalar.H"
-#include "complex.H"
 
 using namespace Foam;
 
@@ -57,65 +56,50 @@ unsigned nTest_ = 0;
 unsigned nFail_ = 0;
 
 
-// Compare two floating point types, and print output.
+// Compare two containers elementwise, and print output.
 // Do ++nFail_ if values of two objects are not equal within a given tolerance.
 // The function is converted from PEP-485.
-template<class Type>
-typename std::enable_if<pTraits<Type>::rank == 0, void>::type
-cmp
+template<class Type, class Type2 = Type>
+void cmp
 (
     const word& msg,
     const Type& x,
-    const Type& y,
+    const Type2& y,
     const scalar relTol = 1e-8,  //<! are values the same within 8 decimals
     const scalar absTol = 0      //<! useful for cmps near zero
 )
 {
-    Info<< msg << x << endl;
+    const auto notEqual = [=](const auto& a, const auto& b) -> bool
+    {
+        return
+        (
+            Foam::max(absTol, relTol*Foam::max(Foam::mag(a), Foam::mag(b)))
+          < Foam::mag(a - b)
+        );
+    };
 
     unsigned nFail = 0;
 
-    if (max(absTol, relTol*max(mag(x), mag(y))) < mag(x - y))
+    if constexpr (is_vectorspace_v<Type>)
     {
-        ++nFail;
+        for (direction i = 0; i < pTraits<Type>::nComponents; ++i)
+        {
+            if (notEqual(x[i], y[i]))
+            {
+                ++nFail;
+            }
+        }
     }
-
-    if (nFail)
+    else
     {
-        Info<< nl
-            << "        #### Fail in " << nFail << " comps ####" << nl << endl;
-        ++nFail_;
-    }
-    ++nTest_;
-}
-
-
-// Compare two containers elementwise, and print output.
-// Do ++nFail_ if two components are not equal within a given tolerance.
-// The function is converted from PEP-485
-template<class Type>
-typename std::enable_if<pTraits<Type>::rank != 0, void>::type
-cmp
-(
-    const word& msg,
-    const Type& x,
-    const Type& y,
-    const scalar relTol = 1e-8,
-    const scalar absTol = 0
-)
-{
-    Info<< msg << x << endl;
-
-    unsigned nFail = 0;
-
-    for (direction i = 0; i < pTraits<Type>::nComponents; ++i)
-    {
-        if (max(absTol, relTol*max(mag(x[i]), mag(y[i]))) < mag(x[i] - y[i]))
+        if (notEqual(x, y))
         {
             ++nFail;
         }
     }
 
+    Info<< msg << x << endl;
+
     if (nFail)
     {
         Info<< nl
@@ -277,27 +261,26 @@ void test_global_opers(Type)
 
 // Do compile-time recursion over the given types
 template<std::size_t I = 0, typename... Tp>
-inline typename std::enable_if<I == sizeof...(Tp), void>::type
-run_tests(const std::tuple<Tp...>& types, const List<word>& typeID){}
-
-
-template<std::size_t I = 0, typename... Tp>
-inline typename std::enable_if<I < sizeof...(Tp), void>::type
-run_tests(const std::tuple<Tp...>& types, const List<word>& typeID)
+void run_tests(const std::tuple<Tp...>& types, const List<word>& names)
 {
-    Info<< nl << "    ## Test constructors: "<< typeID[I] <<" ##" << nl;
-    test_constructors(std::get<I>(types));
+    if constexpr (I < sizeof...(Tp))
+    {
+        const auto& name = names[I];
 
-    Info<< nl << "    ## Test member functions: "<< typeID[I] <<" ##" << nl;
-    test_member_funcs(std::get<I>(types));
+        Info<< nl << "    ## Test constructors: " << name << " ##" << nl;
+        test_constructors(std::get<I>(types));
 
-    Info<< nl << "    ## Test global functions: "<< typeID[I] << " ##" << nl;
-    test_global_funcs(std::get<I>(types));
+        Info<< nl << "    ## Test member functions: " << name << " ##" << nl;
+        test_member_funcs(std::get<I>(types));
 
-    Info<< nl << "    ## Test global operators: "<< typeID[I] <<" ##" << nl;
-    test_global_opers(std::get<I>(types));
+        Info<< nl << "    ## Test global functions: " << name << " ##" << nl;
+        test_global_funcs(std::get<I>(types));
 
-    run_tests<I + 1, Tp...>(types, typeID);
+        Info<< nl << "    ## Test global operators: " << name << " ##" << nl;
+        test_global_opers(std::get<I>(types));
+
+        run_tests<I + 1, Tp...>(types, names);
+    }
 }
 
 
@@ -312,8 +295,8 @@ int main()
 
     const List<word> typeID
     ({
-        "SphericalTensor<floatScalar>",
-        "SphericalTensor<doubleScalar>",
+        "SphericalTensor<float>",
+        "SphericalTensor<double>",
         "SphericalTensor<complex>"
     });
 

applications/test/SphericalTensor2D/Test-SphericalTensor2D.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2020-2022 OpenCFD Ltd.
+    Copyright (C) 2020-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -38,11 +38,10 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
+#include "complex.H"
 #include "Tensor2D.H"
 #include "SymmTensor2D.H"
 #include "SphericalTensor2D.H"
-#include "scalar.H"
-#include "complex.H"
 
 using namespace Foam;
 
@@ -56,12 +55,11 @@ unsigned nTest_ = 0;
 unsigned nFail_ = 0;
 
 
-// Compare two floating point types, and print output.
+// Compare two containers elementwise, and print output.
 // Do ++nFail_ if values of two objects are not equal within a given tolerance.
 // The function is converted from PEP-485.
 template<class Type>
-typename std::enable_if<pTraits<Type>::rank == 0, void>::type
-cmp
+void cmp
 (
     const word& msg,
     const Type& x,
@@ -70,51 +68,37 @@ cmp
     const scalar absTol = 0      //<! useful for cmps near zero
 )
 {
-    Info<< msg << x << endl;
+    const auto notEqual = [=](const auto& a, const auto& b) -> bool
+    {
+        return
+        (
+            Foam::max(absTol, relTol*Foam::max(Foam::mag(a), Foam::mag(b)))
+          < Foam::mag(a - b)
+        );
+    };
 
     unsigned nFail = 0;
 
-    if (max(absTol, relTol*max(mag(x), mag(y))) < mag(x - y))
+    if constexpr (is_vectorspace_v<Type>)
     {
-        ++nFail;
+        for (direction i = 0; i < pTraits<Type>::nComponents; ++i)
+        {
+            if (notEqual(x[i], y[i]))
+            {
+                ++nFail;
+            }
+        }
     }
-
-    if (nFail)
+    else
     {
-        Info<< nl
-            << "        #### Fail in " << nFail << " comps ####" << nl << endl;
-        ++nFail_;
-    }
-    ++nTest_;
-}
-
-
-// Compare two containers elementwise, and print output.
-// Do ++nFail_ if two components are not equal within a given tolerance.
-// The function is converted from PEP-485
-template<class Type>
-typename std::enable_if<pTraits<Type>::rank != 0, void>::type
-cmp
-(
-    const word& msg,
-    const Type& x,
-    const Type& y,
-    const scalar relTol = 1e-8,
-    const scalar absTol = 0
-)
-{
-    Info<< msg << x << endl;
-
-    unsigned nFail = 0;
-
-    for (direction i = 0; i < pTraits<Type>::nComponents; ++i)
-    {
-        if (max(absTol, relTol*max(mag(x[i]), mag(y[i]))) < mag(x[i] - y[i]))
+        if (notEqual(x, y))
         {
             ++nFail;
         }
     }
 
+    Info<< msg << x << endl;
+
     if (nFail)
     {
         Info<< nl
@@ -260,27 +244,26 @@ void test_global_opers(Type)
 
 // Do compile-time recursion over the given types
 template<std::size_t I = 0, typename... Tp>
-inline typename std::enable_if<I == sizeof...(Tp), void>::type
-run_tests(const std::tuple<Tp...>& types, const List<word>& typeID){}
-
-
-template<std::size_t I = 0, typename... Tp>
-inline typename std::enable_if<I < sizeof...(Tp), void>::type
-run_tests(const std::tuple<Tp...>& types, const List<word>& typeID)
+void run_tests(const std::tuple<Tp...>& types, const List<word>& names)
 {
-    Info<< nl << "    ## Test constructors: "<< typeID[I] <<" ##" << nl;
-    test_constructors(std::get<I>(types));
+    if constexpr (I < sizeof...(Tp))
+    {
+        const auto& name = names[I];
 
-    Info<< nl << "    ## Test member functions: "<< typeID[I] <<" ##" << nl;
-    test_member_funcs(std::get<I>(types));
+        Info<< nl << "    ## Test constructors: " << name << " ##" << nl;
+        test_constructors(std::get<I>(types));
 
-    Info<< nl << "    ## Test global functions: "<< typeID[I] << " ##" << nl;
-    test_global_funcs(std::get<I>(types));
+        Info<< nl << "    ## Test member functions: " << name << " ##" << nl;
+        test_member_funcs(std::get<I>(types));
 
-    Info<< nl << "    ## Test global operators: "<< typeID[I] <<" ##" << nl;
-    test_global_opers(std::get<I>(types));
+        Info<< nl << "    ## Test global functions: " << name << " ##" << nl;
+        test_global_funcs(std::get<I>(types));
 
-    run_tests<I + 1, Tp...>(types, typeID);
+        Info<< nl << "    ## Test global operators: " << name << " ##" << nl;
+        test_global_opers(std::get<I>(types));
+
+        run_tests<I + 1, Tp...>(types, names);
+     }
 }
 
 
@@ -295,8 +278,8 @@ int main()
 
     const List<word> typeID
     ({
-        "SphericalTensor2D<floatScalar>",
-        "SphericalTensor2D<doubleScalar>",
+        "SphericalTensor2D<float>",
+        "SphericalTensor2D<double>",
         "SphericalTensor2D<complex>"
     });
 

applications/test/SymmTensor/Test-SymmTensor.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2020-2022 OpenCFD Ltd.
+    Copyright (C) 2020-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -40,11 +40,10 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
+#include "complex.H"
 #include "symmTensor.H"
 #include "transform.H"
 #include "Random.H"
-#include "scalar.H"
-#include "complex.H"
 
 using namespace Foam;
 
@@ -69,12 +68,12 @@ symmTensor makeRandomContainer(Random& rnd)
 
 // Create a symmTensor based on a given value
 template<class Type>
-typename std::enable_if
+std::enable_if_t
 <
-    std::is_same<floatScalar, Type>::value ||
-    std::is_same<doubleScalar, Type>::value,
+    std::is_floating_point_v<Type> || std::is_same_v<complex, Type>,
     symmTensor
->::type makeContainer(const Type val)
+>
+makeContainer(const Type val)
 {
     symmTensor T(Zero);
     std::fill(T.begin(), T.end(), val);
@@ -82,12 +81,11 @@ typename std::enable_if
 }
 
 
-// Compare two floating point types, and print output.
+// Compare two containers elementwise, and print output.
 // Do ++nFail_ if values of two objects are not equal within a given tolerance.
 // The function is converted from PEP-485.
 template<class Type>
-typename std::enable_if<pTraits<Type>::rank == 0, void>::type
-cmp
+void cmp
 (
     const word& msg,
     const Type& x,
@@ -96,51 +94,37 @@ cmp
     const scalar relTol = 1e-8  //<! are values the same within 8 decimals
 )
 {
-    Info<< msg << x << "?=" << y << endl;
+    const auto notEqual = [=](const auto& a, const auto& b) -> bool
+    {
+        return
+        (
+            Foam::max(absTol, relTol*Foam::max(Foam::mag(a), Foam::mag(b)))
+          < Foam::mag(a - b)
+        );
+    };
 
     unsigned nFail = 0;
 
-    if (max(absTol, relTol*max(mag(x), mag(y))) < mag(x - y))
+    if constexpr (is_vectorspace_v<Type>)
     {
-        ++nFail;
+        for (direction i = 0; i < pTraits<Type>::nComponents; ++i)
+        {
+            if (notEqual(x[i], y[i]))
+            {
+                ++nFail;
+            }
+        }
     }
-
-    if (nFail)
+    else
     {
-        Info<< nl
-            << "        #### Fail in " << nFail << " comps ####" << nl << endl;
-        ++nFail_;
-    }
-    ++nTest_;
-}
-
-
-// Compare two containers elementwise, and print output.
-// Do ++nFail_ if two components are not equal within a given tolerance.
-// The function is converted from PEP-485
-template<class Type>
-typename std::enable_if<pTraits<Type>::rank != 0, void>::type
-cmp
-(
-    const word& msg,
-    const Type& x,
-    const Type& y,
-    const scalar absTol = 0,
-    const scalar relTol = 1e-8
-)
-{
-    Info<< msg << x << "?=" << y << endl;
-
-    unsigned nFail = 0;
-
-    for (direction i = 0; i < pTraits<Type>::nComponents; ++i)
-    {
-        if (max(absTol, relTol*max(mag(x[i]), mag(y[i]))) < mag(x[i] - y[i]))
+        if (notEqual(x, y))
         {
             ++nFail;
         }
     }
 
+    Info<< msg << x << "?=" << y << endl;
+
     if (nFail)
     {
         Info<< nl
@@ -588,27 +572,26 @@ void test_eigen_funcs(const symmTensor& T)
 
 // Do compile-time recursion over the given types
 template<std::size_t I = 0, typename... Tp>
-inline typename std::enable_if<I == sizeof...(Tp), void>::type
-run_tests(const std::tuple<Tp...>& types, const List<word>& typeID){}
-
-
-template<std::size_t I = 0, typename... Tp>
-inline typename std::enable_if<I < sizeof...(Tp), void>::type
-run_tests(const std::tuple<Tp...>& types, const List<word>& typeID)
+void run_tests(const std::tuple<Tp...>& types, const List<word>& names)
 {
-    Info<< nl << "    ## Test constructors: "<< typeID[I] <<" ##" << nl;
-    test_constructors(std::get<I>(types));
+    if constexpr (I < sizeof...(Tp))
+    {
+        const auto& name = names[I];
 
-    Info<< nl << "    ## Test member functions: "<< typeID[I] <<" ##" << nl;
-    test_member_funcs(std::get<I>(types));
+        Info<< nl << "    ## Test constructors: " << name << " ##" << nl;
+        test_constructors(std::get<I>(types));
 
-    Info<< nl << "    ## Test global functions: "<< typeID[I] << " ##" << nl;
-    test_global_funcs(std::get<I>(types));
+        Info<< nl << "    ## Test member functions: " << name << " ##" << nl;
+        test_member_funcs(std::get<I>(types));
 
-    Info<< nl << "    ## Test global operators: "<< typeID[I] <<" ##" << nl;
-    test_global_opers(std::get<I>(types));
+        Info<< nl << "    ## Test global functions: " << name << " ##" << nl;
+        test_global_funcs(std::get<I>(types));
 
-    run_tests<I + 1, Tp...>(types, typeID);
+        Info<< nl << "    ## Test global operators: " << name << " ##" << nl;
+        test_global_opers(std::get<I>(types));
+
+        run_tests<I + 1, Tp...>(types, names);
+    }
 }
 
 
@@ -623,8 +606,8 @@ int main()
 
     const List<word> typeID
     ({
-        "SymmTensor<floatScalar>",
-        "SymmTensor<doubleScalar>",
+        "SymmTensor<float>",
+        "SymmTensor<double>",
         "SymmTensor<complex>"
     });
 

applications/test/SymmTensor2D/Test-SymmTensor2D.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2019-2022 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -40,11 +40,10 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
+#include "complex.H"
 #include "symmTensor2D.H"
 #include "transform.H"
 #include "Random.H"
-#include "scalar.H"
-#include "complex.H"
 
 using namespace Foam;
 
@@ -67,45 +66,11 @@ symmTensor2D makeRandomContainer(Random& rnd)
 }
 
 
-// Compare two floating point types, and print output.
-// Do ++nFail_ if values of two objects are not equal within a given tolerance.
-// The function is converted from PEP-485.
-template<class Type>
-typename std::enable_if<pTraits<Type>::rank == 0, void>::type
-cmp
-(
-    const word& msg,
-    const Type& x,
-    const Type& y,
-    const scalar absTol = 0,     //<! useful for cmps near zero
-    const scalar relTol = 1e-8   //<! are values the same within 8 decimals
-)
-{
-    Info<< msg << x << "?=" << y << endl;
-
-    unsigned nFail = 0;
-
-    if (max(absTol, relTol*max(mag(x), mag(y))) < mag(x - y))
-    {
-        ++nFail;
-    }
-
-    if (nFail)
-    {
-        Info<< nl
-            << "        #### Fail in " << nFail << " comps ####" << nl << endl;
-        ++nFail_;
-    }
-    ++nTest_;
-}
-
-
 // Compare two containers elementwise, and print output.
 // Do ++nFail_ if two components are not equal within a given tolerance.
 // The function is converted from PEP-485
 template<class Type>
-typename std::enable_if<pTraits<Type>::rank != 0, void>::type
-cmp
+void cmp
 (
     const word& msg,
     const Type& x,
@@ -114,18 +79,37 @@ cmp
     const scalar relTol = 1e-8
 )
 {
-    Info<< msg << x << "?=" << y << endl;
+    const auto notEqual = [=](const auto& a, const auto& b) -> bool
+    {
+        return
+        (
+            Foam::max(absTol, relTol*Foam::max(Foam::mag(a), Foam::mag(b)))
+          < Foam::mag(a - b)
+        );
+    };
 
     unsigned nFail = 0;
 
-    for (direction i = 0; i < pTraits<Type>::nComponents; ++i)
+    if constexpr (is_vectorspace_v<Type>)
     {
-        if (max(absTol, relTol*max(mag(x[i]), mag(y[i]))) < mag(x[i] - y[i]))
+        for (direction i = 0; i < pTraits<Type>::nComponents; ++i)
+        {
+            if (notEqual(x[i], y[i]))
+            {
+                ++nFail;
+            }
+        }
+    }
+    else
+    {
+        if (notEqual(x, y))
         {
             ++nFail;
         }
     }
 
+    Info<< msg << x << "?=" << y << endl;
+
     if (nFail)
     {
         Info<< nl
@@ -538,27 +522,26 @@ void test_eigen_funcs(const symmTensor2D& T)
 
 // Do compile-time recursion over the given types
 template<std::size_t I = 0, typename... Tp>
-inline typename std::enable_if<I == sizeof...(Tp), void>::type
-run_tests(const std::tuple<Tp...>& types, const List<word>& typeID){}
-
-
-template<std::size_t I = 0, typename... Tp>
-inline typename std::enable_if<I < sizeof...(Tp), void>::type
-run_tests(const std::tuple<Tp...>& types, const List<word>& typeID)
+void run_tests(const std::tuple<Tp...>& types, const List<word>& names)
 {
-    Info<< nl << "    ## Test constructors: "<< typeID[I] <<" ##" << nl;
-    test_constructors(std::get<I>(types));
+    if constexpr (I < sizeof...(Tp))
+    {
+        const auto& name = names[I];
 
-    Info<< nl << "    ## Test member functions: "<< typeID[I] <<" ##" << nl;
-    test_member_funcs(std::get<I>(types));
+        Info<< nl << "    ## Test constructors: " << name << " ##" << nl;
+        test_constructors(std::get<I>(types));
 
-    Info<< nl << "    ## Test global functions: "<< typeID[I] << " ##" << nl;
-    test_global_funcs(std::get<I>(types));
+        Info<< nl << "    ## Test member functions: " << name << " ##" << nl;
+        test_member_funcs(std::get<I>(types));
 
-    Info<< nl << "    ## Test global operators: "<< typeID[I] <<" ##" << nl;
-    test_global_opers(std::get<I>(types));
+        Info<< nl << "    ## Test global functions: " << name << " ##" << nl;
+        test_global_funcs(std::get<I>(types));
 
-    run_tests<I + 1, Tp...>(types, typeID);
+        Info<< nl << "    ## Test global operators: " << name << " ##" << nl;
+        test_global_opers(std::get<I>(types));
+
+        run_tests<I + 1, Tp...>(types, names);
+    }
 }
 
 
@@ -573,8 +556,8 @@ int main(int argc, char *argv[])
 
     const List<word> typeID
     ({
-        "SymmTensor2D<floatScalar>",
-        "SymmTensor2D<doubleScalar>",
+        "SymmTensor2D<float>",
+        "SymmTensor2D<double>",
         "SymmTensor2D<complex>"
     });
 

applications/test/Tensor/Test-Tensor.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2018 OpenFOAM Foundation
-    Copyright (C) 2019-2020 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -41,11 +41,10 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
+#include "complex.H"
 #include "tensor.H"
 #include "transform.H"
 #include "Random.H"
-#include "scalar.H"
-#include "complex.H"
 
 using namespace Foam;
 
@@ -68,45 +67,11 @@ tensor makeRandomContainer(Random& rnd)
 }
 
 
-// Compare two floating point types, and print output.
-// Do ++nFail_ if values of two objects are not equal within a given tolerance.
-// The function is converted from PEP-485.
-template<class Type>
-typename std::enable_if<pTraits<Type>::rank == 0, void>::type
-cmp
-(
-    const word& msg,
-    const Type& x,
-    const Type& y,
-    const scalar absTol = 0,     //<! useful for cmps near zero
-    const scalar relTol = 1e-8   //<! are values the same within 8 decimals
-)
-{
-    Info<< msg << x << "?=" << y << endl;
-
-    unsigned nFail = 0;
-
-    if (max(absTol, relTol*max(mag(x), mag(y))) < mag(x - y))
-    {
-        ++nFail;
-    }
-
-    if (nFail)
-    {
-        Info<< nl
-            << "        #### Fail in " << nFail << " comps ####" << nl << endl;
-        ++nFail_;
-    }
-    ++nTest_;
-}
-
-
 // Compare two containers elementwise, and print output.
 // Do ++nFail_ if two components are not equal within a given tolerance.
 // The function is converted from PEP-485
 template<class Type>
-typename std::enable_if<pTraits<Type>::rank != 0, void>::type
-cmp
+void cmp
 (
     const word& msg,
     const Type& x,
@@ -115,18 +80,37 @@ cmp
     const scalar relTol = 1e-8
 )
 {
-    Info<< msg << x << "?=" << y << endl;
+    const auto notEqual = [=](const auto& a, const auto& b) -> bool
+    {
+        return
+        (
+            Foam::max(absTol, relTol*Foam::max(Foam::mag(a), Foam::mag(b)))
+          < Foam::mag(a - b)
+        );
+    };
 
     unsigned nFail = 0;
 
-    for (direction i = 0; i < pTraits<Type>::nComponents; ++i)
+    if constexpr (is_vectorspace_v<Type>)
     {
-        if (max(absTol, relTol*max(mag(x[i]), mag(y[i]))) < mag(x[i] - y[i]))
+        for (direction i = 0; i < pTraits<Type>::nComponents; ++i)
+        {
+            if (notEqual(x[i], y[i]))
+            {
+                ++nFail;
+            }
+        }
+    }
+    else
+    {
+        if (notEqual(x, y))
         {
             ++nFail;
         }
     }
 
+    Info<< msg << x << "?=" << y << endl;
+
     if (nFail)
     {
         Info<< nl
@@ -987,27 +971,26 @@ void test_eigen_funcs(const tensor& T, const bool prod = true)
 
 // Do compile-time recursion over the given types
 template<std::size_t I = 0, typename... Tp>
-inline typename std::enable_if<I == sizeof...(Tp), void>::type
-run_tests(const std::tuple<Tp...>& types, const List<word>& typeID){}
-
-
-template<std::size_t I = 0, typename... Tp>
-inline typename std::enable_if<I < sizeof...(Tp), void>::type
-run_tests(const std::tuple<Tp...>& types, const List<word>& typeID)
+void run_tests(const std::tuple<Tp...>& types, const List<word>& names)
 {
-    Info<< nl << "    ## Test constructors: "<< typeID[I] <<" ##" << nl;
-    test_constructors(std::get<I>(types));
+    if constexpr (I < sizeof...(Tp))
+    {
+        const auto& name = names;
 
-    Info<< nl << "    ## Test member functions: "<< typeID[I] <<" ##" << nl;
-    test_member_funcs(std::get<I>(types));
+        Info<< nl << "    ## Test constructors: " << name << " ##" << nl;
+        test_constructors(std::get<I>(types));
 
-    Info<< nl << "    ## Test global functions: "<< typeID[I] << " ##" << nl;
-    test_global_funcs(std::get<I>(types));
+        Info<< nl << "    ## Test member functions: " << name << " ##" << nl;
+        test_member_funcs(std::get<I>(types));
 
-    Info<< nl << "    ## Test global operators: "<< typeID[I] <<" ##" << nl;
-    test_global_opers(std::get<I>(types));
+        Info<< nl << "    ## Test global functions: " << name <<" ##" << nl;
+        test_global_funcs(std::get<I>(types));
 
-    run_tests<I + 1, Tp...>(types, typeID);
+        Info<< nl << "    ## Test global operators: " << name <<" ##" << nl;
+        test_global_opers(std::get<I>(types));
+
+        run_tests<I + 1, Tp...>(types, names);
+    }
 }
 
 
@@ -1022,8 +1005,8 @@ int main()
 
     const List<word> typeID
     ({
-        "Tensor<floatScalar>",
-        "Tensor<doubleScalar>",
+        "Tensor<float>",
+        "Tensor<double>",
         "Tensor<complex>"
     });
 

applications/test/Tensor2D/Test-Tensor2D.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2014 OpenFOAM Foundation
-    Copyright (C) 2019-2022 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -41,13 +41,13 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
+#include "scalar.H"
+#include "complex.H"
 #include "vector2DField.H"
 #include "tensor2D.H"
 #include "symmTensor2D.H"
 #include "transform.H"
 #include "Random.H"
-#include "scalar.H"
-#include "complex.H"
 
 using namespace Foam;
 
@@ -70,12 +70,11 @@ tensor2D makeRandomContainer(Random& rnd)
 }
 
 
-// Compare two floating point types, and print output.
-// Do ++nFail_ if values of two objects are not equal within a given tolerance.
-// The function is converted from PEP-485.
+// Compare two containers elementwise, and print output.
+// Do ++nFail_ if two components are not equal within a given tolerance.
+// The function is converted from PEP-485
 template<class Type>
-typename std::enable_if<pTraits<Type>::rank == 0, void>::type
-cmp
+void cmp
 (
     const word& msg,
     const Type& x,
@@ -84,51 +83,37 @@ cmp
     const scalar relTol = 1e-8   //<! are values the same within 8 decimals
 )
 {
-    Info<< msg << x << "?=" << y << endl;
+    const auto notEqual = [=](const auto& a, const auto& b) -> bool
+    {
+        return
+        (
+            Foam::max(absTol, relTol*Foam::max(Foam::mag(a), Foam::mag(b)))
+          < Foam::mag(a - b)
+        );
+    };
 
     unsigned nFail = 0;
 
-    if (max(absTol, relTol*max(mag(x), mag(y))) < mag(x - y))
+    if constexpr (is_vectorspace_v<Type>)
     {
-        ++nFail;
+        for (direction i = 0; i < pTraits<Type>::nComponents; ++i)
+        {
+            if (notEqual(x[i], y[i]))
+            {
+                ++nFail;
+            }
+        }
     }
-
-    if (nFail)
+    else
     {
-        Info<< nl
-            << "        #### Fail in " << nFail << " comps ####" << nl << endl;
-        ++nFail_;
-    }
-    ++nTest_;
-}
-
-
-// Compare two containers elementwise, and print output.
-// Do ++nFail_ if two components are not equal within a given tolerance.
-// The function is converted from PEP-485
-template<class Type>
-typename std::enable_if<pTraits<Type>::rank != 0, void>::type
-cmp
-(
-    const word& msg,
-    const Type& x,
-    const Type& y,
-    const scalar absTol = 0,
-    const scalar relTol = 1e-8
-)
-{
-    Info<< msg << x << "?=" << y << endl;
-
-    unsigned nFail = 0;
-
-    for (direction i = 0; i < pTraits<Type>::nComponents; ++i)
-    {
-        if (max(absTol, relTol*max(mag(x[i]), mag(y[i]))) < mag(x[i] - y[i]))
+        if (notEqual(x, y))
         {
             ++nFail;
         }
     }
 
+    Info<< msg << x << "?=" << y << endl;
+
     if (nFail)
     {
         Info<< nl
@@ -795,27 +780,26 @@ void test_eigen_funcs(const tensor2D& T)
 
 // Do compile-time recursion over the given types
 template<std::size_t I = 0, typename... Tp>
-inline typename std::enable_if<I == sizeof...(Tp), void>::type
-run_tests(const std::tuple<Tp...>& types, const List<word>& typeID){}
-
-
-template<std::size_t I = 0, typename... Tp>
-inline typename std::enable_if<I < sizeof...(Tp), void>::type
-run_tests(const std::tuple<Tp...>& types, const List<word>& typeID)
+void run_tests(const std::tuple<Tp...>& types, const List<word>& names)
 {
-    Info<< nl << "    ## Test constructors: "<< typeID[I] <<" ##" << nl;
-    test_constructors(std::get<I>(types));
+    if constexpr (I < sizeof...(Tp))
+    {
+        const auto& name = names[I];
 
-    Info<< nl << "    ## Test member functions: "<< typeID[I] <<" ##" << nl;
-    test_member_funcs(std::get<I>(types));
+        Info<< nl << "    ## Test constructors: " << name << " ##" << nl;
+        test_constructors(std::get<I>(types));
 
-    Info<< nl << "    ## Test global functions: "<< typeID[I] << " ##" << nl;
-    test_global_funcs(std::get<I>(types));
+        Info<< nl << "    ## Test member functions: " << name << " ##" << nl;
+        test_member_funcs(std::get<I>(types));
 
-    Info<< nl << "    ## Test global operators: "<< typeID[I] <<" ##" << nl;
-    test_global_opers(std::get<I>(types));
+        Info<< nl << "    ## Test global functions: " << name << " ##" << nl;
+        test_global_funcs(std::get<I>(types));
 
-    run_tests<I + 1, Tp...>(types, typeID);
+        Info<< nl << "    ## Test global operators: " << name << " ##" << nl;
+        test_global_opers(std::get<I>(types));
+
+        run_tests<I + 1, Tp...>(types, names);
+    }
 }
 
 
@@ -831,8 +815,8 @@ int main(int argc, char *argv[])
 
     const List<word> typeID
     ({
-        "Tensor2D<floatScalar>",
-        "Tensor2D<doubleScalar>",
+        "Tensor2D<float>",
+        "Tensor2D<double>",
         "Tensor2D<complex>"
     });
 

applications/test/TestTools/TestTools.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2020-2022 OpenCFD Ltd.
+    Copyright (C) 2020-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -67,13 +67,9 @@ doubleScalar getTol(complex)
 }
 
 
-// Create a non-complex random Matrix.
+// Create a random Matrix (real or complex)
 template<class MatrixType>
-typename std::enable_if
-<
-    !std::is_same<complex, typename MatrixType::cmptType>:: value,
-    MatrixType
->::type makeRandomMatrix
+MatrixType makeRandomMatrix
 (
     const labelPair& dims,
     Random& rndGen
@@ -81,34 +77,22 @@ typename std::enable_if
 {
     MatrixType mat(dims);
 
-    std::generate
-    (
-        mat.begin(),
-        mat.end(),
-        [&]{return rndGen.GaussNormal<scalar>();}
-    );
-
-    return mat;
-}
-
-
-// Create a complex random Matrix.
-template<class MatrixType>
-typename std::enable_if
-<
-    std::is_same<complex, typename MatrixType::cmptType>:: value,
-    MatrixType
->::type makeRandomMatrix
-(
-    const labelPair& dims,
-    Random& rndGen
-)
-{
-    MatrixType mat(dims);
-
-    for (auto& x : mat)
+    if constexpr (std::is_same_v<complex, typename MatrixType::cmptType>)
     {
-        x = complex(rndGen.GaussNormal<scalar>(), rndGen.GaussNormal<scalar>());
+        for (auto& x : mat)
+        {
+            x.real(rndGen.GaussNormal<scalar>());
+            x.imag(rndGen.GaussNormal<scalar>());
+        }
+    }
+    else
+    {
+        std::generate
+        (
+            mat.begin(),
+            mat.end(),
+            [&]{ return rndGen.GaussNormal<scalar>(); }
+        );
     }
 
     return mat;
@@ -179,128 +163,57 @@ List<Type> flt
 }
 
 
-// Compare two floating point types, and print output.
+// Compare two values or two containers (elementwise), and print output.
 // Do ++nFail_ if values of two objects are not equal within a given tolerance.
 // The function is converted from PEP-485.
-template<class Type>
-typename std::enable_if
-<
-    std::is_same<floatScalar, Type>::value ||
-    std::is_same<doubleScalar, Type>::value ||
-    std::is_same<complex, Type>::value,
-    void
->::type cmp
+template<class Type1, class Type2 = Type1>
+void cmp
 (
     const word& msg,
-    const Type& x,
-    const Type& y,
+    const Type1& x,
+    const Type2& y,
     const scalar absTol = 0,    //<! useful for cmps near zero
     const scalar relTol = 1e-8, //<! are values the same within 8 decimals
     const bool verbose = false
 )
 {
-    if (verbose)
+    const auto notEqual = [=](const auto& a, const auto& b) -> bool
     {
-        Info<< msg << x << "?=" << y << endl;
-    }
+        return
+        (
+            Foam::max(absTol, relTol*Foam::max(Foam::mag(a), Foam::mag(b)))
+          < Foam::mag(a - b)
+        );
+    };
 
     unsigned nFail = 0;
 
-    if (max(absTol, relTol*max(mag(x), mag(y))) < mag(x - y))
+    if constexpr
+    (
+        std::is_floating_point_v<Type1> || std::is_same_v<complex, Type1>
+    )
     {
-        ++nFail;
-    }
-
-    if (nFail)
-    {
-        Info<< nl
-            << "        #### Fail in " << nFail << " comps ####" << nl << endl;
-        ++nFail_;
-    }
-    ++nTest_;
-}
-
-
-// Compare two containers elementwise, and print output.
-// Do ++nFail_ if two components are not equal within a given tolerance.
-// The function is converted from PEP-485
-template<class Type>
-typename std::enable_if
-<
-    !std::is_same<floatScalar, Type>::value &&
-    !std::is_same<doubleScalar, Type>::value &&
-    !std::is_same<complex, Type>::value,
-    void
->::type cmp
-(
-    const word& msg,
-    const Type& x,
-    const Type& y,
-    const scalar absTol = 0,
-    const scalar relTol = 1e-8,
-    const bool verbose = false
-)
-{
-    if (verbose)
-    {
-        Info<< msg << x << "?=" << y << endl;
-    }
-
-    unsigned nFail = 0;
-
-    for (label i = 0; i < x.size(); ++i)
-    {
-        if (max(absTol, relTol*max(mag(x[i]), mag(y[i]))) < mag(x[i] - y[i]))
+        if (notEqual(x, y))
         {
             ++nFail;
         }
     }
-
-    if (nFail)
+    else
     {
-        Info<< nl
-            << "        #### Fail in " << nFail << " comps ####" << nl << endl;
-        ++nFail_;
+        for (label i = 0; i < x.size(); ++i)
+        {
+            if (notEqual(x[i], y[i]))
+            {
+                ++nFail;
+            }
+        }
     }
-    ++nTest_;
-}
 
-
-// Compare two containers elementwise, and print output.
-// Do ++nFail_ if two components are not equal within a given tolerance.
-// The function is converted from PEP-485
-template<class Type1, class Type2>
-typename std::enable_if
-<
-    !std::is_same<floatScalar, Type1>::value &&
-    !std::is_same<doubleScalar, Type1>::value &&
-    !std::is_same<complex, Type1>::value,
-    void
->::type cmp
-(
-    const word& msg,
-    const Type1& x,
-    const Type2& y,
-    const scalar absTol = 0,
-    const scalar relTol = 1e-8,
-    const bool verbose = false
-)
-{
     if (verbose)
     {
         Info<< msg << x << "?=" << y << endl;
     }
 
-    unsigned nFail = 0;
-
-    for (label i = 0; i < x.size(); ++i)
-    {
-        if (max(absTol, relTol*max(mag(x[i]), mag(y[i]))) < mag(x[i] - y[i]))
-        {
-            ++nFail;
-        }
-    }
-
     if (nFail)
     {
         Info<< nl
@@ -321,11 +234,6 @@ void cmp
     const bool verbose = false
 )
 {
-    if (verbose)
-    {
-        Info<< msg << x << "?=" << y << endl;
-    }
-
     unsigned nFail = 0;
 
     if (x != y)
@@ -333,6 +241,11 @@ void cmp
         ++nFail;
     }
 
+    if (verbose)
+    {
+        Info<< msg << x << "?=" << y << endl;
+    }
+
     if (nFail)
     {
         Info<< nl

applications/test/Tuple2/Make/files

@@ -1,3 +1,3 @@
-Test-Tuple2.C
+Test-Tuple2.cxx
 
 EXE = $(FOAM_USER_APPBIN)/Test-Tuple2

applications/test/Tuple2/Test-Tuple2.cxx

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
-    Copyright (C) 2019-2020 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -32,6 +32,7 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
+#include "argList.H"
 #include "labelPair.H"
 #include "Tuple2.H"
 #include "label.H"
@@ -102,8 +103,12 @@ void printTuple2(const Pair<word>& t)
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 // Main program:
 
-int main()
+int main(int argc, char *argv[])
 {
+    argList::noCheckProcessorDirectories();
+
+    #include "setRootCase.H"
+
     typedef Tuple2<label, scalar> indexedScalar;
 
     Info<< "Default constructed Tuple: " << indexedScalar() << nl;

applications/test/UPstreamTraits/Make/files

@@ -0,0 +1,3 @@
+Test-UPstreamTraits.cxx
+
+EXE = $(FOAM_USER_APPBIN)/Test-UPstreamTraits

applications/test/UPstreamTraits/Make/options

@@ -0,0 +1,2 @@
+/* EXE_INC = */
+/* EXE_LIBS = */

applications/test/UPstreamTraits/Test-UPstreamTraits.cxx

@@ -0,0 +1,267 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2025 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Description
+    Simple compilation tests and access for UPstream types
+
+\*---------------------------------------------------------------------------*/
+
+#include "pTraits.H"
+#include "contiguous.H"
+#include "FixedList.H"
+#include "boolVector.H"  // A FixedList pretending to be a vector
+#include "barycentric.H"
+#include "complex.H"
+#include "vector.H"
+#include "tensor.H"
+#include "uLabel.H"
+#include "Switch.H"
+#include "IOstreams.H"
+#include "UPstream.H"
+
+#include <type_traits>
+
+using namespace Foam;
+
+// Just for debugging
+const List<std::string> dataType_names
+({
+    "byte",
+    "int32",
+    "int64",
+    "uint32",
+    "uint64",
+    "float",
+    "double",
+    "long_double",
+
+    "float(2)",
+    "double(2)",
+    "float(3)",
+    "double(3)",
+    "float(6)",
+    "double(6)",
+    "float(9)",
+    "double(9)"
+});
+
+//- Test for pTraits typeName member : default is false
+template<class T, class = void>
+struct check_has_typeName : std::false_type {};
+
+//- Test for pTraits zero
+template<class T>
+struct check_has_typeName
+<
+    T,
+    std::void_t<decltype(pTraits<std::remove_cv_t<T>>::typeName)>
+>
+:
+    std::true_type
+{};
+
+
+// Possible future change...
+// //- A supported UPstream data type (intrinsic or user-defined)
+// template<>
+// struct UPstream_base_dataType<complex> : std::true_type
+// {
+//     static constexpr auto datatype_id = []()
+//     {
+//         if constexpr (sizeof(complex) == 2*sizeof(float))
+//             return UPstream::dataTypes::type_2float;
+//         else
+//             return UPstream::dataTypes::type_2double;
+//     }();
+// };
+
+
+template<class T>
+void printTypeName(const bool showSize = false)
+{
+    // Both float and double have pTraits typeName = "scalar"!
+    if constexpr (std::is_same_v<float, std::remove_cv_t<T>>)
+    {
+        Info<< "<float>";
+    }
+    else if constexpr (std::is_same_v<double, std::remove_cv_t<T>>)
+    {
+        Info<< "<double>";
+    }
+    else if constexpr (check_has_typeName<T>::value)
+    {
+        Info<< pTraits<std::remove_cv_t<T>>::typeName;
+    }
+    else
+    {
+        Info<< typeid(T).name();
+    }
+    if (showSize)
+    {
+        Info<< " (" << sizeof(T) << " bytes)";
+    }
+}
+
+template<class Type, bool UseTypeName = true>
+void printPstreamTraits(const std::string_view name = std::string_view())
+{
+    Info<< "========" << nl;
+    Info<< "type: ";
+    if (!name.empty())
+    {
+        Info<< name << ' ';
+    }
+    if constexpr (UseTypeName)
+    {
+        printTypeName<Type>(true);
+    }
+    else
+    {
+        Info<< typeid(Type).name();
+        Info<< " (" << sizeof(Type) << " bytes)";
+    }
+
+    Info<< ", cmpt:";
+    printTypeName<typename Foam::pTraits_cmptType<Type>::type>(true);
+
+    Info<< nl
+        << "  is_contiguous:"
+        << is_contiguous<Type>::value
+        << ", is base:"
+        << UPstream_base_dataType<Type>::value
+        << ", is cmpt:"
+        << UPstream_dataType<Type>::value << nl;
+
+    Info<< "is base:"
+        << UPstream_base_dataType<Type>::value
+        << " (type:" << int(UPstream_base_dataType<Type>::datatype_id)
+        << ")  is alias:" << UPstream_alias_dataType<Type>::value
+        << " (type:" << int(UPstream_alias_dataType<Type>::datatype_id)
+        << ")" << nl;
+
+
+    {
+        int index = int(UPstream_base_dataType<Type>::datatype_id);
+        Info<< "datatype: " << index;
+
+        if (index < dataType_names.size())
+        {
+            Info<< ' ' << dataType_names[index];
+        }
+        Info<< nl;
+    }
+
+    {
+        // Use element or component type (or byte-wise) for data type
+        using base = typename UPstream_dataType<Type>::base;
+        constexpr auto datatype = UPstream_dataType<Type>::datatype_id;
+
+        Info<< "datatype => ";
+        printTypeName<base>();
+        Info<< " (" << sizeof(Type)/sizeof(base) << " elems)" << nl
+            << "datatype: " << static_cast<int>(datatype) << nl;
+    }
+}
+
+
+template<class BinaryOp>
+void printOpCodeTraits(BinaryOp bop, std::string_view name)
+{
+    Info<< "op: " << name << ' ';
+    if constexpr (UPstream_opType<BinaryOp>::value)
+    {
+        Info<< "supported";
+    }
+    else
+    {
+        Info<< "unknown";
+    }
+    Info<< ": " << int(UPstream_opType<BinaryOp>::opcode_id) << nl;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Main program:
+
+int main()
+{
+    printPstreamTraits<bool>();
+    printPstreamTraits<label>();
+
+    printPstreamTraits<int>("<int>");
+    printPstreamTraits<long>("<long>");
+    printPstreamTraits<unsigned>("<unsigned>");
+    printPstreamTraits<unsigned int>("<unsigned int>");
+    printPstreamTraits<unsigned long>("<long long>");
+
+    printPstreamTraits<const float>();
+    printPstreamTraits<floatVector>();
+
+    printPstreamTraits<scalar>();
+    printPstreamTraits<double>();
+    printPstreamTraits<doubleVector>();
+
+    // Avoid typeName for barycentric. It is declared, but not defined
+    printPstreamTraits<barycentric, false>("barycentric");
+
+    printPstreamTraits<complex>();     // Uses specialized pTraits_...
+
+    printPstreamTraits<boolVector>();  // Uses specialized pTraits_...
+    printPstreamTraits<floatVector>();
+    printPstreamTraits<doubleVector>();
+    printPstreamTraits<tensor>();
+    printPstreamTraits<word>();
+    printPstreamTraits<std::string>();
+
+    // This will not identify properly at the moment...
+    printPstreamTraits<FixedList<doubleVector, 4>>();
+    printPstreamTraits<labelPair>();
+
+    Info<< nl
+        << "========" << nl
+        << "Mapping of binary reduction ops" << nl;
+
+    printOpCodeTraits(minOp<scalar>{}, "min");
+    printOpCodeTraits(maxOp<vector>{}, "max");
+    printOpCodeTraits(sumOp<vector>{}, "sum");
+    printOpCodeTraits(plusOp<vector>{}, "plus");
+    printOpCodeTraits(multiplyOp<scalar>{}, "multiply");
+    printOpCodeTraits(divideOp<vector>{}, "divide");
+    printOpCodeTraits(minMagSqrOp<vector>{}, "minMagSqr");
+
+    printOpCodeTraits(bitAndOp<vector>{}, "bitAnd<vector>");
+    printOpCodeTraits(bitOrOp<vector>{}, "bitOr<vector>");
+
+    printOpCodeTraits(bitOrOp<float>{}, "bitOr<float>");
+    printOpCodeTraits(bitAndOp<unsigned>{}, "bitAnd<unsigned>");
+    printOpCodeTraits(bitOrOp<unsigned>{}, "bitOr<unsigned>");
+
+    Info<< nl << "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/test/argList/Test-argList.C

@@ -123,15 +123,12 @@ int main(int argc, char *argv[])
     argList::addDryRunOption("Just for testing");
     argList::addVerboseOption("Increase verbosity");
 
-    // Check -verbose before initialisation
-    UPstream::debug = argList::verbose(argc, argv);
-
     #include "setRootCase.H"
 
     Pout<< "command-line ("
         << args.options().size() << " options, "
         << args.args().size() << " args)" << nl
-        << "    " << args.commandLine().c_str() << nl << nl;
+        << "    " << args.commandLine().data() << nl << nl;
 
     Pout<< "rootPath:   " << args.rootPath() << nl
         << "globalCase: " << args.globalCaseName() << nl

applications/test/boolVector/Test-boolVector.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2020-2022 OpenCFD Ltd.
+    Copyright (C) 2020-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -54,7 +54,7 @@ int main(int argc, char *argv[])
 {
     Info<< "boolVector" << nl
         << "  size = " << boolVector::size() << nl
-        << "  contiguous = " << is_contiguous<boolVector>::value << nl
+        << "  contiguous = " << is_contiguous_v<boolVector> << nl
         << nl;
 
     {

applications/test/codeStream/codeStreamDict1

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/compoundToken1/testDict1

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/compoundToken1/testDict2

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/contiguous/Test-contiguous.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2019 OpenCFD Ltd.
+    Copyright (C) 2018-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -72,13 +72,14 @@ void printInfo(const char* const name = nullptr)
         Info<< name;
     }
 
-    Info<< " contiguous=" <<  Switch(is_contiguous<T>::value);
+    Info<< " contiguous=" <<  Switch(is_contiguous<T>::value)
+        << " / " <<  Switch(is_contiguous_v<T>);
 
-    if (is_contiguous_label<T>::value)
+    if constexpr (is_contiguous_label<T>::value)
     {
         Info<< " label";
     }
-    if (is_contiguous_scalar<T>::value)
+    if constexpr (is_contiguous_scalar<T>::value)
     {
         Info<< " scalar";
     }
@@ -96,10 +97,11 @@ int main(int argc, char *argv[])
     argList::noParallel();
     argList::noFunctionObjects();
 
+    printInfo<label>();
     printInfo<label>();
     printInfo<double>();
     printInfo<FixedList<double, 4>>();
-    printInfo<Pair<long>>();
+    printInfo<const Pair<long>>();
 
     printInfo<FixedList<word, 2>>();
     printInfo<Pair<word>>();

applications/test/coordinateSystem/testCase0/constant/coordinateSystems

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/coordinateSystem/testCase0/system/controlDict

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/coordinateSystem/testCase1/constant/coordinateSystems

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/coordinateSystem/testCase1/system/controlDict

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/coordinateSystem/testCsys1

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/coordinateSystem/testCsys2

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/dictionary/blockMeshDict1.calc

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/dictionary/blockMeshDict1.eval

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/dictionary/testDict

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/dictionary/testDict2

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/dictionary/testDictAPI

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/dictionary/testDictCalc1

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/dictionary/testDictEval1

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/dictionary/testDictEval2

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/dictionary/testDictEval3

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/dictionary/testDictEval4

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/dictionary/testDictEval5

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/dictionary/testDictList

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/dictionary/testDictRegex

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/dictionary/testPrimitiveEntry

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/dictionary/testSubkeyword

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/dictionaryCopy/testDictCopy

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/exprEntry/testDict1

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/exprValue1/Test-exprValue1.cxx

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021-2023 OpenCFD Ltd.
+    Copyright (C) 2021-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
@@ -21,6 +21,8 @@ Description
 #include "argList.H"
 #include "IOstreams.H"
 #include "ITstream.H"
+#include "OTstream.H"
+#include "SpanStream.H"
 #include "exprValue.H"
 #include "Pstream.H"
 
@@ -34,6 +36,41 @@ void printInfo(const expressions::exprValue& val)
 }
 
 
+void write_read(const expressions::exprValue& val)
+{
+    OCharStream os;
+    os << val;
+
+    ISpanStream is(os.view());
+    expressions::exprValue val2;
+    is >> val2;
+
+    Pout<< "wrote " << os.count() << " chars: " << os.str() << nl;
+
+    printInfo(val);
+    printInfo(val2);
+    Pout<< "====" << nl;
+}
+
+
+tokenList tokens_of(const expressions::exprValue& val)
+{
+    OTstream toks;
+    toks << val;
+
+    Pout<< "val with tokens: ";
+    toks.writeList(Pout, 0) << nl;
+
+    for (const auto& t : toks)
+    {
+        Pout<< "  " << t.info() << nl;
+    }
+    Pout<< nl;
+
+    return toks;
+}
+
+
 expressions::exprValue tryParse(const std::string& str)
 {
     expressions::exprValue val, val2;
@@ -85,11 +122,12 @@ int main(int argc, char *argv[])
     // Regular broadcast doesn't work
     Info<< "exprValue"
         << " sizeof:" << sizeof(expressions::exprValue)
-        << " contiguous:" << is_contiguous<expressions::exprValue>::value
+        << " contiguous:" << is_contiguous_v<expressions::exprValue>
         << nl << nl;
 
     {
         expressions::exprValue value;
+        tokenList toks;
 
         Info<< "exprValue"
             << " sizeof:" << value.size_bytes()
@@ -99,21 +137,31 @@ int main(int argc, char *argv[])
 
         // Nothing
         printInfo(value);
+        toks = tokens_of(value);
+        write_read(value);
 
         value.set(scalar(100));
-        printInfo(value);
+        printInfo(value); write_read(value); toks = tokens_of(value);
+
+        value.set(scalar(100.01));
+        printInfo(value); write_read(value); toks = tokens_of(value);
 
         value.set(vector(1,2,3));
-        printInfo(value);
+        printInfo(value); write_read(value); toks = tokens_of(value);
 
         value = vector(4,5,6);
-        printInfo(value);
+        printInfo(value); write_read(value); toks = tokens_of(value);
 
         value = Zero;
-        printInfo(value);
+        printInfo(value); write_read(value); toks = tokens_of(value);
 
         value.clear();
+        printInfo(value); write_read(value); toks = tokens_of(value);
+
+        value.set<bool>(true);
+
         printInfo(value);
+        printInfo(value); write_read(value); toks = tokens_of(value);
 
         if (UPstream::parRun())
         {

applications/test/exprValue2/Make/files

@@ -1,5 +1,3 @@
-exprValueFieldTag.cxx
-
 Test-exprValue2.cxx
 
 EXE = $(FOAM_USER_APPBIN)/Test-exprValue2

applications/test/exprValue2/Test-exprValue2.cxx

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2023 OpenCFD Ltd.
+    Copyright (C) 2023-2024 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -36,7 +36,6 @@ Description
 #include "vectorField.H"
 #include "DynamicList.H"
 #include "Random.H"
-#include "exprValue.H"
 #include "exprValueFieldTag.H"
 
 using namespace Foam;
@@ -61,27 +60,81 @@ int main(int argc, char *argv[])
 
     #include "setRootCase.H"
 
+    DynamicList<fieldTag> allTags;
+
     {
         scalarField fld1(20);
         scalarField fld2a(20, Zero);
         scalarField fld2b(10, 3.10);
         scalarField fld3;
 
-        forAll(fld1, i)
+        for (auto& val : fld1)
         {
-            fld1[i] = rnd.position<scalar>(0, 20);
+            val = rnd.position<scalar>(0, 20);
+        }
+
+        if (!UPstream::master())
+        {
+            fld2b.resize(5);
+            fld2b *= 2;
         }
 
         fieldTag tag1(fld1.begin(), fld1.end());
         fieldTag tag2a(fld2a.begin(), fld2a.end());
         fieldTag tag2b(fld2b.begin(), fld2b.end());
         fieldTag tag3(fld3.begin(), fld3.end());
+        fieldTag tag4(fld3.begin(), fld3.end());
 
         printInfo(tag1) << nl;
         printInfo(tag2a) << nl;
         printInfo(tag2b) << nl;
         printInfo(tag3) << nl;
 
+        {
+            Pout<< "Test reduce" << nl;
+
+            fieldTag work(fld2b.begin(), fld2b.end());
+
+            Pout<< "Before" << nl;
+            printInfo(work) << nl;
+
+            work.reduce();
+
+            Pout<< "After" << nl;
+            printInfo(work) << nl;
+            Pout<< "====" << nl;
+        }
+
+        allTags.clear();
+        allTags.push_back(tag1);
+        allTags.push_back(tag2a);
+        allTags.push_back(tag2b);
+        allTags.push_back(tag3);
+        allTags.push_back(tag4);
+        allTags.push_back(fieldTag::make_empty<tensor>());
+
+
+        // Add some other types
+        {
+            vectorField vfld2a(20, vector::uniform(1.23));
+
+            allTags.emplace_back
+            (
+                vfld2a.begin(),
+                vfld2a.end()
+            );
+            allTags.emplace_back(vector(1.01, 2.02, 3.03));
+            allTags.emplace_back(12.4);
+
+            allTags.emplace_back().set_value(vector::uniform(2.0));
+            allTags.back().set_empty();
+        }
+        Info<< "all tags: " << allTags << nl;
+
+        Foam::sort(allTags);
+
+        Info<< "sorted: " << allTags << nl;
+
         fieldTag result;
 
         result = fieldTag::combineOp{}(tag1, tag2a);

applications/test/exprValue2/exprValueFieldTag.cxx

@@ -1,160 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2023 OpenCFD Ltd.
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "exprValueFieldTag.H"
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-bool Foam::expressions::exprValueFieldTag::empty() const noexcept
-{
-    return
-    (
-        uniformity_ == Foam::Detail::ListPolicy::uniformity::EMPTY
-    );
-}
-
-
-bool Foam::expressions::exprValueFieldTag::is_uniform() const noexcept
-{
-    return
-    (
-        uniformity_ == Foam::Detail::ListPolicy::uniformity::UNIFORM
-    );
-}
-
-
-bool Foam::expressions::exprValueFieldTag::is_nonuniform() const noexcept
-{
-    return
-    (
-        uniformity_ == Foam::Detail::ListPolicy::uniformity::NONUNIFORM
-    );
-}
-
-
-bool Foam::expressions::exprValueFieldTag::equal
-(
-    const exprValueFieldTag& rhs
-) const
-{
-    return (value_ == rhs.value_);
-}
-
-
-void Foam::expressions::exprValueFieldTag::set_nouniform() noexcept
-{
-    uniformity_ = Foam::Detail::ListPolicy::uniformity::NONUNIFORM;
-    value_ = Foam::zero{};
-}
-
-
-void Foam::expressions::exprValueFieldTag::combine
-(
-    const exprValueFieldTag& b
-)
-{
-    if (b.empty())
-    {
-        // no-op
-        return;
-    }
-
-    exprValueFieldTag& a = *this;
-
-    if (a.empty())
-    {
-        a = b;
-    }
-    else if (a.is_nonuniform())
-    {
-        // Already non-uniform/mixed
-        // a.uniformity_ |= b.uniformity_;
-
-        a.value_ = Foam::zero{};
-    }
-    else if (a.is_uniform() && b.is_uniform())
-    {
-        // Both are uniform, but are they the same value?
-        if (!a.equal(b))
-        {
-            a.set_nouniform();
-        }
-    }
-}
-
-
-// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
-
-void Foam::expressions::exprValueFieldTag::read(Istream& is)
-{
-    label uniformTag;
-
-    is >> uniformTag;
-    uniformity_ = int(uniformTag);
-    value_.read(is);
-}
-
-
-void Foam::expressions::exprValueFieldTag::write(Ostream& os) const
-{
-    os << label(uniformity_);
-    value_.write(os, false);  // No pruning
-}
-
-
-void Foam::expressions::exprValueFieldTag::print(Ostream& os) const
-{
-    os  << "{ uniform:"
-        << label(uniformity_)
-        << " type:" << label(value_.typeCode())
-        << " value: " << value_ << " }";
-}
-
-
-Foam::Istream& Foam::operator>>
-(
-    Istream& is,
-    expressions::exprValueFieldTag& tag
-)
-{
-    tag.read(is);
-    return is;
-}
-
-
-Foam::Ostream& Foam::operator<<
-(
-    Ostream& os,
-    const expressions::exprValueFieldTag& tag
-)
-{
-    tag.write(os);
-    return os;
-}
-
-
-// ************************************************************************* //

applications/test/extendedStencil/Make/options

@@ -3,4 +3,5 @@ EXE_INC = \
     -I$(LIB_SRC)/meshTools/lnInclude
 
 EXE_LIBS = \
-    -lfiniteVolume
+    -lfiniteVolume \
+    -lmeshTools

applications/test/fieldDependency/Make/options

@@ -3,4 +3,5 @@ EXE_INC = \
     -I$(LIB_SRC)/meshTools/lnInclude
 
 EXE_LIBS = \
-    -lfiniteVolume
+    -lfiniteVolume \
+    -lmeshTools

applications/test/fieldMapping/pipe1D/constant/manualDecomposition

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/fieldMapping/pipe1D/constant/transportProperties

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/fieldMapping/pipe1D/system/blockMeshDict

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/fieldMapping/pipe1D/system/controlDict

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/fieldMapping/pipe1D/system/fvSchemes

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2312                                 |
+|  \\    /   O peration     | Version:  v2412                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/