WIP: issue #3348

- Pstream changes (one-sided), local AMI communicators,
  other adjustments

META-INFO/api-info

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

applications/solvers/combustion/PDRFoam/setDeltaT.H

@@ -36,11 +36,12 @@ Description
 if (adjustTimeStep)
 {
     scalar maxDeltaTFact = maxCo/(CoNum + StCoNum + SMALL);
-    scalar deltaTFact = min(min(maxDeltaTFact, 1.0 + 0.1*maxDeltaTFact), 1.2);
+    scalar deltaTFact =
+        Foam::min(Foam::min(maxDeltaTFact, 1.0 + 0.1*maxDeltaTFact), 1.2);
 
     runTime.setDeltaT
     (
-        min
+        Foam::min
         (
             deltaTFact*runTime.deltaTValue(),
             maxDeltaT

applications/solvers/combustion/chemFoam/setDeltaT.H

@@ -1,5 +1,5 @@
 if (adjustTimeStep)
 {
-    runTime.setDeltaT(min(dtChem, maxDeltaT));
+    runTime.setDeltaT(Foam::min(dtChem, maxDeltaT));
     Info<< "deltaT = " <<  runTime.deltaTValue() << endl;
 }

applications/solvers/combustion/fireFoam/setMultiRegionDeltaT.H

@@ -54,9 +54,18 @@ if (adjustTimeStep)
 
     runTime.setDeltaT
     (
-        min
+        Foam::min
         (
-            dt0*min(min(TFactorFluid, min(TFactorFilm, TFactorSolid)), 1.2),
+            dt0
+          * Foam::min
+            (
+                Foam::min
+                (
+                    TFactorFluid,
+                    Foam::min(TFactorFilm, TFactorSolid)
+                ),
+                1.2
+            ),
             maxDeltaT
         )
     );

applications/solvers/compressible/rhoPimpleFoam/setRDeltaT.H

@@ -75,8 +75,10 @@
     )
     {
         rDeltaT =
+        (
             rDeltaT0
-           *max(rDeltaT/rDeltaT0, scalar(1) - rDeltaTDampingCoeff);
+          * Foam::max(rDeltaT/rDeltaT0, scalar(1) - rDeltaTDampingCoeff)
+        );
 
         Info<< "Damped flow time scale min/max = "
             << gMin(1/rDeltaT.primitiveField())

applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/compressibleMultiRegionCourantNo.H

@@ -1,7 +1,7 @@
     scalar CoNum = -GREAT;
     forAll(fluidRegions, regionI)
     {
-        CoNum = max
+        CoNum = Foam::max
         (
             compressibleCourantNo
             (

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

@@ -31,7 +31,7 @@
             );
 
 
-            CoNum =
+            scalar maxPhiCoNum =
                 0.5*gMax
                 (
                     sumPhi/fluidRegions[regioni].V().field()
@@ -41,9 +41,9 @@
             (
                 fvc::surfaceSum(mag(phi1 - phi2))().primitiveField()
               / fluidRegions[regioni].V().field()
-            )*runTime.deltaTValue(),
+            )*runTime.deltaTValue();
 
-            CoNum = max(UrCoNum, CoNum);
+            CoNum = Foam::max(CoNum, Foam::max(maxPhiCoNum, UrCoNum));
         }
     }
 

applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/compressibleMultiRegionCourantNo.H

@@ -2,7 +2,7 @@
 
     forAll(fluidRegions, regioni)
     {
-        CoNum = max
+        CoNum = Foam::max
         (
             compressibleCourantNo
             (
@@ -17,7 +17,7 @@
 /*
     forAll(porousFluidRegions, porousi)
     {
-        CoNum = max
+        CoNum = Foam::max
         (
             compressibleCourantNo
             (

applications/solvers/heatTransfer/chtMultiRegionFoam/include/setInitialMultiRegionDeltaT.H

@@ -47,10 +47,10 @@ if (adjustTimeStep)
 
         runTime.setDeltaT
         (
-            min
+            Foam::min
             (
-                min(maxCo/CoNum, maxDi/DiNum)*runTime.deltaTValue(),
-                min(runTime.deltaTValue(), maxDeltaT)
+                Foam::min(maxCo/CoNum, maxDi/DiNum)*runTime.deltaTValue(),
+                Foam::min(runTime.deltaTValue(), maxDeltaT)
             )
         );
         Info<< "deltaT = " <<  runTime.deltaTValue() << endl;

applications/solvers/heatTransfer/chtMultiRegionFoam/include/setMultiRegionDeltaT.H

@@ -49,17 +49,17 @@ if (adjustTimeStep)
     scalar maxDeltaTSolid = maxDi/(DiNum + SMALL);
 
     scalar deltaTFluid =
-        min
+        Foam::min
         (
-            min(maxDeltaTFluid, 1.0 + 0.1*maxDeltaTFluid),
+            Foam::min(maxDeltaTFluid, 1.0 + 0.1*maxDeltaTFluid),
             1.2
         );
 
     runTime.setDeltaT
     (
-        min
+        Foam::min
         (
-            min(deltaTFluid, maxDeltaTSolid)*runTime.deltaTValue(),
+            Foam::min(deltaTFluid, maxDeltaTSolid)*runTime.deltaTValue(),
             maxDeltaT
         )
     );

applications/solvers/heatTransfer/chtMultiRegionFoam/solid/solidRegionDiffusionNo.H

@@ -22,7 +22,7 @@ forAll(solidRegions, i)
     tmp<volScalarField> trho = thermo.rho();
     const volScalarField& rho = trho();
 
-    DiNum = max
+    DiNum = Foam::max
     (
         solidRegionDiffNo
         (

applications/solvers/heatTransfer/solidFoam/solidDiffusionNo.H

@@ -17,7 +17,7 @@ scalar DiNum = -GREAT;
     tmp<volScalarField> trho = thermo.rho();
     const volScalarField& rho = trho();
 
-    DiNum = max
+    DiNum = Foam::max
     (
         solidRegionDiffNo
         (

applications/solvers/lagrangian/reactingParcelFoam/setMultiRegionDeltaT.H

@@ -36,13 +36,16 @@ Description
 if (adjustTimeStep)
 {
     const scalar maxDeltaTFact =
-        min(maxCo/(CoNum + SMALL), maxCo/(surfaceFilm.CourantNumber() + SMALL));
+        Foam::min
+        (
+            maxCo/(CoNum + SMALL), maxCo/(surfaceFilm.CourantNumber() + SMALL)
+        );
     const scalar deltaTFact =
-        min(min(maxDeltaTFact, 1.0 + 0.1*maxDeltaTFact), 1.2);
+        Foam::min(Foam::min(maxDeltaTFact, 1.0 + 0.1*maxDeltaTFact), 1.2);
 
     runTime.setDeltaT
     (
-        min
+        Foam::min
         (
             deltaTFact*runTime.deltaTValue(),
             maxDeltaT

applications/solvers/multiphase/VoF/setDeltaT.H

@@ -36,13 +36,14 @@ Description
 if (adjustTimeStep)
 {
     scalar maxDeltaTFact =
-        min(maxCo/(CoNum + SMALL), maxAlphaCo/(alphaCoNum + SMALL));
+        Foam::min(maxCo/(CoNum + SMALL), maxAlphaCo/(alphaCoNum + SMALL));
 
-    scalar deltaTFact = min(min(maxDeltaTFact, 1.0 + 0.1*maxDeltaTFact), 1.2);
+    scalar deltaTFact =
+        Foam::min(Foam::min(maxDeltaTFact, 1.0 + 0.1*maxDeltaTFact), 1.2);
 
     runTime.setDeltaT
     (
-        min
+        Foam::min
         (
             deltaTFact*runTime.deltaTValue(),
             maxDeltaT

applications/solvers/multiphase/cavitatingFoam/setDeltaT.H

@@ -36,13 +36,14 @@ Description
 if (adjustTimeStep)
 {
     scalar maxDeltaTFact =
-        min(maxCo/(CoNum + SMALL), maxAcousticCo/(acousticCoNum + SMALL));
+        Foam::min(maxCo/(CoNum + SMALL), maxAcousticCo/(acousticCoNum + SMALL));
 
-    scalar deltaTFact = min(min(maxDeltaTFact, 1.0 + 0.1*maxDeltaTFact), 1.2);
+    scalar deltaTFact =
+        Foam::min(Foam::min(maxDeltaTFact, 1.0 + 0.1*maxDeltaTFact), 1.2);
 
     runTime.setDeltaT
     (
-        min
+        Foam::min
         (
             deltaTFact*runTime.deltaTValue(),
             maxDeltaT

applications/solvers/multiphase/cavitatingFoam/setInitialDeltaT.H

@@ -37,11 +37,15 @@ if (adjustTimeStep)
     if (CoNum > SMALL)
     {
         scalar maxDeltaTFact =
-            min(maxCo/(CoNum + SMALL), maxAcousticCo/(acousticCoNum + SMALL));
+            Foam::min
+            (
+                maxCo/(CoNum + SMALL),
+                maxAcousticCo/(acousticCoNum + SMALL)
+            );
 
         runTime.setDeltaT
         (
-            min
+            Foam::min
             (
                 maxDeltaTFact*runTime.deltaTValue(),
                 maxDeltaT

applications/solvers/multiphase/compressibleInterFoam/alphaSuSp.H

@@ -26,12 +26,12 @@ forAll(dgdt, celli)
 {
     if (dgdt[celli] > 0.0)
     {
-        Sp[celli] -= dgdt[celli]/max(1.0 - alpha1[celli], 1e-4);
-        Su[celli] += dgdt[celli]/max(1.0 - alpha1[celli], 1e-4);
+        Sp[celli] -= dgdt[celli]/Foam::max(1.0 - alpha1[celli], 1e-4);
+        Su[celli] += dgdt[celli]/Foam::max(1.0 - alpha1[celli], 1e-4);
     }
     else if (dgdt[celli] < 0.0)
     {
-        Sp[celli] += dgdt[celli]/max(alpha1[celli], 1e-4);
+        Sp[celli] += dgdt[celli]/Foam::max(alpha1[celli], 1e-4);
     }
 }
 

applications/solvers/multiphase/compressibleInterFoam/compressibleInterIsoFoam/alphaSuSp.H

@@ -26,12 +26,12 @@ forAll(dgdt, celli)
 {
     if (dgdt[celli] > 0.0)
     {
-        Sp[celli] -= dgdt[celli]/max(1.0 - alpha1[celli], 1e-4);
-        Su[celli] += dgdt[celli]/max(1.0 - alpha1[celli], 1e-4);
+        Sp[celli] -= dgdt[celli]/Foam::max(1.0 - alpha1[celli], 1e-4);
+        Su[celli] += dgdt[celli]/Foam::max(1.0 - alpha1[celli], 1e-4);
     }
     else if (dgdt[celli] < 0.0)
     {
-        Sp[celli] += dgdt[celli]/max(alpha1[celli], 1e-4);
+        Sp[celli] += dgdt[celli]/Foam::max(alpha1[celli], 1e-4);
     }
 }
 

applications/solvers/multiphase/compressibleInterFoam/overCompressibleInterDyMFoam/alphaSuSp.H

@@ -26,12 +26,12 @@ forAll(dgdt, celli)
 {
     if (dgdt[celli] > 0.0)
     {
-        Sp[celli] -= dgdt[celli]/max(1.0 - alpha1[celli], 1e-4);
-        Su[celli] += dgdt[celli]/max(1.0 - alpha1[celli], 1e-4);
+        Sp[celli] -= dgdt[celli]/Foam::max(1.0 - alpha1[celli], 1e-4);
+        Su[celli] += dgdt[celli]/Foam::max(1.0 - alpha1[celli], 1e-4);
     }
     else if (dgdt[celli] < 0.0)
     {
-        Sp[celli] += dgdt[celli]/max(alpha1[celli], 1e-4);
+        Sp[celli] += dgdt[celli]/Foam::max(alpha1[celli], 1e-4);
     }
 }
 

applications/solvers/multiphase/icoReactingMultiphaseInterFoam/laserDTRM/laserDTRM.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2023 OpenCFD Ltd.
+    Copyright (C) 2017-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -679,7 +679,7 @@ void Foam::radiation::laserDTRM::calculate()
             }
         }
 
-        scalar totalQ = gSum(Q_.primitiveFieldRef()*mesh_.V());
+        scalar totalQ = gWeightedSum(mesh_.V(), Q_.primitiveField());
         Info << "Total energy absorbed [W]: " << totalQ << endl;
 
         if (mesh_.time().writeTime())

applications/solvers/multiphase/icoReactingMultiphaseInterFoam/setDeltaT.H

@@ -36,13 +36,13 @@ Description
 if (adjustTimeStep)
 {
     scalar maxDeltaTFact =
-        min
+        Foam::min
         (
             maxCo/(CoNum + SMALL),
-            min
+            Foam::min
             (
                 maxAlphaCo/(alphaCoNum + SMALL),
-                min
+                Foam::min
                 (
                     maxAlphaDdt/(ddtAlphaNum + SMALL),
                     maxDi/(DiNum + SMALL)
@@ -50,11 +50,12 @@ if (adjustTimeStep)
             )
         );
 
-    scalar deltaTFact = min(min(maxDeltaTFact, 1.0 + 0.1*maxDeltaTFact), 1.2);
+    scalar deltaTFact =
+        Foam::min(Foam::min(maxDeltaTFact, 1.0 + 0.1*maxDeltaTFact), 1.2);
 
     runTime.setDeltaT
     (
-        min
+        Foam::min
         (
             deltaTFact*runTime.deltaTValue(),
             maxDeltaT

applications/solvers/multiphase/reactingTwoPhaseEulerFoam/CourantNos.H

@@ -8,5 +8,5 @@
 
     Info<< "Max Ur Courant Number = " << UrCoNum << endl;
 
-    CoNum = max(CoNum, UrCoNum);
+    CoNum = Foam::max(CoNum, UrCoNum);
 }

applications/solvers/multiphase/twoPhaseEulerFoam/CourantNos.H

@@ -8,5 +8,5 @@
 
     Info<< "Max Ur Courant Number = " << UrCoNum << endl;
 
-    CoNum = max(CoNum, UrCoNum);
+    CoNum = Foam::max(CoNum, UrCoNum);
 }

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

@@ -51,17 +51,20 @@ Description
 //- 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
+    // Fundamental Types [10]:
+    Basic_begin,
+    type_byte = Basic_begin,
+    type_int16,
     type_int32,
     type_int64,
+    type_uint16,
     type_uint32,
     type_uint64,
     type_float,
     type_double,
     type_long_double,
-    invalid
+    invalid,
+    Basic_end = invalid
 };
 
 
@@ -69,20 +72,19 @@ enum class dataTypes : int
 
 // Partial copy from UPstreamTraits.H
 
-//- A supported UPstream data type (intrinsic or user-defined)
+//- UPstream data type corresponding to an intrinsic (MPI) type
 template<class T>
-struct UPstream_base_dataType : std::false_type
+struct UPstream_mpi_dataType : std::false_type
 {
     static constexpr auto datatype_id = dataTypes::invalid;
 };
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-// Specializations of the above,
-// each to match the elements of UPstream::dataTypes
 
+// Specializations to match elements of UPstream::dataTypes
 #undef  defineUPstreamDataTraits
 #define defineUPstreamDataTraits(TypeId, Type)                                \
-    template<> struct UPstream_base_dataType<Type> : std::true_type           \
+    template<> struct UPstream_mpi_dataType<Type> : std::true_type            \
     {                                                                         \
         static constexpr auto datatype_id = dataTypes::TypeId;                \
     };
@@ -90,8 +92,10 @@ struct UPstream_base_dataType : std::false_type
 
 defineUPstreamDataTraits(type_byte,   char);
 defineUPstreamDataTraits(type_byte,   unsigned char);
+defineUPstreamDataTraits(type_int16,  int16_t);
 defineUPstreamDataTraits(type_int32,  int32_t);
 defineUPstreamDataTraits(type_int64,  int64_t);
+defineUPstreamDataTraits(type_uint16, uint16_t);
 defineUPstreamDataTraits(type_uint32, uint32_t);
 defineUPstreamDataTraits(type_uint64, uint64_t);
 defineUPstreamDataTraits(type_float,  float);
@@ -109,8 +113,8 @@ struct UPstream_alias_dataType
 :
     std::bool_constant
     <
-        // Base type (no alias needed)
-        UPstream_base_dataType<std::remove_cv_t<T>>::value ||
+        // Basic MPI type
+        UPstream_mpi_dataType<std::remove_cv_t<T>>::value ||
         (
             // Or some int 32/64 type to re-map
             std::is_integral_v<T>
@@ -118,15 +122,11 @@ struct UPstream_alias_dataType
         )
     >
 {
-    // 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
+        UPstream_mpi_dataType<std::remove_cv_t<T>>::value,
+        std::remove_cv_t<T>,  // <- using mpi type (no alias)
+        std::conditional_t    // <- using alias
         <
             (
                 std::is_integral_v<T>
@@ -138,12 +138,32 @@ struct UPstream_alias_dataType
                 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)
+            char  // Fallback is a byte (eg, arbitrary contiguous data)
         >
     >;
 
     static constexpr auto datatype_id =
-        UPstream_base_dataType<base>::datatype_id;
+        UPstream_mpi_dataType<base>::datatype_id;
+};
+
+
+// Handle int8_t/uint8_t as aliases since 'signed char' etc may be
+// ambiguous
+
+//- Map \c int8_t to UPstream::dataTypes::type_byte
+template<>
+struct UPstream_alias_dataType<int8_t> : std::true_type
+{
+    using base = char;
+    static constexpr auto datatype_id = dataTypes::type_byte;
+};
+
+//- Map \c uint8_t to UPstream::dataTypes::type_byte
+template<>
+struct UPstream_alias_dataType<uint8_t> : std::true_type
+{
+    using base = unsigned char;
+    static constexpr auto datatype_id = dataTypes::type_byte;
 };
 
 
@@ -172,25 +192,30 @@ void print(const char* name, bool showLimits = true)
     }
 
     // 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 constexpr (UPstream_mpi_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) << ")";
-        }
+        std::cout
+            << " is_mpi=("
+            << int(UPstream_mpi_dataType<T>::datatype_id) << ')';
     }
     else
     {
-        std::cout<< " no_alias";
+        std::cout << " is_mpi=(null)";
+    }
+
+    // Any aliases?
+    if constexpr (UPstream_alias_dataType<T>::value)
+    {
+        if constexpr (UPstream_mpi_dataType<T>::value)
+        {
+            std::cout << " alias=base";
+        }
+        else
+        {
+            std::cout
+                << " alias=("
+                << int(UPstream_alias_dataType<T>::datatype_id) << ')';
+        }
     }
 
     std::cout<< '\n';
@@ -217,6 +242,7 @@ int main(int argc, char *argv[])
 
     std::cout << '\n';
     print<char>("char");
+    print<signed char>("signed char");
     print<unsigned char>("unsigned char");
     print<short>("short");
     print<int>("int");

applications/test/HashTable1/Make/files

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

applications/test/ITstream/Test-ITstream.cxx

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2023 OpenCFD Ltd.
+    Copyright (C) 2017-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -74,15 +74,11 @@ Ostream& toString(Ostream& os, const List<char>& list)
 void printTokens(Istream& is)
 {
     label count = 0;
-    token t;
-    while (is.good())
+
+    Info<< "stream tokens:" << endl;
+    for (token tok; tok.read(is); ++count)
     {
-        is >> t;
-        if (t.good())
-        {
-            ++count;
-            Info<< "token: " << t << endl;
-        }
+        Info<< "  : " << tok << endl;
     }
 
     Info<< count << " tokens" << endl;
@@ -455,6 +451,12 @@ int main(int argc, char *argv[])
             "( const char input \"string\" to tokenize )\n"
             "List<label> 5(0 1 2 3 4);";
 
+        // printTokens
+        {
+            ISpanStream is(charInput);
+            printTokens(is);
+        }
+
         string stringInput("( string     ;    input \"string\" to tokenize )");
 
         List<char> listInput

applications/test/IjkField/Make/files

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

applications/test/List2/Make/files

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

applications/test/List2/Test-List2.cxx

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017 OpenCFD Ltd.
+    Copyright (C) 2017-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -35,6 +35,7 @@ Description
 #include "FixedList.H"
 #include "labelList.H"
 #include "vectorList.H"
+#include "SubList.H"
 #include "ListOps.H"
 #include "IFstream.H"
 #include "OFstream.H"
@@ -200,6 +201,7 @@ int main(int argc, char *argv[])
     argList::addBoolOption("order");
     argList::addBoolOption("labelList");
     argList::addBoolOption("vectorList");
+    argList::addBoolOption("ulist");
 
     argList args(argc, argv);
 
@@ -261,6 +263,37 @@ int main(int argc, char *argv[])
     }
 
 
+    if (args.found("ulist"))
+    {
+        using span_type = stdFoam::span<vector>;
+        using ulist_type = UList<vector>;
+
+        ulist_type view1, view2;
+        span_type span1, span2;
+
+        List<vector> list(10, vector::one);
+
+        Info<< "List: " << Foam::name(list.data()) << nl;
+        Info<< "view: " << Foam::name(view1.data()) << nl;
+        Info<< "span: " << Foam::name(span1.data()) << nl;
+
+        view1 = list.slice(4);
+        span1 = span_type(list.begin(4), list.size()-4);
+        Info<< "view [4]:" << Foam::name(view1.data()) << nl;
+        Info<< "span [4]:" << Foam::name(span1.data()) << nl;
+
+        view2 = std::move(view1);
+        span2 = std::move(span1);
+        Info<< "view old:" << Foam::name(view1.data()) << nl;
+        Info<< "span old:" << Foam::name(span1.data()) << nl;
+        Info<< "view [4]:" << Foam::name(view2.data()) << nl;
+        Info<< "span [4]:" << Foam::name(span2.data()) << nl;
+
+        view1 = list.slice(7);
+        Info<< "view [7]:" << Foam::name(view1.data()) << nl;
+    }
+
+
     Info<< nl << "Done" << nl << endl;
     return 0;
 }

applications/test/UPstreamTraits/Test-UPstreamTraits.cxx

@@ -37,35 +37,40 @@ Description
 #include "vector.H"
 #include "tensor.H"
 #include "uLabel.H"
+#include "MinMax.H"
 #include "Switch.H"
 #include "IOstreams.H"
 #include "UPstream.H"
 
+#include <functional>
 #include <type_traits>
 
-using namespace Foam;
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-// Just for debugging
-const List<std::string> dataType_names
-({
-    "byte",
-    "int32",
-    "int64",
-    "uint32",
-    "uint64",
-    "float",
-    "double",
-    "long_double",
+namespace Foam
+{
+
+// Add in some extras from functional
+
+//- Map std::plus to \c UPstream::opCodes::op_sum
+template<>
+struct UPstream_opType<std::plus<void>> : std::true_type
+{
+    static constexpr auto opcode_id = UPstream::opCodes::op_sum;
+};
+
+
+//- Map 'signed char' to UPstream::dataTypes::type_byte
+//  Caution with: may be identical to int8_t mapping!!
+#if 0
+template<>
+struct UPstream_alias_dataType<signed char> : std::true_type
+{
+    using base = char;
+    static constexpr auto datatype_id = UPstream::dataTypes::type_byte;
+};
+#endif
 
-    "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>
@@ -82,24 +87,93 @@ struct check_has_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;
-//     }();
-// };
+} // End namespace Foam
 
 
-template<class T>
-void printTypeName(const bool showSize = false)
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Just for debugging
+static const Foam::List<std::string> dataType_names
+({
+    "byte",
+    "int16",
+    "int32",
+    "int64",
+    "uint16",
+    "uint32",
+    "uint64",
+    "float",
+    "double",
+    "long_double",
+
+    "float[3]",
+    "double[3]",
+    "float[6]",
+    "double[6]",
+    "float[9]",
+    "double[9]"
+});
+
+// Just for debugging
+static const Foam::List<std::string> opType_names
+({
+    "op_min",
+    "op_max",
+    "op_sum",
+    "op_prod",
+    "op_bool_and",
+    "op_bool_or",
+    "op_bool_xor",
+    "op_bit_and",
+    "op_bit_or",
+    "op_bit_xor",
+    "op_replace",
+    "op_no_op"
+});
+
+
+using namespace Foam;
+
+void printDataTypeId(UPstream::dataTypes datatype_id)
+{
+    if (datatype_id != UPstream::dataTypes::invalid)
+    {
+        const int index = int(datatype_id);
+        if (index < dataType_names.size())
+        {
+            Info<< dataType_names[index];
+        }
+        else
+        {
+            Info<< '(' << index << ')';
+        }
+    }
+}
+
+
+void printOpCodeId(UPstream::opCodes opcode_id)
+{
+    if (opcode_id != UPstream::opCodes::invalid)
+    {
+        const int index = int(opcode_id);
+        if (index < opType_names.size())
+        {
+            Info<< ':' << opType_names[index].c_str();
+        }
+        else
+        {
+            Info<< '(' << index << ')';
+        }
+    }
+    else
+    {
+        Info<< "(null)";
+    }
+}
+
+
+template<class T, bool showSize = false>
+void printTypeName()
 {
     // Both float and double have pTraits typeName = "scalar"!
     if constexpr (std::is_same_v<float, std::remove_cv_t<T>>)
@@ -118,12 +192,13 @@ void printTypeName(const bool showSize = false)
     {
         Info<< typeid(T).name();
     }
-    if (showSize)
+    if constexpr (showSize)
     {
         Info<< " (" << sizeof(T) << " bytes)";
     }
 }
 
+
 template<class Type, bool UseTypeName = true>
 void printPstreamTraits(const std::string_view name = std::string_view())
 {
@@ -133,55 +208,111 @@ void printPstreamTraits(const std::string_view name = std::string_view())
     {
         Info<< name << ' ';
     }
+
     if constexpr (UseTypeName)
     {
-        printTypeName<Type>(true);
+        printTypeName<Type, true>();
     }
     else
     {
-        Info<< typeid(Type).name();
-        Info<< " (" << sizeof(Type) << " bytes)";
+        Info<< typeid(Type).name() << " (" << sizeof(Type) << " bytes)";
+    }
+
+    {
+        using cmpt = typename Foam::pTraits_cmptType<Type>::type;
+
+        if constexpr (!std::is_same_v<Type, cmpt>)
+        {
+            Info<< ", cmpt:";
+
+            if constexpr (UseTypeName)
+            {
+                printTypeName<cmpt, true>();
+            }
+            else
+            {
+                Info<< typeid(cmpt).name() << " (" << sizeof(cmpt) << " 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;
-
+        << is_contiguous<Type>::value;
 
+    if constexpr (UPstream_mpi_dataType<Type>::value)
     {
-        int index = int(UPstream_base_dataType<Type>::datatype_id);
-        Info<< "datatype: " << index;
+        Info<< ", is_mpi=("
+            << int(UPstream_mpi_dataType<Type>::datatype_id) << ')';
+    }
+    else
+    {
+        std::cout << ", is_mpi=(null)";
+    }
+    if constexpr (UPstream_user_dataType<Type>::value)
+    {
+        Info<< ", is_user=("
+            << int(UPstream_user_dataType<Type>::datatype_id) << ')';
+    }
+    else
+    {
+        std::cout << ", is_user=(null)";
+    }
+    if constexpr (UPstream_any_dataType<Type>::value)
+    {
+        Info<< ", is_any=("
+            << int(UPstream_any_dataType<Type>::datatype_id) << ')';
+    }
+    else
+    {
+        std::cout << ", is_any=(null)";
+    }
 
-        if (index < dataType_names.size())
-        {
-            Info<< ' ' << dataType_names[index];
-        }
-        Info<< nl;
+    // Any aliases?
+    if constexpr
+    (
+        UPstream_alias_dataType<Type>::value
+     && !UPstream_mpi_dataType<Type>::value
+    )
+    {
+        Info<< ", alias=("
+            << int(UPstream_alias_dataType<Type>::datatype_id) << ')';
+    }
+
+    Info<< " base-type:" << int(UPstream_basic_dataType<Type>::datatype_id)
+        << " data-type:" << int(UPstream_dataType<Type>::datatype_id)
+        << nl;
+
+    if constexpr (UPstream_basic_dataType<Type>::value)
+    {
+        Info<< " base-type=";
+        printDataTypeId(UPstream_basic_dataType<Type>::datatype_id);
+    }
+    else if constexpr (UPstream_dataType<Type>::value)
+    {
+        Info<< " data-type=";
+        printDataTypeId(UPstream_dataType<Type>::datatype_id);
     }
 
     {
         // 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;
+        Info<< " : ";
+        if constexpr (UseTypeName)
+        {
+            printTypeName<base, true>();
+        }
+        else
+        {
+            Info<< typeid(base).name() << " (" << sizeof(base) << " bytes)";
+        }
+
+        Info<< " cmpt-type=";
+        printDataTypeId(UPstream_dataType<Type>::datatype_id);
+        Info<< " count=" << UPstream_dataType<Type>::size(1);
+        Info<< nl;
     }
 }
 
@@ -190,15 +321,44 @@ template<class BinaryOp>
 void printOpCodeTraits(BinaryOp bop, std::string_view name)
 {
     Info<< "op: " << name << ' ';
-    if constexpr (UPstream_opType<BinaryOp>::value)
+
+    printOpCodeId(UPstream_opType<BinaryOp>::opcode_id);
+    Info<< nl;
+}
+
+
+template<class DataType, class BinaryOp>
+void printOpCodeTraits(BinaryOp bop, std::string_view name)
+{
+    Info<< "op: " << name << ' ';
+
+    printOpCodeId(UPstream_opType<BinaryOp>::opcode_id);
+
+    if constexpr (!std::is_void_v<DataType>)
     {
-        Info<< "supported";
+        if constexpr (UPstream_basic_dataType<DataType>::value)
+        {
+            Info<< " [supported type]";
+        }
+        else
+        {
+            Info<< " [disabled]";
+        }
     }
-    else
-    {
-        Info<< "unknown";
-    }
-    Info<< ": " << int(UPstream_opType<BinaryOp>::opcode_id) << nl;
+    Info<< nl;
+}
+
+
+template<class DataType, class BinaryOp>
+void print_data_opType(BinaryOp bop, std::string_view name)
+{
+    Info<< "op: " << name << ' ';
+
+    printOpCodeId(UPstream_data_opType<BinaryOp, DataType>::opcode_id);
+
+    const bool ok = UPstream_data_opType<BinaryOp, DataType>::value;
+
+    Info<< " okay=" << ok << nl;
 }
 
 
@@ -210,6 +370,16 @@ int main()
     printPstreamTraits<bool>();
     printPstreamTraits<label>();
 
+    printPstreamTraits<char, false>("<char>");
+    printPstreamTraits<signed char, false>("<signed char>");
+    printPstreamTraits<unsigned char, false>("<unsigned char>");
+
+    printPstreamTraits<int8_t, false>("<int8_t>");
+    printPstreamTraits<uint8_t, false>("<uint8_t>");
+
+    printPstreamTraits<int16_t, false>("<int16_t>");
+    printPstreamTraits<uint16_t, false>("<uint16_t>");
+
     printPstreamTraits<int>("<int>");
     printPstreamTraits<long>("<long>");
     printPstreamTraits<unsigned>("<unsigned>");
@@ -258,6 +428,35 @@ int main()
     printOpCodeTraits(bitAndOp<unsigned>{}, "bitAnd<unsigned>");
     printOpCodeTraits(bitOrOp<unsigned>{}, "bitOr<unsigned>");
 
+    printOpCodeTraits<vector>(sumOp<vector>{}, "sum");
+    printOpCodeTraits(sumOp<scalarMinMax>{}, "sum");
+
+    printOpCodeTraits(std::plus<>{}, "sum");
+    printOpCodeTraits<bool>(std::plus<>{}, "sum");
+    printOpCodeTraits<vector>(std::plus<>{}, "sum");
+
+
+    // Expect success
+    Info<< nl << "expect success" << nl;
+    print_data_opType<vector>(maxOp<scalar>(), "maxOp(scalar)");
+    print_data_opType<unsigned>(bitOrOp<unsigned>(), "bitOrOp(unsigned)");
+    print_data_opType<uint8_t>(bitOrOp<uint8_t>(), "bitOrOp(uint8_t)");
+    print_data_opType<uint16_t>(bitOrOp<uint16_t>(), "bitOrOp(uint16_t)");
+
+    // Even allow signed integrals
+    print_data_opType<int>(bitOrOp<int>(), "bitOrOp(int)");
+    print_data_opType<int8_t>(bitOrOp<int8_t>(), "bitOrOp(int8_t)");
+
+    // Failure - supported op, unsupported data type.
+    Info<< nl << "expect failure" << nl;
+    print_data_opType<bool>(maxOp<scalar>(), "maxOp(scalar, bool)");
+    print_data_opType<bool>(bitOrOp<unsigned>(), "bitOrOp(unsigned, bool)");
+
+    // False positives. Failure - supported op, unsupported data type.
+    Info<< nl << "false positives" << nl;
+    print_data_opType<void>(maxOp<bool>(), "maxOp(bool, void)");
+    print_data_opType<float>(bitOrOp<unsigned>(), "bitOrOp(unsigned, float)");
+
     Info<< nl << "End\n" << endl;
 
     return 0;

applications/test/gather-scatter1/Make/files

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

applications/test/gather-scatter1/Make/options

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

applications/test/gather-scatter1/Test-gather-scatter1.cxx

@@ -0,0 +1,282 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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/>.
+
+Application
+    Test-gather-scatter1
+
+Description
+    Simple tests for gather/scatter
+
+\*---------------------------------------------------------------------------*/
+
+#include "List.H"
+#include "argList.H"
+#include "Time.H"
+#include "Pstream.H"
+#include "IOstreams.H"
+
+using namespace Foam;
+
+
+//- Ostensibly the inverse of gatherList, but actually works like
+//- a broadcast that skips overwriting the local rank!
+template<class T>
+void real_scatterList
+(
+    //! [in,out]
+    UList<T>& values,
+    [[maybe_unused]] const int tag = UPstream::msgType(),
+    const int communicator = UPstream::worldComm
+)
+{
+    if (!UPstream::is_parallel(communicator))
+    {
+        // Nothing to do
+        return;
+    }
+    else if constexpr (is_contiguous_v<T>)
+    {
+        // This part is a real in-place scatter:
+
+        // In-place scatter for contiguous types - one element per rank
+        // - on master:
+        //   * send pointer is the full list
+        //   * recv pointer is first destination
+        // - on rank:
+        //   * send pointer is irrelevant
+        //   * recv pointer is destination in the list
+        //
+        // So can simply use identical pointers for send/recv
+
+        auto* ptr = values.data() + UPstream::myProcNo(communicator);
+        UPstream::mpiScatter(ptr, ptr, 1, communicator);
+    }
+    else
+    {
+        // Communication order
+        const auto& commOrder = UPstream::whichCommunication(communicator);
+
+        Pstream::scatterList_algorithm(commOrder, values, tag, communicator);
+    }
+}
+
+
+//- gatherList_algorithm, but with specific communication style
+template<class T>
+void gatherList_algo
+(
+    const bool linear,
+    //! [in,out]
+    UList<T>& values,
+    [[maybe_unused]] const int tag = UPstream::msgType(),
+    const int communicator = UPstream::worldComm
+)
+{
+    if (UPstream::is_parallel(communicator))
+    {
+        Pstream::gatherList_algorithm
+        (
+            UPstream::whichCommunication(communicator, linear),
+            values,
+            tag,
+            communicator
+        );
+    }
+}
+
+
+//- scatterList_algorithm, but with specific communication style
+template<class T>
+void scatterList_algo
+(
+    const bool linear,
+    //! [in,out]
+    UList<T>& values,
+    [[maybe_unused]] const int tag = UPstream::msgType(),
+    const int communicator = UPstream::worldComm
+)
+{
+    if (UPstream::is_parallel(communicator))
+    {
+        Pstream::scatterList_algorithm
+        (
+            UPstream::whichCommunication(communicator, linear),
+            values,
+            tag,
+            communicator
+        );
+    }
+}
+
+
+// Perform tests
+template<class ListType, class ResetCode>
+void doTest(ResetCode reset)
+{
+    ListType values;
+
+    reset(values);
+
+    Pout<< nl << "before:" << flatOutput(values) << endl;
+    Pstream::broadcastList(values);
+    Pout<< "broadcast:" << flatOutput(values) << endl;
+
+    reset(values);
+
+    Pout<< nl << "before:" << flatOutput(values) << endl;
+    Pstream::scatterList(values);
+    Pout<< "scatter:" << flatOutput(values) << endl;
+
+    reset(values);
+
+    Pout<< "before:" << flatOutput(values) << endl;
+    real_scatterList(values);
+    Pout<< "inplace:" << flatOutput(values) << endl;
+
+    using control = std::pair<int, int>;
+
+    const char* algoType[2] = { "tree", "linear" };
+
+    for
+    (
+        auto [gather, scatter] :
+        {
+            control{0, 0},
+            control{1, 1},
+            control{0, 1},
+            control{1, 0}
+        }
+    )
+    {
+        reset(values);
+
+        Pout<< nl << "before:" << flatOutput(values) << endl;
+
+        gatherList_algo(gather, values);
+        Pout<< "gather[" << algoType[gather] << "]:"
+            << flatOutput(values) << endl;
+
+        scatterList_algo(scatter, values);
+        Pout<< "scatter[" << algoType[scatter] << "]:"
+            << flatOutput(values) << endl;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    argList::noCheckProcessorDirectories();
+    argList::addVerboseOption("increase UPstream::debug level");
+
+    #include "setRootCase.H"
+
+    const int optVerbose = args.verbose();
+
+    if (optVerbose)
+    {
+        UPstream::debug = optVerbose;
+    }
+
+    Pout<< nl << "Test contiguous" << endl;
+    {
+        doTest<labelList>
+        (
+            [](auto& values){
+                if (UPstream::master())
+                {
+                    values = identity(UPstream::nProcs());
+                }
+                else
+                {
+                    values.resize(UPstream::nProcs());
+                    values = -1;
+                    values[UPstream::myProcNo()] = 10 * UPstream::myProcNo();
+                }
+            }
+        );
+    }
+
+    Pout<< nl << "Test non-contiguous" << endl;
+    {
+        doTest<wordList>
+        (
+            [](auto& values) {
+                values.resize(UPstream::nProcs());
+                if (UPstream::master())
+                {
+                    forAll(values, i)
+                    {
+                        values[i] = "proc" + Foam::name(i);
+                    }
+                }
+                else
+                {
+                    values = "none";
+                    values[UPstream::myProcNo()] =
+                        "_" + Foam::name(UPstream::myProcNo());
+                }
+            }
+        );
+    }
+
+    // Test dummy broadcast as well
+    Pout<< nl << "Test broadcastList" << endl;
+    {
+        wordList list;
+
+        Pout<< nl << "before: " << flatOutput(list) << endl;
+
+        Pstream::broadcastList(list);
+        Pout<< "-> " << flatOutput(list) << endl;
+    }
+
+    // Test in-place reduce
+    Pout<< nl << "Test in-place reduce" << endl;
+    {
+        FixedList<label, 6> list;
+        list = UPstream::myProcNo();
+
+        Pout<< nl << "before: " << flatOutput(list) << endl;
+
+        UPstream::mpiReduce
+        (
+            list.data(),
+            list.size(),
+            UPstream::opCodes::op_sum,
+            UPstream::worldComm
+        );
+
+        Pout<< "-> " << flatOutput(list) << endl;
+    }
+
+    Info<< nl << "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/test/globalIndex3/Test-globalIndex3.cxx

@@ -345,8 +345,8 @@ static void reportOffsets(const globalIndex& gi)
 
         UPstream::broadcast
         (
-            allOffsets.data_bytes(),
-            allOffsets.size_bytes(),
+            allOffsets.data(),
+            allOffsets.size(),
             interNodeComm
         );
     }
@@ -508,7 +508,7 @@ int main(int argc, char *argv[])
 
     #include "setRootCase.H"
 
-    const bool useLocalComms = UPstream::usingNodeComms();
+    const bool useLocalComms = UPstream::usingNodeComms(UPstream::worldComm);
     bool useWindow = args.found("window");
     bool useBuiltin = args.found("builtin");
 

applications/test/matrices/DiagonalMatrix/Make/files

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

applications/test/matrices/EigenMatrix/Make/files

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

applications/test/matrices/Matrix/Make/files

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

applications/test/matrices/QRMatrix/Make/files

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

applications/test/matrices/RectangularMatrix/Make/files

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

applications/test/matrices/SquareMatrix/Make/files

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

applications/test/matrices/SymmetricSquareMatrix/Make/files

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

applications/test/nodeTopology/Test-nodeTopology.cxx

@@ -115,6 +115,13 @@ int main(int argc, char *argv[])
     );
 
 
+    if (UPstream::parRun())
+    {
+        const auto& procs = UPstream::localNode_parentProcs();
+        Perr<< "local processors: [" << procs.min()
+            << ".." << procs.max() << ']' << endl;
+    }
+
     // Generate the graph
     if (UPstream::master(UPstream::worldComm))
     {

applications/test/one-sided1/Make/files

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

applications/test/one-sided1/Make/options

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

applications/test/one-sided1/Test-one-sided1.cxx

@@ -0,0 +1,354 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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/>.
+
+Application
+    Test-one-sided1
+
+Description
+    Simple test of one-sided communication
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "Time.H"
+#include "IPstream.H"
+#include "OPstream.H"
+#include "SubField.H"
+#include "vector.H"
+#include "IOstreams.H"
+
+using namespace Foam;
+
+template<class T>
+Ostream& printSpanInfo(Ostream& os, const UList<T>& span)
+{
+    os  << "addr=" << Foam::name(span.cdata())
+        << " size= " << span.size();
+
+    return os;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    argList::noCheckProcessorDirectories();
+    argList::addVerboseOption();
+    argList::addBoolOption("no-shared", "disable shared memory tests");
+    argList::addBoolOption("no-sleep", "disable sleep for async test");
+
+    #include "setRootCase.H"
+
+    const bool with_shared = !args.found("no-shared");
+    const bool with_sleep = !args.found("no-sleep");
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    Info<< nl
+        << "nProcs = " << UPstream::nProcs()
+        << " with " << UPstream::nComms() << " predefined comm(s)" << nl;
+
+    if (!UPstream::parRun())
+    {
+        Info<< "###############" << nl
+            << "Not running in parallel. Stopping now" << nl
+            << "###############" << endl;
+        return 1;
+    }
+
+    const auto myProci = UPstream::myProcNo();
+    const auto numProc = UPstream::nProcs();
+
+    // Make some windows
+    Field<label> buffer(10 + myProci);
+    buffer = myProci;
+
+    Pout<< "input: " << flatOutput(buffer) << endl;
+
+    UPstream::Window win;
+    win.create(buffer, UPstream::worldComm);
+
+    // Pass 1
+    // - grab things from sub-ranks
+    if (UPstream::master())
+    {
+        win.lock_all(true);
+
+        win.get
+        (
+            buffer.slice(4, 2),
+            1,  // target_rank
+            2   // target_disp
+        );
+
+        win.unlock_all();
+    }
+
+    Pout<< "output: " << flatOutput(buffer) << endl;
+
+    // Pass 2:
+    // accumulate into master
+    if (UPstream::is_subrank())
+    {
+        win.lock(0);
+
+        win.put
+        (
+            UPstream::opCodes::op_sum,
+            buffer.slice(2, 4),
+            UPstream::masterNo(),
+            2  // target_disp
+        );
+
+        win.unlock(0);
+    }
+
+    Pout<< "updated: " << flatOutput(buffer) << endl;
+
+    // Pass 3:
+    // Update some values - something very asynchronous
+    if (UPstream::is_subrank())
+    {
+        if (with_sleep)
+        {
+            if (UPstream::myProcNo() % 3)
+            {
+                Foam::sleep(3);
+            }
+            else
+            {
+                Foam::sleep(1);
+            }
+        }
+        buffer *= 10;
+        forAll(buffer, i)
+        {
+            buffer[i] *= 1 + (i % 3);
+        }
+    }
+
+    // Needs a process sync, otherwise master fetches old values
+    UPstream::barrier(UPstream::worldComm);
+
+    label lastValue(-1);
+
+    if (UPstream::master())
+    {
+        win.lock_all(true);
+
+        for (const auto proci : UPstream::subProcs())
+        {
+            win.fetch_and_op
+            (
+                UPstream::opCodes::op_sum,
+                buffer[0],
+                lastValue,
+                proci,
+                2  // target_disp
+            );
+        }
+
+        // Force changes to occur
+        win.flush_all();
+        win.unlock_all();
+    }
+
+
+    Pout<< "last-value : " << lastValue << nl
+        << "final : " << flatOutput(buffer) << endl;
+
+    labelList allUpdates;
+
+    if (UPstream::master())
+    {
+        allUpdates.resize(UPstream::nProcs(), -10);
+
+        win.lock_all(true);
+
+        for (const auto proci : UPstream::subProcs())
+        {
+            win.get_value
+            (
+                allUpdates[proci],
+                proci,
+                2  // target_disp
+            );
+        }
+
+        win.flush_all();
+        win.unlock_all();
+    }
+
+    Info<< "gets: " << flatOutput(allUpdates) << endl;
+
+
+    // This should fail (runtime)
+    #if 0
+    if (UPstream::master())
+    {
+        labelPair value1(-1, -1);
+
+        win.lock_all(true);
+
+        for (const auto proci : UPstream::subProcs())
+        {
+            win.fetch_and_op
+            (
+                UPstream::opCodes::op_sum,
+                value1,
+                lastValue,
+                proci,
+                8  // target_disp
+            );
+        }
+
+        win.unlock_all();
+    }
+    #endif
+
+    // Last thing before closing out
+    // replace values. Not very efficient...
+
+    // Persistent data to move onto target:
+    const label newValue(333);
+    const label multiplier(-3);
+
+    if (UPstream::master())
+    {
+        win.lock_all(true);
+
+        for (const auto proci : UPstream::subProcs())
+        {
+            win.fetch_and_op
+            (
+                UPstream::opCodes::op_replace,
+                newValue,
+                lastValue,
+                proci,  // target_rank
+                3       // target_disp
+            );
+
+            win.put_value
+            (
+                UPstream::opCodes::op_prod,
+                multiplier,
+                proci,  // target_rank
+                5       // target_disp
+            );
+        }
+        win.unlock_all();
+    }
+
+    win.close();  // process collective
+
+    Pout<< "modified: " << flatOutput(buffer) << endl;
+
+    if (with_shared)
+    {
+        // Make some shared window
+        UList<label> newBuffer;
+
+        {
+            label localLen(0);
+
+            if
+            (
+                (myProci == 3)
+             || (myProci == numProc-2)
+            )
+            {
+                localLen = 0;
+            }
+            else
+            {
+                localLen = (10 + UPstream::myProcNo());
+            }
+
+            // Just to prove that we can shallow copy the view...
+            newBuffer =
+                win.allocate_shared<label>(localLen, UPstream::worldComm);
+        }
+
+        newBuffer = UPstream::myProcNo();
+
+        Pout<< "Shared: " << flatOutput(newBuffer) << endl;
+
+        {
+            UList<label> local = win.view<label>();
+            Pout<< "local win: ";
+            printSpanInfo(Pout, local) << endl;
+        }
+
+        Pout<< "Query rank1" << endl;
+
+        {
+            // UPtrList<UList<label>> totalList(UPstream::nProcs());
+            //
+            // totalList.set(0, &newBuffer);
+
+            const label* ptr0 = nullptr;
+
+            {
+                UList<label> buf = win.view_shared<label>(0);
+                ptr0 = buf.cdata();
+
+                Pout<< "addr 0 = " << Foam::name(ptr0)
+                    << " diff = " << label(0)
+                    << " + " << buf.size() << endl;
+            }
+
+            // UList<label> other = win.global_view<label>();
+
+            for (const auto proci : UPstream::subProcs())
+            {
+                UList<label> other = win.view_shared<label>(proci);
+
+                const label* ptr = other.cdata();
+
+                Pout<< "addr " << proci << " = "
+                    << Foam::name(ptr)
+                    << " diff = " << label(ptr - ptr0)
+                    << " + " << other.size() << endl;
+                // totalList.set(proci, &other);
+            }
+        }
+
+        win.close();
+    }
+
+    // Since close() is ignored on null window,
+    // can call it an arbitrary number of times
+    win.close();
+    win.close();
+    win.close();
+
+    Info<< "\nEnd\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/test/pTraits/Make/files

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

applications/test/regex1/Make/files

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

applications/test/regex1/Test-regex1.cxx

@@ -35,11 +35,8 @@ Description
 #include "Switch.H"
 
 #include "stringOps.H"
-#include "SubStrings.H"
+#include "regExp.H"
 #include "regExpCxx.H"
-#ifndef _WIN32
-#include "regExpPosix.H"
-#endif
 
 using namespace Foam;
 
@@ -89,20 +86,6 @@ static Ostream& operator<<(Ostream& os, const regExpCxx::results_type& sm)
 }
 
 
-// Simple output of match groups
-#ifndef _WIN32
-static Ostream& operator<<(Ostream& os, const regExpPosix::results_type& sm)
-{
-    for (std::smatch::size_type i = 1; i < sm.size(); ++i)
-    {
-        os << " " << sm.str(i);
-    }
-
-    return os;
-}
-#endif
-
-
 template<class RegexType>
 void generalTests()
 {
@@ -299,10 +282,6 @@ int main(int argc, char *argv[])
     argList::noFunctionObjects();
     argList::noParallel();
 
-    argList::addBoolOption("cxx", "Test C++11 regular expressions");
-    #ifndef _WIN32
-    argList::addBoolOption("posix", "Test POSIX regular expressions");
-    #endif
     argList::addOption
     (
         "regex",
@@ -321,34 +300,16 @@ int main(int argc, char *argv[])
     #ifdef _GLIBCXX_RELEASE
     Info<< "_GLIBCXX_RELEASE = " << (_GLIBCXX_RELEASE) << nl;
     #endif
-
-    if constexpr (std::is_same_v<regExp, regExpCxx>)
-    {
-        Info<< "Foam::regExp uses C++11 regex" << nl;
-    }
-    #ifndef _WIN32
-    if constexpr (std::is_same_v<regExp, regExpPosix>)
-    {
-        Info<< "Foam::regExp uses POSIX regex" << nl;
-    }
+    #ifdef __clang_major__
+    Info<< "__clang_major__ = " << (__clang_major__) << nl;
     #endif
 
     Info<< "sizeof std::regex:  " << sizeof(std::regex) << nl;
-    Info<< "sizeof regex C++11: " << sizeof(regExpCxx) << nl;
-    #ifndef _WIN32
-    Info<< "sizeof regex POSIX: " << sizeof(regExpPosix) << nl;
-    #endif
+    Info<< "sizeof regExp: " << sizeof(Foam::regExp) << nl;
     Info<< "sizeof word: " << sizeof(Foam::word) << nl;
     Info<< "sizeof wordRe: " << sizeof(Foam::wordRe) << nl;
     Info<< "sizeof keyType: " << sizeof(Foam::keyType) << nl;
 
-    if (!args.count({"cxx", "posix"}))
-    {
-        args.setOption("cxx");
-        Info<< "Assuming -cxx as default" << nl;
-    }
-    Info<< nl;
-
     if (args.found("regex"))
     {
         std::string expr(args["regex"]);
@@ -359,31 +320,15 @@ int main(int argc, char *argv[])
             << "quotemeta: "
             << stringOps::quotemeta(expr, regExpCxx::meta()) << nl
             << nl;
-
-        #ifndef _WIN32
-        Info<< "(posix):" << nl
-            << "meta : " << Switch(regExpPosix::is_meta(expr)) << nl
-            << "quotemeta: "
-            << stringOps::quotemeta(expr, regExpPosix::meta()) << nl
-            << nl;
-        #endif
         Info<< nl;
     }
     else if (args.size() < 2)
     {
         Info<< "No test files specified .. restrict to general tests" << nl;
 
-        if (args.found("cxx"))
         {
             generalTests<regExpCxx>();
         }
-
-        #ifndef _WIN32
-        if (args.found("posix"))
-        {
-            generalTests<regExpPosix>();
-        }
-        #endif
     }
 
     for (label argi = 1; argi < args.size(); ++argi)
@@ -394,17 +339,9 @@ int main(int argc, char *argv[])
         Info<< "Test expressions:" << tests << endl;
         IOobject::writeDivider(Info) << endl;
 
-        if (args.found("cxx"))
         {
             testExpressions<regExpCxx>(tests);
         }
-
-        #ifndef _WIN32
-        if (args.found("posix"))
-        {
-            testExpressions<regExpPosix>(tests);
-        }
-        #endif
     }
 
     Info<< "\nDone" << nl << endl;

applications/test/sigFpe/Make/files

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

applications/test/string/Make/files

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

applications/test/string/Test-string.cxx

@@ -89,7 +89,7 @@ int main(int argc, char *argv[])
 
         inputType in1("move-construct-from");
 
-        Info<<"move construct from " << in1.length() << nl;
+        Info<<"move construct from " << in1.size() << nl;
 
         outputType out1(std::move(in1));
 
@@ -100,7 +100,7 @@ int main(int argc, char *argv[])
         out1 = "some-text-rubbish";
         out1.resize(10);
 
-        Info<<"move assign from " << in1.length() << nl;
+        Info<<"move assign from " << in1.size() << nl;
 
         out1 = std::move(in1);
 
@@ -329,7 +329,7 @@ int main(int argc, char *argv[])
 
     string s2(s.expand());
 
-    cout<< "output string with " << s2.length() << " characters\n";
+    cout<< "output string with " << s2.size() << " characters\n";
     cout<< "ostream<<  >" << s2 << "<\n";
     Info<< "Ostream<<  >" << s2 << "<\n";
     Info<< "hash:" << hex << string::hasher()(s2) << dec << endl;

applications/test/stringList/Make/files

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

applications/test/stringSplit/Make/files

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

applications/test/stringSplit/Test-stringSplit.cxx

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2024 OpenCFD Ltd.
+    Copyright (C) 2017-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -43,18 +43,19 @@ template<class StringType>
 void printSubStrings
 (
     const StringType& str,
-    const SubStrings<StringType>& split
+    const SubStrings& split
 )
 {
     Info<< "string {" << str.size() << " chars} = " << str << nl
         << split.size() << " elements {" << split.length() << " chars}"
         << nl;
 
-    unsigned i = 0;
-    for (const auto s : split)
+    for (unsigned i = 0; i < split.size(); ++i)
     {
-        Info<< "[" << i++ << "] {" << s.length() << " chars} = "
-            << s.str() << nl;
+        const auto& s = split[i];
+        Info<< "[" << i << "] {" << s.length() << " chars} = "
+            << split.view(i) << " == " << s.str()
+            << nl;
     }
 }
 

applications/test/vector/Make/files

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

applications/test/vector/Test-vector.cxx

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2023 OpenCFD Ltd.
+    Copyright (C) 2018-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -32,7 +32,10 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "vectorField.H"
+#include "boolVector.H"
+#include "labelVector.H"
 #include "IOstreams.H"
+#include "FixedList.H"
 #include "Random.H"
 #include <algorithm>
 #include <random>
@@ -125,6 +128,42 @@ void testNormalise(Field<Type>& fld)
 }
 
 
+// Transcribe vectorspace information into a FixedList
+template<class Type>
+void testTranscribe(Type& input)
+{
+    if constexpr
+    (
+        is_vectorspace_v<Type>
+     && std::is_floating_point_v<typename pTraits_cmptType<Type>::type>
+    )
+    {
+        constexpr auto nCmpts = pTraits_nComponents<Type>::value;
+        using cmpt = typename pTraits_cmptType<Type>::type;
+
+        FixedList<cmpt, nCmpts+1> values;
+        values.back() = 100;  // some additional data
+
+        VectorSpaceOps<nCmpts>::copy_n(input.cdata(), values.data());
+
+        Info<< "Transcribed " << input << " => " << values << nl;
+
+        for (auto& val : values)
+        {
+            val *= -1;
+        }
+
+        VectorSpaceOps<nCmpts>::copy_n(values.cdata(), input.data());
+        Info<< "  copied back (-1) as " << input
+            << " from " << values << nl;
+    }
+    else
+    {
+        Info<< "Did not transcribe " << input << nl;
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 //  Main program:
 
@@ -240,6 +279,16 @@ int main(int argc, char *argv[])
         testNormalise(vfld2);
     }
 
+    Info<< nl
+        << "Test transcribing components" << nl;
+    {
+        vector vec1(1.1, 2.2, 3.3);
+        testTranscribe(vec1);
+
+        labelVector vec2(10, 20, 30);
+        testTranscribe(vec2);
+    }
+
     Info<< "\nEnd\n" << nl;
 
     return 0;

applications/test/vectorTools/Make/files

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

applications/utilities/finiteArea/makeFaMesh/checkPatchTopology.H

@@ -108,13 +108,13 @@ Input
             if (numNbrs == 1)
             {
                 //if (pointSetPtr) pointSetPtr->insert(mesh.edges()[meshEdgei]);
-                labelTyp = max(labelTyp, TopoType::OPEN);
+                labelTyp = Foam::max(labelTyp, TopoType::OPEN);
             }
             else if (numNbrs == 0 || numNbrs > 2)
             {
                 if (pointSetPtr) pointSetPtr->insert(mesh.edges()[meshEdgei]);
                 if (badEdgesPtr) badEdgesPtr->insert(edgei);
-                labelTyp = max(labelTyp, TopoType::ILLEGAL);
+                labelTyp = Foam::max(labelTyp, TopoType::ILLEGAL);
             }
         }
         reduce(labelTyp, maxOp<label>());

applications/utilities/mesh/advanced/PDRMesh/PDRMesh.C

@@ -368,7 +368,8 @@ void subsetTopoSets
 
         Info<< "Subsetting " << set.type() << ' ' << set.name() << endl;
 
-        labelHashSet subset(2*min(set.size(), map.size()));
+        labelHashSet subset;
+        subset.reserve(Foam::min(set.size(), map.size()));
 
         // Map the data
         forAll(map, i)

applications/utilities/mesh/advanced/snappyRefineMesh/snappyRefineMesh.C

@@ -142,26 +142,26 @@ scalar getEdgeStats(const primitiveMesh& mesh, const direction excludeCmpt)
 
         if (mag(eVec & x) > 1-edgeTol)
         {
-            minX = min(minX, eMag);
-            maxX = max(maxX, eMag);
+            minX = Foam::min(minX, eMag);
+            maxX = Foam::max(maxX, eMag);
             nX++;
         }
         else if (mag(eVec & y) > 1-edgeTol)
         {
-            minY = min(minY, eMag);
-            maxY = max(maxY, eMag);
+            minY = Foam::min(minY, eMag);
+            maxY = Foam::max(maxY, eMag);
             nY++;
         }
         else if (mag(eVec & z) > 1-edgeTol)
         {
-            minZ = min(minZ, eMag);
-            maxZ = max(maxZ, eMag);
+            minZ = Foam::min(minZ, eMag);
+            maxZ = Foam::max(maxZ, eMag);
             nZ++;
         }
         else
         {
-            minOther = min(minOther, eMag);
-            maxOther = max(maxOther, eMag);
+            minOther = Foam::min(minOther, eMag);
+            maxOther = Foam::max(maxOther, eMag);
         }
     }
 
@@ -179,19 +179,19 @@ scalar getEdgeStats(const primitiveMesh& mesh, const direction excludeCmpt)
 
     if (excludeCmpt == 0)
     {
-        return min(minY, min(minZ, minOther));
+        return Foam::min(minY, Foam::min(minZ, minOther));
     }
     else if (excludeCmpt == 1)
     {
-        return min(minX, min(minZ, minOther));
+        return Foam::min(minX, Foam::min(minZ, minOther));
     }
     else if (excludeCmpt == 2)
     {
-        return min(minX, min(minY, minOther));
+        return Foam::min(minX, Foam::min(minY, minOther));
     }
     else
     {
-        return min(minX, min(minY, min(minZ, minOther)));
+        return Foam::min(minX, Foam::min(minY, Foam::min(minZ, minOther)));
     }
 }
 

applications/utilities/mesh/conversion/ansysToFoam/ansysToFoam.L

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2024 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -49,7 +49,7 @@ Description
 #include <cstdio>
 
 #include "scalar.H"
-#include "StringStream.H"
+#include "SpanStream.H"
 
 #include "argList.H"
 #include "Time.H"
@@ -57,25 +57,23 @@ Description
 #include "emptyPolyPatch.H"
 #include "preservePatchTypes.H"
 #include "cellShape.H"
-#include "SLList.H"
-#include "SLPtrList.H"
 
 // Flex may use register, which is deprecated and incompatible with C++17
 #pragma clang diagnostic ignored "-Wdeprecated-register"
 
 using namespace Foam;
 
-SLList<point> slPoints;
-SLList<label> slPointMap;
+DynamicList<point> dynPoints;
+DynamicList<label> dynPointMap;
 label maxNodei = 0;
 
-SLPtrList<labelList> slCellLabels;
-SLList<label> slCellMap;
-SLList<label> slCellType;
+DynamicList<labelList> dynCellLabels;
+DynamicList<label> dynCellMap;
+DynamicList<label> dynCellType;
 label maxCelli = 0;
 
-PtrList<SLList<label>> slPatchCells;
-PtrList<SLList<label>> slPatchCellFaces;
+// Per patch index, the cell/face pairs
+PtrList<DynamicList<labelPair>> patchCellFaces;
 
 // Cell types
 Map<word> cellTypes;
@@ -126,22 +124,18 @@ elementType           ^{space}"TYPE"{cspace}
 
 %%
 
-%{
-    labelList labels(8);
-%}
-
-
  /* ------------------------------------------------------------------------- *\
                             ------ Start Lexing ------
  \* ------------------------------------------------------------------------- */
 
 {node}{label}{cspace}{x}{cspace}{y}{cspace}{z}{space}\n {
-        IStringStream nodeStream(YYText());
+        ISpanStream is(YYText());
         char tag, c;
         label nodei;
-        point node;
-        nodeStream
-            >> tag
+        point& node = dynPoints.emplace_back();
+
+        is
+            >> tag                  // skip 'N'
             >> c >> nodei
             >> c >> node.x()
             >> c >> node.y()
@@ -149,17 +143,18 @@ elementType           ^{space}"TYPE"{cspace}
 
         if (nodei > maxNodei) maxNodei = nodei;
 
-        slPointMap.append(nodei);
-        slPoints.append(node);
+        dynPointMap.push_back(nodei);
     }
 
 
 {element}{label}{cspace}{label}{cspace}{label}{cspace}{label}{cspace}{label}{cspace}{label}{cspace}{label}{cspace}{label}{cspace}{label}{space}\n {
-        IStringStream elementStream(YYText());
+        ISpanStream is(YYText());
         char tag, c;
         label celli;
-        elementStream
-            >> tag >> tag
+        labelList& labels = dynCellLabels.emplace_back(8);
+
+        is
+            >> tag >> tag           // skip 'EN'
             >> c >> celli
             >> c >> labels[0]
             >> c >> labels[1]
@@ -172,66 +167,50 @@ elementType           ^{space}"TYPE"{cspace}
 
         if (celli > maxCelli) maxCelli = celli;
 
-        slCellMap.append(celli);
-        slCellLabels.append(new labelList(labels));
-        slCellType.append(currentTypei);
+        dynCellMap.push_back(celli);
+        dynCellType.push_back(currentTypei);
     }
 
 
 {bface}{label}{cspace}{label}{cspace}{identifier}{cspace}{integer}{cspace}{value}{space}\n {
-        IStringStream bfaceStream(YYText());
+        ISpanStream is(YYText());
         char tag, c;
-        label elementi;
-        label facei;
+        label elementi, facei;
         scalar indexValue, unknown;
-        bfaceStream
-            >> tag >> tag >> tag
+
+        is
+            >> tag >> tag >> tag    // skip 'SFE'
             >> c >> elementi
             >> c >> facei
             >> c >> tag >> tag >> tag >> tag
             >> c >> unknown
             >> c >> indexValue;
 
-        label patchi = label(indexValue);
+        const label patchi = label(indexValue);
 
-        if (patchi > slPatchCells.size())
+        if (patchCellFaces.size() < patchi)
         {
-            slPatchCells.setSize(patchi);
+            label i = patchCellFaces.size();
 
-            forAll(slPatchCells, i)
+            patchCellFaces.resize(patchi);
+
+            for (; i < patchi; ++i)
             {
-                if (!slPatchCells.set(i))
-                {
-                    slPatchCells.set(i, new SLList<label>);
-                }
+                patchCellFaces.try_emplace(i);
             }
         }
 
-        if (patchi > slPatchCellFaces.size())
-        {
-            slPatchCellFaces.setSize(patchi);
-
-            forAll(slPatchCells, i)
-            {
-                if (!slPatchCellFaces.set(i))
-                {
-                    slPatchCellFaces.set(i, new SLList<label>);
-                }
-            }
-        }
-
-        slPatchCells[patchi-1].append(elementi);
-        slPatchCellFaces[patchi-1].append(facei);
+        patchCellFaces[patchi-1].emplace_back(elementi, facei);
     }
 
 
 {elementTypeName}{label}{cspace}{identifier}{space}\n {
-
-        IStringStream elementStream(YYText());
+        ISpanStream is(YYText());
         char tag,c;
         label cellTypei;
         word cellTypeName;
-        elementStream
+
+        is
             >> tag >> tag           // skip 'ET'
             >> c >> cellTypei
             >> c >> cellTypeName;
@@ -244,10 +223,11 @@ elementType           ^{space}"TYPE"{cspace}
 
 
 {elementType}{label}{space}\n {
-        IStringStream elementStream(YYText());
+        ISpanStream is(YYText());
         char tag,c;
         label cellTypei;
-        elementStream
+
+        is
             >> tag >> tag >> tag >> tag     // skip 'TYPE'
             >> c >> cellTypei;
 
@@ -281,10 +261,8 @@ label findFace(const polyMesh& mesh, const face& f)
 {
     const labelList& pFaces = mesh.pointFaces()[f[0]];
 
-    forAll(pFaces, i)
+    for (const label facei : pFaces)
     {
-        label facei = pFaces[i];
-
         if (mesh.faces()[facei] == f)
         {
             return facei;
@@ -323,7 +301,8 @@ int main(int argc, char *argv[])
         FatalError.exit();
     }
 
-    const scalar scaleFactor = args.getOrDefault<scalar>("scale", 1);
+    // Actually uses default=0 to skip unnecessary scaling by factor 1.
+    const scalar scaleFactor = args.getOrDefault<scalar>("scale", 0);
 
     #include "createTime.H"
 
@@ -344,32 +323,32 @@ int main(int argc, char *argv[])
 
     Info<< "Creating points" << endl;
 
-    pointField points(slPoints.size());
+    pointField points(std::move(dynPoints));
 
-    label i = 0;
-    for (const point& pt : slPoints)
+    // Scale points by the given scale factor
+    if (scaleFactor > 0)
     {
-        // Scale points for the given scale factor
-        points[i++] = scaleFactor * pt;
+        points *= scaleFactor;
     }
 
-
     labelList pointMap(maxNodei+1);
-
-    i = 0;
-    for (const label pointi : slPointMap)
     {
-        pointMap[pointi] = i++;
+        label i = 0;
+        for (const label pointi : dynPointMap)
+        {
+            pointMap[pointi] = i++;
+        }
     }
 
     Info<< "Creating cells" << endl;
 
     labelList cellMap(maxCelli+1);
-
-    i = 0;
-    for (const label celli : slCellMap)
     {
-        cellMap[celli] = i++;
+        label i = 0;
+        for (const label celli : dynCellMap)
+        {
+            cellMap[celli] = i++;
+        }
     }
 
 
@@ -378,15 +357,15 @@ int main(int argc, char *argv[])
     const cellModel& pyr = cellModel::ref(cellModel::PYR);
     const cellModel& tet = cellModel::ref(cellModel::TET);
 
-    labelList labelsHex(8);
-    labelList labelsPrism(6);
-    labelList labelsPyramid(5);
-    labelList labelsTet(4);
+    FixedList<label, 8> labelsHex;
+    FixedList<label, 6> labelsPrism;
+    FixedList<label, 5> labelsPyramid;
+    FixedList<label, 4> labelsTet;
 
-    cellShapeList cellShapes(slCellLabels.size());
+    cellShapeList cellShapes(dynCellLabels.size());
     label nCells = 0;
 
-    for (const labelList& labels : slCellLabels)
+    for (const labelList& labels : dynCellLabels)
     {
         if      // Tetrahedron
         (
@@ -490,37 +469,29 @@ int main(int argc, char *argv[])
 
     Info<< "Creating boundary patches" << endl;
 
-    faceListList boundary(slPatchCells.size());
-    wordList patchNames(slPatchCells.size());
+    faceListList boundary(patchCellFaces.size());
+    wordList patchNames(patchCellFaces.size());
 
-    forAll(slPatchCells, patchi)
+    forAll(patchCellFaces, patchi)
     {
-        SLList<face> patchFaces;
+        DynamicList<face> patchFaces;
 
-        auto cellIter = slPatchCells[patchi].cbegin();
-        auto faceIter = slPatchCellFaces[patchi].cbegin();
+        patchFaces.reserve(patchCellFaces[patchi].size());
 
-        for
-        (
-            ;
-            cellIter.good() && faceIter.good();
-            ++cellIter, ++faceIter
-        )
+        for (const auto& tup : patchCellFaces[patchi])
         {
-            const cellShape& shape = cellShapes[cellMap[cellIter()]];
+            const label celli = tup.first();
+            const label facei = tup.second();
 
-            patchFaces.append
+            const cellShape& shape = cellShapes[cellMap[celli]];
+
+            patchFaces.push_back
             (
-                shape.faces()
-                [
-                    faceIndex
-                        [shape.nFaces()]
-                        [faceIter()-1]
-                ]
+                shape.faces()[faceIndex[shape.nFaces()][facei-1]]
             );
         }
 
-        boundary[patchi] = patchFaces;
+        boundary[patchi] = std::move(patchFaces);
         patchNames[patchi] = polyPatch::defaultName(patchi + 1);
     }
 
@@ -543,8 +514,8 @@ int main(int argc, char *argv[])
 
     // Now split the boundary faces into external and internal faces. All
     // faces go into faceZones and external faces go into patches.
-    List<faceList> patchFaces(slPatchCells.size());
-    labelList patchNFaces(slPatchCells.size(), Zero);
+    List<faceList> patchFaces(patchCellFaces.size());
+    labelList patchNFaces(patchCellFaces.size(), Zero);
     forAll(boundary, patchi)
     {
         const faceList& bFaces = boundary[patchi];
@@ -644,7 +615,7 @@ int main(int argc, char *argv[])
                 Info<< "Creating faceZone " <<  patchNames[patchi]
                     << " with " << bFaceLabels.size() << " faces" << endl;
 
-                fz.append
+                fz.push_back
                 (
                     new faceZone
                     (
@@ -660,29 +631,20 @@ int main(int argc, char *argv[])
 
 
         // CellZones
-        labelList types = cellTypes.sortedToc();
-
-        forAll(types, typei)
+        for (const label cellType : cellTypes.sortedToc())
         {
-            const label cellType = types[typei];
-
             // Pick up cells in zone
             DynamicList<label> addr;
 
-            auto cellMapIter = slCellMap.cbegin();
-            auto typeIter = slCellType.cbegin();
+            auto cellMapIter = dynCellMap.cbegin();
 
-            for
-            (
-                ;
-                typeIter.good();
-                ++typeIter, ++cellMapIter
-            )
+            for (const auto& ctype : dynCellType)
             {
-                if (typeIter() == cellType)
+                if (ctype == cellType)
                 {
-                    addr.append(cellMap[cellMapIter()]);
+                    addr.push_back(cellMap[*cellMapIter]);
                 }
+                ++cellMapIter;
             }
 
             Info<< "Creating cellZone " << cellTypes[cellType]
@@ -694,7 +656,7 @@ int main(int argc, char *argv[])
                 (
                     cellTypes[cellType],
                     addr,
-                    typei,
+                    cz.size(),
                     pShapeMesh.cellZones()
                 )
             );

applications/utilities/mesh/conversion/cfx4ToFoam/cfx4ToFoam.C

@@ -271,7 +271,7 @@ int main(int argc, char *argv[])
                     if (blockPFacePointi != blockPFacePointi2)
                     {
                         sqrMergeTol =
-                            min
+                            Foam::min
                             (
                                 sqrMergeTol,
                                 magSqr
@@ -338,16 +338,16 @@ int main(int argc, char *argv[])
                         blockNFacePoints[blockNFacePointi]
                       + blockOffsets[blockNlabel];
 
-                    label minPN = min(PpointLabel, NpointLabel);
+                    label minPN = Foam::min(PpointLabel, NpointLabel);
 
                     if (pointMergeList[PpointLabel] != -1)
                     {
-                        minPN = min(minPN, pointMergeList[PpointLabel]);
+                        minPN = Foam::min(minPN, pointMergeList[PpointLabel]);
                     }
 
                     if (pointMergeList[NpointLabel] != -1)
                     {
-                        minPN = min(minPN, pointMergeList[NpointLabel]);
+                        minPN = Foam::min(minPN, pointMergeList[NpointLabel]);
                     }
 
                     pointMergeList[PpointLabel]
@@ -411,7 +411,7 @@ int main(int argc, char *argv[])
 
                         pointMergeList[PpointLabel]
                       = pointMergeList[NpointLabel]
-                      = min
+                      = Foam::min
                         (
                             pointMergeList[PpointLabel],
                             pointMergeList[NpointLabel]

applications/utilities/mesh/conversion/ensightToFoam/ensightMeshReader.C

@@ -645,7 +645,7 @@ bool Foam::fileFormats::ensightMeshReader::readGeometry
 
 
     // Parse all
-    SubStrings<string> split;
+    SubStrings split;
 
     while (is.good())
     {

applications/utilities/mesh/conversion/gambitToFoam/gambitToFoam.L

@@ -350,7 +350,7 @@ mtype                 {space}"MTYPE:"{space}
         // Find out how many labels are expected. If less or equal to
         // seven, read them all and finish with it. If there is more,
         // set read of the next line
-        label labelsToRead = min(8, nVertices);
+        label labelsToRead = Foam::min(8, nVertices);
         label labelI = 0;
         for (; labelI < labelsToRead; labelI++)
         {
@@ -387,7 +387,7 @@ mtype                 {space}"MTYPE:"{space}
 
         labelList& curLabels = cellLabels[curNumberOfCells];
 
-        label labelsToRead = min
+        label labelsToRead = Foam::min
         (
             (nCellContinuationLines + 1)*7,
             curLabels.size()

applications/utilities/mesh/conversion/ideasUnvToFoam/ideasUnvToFoam.C

@@ -269,7 +269,7 @@ void readCells
     label maxUnvPoint = 0;
     forAll(unvPointID, pointi)
     {
-        maxUnvPoint = max(maxUnvPoint, unvPointID[pointi]);
+        maxUnvPoint = Foam::max(maxUnvPoint, unvPointID[pointi]);
     }
     labelList unvToFoam(invert(maxUnvPoint+1, unvPointID));
 
@@ -784,7 +784,7 @@ int main(int argc, char *argv[])
     label maxUnvPoint = 0;
     forAll(unvPointID, pointi)
     {
-        maxUnvPoint = max(maxUnvPoint, unvPointID[pointi]);
+        maxUnvPoint = Foam::max(maxUnvPoint, unvPointID[pointi]);
     }
     labelList unvToFoam(invert(maxUnvPoint+1, unvPointID));
 

applications/utilities/mesh/conversion/kivaToFoam/checkPatch.H

@@ -8,10 +8,10 @@
         {
             if (kivaVersion == kiva3v)
             {
-                regionIndex = max
+                regionIndex = Foam::max
                 (
-                    max(idface[quadFace[0]], idface[quadFace[1]]),
-                    max(idface[quadFace[2]], idface[quadFace[3]])
+                    Foam::max(idface[quadFace[0]], idface[quadFace[1]]),
+                    Foam::max(idface[quadFace[2]], idface[quadFace[3]])
                 );
 
                 if (regionIndex > 0)

applications/utilities/mesh/conversion/kivaToFoam/readKivaGrid.H

@@ -148,7 +148,7 @@ for (label i=0; i<nPoints; i++)
                     end = pointMap[end];
                 }
 
-                label minLabel = min(start, end);
+                label minLabel = Foam::min(start, end);
 
                 pointMap[start] = pointMap[end] = minLabel;
             }
@@ -181,7 +181,7 @@ forAll(cellShapes, celli)
 
 label bcIDs[11] = {-1, 0, 2, 4, -1, 5, -1, 6, 7, 8, 9};
 
-const label nBCs = 12;
+constexpr label nBCs = 12;
 
 const word* kivaPatchTypes[nBCs] =
 {
@@ -232,7 +232,7 @@ const char* kivaPatchNames[nBCs] =
 };
 
 
-List<SLList<face>> pFaces[nBCs];
+List<DynamicList<face>> pFaces[nBCs];
 
 face quadFace(4);
 face triFace(3);
@@ -331,29 +331,29 @@ if
     {
         forAll(pf, pfi)
         {
-            minz = min(minz, points[pf[pfi]].z());
+            minz = Foam::min(minz, points[pf[pfi]].z());
         }
     }
 
     minz += SMALL;
 
-    SLList<face> newLinerFaces;
+    DynamicList<face> newLinerFaces;
 
     for (const face& pf : pFaces[LINER][0])
     {
         scalar minfz = GREAT;
-        forAll(pf, pfi)
+        for (const label pointi : pf)
         {
-            minfz = min(minfz, points[pf[pfi]].z());
+            minfz = Foam::min(minfz, points[pointi].z());
         }
 
         if (minfz > minz)
         {
-            pFaces[CYLINDERHEAD][0].append(pf);
+            pFaces[CYLINDERHEAD][0].push_back(pf);
         }
         else
         {
-            newLinerFaces.append(pf);
+            newLinerFaces.push_back(pf);
         }
     }
 
@@ -361,33 +361,33 @@ if
     {
         Info<< "Transferred " << pFaces[LINER][0].size() - newLinerFaces.size()
             << " faces from liner region to cylinder head" << endl;
-        pFaces[LINER][0] = newLinerFaces;
+        pFaces[LINER][0] = std::move(newLinerFaces);
     }
 
-    SLList<face> newCylinderHeadFaces;
+    DynamicList<face> newCylinderHeadFaces;
 
     for (const face& pf : pFaces[CYLINDERHEAD][0])
     {
         scalar minfz = GREAT;
-        forAll(pf, pfi)
+        for (const label pointi : pf)
         {
-            minfz = min(minfz, points[pf[pfi]].z());
+            minfz = Foam::min(minfz, points[pointi].z());
         }
 
         if (minfz < zHeadMin)
         {
-            pFaces[LINER][0].append(pf);
+            pFaces[LINER][0].push_back(pf);
         }
         else
         {
-            newCylinderHeadFaces.append(pf);
+            newCylinderHeadFaces.push_back(pf);
         }
     }
 
     if (pFaces[CYLINDERHEAD][0].size() != newCylinderHeadFaces.size())
     {
         Info<< "Transferred faces from cylinder-head region to linder" << endl;
-        pFaces[CYLINDERHEAD][0] = newCylinderHeadFaces;
+        pFaces[CYLINDERHEAD][0] = std::move(newCylinderHeadFaces);
     }
 }
 
@@ -396,9 +396,9 @@ if
 label nPatches = 0;
 for (int bci=0; bci<nBCs; bci++)
 {
-    forAll(pFaces[bci], rgi)
+    for (const auto& faces : pFaces[bci])
     {
-        if (pFaces[bci][rgi].size())
+        if (faces.size())
         {
             nPatches++;
         }
@@ -415,31 +415,34 @@ if (pFaces[WEDGE].size() && pFaces[WEDGE][0].size())
 
         const scalar tanTheta = Foam::tan(degToRad(2.5));
 
-        auto iterf = pFaces[WEDGE][0].begin();
-        auto iterb = pFaces[WEDGE][1].begin();
+        auto iterf = pFaces[WEDGE][0].cbegin();
+        auto iterb = pFaces[WEDGE][1].cbegin();
+
+        const auto end_iterf = pFaces[WEDGE][0].cend();
+        const auto end_iterb = pFaces[WEDGE][1].cend();
 
         for
         (
             ;
-            iterf.good() && iterb.good();
+            (iterf != end_iterf) && (iterb != end_iterb);
             ++iterf, ++iterb
         )
         {
+            const auto& facef = *iterf;
+            const auto& faceb = *iterb;
+
             for (direction d=0; d<4; d++)
             {
-                points[iterf()[d]].y() = -tanTheta*points[iterf()[d]].x();
-                points[iterb()[d]].y() =  tanTheta*points[iterb()[d]].x();
+                points[facef[d]].y() = -tanTheta*points[facef[d]].x();
+                points[faceb[d]].y() =  tanTheta*points[faceb[d]].x();
             }
         }
     }
     else
     {
-        pFaces[CYCLIC].setSize(1);
+        pFaces[CYCLIC].resize(1);
         pFaces[CYCLIC][0] = pFaces[WEDGE][0];
-        for (const face& pf : pFaces[WEDGE][1])
-        {
-            pFaces[CYCLIC][0].append(pf);
-        }
+        pFaces[CYCLIC][0].push_back(pFaces[WEDGE][1]);
 
         pFaces[WEDGE].clear();
         nPatches--;

applications/utilities/mesh/conversion/netgenNeutralToFoam/netgenNeutralToFoam.C

@@ -188,7 +188,7 @@ int main(int argc, char *argv[])
         }
 
 
-        maxPatch = max(maxPatch, patchi);
+        maxPatch = Foam::max(maxPatch, patchi);
 
         triFace tri(readLabel(str)-1, readLabel(str)-1, readLabel(str)-1);
 

applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/extrudeToRegionMesh.C

@@ -556,8 +556,8 @@ void calcEdgeMinMaxZone
             forAll(eFaces, i)
             {
                 label zoneI = mappedZoneID[eFaces[i]];
-                minZoneID[edgeI] = min(minZoneID[edgeI], zoneI);
-                maxZoneID[edgeI] = max(maxZoneID[edgeI], zoneI);
+                minZoneID[edgeI] = Foam::min(minZoneID[edgeI], zoneI);
+                maxZoneID[edgeI] = Foam::max(maxZoneID[edgeI], zoneI);
             }
         }
     }
@@ -661,8 +661,8 @@ void countExtrudePatches
     }
     // Synchronise decision. Actual numbers are not important, just make
     // sure that they're > 0 on all processors.
-    Pstream::listCombineReduce(zoneSidePatch, plusEqOp<label>());
-    Pstream::listCombineReduce(zoneZonePatch, plusEqOp<label>());
+    Pstream::listReduce(zoneSidePatch, sumOp<label>());
+    Pstream::listReduce(zoneZonePatch, sumOp<label>());
 }
 
 
@@ -813,8 +813,8 @@ void addCoupledPatches
             forAll(eFaces, i)
             {
                 label proci = procID[eFaces[i]];
-                minProcID[edgeI] = min(minProcID[edgeI], proci);
-                maxProcID[edgeI] = max(maxProcID[edgeI], proci);
+                minProcID[edgeI] = Foam::min(minProcID[edgeI], proci);
+                maxProcID[edgeI] = Foam::max(maxProcID[edgeI], proci);
             }
         }
     }
@@ -1291,7 +1291,7 @@ void extrudeGeometricProperties
             label celli = regionMesh.faceOwner()[facei];
             if (regionMesh.isInternalFace(facei))
             {
-                celli = max(celli, regionMesh.faceNeighbour()[facei]);
+                celli = Foam::max(celli, regionMesh.faceNeighbour()[facei]);
             }
 
             // Calculate layer from cell numbering (see createShellMesh)
@@ -2210,8 +2210,8 @@ int main(int argc, char *argv[])
 
             if (addSidePatches && (zone0 != zone1)) // || (cos(angle) > blabla))
             {
-                label minZone = min(zone0,zone1);
-                label maxZone = max(zone0,zone1);
+                label minZone = Foam::min(zone0,zone1);
+                label maxZone = Foam::max(zone0,zone1);
                 label index = minZone*zoneNames.size()+maxZone;
 
                 ePatches.setSize(eFaces.size());

applications/utilities/mesh/generation/foamyMesh/foamyHexMeshSurfaceSimplify/Make/options

@@ -3,6 +3,7 @@ MarchingCubes = fastdualoctree_sgp
 include $(GENERAL_RULES)/cgal
 
 EXE_INC = \
+    $(c++LESSWARN) \
     -DUNIX \
     /* -IMarchingCubes */ \
     -I$(FASTDUALOCTREE_SRC_PATH) \

applications/utilities/mesh/manipulation/checkMesh/writeFields.C

@@ -26,7 +26,7 @@ void maxFaceToCell
         const cell& cFaces = cells[cellI];
         forAll(cFaces, i)
         {
-            cellFld[cellI] = max(cellFld[cellI], faceData[cFaces[i]]);
+            cellFld[cellI] = Foam::max(cellFld[cellI], faceData[cFaces[i]]);
         }
     }
 
@@ -56,7 +56,7 @@ void minFaceToCell
         const cell& cFaces = cells[cellI];
         forAll(cFaces, i)
         {
-            cellFld[cellI] = min(cellFld[cellI], faceData[cFaces[i]]);
+            cellFld[cellI] = Foam::min(cellFld[cellI], faceData[cFaces[i]]);
         }
     }
 
@@ -87,8 +87,8 @@ void minFaceToCell
     // Internal faces
     forAll(own, facei)
     {
-        cellFld[own[facei]] = min(cellFld[own[facei]], faceData[facei]);
-        cellFld[nei[facei]] = min(cellFld[nei[facei]], faceData[facei]);
+        cellFld[own[facei]] = Foam::min(cellFld[own[facei]], faceData[facei]);
+        cellFld[nei[facei]] = Foam::min(cellFld[nei[facei]], faceData[facei]);
     }
 
     // Patch faces
@@ -99,7 +99,7 @@ void minFaceToCell
 
         forAll(fc, i)
         {
-            cellFld[fc[i]] = min(cellFld[fc[i]], fvp[i]);
+            cellFld[fc[i]] = Foam::min(cellFld[fc[i]], fvp[i]);
         }
     }
 
@@ -178,7 +178,14 @@ void Foam::writeFields
         (
             radToDeg
             (
-                Foam::acos(min(scalar(1), max(scalar(-1), faceOrthogonality)))
+                Foam::acos
+                (
+                    Foam::min
+                    (
+                        scalar(1),
+                        Foam::max(scalar(-1), faceOrthogonality)
+                    )
+                )
             )
         );
 
@@ -534,7 +541,7 @@ void Foam::writeFields
                         ownCc,
                         fc
                     ).quality();
-                    ownVol = min(ownVol, tetQual);
+                    ownVol = Foam::min(ownVol, tetQual);
                 }
             }
             if (mesh.isInternalFace(facei))
@@ -550,7 +557,7 @@ void Foam::writeFields
                         fc,
                         neiCc
                     ).quality();
-                    neiVol = min(neiVol, tetQual);
+                    neiVol = Foam::min(neiVol, tetQual);
                 }
             }
         }
@@ -602,8 +609,10 @@ void Foam::writeFields
         // Internal faces
         forAll(own, facei)
         {
-            cellFld[own[facei]] = min(cellFld[own[facei]], ownPyrVol[facei]);
-            cellFld[nei[facei]] = min(cellFld[nei[facei]], neiPyrVol[facei]);
+            cellFld[own[facei]] =
+                Foam::min(cellFld[own[facei]], ownPyrVol[facei]);
+            cellFld[nei[facei]] =
+                Foam::min(cellFld[nei[facei]], neiPyrVol[facei]);
         }
 
         // Patch faces
@@ -614,7 +623,8 @@ void Foam::writeFields
             forAll(fc, i)
             {
                 const label meshFacei = fvp.patch().start();
-                cellFld[fc[i]] = min(cellFld[fc[i]], ownPyrVol[meshFacei]);
+                cellFld[fc[i]] =
+                    Foam::min(cellFld[fc[i]], ownPyrVol[meshFacei]);
             }
         }
 
@@ -625,7 +635,7 @@ void Foam::writeFields
         if (writeFaceFields)
         {
             scalarField minFacePyrVol(neiPyrVol);
-            minFacePyrVol = min
+            minFacePyrVol = Foam::min
             (
                 minFacePyrVol,
                 SubField<scalar>(ownPyrVol, mesh.nInternalFaces())

applications/utilities/mesh/manipulation/objToVTK/objToVTK.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -37,7 +37,7 @@ Description
 
 #include "argList.H"
 #include "OFstream.H"
-#include "StringStream.H"
+#include "stringOps.H"
 #include "point.H"
 #include "DynamicList.H"
 
@@ -58,58 +58,49 @@ string getLine(std::ifstream& is)
 }
 
 
-// Read space-separated vertices (with optional '/' arguments)
-labelList parseVertices(const string& line)
+// Token list with one of the following:
+//     f v1 v2 v3 ...
+//     f v1/vt1 v2/vt2 v3/vt3 ...
+//     l v1 v2 v3 ...
+//     l v1/vt1 v2/vt2 v3/vt3 ...
+static label readObjVertices
+(
+    const SubStrings& tokens,
+    DynamicList<label>& verts
+)
 {
-    DynamicList<label> verts;
+    verts.clear();
 
-    // Assume 'l' is followed by space.
-    string::size_type endNum = 1;
-
-    do
+    bool first = true;
+    for (const auto& tok : tokens)
     {
-        string::size_type startNum = line.find_first_not_of(' ', endNum);
-
-        if (startNum == string::npos)
+        if (first)
         {
-            break;
+            // skip initial "f" or "l"
+            first = false;
+            continue;
         }
 
-        endNum = line.find(' ', startNum);
+        std::string vrtSpec(tok.str());
 
-        string vertexSpec;
-        if (endNum != string::npos)
+        if
+        (
+            const auto slash = vrtSpec.find('/');
+            slash != std::string::npos
+        )
         {
-            vertexSpec = line.substr(startNum, endNum-startNum);
-        }
-        else
-        {
-            vertexSpec = line.substr(startNum, line.size() - startNum);
+            vrtSpec.erase(slash);
         }
 
-        string::size_type slashPos = vertexSpec.find('/');
+        label vertId = readLabel(vrtSpec);
 
-        label vertI = 0;
-        if (slashPos != string::npos)
-        {
-            IStringStream intStream(vertexSpec.substr(0, slashPos));
-
-            intStream >> vertI;
-        }
-        else
-        {
-            IStringStream intStream(vertexSpec);
-
-            intStream >> vertI;
-        }
-        verts.append(vertI - 1);
+        verts.push_back(vertId - 1);
     }
-    while (true);
 
-    return verts.shrink();
+    return verts.size();
 }
 
-
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 int main(int argc, char *argv[])
 {
@@ -142,6 +133,8 @@ int main(int argc, char *argv[])
     DynamicList<labelList> polyLines;
     DynamicList<labelList> polygons;
 
+    DynamicList<label> dynVerts;
+
     bool hasWarned = false;
 
     label lineNo = 0;
@@ -152,33 +145,58 @@ int main(int argc, char *argv[])
 
         if (line.empty()) continue;
 
-        // Read first word
-        IStringStream lineStream(line);
-        word cmd(lineStream);
+        const auto tokens = stringOps::splitSpace(line);
+
+        // Require command and some arguments
+        if (tokens.size() < 2)
+        {
+            continue;
+        }
+
+        const word cmd = word::validate(tokens[0]);
 
         if (cmd == "v")
         {
-            scalar x, y, z;
+            // Vertex
+            // v x y z
 
-            lineStream >> x >> y >> z;
-
-            points.append(point(x, y, z));
+            points.emplace_back
+            (
+                readScalar(tokens[1]),
+                readScalar(tokens[2]),
+                readScalar(tokens[3])
+            );
         }
         else if (cmd == "vn")
         {
-            scalar x, y, z;
+            // Vertex normals
+            // vn x y z
 
-            lineStream >> x >> y >> z;
-
-            pointNormals.append(vector(x, y, z));
+            pointNormals.emplace_back
+            (
+                readScalar(tokens[1]),
+                readScalar(tokens[2]),
+                readScalar(tokens[3])
+            );
         }
         else if (cmd == "l")
         {
-            polyLines.append(parseVertices(line));
+            // Line
+            // l v1 v2 v3 ...
+            // OR
+            // l v1/vt1 v2/vt2 v3/vt3 ...
+
+            readObjVertices(tokens, dynVerts);
+            polyLines.emplace_back() = dynVerts;
         }
         else if (cmd == "f")
         {
-            polygons.append(parseVertices(line));
+            // f v1 v2 v3 ...
+            // OR
+            // f v1/vt1 v2/vt2 v3/vt3 ...
+
+            readObjVertices(tokens, dynVerts);
+            polygons.emplace_back() = dynVerts;
         }
         else if (cmd != "")
         {
@@ -188,7 +206,7 @@ int main(int argc, char *argv[])
 
                 WarningInFunction
                     << "Unrecognized OBJ command " << cmd << nl
-                    << "In line " << lineStream.str()
+                    << "In line " << line
                     << " at linenumber " << lineNo << nl
                     << "Only recognized commands are 'v' and 'l'.\n"
                     << "If this is a surface command use surfaceConvert instead"
@@ -230,46 +248,42 @@ int main(int argc, char *argv[])
     }
 
     label nItems = 0;
-    forAll(polyLines, polyI)
+    for (const labelList& line : polyLines)
     {
-        nItems += polyLines[polyI].size() + 1;
+        nItems += line.size() + 1;
     }
 
     outFile
         << "LINES " << polyLines.size() << ' ' << nItems << nl;
 
-    forAll(polyLines, polyI)
+    for (const labelList& line : polyLines)
     {
-        const labelList& line = polyLines[polyI];
-
         outFile << line.size();
 
-        forAll(line, i)
+        for (const label vrt : line)
         {
-            outFile << ' ' << line[i];
+            outFile << ' ' << vrt;
         }
         outFile << nl;
     }
 
 
     nItems = 0;
-    forAll(polygons, polyI)
+    for (const labelList& line : polygons)
     {
-        nItems += polygons[polyI].size() + 1;
+        nItems += line.size() + 1;
     }
 
     outFile
         << "POLYGONS " << polygons.size() << ' ' << nItems << nl;
 
-    forAll(polygons, polyI)
+    for (const labelList& line : polygons)
     {
-        const labelList& line = polygons[polyI];
-
         outFile << line.size();
 
-        forAll(line, i)
+        for (const label vrt : line)
         {
-            outFile << ' ' << line[i];
+            outFile << ' ' << vrt;
         }
         outFile << nl;
     }

applications/utilities/mesh/manipulation/refineMesh/refineMesh.C

@@ -100,26 +100,26 @@ void printEdgeStats(const polyMesh& mesh)
 
             if (mag(eVec & x) > 1-edgeTol)
             {
-                minX = min(minX, eMag);
-                maxX = max(maxX, eMag);
+                minX = Foam::min(minX, eMag);
+                maxX = Foam::max(maxX, eMag);
                 nX++;
             }
             else if (mag(eVec & y) > 1-edgeTol)
             {
-                minY = min(minY, eMag);
-                maxY = max(maxY, eMag);
+                minY = Foam::min(minY, eMag);
+                maxY = Foam::max(maxY, eMag);
                 nY++;
             }
             else if (mag(eVec & z) > 1-edgeTol)
             {
-                minZ = min(minZ, eMag);
-                maxZ = max(maxZ, eMag);
+                minZ = Foam::min(minZ, eMag);
+                maxZ = Foam::max(maxZ, eMag);
                 nZ++;
             }
             else
             {
-                minOther = min(minOther, eMag);
-                maxOther = max(maxOther, eMag);
+                minOther = Foam::min(minOther, eMag);
+                maxOther = Foam::max(maxOther, eMag);
             }
         }
     }

applications/utilities/mesh/manipulation/renumberMesh/renumberMesh.C

@@ -465,7 +465,7 @@ labelList getRegionFaceOrder
 
     // Do region interfaces
     {
-        const label nRegions = max(cellToRegion)+1;
+        const label nRegions = Foam::max(cellToRegion)+1;
 
         // Sort in increasing region
         SortableList<label> sortKey(mesh.nInternalFaces(), labelMax);
@@ -478,8 +478,10 @@ labelList getRegionFaceOrder
             if (ownRegion != neiRegion)
             {
                 sortKey[facei] =
-                    min(ownRegion, neiRegion)*nRegions
-                   +max(ownRegion, neiRegion);
+                (
+                    Foam::min(ownRegion, neiRegion)*nRegions
+                  + Foam::max(ownRegion, neiRegion)
+                );
             }
         }
 

applications/utilities/mesh/manipulation/setSet/setSet.C

@@ -320,10 +320,10 @@ bool doCommand
     const globalMeshData& parData = mesh.globalData();
 
     label typSize =
-        max
+        Foam::max
         (
             parData.nTotalCells(),
-            max
+            Foam::max
             (
                 parData.nTotalFaces(),
                 parData.nTotalPoints()
@@ -375,7 +375,7 @@ bool doCommand
 
                 topoSet& currentSet = currentSetPtr();
                 // Presize it according to current mesh data.
-                currentSet.reserve(max(currentSet.size(), typSize));
+                currentSet.reserve(Foam::max(currentSet.size(), typSize));
             }
         }
 

applications/utilities/mesh/manipulation/splitMeshRegions/splitMeshRegions.C

@@ -269,11 +269,7 @@ void addToInterface
     EdgeMap<Map<label>>& regionsToSize
 )
 {
-    edge interface
-    (
-        min(ownRegion, neiRegion),
-        max(ownRegion, neiRegion)
-    );
+    const edge interface(ownRegion, neiRegion, true);  // sort=true
 
     auto iter = regionsToSize.find(interface);
 
@@ -509,11 +505,7 @@ void getInterfaceSizes
                 zoneID = mesh.faceZones().whichZone(facei);
             }
 
-            edge interface
-            (
-                min(ownRegion, neiRegion),
-                max(ownRegion, neiRegion)
-            );
+            const edge interface(ownRegion, neiRegion, true);  // sort=true
 
             faceToInterface[facei] = regionsToInterface[interface][zoneID];
         }
@@ -532,11 +524,7 @@ void getInterfaceSizes
                 zoneID = mesh.faceZones().whichZone(facei);
             }
 
-            edge interface
-            (
-                min(ownRegion, neiRegion),
-                max(ownRegion, neiRegion)
-            );
+            const edge interface(ownRegion, neiRegion, true);  // sort=true
 
             faceToInterface[facei] = regionsToInterface[interface][zoneID];
         }
