ENH: helical: new particle force model to follow helical trajectory

- makes fileHandler calling resemble Time more closely

ENH: provide natural_sort less/greater functions

- more succinct than (compare < 0) or (compare > 0).
  The corresponding wrappers for UList renamed as list_less, etc
  but they were only used in unit tests

ENH: handle (-allRegions | -all-regions, ..) directly when retrieving args

- makes handling independent of aliasing order

STYLE: include <string_view> when including <string>

- the standard does not guarantee which headers (if any) actually
  include string_view

.gitignore

@@ -11,6 +11,7 @@
 
 # File-browser settings - anywhere
 .directory
+.DS_Store   # OSX app store 
 
 # Backup/recovery versions - anywhere
 .#*
@@ -38,6 +39,8 @@ linux*Gcc*/
 linux*Icc*/
 solaris*Gcc*/
 SunOS*Gcc*/
+darwin*Clang*/
+darwin*Gcc*/
 platforms/
 
 # Top-level build directories

Allwmake-modules

@@ -1,6 +1,6 @@
 #!/bin/sh
 cd "${0%/*}" || exit            # Run from this directory
-set -- -no-recursion "$@"       # Parse arguments only
+set -- -all="${0##*/}" "$@"     # Execute this instead of ./Allwmake
 
 # Run from OPENFOAM top-level directory only
 wmake -check-dir "$WM_PROJECT_DIR" 2>/dev/null || {
@@ -33,7 +33,7 @@ case "$FOAM_MODULE_PREFIX" in
     ;;
 (*)
     # Use wmake -all instead of Allwmake to allow for overrides
-    ( cd "$WM_PROJECT_DIR/modules" 2>/dev/null && wmake -all )
+    ( cd "$WM_PROJECT_DIR/modules" 2>/dev/null && wmake -all $* )
 esac
 
 #------------------------------------------------------------------------------

Allwmake-plugins

@@ -1,6 +1,6 @@
 #!/bin/sh
 cd "${0%/*}" || exit            # Run from this directory
-set -- -no-recursion "$@"       # Parse arguments only
+set -- -all="${0##*/}" "$@"     # Execute this instead of ./Allwmake
 
 # Run from OPENFOAM top-level directory only
 wmake -check-dir "$WM_PROJECT_DIR" 2>/dev/null || {
@@ -33,7 +33,7 @@ case "$FOAM_MODULE_PREFIX" in
     ;;
 (*)
     # Use wmake -all instead of Allwmake to allow for overrides
-    ( cd "$WM_PROJECT_DIR/plugins" 2>/dev/null && wmake -all )
+    ( cd "$WM_PROJECT_DIR/plugins" 2>/dev/null && wmake -all $* )
 esac
 
 #------------------------------------------------------------------------------

META-INFO/api-info

@@ -1,2 +1,2 @@
-api=2506
+api=2507
 patch=0

applications/solvers/basic/potentialFoam/createFields.H

@@ -15,11 +15,10 @@ volVectorField U
 // Initialise the velocity internal field to zero
 // Note: explicitly bypass evaluation of contraint patch overrides
 //       (e.g. swirlFanVelocity might lookup phi,rho)
-//U = dimensionedVector(U.dimensions(), Zero);
+//U = Zero;
 {
-    const dimensionedVector dt(U.dimensions(), Zero);
-    U.internalFieldRef() = dt;
-    U.boundaryFieldRef() = dt.value();
+    U.internalFieldRef() = Zero;
+    U.boundaryFieldRef() = Zero;
 }
 
 surfaceScalarField phi

applications/solvers/lagrangian/kinematicParcelFoam/UEqn.H

@@ -6,7 +6,7 @@
       + MRF.DDt(U)
       + turbulence->divDevReff(U)
      ==
-        parcels.SU(U, true)
+        invRhoInf*parcels.SU(U)
       + fvOptions(U)
     );
 

applications/solvers/lagrangian/kinematicParcelFoam/createFields.H

@@ -39,6 +39,11 @@ dimensionedScalar rhoInfValue
     laminarTransport
 );
 
+const dimensionedScalar invRhoInf
+(
+    dimless/dimDensity, scalar(1)/rhoInfValue.value()
+);
+
 volScalarField rhoInf
 (
     IOobject

applications/solvers/multiphase/compressibleMultiphaseInterFoam/multiphaseMixtureThermo/multiphaseMixtureThermo.C

@@ -1086,7 +1086,7 @@ void Foam::multiphaseMixtureThermo::solveAlphas
 
     MULES::limitSum(alphaPhiCorrs);
 
-    rhoPhi_ = dimensionedScalar(dimensionSet(1, 0, -1, 0, 0), Zero);
+    rhoPhi_ = Zero;
 
     volScalarField sumAlpha
     (

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

@@ -63,23 +63,11 @@ Foam::DTRMParticle::DTRMParticle
         {
             is >> p0_ >> p1_ >> I0_ >> I_ >> dA_ >> transmissiveId_;
         }
-        else if (!is.checkLabelSize<>() || !is.checkScalarSize<>())
-        {
-            // Non-native label or scalar size
-
-            is.beginRawRead();
-
-            readRawScalar(is, p0_.data(), vector::nComponents);
-            readRawScalar(is, p1_.data(), vector::nComponents);
-            readRawScalar(is, &I0_);
-            readRawScalar(is, &I_);
-            readRawScalar(is, &dA_);
-            readRawLabel(is, &transmissiveId_);
-
-            is.endRawRead();
-        }
         else
         {
+            // No non-native streaming
+            is.fatalCheckNativeSizes(FUNCTION_NAME);
+
             is.read(reinterpret_cast<char*>(&p0_), sizeofFields_);
         }
     }

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

@@ -557,7 +557,7 @@ void Foam::radiation::laserDTRM::calculate()
 
 
     // Reset the field
-    Q_ == dimensionedScalar(Q_.dimensions(), Zero);
+    Q_ == Zero;
 
     a_ = absorptionEmission_->a();
     e_ = absorptionEmission_->e();

applications/solvers/multiphase/multiphaseEulerFoam/pEqn.H

@@ -232,7 +232,7 @@
             surfaceScalarField mSfGradp("mSfGradp", pEqnIncomp.flux()/rAUf);
 
             phasei = 0;
-            phi = dimensionedScalar("phi", phi.dimensions(), Zero);
+            phi = Zero;
 
             for (phaseModel& phase : fluid.phases())
             {
@@ -261,7 +261,7 @@
 
             mSfGradp = pEqnIncomp.flux()/rAUf;
 
-            U = dimensionedVector("U", dimVelocity, Zero);
+            U = Zero;
 
             phasei = 0;
             for (phaseModel& phase : fluid.phases())

applications/solvers/multiphase/multiphaseInterFoam/multiphaseMixture/multiphaseMixture.C

@@ -626,7 +626,7 @@ void Foam::multiphaseMixture::solveAlphas
 
     MULES::limitSum(alphaPhiCorrs);
 
-    rhoPhi_ = dimensionedScalar(dimMass/dimTime, Zero);
+    rhoPhi_ = Zero;
 
     volScalarField sumAlpha
     (

applications/solvers/stressAnalysis/solidEquilibriumDisplacementFoam/kineticEnergyLimiter.H

@@ -14,6 +14,6 @@ if (!(runTime.timeIndex() % 5))
     if (smi < -SMALL)
     {
         Info<< "Resetting Dcorr to 0" << endl;
-        Dcorr == dimensionedVector(Dcorr.dimensions(), Zero);
+        Dcorr == Zero;
     }
 }

applications/test/00-dummy/library/Allwclean-mpi

@@ -1,6 +1,6 @@
 #!/bin/sh
-cd "${0%/*}" || exit                                # Run from this directory
-. ${WM_PROJECT_DIR:?}/wmake/scripts/wmakeFunctions  # Require wmake functions
+cd "${0%/*}" || exit            # Run from this directory
+. "${WM_PROJECT_DIR:?}"/wmake/scripts/wmakeFunctions  # Need wmake functions
 
 #------------------------------------------------------------------------------
 

applications/test/00-dummy/library/Allwmake-mpi

@@ -1,8 +1,9 @@
 #!/bin/sh
 cd "${0%/*}" || exit            # Run from this directory
-set -- -no-recursion "$@"       # Parse arguments only
-. ${WM_PROJECT_DIR:?}/wmake/scripts/AllwmakeParseArguments
-. ${WM_PROJECT_DIR:?}/wmake/scripts/wmakeFunctions  # Require wmake functions
+set -- -all="${0##*/}" "$@"     # Execute this instead of ./Allwmake
+
+. "${WM_PROJECT_DIR:?}"/wmake/scripts/AllwmakeParseArguments
+. "${WM_PROJECT_DIR:?}"/wmake/scripts/wmakeFunctions  # Need wmake functions
 
 #------------------------------------------------------------------------------
 # Environment

applications/test/CompactIOList/Make/files

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

applications/test/CompactIOList/Test-CompactIOList.cxx

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2020-2022 OpenCFD Ltd.
+    Copyright (C) 2020-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,7 +25,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Application
-    testCompactIOList
+    Test-CompactIOList
 
 Description
     Simple demonstration and test application for the CompactIOList container
@@ -46,13 +46,20 @@ using namespace Foam;
 
 int main(int argc, char *argv[])
 {
+    argList::addBoolOption("ascii", "use ascii format");
+    argList::addOption("count", "number of faces");
+
     #include "setRootCase.H"
     #include "createTime.H"
 
     IOstreamOption streamOpt(IOstreamOption::BINARY);
-    // IOstreamOption streamOpt(IOstreamOption::ASCII);
 
-    const label size = 20000000;
+    if (args.found("ascii"))
+    {
+        streamOpt.format(IOstreamOption::ASCII);
+    }
+
+    const label size = args.getOrDefault<label>("count", 20000000);
 
     // Old format
     // ~~~~~~~~~~
@@ -63,39 +70,50 @@ int main(int argc, char *argv[])
         (
             IOobject
             (
-                "faces2",
+                "faces2-plain",
                 runTime.constant(),
                 polyMesh::meshSubDir,
                 runTime,
                 IOobject::NO_READ,
                 IOobject::NO_WRITE,
                 IOobject::NO_REGISTER
-            ),
-            size
+            )
         );
 
-        const face f(identity(4));
+        faces2.resize(size, face(identity(4)));
 
-        forAll(faces2, i)
-        {
-            faces2[i] = f;
-        }
-
-        Info<< "Constructed faceList in = "
-            << runTime.cpuTimeIncrement() << " s" << nl << endl;
+        Info<< "Plain format faceList " << faces2.objectRelPath() << nl;
+        Info<< "    constructed in = " << runTime.cpuTimeIncrement()
+            << " s" << endl;
 
 
         faces2.writeObject(streamOpt, true);
 
-        Info<< "Written old format faceList in = "
-            << runTime.cpuTimeIncrement() << " s" << nl << endl;
+        Info<< "    wrote in = "
+            << runTime.cpuTimeIncrement() << " s" << endl;
 
-        // Read
-        faceIOList faces3
+        // Read (size only)
+        label count = faceIOList::readContentsSize
         (
             IOobject
             (
-                "faces2",
+                "faces2-plain",
+                runTime.constant(),
+                polyMesh::meshSubDir,
+                runTime,
+                IOobject::MUST_READ
+            )
+        );
+
+        Info<< "    counted " << count << " faces on disk in = "
+            << runTime.cpuTimeIncrement() << " s" << endl;
+
+        // Read
+        faceIOList faces2b
+        (
+            IOobject
+            (
+                "faces2-plain",
                 runTime.constant(),
                 polyMesh::meshSubDir,
                 runTime,
@@ -105,7 +123,7 @@ int main(int argc, char *argv[])
             )
         );
 
-        Info<< "Read old format " << faces3.size() << " faceList in = "
+        Info<< "    read " << faces2b.size() << " faces in = "
             << runTime.cpuTimeIncrement() << " s" << nl << endl;
     }
 
@@ -114,44 +132,54 @@ int main(int argc, char *argv[])
     // ~~~~~~~~~~
 
     {
-        // Construct big faceList in new format
+        // Construct big faceList in compact format
         faceCompactIOList faces2
         (
             IOobject
             (
-                "faces2",
+                "faces2-compact",
                 runTime.constant(),
                 polyMesh::meshSubDir,
                 runTime,
                 IOobject::NO_READ,
                 IOobject::NO_WRITE,
                 IOobject::NO_REGISTER
-            ),
-            size
+            )
         );
 
-        const face f(identity(4));
+        faces2.resize(size, face(identity(4)));
 
-        forAll(faces2, i)
-        {
-            faces2[i] = f;
-        }
-
-        Info<< "Constructed new format faceList in = "
-            << runTime.cpuTimeIncrement() << " s" << nl << endl;
+        Info<< "Compact format faceList" << faces2.objectRelPath() << nl;
+        Info<< "    constructed in = "
+            << runTime.cpuTimeIncrement() << " s" << endl;
 
 
         faces2.writeObject(streamOpt, true);
 
-        Info<< "Written new format faceList in = "
-            << runTime.cpuTimeIncrement() << " s" << nl << endl;
+        Info<< "    wrote in = "
+            << runTime.cpuTimeIncrement() << " s" << endl;
 
-        // Read
-        faceCompactIOList faces3
+        // Read (size only)
+        label count = faceCompactIOList::readContentsSize
         (
             IOobject
             (
-                "faces2",
+                "faces2-compact",
+                runTime.constant(),
+                polyMesh::meshSubDir,
+                runTime,
+                IOobject::MUST_READ
+            )
+        );
+        Info<< "    counted " << count << " faces on disk in = "
+            << runTime.cpuTimeIncrement() << " s" << endl;
+
+        // Read
+        faceCompactIOList faces2b
+        (
+            IOobject
+            (
+                "faces2-compact",
                 runTime.constant(),
                 polyMesh::meshSubDir,
                 runTime,
@@ -161,7 +189,7 @@ int main(int argc, char *argv[])
             )
         );
 
-        Info<< "Read new format " << faces3.size() << " faceList in = "
+        Info<< "    read " << faces2b.size() << " faces in = "
             << runTime.cpuTimeIncrement() << " s" << nl << endl;
     }
 