@@ -1081,7 +1069,7 @@ label findCorrespondingRegion
         }
     }
 
-    Pstream::listCombineReduce(cellsInZone, plusEqOp<label>());
+    Pstream::listReduce(cellsInZone, sumOp<label>());
 
     // Pick region with largest overlap of zoneI
     label regionI = findMax(cellsInZone);

applications/utilities/mesh/manipulation/subsetMesh/subsetMesh.C

@@ -295,7 +295,8 @@ void subsetTopoSets
 
         Info<< "Subsetting " << set.type() << " " << set.name() << endl;
 
-        labelHashSet subset(2*min(set.size(), map.size()));
+        labelHashSet subset;
+        subset.reserve(Foam::min(set.size(), map.size()));
 
         // Map the data
         forAll(map, i)

applications/utilities/miscellaneous/OSspecific/addr2line/Make/files

@@ -1,3 +1,3 @@
-addr2line.C
+addr2line.cxx
 
 EXE = $(FOAM_APPBIN)/addr2line

applications/utilities/miscellaneous/OSspecific/addr2line/Make/options

@@ -1,2 +1,6 @@
+/* Disable normal project defaults */
+PROJECT_INC =
+PROJECT_LIBS =
+
 /* EXE_INC = */
 /* EXE_LIBS = */

applications/utilities/miscellaneous/OSspecific/addr2line/addr2line.cxx

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2018 Alexey Matveichev
+    Copyright (C) 2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -33,12 +34,11 @@ Description
 
 #include <getopt.h>
 #include <cstdlib>
+#include <regex>
 #include <string>
 #include <vector>
 #include <iostream>
 
-#include "regExp.H"
-#include "SubStrings.H"
 
 static void usage();
 static void version();
@@ -53,7 +53,6 @@ int main(int argc, char *argv[])
     int optHelp = 0, optFunctions = 0, optVersion = 0;
     int ch;
     std::string filename = "a.out";
-    std::vector<std::string> addresses;
 
     static struct option opts[] =
     {
@@ -100,15 +99,9 @@ int main(int argc, char *argv[])
     argc -= optind;
     argv += optind;
 
-    while (argc > 0)
-    {
-        addresses.push_back(std::string(*argv));
-        ++argv;
-        --argc;
-    }
-
-    for (const auto& addr : addresses)
+    for (std::string addr; argc > 0; --argc, ++argv)
     {
+        addr.assign(*argv);
         std::cout<< '\n' << getLine(filename, addr).c_str() << '\n';
     }
 
@@ -190,10 +183,10 @@ std::string getLine(const std::string& filename, const std::string& addr)
         );
 
 