applications/test/HashPtrTable/Make/files

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

applications/test/HashPtrTable/Test-HashPtrTable.cxx

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
-    Copyright (C) 2017-2022 OpenCFD Ltd.
+    Copyright (C) 2017-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -42,33 +42,55 @@ Description
 
 using namespace Foam;
 
-class Scalar
+bool verbosity = true;
+
+// Gratuitous class inheritance
+template<class T>
+class BoxedType
 {
-    scalar data_;
+    T data_;
 
 public:
 
     static bool verbose;
 
-    constexpr Scalar() noexcept : data_(0) {}
-    Scalar(scalar val) noexcept : data_(val) {}
+    constexpr BoxedType() noexcept : data_(0) {}
+    BoxedType(T val) noexcept : data_(val) {}
+
+    ~BoxedType()
+    {
+        if (verbosity) Info<< "    [delete BoxedType: " << value() << ']' << nl;
+    }
+
+    T value() const noexcept { return data_; }
+    T& value() noexcept { return data_; }
+
+    auto clone() const { return autoPtr<BoxedType<T>>::New(*this); }
+};
+
+template<class T> Ostream& operator<<(Ostream& os, const BoxedType<T>& item)
+{
+    return (os << " -> " << item.value());
+}
+
+
+class Scalar : public BoxedType<scalar>
+{
+public:
+
+    using BoxedType<scalar>::BoxedType;
 
     ~Scalar()
     {
-        if (verbose) Info<< "delete Scalar: " << data_ << endl;
-    }
-
-    const scalar& value() const noexcept { return data_; }
-    scalar& value() noexcept { return data_; }
-
-    friend Ostream& operator<<(Ostream& os, const Scalar& item)
-    {
-        os  << item.value();
-        return os;
+        if (verbosity) Info<< "delete Scalar: " << value() << nl;
     }
+    auto clone() const { return autoPtr<Scalar>::New(*this); }
 };
 
-bool Scalar::verbose = true;
+Ostream& operator<<(Ostream& os, const Scalar& item)
+{
+    return (os << item.value());
+}
 
 
 template<class T>

applications/test/HashTable1/Test-HashTable1.cxx

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2025 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -37,30 +37,11 @@ License
 
 using namespace Foam;
 
-void checkCanonicalSize(label size)
-{
-    const auto n = HashTableCore::canonicalSize(size);
-
-    std::ostringstream buf;
-    buf.setf(std::ios_base::hex, std::ios_base::basefield);
-    buf << n;
-
-    Info<< "hash-table size of " << size
-        << " = " << n << " (0x" << buf.str().c_str() << ')' << nl;
-}
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 //  Main program:
 
 int main()
 {
-    for (label size : { -1, 0, 1, 7, 500, 1024, 1025, 10000, (labelMax-1)} )
-    {
-        checkCanonicalSize(size);
-    }
-    Info<< nl;
-
     HashTable<scalar> table1
     {
         {"aaa", 1.0},

applications/test/HashTable2/Make/files

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

applications/test/HashTable3/Make/files

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

applications/test/ICharStream1/Test-ICharStream1.cxx

@@ -89,12 +89,6 @@ Ostream& printView(Ostream& os, std::string_view s)
 }
 
 
-Ostream& printView(Ostream& os, stdFoam::span<char> s)
-{
-    return printView(os, s.begin(), s.end());
-}
-
-
 Ostream& printView(Ostream& os, const UList<char>& list)
 {
     return printView(os, list.begin(), list.end());

applications/test/IOobjectList/Make/files

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

applications/test/ISLList/Make/files

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

applications/test/IStringStream/Make/files

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

applications/test/List/Test-List.cxx

@@ -106,7 +106,7 @@ void printMyString(const UList<string>& lst)
 {
     MyStrings slist2(lst);
 
-    Info<<slist2 << nl;
+    Info<< slist2 << nl;
 }
 
 
@@ -204,16 +204,6 @@ int main(int argc, char *argv[])
             Info<<" " << *iter;
         }
         Info<< nl;
-
-        Info<< "data:" << Foam::name(ident.cdata())
-            << " size:" << ident.size() << nl;
-
-
-        Info<< "resize_unsafe(10)" << nl;
-        ident.resize_unsafe(10);
-
-        Info<< "data:" << Foam::name(ident.cdata())
-            << " size:" << ident.size() << nl;
     }
 
     if (false)
@@ -370,7 +360,7 @@ int main(int argc, char *argv[])
         auto shrtList = ListOps::create<short>
         (
             longLabelList,
-            [](const label& val){ return val; }
+            [](label val){ return val; }
         );
 
         printListOutputType<short>("short") << nl;
@@ -567,7 +557,7 @@ int main(int argc, char *argv[])
             auto scalars = ListOps::create<scalar>
             (
                 labels,
-                [](const label& val){ return scalar(1.5*val); }
+                [](label val){ return scalar(1.5*val); }
             );
             Info<< "scalars: " << flatOutput(scalars) << endl;
         }
@@ -576,7 +566,7 @@ int main(int argc, char *argv[])
             auto vectors = ListOps::create<vector>
             (
                 labels,
-                [](const label& val){ return vector(1.2*val, -1.2*val, 0); }
+                [](label val){ return vector(1.2*val, -1.2*val, 0); }
             );
             Info<< "vectors: " << flatOutput(vectors) << endl;
         }
@@ -585,7 +575,7 @@ int main(int argc, char *argv[])
             auto longs = ListOps::create<long>
             (
                 labels,
-                [](const label& val){ return val; }
+                [](label val){ return val; }
             );
             Info<< "longs: " << flatOutput(longs) << endl;
         }
@@ -603,7 +593,7 @@ int main(int argc, char *argv[])
             (
                 labelRange().cbegin(),
                 labelRange(15).cend(),
-                [](const label& val){ return scalar(-1.125*val); }
+                [](label val){ return scalar(-1.125*val); }
             );
             Info<< "scalars: " << flatOutput(scalars) << endl;
         }

applications/test/OCharStream1/Test-OCharStream1.cxx

@@ -89,12 +89,6 @@ Ostream& printView(Ostream& os, std::string_view s)
 }
 
 