-    Foam::regExp re(".+LineEntry: .+: (.+):([0-9]+):[0-9]+");
+    static std::regex re(".+LineEntry: .+: (.+):([0-9]+):[0-9]+");
+    std::smatch groups;
 
-    Foam::regExp::results_type groups;
-    if (!re.match(line, groups))
+    if (!std::regex_match(line, groups, re))
     {
         line = "??:0";
     }

applications/utilities/miscellaneous/foamDictionary/foamDictionary.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016-2017 OpenFOAM Foundation
-    Copyright (C) 2017-2023 OpenCFD Ltd.
+    Copyright (C) 2017-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -140,6 +140,38 @@ using namespace Foam;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+//- Read dictionary from IFstream, setting the stream to ascii/binary mode
+//- depending on the 'FoamFile' header content
+dictionary readDictionary(Istream& is)
+{
+    auto format = is.format();
+
+    // If the file starts with 'FoamFile { ... }'
+    token tok;
+    if
+    (
+        (tok.read(is) && tok.isWord("FoamFile"))
+     && (tok.read(is) && tok.isPunctuation(token::BEGIN_BLOCK))
+    )
+    {
+        is.putBack(tok);  // Put back '{'
+
+        // FoamFile sub-dictionary content
+        dictionary header(is);
+
+        // Get "format" if present
+        format = IOstreamOption::formatEnum("format", header, format);
+    }
+
+    // Start again. Probably does not work well with IPstream though
+    is.rewind();
+    is.format(format);
+
+    // Read, preserving headers
+    return dictionary(is, true);
+}
+
+
 //- Convert very old ':' scope syntax to less old '.' scope syntax,
 //  but leave anything with '/' delimiters untouched
 bool upgradeScope(word& entryName)