-Ostream& printView(Ostream& os, stdFoam::span<char> s)
-{
-    return printView(os, s.begin(), s.end());
-}
-
-
 Ostream& printView(Ostream& os, const UList<char>& list)
 {
     return printView(os, list.begin(), list.end());
@@ -189,12 +183,25 @@ int main(int argc, char *argv[])
     printInfo(obuf);
 
     // Overwrite at some position
-    obuf.stdStream().rdbuf()->pubseekpos(0.60 * obuf.size());
-    obuf << "<" << nl << "OVERWRITE" << nl;
+    if (auto i = obuf.view().find("item5"); i != std::string::npos)
+    {
+        // obuf.seek(0.60 * obuf.size());
+        obuf.seek(i);
+        obuf << "<OVERWRITE>" << nl;
+    }
 
     Info<<"after overwrite" << nl;
     printInfo(obuf);
 
+    // Truncate
+    {
+        constexpr float fraction = 0.90;
+        Info<<"truncated at " << (100*fraction) << "% ["
+            << int(fraction*obuf.size()) << " chars]" << nl;
+        obuf.seek(fraction*obuf.size());
+        printInfo(obuf);
+    }
+
     Info<< "transfer contents to a List or ICharStream" << nl;
 
     // Reclaim data storage from OCharStream -> ICharStream

applications/test/OCharStream2/Make/files

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

applications/test/OCharStream2/Make/options

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

applications/test/OCharStream2/Test-OCharStream2.cxx

@@ -0,0 +1,473 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2025 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#include "SpanStream.H"
+#include "wordList.H"
+#include "IOstreams.H"
+#include "argList.H"
+
+#include <charconv>
+#include <cctype>
+#include <cstdio>
+#include <limits>
+#include <iomanip>
+
+using namespace Foam;
+
+Ostream& printString(Ostream& os, const char* first, const char* last)
+{
+    os << '"';
+    for (; first != last; (void)++first)
+    {
+        os << *first;
+    }
+    os << '"';
+
+    return os;
+}
+
+
+Ostream& printView(Ostream& os, const char* first, const char* last)
+{
+    char buf[4];
+    os << label(last-first) << '(';
+
+    for (; first != last; (void)++first)
+    {
+        const char c = *first;
+
+        if (isprint(c))
+        {
+            os << c;
+        }
+        else if (c == '\t')
+        {
+            os << "\\t";
+        }
+        else if (c == '\n')
+        {
+            os << "\\n";
+        }
+        else
+        {
+            ::snprintf(buf, 4, "%02X", c);
+            os << "\\x" << buf;
+        }
+    }
+    os << ')';
+
+    return os;
+}
+
+
+Ostream& printView(Ostream& os, std::string_view s)
+{
+    return printView(os, s.begin(), s.end());
+}
+
+
+Ostream& printView(Ostream& os, const UList<char>& list)
+{
+    return printView(os, list.begin(), list.end());
+}
+
+
+Ostream& writeList(Ostream& os, const UList<char>& list)
+{
+    return printView(os, list);
+}
+
+
+Ostream& toString(Ostream& os, const UList<char>& list)
+{
+    return printString(os, list.begin(), list.end());
+}
+
+
+Ostream& toString(Ostream& os, std::string_view s)
+{
+    return printString(os, s.begin(), s.end());
+}
+
+
+template<class BufType>
+void printInfo(const BufType& buf)
+{
+    Info<< nl << "=========================" << endl;
+    buf.print(Info);
+    Info<< "addr: " << Foam::name(buf.view().data()) << nl;
+    toString(Info, buf.view());
+    Info<< nl << "=========================" << endl;
+}
+
+
+// Return a left-padded integer as "word"
+template<class IntType>
+std::string leftpadded(IntType val, char fillch = ' ')
+{
+    std::string buf;
+    buf.resize((std::numeric_limits<IntType>::digits10+1), fillch);
+
+    auto first = (buf.data());
+    auto last  = (buf.data() + buf.size());
+
+    auto result = std::to_chars(first, last, val);
+
+    if (result.ec == std::errc{})
+    {
+        auto* iter = result.ptr;
+        int count = std::distance(iter, last);
+
+        std::cout << "did not fill: " << count << " chars\n";
+
+        // With two spaces before comments
+        if (count > 0) { *iter++ = ' '; --count; }
+        if (count > 0) { *iter++ = ' '; --count; }
+        for (char c = (count >= 2 ? '/' : ' '); count > 0; --count)
+        {
+            *iter++ = c;
+        }
+    }
+
+    return buf;
+}
+
+
+template<class IntType>
+void leftpad(std::ostream& os, IntType val, char fillch = ' ')
+{
+    // set fill char and width
+    os.setf(std::ios_base::left, std::ios_base::adjustfield);
+    fillch = os.fill(fillch);
+    os.width(std::numeric_limits<IntType>::digits10+1);
+    os  << val;
+    // restore fill char
+    os.fill(fillch);
+}
+
+
+template<class IntType>
+void rightpad(std::ostream& os, IntType val, char fillch = ' ')
+{
+    // set fill char and width
+    os.setf(std::ios_base::right, std::ios_base::adjustfield);
+    fillch = os.fill(fillch);
+    os.width(std::numeric_limits<IntType>::digits10+1);
+    os  << val;
+    // restore fill char
+    os.fill(fillch);
+}
+
+
+// Left-padded value with trailing comment slashes
+template<class IntType>
+void leftpad(ocharstream& os, IntType val)
+{
+    const auto beg = os.tellp();
+    os << val;
+    int count = (std::numeric_limits<IntType>::digits10+1) - (os.tellp() - beg);
+
+    // With two spaces before comments
+    if (count > 0) { os << ' '; --count; }
+    if (count > 0) { os << ' '; --count; }
+    for (const char c = (count >= 2 ? '/' : ' '); count > 0; --count)
+    {
+        os << c;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Main program:
+
+int main(int argc, char *argv[])
+{
+    argList::noBanner();
+    argList::noParallel();
+    argList::addBoolOption("fake-zerosize", "Fake overwriting with zero data");
+    argList::addBoolOption("dict-format", "Format as dictionary entry");
+
+    #include "setRootCase.H"
+
+    const bool optFakeZerosize = args.found("fake-zerosize");
+    const bool isDictFormat = args.found("dict-format");
+
+    // const constexpr int width = (std::numeric_limits<label>::digits10+1);
+
+    // experiment with to_chars instead of streaming
+    {
+        // Some value
+        label val(1234);
+
+        auto fixed = leftpadded(val);
+        Info<< "leftpadded " << val << " : " << fixed << nl;
+    }
+
+    ocharstream labelbuf;
+    labelbuf.reserve_exact(32);
+
+    // Some value
+    labelbuf.rewind();
+    rightpad(labelbuf, label(10));
+
+    printInfo(labelbuf);
+
+    OCharStream obuf;
+    obuf.reserve_exact(48);
+
+    printInfo(obuf);
+
+    obuf.push_back('>');
+    obuf.append(" string_view ");
+    obuf.push_back('<');
+    printInfo(obuf);
+
+    obuf.pop_back(8);
+    printInfo(obuf);
+
+    obuf.pop_back(100);
+    printInfo(obuf);
+
+
+    // Fill with some content
+    for (int i = 0; i < 26; ++i)
+    {
+        obuf<< char('A' + i);
+    }
+
+    // Change letter 'O' to '_'
+    if (auto i = obuf.view().find('O'); i != std::string::npos)
+    {
+        obuf.overwrite(i, '_');
+    }
+
+    // append and push_back some content
+    obuf.append(5, '<');
+    obuf.push_back('#');
+    obuf.append(5, '>');
+
+    printInfo(obuf);
+
+    obuf.pop_back(8);
+    printInfo(obuf);
+
+    // Slightly silly test
+    {
+        const auto list = obuf.list();
+        Info<< "list content:" << list << nl;
+        Info<< "view content:" << nl << list.view() << nl;
+    }
+
+    obuf.overwrite(4, labelbuf.view());
+    printInfo(obuf);
+
+    obuf.overwrite(20, "####");
+    printInfo(obuf);
+
+    Info<< "operation Ignored..." << nl;
+    obuf.overwrite(45, "????");
+    printInfo(obuf);
+
+    // Update with new value
+    {
+        labelbuf.rewind();
+        rightpad(labelbuf, label(200), '.');
+        obuf.overwrite(4, labelbuf.view());
+
+        printInfo(obuf);
+    }
+
+    // With yet another value (non-fixed width)
+    {
+        labelbuf.rewind();
+        labelbuf << label(15);
+        obuf.overwrite(4, labelbuf.view());
+
+        printInfo(obuf);
+    }
+
+    // Slightly harder test
+    {
+        std::string chars(26, '?');
+
+        for (int i = 0; i < 26; ++i)
+        {
+            chars[i] = char('A' + i);
+        }
+
+        auto& os = obuf;
+        os.rewind();
+
+        const word procName("processor0");
+
+        // Write as primitiveEntry or commented content
+        // // constexpr bool isDictFormat = true;
+
+        // if constexpr (isDictFormat)
+        if (isDictFormat)
+        {
+            // Like writeKeyword() with compoundToken
+            os << nl << procName << ' ' << word("List<char>") << nl;
+        }
+        else
+        {
+            // Human-readable comments
+            os << nl << "// " << procName << nl;
+        }
+
+        // This is the code we want to have, but assume we don't know
+        // the size or data beforehand.
+        //
+        // if (str && len > 0)
+        // {
+        //     // Special treatment for char data (binary I/O only)
+        //     const auto oldFmt = os.format(IOstreamOption::BINARY);
+        //
+        //     os << label(len) << nl;
+        //     os.write(str, len);
+        //     os << nl;
+        //
+        //     os.format(oldFmt);
+        // }
+        // else
+        // {
+        //     os << label(0) << nl;
+        // }
+
+        // Position before writing the label
+        const auto labelBegin = os.tellp();
+
+        // Replace: os << label(len) << nl;
+        // with a fixed-length version
+        {
+            labelbuf.rewind();
+            rightpad(labelbuf, 0);
+
+            os.append(labelbuf.view());
+            os << nl;
+        }
+
+        constexpr bool testUnknown = true;
+
+        label dataCount = 0;
+
+        if constexpr (testUnknown)
+        {
+            // Pretend we don't know the number of characters a priori
+
+            const auto oldFmt = os.format(IOstreamOption::BINARY);
+
+            const auto lineNumber = os.lineNumber();
+
+            // count is unknown but irrelevant for serial
+            os.beginRawWrite(0);
+
+            // Position before raw binary data
+            const auto dataBegin = os.tellp();
+
+            // Some type of output, streaming etc
+            os.writeRaw(chars.data(), chars.size());
+
+            // How many chars of binary data written?
+            dataCount = (os.tellp() - dataBegin);
+
+            os.endRawWrite();
+            os.lineNumber() = lineNumber;
+            os << nl;
+
+            os.format(oldFmt);
+        }
+        else
+        {
+            // If we had all data collected a priori
+
+            dataCount = chars.size();
+
+            const auto oldFmt = os.format(IOstreamOption::BINARY);
+
+            if (dataCount > 0)
+            {
+                os.write(chars.data(), chars.size());
+                os << nl;
+            }
+            os.format(oldFmt);
+        }
+
+        if (optFakeZerosize)
+        {
+            dataCount = 0;  // fake zero-size
+        }
+
+        printInfo(os);
+
+        // Update the data count with the correct value
+
+        if (dataCount > 0)
+        {
+            labelbuf.rewind();
+            leftpad(labelbuf, label(dataCount));
+
+            os.overwrite(labelBegin, labelbuf.view());
+        }
+        else
+        {
+            os.seek(int64_t(labelBegin)-1);
+
+            // if constexpr (isDictFormat)
+            if (isDictFormat)
+            {
+                os << ' ' << label(0);
+            }
+            else
+            {
+                os << nl << label(0) << nl;
+            }
+        }
+
+        // if constexpr (isDictFormat)
+        if (isDictFormat)
+        {
+            os.endEntry();
+        }
+
+        printInfo(os);
+
+        Info<< "view: " << os.view(4, 8) << nl;
+        Info<< "view: " << os.view(32) << nl;
+        // Ignores out-of-range
+        Info<< "view: " << os.view(1000) << nl;
+    }
+
+    Info<< "\nEnd\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/test/OCountStream/Test-OCountStream.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.
@@ -65,7 +65,6 @@ int main(int argc, char *argv[])
 
     OCountStream cnt;
     OCharStream cstr;
-    OStringStream sstr;
     ocountstream plain;
 
     generateOutput(cstr);
@@ -77,7 +76,6 @@ int main(int argc, char *argv[])
 
     Info<< "counter state: " << (cnt.stdStream().rdstate()) << nl
         << "via char-stream: " << label(cstr.view().size()) << " chars" << nl
-        << "via string-stream: " << label(sstr.count()) << " chars" << nl
         << "via ocountstream: " << plain.count() << " chars" << endl;
 
     fileName outputName;

applications/test/OStringStream/Make/files

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

applications/test/PackedList/Make/files

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

applications/test/PtrDictionary1/Make/files

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

applications/test/PtrDictionary1/Test-PtrDictionary1.cxx

@@ -42,6 +42,8 @@ Description
 
 using namespace Foam;
 
+bool verbosity = true;
+
 class ent
 :
     public Dictionary<ent>::link
@@ -73,14 +75,12 @@ class Scalar
 
 public:
 
-    static bool verbose;
-
     constexpr Scalar() noexcept : data_(0) {}
     Scalar(scalar val) noexcept : data_(val) {}
 
     ~Scalar()
     {
-        if (verbose) Info<< "delete Scalar: " << data_ << endl;
+        if (verbosity) Info<< "delete Scalar: " << data_ << endl;
     }
 
     scalar value() const noexcept { return data_; }
@@ -93,8 +93,6 @@ public:
     }
 };
 
-bool Scalar::verbose = true;
-
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 //  Main program:

applications/test/PtrList/Make/files

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

applications/test/PtrList/Test-PtrList.cxx

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
-    Copyright (C) 2018-2023 OpenCFD Ltd.
+    Copyright (C) 2018-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -41,35 +41,85 @@ Description
 
 using namespace Foam;
 
-class Scalar
+bool verbosity = true;
+
+// Gratuitous class inheritance
+template<class T>
+class BoxedType
 {
-    scalar data_;
+    T data_;
 
 public:
 
     static bool verbose;
 
-    constexpr Scalar() noexcept : data_(0) {}
-    Scalar(scalar val) noexcept : data_(val) {}
+    constexpr BoxedType() noexcept : data_(0) {}
+    BoxedType(T val) noexcept : data_(val) {}
+
+    ~BoxedType()
+    {
+        if (verbosity) Info<< "    [delete BoxedType: " << value() << ']' << nl;
+    }
+
+    T value() const noexcept { return data_; }
+    T& value() noexcept { return data_; }
+
+    auto clone() const { return autoPtr<BoxedType<T>>::New(*this); }
+};
+
+template<class T> Ostream& operator<<(Ostream& os, const BoxedType<T>& item)
+{
+    return (os << " -> " << item.value());
+}
+
+
+class Scalar : public BoxedType<scalar>
+{
+public:
+
+    using BoxedType<scalar>::BoxedType;
 
     ~Scalar()
     {
-        if (verbose) Info<< "delete Scalar: " << data_ << endl;
-    }
-
-    scalar value() const noexcept { return data_; }
-    scalar& value() noexcept { return data_; }
-
-    autoPtr<Scalar> clone() const { return autoPtr<Scalar>::New(data_); }
-
-    friend Ostream& operator<<(Ostream& os, const Scalar& item)
-    {
-        os  << item.value();
-        return os;
+        if (verbosity) Info<< "delete Scalar: " << value() << nl;
     }
+    auto clone() const { return autoPtr<Scalar>::New(*this); }
 };
 
-bool Scalar::verbose = true;
+Ostream& operator<<(Ostream& os, const Scalar& item)
+{
+    return (os << item.value());
+}
+
+
+class Integer : public BoxedType<label>
+{
+public:
+
+    using BoxedType<label>::BoxedType;
+
+    ~Integer()
+    {
+        if (verbosity) Info<< "delete Integer: " << value() << nl;
+    }
+    auto clone() const { return autoPtr<Integer>::New(*this); }
+};
+
+Ostream& operator<<(Ostream& os, const Integer& item)
+{
+    return (os << item.value());
+}
+
+
+//- Permit up-casting to the base class (eg, fvMesh to polyMesh).
+//  Usually only for holding (const) references.
+//  Exercise caution with the
+template<class Base, class Derived>
+std::enable_if_t<std::is_base_of_v<Base, Derived>, const UPtrList<Base>&>
+upcast(const UPtrList<Derived>& This)
+{
+    return *reinterpret_cast<const UPtrList<Base>*>(&This);
+}
 
 
 // As per
@@ -86,20 +136,7 @@ Ostream& printAddr
     const UPtrList<T>& list
 )
 {
-    const label len = list.size();
-
-    // Size and start delimiter
-    os  << nl << indent << len << nl
-        << indent << token::BEGIN_LIST << incrIndent << nl;
-
-    for (label i=0; i < len; ++i)
-    {
-        os << "addr=" << Foam::name(list.get(i)) << nl;
-    }
-
-    // End delimiter
-    os << decrIndent << indent << token::END_LIST << nl;
-    return os;
+    return list.printAddresses(os);
 }
 
 
@@ -176,11 +213,11 @@ Ostream& print
     {
         const label cap = list.capacity();
 
-        for (label i=len; i < cap; ++i)
+        for (label i = len; i < cap; ++i)
         {
             const T* ptr = list.get(i);
 
-            os << "unused " << name(ptr) << nl;
+            os << "unused " << Foam::name(ptr) << nl;
         }
     }
 
@@ -264,9 +301,9 @@ int main(int argc, char *argv[])
 
         Info<< "DLPtrList: " << llist1 << endl;
 
-        Scalar::verbose = false;
+        verbosity = false;
         llist1.clear();
-        Scalar::verbose = true;
+        verbosity = true;
     }
     #endif
 
@@ -344,6 +381,44 @@ int main(int argc, char *argv[])
     }
 
 
+    // Test upcasting - dangerous
+    {
+        const auto& base =
+            *reinterpret_cast<UPtrList<BoxedType<scalar>>*>(&list1);
+
+        Info<< "list :" << list1 << nl;
+        Info<< "base :" << base << nl;
+    }
+
+    // Expect bad things to happen!!
+    {
+        const auto& base =
+            *reinterpret_cast<UPtrList<BoxedType<label>>*>(&list1);
+
+        Info<< "list :" << list1 << nl;
+        Info<< "base :" << base << nl;
+    }
+
+    // Test upcasting - compile safer (make as member function?)
+    {
+        // const auto& base = list1.upcast<BoxedType<scalar>>();
+        const auto& base = upcast<BoxedType<scalar>>(list1);
+
+        Info<< "list :" << list1 << nl;
+        Info<< "base :" << base << nl;
+    }
+
+    // Refuse to compile (good!)
+    #if 0
+    {
+        // const auto& base = list1.upcast<BoxedType<label>>();
+        const auto& base = upcast<BoxedType<label>>(list1);
+
+        Info<< "list :" << list1 << nl;
+        Info<< "base :" << base << nl;
+    }
+    #endif
+
     PtrList<Scalar> list2(15);
     Info<< "Emplace set " << list2.size() << " values" << nl;
     forAll(list2, i)
@@ -518,6 +593,7 @@ int main(int argc, char *argv[])
         print(Info, dynlist1d);
 
         Info<< "addresses:" << nl;
+        dynlist1d.printAddresses(Info, true);
         printAddr(Info, dynlist1d);
 
         PtrList<Scalar> list1d;

applications/test/PtrListDictionary/Make/files

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

applications/test/PtrListDictionary/Test-PtrListDictionary.cxx

@@ -39,26 +39,26 @@ Description
 
 using namespace Foam;
 
+bool verbosity = true;
+
 class Scalar
 {
     scalar data_;
 
 public:
 
-    static bool verbose;
-
     constexpr Scalar() noexcept : data_(0) {}
     Scalar(scalar val) noexcept : data_(val) {}
 
     ~Scalar()
     {
-        if (verbose) Info<< "delete Scalar: " << data_ << endl;
+        if (verbosity) Info<< "delete Scalar: " << value() << nl;
     }
 
-    const scalar& value() const noexcept { return data_; }
+    scalar value() const noexcept { return data_; }
     scalar& value() noexcept { return data_; }
 
-    autoPtr<Scalar> clone() const { return autoPtr<Scalar>::New(data_); }
+    auto clone() const { return autoPtr<Scalar>::New(*this); }
 
     friend Ostream& operator<<(Ostream& os, const Scalar& item)
     {
@@ -67,8 +67,6 @@ public:
     }
 };
 
-bool Scalar::verbose = true;
-
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 //  Main program:

applications/test/SpanStream1/Test-SpanStream1.cxx

@@ -91,12 +91,6 @@ Ostream& printView(Ostream& os, std::string_view s)
 }
 
 
-Ostream& printView(Ostream& os, stdFoam::span<char> s)
-{
-    return printView(os, s.begin(), s.end());
-}
-
-
 Ostream& printView(Ostream& os, const UList<char>& list)
 {
     return printView(os, list.begin(), list.end());

applications/test/UPstreamTraits/Test-UPstreamTraits.cxx

@@ -200,7 +200,7 @@ void printTypeName()
 
 
 template<class Type, bool UseTypeName = true>
-void printPstreamTraits(const std::string_view name = std::string_view())
+void printPstreamTraits(std::string_view name = std::string_view())
 {
     Info<< "========" << nl;
     Info<< "type: ";
@@ -299,6 +299,9 @@ void printPstreamTraits(const std::string_view name = std::string_view())
         // Use element or component type (or byte-wise) for data type
         using base = typename UPstream_dataType<Type>::base;
 
+        // The sizing factor is constexpr
+        constexpr std::streamsize count = UPstream_dataType<Type>::size(1);
+
         Info<< " : ";
         if constexpr (UseTypeName)
         {
@@ -311,8 +314,7 @@ void printPstreamTraits(const std::string_view name = std::string_view())
 
         Info<< " cmpt-type=";
         printDataTypeId(UPstream_dataType<Type>::datatype_id);
-        Info<< " count=" << UPstream_dataType<Type>::size(1);
-        Info<< nl;
+        Info<< " count=" << count << nl;
     }
 }
 
@@ -362,6 +364,24 @@ void print_data_opType(BinaryOp bop, std::string_view name)
 }
 
 
+
+template<class Type>
+int check_simple(std::string_view name = std::string_view())
+{
+    // The sizing factor is constexpr
+    constexpr std::streamsize count = UPstream_dataType<Type>::size(1);
+
+    static_assert
+    (
+        (count == 1),
+        "Code does not (yet) work with aggregate types"
+    );
+
+    Info<< "check_simple: " << name << ": " << count << nl;
+    return count;
+}
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 // Main program:
 
@@ -389,6 +409,8 @@ int main()
     printPstreamTraits<const float>();
     printPstreamTraits<floatVector>();
 
+    check_simple<floatVector>("vector<float>");
+
     printPstreamTraits<scalar>();
     printPstreamTraits<double>();
     printPstreamTraits<doubleVector>();

applications/test/base64/Make/files

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

applications/test/base64/Test-base64Encoding.cxx

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2016 OpenCFD Ltd.
+    Copyright (C) 2016-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -35,25 +35,31 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "base64Layer.H"
+#include "SpanStream.H"
 #include "List.H"
 #include "Pair.H"
 
-#include <sstream>
-
 using namespace Foam;
 
 bool test(const Pair<string>& unit)
 {
-    const string& input = unit.first();
-    const string& expected = unit.second();
+    const auto& input = unit.first();
+    const auto& expected = unit.second();
 
-    std::ostringstream os;
+    Foam::ocharstream os;
 
-    base64Layer b64(os);
-    b64.write(input.data(), input.size());
-    b64.close();
+    {
+        base64Layer b64(os);
+        b64.write(input.data(), input.size());
 
-    const string encoded = os.str();
+        if (b64.close())
+        {
+            // Extra information
+            // std::cerr<< "closed with pending data" << nl;
+        }
+    }
+
+    const auto encoded = os.view();
 
     Info<< input << nl;
 
@@ -78,7 +84,7 @@ bool test(std::initializer_list<Pair<string>> list)
 {
     bool good = true;
 
-    for (const Pair<string>& t : list)
+    for (const auto& t : list)
     {
         good = test(t) && good;
     }
@@ -91,7 +97,7 @@ bool test(const UList<Pair<string>>& list)
 {
     bool good = true;
 
-    for (const Pair<string>& t : list)
+    for (const auto& t : list)
     {
         good = test(t) && good;
     }
@@ -107,7 +113,7 @@ void testMixed(std::ostream& os, const UList<Pair<string>>& list)
     os  << "<test-mixed>" << nl;
 
     int i=0;
-    for (const Pair<string>& t : list)
+    for (const auto& t : list)
     {
         const string& input = t.first();
 

applications/test/bitSet1/Make/files

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

applications/test/bitSet1/Test-bitSet1.cxx

@@ -142,6 +142,9 @@ int main(int argc, char *argv[])
             Info<< "got: " << bset1 << nl
                 << "and: " << bset2 << nl
                 << "and: " << bset3 << nl;
+
+            Info<< "==";
+            bset3.writeList(Info, 10) << nl;  // matrix-like output
         }
     }
 

applications/test/bitSet2/Test-bitSet2.cxx

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -75,9 +75,9 @@ inline Ostream& info(const UList<bool>& bools)
     Info<< "size=" << bools.size()
         << " count=" << BitOps::count(bools)
         << " !count=" << BitOps::count(bools, false)
-        << " all:" << BitOps::all(bools)
-        << " any:" << BitOps::any(bools)
-        << " none:" << BitOps::none(bools) << nl;
+        << " all:" << bools.all()
+        << " any:" << bools.any()
+        << " none:" << bools.none() << nl;
 
     return Info;
 }
@@ -137,11 +137,11 @@ inline bool compare
     const std::string& expected
 )
 {
-    const List<unsigned int>& store = bitset.storage();
+    const auto& store = bitset.storage();
 
     std::string has;
 
-    for (label blocki=0; blocki < bitset.nBlocks(); ++blocki)
+    for (label blocki=0; blocki < bitset.num_blocks(); ++blocki)
     {
         has += toString(store[blocki]);
     }
@@ -194,8 +194,10 @@ int main(int argc, char *argv[])
     {
         boolList bools = list1.values();
 
-        Info<<"===============" << nl;
-        Info<<"bools: " << flatOutput(bools) << nl;
+        Info<< "===============" << nl;
+        Info<< "bools: " << flatOutput(bools) << nl;
+        Info<< "    ";
+        info(bools);
 
         for (int i : { -10, 0, 8, 15, 32})
         {
@@ -238,17 +240,18 @@ int main(int argc, char *argv[])
     }
 
     #ifdef TEST_SFINAE
+    // This should fail to compile:
     {
         labelList labels = list1.toc();
         if (labels.test(0))
         {
-            Info<<"no" << endl;
+            Info<< "no" << endl;
         }
 
         List<double*> ptrs(10, nullptr);
         if (ptrs.get(0))
         {
-            Info<<"no" << endl;
+            Info<< "no" << endl;
         }
     }
     #endif

applications/test/boolList/Make/files

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

applications/test/boolList/Test-boolList.cxx

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2020-2022 OpenCFD Ltd.
+    Copyright (C) 2020-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -71,9 +71,9 @@ inline Ostream& info(const UList<bool>& bools)
     Info<< "size=" << bools.size()
         << " count=" << BitOps::count(bools)
         << " !count=" << BitOps::count(bools, false)
-        << " all:" << BitOps::all(bools)
-        << " any:" << BitOps::any(bools)
-        << " none:" << BitOps::none(bools) << nl;
+        << " all:" << bools.all()
+        << " any:" << bools.any()
+        << " none:" << bools.none() << nl;
 
     return Info;
 }

applications/test/compoundToken1/Make/files

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

applications/test/compoundToken1/Test-compoundToken1.cxx

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2023 OpenCFD Ltd.
+    Copyright (C) 2023-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -158,7 +158,8 @@ void populateCompound(token::compound& ct, const dictionary& dict)
         }
         break;
 
-        case token::tokenType::LABEL :
+        case token::tokenType::INTEGER_32 :
+        case token::tokenType::INTEGER_64 :
         {
             fillComponents(label, cmpts, 123);
         }

applications/test/dictionary/Make/files

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

applications/test/dictionary2/Make/files

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

applications/test/dictionary2/Test-dictionary2.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.
@@ -47,8 +47,18 @@ void entryInfo(entry* e)
 {
     if (e)
     {
-        Info<<"added "
-            << e->keyword() << ": " << typeid(e).name() << nl;
+        Info<< "added "
+            << e->keyword() << ": " << typeid(e).name();
+
+        if (auto* stream = e->streamPtr())
+        {
+            Info<< " tokens: "; stream->tokens().writeList(Info);
+        }
+        if (auto* dict = e->dictPtr())
+        {
+            Info<< " dictionary:";
+        }
+        Info<< nl;
     }
 }
 