@@ -266,6 +298,8 @@ void removeDict(dictionary& dict, const dictionary& dictToRemove)
 }
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 int main(int argc, char *argv[])
 {
     argList::addNote
@@ -273,7 +307,7 @@ int main(int argc, char *argv[])
         "Interrogate and manipulate dictionaries"
     );
 
-    argList::noBanner();
+    argList::noBanner();  // Essential if redirecting stdout
     argList::noJobInfo();
     argList::addArgument("dict", "The dictionary file to process");
     argList::addBoolOption("keywords", "List keywords");
@@ -336,7 +370,7 @@ int main(int argc, char *argv[])
         "disableFunctionEntries",
         "Disable expansion of dictionary directives - #include, #codeStream etc"
     );
-    profiling::disable(); // Disable profiling (and its output)
+    profiling::disable();  // Disable profiling (and its output)
 
     argList args(argc, argv);
 
@@ -369,7 +403,7 @@ int main(int argc, char *argv[])
     const auto dictFileName = args.get<fileName>(1);
 
     auto dictFile = autoPtr<IFstream>::New(dictFileName);
-    if (!dictFile().good())
+    if (!dictFile || !dictFile().good())
     {
         FatalErrorInFunction
             << "Cannot open file " << dictFileName
@@ -379,8 +413,13 @@ int main(int argc, char *argv[])
 
     bool changed = false;
 
-    // Read but preserve headers
-    dictionary dict(dictFile(), true);
+    // Read, preserving headers
+    //// dictionary dict(dictFile(), true);
+    dictionary dict = readDictionary(dictFile());
+
+    // The extracted dictionary format
+    const auto dictFormat = dictFile().format();
+
 
     if (listIncludes)
     {
@@ -414,8 +453,10 @@ int main(int argc, char *argv[])
                     << exit(FatalError, 1);
             }
 
-            // Read but preserve headers
-            diffDict.read(diffFile, true);
+            // Read, preserving headers
+            //// diffDict.read(diffFile, true);
+            diffDict = readDictionary(diffFile);
+
             optDiff = true;
         }
         else if (args.readIfPresent("diff-etc", diffFileName))
@@ -436,8 +477,9 @@ int main(int argc, char *argv[])
                     << exit(FatalError, 1);
             }
 
-            // Read but preserve headers
-            diffDict.read(diffFile, true);
+            // Read, preserving headers
+            //// diffDict.read(diffFile, true);
+            diffDict = readDictionary(diffFile);
             optDiff = true;
         }
     }
@@ -592,10 +634,12 @@ int main(int argc, char *argv[])
         dict.write(Info, false);
     }
 
+    // Close the input file
+    dictFile.reset();
+
     if (changed)
     {
-        dictFile.clear();
-        OFstream os(dictFileName);
+        OFstream os(dictFileName, dictFormat);
         IOobject::writeBanner(os);
         IOobject::writeDivider(os);
         dict.write(os, false);

applications/utilities/parallelProcessing/reconstructParMesh/reconstructParMesh.C

@@ -1131,7 +1131,7 @@ int main(int argc, char *argv[])
                         for
                         (
                             label addedI=next;
-                            addedI<min(proci+step, nProcs);
+                            addedI < Foam::min(proci+step, nProcs);
                             addedI++
                         )
                         {

applications/utilities/parallelProcessing/redistributePar/redistributePar.C

@@ -403,11 +403,11 @@ void printMeshData(const polyMesh& mesh)
                 << nBndFaces-nProcFaces << endl;
         }
 
-        maxProcCells = max(maxProcCells, nLocalCells);
+        maxProcCells = Foam::max(maxProcCells, nLocalCells);
         totProcFaces += nProcFaces;
         totProcPatches += nei.size();
-        maxProcFaces = max(maxProcFaces, nProcFaces);
-        maxProcPatches = max(maxProcPatches, nei.size());
+        maxProcFaces = Foam::max(maxProcFaces, nProcFaces);
+        maxProcPatches = Foam::max(maxProcPatches, nei.size());
     }
 
     // Summary stats