@@ -200,12 +210,31 @@ int main(int argc, char *argv[])
     {
         dictionary tmpdict;
 
+        // Add an empty entry and populate afterwards
+        if (entry* e = dict1.set(word::printf("entry%d", i), nullptr))
         {
-            entry* e = dict1.add
-            (
-                word::printf("entry%d", i),
-                string("entry" + Foam::name(i))
-            );
+            auto& toks = e->stream();
+            toks.resize(2);
+
+            toks[0] = word("value" + Foam::name(i));
+            toks[1] = 10*i;
+            entryInfo(e);
+        }
+
+        // Add an entry from given list of tokens
+        {
+            tokenList toks(2);
+            toks[0] = word("value" + Foam::name(i));
+            toks[1] = 10*i;
+
+            Info<< "set token0: " << Foam::name(&(toks[0])) << nl;
+
+            entry* e = dict1.set(word::printf("_entry%d", i), std::move(toks));
+
+            // verify that the address is identical (ie, move semantics worked)
+            auto& newToks = e->stream();
+            Info<< "get token0: " << Foam::name(&(newToks[0])) << nl;
+
             entryInfo(e);
         }
 

applications/test/dictionaryCopy/Make/files

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

applications/test/fileOperation1/Make/files

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

applications/test/fileOperation1/Test-fileOperation1.cxx

@@ -27,7 +27,7 @@ Application
     Test-fileOperation1
 
 Description
-   Test string parsing and other bits for fileOperation
+    Test string parsing and other bits for fileOperation
 
 \*---------------------------------------------------------------------------*/
 
@@ -42,7 +42,8 @@ Description
 
 using namespace Foam;
 
-word toString(const fileOperation::procRangeType& group)
+template<class IntType>
+word toString(const IntRange<IntType>& group)
 {
     if (group.empty())
     {

applications/test/instant/Make/files

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

applications/test/instant/Test-instant.cxx

@@ -79,8 +79,11 @@ int main(int argc, char *argv[])
     }
 
     Info<< nl << "times:" << times << nl;
-    sort(times);
+
+    labelList order(Foam::sortedOrder(times));
+    Foam::sort(times);
     Info<< "Sorted:" << times << nl;
+    Info<< "order:" << flatOutput(order) << nl;
 
     for (const scalar val : { -0.5, 5.0, 18.0, 25.0, 450.0, 480.0 })
     {
@@ -105,10 +108,29 @@ int main(int argc, char *argv[])
     files.emplace_back(10, "ten");
 
     Info<< nl << "files:" << files << nl;
-    sort(files);
+    Foam::sort(files);
     Info<< "Sorted:" << files << nl;
 
 
+    {
+        const auto& a = times[3];
+        scalar b = 10;
+        Info<< "compare (" << a << ") <= (" << b << ")  => "
+            << a.less_equal(10) << nl;
+        Info<< "compare (" << a << ") >= (" << b << ")  => "
+            << a.greater_equal(10) << nl;
+    }
+
+    {
+        const auto& a = times[3];
+        const auto& b = files[4];
+        Info<< "compare (" << a << ") <= (" << b << ")  => "
+            << (a <= b) << nl;
+
+        Info<< "compare (" << a << ") >= (" << b << ")  => "
+            << (a >= b) << nl;
+    }
+
     Info<< "\nEnd\n" << endl;
 
     return 0;

applications/test/memInfo/Test-memInfo.cxx

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
+    Copyright (C) 2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -24,8 +25,10 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Application
+    Test-memInfo
 
 Description
+    Very basic test for memInfo values
 
 \*---------------------------------------------------------------------------*/
 
@@ -33,6 +36,7 @@ Description
 #include "IOstreams.H"
 #include "List.H"
 #include "vector.H"
+#include "Switch.H"
 
 using namespace Foam;
 
@@ -41,9 +45,13 @@ using namespace Foam;
 
 int main(int argc, char *argv[])
 {
-    const int n = 10000000;
+    constexpr int n = 10000000;
     const char* const memTags = "peak/size/rss/free mem: ";
 
+    Info<< nl
+        << "memInfo::supported() = " << Switch(memInfo::supported()) << nl
+        << nl;
+
     memInfo mem;
 
     Info<< memTags << mem << endl;

applications/test/nodeTopology/Test-nodeTopology.cxx

@@ -54,9 +54,12 @@ int main(int argc, char *argv[])
         "int",
         "Num of cores to simulate (default: 4)"
     );
+    argList::addBoolOption("scatter", "Use scatter arrows");
 
     #include "setRootCase.H"
 
+    const bool optScatterGraph = args.found("scatter");
+
     label nProcs = UPstream::nProcs(UPstream::worldComm);
 
     DynamicList<int> fake_interNode_offsets;
@@ -128,25 +131,50 @@ int main(int argc, char *argv[])
         auto& os = Info.stream();
 
         os << "// node topology graph:" << nl;
-        os.beginBlock("graph");
+
+        std::string arrow;
+        if (optScatterGraph)
+        {
+            arrow = " -> ";
+            os.beginBlock("digraph");
+        }
+        else
+        {
+            arrow = " -- ";
+            os.beginBlock("graph");
+        }
 
         // Prefer left-to-right layout for large graphs
-        os << indent << "rankdir=LR" << nl;
+        os << indent << "rankdir=LR" << nl << nl;
 
         const label numNodes = interNodeOffsets.size()-1;
 
+        // The master
+        os  << indent
+            << "0 [label=\"master\", style=filled, fillcolor=lightgray];"
+            << nl << nl;
+
         // First level are the inter-node connections
         {
-            os  << indent << 0 << " -- " << token::LBRACE;
+            os  << indent
+                << "// inter-node: " << flatOutput(interNodeOffsets) << nl;
 
-            for (label nodei = 1; nodei < numNodes; ++nodei)
+            os  << indent
+                << 0 << arrow.data() << nl;
+
+            os.beginBlock();
+
+            os  << indent << "rank=same; node [shape=box];" << nl << nl;
+
+            os  << indent;
+            for (label nodei = 0; nodei < numNodes; ++nodei)
             {
-                os  << ' ' << interNodeOffsets[nodei];
+                if (nodei) os << ' ';
+                os  << "node" << nodei;
             }
 
-            os  << token::SPACE << token::RBRACE
-                << "  // inter-node: " << flatOutput(interNodeOffsets)
-                << nl;
+            os  << nl;
+            os.endBlock() << nl;
         }
 
         // Next level are the local-node connections
@@ -155,8 +183,9 @@ int main(int argc, char *argv[])
             const auto firstProc = interNodeOffsets[nodei];
             const auto lastProc = interNodeOffsets[nodei+1];
 
-            os  << indent << firstProc << " -- " << token::DQUOTE
-                << (firstProc+1) << ".." << (lastProc-1)
+            os  << indent << "node" << nodei << arrow.data()
+                << token::DQUOTE
+                << firstProc << ".." << (lastProc-1)
                 << token::DQUOTE << nl;
         }
 

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

@@ -38,6 +38,7 @@ Description
 #include "SubField.H"
 #include "vector.H"
 #include "IOstreams.H"
+#include "UPstreamWindow.H"
 
 using namespace Foam;
 

applications/test/pTraits/Test-pTraits.cxx

@@ -186,9 +186,9 @@ int main()
 
     Info<< nl << "some interesting label limits:" << nl;
     std::cout<< "sizeof = " << sizeof(label) << nl;
-    std::cout<< "min = " << pTraits<label>::min << nl;
-    std::cout<< "max = " << pTraits<label>::max << nl;
-    std::cout<< "umax = " << pTraits<uLabel>::max << nl;
+    std::cout<< "min = " << pTraits<label>::min_ << nl;
+    std::cout<< "max = " << pTraits<label>::max_ << nl;
+    std::cout<< "umax = " << pTraits<uLabel>::max_ << nl;
 
     std::cout<< "max_2 = " << pTraits<label>::max/2 << " <=> "
         << (1L << (sizeof(label)*8-2)) << nl;

applications/test/parallel-chunks/Test-parallel-chunks.cxx

@@ -185,9 +185,9 @@ int main(int argc, char *argv[])
     }
     broadcast_chunks<labelList, label>(input1);
 
-    Pstream::maxCommsSize = 33;
+    UPstream::maxCommsSize = 33;
 
-    args.readIfPresent("comms-size", Pstream::maxCommsSize);
+    args.readIfPresent("comms-size", UPstream::maxCommsSize);
 
     broadcast_chunks<labelList, label>(input1);
 
@@ -197,11 +197,11 @@ int main(int argc, char *argv[])
         PstreamBuffers pBufs;
 
         labelList sendData;
-        if (Pstream::master())
+        if (UPstream::master())
         {
             sendData = identity(500);
 
-            for (const int proci : Pstream::subProcs())
+            for (const int proci : UPstream::subProcs())
             {
                 UOPstream os(proci, pBufs);
                 os << sendData;
@@ -211,7 +211,7 @@ int main(int argc, char *argv[])
         Info<< "call finishedSends()" << endl;
         pBufs.finishedScatters();
 
-        if (!Pstream::master())
+        if (UPstream::is_subrank())
         {
             UIPstream is(UPstream::masterNo(), pBufs);
             is >> sendData;
@@ -225,11 +225,11 @@ int main(int argc, char *argv[])
         labelListList recvBufs(UPstream::nProcs());
         labelList recvSizes;
 
-        if (Pstream::master())
+        if (UPstream::master())
         {
-            for (const int proci : Pstream::allProcs())
+            for (const int proci : UPstream::allProcs())
             {
-                if (proci != Pstream::myProcNo())
+                if (proci != UPstream::myProcNo())
                 {
                     sendBufs[proci] = identity(500);
                 }
@@ -253,11 +253,11 @@ int main(int argc, char *argv[])
         Map<labelList> recvBufs;
         Map<label> recvSizes;
 
-        if (Pstream::master())
+        if (UPstream::master())
         {
-            for (const int proci : Pstream::allProcs())
+            for (const int proci : UPstream::allProcs())
             {
-                if (proci != Pstream::myProcNo())
+                if (proci != UPstream::myProcNo())
                 {
                     sendBufs(proci) = identity(500);
                 }

applications/test/parallel-comm0/Test-parallel-comm0.cxx

@@ -110,21 +110,25 @@ int main(int argc, char *argv[])
             << " (self) reduced " << selfVal << nl;
 
         // Identical size on all procs
-        bitSet procUsed(nProcs);
-
-        if ((myRank % 4) == 0)
         {
-            procUsed.set(myRank);
+            bitSet localUsed(nProcs);
+            localUsed.set(myRank, ((myRank % 4) == 0));
+
+            Pout<< "local  procUsed " << localUsed << nl;
+            localUsed.reduceOr(UPstream::worldComm, false);
+            Pout<< "reduce procUsed " << localUsed << nl;
+        }
+
+        // With allGather
+        {
+            bitSet procUsed
+            (
+                bitSet::allGather((myRank % 4) == 0)
+            );
+
+            Pout<< "allGather: " << procUsed << nl;
         }
 
-        Pout<< "local  procUsed " << procUsed << nl;
-        reduce
-        (
-            procUsed.data(),
-            procUsed.size_data(),
-            bitOrOp<unsigned int>()
-        );
-        Pout<< "reduce procUsed " << procUsed << nl;
 
         // Identical size on all procs
         // encode as 0:empty, 1:uniform, 2:nonuniform, 3:mixed
@@ -147,12 +151,26 @@ int main(int argc, char *argv[])
         }
 
         Pout<< "local  uniform " << uniformity << nl;
-        reduce
+        // reduce with op<..>()
+        #if 1
+        Foam::reduce
         (
             uniformity.data(),
-            uniformity.size_data(),
-            bitOrOp<unsigned int>()
+            uniformity.num_blocks(),
+            bitOrOp<unsigned int>(),
+            UPstream::msgType(),  // ignored
+            UPstream::worldComm
         );
+        #else
+        // Direct call to MPI_Allreduce
+        UPstream::mpiAllReduce
+        (
+            uniformity.data(),
+            uniformity.num_blocks(),
+            UPstream::opCodes::op_bit_or,
+            UPstream::worldComm
+        );
+        #endif
         Pout<< "reduce uniform " << uniformity << nl;
     }
 
@@ -160,8 +178,8 @@ int main(int argc, char *argv[])
     {
         Pair<label> val
         (
-            Pstream::myProcNo(UPstream::commWorld()),
-            Pstream::myProcNo(UPstream::commWorld())
+            UPstream::myProcNo(UPstream::commWorld()),
+            UPstream::myProcNo(UPstream::commWorld())
         );
 
         Pair<label> worldVal = val;

applications/test/parallel-comm3a/Test-parallel-comm3a.cxx

@@ -79,7 +79,7 @@ int main(int argc, char *argv[])
 
     #include "setRootCase.H"
 
-    if (!Pstream::parRun())
+    if (!UPstream::parRun())
     {
         Info<< "\nWarning: not parallel - skipping further tests\n" << endl;
         return 0;
@@ -97,7 +97,7 @@ int main(int argc, char *argv[])
     DynamicList<MPI_Request> recvRequests(10);
 
 
-    if (!Pstream::master())
+    if (UPstream::is_subrank())
     {
         // Send some random length to master
 

applications/test/parallel-comm3b/Test-parallel-comm3b.cxx

@@ -76,7 +76,7 @@ int main(int argc, char *argv[])
 
     #include "setRootCase.H"
 
-    if (!Pstream::parRun())
+    if (!UPstream::parRun())
     {
         Info<< "\nWarning: not parallel - skipping further tests\n" << endl;
         return 0;
@@ -96,7 +96,7 @@ int main(int argc, char *argv[])
     // Map request indices to procs
     Map<label> recvFromProc(20);
 
-    if (!Pstream::master())
+    if (UPstream::is_subrank())
     {
         // Send some random length to master
 

applications/test/parallel-file-write1/Make/files

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

applications/test/parallel-file-write1/Make/options

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

applications/test/parallel-file-write1/Test-parallel-file-write1.cxx

@@ -0,0 +1,260 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2025 Mark Olesen
+-------------------------------------------------------------------------------
+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-parallel-file-write1
+
+Description
+    Simple test of writing with MPI/IO
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "Time.H"
+#include "Switch.H"
+#include "UPstreamFile.H"
+#include "SpanStream.H"
+
+using namespace Foam;
+
+template<class IntType>
+void zeropadded(std::ostream& os, IntType val, char fillch = '0')
+{
+    // set fill char and width
+    os.setf(std::ios_base::right, std::ios_base::adjustfield);
+    fillch = os.fill(fillch);
+    os.width(std::numeric_limits<IntType>::digits10+1);
+    os  << val;
+    // restore fill char
+    os.fill(fillch);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    argList::noCheckProcessorDirectories();
+    argList::addVerboseOption();
+    argList::addBoolOption("master-footer", "Write footer from master");
+
+    #include "setRootCase.H"
+
+    if (!UPstream::parRun())
+    {
+        Info<< "###############" << nl
+            << "Not running in parallel. Stopping now" << nl
+            << "###############" << endl;
+        return 1;
+    }
+
+    const bool optMasterFooter = args.found("master-footer");
+
+    Info<< nl << "Write master-footer: " << Switch::name(optMasterFooter)
+        << nl << nl;
+
+    Info<< "Create time (without controlDict)\n" << endl;
+
+    auto runTimePtr = Time::New();
+    auto& runTime = runTimePtr();
+
+    const auto myProc = UPstream::myProcNo();
+    const auto nProcs = UPstream::nProcs();
+
+    // Some content
+    OCharStream charset;
+    for (int i = 0; i < 10; ++i)
+    {
+        charset<< char('A' + i);
+    }
+
+    // Header/footer buffers - these can be separate or bundled into
+    // the first/last blocks
+
+    OCharStream header;
+    OCharStream footer;
+
+    // Content buffer
+    OCharStream os(IOstream::BINARY);
+
+    {
+        const auto v = charset.view();
+
+        os << nl;
+        os.beginBlock(word("rank" + Foam::name(myProc)));
+
+        for (int repeat = 0;  repeat <= myProc; ++repeat)
+        {
+            os << indent << word("entry" + Foam::name(repeat))
+                << ' ' << word("List<char>");
+            // os << nl;
+            os << ' ';
+            os << label(v.size());
+            os.write(v.data(), v.size());
+            // os << nl;
+            os.endEntry();
+        }
+
+        os.endBlock();
+    }
+
+    // Bundle the footer into the last block
+    if (!optMasterFooter && (myProc == nProcs-1))
+    {
+        IOobject::writeEndDivider(os);
+    }
+
+
+    // All content now exists - commit to disk
+    const std::string_view blockData(os.view());
+    const int64_t blockSize(blockData.size());
+
+    // Collect sizes
+    const List<int64_t> sizes
+    (
+        UPstream::allGatherValues(blockSize, UPstream::worldComm)
+    );
+
+
+    // Format header with size information
+    if (UPstream::master())
+    {
+        header
+            << "Simple MPI/IO test with " << nProcs << " ranks" << nl << nl;
+
+        ocharstream labelbuf;
+        labelbuf.reserve_exact(32);
+
+        // Position before writing a label
+        auto labelBegin = header.tellp();
+
+        header.beginBlock("meta");
+        {
+            header << indent << word("data.start") << ' ';
+
+            labelBegin = header.tellp();
+
+            // Add the start value (placeholder)
+            {
+                labelbuf.rewind();
+                zeropadded(labelbuf, label(0));
+                header.append(labelbuf.view());
+            }
+
+            header.endEntry();
+
+            header << indent << word("data.sizes") << nl;
+            sizes.writeList(header);  // flatOutput
+            header.endEntry();
+        }
+        header.endBlock();
+
+        header << nl;
+        IOobject::writeDivider(header);
+
+        // Now update with the correct size
+        {
+            labelbuf.rewind();
+            zeropadded(labelbuf, label(header.view().size()));
+            header.overwrite(labelBegin, labelbuf.view());
+        }
+
+        // Bundled the footer into the last block or from master?
+        if (optMasterFooter)
+        {
+            IOobject::writeEndDivider(footer);
+        }
+    }
+
+    // With additional header/footer
+    int64_t headerSize(header.view().size());
+    int64_t footerSize(footer.view().size());
+
+    Pstream::broadcast(headerSize);
+    if (optMasterFooter)
+    {
+        Pstream::broadcast(footerSize);
+    }
+
+
+    int64_t totalSize(headerSize);
+    for (int i = 0; i < myProc; ++i)
+    {
+        totalSize += sizes[i];
+    }
+
+    const int64_t blockOffset(totalSize);
+
+    for (int i = myProc; i < nProcs; ++i)
+    {
+        totalSize += sizes[i];
+    }
+    const int64_t footerOffset(totalSize);
+    totalSize += footerSize;
+
+
+    Pout<< "write size=" << label(blockSize)
+        << " at=" << label(blockOffset) << " total=" << label(totalSize) << nl;
+
+    {
+        UPstream::File file;
+
+        bool ok = file.open_write
+        (
+            UPstream::worldComm,
+            runTime.globalPath()/"mpiio-test1.txt",
+            IOstreamOption::ATOMIC
+        );
+
+        if (ok)
+        {
+            Info<< "writing: " << file.name() << nl;
+
+            if (UPstream::master())
+            {
+                // A no-op for empty buffer
+                ok = file.write_at(0, header.view());
+            }
+
+            ok = file.write_at_all(blockOffset, blockData);
+
+            if (UPstream::master())
+            {
+                // A no-op for empty buffer
+                ok = file.write_at(footerOffset, footer.view());
+            }
+        }
+
+        file.set_size(totalSize);
+        file.close();
+    }
+
+    Info<< "\nEnd\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/test/parallel-nbx2/Test-parallel-nbx2.cxx

@@ -52,7 +52,7 @@ int main(int argc, char *argv[])
 
     const bool optNonBlocking = args.found("non-blocking");
 
-    if (!Pstream::parRun())
+    if (!UPstream::parRun())
     {
         Info<< "\nWarning: not parallel - skipping further tests\n" << endl;
         return 0;
@@ -73,7 +73,7 @@ int main(int argc, char *argv[])
     DynamicList<UPstream::Request> sendRequests(10);
     DynamicList<UPstream::Request> recvRequests(10);
 
-    if (!Pstream::master())
+    if (UPstream::is_subrank())
     {
         // Send some random length to master
 

applications/test/sha1/Make/files

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

applications/test/sha1/Test-SHA1.cxx

@@ -64,6 +64,10 @@ int main(int argc, char * argv[])
     osha<< str;
     Info<< osha.digest() << " : output << to empty" << nl;
 
+    osha.reset();
+    osha<< std::string_view(str);
+    Info<< osha.digest() << " : << string_view [ not quite right !]" << nl;
+
     sha.clear();
     sha.append(str);
     shaDig = sha;

applications/test/sort/Test-sortList.cxx

@@ -296,7 +296,7 @@ int main(int argc, char *argv[])
             (
                 strings,
                 order,
-                stringOps::natural_sort::less<string>(strings)
+                stringOps::natural_sort::list_less(strings)
             );
             Info<< "natural sortedOrder: " << flatOutput(order) << endl;
         }
@@ -321,7 +321,7 @@ int main(int argc, char *argv[])
             ///  sortable = hashed.toc();
             ///  sortable.sort
             ///  (
-            ///      stringOps::natural_sort::less<string>(sortable)
+            ///      stringOps::natural_sort::list_less(sortable)
             ///  );
             ///  Info<< nl << "natural:" << sortable << endl;
 
@@ -329,7 +329,7 @@ int main(int argc, char *argv[])
             ///  sortable = hashed.toc();
             ///  sortable.sort
             ///  (
-            ///      stringOps::natural_sort::greater<string>(sortable)
+            ///      stringOps::natural_sort::list_greater(sortable)
             ///  );
             ///  Info<< nl << "natural:" << sortable << endl;
         }

applications/test/stringList/Test-stringList.cxx

@@ -42,7 +42,7 @@ using namespace Foam;
 int main(int argc, char *argv[])
 {
     stringList strings
-    {
+    ({
         "hello",
         "heello",
         "heeello",
@@ -52,7 +52,7 @@ int main(int argc, char *argv[])
         "okey",
         "okkey",
         "okkkey",
-    };
+    });
     labelList matches;
 
     wordRes matcher1(ICharStream("( okey \"[hy]e+.*\" )")());
@@ -72,12 +72,14 @@ int main(int argc, char *argv[])
         }
     }
 
-    Info<< "Match found using ListOps = "
-        << ListOps::found(strings, regExp(".*ee.*")) << nl;
-
-    Info<< "First index = "
-        << ListOps::find(strings, regExp(".*ee.*")) << nl;
+    {
+        regExp matcher(".*ee.*");
 
+        Info<< "Match found using ListOps = "
+            << ListOps::found_if(strings, matcher) << nl
+            << "First index = "
+            << ListOps::find_if(strings, matcher) << nl;
+    }
     Info<< endl;
 
     matches = findMatchingStrings(matcher1, strings);

applications/test/string_view1/Test-string_view1.cxx

@@ -59,11 +59,6 @@ int main(int argc, char *argv[])
                 << " type: " << typeid(cstr).name() << " len:" << len << nl;
 
             Info<< "    view: " << std::string_view(cstr) << nl;
-
-            Info<< "    span: "
-                << stdFoam::span<const char>(cstr, len) << nl;
-            Info<< "    span: "
-                << stdFoam::span<char>(const_cast<char*>(cstr), len) << nl;
         }
     }
 

applications/test/surface-sampling/Make/files

@@ -1,4 +1,4 @@
-mydebugSurfaceWriter.C
-Test-surface-sampling.C
+mydebugSurfaceWriter.cxx
+Test-surface-sampling.cxx
 
 EXE = $(FOAM_USER_APPBIN)/Test-surface-sampling

applications/test/surface-sampling/mydebugSurfaceWriter.cxx

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2022-2023 OpenCFD Ltd.
+    Copyright (C) 2022-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -83,12 +83,10 @@ template<> struct narrowType<SymmTensor<double>>
     typedef SymmTensor<float> type;
 };
 
-// FIXME: Not sure why this one seems to be broken...
-//
-// template<> struct narrowType<Tensor<double>>
-// {
-//     typedef Tensor<float> type;
-// };
+template<> struct narrowType<Tensor<double>>
+{
+    typedef Tensor<float> type;
+};
 
 } // End namespace Foam
 
@@ -104,12 +102,18 @@ Foam::surfaceWriters::mydebugWriter::mergeField
 {
     addProfiling(merge, "debugWriter::merge-field");
 
-    // This is largely identical to surfaceWriter::mergeField()
+    // Identical to surfaceWriter::mergeField()
     // but with narrowing for communication
-    if (narrowTransfer_ && parallel_ && UPstream::parRun())
+
+    if constexpr (std::is_same_v<Tensor<double>, Type>)
+    {
+        // Cannot narrow tensor. Does not compile since MatrixSpace
+        // does not (yet) allow assigments from different Cmpt types.
+    }
+    else if (narrowTransfer_ && parallel_ && UPstream::parRun())
     {
         // The narrowed type
-        typedef typename narrowType<Type>::type narrowedType;
+        using narrowedType = typename narrowType<Type>::type;
 
         // Ensure geometry is also merged
         merge();
@@ -130,14 +134,29 @@ Foam::surfaceWriters::mydebugWriter::mergeField
         ConstPrecisionAdaptor<narrowedType, Type> input(fld);
         PrecisionAdaptor<narrowedType, Type> output(allFld);
 
-        globIndex.gather
-        (
-            input.cref(),   // fld,
-            output.ref(),   // allFld,
-            UPstream::msgType(),
-            commType_,
-            UPstream::worldComm
-        );
+        if (gatherv_)
+        {
+            globIndex.mpiGather
+            (
+                input.cref(),   // fld
+                output.ref(),   // allFld
+                UPstream::worldComm,
+                // For fallback:
+                commType_,
+                UPstream::msgType()
+            );
+        }
+        else
+        {
+            globIndex.gather
+            (
+                input.cref(),   // fld
+                output.ref(),   // allFld
+                UPstream::msgType(),
+                commType_,
+                UPstream::worldComm
+            );
+        }
 
         // Commit adapted content changes
         input.commit();
@@ -193,8 +212,19 @@ Foam::surfaceWriters::mydebugWriter::mydebugWriter
 {
     Info<< "Using debug surface writer ("
         << (this->isPointData() ? "point" : "face") << " data):"
-        << " commsType=" << UPstream::commsTypeNames[commType_]
-        << " merge=" << Switch::name(enableMerge_)
+        << " commsType=";
+
+    if (UPstream::parRun())
+    {
+        if (gatherv_) Info<< "gatherv+";
+        Info<< UPstream::commsTypeNames[commType_];
+    }
+    else
+    {
+        Info<< "serial";
+    }
+
+    Info<< " merge=" << Switch::name(enableMerge_)
         << " write=" << Switch::name(enableWrite_)
         << " narrow=" << Switch::name(narrowTransfer_)
         << endl;

applications/test/token/Test-token.cxx

@@ -43,6 +43,29 @@ Description
 
 using namespace Foam;
 
+const char yesno[2] = { 'n', 'y' };
+
+void printIntegralTest(const token& tok)
+{
+    Info<< "Test: " << tok.info() << nl
+        << "  is  int32 = " << yesno[tok.is_int32()]
+        << ", int64 = " << yesno[tok.is_int64()]
+        << ", uint32 = " << yesno[tok.is_uint32()]
+        << ", uint64 = " << yesno[tok.is_uint64()]
+        << nl;
+}
+
+
+void printFloatTest(const token& tok)
+{
+    Info<< "Test: " << tok.info() << nl
+        << "  is  float = " << yesno[tok.isFloat()]
+        << ", double = " << yesno[tok.isDouble()]
+        << ", number = " << yesno[tok.isNumber()]
+        << nl;
+}
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 //  Main program:
 
@@ -56,6 +79,23 @@ int main(int argc, char *argv[])
     token tok1;
     Info<< "default construct: " << tok1.info() << endl;
 
+    tok1 = label(100);
+    Info<< "assign label: " << tok1.info() << endl;
+
+    tok1 = int64_t(100);
+    Info<< "assign int64: " << tok1.info() << endl;
+
+    tok1 = int32_t(100);
+    Info<< "assign int32: " << tok1.info() << endl;
+
+    {
+        tok1.int64Token(int64_t(INT32_MIN)-1);
+        Info<< "set int64Token: " << tok1.info() << endl;
+
+        printIntegralTest(tok1);
+        printFloatTest(tok1);
+    }
+
     tok1 = double(3.14159);
     Info<< "assign double: " << tok1.info() << endl;
 

applications/test/vector/Test-vector.cxx

@@ -33,6 +33,7 @@ Description
 
 #include "vectorField.H"
 #include "boolVector.H"
+#include "complexVector.H"
 #include "labelVector.H"
 #include "IOstreams.H"
 #include "FixedList.H"
@@ -164,6 +165,30 @@ void testTranscribe(Type& input)
 }
 
 
+// Test of adding to vectors, possible of dissimilar types
+template<class Target, class Source>
+void testAdding(const Target& a, const Source& b)
+{
+    typedef typename Target::cmptType cmptType1;
+    typedef typename Source::cmptType cmptType2;
+
+    Info<< "    "
+        << pTraits<Target>::typeName << " += "
+        << pTraits<Source>::typeName << " : ";
+
+    if constexpr (std::is_convertible_v<cmptType2, cmptType1>)
+    {
+        Target res(a);
+        res += b;
+        Info<< a << " += " << b << " == " << res << nl;
+    }
+    else
+    {
+        Info<< "unsupported" << nl;
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 //  Main program:
 
@@ -173,6 +198,37 @@ int main(int argc, char *argv[])
     Info<<"normalised: " << vector::uniform(VSMALL).normalise() << nl;
     Info<<"normalised: " << vector::uniform(ROOTVSMALL).normalise() << nl;
 
+    {
+        complexVector cvec(complex(1), complex(0), complex(0));
+        doubleVector dvec(1, 0, 0);
+        floatVector  fvec(1, 0, 0);
+        labelVector  lvec(1, 0, 0);
+
+        Info<< nl << "additions:" << nl;
+
+        testAdding(cvec, cvec);
+        testAdding(cvec, dvec);
+        testAdding(cvec, fvec);
+        testAdding(cvec, lvec);
+
+        testAdding(dvec, cvec);
+        testAdding(dvec, dvec);
+        testAdding(dvec, fvec);
+        testAdding(dvec, lvec);
+
+        testAdding(fvec, cvec);
+        testAdding(fvec, dvec);
+        testAdding(fvec, fvec);
+        testAdding(fvec, lvec);
+
+        testAdding(lvec, cvec);
+        testAdding(lvec, dvec);
+        testAdding(lvec, fvec);
+        testAdding(lvec, lvec);
+
+        Info<< nl;
+    }
+
     {
         vector vec1(0.5, 0.5, 0.5);
         vector vec2(0.5, 0.51, -0.5);

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

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2023 OpenCFD Ltd.
+    Copyright (C) 2016-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -857,16 +857,8 @@ int main(int argc, char *argv[])
 
             if
             (
-                obj.isHeaderClass<volScalarField>()
-             || obj.isHeaderClass<volVectorField>()
-             || obj.isHeaderClass<volSphericalTensorField>()
-             || obj.isHeaderClass<volTensorField>()
-             || obj.isHeaderClass<volSymmTensorField>()
-             || obj.isHeaderClass<surfaceScalarField>()
-             || obj.isHeaderClass<surfaceVectorField>()
-             || obj.isHeaderClass<surfaceSphericalTensorField>()
-             || obj.isHeaderClass<surfaceSymmTensorField>()
-             || obj.isHeaderClass<surfaceTensorField>()
+                Foam::fieldTypes::is_volume(obj.headerClassName())
+             || Foam::fieldTypes::is_surface(obj.headerClassName())
             )
             {
                 objects.add(objPtr);

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

@@ -86,7 +86,7 @@ void constructVolFields(fvMesh& mesh, const vtkUnstructuredReader& reader)
         );
         auto& fld = tfld.ref();
         fld.instance() = mesh.time().timeName();
-        fld.writeOpt() = IOobject::AUTO_WRITE;
+        fld.writeOpt(IOobject::AUTO_WRITE);
 
         // Fill cell values
         fld.internalFieldRef().field() =

applications/utilities/mesh/generation/blockMesh/mergePatchPairs.H

@@ -152,7 +152,7 @@ Description
 
                 if
                 (
-                    !cleanupPatches.found(patchName)
+                    !cleanupPatches.contains(patchName)
                  || returnReduceOr(oldPatches[patchi].size())
                 )
                 {
@@ -188,8 +188,9 @@ Description
 
         // Cleanup empty merged point zones
         {
-            PtrList<pointZone>& zones = mesh.pointZones();
-            mesh.pointZones().clearAddressing();
+            auto& zmesh = mesh.pointZones();
+            zmesh.clearAddressing();
+            PtrList<pointZone>& zones = zmesh;
 
             wordHashSet removedZones(2*zones.size());
 
@@ -198,12 +199,11 @@ Description
             {
                 if
                 (
-                    !cleanupPointZones.found(zones[zonei].name())
+                    !cleanupPointZones.contains(zones[zonei].name())
                  || returnReduceOr(zones[zonei].size())
                 )
                 {
                     zones.set(nZones, zones.release(zonei));
-                    zones[nZones].index() = nZones;  // re-index
                     ++nZones;
                 }
                 else
@@ -212,6 +212,7 @@ Description
                 }
             }
             zones.resize(nZones);
+            zmesh.reindex();
 
             if (removedZones.size())
             {
@@ -223,8 +224,9 @@ Description
 
         // Cleanup empty merged face zones
         {
-            PtrList<faceZone>& zones = mesh.faceZones();
-            mesh.faceZones().clearAddressing();
+            auto& zmesh = mesh.faceZones();
+            zmesh.clearAddressing();
+            PtrList<faceZone>& zones = zmesh;
 
             wordHashSet removedZones(2*zones.size());
 
@@ -233,12 +235,11 @@ Description
             {
                 if
                 (
-                    !cleanupFaceZones.found(zones[zonei].name())
+                    !cleanupFaceZones.contains(zones[zonei].name())
                  || returnReduceOr(zones[zonei].size())
                 )
                 {
                     zones.set(nZones, zones.release(zonei));
-                    zones[nZones].index() = nZones;  // re-index
                     ++nZones;
                 }
                 else
@@ -247,6 +248,7 @@ Description
                 }
             }
             zones.resize(nZones);
+            zmesh.reindex();
 
             if (removedZones.size())
             {

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

@@ -473,16 +473,6 @@ int main(int argc, char *argv[])
         );
 
 
-        // Precalculate mesh edges for pp.edges.
-        const labelList meshEdges
-        (
-            extrudePatch.meshEdges
-            (
-                mesh.edges(),
-                mesh.pointEdges()
-            )
-        );
-
         // Global face indices engine
         const globalIndex globalFaces(mesh.nFaces());
 

applications/utilities/mesh/manipulation/checkMesh/writeMeshChecks.H

@@ -13,28 +13,40 @@ const Enum<writeChecksFormatType> writeChecksFormatTypeNames
 
 writeChecksFormatType writeChecksFormat(writeChecksFormatType::none);
 
-auto writeMeshChecks = [](const fvMesh& mesh, const writeChecksFormatType fmt)
+auto writeMeshChecks = [&](const fvMesh& mesh, const writeChecksFormatType fmt)
 {
+    // Early exit if 'none' option is set
+    if (fmt == writeChecksFormatType::none)
+    {
+        return;
+    }
+
     if (UPstream::master())
     {
+        fileName path(mesh.time().globalPath()/"checkMesh");
+        if (mesh.name() != polyMesh::defaultRegion)
+        {
+            path += "_" + mesh.name();
+        }
+
+        OFstream os(path.ext(writeChecksFormatTypeNames[fmt]));
+
+        Info<< "Writing mesh data to " << os.name() << nl << endl;
+
         switch (fmt)
         {
             case writeChecksFormatType::dictionary:
             {
-                OFstream os(mesh.time().globalPath()/"checkMesh.dict");
-
                 IOdictionary data
                 (
                     IOobject
                     (
-                        mesh.time().globalPath()/"checkMesh.dict",
+                        os.name(),
                         mesh,
                         IOobject::NO_READ
                     )
                 );
 
-                Info<< "Writing mesh data to " << os.name() << nl << endl;
-
                 data.writeHeader(os);
 
                 mesh.data().meshDict().write(os, false);
@@ -45,13 +57,9 @@ auto writeMeshChecks = [](const fvMesh& mesh, const writeChecksFormatType fmt)
             }
             case writeChecksFormatType::JSON:
             {
-                OFstream os(mesh.time().globalPath()/"checkMesh.json");
-
-                Info<< "Writing mesh data to " << os.name() << nl << endl;
-
                 JSONformatter json(os);
-
                 json.writeDict(mesh.data().meshDict());
+
                 break;
             }
             default:

applications/utilities/mesh/manipulation/createPatch/createPatch.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2016-2024 OpenCFD Ltd.
+    Copyright (C) 2016-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -42,14 +42,14 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
-#include "cyclicPolyPatch.H"
-#include "syncTools.H"
 #include "argList.H"
 #include "Time.H"
 #include "OFstream.H"
 #include "meshTools.H"
 #include "faceSet.H"
 #include "IOPtrList.H"
+#include "cyclicPolyPatch.H"
+#include "syncTools.H"
 #include "polyTopoChange.H"
 #include "polyModifyFace.H"
 #include "polyAddFace.H"
@@ -942,6 +942,9 @@ int main(int argc, char *argv[])
     }
 
 
+    // Maintain list of added patches so we exclude them from filtering
+    // later on
+    List<DynamicList<word>> allAddedPatches(meshes.size());
 
     // Loop over all regions
 
@@ -1036,6 +1039,7 @@ int main(int argc, char *argv[])
                                 fvPatchFieldBase::calculatedType(),
                                 true
                             );
+                            allAddedPatches[meshi].append(ppPtr->name());
                         }
                     }
                 }
@@ -1087,6 +1091,7 @@ int main(int argc, char *argv[])
                                 fvPatchFieldBase::calculatedType(),
                                 true
                             );
+                            allAddedPatches[meshi].append(ppPtr->name());
                         }
                     }
                 }
@@ -1116,6 +1121,7 @@ int main(int argc, char *argv[])
                         fvPatchFieldBase::calculatedType(),
                         true
                     );
+                    allAddedPatches[meshi].append(ppPtr->name());
                 }
             }
         }
@@ -1453,7 +1459,7 @@ int main(int argc, char *argv[])
         Info<< "Removing patches with no faces in them." << nl << endl;
         const wordList oldPatchNames(mesh.boundaryMesh().names());
         const wordList oldPatchTypes(mesh.boundaryMesh().types());
-        fvMeshTools::removeEmptyPatches(mesh, true);
+        fvMeshTools::removeEmptyPatches(mesh, allAddedPatches[meshi], true);
         forAll(oldPatchNames, patchi)
         {
             const word& pName = oldPatchNames[patchi];
@@ -1476,14 +1482,11 @@ int main(int argc, char *argv[])
     {
         ++runTime;
     }
-    else
-    {
-        forAll(meshes, meshi)
-        {
-            fvMesh& mesh = meshes[meshi];
 
-            mesh.setInstance(oldInstances[meshi]);
-        }
+    forAll(meshes, meshi)
+    {
+        fvMesh& mesh = meshes[meshi];
+        mesh.setInstance(overwrite ? oldInstances[meshi] : runTime.timeName());
     }
 
     // More precision (for points data)
@@ -1493,6 +1496,21 @@ int main(int argc, char *argv[])
     forAll(meshes, meshi)
     {
         fvMesh& mesh = meshes[meshi];
+
+        // Override bcs with explicitly provided info. Done late so there
+        // are already patch faces
+        forAll(patchInfoDicts[meshi], sourcei)
+        {
+            const dictionary& patchDict = patchInfoDicts[meshi][sourcei];
+            const word& patchName = patchNames[meshi][sourcei];
+            const label patchID = mesh.boundary().findPatchID(patchName);
+            if (patchID != -1 && patchDict.found("patchFields"))
+            {
+                const dictionary& pfd = patchDict.subDict("patchFields");
+                fvMeshTools::setPatchFields(mesh, patchID, pfd);
+            }
+        }
+
         Info<< "\n\nWriting repatched mesh " << mesh.name()
             << " to " << runTime.timeName() << nl << endl;
         mesh.clearOut();    // remove meshPhi

applications/utilities/miscellaneous/foamDictionary/foamDictionary.C

@@ -251,18 +251,31 @@ const dictionary& lookupScopedDict
         return dict;
     }
 
-    const entry* eptr = dict.findScoped(subDictName, keyType::LITERAL);
+    const auto finder = dict.csearchScoped(subDictName, keyType::LITERAL);
 
-    if (!eptr || !eptr->isDict())
+    if (!finder.good() || !finder.isDict())
     {
+        // Not found or not a dictionary
         FatalIOErrorInFunction(dict)
-            << "'" << subDictName << "' not found in dictionary "
-            << dict.name() << " or is not a dictionary" << nl
-            << "Known entries are " << dict.keys()
+            << '"' << subDictName << '"' << nl;
+
+        if (!finder.good())
+        {
+            FatalIOError << "Not found in dictionary";
+        }
+        else
+        {
+            FatalIOError << "Not a dictionary entry";
+        }
+
+        FatalIOError
+            << nl << nl
+            << "Known entries of " << finder.context().name() << " : " << nl
+            << finder.context().keys()
             << exit(FatalIOError);
     }
 
-    return eptr->dict();
+    return finder.dict();
 }
 
 

applications/utilities/miscellaneous/foamFormatConvert/foamFormatConvert.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2016-2023 OpenCFD Ltd.
+    Copyright (C) 2016-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -383,29 +383,10 @@ int main(int argc, char *argv[])
 
             if
             (
-                io.isHeaderClass<volScalarField>()
-             || io.isHeaderClass<volVectorField>()
-             || io.isHeaderClass<volSphericalTensorField>()
-             || io.isHeaderClass<volSymmTensorField>()
-             || io.isHeaderClass<volTensorField>()
-
-             || io.isHeaderClass<surfaceScalarField>()
-             || io.isHeaderClass<surfaceVectorField>()
-             || io.isHeaderClass<surfaceSphericalTensorField>()
-             || io.isHeaderClass<surfaceSymmTensorField>()
-             || io.isHeaderClass<surfaceTensorField>()
-
-             || io.isHeaderClass<pointScalarField>()
-             || io.isHeaderClass<pointVectorField>()
-             || io.isHeaderClass<pointSphericalTensorField>()
-             || io.isHeaderClass<pointSymmTensorField>()
-             || io.isHeaderClass<pointTensorField>()
-
-             || io.isHeaderClass<volScalarField::Internal>()
-             || io.isHeaderClass<volVectorField::Internal>()
-             || io.isHeaderClass<volSphericalTensorField::Internal>()
-             || io.isHeaderClass<volSymmTensorField::Internal>()
-             || io.isHeaderClass<volTensorField::Internal>()
+                Foam::fieldTypes::is_volume(io.headerClassName())
+             || Foam::fieldTypes::is_internal(io.headerClassName())
+             || Foam::fieldTypes::is_surface(io.headerClassName())
+             || Foam::fieldTypes::is_point(io.headerClassName())
             )
             {
                 Info<< "        Reading " << io.headerClassName()

applications/utilities/miscellaneous/foamListRegions/foamListRegions.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2020 OpenCFD Ltd.
+    Copyright (C) 2017-2025 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -30,7 +30,8 @@ Group
     grpPostProcessingUtilities
 
 Description
-    List regions from constant/regionProperties.
+    List volume regions from constant/regionProperties
+    or area regions from constant/finite-area/regionProperties
 
 Usage
     \b foamListRegions [OPTION]
@@ -45,6 +46,9 @@ Note
 #include "Time.H"
 #include "regionProperties.H"
 
+// Same as faMesh::prefix() but without additional linkage
+constexpr const char* const faMeshPrefix = "finite-area";
+
 using namespace Foam;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -53,7 +57,8 @@ int main(int argc, char *argv[])
 {
     argList::addNote
     (
-        "List regions from constant/regionProperties"
+        "List volume regions from constant/regionProperties,\n"
+        "or area regions from constant/finite-area/regionProperties"
     );
 
     argList::noBanner();
@@ -62,12 +67,55 @@ int main(int argc, char *argv[])
     argList::noFunctionObjects();  // Never use function objects
     // No profiling since there is no time loop
 
+    argList::addBoolOption
+    (
+        "finite-area",
+        "List constant/finite-area/regionProperties (if available)"
+    );
+
+    argList::addBoolOption
+    (
+        "optional",
+        "A missing regionProperties is not treated as an error"
+    );
+
+    argList::addDryRunOption
+    (
+        "Make reading optional and add verbosity"
+    );
+    argList::addVerboseOption("Additional verbosity");
+
     // Arguments are optional (non-mandatory)
     argList::noMandatoryArgs();
     argList::addArgument("regionType ... regionType");
 
     #include "setRootCase.H"
 
+    const bool dryRun = args.dryRun();
+    int optVerbose = args.verbose();
+
+    if (dryRun && !optVerbose)
+    {
+        ++optVerbose;
+    }
+
+    // File is optional, not an error
+    const bool isOptional = args.found("optional");
+
+    // Use finite-area regions
+    const bool doFiniteArea = args.found("finite-area");
+
+    // The number of optional region filters to apply
+    const label nFilters = (args.size()-1);
+
+    IOobjectOption::readOption readOpt(IOobjectOption::MUST_READ);
+
+    if (dryRun || isOptional || doFiniteArea)
+    {
+        // The finite-area regionProperties are also considered optional
+        readOpt = IOobjectOption::READ_IF_PRESENT;
+    }
+
     // Silent version of "createTime.H", without libraries
     Time runTime
     (
@@ -77,30 +125,74 @@ int main(int argc, char *argv[])
         false   // no enableLibs
     );
 
-    regionProperties rp(runTime);
+    regionProperties regionProps;
+    if (doFiniteArea)
+    {
+        regionProps = regionProperties(runTime, faMeshPrefix, readOpt);
+    }
+    else
+    {
+        regionProps = regionProperties(runTime, readOpt);
+    }
+
+    // Some reporting...
+    if (regionProps.empty())
+    {
+        if (doFiniteArea)
+        {
+            InfoErr<< "No finite-area region types" << nl;
+        }
+        else if (isOptional)
+        {
+            InfoErr<< "No region types" << nl;
+        }
+    }
+    else if (optVerbose)
+    {
+        InfoErr << "Have " << regionProps.size();
+
+        if (doFiniteArea)
+        {
+            InfoErr<< " finite-area";
+        }
+        InfoErr
+            << " region types, "
+            << regionProps.count() << " regions" << nl << nl;
+    }
+
 
     // We now handle checking args and general sanity etc.
-    wordList regionTypes;
 
-    if (args.size() > 1)
+    DynamicList<word> regionTypes;
+
+    if (isOptional && regionProps.empty())
     {
-        regionTypes.resize(args.size()-1);
+        // Nothing to do...
+    }
+    else if (nFilters > 0)
+    {
+        // Apply region filters
 
-        // No duplicates
+        regionTypes.reserve_exact
+        (
+            Foam::min(nFilters, regionProps.size())
+        );
+
+        // No duplicates, and no duplicate warnings
         wordHashSet uniq;
 
-        label nTypes = 0;
         for (label argi = 1; argi < args.size(); ++argi)
         {
-            regionTypes[nTypes] = args[argi];
-
-            const word& regType = regionTypes[nTypes];
+            word regType(args[argi]);
 
             if (uniq.insert(regType))
             {
-                if (rp.found(regType))
+                if (regionProps.contains(regType))
                 {
-                    ++nTypes;
+                    if (!regionTypes.contains(regType))
+                    {
+                        regionTypes.push_back(std::move(regType));
+                    }
                 }
                 else
                 {
@@ -108,22 +200,22 @@ int main(int argc, char *argv[])
                 }
             }
         }
-
-        regionTypes.resize(nTypes);
     }
     else
     {
-        regionTypes = rp.sortedToc();
+        // Take all regions
+        regionTypes = regionProps.sortedToc();
     }
 
 
     for (const word& regionType : regionTypes)
     {
-        const wordList& regionNames = rp[regionType];
-
-        for (const word& regionName : regionNames)
+        if (const auto iter = regionProps.cfind(regionType); iter.good())
         {
-            Info<< regionName << nl;
+            for (const word& regionName : iter.val())
+            {
+                Info<< regionName << nl;
+            }
         }
     }
 

applications/utilities/parallelProcessing/decomposePar/decomposePar.C

@@ -418,8 +418,14 @@ int main(int argc, char *argv[])
     // Allow explicit -constant, have zero from time range
     timeSelector::addOptions(true, false);  // constant(true), zero(false)
 
+    // Prevent volume BCs from triggering finite-area
+    regionModels::allowFaModels(false);
+
     #include "setRootCase.H"
 
+    // ------------------------------------------------------------------------
+    // Configuration
+
     const bool writeCellDist    = args.found("cellDist");
 
     // Most of these are ignored for dry-run (not triggered anywhere)