applications/utilities/postProcessing/lagrangian/particleTracks/particleTracks.C

@@ -131,7 +131,7 @@ int main(int argc, char *argv[])
     args.readIfPresent("format", setFormat);
 
     args.readIfPresent("stride", sampleFrequency);
-    sampleFrequency = max(1, sampleFrequency);  // sanity
+    sampleFrequency = Foam::max(1, sampleFrequency);  // sanity
 
     // Setup the writer
     auto writerPtr =
@@ -179,14 +179,14 @@ int main(int argc, char *argv[])
                     maxIds.resize(origProc+1, -1);
                 }
 
-                maxIds[origProc] = max(maxIds[origProc], origId);
+                maxIds[origProc] = Foam::max(maxIds[origProc], origId);
             }
         }
 
         const label maxNProcs = returnReduce(maxIds.size(), maxOp<label>());
         maxIds.resize(maxNProcs, -1);
 
-        Pstream::listCombineReduce(maxIds, maxEqOp<label>());
+        Pstream::listReduce(maxIds, maxOp<label>());
 
         // From ids to count
         const labelList numIds = maxIds + 1;

applications/utilities/postProcessing/miscellaneous/postChannel/channelIndexTemplates.C

@@ -40,7 +40,7 @@ Foam::Field<T> Foam::channelIndex::regionSum(const Field<T>& cellField) const
     }
 
     // Global sum
-    Pstream::listCombineReduce(regionField, plusEqOp<T>());
+    Pstream::listReduce(regionField, sumOp<T>());
 
     return regionField;
 }

applications/utilities/preProcessing/PDR/pdrFields/PDRarraysCalc.C

@@ -1056,7 +1056,7 @@ void calc_drag_etc
     const scalar expon =
     (
         br > 0.0
-      ? min(max((surr_br / br - 0.25) * 4.0 / 3.0, scalar(0)), scalar(1))
+      ? Foam::clamp((surr_br / br - 0.25) * 4.0 / 3.0, Foam::zero_one{})
       : 0.0
     );
 
@@ -1114,16 +1114,16 @@ void Foam::PDRarrays::blockageSummary() const
                 totVolBlock += v_block(ijk) * pdrBlock.V(ijk);
                 totArea += surf(ijk);
 
-                totCount += max(0, obs_count(ijk));
+                totCount += Foam::max(0, obs_count(ijk));
 
-                totDrag.x() += max(0, drag_s(ijk).xx());
-                totDrag.y() += max(0, drag_s(ijk).yy());
-                totDrag.z() += max(0, drag_s(ijk).zz());
+                totDrag.x() += Foam::max(0, drag_s(ijk).xx());
+                totDrag.y() += Foam::max(0, drag_s(ijk).yy());
+                totDrag.z() += Foam::max(0, drag_s(ijk).zz());
 
                 for (direction cmpt=0; cmpt < vector::nComponents; ++cmpt)
                 {
-                    totBlock[cmpt] += max(0, area_block_s(ijk)[cmpt]);
-                    totBlock[cmpt] += max(0, area_block_r(ijk)[cmpt]);
+                    totBlock[cmpt] += Foam::max(0, area_block_s(ijk)[cmpt]);
+                    totBlock[cmpt] += Foam::max(0, area_block_r(ijk)[cmpt]);
                 }
             }
         }

applications/utilities/preProcessing/PDR/pdrFields/PDRutilsOverlap.C

@@ -302,7 +302,7 @@ void Foam::PDRutils::circle_overlap
                     scalar da = ac - 0.5 * (a1 + a2);
                     scalar db = bc - 0.5 * (b1 + b2);
                     scalar dc = std::hypot(da, db);
-                    scalar rat1 = min(max((dc / sqrt(area) - 0.3) * 1.4, 0), 1);
+                    scalar rat1 = Foam::min(Foam::max((dc / sqrt(area) - 0.3) * 1.4, 0), 1);
                     scalar drg0 = c_drag(ia,ib).xx();
                     scalar drg1 = c_drag(ia,ib).yy();
                     scalar drg = std::hypot(drg0, drg1);
@@ -449,8 +449,8 @@ scalar block_overlap
             {
                 PDRobstacle over;
 
-                over.pt = max(blk1.pt, blk2.pt);
-                over.span = min(max1, max2) - over.pt;
+                over.pt = Foam::max(blk1.pt, blk2.pt);
+                over.span = Foam::min(max1, max2) - over.pt;
 
                 assert(cmptProduct(over.span) > 0.0);
 
@@ -603,11 +603,11 @@ scalar block_cylinder_overlap
 
                     over.x() = a_centre - 0.5 * a_lblk;
                     over.y() = b_centre - 0.5 * b_lblk;
-                    over.z() = max(blk1.z(), cyl2.z());
+                    over.z() = Foam::max(blk1.z(), cyl2.z());
 
                     over.span.x() = a_lblk;
                     over.span.y() = b_lblk;
-                    over.span.z() = min(max1.z(), cyl2.z() + cyl2.len()) - over.z();
+                    over.span.z() = Foam::min(max1.z(), cyl2.z() + cyl2.len()) - over.z();
                     assert(over.x() > -200.0);
                     assert(over.x() < 2000.0);
                 }
@@ -668,11 +668,11 @@ scalar block_cylinder_overlap
 
                     over.z() = a_centre - a_lblk * 0.5;
                     over.x() = b_centre - b_lblk * 0.5;
-                    over.y() = max(blk1.y(), cyl2.y());
+                    over.y() = Foam::max(blk1.y(), cyl2.y());
 
                     over.span.z() = a_lblk;
                     over.span.x() = b_lblk;
-                    over.span.y() = min(max1.y(), cyl2.y() + cyl2.len()) - over.y();
+                    over.span.y() = Foam::min(max1.y(), cyl2.y() + cyl2.len()) - over.y();
                 }
                 break;
 
@@ -734,11 +734,11 @@ scalar block_cylinder_overlap
 
                     over.y() = a_centre - a_lblk * 0.5;
                     over.z() = b_centre - b_lblk * 0.5;
-                    over.x() = max(blk1.x(), cyl2.x());
+                    over.x() = Foam::max(blk1.x(), cyl2.x());
 
                     over.span.y() = a_lblk;
                     over.span.z() = b_lblk;
-                    over.span.x() = min(max1.x(), cyl2.x() + cyl2.len()) - over.x();
+                    over.span.x() = Foam::min(max1.x(), cyl2.x() + cyl2.len()) - over.x();
                 }
                 break;
             }