Merge branch 'update-selection-ordering' into 'develop'

Updates to function objects handling of patches / selection names for parallel consistent order

See merge request Development/openfoam!617

applications/solvers/multiphase/compressibleInterFoam/compressibleInterFilmFoam/VoFPatchTransfer/VoFPatchTransfer.C

@@ -86,6 +86,7 @@ VoFPatchTransfer::VoFPatchTransfer
     wordRes patchNames;
     if (coeffDict_.readIfPresent("patches", patchNames))
     {
+        // Can also use pbm.indices(), but no warnings...
         patchIDs_ = pbm.patchSet(patchNames).sortedToc();
 
         Info<< "        applying to " << patchIDs_.size() << " patches:" << nl;

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

@@ -52,7 +52,9 @@ namespace Foam
 const Foam::volScalarField&
 Foam::radiation::localDensityAbsorptionEmission::alpha(word alphaName) const
 {
-    if (!mesh_.foundObject<volScalarField>(alphaName))
+    const volScalarField* ptr = mesh_.cfindObject<volScalarField>(alphaName);
+
+    if (!ptr)
     {
         FatalErrorInFunction
             << "Unable to retrieve density field " << alphaName << " from "
@@ -60,7 +62,7 @@ Foam::radiation::localDensityAbsorptionEmission::alpha(word alphaName) const
             << exit(FatalError);
     }
 
-    return mesh_.lookupObject<volScalarField>(alphaName);
+    return *ptr;
 }
 
 

applications/test/DirLister/DirLister.H

@@ -85,7 +85,7 @@ Description
 
         fileNameList procDirs
         (
-            DirLister::dirs(".").sorted<fileName>(matchProcs)
+            DirLister::dirs(".").csorted<fileName>(matchProcs)
         );
     }
     \endcode
@@ -206,11 +206,11 @@ public:
 
         //- Return a complete list of names, sorted in natural order
         template<class StringType=Foam::word>
-        List<StringType> sorted() const;
+        List<StringType> csorted() const;
 
         //- Return complete list of names, sorted in natural order
         template<class StringType=Foam::word, class UnaryPredicate>
-        List<StringType> sorted
+        List<StringType> csorted
         (
             const UnaryPredicate& pred,
             const bool prune = false

applications/test/DirLister/DirListerTemplates.C

@@ -70,23 +70,23 @@ Foam::List<StringType> Foam::DirLister::list() const
 
 
 template<class StringType, class UnaryPredicate>
-Foam::List<StringType> Foam::DirLister::sorted
+Foam::List<StringType> Foam::DirLister::csorted
 (
     const UnaryPredicate& pred,
     const bool prune
 ) const
 {
-    List<StringType> lst(list<StringType>(pred, prune));
-    sort(lst, stringOps::natural_sort());
+    List<StringType> list(list<StringType>(pred, prune));
+    Foam::sort(list, stringOps::natural_sort());
 
-    return lst;
+    return list;
 }
 
 
 template<class StringType>
-Foam::List<StringType> Foam::DirLister::sorted() const
+Foam::List<StringType> Foam::DirLister::csorted() const
 {
-    return sorted<StringType>(predicates::always());
+    return csorted<StringType>(predicates::always());
 }
 
 

applications/test/DirLister/Test-DirLister.C

@@ -162,7 +162,7 @@ int main(int argc, char *argv[])
         Info<< "dirList: "
             << flatOutput
                (
-                   DirLister::dirs(".").sorted<fileName>(relist)
+                   DirLister::dirs(".").csorted<fileName>(relist)
                ) << nl;
     }
 

applications/test/HashTable1/Test-HashTable1.C

@@ -75,8 +75,8 @@ int main()
     }
 
 
-    Info<< "\ntable1 sorted() :" << endl;
-    for (const auto& iter : table1.sorted())
+    Info<< "\ntable1 csorted() :" << endl;
+    for (const auto& iter : table1.csorted())
     {
         Info<< "    " << iter.key() << " => " << iter.val() << nl;
     }
@@ -100,7 +100,7 @@ int main()
     }
 
     Info<< "\nInplace modified - via sorted() access :" << endl;
-    for (const auto& iter : table1.sorted())
+    for (const auto& iter : table1.csorted())
     {
         Info<< "    " << iter.key() << " => " << iter.val() << nl;
     }

applications/test/IOobjectList/Test-IOobjectList.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2022 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -290,14 +290,14 @@ int main(int argc, char *argv[])
         Info<< "Time: " << runTime.timeName() << nl;
 
         report(objects);
-        report(objects.sorted());
+        report(objects.csorted());
 
-        report(objects.sorted<volScalarField>());
-        report(objects.sorted<volVectorField>());
+        report(objects.csorted<volScalarField>());
+        report(objects.csorted<volVectorField>());
 
         // Extra checks
-        report<volScalarField>(objects.sorted<volScalarField>());
-        report<volScalarField>(objects.sorted<volVectorField>());
+        report<volScalarField>(objects.csorted<volScalarField>());
+        report<volScalarField>(objects.csorted<volVectorField>());
 
 
         findObjectTest(objects);

applications/test/foamToEnsight-check/foamToEnsight-check.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2022 OpenCFD Ltd.
+    Copyright (C) 2022-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -139,7 +139,7 @@ void printInfo(const ensightMesh& mesh, int verbose = 0)
     FixedList<label, 3> cellStats(Zero);
     FixedList<label, 3> faceStats(Zero);
 
-    for (const auto& iter : mesh.cellZoneParts().sorted())
+    for (const auto& iter : mesh.cellZoneParts().csorted())
     {
         FixedList<label, 3> stats = printPartInfo(iter.val(), verbose);
 
@@ -149,7 +149,7 @@ void printInfo(const ensightMesh& mesh, int verbose = 0)
         }
     }
 
-    for (const auto& iter : mesh.faceZoneParts().sorted())
+    for (const auto& iter : mesh.faceZoneParts().csorted())
     {
         FixedList<label, 3> stats = printPartInfo(iter.val(), verbose);
 
@@ -159,7 +159,7 @@ void printInfo(const ensightMesh& mesh, int verbose = 0)
         }
     }
 
-    for (const auto& iter : mesh.boundaryParts().sorted())
+    for (const auto& iter : mesh.boundaryParts().csorted())
     {
         FixedList<label, 3> stats = printPartInfo(iter.val(), verbose);
 

applications/test/gravityMeshObject/Test-gravityMeshObject.C

@@ -57,7 +57,7 @@ int main(int argc, char *argv[])
 
     Info<< "Found: " << objects << nl << endl;
 
-    for (const IOobject& io : objects.sorted<uniformDimensionedVectorField>())
+    for (const IOobject& io : objects.csorted<uniformDimensionedVectorField>())
     {
         if (io.name() == meshObjects::gravity::typeName)
         {

applications/test/objectRegistry/Test-objectRegistry.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2016-2022 OpenCFD Ltd.
+    Copyright (C) 2016-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -78,8 +78,8 @@ void printRegistry
     Foam::label indent
 )
 {
-    UPtrList<const regIOobject> objects(obr.sorted());
-    wordList regNames(obr.sortedNames<objectRegistry>());
+    const UPtrList<const regIOobject> objects(obr.csorted());
+    const wordList regNames(obr.sortedNames<objectRegistry>());
 
     std::string prefix;
     for (label i=indent; i; --i)

applications/test/objectRegistry2/Test-objectRegistry2.C

@@ -145,8 +145,8 @@ void printRegistry
     Foam::label indent
 )
 {
-    UPtrList<const regIOobject> objects(obr.sorted());
-    wordList regNames(obr.sortedNames<objectRegistry>());
+    const UPtrList<const regIOobject> objects(obr.csorted());
+    const wordList regNames(obr.sortedNames<objectRegistry>());
 
     std::string prefix;
     for (label i=indent; i; --i)
@@ -315,7 +315,7 @@ int main(int argc, char *argv[])
 
         registryTests(mesh);
 
-        report(mesh.sorted<const volScalarField>());
+        report(mesh.csorted<volScalarField>());
         report(mesh.csorted<volVectorField>());
 
         Info<< nl;

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

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2022 OpenCFD Ltd.
+    Copyright (C) 2016-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -131,40 +131,56 @@ void modifyOrAddFace
 
 
 template<class Type>
-void subsetVolFields
+PtrList<GeometricField<Type, fvPatchField, volMesh>> subsetVolFields
 (
     const fvMeshSubset& subsetter,
     const IOobjectList& objects,
     const label patchi,
-    const Type& exposedValue,
-    PtrList<GeometricField<Type, fvPatchField, volMesh>>& subFields
+    const Type& exposedValue
 )
 {
     typedef GeometricField<Type, fvPatchField, volMesh> GeoField;
 
     const fvMesh& baseMesh = subsetter.baseMesh();
 
+    const UPtrList<const IOobject> fieldObjects
+    (
+        objects.csorted<GeoField>()
+    );
+
+    PtrList<GeoField> subFields(fieldObjects.size());
+
     label nFields = 0;
-
-    for (const word& fieldName : objects.sortedNames<GeoField>())
+    for (const IOobject& io : fieldObjects)
     {
-        const IOobject* ioptr = objects.findObject(fieldName);
-
         if (!nFields)
         {
-            Info<< "Subsetting " << GeoField::typeName << nl;
+            Info<< "Subsetting " << GeoField::typeName << " (";
         }
-        Info<< "    " << fieldName << endl;
+        else
+        {
+            Info<< ' ';
+        }
+        Info<< "    " << io.name() << endl;
 
-        GeoField origField(*ioptr, baseMesh);
+        // Read unregistered
+        IOobject rio(io, IOobjectOption::NO_REGISTER);
+        GeoField origField(rio, baseMesh);
 
         subFields.set(nFields, subsetter.interpolate(origField));
+        auto& subField = subFields[nFields];
+        ++nFields;
+
+
+        // Subsetting adds 'subset' prefix. Rename field to be like original.
+        subField.rename(io.name());
+        subField.writeOpt(IOobjectOption::AUTO_WRITE);
+
 
         // Explicitly set exposed faces (in patchi) to exposedValue.
         if (patchi >= 0)
         {
-            fvPatchField<Type>& fld =
-                subFields[nFields].boundaryFieldRef()[patchi];
+            fvPatchField<Type>& fld = subField.boundaryFieldRef()[patchi];
 
             const label newStart = fld.patch().patch().start();
             const label oldPatchi = subsetter.patchMap()[patchi];
@@ -195,48 +211,68 @@ void subsetVolFields
                     }
                 }
             }
+        }
+    }
 
-            ++nFields;
-        }
+    if (nFields)
+    {
+        Info<< ')' << nl;
     }
+
+    return subFields;
 }
 
 
 template<class Type>
-void subsetSurfaceFields
+PtrList<GeometricField<Type, fvsPatchField, surfaceMesh>> subsetSurfaceFields
 (
     const fvMeshSubset& subsetter,
     const IOobjectList& objects,
     const label patchi,
-    const Type& exposedValue,
-    PtrList<GeometricField<Type, fvsPatchField, surfaceMesh>>& subFields
+    const Type& exposedValue
 )
 {
     typedef GeometricField<Type, fvsPatchField, surfaceMesh> GeoField;
 
     const fvMesh& baseMesh = subsetter.baseMesh();
 
+    const UPtrList<const IOobject> fieldObjects
+    (
+        objects.csorted<GeoField>()
+    );
+
+    PtrList<GeoField> subFields(fieldObjects.size());
+
     label nFields = 0;
-
-    for (const word& fieldName : objects.sortedNames<GeoField>())
+    for (const IOobject& io : fieldObjects)
     {
-        const IOobject* ioptr = objects.findObject(fieldName);
-
         if (!nFields)
         {
-            Info<< "Subsetting " << GeoField::typeName << nl;
+            Info<< "Subsetting " << GeoField::typeName << " (";
         }
-        Info<< "    " << fieldName << endl;
+        else
+        {
+            Info<< ' ';
+        }
+        Info<< io.name();
 
-        GeoField origField(*ioptr, baseMesh);
+        // Read unregistered
+        IOobject rio(io, IOobjectOption::NO_REGISTER);
+        GeoField origField(rio, baseMesh);
 
         subFields.set(nFields, subsetter.interpolate(origField));
+        auto& subField = subFields[nFields];
+        ++nFields;
+
+        // Subsetting adds 'subset' prefix. Rename field to be like original.
+        subField.rename(io.name());
+        subField.writeOpt(IOobjectOption::AUTO_WRITE);
+
 
         // Explicitly set exposed faces (in patchi) to exposedValue.
         if (patchi >= 0)
         {
-            fvsPatchField<Type>& fld =
-                subFields[nFields].boundaryFieldRef()[patchi];
+            fvsPatchField<Type>& fld = subField.boundaryFieldRef()[patchi];
 
             const label newStart = fld.patch().patch().start();
             const label oldPatchi = subsetter.patchMap()[patchi];
@@ -268,9 +304,14 @@ void subsetSurfaceFields
                 }
             }
         }
-
-        ++nFields;
     }
+
+    if (nFields)
+    {
+        Info<< ')' << nl;
+    }
+
+    return subFields;
 }
 
 
@@ -284,16 +325,9 @@ void initCreatedPatches
     const typename GeoField::value_type initValue
 )
 {
-    HashTable<const GeoField*> fields
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllIters(fields, fieldIter)
+    for (const GeoField& field : mesh.objectRegistry::csorted<GeoField>())
     {
-        GeoField& field = const_cast<GeoField&>(*fieldIter());
-
-        auto& fieldBf = field.boundaryFieldRef();
+        auto& fieldBf = const_cast<GeoField&>(field).boundaryFieldRef();
 
         forAll(fieldBf, patchi)
         {
@@ -326,43 +360,36 @@ void subsetTopoSets
     PtrList<TopoSet> sets;
     ReadFields<TopoSet>(objects, sets);
 
-    subSets.resize(sets.size());
+    subSets.resize_null(sets.size());
+
     forAll(sets, seti)
     {
-        TopoSet& set = sets[seti];
+        const TopoSet& set = sets[seti];
 
-        Info<< "Subsetting " << set.type() << " " << set.name() << endl;
+        Info<< "Subsetting " << set.type() << ' ' << set.name() << endl;
+
+        labelHashSet subset(2*min(set.size(), map.size()));
 
         // Map the data
-        bitSet isSet(set.maxSize(mesh));
-        for (const label id : set)
+        forAll(map, i)
         {
-            isSet.set(id);
-        }
-
-        label nSet = 0;
-        for (const label id : map)
+            if (set.contains(map[i]))
             {
-            if (isSet.test(id))
-            {
-                ++nSet;
+                subset.insert(i);
             }
         }
 
         subSets.set
         (
             seti,
-            new TopoSet(subMesh, set.name(), nSet, IOobject::AUTO_WRITE)
+            new TopoSet
+            (
+                subMesh,
+                set.name(),
+                std::move(subset),
+                IOobjectOption::AUTO_WRITE
+            )
         );
-        TopoSet& subSet = subSets[seti];
-
-        forAll(map, i)
-        {
-            if (isSet.test(map[i]))
-            {
-                subSet.insert(i);
-            }
-        }
     }
 }
 
@@ -613,6 +640,7 @@ label findPatch(const polyBoundaryMesh& patches, const word& patchName)
 }
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 int main(int argc, char *argv[])
 {
@@ -844,138 +872,117 @@ int main(int argc, char *argv[])
             }
         }
     }
+
     // Read vol fields and subset.
-
-    wordList scalarNames(objects.sortedNames<volScalarField>());
-    PtrList<volScalarField> scalarFlds(scalarNames.size());
-    subsetVolFields
+    PtrList<volScalarField> scalarFlds
+    (
+        subsetVolFields<scalar>
         (
             subsetter,
             objects,
             defaultPatchi,
-        scalar(Zero),
-        scalarFlds
+            scalar(Zero)
+        )
     );
 
-    wordList vectorNames(objects.sortedNames<volVectorField>());
-    PtrList<volVectorField> vectorFlds(vectorNames.size());
-    subsetVolFields
+    PtrList<volVectorField> vectorFlds
+    (
+        subsetVolFields<vector>
         (
             subsetter,
             objects,
             defaultPatchi,
-        vector(Zero),
-        vectorFlds
+            vector(Zero)
+        )
     );
 
-    wordList sphTensorNames
-    (
-        objects.sortedNames<volSphericalTensorField>()
-    );
     PtrList<volSphericalTensorField> sphTensorFlds
     (
-        sphTensorNames.size()
-    );
-    subsetVolFields
+        subsetVolFields<sphericalTensor>
         (
             subsetter,
             objects,
             defaultPatchi,
-        sphericalTensor(Zero),
-        sphTensorFlds
+            sphericalTensor(Zero)
+        )
     );
 
-    wordList symmTensorNames(objects.sortedNames<volSymmTensorField>());
-    PtrList<volSymmTensorField> symmTensorFlds(symmTensorNames.size());
-    subsetVolFields
+    PtrList<volSymmTensorField> symmTensorFlds
+    (
+        subsetVolFields<symmTensor>
         (
             subsetter,
             objects,
             defaultPatchi,
-        symmTensor(Zero),
-        symmTensorFlds
+            symmTensor(Zero)
+        )
     );
 
-    wordList tensorNames(objects.sortedNames<volTensorField>());
-    PtrList<volTensorField> tensorFlds(tensorNames.size());
-    subsetVolFields
+    PtrList<volTensorField> tensorFlds
+    (
+        subsetVolFields<tensor>
         (
             subsetter,
             objects,
             defaultPatchi,
-        tensor(Zero),
-        tensorFlds
+            tensor(Zero)
+        )
     );
 
     // Read surface fields and subset.
-
-    wordList surfScalarNames(objects.sortedNames<surfaceScalarField>());
-    PtrList<surfaceScalarField> surfScalarFlds(surfScalarNames.size());
-    subsetSurfaceFields
+    PtrList<surfaceScalarField> surfScalarFlds
+    (
+        subsetSurfaceFields<scalar>
         (
             subsetter,
             objects,
             defaultPatchi,
-        scalar(Zero),
-        surfScalarFlds
+            scalar(Zero)
+        )
     );
 
-    wordList surfVectorNames(objects.sortedNames<surfaceVectorField>());
-    PtrList<surfaceVectorField> surfVectorFlds(surfVectorNames.size());
-    subsetSurfaceFields
+    PtrList<surfaceVectorField> surfVectorFlds
+    (
+        subsetSurfaceFields<vector>
         (
             subsetter,
             objects,
             defaultPatchi,
-        vector(Zero),
-        surfVectorFlds
+            vector(Zero)
+        )
     );
 
-    wordList surfSphTensorNames
-    (
-        objects.sortedNames<surfaceSphericalTensorField>()
-    );
     PtrList<surfaceSphericalTensorField> surfSphericalTensorFlds
     (
-        surfSphTensorNames.size()
-    );
-    subsetSurfaceFields
+        subsetSurfaceFields<sphericalTensor>
         (
             subsetter,
             objects,
             defaultPatchi,
-        sphericalTensor(Zero),
-        surfSphericalTensorFlds
-    );
-
-    wordList surfSymmTensorNames
-    (
-        objects.sortedNames<surfaceSymmTensorField>()
+            sphericalTensor(Zero)
+        )
     );
 
     PtrList<surfaceSymmTensorField> surfSymmTensorFlds
     (
-        surfSymmTensorNames.size()
-    );
-
-    subsetSurfaceFields
+        subsetSurfaceFields<symmTensor>
         (
             subsetter,
             objects,
             defaultPatchi,
-        symmTensor(Zero),
-        surfSymmTensorFlds
+            symmTensor(Zero)
+        )
     );
 
-    wordList surfTensorNames(objects.sortedNames<surfaceTensorField>());
-    PtrList<surfaceTensorField> surfTensorFlds(surfTensorNames.size());
-    subsetSurfaceFields
+    PtrList<surfaceTensorField> surfTensorFlds
+    (
+        subsetSurfaceFields<tensor>
         (
             subsetter,
             objects,
             defaultPatchi,
-        tensor(Zero),
-        surfTensorFlds
+            tensor(Zero)
+        )
     );
 
 
@@ -1017,62 +1024,8 @@ int main(int argc, char *argv[])
         ++runTime;
     }
 
-    Info<< "Writing mesh without blockedCells to time " << runTime.value()
-        << endl;
-
-    // Subsetting adds 'subset' prefix. Rename field to be like original.
-    forAll(scalarFlds, i)
-    {
-        scalarFlds[i].rename(scalarNames[i]);
-        scalarFlds[i].writeOpt(IOobject::AUTO_WRITE);
-    }
-    forAll(vectorFlds, i)
-    {
-        vectorFlds[i].rename(vectorNames[i]);
-        vectorFlds[i].writeOpt(IOobject::AUTO_WRITE);
-    }
-    forAll(sphTensorFlds, i)
-    {
-        sphTensorFlds[i].rename(sphTensorNames[i]);
-        sphTensorFlds[i].writeOpt(IOobject::AUTO_WRITE);
-    }
-    forAll(symmTensorFlds, i)
-    {
-        symmTensorFlds[i].rename(symmTensorNames[i]);
-        symmTensorFlds[i].writeOpt(IOobject::AUTO_WRITE);
-    }
-    forAll(tensorFlds, i)
-    {
-        tensorFlds[i].rename(tensorNames[i]);
-        tensorFlds[i].writeOpt(IOobject::AUTO_WRITE);
-    }
-
-    // Surface ones.
-    forAll(surfScalarFlds, i)
-    {
-        surfScalarFlds[i].rename(surfScalarNames[i]);
-        surfScalarFlds[i].writeOpt(IOobject::AUTO_WRITE);
-    }
-    forAll(surfVectorFlds, i)
-    {
-        surfVectorFlds[i].rename(surfVectorNames[i]);
-        surfVectorFlds[i].writeOpt(IOobject::AUTO_WRITE);
-    }
-    forAll(surfSphericalTensorFlds, i)
-    {
-        surfSphericalTensorFlds[i].rename(surfSphTensorNames[i]);
-        surfSphericalTensorFlds[i].writeOpt(IOobject::AUTO_WRITE);
-    }
-    forAll(surfSymmTensorFlds, i)
-    {
-        surfSymmTensorFlds[i].rename(surfSymmTensorNames[i]);
-        surfSymmTensorFlds[i].writeOpt(IOobject::AUTO_WRITE);
-    }
-    forAll(surfTensorNames, i)
-    {
-        surfTensorFlds[i].rename(surfTensorNames[i]);
-        surfTensorFlds[i].writeOpt(IOobject::AUTO_WRITE);
-    }
+    Info<< "Writing mesh without blockedCells to time "
+        << runTime.value() << endl;
 
     subsetter.subMesh().write();
 

applications/utilities/mesh/manipulation/rotateMesh/rotateMesh.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2022 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -55,12 +55,9 @@ void ReadAndRotateFields
     const dimensionedTensor& rotT
 )
 {
-    // Objects of field type
-    IOobjectList fields(objects.lookupClass<GeoField>());
-
-    forAllConstIters(fields, fieldIter)
+    for (const IOobject& io : objects.csorted<GeoField>())
     {
-        GeoField fld(*fieldIter(), mesh);
+        GeoField fld(io, mesh);
         Info<< "    Rotating " << fld.name() << endl;
         transform(fld, rotT, fld);
         fld.write();

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

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2018 OpenFOAM Foundation
-    Copyright (C) 2017-2022 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -158,7 +158,7 @@ void printSets(Ostream& os, const IOobjectList& objects)
 {
     label n = 0;
 
-    for (const IOobject& io : objects.sorted<SetType>())
+    for (const IOobject& io : objects.csorted<SetType>())
     {
         SetType set(io);
         if (!n++) os << SetType::typeName << "s:" << nl;

applications/utilities/mesh/manipulation/setsToZones/setsToZones.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2021-2022 OpenCFD Ltd.
+    Copyright (C) 2021-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -105,7 +105,7 @@ int main(int argc, char *argv[])
         << endl;
 
 
-    for (const IOobject& io : objects.sorted<pointSet>())
+    for (const IOobject& io : objects.csorted<pointSet>())
     {
         // Not in memory. Load it.
         pointSet set(io);
@@ -137,7 +137,7 @@ int main(int argc, char *argv[])
 
     wordHashSet slaveCellSets;
 
-    for (const IOobject& io : objects.sorted<faceSet>())
+    for (const IOobject& io : objects.csorted<faceSet>())
     {
         // Not in memory. Load it.
         faceSet set(io);
@@ -259,7 +259,7 @@ int main(int argc, char *argv[])
 
 
 
-    for (const IOobject& io : objects.sorted<cellSet>())
+    for (const IOobject& io : objects.csorted<cellSet>())
     {
         if (!slaveCellSets.found(io.name()))
         {

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

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2015-2022 OpenCFD Ltd.
+    Copyright (C) 2015-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -164,14 +164,8 @@ void subsetVolFields
 {
     const labelList patchMap(identity(mesh.boundaryMesh().size()));
 
-    HashTable<const GeoField*> fields
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-    forAllConstIters(fields, iter)
+    for (const GeoField& fld : mesh.objectRegistry::csorted<GeoField>())
     {
-        const GeoField& fld = *iter.val();
-
         Info<< "Mapping field " << fld.name() << endl;
 
         tmp<GeoField> tSubFld
@@ -192,8 +186,7 @@ void subsetVolFields
         {
             if (addedPatches.found(patchi))
             {
-                tSubFld.ref().boundaryFieldRef()[patchi] ==
-                    typename GeoField::value_type(Zero);
+                tSubFld.ref().boundaryFieldRef()[patchi] == Zero;
             }
         }
 
@@ -218,14 +211,8 @@ void subsetSurfaceFields
 {
     const labelList patchMap(identity(mesh.boundaryMesh().size()));
 
-    HashTable<const GeoField*> fields
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-    forAllConstIters(fields, iter)
+    for (const GeoField& fld : mesh.objectRegistry::csorted<GeoField>())
     {
-        const GeoField& fld = *iter.val();
-
         Info<< "Mapping field " << fld.name() << endl;
 
         tmp<GeoField> tSubFld
@@ -246,8 +233,7 @@ void subsetSurfaceFields
         {
             if (addedPatches.found(patchi))
             {
-                tSubFld.ref().boundaryFieldRef()[patchi] ==
-                    typename GeoField::value_type(Zero);
+                tSubFld.ref().boundaryFieldRef()[patchi] == Zero;
             }
         }
 

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

@@ -149,178 +149,127 @@ labelList nearestPatch(const polyMesh& mesh, const labelList& patchIDs)
 
 
 //
-// Subset field-type, availability information cached
-// in the availableFields hashtable.
+// Subset DimensionedField/GeometricField
 //
-template<class Type, template<class> class PatchField, class GeoMesh>
-void subsetFields
+template<class FieldType>
+PtrList<FieldType> subsetFields
 (
     const fvMeshSubset& subsetter,
-    HashTable<wordHashSet>& availableFields,
-    PtrList<GeometricField<Type, PatchField, GeoMesh>>& subFields
+    const IOobjectList& objects
 )
 {
-    typedef GeometricField<Type, PatchField, GeoMesh> FieldType;
-    const word fieldType = FieldType::typeName;
-
-    const wordList fieldNames = availableFields(fieldType).sortedToc();
-    subFields.setSize(fieldNames.size());
-
     const fvMesh& baseMesh = subsetter.baseMesh();
 
+    const UPtrList<const IOobject> fieldObjects
+    (
+        objects.csorted<FieldType>()
+    );
+
+    PtrList<FieldType> subFields(fieldObjects.size());
+
     label nFields = 0;
-    for (const word& fieldName : fieldNames)
+    for (const IOobject& io : fieldObjects)
     {
         if (!nFields)
         {
-            Info<< "Subsetting " << fieldType << " (";
+            Info<< "Subsetting " << FieldType::typeName << " (";
         }
         else
         {
             Info<< ' ';
         }
-        Info<< fieldName;
+        Info<< io.name();
 
         FieldType fld
         (
             IOobject
             (
-                fieldName,
+                io.name(),
                 baseMesh.time().timeName(),
                 baseMesh,
-                IOobject::MUST_READ,
-                IOobject::NO_WRITE
+                IOobjectOption::MUST_READ,
+                IOobjectOption::NO_WRITE,
+                IOobjectOption::NO_REGISTER
             ),
             baseMesh
         );
 
         subFields.set(nFields, subsetter.interpolate(fld));
+        auto& subField = subFields[nFields];
+        ++nFields;
 
         // Subsetting adds 'subset' prefix - rename to match original.
-        subFields[nFields].rename(fieldName);
-
-        ++nFields;
+        subField.rename(io.name());
     }
 
     if (nFields)
     {
         Info<< ')' << nl;
     }
+
+    return subFields;
 }
 
 
-template<class Type>
-void subsetPointFields
+// Subset point fields
+template<class FieldType>
+PtrList<FieldType> subsetFields
 (
     const fvMeshSubset& subsetter,
-    const pointMesh& pMesh,
-    HashTable<wordHashSet>& availableFields,
-    PtrList<GeometricField<Type, pointPatchField, pointMesh>>& subFields
+    const IOobjectList& objects,
+    const pointMesh& pMesh
 )
 {
-    typedef GeometricField<Type, pointPatchField, pointMesh> FieldType;
-    const word fieldType = FieldType::typeName;
-
-    const wordList fieldNames = availableFields(fieldType).sortedToc();
-    subFields.setSize(fieldNames.size());
-
     const fvMesh& baseMesh = subsetter.baseMesh();
 
+    const UPtrList<const IOobject> fieldObjects
+    (
+        objects.csorted<FieldType>()
+    );
+
+    PtrList<FieldType> subFields(fieldObjects.size());
+
     label nFields = 0;
-    for (const word& fieldName : fieldNames)
+    for (const IOobject& io : fieldObjects)
     {
         if (!nFields)
         {
-            Info<< "Subsetting " << fieldType << " (";
+            Info<< "Subsetting " << FieldType::typeName << " (";
         }
         else
         {
             Info<< ' ';
         }
-        Info<< fieldName;
+        Info<< io.name();
 
         FieldType fld
         (
             IOobject
             (
-                fieldName,
+                io.name(),
                 baseMesh.time().timeName(),
                 baseMesh,
-                IOobject::MUST_READ,
-                IOobject::NO_WRITE
+                IOobjectOption::MUST_READ,
+                IOobjectOption::NO_WRITE,
+                IOobjectOption::NO_REGISTER
             ),
             pMesh
         );
 
         subFields.set(nFields, subsetter.interpolate(fld));
+        auto& subField = subFields[nFields];
+        ++nFields;
 
         // Subsetting adds 'subset' prefix - rename to match original.
-        subFields[nFields].rename(fieldName);
-
-        ++nFields;
+        subField.rename(io.name());
     }
 
     if (nFields)
     {
         Info<< ')' << nl;
     }
-}
 
-
-template<class Type>
-void subsetDimensionedFields
-(
-    const fvMeshSubset& subsetter,
-    HashTable<wordHashSet>& availableFields,
-    PtrList<DimensionedField<Type, volMesh>>& subFields
-)
-{
-    typedef DimensionedField<Type, volMesh> FieldType;
-    const word fieldType = FieldType::typeName;
-
-    const wordList fieldNames = availableFields(fieldType).sortedToc();
-    subFields.setSize(fieldNames.size());
-
-    const fvMesh& baseMesh = subsetter.baseMesh();
-
-    label nFields = 0;
-    for (const word& fieldName : fieldNames)
-    {
-        if (!nFields)
-        {
-            Info<< "Subsetting " << fieldType << " (";
-        }
-        else
-        {
-            Info<< ' ';
-        }
-        Info<< fieldName;
-
-        FieldType fld
-        (
-            IOobject
-            (
-                fieldName,
-                baseMesh.time().timeName(),
-                baseMesh,
-                IOobject::MUST_READ,
-                IOobject::NO_WRITE
-            ),
-            baseMesh
-        );
-
-        subFields.set(nFields, subsetter.interpolate(fld));
-
-        // Subsetting adds 'subset' prefix - rename to match original.
-        subFields[nFields].rename(fieldName);
-
-        ++nFields;
-    }
-
-    if (nFields)
-    {
-        Info<< ')' << nl;
-    }
+    return subFields;
 }
 
 
@@ -338,7 +287,8 @@ void subsetTopoSets
     PtrList<TopoSet> sets;
     ReadFields<TopoSet>(objects, sets);
 
-    subSets.setSize(sets.size());
+    subSets.resize_null(sets.size());
+
     forAll(sets, seti)
     {
         const TopoSet& set = sets[seti];
@@ -347,6 +297,7 @@ void subsetTopoSets
 
         labelHashSet subset(2*min(set.size(), map.size()));
 
+        // Map the data
         forAll(map, i)
         {
             if (set.found(map[i]))
@@ -363,13 +314,14 @@ void subsetTopoSets
                 subMesh,
                 set.name(),
                 std::move(subset),
-                IOobject::AUTO_WRITE
+                IOobjectOption::AUTO_WRITE
             )
         );
     }
 }
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 int main(int argc, char *argv[])
 {
@@ -568,54 +520,51 @@ int main(int argc, char *argv[])
             );
         }
 
-        Info<< "Subset "
-            << returnReduce(subsetter.subMesh().nCells(), sumOp<label>())
-            << " of "
-            << returnReduce(mesh.nCells(), sumOp<label>())
+        FixedList<label, 2> cellCount;
+        cellCount[0] = subsetter.subMesh().nCells();
+        cellCount[1] = mesh.nCells();
+        reduce(cellCount, sumOp<label>());
+
+        Info<< "Subset " << cellCount[0] << " of " << cellCount[1]
             << " cells" << nl << nl;
     }
 
 
     IOobjectList objects(mesh, runTime.timeName());
-    HashTable<wordHashSet> availableFields = objects.classes();
+
+
+    // Read fields and subset
+    #undef  createSubsetFields
+    #define createSubsetFields(FieldType, Variable)             \
+    PtrList<FieldType> Variable                                 \
+    (                                                           \
+        subsetFields<FieldType>(subsetter, objects)             \
+    );
 
 
     // Read vol fields and subset
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    PtrList<volScalarField> vScalarFlds;
-    subsetFields(subsetter, availableFields, vScalarFlds);
-
-    PtrList<volVectorField> vVectorFlds;
-    subsetFields(subsetter, availableFields, vVectorFlds);
-
-    PtrList<volSphericalTensorField> vSphTensorFlds;
-    subsetFields(subsetter, availableFields, vSphTensorFlds);
-
-    PtrList<volSymmTensorField> vSymmTensorFlds;
-    subsetFields(subsetter, availableFields, vSymmTensorFlds);
-
-    PtrList<volTensorField> vTensorFlds;
-    subsetFields(subsetter, availableFields, vTensorFlds);
-
+    createSubsetFields(volScalarField, vScalarFlds);
+    createSubsetFields(volVectorField, vVectorFlds);
+    createSubsetFields(volSphericalTensorField, vSphTensorFlds);
+    createSubsetFields(volSymmTensorField, vSymmTensorFlds);
+    createSubsetFields(volTensorField, vTensorFlds);
 
     // Read surface fields and subset
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    createSubsetFields(surfaceScalarField, sScalarFlds);
+    createSubsetFields(surfaceVectorField, sVectorFlds);
+    createSubsetFields(surfaceSphericalTensorField, sSphTensorFlds);
+    createSubsetFields(surfaceSymmTensorField, sSymmTensorFlds);
+    createSubsetFields(surfaceTensorField, sTensorFlds);
 
-    PtrList<surfaceScalarField> sScalarFlds;
-    subsetFields(subsetter, availableFields, sScalarFlds);
-
-    PtrList<surfaceVectorField> sVectorFlds;
-    subsetFields(subsetter, availableFields, sVectorFlds);
-
-    PtrList<surfaceSphericalTensorField> sSphTensorFlds;
-    subsetFields(subsetter, availableFields, sSphTensorFlds);
-
-    PtrList<surfaceSymmTensorField> sSymmTensorFlds;
-    subsetFields(subsetter, availableFields, sSymmTensorFlds);
-
-    PtrList<surfaceTensorField> sTensorFlds;
-    subsetFields(subsetter, availableFields, sTensorFlds);
+    // Read dimensioned fields and subset
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    createSubsetFields(volScalarField::Internal, dScalarFlds);
+    createSubsetFields(volVectorField::Internal, dVectorFlds);
+    createSubsetFields(volSphericalTensorField::Internal, dSphTensorFlds);
+    createSubsetFields(volSymmTensorField::Internal, dSymmTensorFlds);
+    createSubsetFields(volTensorField::Internal, dTensorFlds);
 
 
     // Read point fields and subset
@@ -623,39 +572,20 @@ int main(int argc, char *argv[])
 
     const pointMesh& pMesh = pointMesh::New(mesh);
 
-    PtrList<pointScalarField> pScalarFlds;
-    subsetPointFields(subsetter, pMesh, availableFields, pScalarFlds);
+    #undef  createSubsetFields
+    #define createSubsetFields(FieldType, Variable)             \
+    PtrList<FieldType> Variable                                 \
+    (                                                           \
+        subsetFields<FieldType>(subsetter, objects, pMesh)      \
+    );
 
-    PtrList<pointVectorField> pVectorFlds;
-    subsetPointFields(subsetter, pMesh, availableFields, pVectorFlds);
+    createSubsetFields(pointScalarField, pScalarFlds);
+    createSubsetFields(pointVectorField, pVectorFlds);
+    createSubsetFields(pointSphericalTensorField, pSphTensorFlds);
+    createSubsetFields(pointSymmTensorField, pSymmTensorFlds);
+    createSubsetFields(pointTensorField, pTensorFlds);
 
-    PtrList<pointSphericalTensorField> pSphTensorFlds;
-    subsetPointFields(subsetter, pMesh, availableFields, pSphTensorFlds);
-
-    PtrList<pointSymmTensorField> pSymmTensorFlds;
-    subsetPointFields(subsetter, pMesh, availableFields, pSymmTensorFlds);
-
-    PtrList<pointTensorField> pTensorFlds;
-    subsetPointFields(subsetter, pMesh, availableFields, pTensorFlds);
-
-
-    // Read dimensioned fields and subset
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    PtrList<volScalarField::Internal> dScalarFlds;
-    subsetDimensionedFields(subsetter, availableFields, dScalarFlds);
-
-    PtrList<volVectorField::Internal> dVectorFlds;
-    subsetDimensionedFields(subsetter, availableFields, dVectorFlds);
-
-    PtrList<volSphericalTensorField::Internal> dSphTensorFlds;
-    subsetDimensionedFields(subsetter, availableFields, dSphTensorFlds);
-
-    PtrList<volSymmTensorField::Internal> dSymmTensorFlds;
-    subsetDimensionedFields(subsetter, availableFields, dSymmTensorFlds);
-
-    PtrList<volTensorField::Internal> dTensorFlds;
-    subsetDimensionedFields(subsetter, availableFields, dTensorFlds);
+    #undef createSubsetFields
 
 
     // Read topoSets and subset
@@ -735,13 +665,6 @@ int main(int argc, char *argv[])
     for (const auto& fld : sSymmTensorFlds) { fld.write(); }
     for (const auto& fld : sTensorFlds)     { fld.write(); }
 
-    // Point fields
-    for (const auto& fld : pScalarFlds)     { fld.write(); }
-    for (const auto& fld : pVectorFlds)     { fld.write(); }
-    for (const auto& fld : pSphTensorFlds)  { fld.write(); }
-    for (const auto& fld : pSymmTensorFlds) { fld.write(); }
-    for (const auto& fld : pTensorFlds)     { fld.write(); }
-
     // Dimensioned fields
     for (const auto& fld : dScalarFlds)     { fld.write(); }
     for (const auto& fld : dVectorFlds)     { fld.write(); }
@@ -749,6 +672,13 @@ int main(int argc, char *argv[])
     for (const auto& fld : dSymmTensorFlds) { fld.write(); }
     for (const auto& fld : dTensorFlds)     { fld.write(); }
 
+    // Point fields
+    for (const auto& fld : pScalarFlds)     { fld.write(); }
+    for (const auto& fld : pVectorFlds)     { fld.write(); }
+    for (const auto& fld : pSphTensorFlds)  { fld.write(); }
+    for (const auto& fld : pSymmTensorFlds) { fld.write(); }
+    for (const auto& fld : pTensorFlds)     { fld.write(); }
+
     Info<< "\nEnd\n" << endl;
 
     return 0;

applications/utilities/miscellaneous/patchSummary/patchSummary.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -89,50 +90,41 @@ int main(int argc, char *argv[])
                 << endl;
         }
 
-        const wordList objNames
-        (
-            IOobjectList(mesh, runTime.timeName()).sortedNames()
+        const IOobjectList objects(mesh, runTime.timeName());
+
+        Info<< "Reading fields:" << endl;
+
+        // Read fields
+        #undef  createFields
+        #define createFields(FieldType, Variable)                   \
+        PtrList<FieldType> Variable                                 \
+        (                                                           \
+            readFields<FieldType>(objects, mesh)                    \
         );
 
-        PtrList<volScalarField> vsf(objNames.size());
-        PtrList<volVectorField> vvf(objNames.size());
-        PtrList<volSphericalTensorField> vsptf(objNames.size());
-        PtrList<volSymmTensorField> vsytf(objNames.size());
-        PtrList<volTensorField> vtf(objNames.size());
+        createFields(volScalarField, vsf);
+        createFields(volVectorField, vvf);
+        createFields(volSphericalTensorField, vsptf);
+        createFields(volSymmTensorField, vsytf);
+        createFields(volTensorField, vtf);
 
-        PtrList<pointScalarField> psf(objNames.size());
-        PtrList<pointVectorField> pvf(objNames.size());
-        PtrList<pointSphericalTensorField> psptf(objNames.size());
-        PtrList<pointSymmTensorField> psytf(objNames.size());
-        PtrList<pointTensorField> ptf(objNames.size());
+        // Point fields
+        const pointMesh& pMesh = pointMesh::New(mesh);
 
-        Info<< "Valid fields:" << endl;
-
-        forAll(objNames, objI)
-        {
-            IOobject obj
-            (
-                objNames[objI],
-                runTime.timeName(),
-                mesh,
-                IOobject::MUST_READ
+        #undef  createFields
+        #define createFields(FieldType, Variable)                   \
+        PtrList<FieldType> Variable                                 \
+        (                                                           \
+            readFields<FieldType>(objects, pMesh)                   \
         );
 
-            if (obj.typeHeaderOk<volScalarField>(false))
-            {
-                addToFieldList(vsf, obj, objI, mesh);
-                addToFieldList(vvf, obj, objI, mesh);
-                addToFieldList(vsptf, obj, objI, mesh);
-                addToFieldList(vsytf, obj, objI, mesh);
-                addToFieldList(vtf, obj, objI, mesh);
+        createFields(pointScalarField, psf);
+        createFields(pointVectorField, pvf);
+        createFields(pointSphericalTensorField, psptf);
+        createFields(pointSymmTensorField, psytf);
+        createFields(pointTensorField, ptf);
 
-                addToFieldList(psf, obj, objI, pointMesh::New(mesh));
-                addToFieldList(pvf, obj, objI, pointMesh::New(mesh));
-                addToFieldList(psptf, obj, objI, pointMesh::New(mesh));
-                addToFieldList(psytf, obj, objI, pointMesh::New(mesh));
-                addToFieldList(ptf, obj, objI, pointMesh::New(mesh));
-            }
-        }
+        #undef createFields
 
         Info<< endl;
 
@@ -144,6 +136,7 @@ int main(int argc, char *argv[])
             forAll(bm, patchi)
             {
                 Info<< bm[patchi].type() << "\t: " << bm[patchi].name() << nl;
+
                 outputFieldList(vsf, patchi);
                 outputFieldList(vvf, patchi);
                 outputFieldList(vsptf, patchi);
@@ -167,6 +160,7 @@ int main(int argc, char *argv[])
             DynamicList<HashTable<word>> fieldToTypes(bm.size());
             // Per 'group' the patches
             DynamicList<DynamicList<label>> groupToPatches(bm.size());
+
             forAll(bm, patchi)
             {
                 HashTable<word> fieldToType;
@@ -208,40 +202,39 @@ int main(int argc, char *argv[])
                     labelHashSet nonGroupPatches;
                     bm.matchGroups(patchIDs, groups, nonGroupPatches);
 
-                    const labelList sortedPatches(nonGroupPatches.sortedToc());
-                    forAll(sortedPatches, i)
+                    for (const label patchi : nonGroupPatches.sortedToc())
                     {
-                        Info<< bm[sortedPatches[i]].type()
-                            << "\t: " << bm[sortedPatches[i]].name() << nl;
+                        Info<< bm[patchi].type()
+                            << "\t: " << bm[patchi].name() << nl;
                     }
-                    if (groups.size())
+                    for (const word& groupName : groups)
                     {
-                        forAll(groups, i)
-                        {
-                            Info<< "group\t: " << groups[i] << nl;
+                        Info<< "group\t: " << groupName << nl;
                     }
-                    }
-                    outputFieldList(vsf, patchIDs[0]);
-                    outputFieldList(vvf, patchIDs[0]);
-                    outputFieldList(vsptf, patchIDs[0]);
-                    outputFieldList(vsytf, patchIDs[0]);
-                    outputFieldList(vtf, patchIDs[0]);
 
-                    outputFieldList(psf, patchIDs[0]);
-                    outputFieldList(pvf, patchIDs[0]);
-                    outputFieldList(psptf, patchIDs[0]);
-                    outputFieldList(psytf, patchIDs[0]);
-                    outputFieldList(ptf, patchIDs[0]);
+                    const label patchi = patchIDs[0];
+
+                    outputFieldList(vsf, patchi);
+                    outputFieldList(vvf, patchi);
+                    outputFieldList(vsptf, patchi);
+                    outputFieldList(vsytf, patchi);
+                    outputFieldList(vtf, patchi);
+
+                    outputFieldList(psf, patchi);
+                    outputFieldList(pvf, patchi);
+                    outputFieldList(psptf, patchi);
+                    outputFieldList(psytf, patchi);
+                    outputFieldList(ptf, patchi);
                     Info<< endl;
                 }
                 else
                 {
                     // No group.
-                    forAll(patchIDs, i)
+                    for (const label patchi : patchIDs)
                     {
-                        label patchi = patchIDs[i];
                         Info<< bm[patchi].type()
                             << "\t: " << bm[patchi].name() << nl;
+
                         outputFieldList(vsf, patchi);
                         outputFieldList(vvf, patchi);
                         outputFieldList(vsptf, patchi);

applications/utilities/miscellaneous/patchSummary/patchSummaryTemplates.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -31,30 +32,49 @@ License
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 template<class GeoField>
-void Foam::addToFieldList
+Foam::PtrList<GeoField> Foam::readFields
 (
-    PtrList<GeoField>& fieldList,
-    const IOobject& obj,
-    const label fieldi,
+    const IOobjectList& objects,
     const typename GeoField::Mesh& mesh
 )
 {
-    if (obj.isHeaderClass<GeoField>())
-    {
-        fieldList.set
+    const UPtrList<const IOobject> fieldObjects
     (
-            fieldi,
-            new GeoField(obj, mesh)
+        objects.csorted<GeoField>()
     );
-        Info<< "    " << GeoField::typeName << tab << obj.name() << endl;
+
+    PtrList<GeoField> fields(fieldObjects.size());
+
+    label nFields = 0;
+    for (const IOobject& io : fieldObjects)
+    {
+        if (!nFields)
+        {
+            Info<< "    " << GeoField::typeName << " (";
         }
+        else
+        {
+            Info<< ' ';
+        }
+        Info<< io.name();
+
+        fields.emplace_set(nFields, io, mesh);
+        ++nFields;
+    }
+
+    if (nFields)
+    {
+        Info<< ')' << nl;
+    }
+
+    return fields;
 }
 
 
 template<class GeoField>
 void Foam::outputFieldList
 (
-    const PtrList<GeoField>& fieldList,
+    const UPtrList<GeoField>& fieldList,
     const label patchi
 )
 {
@@ -74,7 +94,7 @@ void Foam::outputFieldList
 template<class GeoField>
 void Foam::collectFieldList
 (
-    const PtrList<GeoField>& fieldList,
+    const UPtrList<GeoField>& fieldList,
     const label patchi,
     HashTable<word>& fieldToType
 )

applications/utilities/miscellaneous/patchSummary/patchSummaryTemplates.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,39 +26,39 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef patchSummaryTemplates_H
-#define patchSummaryTemplates_H
+#ifndef Foam_patchSummaryTemplates_H
+#define Foam_patchSummaryTemplates_H
 
-#include "fvCFD.H"
 #include "volFields.H"
+#include "IOobjectList.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
-    template<class GeoField>
-    void addToFieldList
-    (
-        PtrList<GeoField>& fieldList,
-        const IOobject& obj,
-        const label fieldi,
+
+template<class GeoField>
+PtrList<GeoField> readFields
+(
+    const IOobjectList& objects,
     const typename GeoField::Mesh& mesh
-    );
+);
 
-    template<class GeoField>
-    void outputFieldList
-    (
-        const PtrList<GeoField>& fieldList,
+template<class GeoField>
+void outputFieldList
+(
+    const UPtrList<GeoField>& fieldList,
     const label patchi
-    );
+);
 
-    template<class GeoField>
-    void collectFieldList
-    (
-        const PtrList<GeoField>& fieldList,
+template<class GeoField>
+void collectFieldList
+(
+    const UPtrList<GeoField>& fieldList,
     const label patchi,
     HashTable<word>& fieldToType
-    );
+);
+
 } // End namespace Foam
 
 

applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2022 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -186,26 +186,17 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
     {
         // Read sets
         IOobjectList objects(*this, facesInstance(), "polyMesh/sets");
+        for (const IOobject& io : objects.csorted<cellSet>())
         {
-            IOobjectList sets(objects.lookupClass<cellSet>());
-            forAllConstIters(sets, iter)
-            {
-                cellSets.append(new cellSet(*(iter.val())));
-            }
+            cellSets.emplace_back(io);
         }
+        for (const IOobject& io : objects.csorted<faceSet>())
         {
-            IOobjectList sets(objects.lookupClass<faceSet>());
-            forAllConstIters(sets, iter)
-            {
-                faceSets.append(new faceSet(*(iter.val())));
-            }
+            faceSets.emplace_back(io);
         }
+        for (const IOobject& io : objects.csorted<pointSet>())
         {
-            IOobjectList sets(objects.lookupClass<pointSet>());
-            forAllConstIters(sets, iter)
-            {
-                pointSets.append(new pointSet(*(iter.val())));
-            }
+            pointSets.emplace_back(io);
         }
     }
 
@@ -219,9 +210,9 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
             facesInstance(),
             polyMesh::meshSubDir,
             *this,
-            IOobject::READ_IF_PRESENT,
-            IOobject::NO_WRITE,
-            IOobject::NO_REGISTER
+            IOobjectOption::READ_IF_PRESENT,
+            IOobjectOption::NO_WRITE,
+            IOobjectOption::NO_REGISTER
         )
     );
 

applications/utilities/parallelProcessing/reconstructPar/reconstructPar.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2015-2022 OpenCFD Ltd.
+    Copyright (C) 2015-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -597,19 +597,19 @@ int main(int argc, char *argv[])
                         polyMesh::meshSubDir/"sets"
                     );
 
-                    for (const word& setName : objects.sortedNames<cellSet>())
+                    for (const IOobject& io : objects.csorted<cellSet>())
                     {
-                        cSetNames.insert(setName, cSetNames.size());
+                        cSetNames.insert(io.name(), cSetNames.size());
                     }
 
-                    for (const word& setName : objects.sortedNames<faceSet>())
+                    for (const IOobject& io : objects.csorted<faceSet>())
                     {
-                        fSetNames.insert(setName, fSetNames.size());
+                        fSetNames.insert(io.name(), fSetNames.size());
                     }
 
-                    for (const word& setName : objects.sortedNames<pointSet>())
+                    for (const IOobject& io : objects.csorted<pointSet>())
                     {
-                        pSetNames.insert(setName, pSetNames.size());
+                        pSetNames.insert(io.name(), pSetNames.size());
                     }
                 }
 
@@ -653,7 +653,7 @@ int main(int argc, char *argv[])
                         const labelList& cellMap =
                             procMeshes.cellProcAddressing()[proci];
 
-                        for (const IOobject& io : objects.sorted<cellSet>())
+                        for (const IOobject& io : objects.csorted<cellSet>())
                         {
                             // Load cellSet
                             const cellSet procSet(io);
@@ -684,7 +684,7 @@ int main(int argc, char *argv[])
                         const labelList& faceMap =
                             procMeshes.faceProcAddressing()[proci];
 
-                        for (const IOobject& io : objects.sorted<faceSet>())
+                        for (const IOobject& io : objects.csorted<faceSet>())
                         {
                             // Load faceSet
                             const faceSet procSet(io);
@@ -714,7 +714,7 @@ int main(int argc, char *argv[])
                         const labelList& pointMap =
                             procMeshes.pointProcAddressing()[proci];
 
-                        for (const IOobject& io : objects.sorted<pointSet>())
+                        for (const IOobject& io : objects.csorted<pointSet>())
                         {
                             // Load pointSet
                             const pointSet procSet(io);

applications/utilities/parallelProcessing/redistributePar/parFvFieldDistributorTemplates.C

@@ -405,20 +405,20 @@ Foam::label Foam::parFvFieldDistributor::distributeInternalFields
 {
     typedef DimensionedField<Type, volMesh> fieldType;
 
-    // Available fields, sorted order
-    const wordList fieldNames =
+    label nFields = 0;
+    for
+    (
+        const IOobject& io :
         (
             selectedFields.empty()
-      ? objects.sortedNames<fieldType>()
-      : objects.sortedNames<fieldType>(selectedFields)
-    );
-
-    label nFields = 0;
-    for (const word& fieldName : fieldNames)
+          ? objects.csorted<fieldType>()
+          : objects.csorted<fieldType>(selectedFields)
+        )
+    )
     {
-        if ("cellDist" == fieldName)
+        if ("cellDist" == io.name())
         {
-            // There is an odd chance this is an internal field
+            // Ignore cellDist (internal or volume) field
             continue;
         }
         if (verbose_)
@@ -428,13 +428,13 @@ Foam::label Foam::parFvFieldDistributor::distributeInternalFields
                 Info<< "    Reconstructing "
                     << fieldType::typeName << "s\n" << nl;
             }
-            Info<< "        " << fieldName << nl;
+            Info<< "        " << io.name() << nl;
         }
         ++nFields;
 
         tmp<fieldType> tfld
         (
-            distributeInternalField<Type>(*(objects[fieldName]))
+            distributeInternalField<Type>(io)
         );
 
         if (isWriteProc_.good())
@@ -470,19 +470,20 @@ Foam::label Foam::parFvFieldDistributor::distributeVolumeFields
 {
     typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
 
-    // Available fields, sorted order
-    const wordList fieldNames =
+    label nFields = 0;
+    for
+    (
+        const IOobject& io :
         (
             selectedFields.empty()
-      ? objects.sortedNames<fieldType>()
-      : objects.sortedNames<fieldType>(selectedFields)
-    );
-
-    label nFields = 0;
-    for (const word& fieldName : fieldNames)
+          ? objects.csorted<fieldType>()
+          : objects.csorted<fieldType>(selectedFields)
+        )
+    )
     {
-        if ("cellDist" == fieldName)
+        if ("cellDist" == io.name())
         {
+            // Ignore cellDist (internal or volume) field
             continue;
         }
         if (verbose_)
@@ -492,13 +493,13 @@ Foam::label Foam::parFvFieldDistributor::distributeVolumeFields
                 Info<< "    Reconstructing "
                     << fieldType::typeName << "s\n" << nl;
             }
-            Info<< "        " << fieldName << nl;
+            Info<< "        " << io.name() << nl;
         }
         ++nFields;
 
         tmp<fieldType> tfld
         (
-            distributeVolumeField<Type>(*(objects[fieldName]))
+            distributeVolumeField<Type>(io)
         );
 
         if (isWriteProc_.good())
@@ -534,16 +535,16 @@ Foam::label Foam::parFvFieldDistributor::distributeSurfaceFields
 {
     typedef GeometricField<Type, fvsPatchField, surfaceMesh> fieldType;
 
-    // Available fields, sorted order
-    const wordList fieldNames =
+    label nFields = 0;
+    for
+    (
+        const IOobject& io :
         (
             selectedFields.empty()
-      ? objects.sortedNames<fieldType>()
-      : objects.sortedNames<fieldType>(selectedFields)
-    );
-
-    label nFields = 0;
-    for (const word& fieldName : fieldNames)
+          ? objects.csorted<fieldType>()
+          : objects.csorted<fieldType>(selectedFields)
+        )
+    )
     {
         if (verbose_)
         {
@@ -552,13 +553,13 @@ Foam::label Foam::parFvFieldDistributor::distributeSurfaceFields
                 Info<< "    Reconstructing "
                     << fieldType::typeName << "s\n" << nl;
             }
-            Info<< "        " << fieldName << nl;
+            Info<< "        " << io.name() << nl;
         }
         ++nFields;
 
         tmp<fieldType> tfld
         (
-            distributeSurfaceField<Type>(*(objects[fieldName]))
+            distributeSurfaceField<Type>(io)
         );
 
         if (isWriteProc_.good())

applications/utilities/parallelProcessing/redistributePar/parLagrangianDistributor.C

@@ -82,7 +82,7 @@ void Foam::parLagrangianDistributor::findClouds
         )
     );
 
-    cloudNames.setSize(localCloudDirs.size());
+    cloudNames.resize_nocopy(localCloudDirs.size());
     forAll(localCloudDirs, i)
     {
         cloudNames[i] = localCloudDirs[i];

applications/utilities/parallelProcessing/redistributePar/parLagrangianDistributorTemplates.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2015 OpenFOAM Foundation
-    Copyright (C) 2018-2022 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -324,18 +324,11 @@ Foam::label Foam::parLagrangianDistributor::distributeStoredFields
     passivePositionParticleCloud& cloud
 ) const
 {
-    HashTable<Container*> fields
-    (
-        cloud.lookupClass<Container>()
-    );
-
     bool reconstruct = false;
-
     label nFields = 0;
-    forAllIters(fields, iter)
-    {
-        Container& field = *(iter.val());
 
+    for (Container& field : cloud.sorted<Container>())
+    {
         if (!nFields)
         {
             // Performing an all-to-one (reconstruct)?

applications/utilities/parallelProcessing/redistributePar/parPointFieldDistributorTemplates.C

@@ -185,11 +185,11 @@ Foam::label Foam::parPointFieldDistributor::distributePointFields
 {
     typedef GeometricField<Type, pointPatchField, pointMesh> fieldType;
 
-    UPtrList<const IOobject> fieldObjects
+    const UPtrList<const IOobject> fieldObjects
     (
         selectedFields.empty()
-      ? objects.sorted<fieldType>()
-      : objects.sorted<fieldType>(selectedFields)
+      ? objects.csorted<fieldType>()
+      : objects.csorted<fieldType>(selectedFields)
     );
 
     label nFields = 0;

applications/utilities/postProcessing/dataConversion/foamDataToFluent/foamDataToFluent.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -105,8 +106,9 @@ int main(int argc, char *argv[])
                 "foamDataToFluentDict",
                 runTime.system(),
                 mesh,
-                IOobject::MUST_READ_IF_MODIFIED,
-                IOobject::NO_WRITE
+                IOobjectOption::MUST_READ,
+                IOobjectOption::NO_WRITE,
+                IOobjectOption::NO_REGISTER
             )
         );
 
@@ -115,44 +117,21 @@ int main(int argc, char *argv[])
         IOobjectList objects(mesh, runTime.timeName());
 
 
-        // volScalarField
-        for (const word& fieldName : objects.sortedNames<volScalarField>())
-        {
-            // Lookup field from dictionary and convert field
-            label unitNumber;
-            if
+        readFieldsAndWriteFluent<volScalarField>
         (
-                foamDataToFluentDict.readIfPresent(fieldName, unitNumber)
-             && unitNumber > 0
-            )
-            {
-                // Read field
-                volScalarField field(*(objects[fieldName]), mesh);
+            foamDataToFluentDict,
+            objects,
+            mesh,
+            fluentDataFile
+        );
 
-                Info<< "    Converting field " << fieldName << nl;
-                writeFluentField(field, unitNumber, fluentDataFile);
-            }
-        }
-
-
-        // volVectorField
-        for (const word& fieldName : objects.sortedNames<volVectorField>())
-        {
-            // Lookup field from dictionary and convert field
-            label unitNumber;
-            if
+        readFieldsAndWriteFluent<volVectorField>
         (
-                foamDataToFluentDict.readIfPresent(fieldName, unitNumber)
-             && unitNumber > 0
-            )
-            {
-                // Read field
-                volVectorField field(*(objects[fieldName]), mesh);
-
-                Info<< "    Converting field " << fieldName << nl;
-                writeFluentField(field, unitNumber, fluentDataFile);
-            }
-        }
+            foamDataToFluentDict,
+            objects,
+            mesh,
+            fluentDataFile
+        );
 
         Info<< endl;
     }

applications/utilities/postProcessing/dataConversion/foamDataToFluent/writeFluentFields.H

@@ -28,10 +28,12 @@ InClass
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef writeFluentFields_H
-#define writeFluentFields_H
+#ifndef Foam_writeFluentFields_H
+#define Foam_writeFluentFields_H
 
 #include "volFields.H"
+#include "dictionary.H"
+#include "IOobjectList.H"
 #include "Ostream.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -43,16 +45,48 @@ void writeFluentField
 (
     const volScalarField& phi,
     const label fluentFieldIdentifier,
-    Ostream& stream
+    Ostream& os
 );
 
 void writeFluentField
 (
     const volVectorField& phi,
     const label fluentFieldIdentifier,
-    Ostream& stream
+    Ostream& os
 );
 
+
+template<class GeoField>
+void readFieldsAndWriteFluent
+(
+    const dictionary& dict,
+    const IOobjectList& objects,
+    const fvMesh& mesh,
+    Ostream& os
+)
+{
+    for (const IOobject& io : objects.csorted<GeoField>())
+    {
+        // Lookup field from dictionary and convert field
+        const word& fieldName = io.name();
+        label unitNumber;
+        if
+        (
+            dict.readIfPresent(fieldName, unitNumber)
+         && unitNumber > 0
+        )
+        {
+            // Read field
+            GeoField field(io, mesh);
+
+            Info<< "    Converting field " << fieldName << nl;
+            writeFluentField(field, unitNumber, os);
+        }
+    }
+}
+
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

applications/utilities/postProcessing/dataConversion/foamDataToFluent/writeFluentScalarField.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -35,12 +36,7 @@ Description
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-namespace Foam
-{
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void writeFluentField
+void Foam::writeFluentField
 (
     const volScalarField& phi,
     const label fluentFieldIdentifier,
@@ -58,15 +54,15 @@ void writeFluentField
         << "1 "                  // Number of components (scalar=1, vector=3)
         << "0 0 "                // Unused
         << "1 " << phiInternal.size() // Start and end of list
-        << ")(" << endl;
+        << ")(" << nl;
 
-    forAll(phiInternal, celli)
+    for (const scalar val : phiInternal)
     {
-        stream << phiInternal[celli] << endl;
+        stream << val << nl;
     }
 
     stream
-        << "))" << endl;
+        << "))" << nl;
 
     label nWrittenFaces = phiInternal.size();
 
@@ -92,13 +88,13 @@ void writeFluentField
                 << "0 0 "                // Unused
                 << nWrittenFaces + 1 << " "
                 << nWrittenFaces + emptyFaceCells.size()// Start and end of list
-                << ")(" << endl;
+                << ")(" << nl;
 
             nWrittenFaces += emptyFaceCells.size();
 
             forAll(emptyFaceCells, facei)
             {
-                stream << phiInternal[emptyFaceCells[facei]] << endl;
+                stream << phiInternal[emptyFaceCells[facei]] << nl;
             }
 
             stream
@@ -120,13 +116,13 @@ void writeFluentField
                 << "0 0 "            // Unused
                 << nWrittenFaces + 1 << " " << nWrittenFaces + patchPhi.size()
                                  // Start and end of list
-                << ")(" << endl;
+                << ")(" << nl;
 
             nWrittenFaces += patchPhi.size();
 
-            forAll(patchPhi, facei)
+            for (const scalar val : patchPhi)
             {
-                stream << patchPhi[facei] << endl;
+                stream << val << nl;
             }
 
             stream
@@ -136,8 +132,4 @@ void writeFluentField
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

applications/utilities/postProcessing/dataConversion/foamDataToFluent/writeFluentVectorField.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -34,12 +35,7 @@ Description
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-namespace Foam
-{
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void writeFluentField
+void Foam::writeFluentField
 (
     const volVectorField& phi,
     const label fluentFieldIdentifier,
@@ -57,19 +53,16 @@ void writeFluentField
         << "3 "                  // Number of components (scalar=1, vector=3)
         << "0 0 "                // Unused
         << "1 " << phiInternal.size() // Start and end of list
-        << ")(" << endl;
+        << ")(" << nl;
 
-    forAll(phiInternal, celli)
+    for (const vector& val : phiInternal)
     {
         stream
-            << phiInternal[celli].x() << " "
-            << phiInternal[celli].y() << " "
-            << phiInternal[celli].z() << " "
-            << endl;
+            << val.x() << ' ' << val.y() << ' ' << val.z() << nl;
     }
 
     stream
-        << "))" << endl;
+        << "))" << nl;
 
     label nWrittenFaces = phiInternal.size();
 
@@ -87,17 +80,14 @@ void writeFluentField
             << "0 0 "            // Unused
             << nWrittenFaces + 1 << " " << nWrittenFaces + patchPhi.size()
                                  // Start and end of list
-            << ")(" << endl;
+            << ")(" << nl;
 
         nWrittenFaces += patchPhi.size();
 
-        forAll(patchPhi, facei)
+        for (const vector& val : patchPhi)
         {
             stream
-                << patchPhi[facei].x() << " "
-                << patchPhi[facei].y() << " "
-                << patchPhi[facei].z() << " "
-                << endl;
+                << val.x() << ' ' << val.y() << ' ' << val.z() << nl;
         }
 
         stream
@@ -106,6 +96,4 @@ void writeFluentField
 }
 
 
-} // End namespace Foam
-
 // ************************************************************************* //

applications/utilities/postProcessing/dataConversion/foamToEnsight/checkFieldAvailability.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021-2022 OpenCFD Ltd.
+    Copyright (C) 2021-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
@@ -28,9 +28,9 @@ forAll(meshes, regioni)
 
     IOobjectList objects(0);
 
-    if (doConvertFields)
+    if (doConvertFields && !timeDirs.empty())
     {
-        objects = IOobjectList(mesh, timeDirs.last().name());
+        objects = IOobjectList(mesh, timeDirs.back().name());
 
         if (fieldSelector && !fieldSelector().empty())
         {

applications/utilities/postProcessing/dataConversion/foamToEnsight/readFields.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2022 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -35,18 +35,30 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef readFields_H
-#define readFields_H
+#ifndef ensight_readFields_H
+#define ensight_readFields_H
 
 #include "instantList.H"
 #include "IOobjectList.H"
-#include "zeroGradientFvPatchFields.H"
+#include "fvPatchField.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 
+//- Get the field or FatalError
+template<class GeoField>
+tmp<GeoField> getField
+(
+    const IOobject& io,
+    const typename GeoField::Mesh& mesh
+)
+{
+    return tmp<GeoField>::New(io, mesh);
+}
+
+
 //- Get the field or return nullptr
 template<class GeoField>
 tmp<GeoField> getField

applications/utilities/postProcessing/dataConversion/foamToEnsight/writeAreaFields.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021-2022 OpenCFD Ltd.
+    Copyright (C) 2021-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
@@ -72,7 +72,7 @@ label writeAreaFields
 
     label count = 0;
 
-    for (const word& fieldName : objects.sortedNames<FieldType>())
+    for (const IOobject& io : objects.csorted<FieldType>())
     {
         if
         (
@@ -80,11 +80,11 @@ label writeAreaFields
             (
                 ensCase,
                 ensMesh,
-                getField<FieldType>(objects.findObject(fieldName), mesh)
+                getField<FieldType>(io, mesh)
             )
         )
         {
-            Info<< ' ' << fieldName;
+            Info<< ' ' << io.name();
             ++count;
         }
     }

applications/utilities/postProcessing/dataConversion/foamToEnsight/writeDimFields.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2022 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
@@ -69,7 +69,7 @@ label writeDimFields
 
     label count = 0;
 
-    for (const word& fieldName : objects.sortedNames<FieldType>())
+    for (const IOobject& io : objects.csorted<FieldType>())
     {
         if
         (
@@ -77,11 +77,11 @@ label writeDimFields
             (
                 ensCase,
                 ensMesh,
-                getField<FieldType>(objects.findObject(fieldName), mesh)
+                getField<FieldType>(io, mesh)
             )
         )
         {
-            Info<< ' ' << fieldName;
+            Info<< ' ' << io.name();
             ++count;
         }
     }

applications/utilities/postProcessing/dataConversion/foamToEnsight/writePointFields.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2020-2022 OpenCFD Ltd.
+    Copyright (C) 2020-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
@@ -70,11 +70,11 @@ label writePointFields
 {
     typedef PointField<Type> FieldType;
 
-    const pointMesh& ptMesh = pointMesh::New(ensMesh.mesh());
+    const pointMesh& pMesh = pointMesh::New(ensMesh.mesh());
 
     label count = 0;
 
-    for (const word& fieldName : objects.sortedNames<FieldType>())
+    for (const IOobject& io : objects.csorted<FieldType>())
     {
         if
         (
@@ -82,11 +82,11 @@ label writePointFields
             (
                 ensCase,
                 ensMesh,
-                getField<FieldType>(ptMesh, objects, fieldName)
+                getField<FieldType>(io, pMesh)
             )
         )
         {
-            Info<< ' ' << fieldName;
+            Info<< ' ' << io.name();
             ++count;
         }
     }

applications/utilities/postProcessing/dataConversion/foamToEnsight/writeVolFields.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2022 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
@@ -92,7 +92,7 @@ label writeVolFields
 
     label count = 0;
 
-    for (const word& fieldName : objects.sortedNames<FieldType>())
+    for (const IOobject& io : objects.csorted<FieldType>())
     {
         if
         (
@@ -100,12 +100,12 @@ label writeVolFields
             (
                 ensCase,
                 ensMesh,
-                getField<FieldType>(objects.findObject(fieldName), mesh),
+                getField<FieldType>(io, mesh),
                 nearCellValue
             )
         )
         {
-            Info<< ' ' << fieldName;
+            Info<< ' ' << io.name();
             ++count;
         }
     }

applications/utilities/postProcessing/dataConversion/foamToTetDualMesh/foamToTetDualMesh.C

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -58,18 +59,21 @@ void ReadAndMapFields
 {
     typedef typename MappedGeoField::value_type Type;
 
-    // Search list of objects for wanted type
-    IOobjectList fieldObjects(objects.lookupClass(ReadGeoField::typeName));
+    // Objects of wanted type
+    const UPtrList<const IOobject> fieldObjects
+    (
+        objects.csorted<ReadGeoField>()
+    );
 
-    tetFields.setSize(fieldObjects.size());
+    tetFields.resize(fieldObjects.size());
 
     label i = 0;
-    forAllConstIters(fieldObjects, iter)
+    for (const IOobject& io : fieldObjects)
     {
-        Info<< "Converting " << ReadGeoField::typeName << ' ' << iter.key()
-            << endl;
+        Info<< "Converting "
+            << ReadGeoField::typeName << ' ' << io.name() << endl;
 
-        ReadGeoField readField(*iter(), mesh);
+        ReadGeoField readField(io, mesh);
 
         tetFields.set
         (
@@ -82,8 +86,8 @@ void ReadAndMapFields
                     readField.instance(),
                     readField.local(),
                     tetDualMesh,
-                    IOobject::NO_READ,
-                    IOobject::AUTO_WRITE,
+                    IOobjectOption::NO_READ,
+                    IOobjectOption::AUTO_WRITE,
                     readField.registerObject()
                 ),
                 pointMesh::New(tetDualMesh),

applications/utilities/postProcessing/dataConversion/foamToVTK/readFields.C

@@ -79,8 +79,8 @@ Foam::tmp<GeoField> Foam::getField
         {
             // Move field to the cache
             IOobject newIO(tfield(), *cache);
-            newIO.readOpt(IOobject::NO_READ);
-            newIO.writeOpt(IOobject::NO_WRITE);
+            newIO.readOpt(IOobjectOption::NO_READ);
+            newIO.writeOpt(IOobjectOption::NO_WRITE);
 
             tfield.ref().checkOut();  // Paranoid
             cache->store(new GeoField(newIO, tfield));

applications/utilities/postProcessing/lagrangian/steadyParticleTracks/steadyParticleTracksTemplates.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2022 OpenCFD Ltd.
+    Copyright (C) 2016-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -108,25 +108,13 @@ void Foam::processFields
     const IOobjectList& cloudObjects
 )
 {
-    for (const word& fldName : cloudObjects.sortedNames<IOField<Type>>())
+    for (const IOobject& io : cloudObjects.csorted<IOField<Type>>())
     {
-        const IOobject* io = cloudObjects.cfindObject<IOField<Type>>(fldName);
-
-        if (!io)
-        {
-            FatalErrorInFunction
-                << "Could not read field:" << fldName
-                << " type:" << IOField<Type>::typeName
-                << abort(FatalError);
-        }
-        else
-        {
-            Info<< "        reading field " << fldName << endl;
-            IOField<Type> field(*io);
+        Info<< "        reading field " << io.name() << endl;
+        IOField<Type> field(io);
 
         writeVTKField<Type>(os, field, addr);
     }
-    }
 }
 
 

applications/utilities/postProcessing/miscellaneous/temporalInterpolate/temporalInterpolate.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2018-2020 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -97,22 +97,24 @@ public:
 template<class GeoFieldType>
 void fieldInterpolator::interpolate()
 {
-    const word& clsName = GeoFieldType::typeName;
-
-    const wordList fieldNames =
+    label nFields = 0;
+    for
+    (
+        const IOobject& io :
         (
             selectedFields_.empty()
-      ? objects_.sortedNames(clsName)
-      : objects_.sortedNames(clsName, selectedFields_)
-    );
-
-    if (fieldNames.size())
+          ? objects_.csorted<GeoFieldType>()
+          : objects_.csorted<GeoFieldType>(selectedFields_)
+        )
+    )
     {
-        Info<< "    " << clsName << 's';
+        const word& fieldName = io.name();
+
+        if (!nFields)
+        {
+            Info<< "    " << GeoFieldType::typeName << 's';
         }
 
-    for (const word& fieldName : fieldNames)
-    {
         Info<< ' ' << fieldName << '(';
 
         const scalar deltaT = (ti1_.value() - ti_.value())/(divisions_ + 1);
@@ -166,7 +168,7 @@ void fieldInterpolator::interpolate()
                     (
                         fieldName,
                         runTime_.timeName(),
-                        objects_[fieldName]->db(),
+                        io.db(),
                         IOobject::NO_READ,
                         IOobject::NO_WRITE,
                         IOobject::NO_REGISTER
@@ -181,9 +183,10 @@ void fieldInterpolator::interpolate()
         }
 
         Info<< ')';
+        ++nFields;
     }
 
-    if (fieldNames.size()) Info<< endl;
+    if (nFields) Info<< endl;
 }
 
 

applications/utilities/postProcessing/postProcess/postProcess.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016 OpenFOAM Foundation
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -49,35 +49,41 @@ using namespace Foam;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define ReadFields(GeoFieldType)                                               \
-    readFields<GeoFieldType>(mesh, objects, selectedFields, storedObjects);
-
-#define ReadPointFields(GeoFieldType)                                          \
-    readFields<GeoFieldType>(pMesh, objects, selectedFields, storedObjects);
-
-#define ReadUniformFields(FieldType)                                           \
-    readUniformFields<FieldType>                                               \
-    (constantObjects, selectedFields, storedObjects);
-
 void executeFunctionObjects
 (
     const argList& args,
     const Time& runTime,
     fvMesh& mesh,
-    const wordHashSet& selectedFields,
+    const wordList& selectedFields,
     functionObjectList& functions,
     bool lastTime
 )
 {
     Info<< nl << "Reading fields:" << endl;
 
-    // Maintain a stack of the stored objects to clear after executing
-    // the functionObjects
-    LIFOStack<regIOobject*> storedObjects;
+    // Read objects in constant directory
+    IOobjectList constObjects(mesh, runTime.constant());
 
     // Read objects in time directory
     IOobjectList objects(mesh, runTime.timeName());
 
+    // List of stored objects to clear after executing functionObjects
+    DynamicList<regIOobject*> storedObjects
+    (
+        objects.size() + constObjects.size()
+    );
+
+    const auto nameMatcher = [&](const word& name) -> bool
+    {
+        return selectedFields.contains(name);
+    };
+
+    // Read GeometricFields
+
+    #undef  ReadFields
+    #define ReadFields(FieldType)                                             \
+    readFields<FieldType>(mesh, objects, nameMatcher, storedObjects);
+
     // Read volFields
     ReadFields(volScalarField);
     ReadFields(volVectorField);
@@ -99,8 +105,12 @@ void executeFunctionObjects
     ReadFields(surfaceSymmTensorField);
     ReadFields(surfaceTensorField);
 
+
     // Read point fields.
     const pointMesh& pMesh = pointMesh::New(mesh);
+    #undef  ReadPointFields
+    #define ReadPointFields(FieldType)                                        \
+    readFields<FieldType>(pMesh, objects, nameMatcher, storedObjects);
 
     ReadPointFields(pointScalarField)
     ReadPointFields(pointVectorField);
@@ -108,8 +118,12 @@ void executeFunctionObjects
     ReadPointFields(pointSymmTensorField);
     ReadPointFields(pointTensorField);
 
+
     // Read uniform dimensioned fields
-    IOobjectList constantObjects(mesh, runTime.constant());
+
+    #undef  ReadUniformFields
+    #define ReadUniformFields(FieldType)                                      \
+    readUniformFields<FieldType>(constObjects, nameMatcher, storedObjects);
 
     ReadUniformFields(uniformDimensionedScalarField);
     ReadUniformFields(uniformDimensionedVectorField);
@@ -130,7 +144,8 @@ void executeFunctionObjects
 
     while (!storedObjects.empty())
     {
-        storedObjects.pop()->checkOut();
+        storedObjects.back()->checkOut();
+        storedObjects.pop_back();
     }
 }
 

applications/utilities/preProcessing/foamUpgradeCyclics/foamUpgradeCyclics.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2022 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -285,7 +285,7 @@ void rewriteField
             fieldName,
             runTime.timeName(),
             runTime,
-            IOobject::MUST_READ_IF_MODIFIED,
+            IOobject::MUST_READ,
             IOobject::NO_WRITE,
             IOobject::NO_REGISTER
         )
@@ -369,29 +369,7 @@ void rewriteField
 }
 
 
-void rewriteFields
-(
-    const bool dryrun,
-    const Time& runTime,
-    const wordList& fieldNames,
-    const HashTable<word>& thisNames,
-    const HashTable<word>& nbrNames
-)
-{
-    for (const word& fieldName : fieldNames)
-    {
-        rewriteField
-        (
-            dryrun,
-            runTime,
-            fieldName,
-            thisNames,
-            nbrNames
-        );
-    }
-}
-
-
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 int main(int argc, char *argv[])
 {
@@ -473,9 +451,9 @@ int main(int argc, char *argv[])
 
     // Convert any fields
 
-    forAll(timeDirs, timeI)
+    forAll(timeDirs, timei)
     {
-        runTime.setTime(timeDirs[timeI], timeI);
+        runTime.setTime(timeDirs[timei], timei);
 
         Info<< "Time: " << runTime.timeName() << endl;
 
@@ -514,139 +492,44 @@ int main(int argc, char *argv[])
             entry::disableFunctionEntries = 1;
         }
 
+        // Rewriting of fields:
+
+        #undef  rewriteFields
+        #define rewriteFields(FieldType)                                      \
+        for (const word& fieldName : objects.sortedNames<FieldType>())        \
+        {                                                                     \
+            rewriteField(dryrun, runTime, fieldName, thisNames, nbrNames);    \
+        }
+
         // volFields
         // ~~~~~~~~~
 
-        rewriteFields
-        (
-            dryrun,
-            runTime,
-            objects.names(volScalarField::typeName),
-            thisNames,
-            nbrNames
-        );
-        rewriteFields
-        (
-            dryrun,
-            runTime,
-            objects.names(volVectorField::typeName),
-            thisNames,
-            nbrNames
-        );
-        rewriteFields
-        (
-            dryrun,
-            runTime,
-            objects.names(volSphericalTensorField::typeName),
-            thisNames,
-            nbrNames
-        );
-        rewriteFields
-        (
-            dryrun,
-            runTime,
-            objects.names(volSymmTensorField::typeName),
-            thisNames,
-            nbrNames
-        );
-        rewriteFields
-        (
-            dryrun,
-            runTime,
-            objects.names(volTensorField::typeName),
-            thisNames,
-            nbrNames
-        );
-
+        rewriteFields(volScalarField);
+        rewriteFields(volVectorField);
+        rewriteFields(volSphericalTensorField);
+        rewriteFields(volSymmTensorField);
+        rewriteFields(volTensorField);
 
         // pointFields
         // ~~~~~~~~~~~
 
-        rewriteFields
-        (
-            dryrun,
-            runTime,
-            objects.names(pointScalarField::typeName),
-            thisNames,
-            nbrNames
-        );
-        rewriteFields
-        (
-            dryrun,
-            runTime,
-            objects.names(pointVectorField::typeName),
-            thisNames,
-            nbrNames
-        );
-        rewriteFields
-        (
-            dryrun,
-            runTime,
-            objects.names(pointSphericalTensorField::typeName),
-            thisNames,
-            nbrNames
-        );
-        rewriteFields
-        (
-            dryrun,
-            runTime,
-            objects.names(pointSymmTensorField::typeName),
-            thisNames,
-            nbrNames
-        );
-        rewriteFields
-        (
-            dryrun,
-            runTime,
-            objects.names(pointTensorField::typeName),
-            thisNames,
-            nbrNames
-        );
+        rewriteFields(pointScalarField);
+        rewriteFields(pointVectorField);
+        rewriteFields(pointSphericalTensorField);
+        rewriteFields(pointSymmTensorField);
+        rewriteFields(pointTensorField);
 
 
         // surfaceFields
-        // ~~~~~~~~~~~
+        // ~~~~~~~~~~~~~
 
-        rewriteFields
-        (
-            dryrun,
-            runTime,
-            objects.names(surfaceScalarField::typeName),
-            thisNames,
-            nbrNames
-        );
-        rewriteFields
-        (
-            dryrun,
-            runTime,
-            objects.names(surfaceVectorField::typeName),
-            thisNames,
-            nbrNames
-        );
-        rewriteFields
-        (
-            dryrun,
-            runTime,
-            objects.names(surfaceSphericalTensorField::typeName),
-            thisNames,
-            nbrNames
-        );
-        rewriteFields
-        (
-            dryrun,
-            runTime,
-            objects.names(surfaceSymmTensorField::typeName),
-            thisNames,
-            nbrNames
-        );
-        rewriteFields
-        (
-            dryrun,
-            runTime,
-            objects.names(surfaceTensorField::typeName),
-            thisNames,
-            nbrNames
-        );
+        rewriteFields(surfaceScalarField);
+        rewriteFields(surfaceVectorField);
+        rewriteFields(surfaceSphericalTensorField);
+        rewriteFields(surfaceSymmTensorField);
+        rewriteFields(surfaceTensorField);
+
+        #undef rewriteFields
 
         entry::disableFunctionEntries = oldFlag;
     }

applications/utilities/preProcessing/mapFields/MapConsistentVolFields.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -52,23 +52,20 @@ void MapConsistentVolFields
     const fvMesh& meshSource = meshToMesh0Interp.fromMesh();
     const fvMesh& meshTarget = meshToMesh0Interp.toMesh();
 
-    IOobjectList fields = objects.lookupClass(fieldType::typeName);
-
-    forAllConstIters(fields, fieldIter)
+    for (const IOobject& io : objects.csorted<fieldType>())
     {
-        Info<< "    interpolating " << (*fieldIter)->name()
-            << endl;
+        Info<< "    interpolating " << io.name() << endl;
 
         // Read field. Do not auto-load old-time field
-        fieldType fieldSource(*fieldIter(), meshSource, false);
+        fieldType fieldSource(io, meshSource, false);
 
         IOobject fieldTargetIOobject
         (
-            (*fieldIter)->name(),
+            io.name(),
             meshTarget.time().timeName(),
             meshTarget,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
+            IOobjectOption::MUST_READ,
+            IOobjectOption::AUTO_WRITE
         );
 
         if (fieldTargetIOobject.typeHeaderOk<fieldType>(true))
@@ -90,7 +87,7 @@ void MapConsistentVolFields
         }
         else
         {
-            fieldTargetIOobject.readOpt(IOobject::NO_READ);
+            fieldTargetIOobject.readOpt(IOobjectOption::NO_READ);
 
             // Interpolate field
             fieldType fieldTarget

applications/utilities/preProcessing/mapFields/MapLagrangianFields.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -33,8 +33,8 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef MapLagrangianFields_H
-#define MapLagrangianFields_H
+#ifndef Foam_MapLagrangianFields_H
+#define Foam_MapLagrangianFields_H
 
 #include "cloud.H"
 #include "GeometricField.H"
@@ -47,6 +47,59 @@ Description
 namespace Foam
 {
 
+//- Gets the indices of (source)particles that have been appended to the
+//  target cloud and maps the lagrangian fields accordingly.
+template<class SourceIOFieldType, class TargetIOFieldType>
+void MapLagrangianFields
+(
+    const string& cloudName,
+    const IOobjectList& objects,
+    const meshToMesh0& meshToMesh0Interp,
+    const labelList& addParticles,
+    const char* msg
+)
+{
+    const fvMesh& meshTarget = meshToMesh0Interp.toMesh();
+
+    for (const IOobject& io : objects.csorted<SourceIOFieldType>())
+    {
+        Info<< "    mapping lagrangian " << msg << ' ' << io.name() << endl;
+
+        // Read field (does not need mesh)
+        // Note: some fieldFields are 0 size (e.g. collision records)
+        //   if not used, so catch any of those for Field as well
+
+        SourceIOFieldType fieldSource(io);
+
+        // Map
+        TargetIOFieldType fieldTarget
+        (
+            IOobject
+            (
+                io.name(),
+                meshTarget.time().timeName(),
+                cloud::prefix/cloudName,
+                meshTarget,
+                IOobjectOption::NO_READ,
+                IOobjectOption::NO_WRITE,
+                IOobjectOption::NO_REGISTER
+            ),
+            min(fieldSource.size(), addParticles.size())  // handle 0 size
+        );
+
+        if (!fieldSource.empty())
+        {
+            forAll(addParticles, i)
+            {
+                fieldTarget[i] = fieldSource[addParticles[i]];
+            }
+        }
+
+        fieldTarget.write();
+    }
+}
+
+
 //- Gets the indices of (source)particles that have been appended to the
 //  target cloud and maps the lagrangian fields accordingly.
 template<class Type>
@@ -60,119 +113,46 @@ void MapLagrangianFields
 {
     const fvMesh& meshTarget = meshToMesh0Interp.toMesh();
 
-    {
-        IOobjectList fields = objects.lookupClass(IOField<Type>::typeName);
-
-        forAllConstIters(fields, fieldIter)
-        {
-            Info<< "    mapping lagrangian field "
-                << (*fieldIter)->name() << endl;
-
-            // Read field (does not need mesh)
-            IOField<Type> fieldSource(*fieldIter());
-
-            // Map
-            IOField<Type> fieldTarget
+    MapLagrangianFields
+    <
+        IOField<Type>,
+        IOField<Type>
+    >
     (
-                IOobject
-                (
-                    (*fieldIter)->name(),
-                    meshTarget.time().timeName(),
-                    cloud::prefix/cloudName,
-                    meshTarget,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE,
-                    IOobject::NO_REGISTER
-                ),
-                addParticles.size()
+        cloudName,
+        objects,
+        meshToMesh0Interp,
+        addParticles,
+        "Field"
     );
 
-            forAll(addParticles, i)
-            {
-                fieldTarget[i] = fieldSource[addParticles[i]];
-            }
-
-            // Write field
-            fieldTarget.write();
-        }
-    }
-
-    {
-        IOobjectList fieldFields =
-            objects.lookupClass(IOField<Field<Type>>::typeName);
-
-        forAllConstIters(fieldFields, fieldIter)
-        {
-            Info<< "    mapping lagrangian fieldField "
-                << (*fieldIter)->name() << endl;
-
-            // Read field (does not need mesh)
-            IOField<Field<Type>> fieldSource(*fieldIter());
-
-            // Map - use CompactIOField to automatically write in
+    // Target is CompactIOField to automatically write in
     // compact form for binary format.
-            CompactIOField<Field<Type>, Type> fieldTarget
+    MapLagrangianFields
+    <
+        IOField<Field<Type>>,
+        CompactIOField<Field<Type>, Type>
+    >
     (
-                IOobject
-                (
-                    (*fieldIter)->name(),
-                    meshTarget.time().timeName(),
-                    cloud::prefix/cloudName,
-                    meshTarget,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE,
-                    IOobject::NO_REGISTER
-                ),
-                addParticles.size()
+        cloudName,
+        objects,
+        meshToMesh0Interp,
+        addParticles,
+        "FieldField"
     );
 
-            forAll(addParticles, i)
-            {
-                fieldTarget[i] = fieldSource[addParticles[i]];
-            }
-
-            // Write field
-            fieldTarget.write();
-        }
-    }
-
-    {
-        IOobjectList fieldFields =
-            objects.lookupClass(CompactIOField<Field<Type>, Type>::typeName);
-
-        forAllConstIters(fieldFields, fieldIter)
-        {
-            Info<< "    mapping lagrangian fieldField "
-                << (*fieldIter)->name() << endl;
-
-            // Read field (does not need mesh)
-            CompactIOField<Field<Type>, Type> fieldSource(*fieldIter());
-
-            // Map
-            CompactIOField<Field<Type>, Type> fieldTarget
+    MapLagrangianFields
+    <
+        CompactIOField<Field<Type>, Type>,
+        CompactIOField<Field<Type>, Type>
+    >
     (
-                IOobject
-                (
-                    (*fieldIter)->name(),
-                    meshTarget.time().timeName(),
-                    cloud::prefix/cloudName,
-                    meshTarget,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE,
-                    IOobject::NO_REGISTER
-                ),
-                addParticles.size()
+        cloudName,
+        objects,
+        meshToMesh0Interp,
+        addParticles,
+        "FieldField"
     );
-
-            forAll(addParticles, i)
-            {
-                fieldTarget[i] = fieldSource[addParticles[i]];
-            }
-
-            // Write field
-            fieldTarget.write();
-        }
-    }
 }
 
 

applications/utilities/preProcessing/mapFields/MapVolFields.H

@@ -6,6 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
+    Copyright (C) 2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -51,25 +52,23 @@ void MapVolFields
     const fvMesh& meshSource = meshToMesh0Interp.fromMesh();
     const fvMesh& meshTarget = meshToMesh0Interp.toMesh();
 
-    IOobjectList fields = objects.lookupClass(fieldType::typeName);
-
-    forAllConstIters(fields, fieldIter)
+    for (const IOobject& io : objects.csorted<fieldType>())
     {
         IOobject fieldTargetIOobject
         (
-            (*fieldIter)->name(),
+            io.name(),
             meshTarget.time().timeName(),
             meshTarget,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
+            IOobjectOption::MUST_READ,
+            IOobjectOption::AUTO_WRITE
         );
 
         if (fieldTargetIOobject.typeHeaderOk<fieldType>(true))
         {
-            Info<< "    interpolating " << (*fieldIter)->name() << endl;
+            Info<< "    interpolating " << io.name() << endl;
 
             // Read field fieldSource. Do not auto-load old-time fields
-            fieldType fieldSource(*fieldIter(), meshSource, false);
+            fieldType fieldSource(io, meshSource, false);
 
             // Read fieldTarget. Do not auto-load old-time fields
             fieldType fieldTarget

applications/utilities/preProcessing/mapFields/UnMapped.H

@@ -40,11 +40,9 @@ namespace Foam
 template<class Type>
 void UnMapped(const IOobjectList& objects)
 {
-    IOobjectList fields = objects.lookupClass(Type::typeName);
-
-    forAllConstIters(fields, fieldIter)
+    for (const IOobject& io : objects.csorted<Type>())
     {
-        mvBak((*fieldIter)->objectPath(), "unmapped");
+        mvBak(io.objectPath(), "unmapped");
     }
 }
 

applications/utilities/preProcessing/mapFieldsPar/MapLagrangianFields.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -33,8 +33,8 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef MapLagrangianFields_H
-#define MapLagrangianFields_H
+#ifndef Foam_MapLagrangianFields_H
+#define Foam_MapLagrangianFields_H
 
 #include "cloud.H"
 #include "GeometricField.H"
@@ -47,6 +47,63 @@ Description
 namespace Foam
 {
 
+//- Gets the indices of (source)particles that have been appended to the
+//  target cloud and maps the lagrangian fields accordingly.
+template<class SourceIOFieldType, class TargetIOFieldType>
+void MapLagrangianFields
+(
+    const string& cloudName,
+    const IOobjectList& objects,
+    const polyMesh& meshTarget,
+    const labelList& addParticles,
+    const char* msg
+)
+{
+    for (const IOobject& io : objects.csorted<SourceIOFieldType>())
+    {
+        Info<< "    mapping lagrangian " << msg << ' ' << io.name() << endl;
+
+        // Read field (does not need mesh)
+        // Note: some fieldFields are 0 size (e.g. collision records)
+        //   if not used, so catch any of those for Field as well
+
+        SourceIOFieldType fieldSource(io);
+
+        // Map
+        TargetIOFieldType fieldTarget
+        (
+            IOobject
+            (
+                io.name(),
+                meshTarget.time().timeName(),
+                cloud::prefix/cloudName,
+                meshTarget,
+                IOobjectOption::NO_READ,
+                IOobjectOption::NO_WRITE,
+                IOobjectOption::NO_REGISTER
+            ),
+            min(fieldSource.size(), addParticles.size())  // handle 0 size
+        );
+
+        if (!fieldSource.empty())
+        {
+            forAll(addParticles, i)
+            {
+                fieldTarget[i] = fieldSource[addParticles[i]];
+            }
+        }
+        else if (cloud::debug && !addParticles.empty())
+        {
+            Pout<< "Not mapping " << io.name()
+                << " since source size = 0 and cloud size = "
+                << addParticles.size() << endl;
+        }
+
+        fieldTarget.write();
+    }
+}
+
+
 //- Gets the indices of (source)particles that have been appended to the
 //  target cloud and maps the lagrangian fields accordingly.
 template<class Type>
@@ -58,144 +115,46 @@ void MapLagrangianFields
     const labelList& addParticles
 )
 {
-    {
-        IOobjectList fields = objects.lookupClass(IOField<Type>::typeName);
-
-        forAllConstIters(fields, fieldIter)
-        {
-            const word& fieldName = (*fieldIter)->name();
-
-            Info<< "    mapping lagrangian field " << fieldName << endl;
-
-            // Read field (does not need mesh)
-            IOField<Type> fieldSource(*fieldIter());
-
-            // Map
-            IOField<Type> fieldTarget
+    MapLagrangianFields
+    <
+        IOField<Type>,
+        IOField<Type>
+    >
     (
-                IOobject
-                (
-                    fieldName,
-                    meshTarget.time().timeName(),
-                    cloud::prefix/cloudName,
+        cloudName,
+        objects,
         meshTarget,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE,
-                    IOobject::NO_REGISTER
-                ),
-                addParticles.size()
+        addParticles,
+        "Field"
     );
 
-            forAll(addParticles, i)
-            {
-                fieldTarget[i] = fieldSource[addParticles[i]];
-            }
-
-            // Write field
-            fieldTarget.write();
-        }
-    }
-
-    {
-        IOobjectList fieldFields =
-            objects.lookupClass(IOField<Field<Type>>::typeName);
-
-        forAllConstIters(fieldFields, fieldIter)
-        {
-            const word& fieldName = (*fieldIter)->name();
-
-            Info<< "    mapping lagrangian fieldField " << fieldName << endl;
-
-            // Read field (does not need mesh)
-            // Note: some fieldFields are 0 size (e.g. collision records) if
-            //       not used
-            IOField<Field<Type>> fieldSource(*fieldIter());
-
-            // Map - use CompactIOField to automatically write in
+    // Target is CompactIOField to automatically write in
     // compact form for binary format.
-            CompactIOField<Field<Type>, Type> fieldTarget
+    MapLagrangianFields
+    <
+        IOField<Field<Type>>,
+        CompactIOField<Field<Type>, Type>
+    >
     (
-                IOobject
-                (
-                    fieldName,
-                    meshTarget.time().timeName(),
-                    cloud::prefix/cloudName,
+        cloudName,
+        objects,
         meshTarget,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE,
-                    IOobject::NO_REGISTER
-                ),
-                min(fieldSource.size(), addParticles.size()) // handle 0 size
+        addParticles,
+        "FieldField"
     );
 
-            if (fieldSource.size())
-            {
-                forAll(addParticles, i)
-                {
-                    fieldTarget[i] = fieldSource[addParticles[i]];
-                }
-            }
-            else if (cloud::debug)
-            {
-                Pout<< "Not mapping " << fieldName << " since source size "
-                    << fieldSource.size() << " different to"
-                    << " cloud size " << addParticles.size()
-                    << endl;
-            }
-
-            // Write field
-            fieldTarget.write();
-        }
-    }
-
-    {
-        IOobjectList fieldFields =
-            objects.lookupClass(CompactIOField<Field<Type>, Type>::typeName);
-
-        forAllConstIters(fieldFields, fieldIter)
-        {
-            const word& fieldName = (*fieldIter)->name();
-
-            Info<< "    mapping lagrangian fieldField " << fieldName << endl;
-
-            // Read field (does not need mesh)
-            CompactIOField<Field<Type>, Type> fieldSource(*fieldIter());
-
-            // Map
-            CompactIOField<Field<Type>, Type> fieldTarget
+    MapLagrangianFields
+    <
+        CompactIOField<Field<Type>, Type>,
+        CompactIOField<Field<Type>, Type>
+    >
     (
-                IOobject
-                (
-                    fieldName,
-                    meshTarget.time().timeName(),
-                    cloud::prefix/cloudName,
+        cloudName,
+        objects,
         meshTarget,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE,
-                    IOobject::NO_REGISTER
-                ),
-                min(fieldSource.size(), addParticles.size()) // handle 0 size
+        addParticles,
+        "FieldField"
     );
-
-            if (fieldSource.size())
-            {
-                forAll(addParticles, i)
-                {
-                    fieldTarget[i] = fieldSource[addParticles[i]];
-                }
-            }
-            else if (cloud::debug)
-            {
-                Pout<< "Not mapping " << fieldName << " since source size "
-                    << fieldSource.size() << " different to"
-                    << " cloud size " << addParticles.size()
-                    << endl;
-            }
-
-            // Write field
-            fieldTarget.write();
-        }
-    }
 }
 
 

applications/utilities/preProcessing/mapFieldsPar/MapVolFields.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -132,20 +132,21 @@ void MapVolFields
     const fvMesh& meshTarget = static_cast<const fvMesh&>(interp.tgtRegion());
 
     // Available fields, sorted order
-    const wordList fieldNames =
+    for
+    (
+        const IOobject& io :
         (
             selectedFields.empty()
-      ? objects.sortedNames<fieldType>()
-      : objects.sortedNames<fieldType>(selectedFields)
-    );
-
-    for (const word& fieldName : fieldNames)
+          ? objects.csorted<fieldType>()
+          : objects.csorted<fieldType>(selectedFields)
+        )
+    )
     {
-        const fieldType fieldSource(*(objects[fieldName]), meshSource, false);
+        const fieldType fieldSource(io, meshSource, false);
 
         IOobject targetIO
         (
-            fieldName,
+            io.name(),
             meshTarget.time().timeName(),
             meshTarget,
             IOobject::MUST_READ
@@ -154,7 +155,7 @@ void MapVolFields
         if (targetIO.typeHeaderOk<fieldType>(true))
         {
             Info<< "    interpolating onto existing field "
-                << fieldName << endl;
+                << targetIO.name() << endl;
 
             fieldType fieldTarget(targetIO, meshTarget, false);
 
@@ -167,7 +168,7 @@ void MapVolFields
         else
         {
             Info<< "    creating new field "
-                << fieldName << endl;
+                << targetIO.name() << endl;
 
             targetIO.readOpt(IOobject::NO_READ);
 

applications/utilities/preProcessing/mapFieldsPar/UnMapped.H

@@ -40,11 +40,9 @@ namespace Foam
 template<class Type>
 void UnMapped(const IOobjectList& objects)
 {
-    IOobjectList fields = objects.lookupClass(Type::typeName);
-
-    forAllConstIters(fields, fieldIter)
+    for (const IOobject& io : objects.csorted<Type>())
     {
-        mvBak((*fieldIter)->objectPath(), "unmapped");
+        mvBak(io.objectPath(), "unmapped");
     }
 }
 

src/OpenFOAM/containers/HashTables/HashTable/HashTable.C

@@ -192,14 +192,6 @@ Foam::HashTable<T, Key, Hash>::csorted() const
 }
 
 
-template<class T, class Key, class Hash>
-Foam::UPtrList<const typename Foam::HashTable<T, Key, Hash>::node_type>
-Foam::HashTable<T, Key, Hash>::sorted() const
-{
-    return csorted();
-}
-
-
 template<class T, class Key, class Hash>
 Foam::UPtrList<typename Foam::HashTable<T, Key, Hash>::node_type>
 Foam::HashTable<T, Key, Hash>::sorted()

src/OpenFOAM/containers/HashTables/HashTable/HashTable.H

@@ -34,7 +34,7 @@ Description
     depends on the method used to generate the hash key index, the
     table capacity, insertion order etc. When the key order is
     important, use the sortedToc() method to obtain a list of sorted
-    keys and use that for further access, or the sorted() method
+    keys and use that for further access, or the csorted()/sorted() methods
     to obtain a UPtrList of entries to traverse in sorted order.
 
     Internally the table uses closed addressing into a flat storage space
@@ -351,11 +351,6 @@ public:
         //  The lifetime of the returned content cannot exceed the parent!
         UPtrList<const node_type> csorted() const;
 
-        //- Const access to the hash-table contents in sorted order
-        //- (sorted by keys).
-        //  The lifetime of the returned content cannot exceed the parent!
-        UPtrList<const node_type> sorted() const;
-
         //- Non-const access to the hash-table contents in sorted order
         //- (sorted by keys).
         //  The lifetime of the returned content cannot exceed the parent!
@@ -1006,6 +1001,11 @@ public:
 
         //- Same as contains()
         bool found(const Key& key) const { return this->contains(key); }
+
+        //- Deprecated(2023-07) use csorted() method
+        //  \deprecated(2023-07) - use csorted() method
+        FOAM_DEPRECATED_FOR(2023-07, "csorted() method")
+        UPtrList<const node_type> sorted() const { return this->csorted(); }
 };
 
 

src/OpenFOAM/db/IOobjectList/IOobjectList.C

@@ -220,22 +220,6 @@ Foam::label Foam::IOobjectList::count(const char* clsName) const
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-Foam::UPtrList<const Foam::IOobject>
-Foam::IOobjectList::sorted() const
-{
-    return sorted<void>();
-}
-
-
-Foam::UPtrList<const Foam::IOobject>
-Foam::IOobjectList::sorted(const bool syncPar) const
-{
-    return sorted<void>(syncPar);
-}
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 Foam::wordList Foam::IOobjectList::names() const

src/OpenFOAM/db/IOobjectList/IOobjectList.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2022 OpenCFD Ltd.
+    Copyright (C) 2016-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -129,12 +129,13 @@ class IOobjectList
             const bool doSort
         );
 
-        //- Templated implementation for sorted()
+        //- Templated implementation for csorted()/sorted()
         template<class Type, class MatchPredicate>
         static UPtrList<const IOobject> objectsTypeImpl
         (
             const IOobjectList& list,
-            const MatchPredicate& matchName
+            const MatchPredicate& matchName,
+            const bool doSort
         );
 
         //- Templated implementation for lookup()
@@ -421,26 +422,37 @@ public:
         HashTable<wordHashSet> classes(const MatchPredicate& matchName) const;
 
 
-    // Sorted access
+    // List-wise access (unsorted)
 
-        //- The sorted list of IOobjects
-        //  The lifetime of the returned content cannot exceed the parent!
-        UPtrList<const IOobject> sorted() const;
-
-        //- The sorted list of IOobjects with optional check for
-        //- parallel consistency.
-        //  FatalError if syncPar = true and names are not consistent on all
-        //  processors.
-        //  The lifetime of the returned content cannot exceed the parent!
-        UPtrList<const IOobject> sorted(const bool syncPar) const;
-
-        //- The sorted list of IOobjects with headerClassName == Type::typeName
+        //- The unsorted list of IOobjects with
+        //- headerClassName == Type::typeName
         //
         //  \note If \a Type is \c void, no headerClassName check is used
         //      (always true).
         //  The lifetime of the returned content cannot exceed the parent!
         template<class Type>
-        UPtrList<const IOobject> sorted() const;
+        UPtrList<const IOobject> cobjects() const;
+
+        //- The unsorted list of IOobjects with
+        //- headerClassName == Type::typeName
+        //- that also have a matching object name.
+        //  The lifetime of the returned content cannot exceed the parent!
+        template<class Type, class MatchPredicate>
+        UPtrList<const IOobject> cobjects
+        (
+            const MatchPredicate& matchName
+        ) const;
+
+    // List-wise access (sorted)
+
+        //- The sorted list of IOobjects with
+        //- headerClassName == Type::typeName
+        //
+        //  \note If \a Type is \c void, no headerClassName check is used
+        //      (always true).
+        //  The lifetime of the returned content cannot exceed the parent!
+        template<class Type>
+        UPtrList<const IOobject> csorted() const;
 
         //- The sorted names of the IOobjects with optional check for
         //- parallel consistency.
@@ -448,13 +460,30 @@ public:
         //  processors.
         //  The lifetime of the returned content cannot exceed the parent!
         template<class Type>
-        UPtrList<const IOobject> sorted(const bool syncPar) const;
+        UPtrList<const IOobject> csorted(const bool syncPar) const;
+
+        //- The sorted list of IOobjects
+        //  The lifetime of the returned content cannot exceed the parent!
+        UPtrList<const IOobject> csorted() const
+        {
+            return csorted<void>();
+        }
+
+        //- The sorted list of IOobjects with optional check for
+        //- parallel consistency.
+        //  FatalError if syncPar = true and names are not consistent on all
+        //  processors.
+        //  The lifetime of the returned content cannot exceed the parent!
+        UPtrList<const IOobject> csorted(const bool syncPar) const
+        {
+            return csorted<void>(syncPar);
+        }
 
         //- The sorted list of IOobjects with headerClassName == Type::typeName
         //- that also have a matching object name.
         //  The lifetime of the returned content cannot exceed the parent!
         template<class Type, class MatchPredicate>
-        UPtrList<const IOobject> sorted(const MatchPredicate& matchName) const;
+        UPtrList<const IOobject> csorted(const MatchPredicate& matchName) const;
 
         //- The sorted list of IOobjects with headerClassName == Type::typeName
         //- that also have a matching object name.
@@ -462,7 +491,7 @@ public:
         //  processors.
         //  The lifetime of the returned content cannot exceed the parent!
         template<class Type, class MatchPredicate>
-        UPtrList<const IOobject> sorted
+        UPtrList<const IOobject> csorted
         (
             const MatchPredicate& matchName,
             const bool syncPar
@@ -769,10 +798,67 @@ public:
         {
             return getObject(objName);
         }
+
+
+        //- Deprecated(2023-07) use csorted() method
+        //  \deprecated(2023-07) - use csorted() method
+        template<class Type>
+        FOAM_DEPRECATED_FOR(2023-07, "csorted() method")
+        UPtrList<const IOobject> sorted() const
+        {
+            return csorted<Type>();
+        }
+
+        //- Deprecated(2023-07) use csorted() method
+        //  \deprecated(2023-07) - use csorted() method
+        template<class Type>
+        FOAM_DEPRECATED_FOR(2023-07, "csorted() method")
+        UPtrList<const IOobject> sorted(const bool syncPar) const
+        {
+            return csorted<Type>(syncPar);
+        }
+
+        //- Deprecated(2023-07) use csorted() method
+        //  \deprecated(2023-07) - use csorted() method
+        FOAM_DEPRECATED_FOR(2023-07, "csorted() method")
+        UPtrList<const IOobject> sorted() const
+        {
+            return csorted<void>();
+        }
+
+        //- Deprecated(2023-07) use csorted() method
+        //  \deprecated(2023-07) - use csorted() method
+        FOAM_DEPRECATED_FOR(2023-07, "csorted() method")
+        UPtrList<const IOobject> sorted(const bool syncPar) const
+        {
+            return csorted<void>(syncPar);
+        }
+
+        //- Deprecated(2023-07) use csorted() method
+        //  \deprecated(2023-07) - use csorted() method
+        template<class Type, class MatchPredicate>
+        FOAM_DEPRECATED_FOR(2023-07, "csorted() method")
+        UPtrList<const IOobject> sorted(const MatchPredicate& matchName) const
+        {
+            return csorted<Type>(matchName);
+        }
+
+        //- Deprecated(2023-07) use csorted() method
+        //  \deprecated(2023-07) - use csorted() method
+        template<class Type, class MatchPredicate>
+        FOAM_DEPRECATED_FOR(2023-07, "csorted() method")
+        UPtrList<const IOobject> sorted
+        (
+            const MatchPredicate& matchName,
+            const bool syncPar
+        ) const
+        {
+            return csorted<Type>(matchName, syncPar);
+        }
 };
 
 
-// Ostream operator
+// Ostream Operator
 Ostream& operator<<(Ostream& os, const IOobjectList& list);
 
 

src/OpenFOAM/db/IOobjectList/IOobjectListTemplates.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2022 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -177,13 +177,14 @@ Foam::wordList Foam::IOobjectList::namesTypeImpl
 }
 
 
-// Templated implementation for sorted()
+// Templated implementation for csorted(), csorted()
 template<class Type, class MatchPredicate>
 Foam::UPtrList<const Foam::IOobject>
 Foam::IOobjectList::objectsTypeImpl
 (
     const IOobjectList& list,
-    const MatchPredicate& matchName
+    const MatchPredicate& matchName,
+    const bool doSort
 )
 {
     UPtrList<const IOobject> result(list.size());
@@ -203,7 +204,10 @@ Foam::IOobjectList::objectsTypeImpl
 
     result.resize(count);
 
+    if (doSort)
+    {
         Foam::sort(result, nameOp<IOobject>());  // Sort by object name()
+    }
 
     return result;
 }
@@ -472,19 +476,30 @@ Foam::label Foam::IOobjectList::count
 
 template<class Type>
 Foam::UPtrList<const Foam::IOobject>
-Foam::IOobjectList::sorted() const
+Foam::IOobjectList::cobjects() const
 {
-    return objectsTypeImpl<Type>(*this, predicates::always());
+    // doSort = false
+    return objectsTypeImpl<Type>(*this, predicates::always(), false);
 }
 
 
 template<class Type>
 Foam::UPtrList<const Foam::IOobject>
-Foam::IOobjectList::sorted(const bool syncPar) const
+Foam::IOobjectList::csorted() const
+{
+    // doSort = true
+    return objectsTypeImpl<Type>(*this, predicates::always(), true);
+}
+
+
+template<class Type>
+Foam::UPtrList<const Foam::IOobject>
+Foam::IOobjectList::csorted(const bool syncPar) const
 {
     UPtrList<const IOobject> list
     (
-        objectsTypeImpl<Type>(*this, predicates::always())
+        // doSort = true
+        objectsTypeImpl<Type>(*this, predicates::always(), true)
     );
 
     checkObjectOrder(list, syncPar);
@@ -495,18 +510,31 @@ Foam::IOobjectList::sorted(const bool syncPar) const
 
 template<class Type, class MatchPredicate>
 Foam::UPtrList<const Foam::IOobject>
-Foam::IOobjectList::sorted
+Foam::IOobjectList::cobjects
 (
     const MatchPredicate& matchName
 ) const
 {
-    return objectsTypeImpl<Type>(*this, matchName);
+    // doSort = false
+    return objectsTypeImpl<Type>(*this, matchName, false);
 }
 
 
 template<class Type, class MatchPredicate>
 Foam::UPtrList<const Foam::IOobject>
-Foam::IOobjectList::sorted
+Foam::IOobjectList::csorted
+(
+    const MatchPredicate& matchName
+) const
+{
+    // doSort = true
+    return objectsTypeImpl<Type>(*this, matchName, true);
+}
+
+
+template<class Type, class MatchPredicate>
+Foam::UPtrList<const Foam::IOobject>
+Foam::IOobjectList::csorted
 (
     const MatchPredicate& matchName,
     const bool syncPar
@@ -514,7 +542,8 @@ Foam::IOobjectList::sorted
 {
     UPtrList<const IOobject> list
     (
-        objectsTypeImpl<Type>(*this, matchName)
+        // doSort = true
+        objectsTypeImpl<Type>(*this, matchName, true)
     );
 
     checkObjectOrder(list, syncPar);
@@ -531,6 +560,7 @@ Foam::wordList Foam::IOobjectList::names
     const MatchPredicate& matchClass
 ) const
 {
+    // doSort = false
     return namesImpl(*this, matchClass, predicates::always(), false);
 }
 
@@ -553,6 +583,7 @@ Foam::wordList Foam::IOobjectList::names
     const MatchPredicate2& matchName
 ) const
 {
+    // doSort = false
     return namesImpl(*this, matchClass, matchName, false);
 }
 
@@ -572,6 +603,7 @@ Foam::wordList Foam::IOobjectList::names
 template<class Type>
 Foam::wordList Foam::IOobjectList::names() const
 {
+    // doSort = false
     return namesTypeImpl<Type>(*this, predicates::always(), false);
 }
 
@@ -589,6 +621,7 @@ Foam::wordList Foam::IOobjectList::names
     const MatchPredicate& matchName
 ) const
 {
+    // doSort = false
     return namesTypeImpl<Type>(*this, matchName, false);
 }
 

src/OpenFOAM/db/objectRegistry/objectRegistry.C

@@ -158,27 +158,6 @@ Foam::label Foam::objectRegistry::count(const char* clsName) const
 }
 
 
-Foam::UPtrList<const Foam::regIOobject>
-Foam::objectRegistry::csorted() const
-{
-    return objectsTypeImpl<const regIOobject>(*this, predicates::always());
-}
-
-
-Foam::UPtrList<const Foam::regIOobject>
-Foam::objectRegistry::sorted() const
-{
-    return objectsTypeImpl<const regIOobject>(*this, predicates::always());
-}
-
-
-Foam::UPtrList<Foam::regIOobject>
-Foam::objectRegistry::sorted()
-{
-    return objectsTypeImpl<regIOobject>(*this, predicates::always());
-}
-
-
 Foam::wordList Foam::objectRegistry::names() const
 {
     return HashTable<regIOobject*>::toc();

src/OpenFOAM/db/objectRegistry/objectRegistry.H

@@ -150,13 +150,24 @@ class objectRegistry
             const bool doSort
         );
 
-        //- Templated implementation for sorted()
+        //- Templated implementation for csorted()/sorted()
         //  Called with 'Type' or 'const Type'
         template<class Type, class MatchPredicate>
         static UPtrList<Type> objectsTypeImpl
         (
+            const bool strict,         // Check with isType<Type>
             const objectRegistry& list,
-            const MatchPredicate& matchName
+            const MatchPredicate& matchName,
+            const bool doSort          // Sort the list by name
+        );
+
+        //- Templated implementation for lookupClass()
+        //  Called with 'Type' or 'const Type'
+        template<class Type>
+        static HashTable<Type*> lookupClassTypeImpl
+        (
+            const bool strict,  // Check with isType<Type>
+            const objectRegistry& list
         );
 
 
@@ -240,49 +251,69 @@ public:
         HashTable<wordHashSet> classes(const MatchPredicate& matchName) const;
 
 
-    // Sorted access
+    // List-wise access (unsorted)
 
-        //- Return sorted list of objects
+        //- Return unsorted list of objects with a class satisfying
+        //- \c isA\<Type\> or \c isType\<Type\> (with Strict)
         //  The lifetime of the returned content cannot exceed the parent!
-        UPtrList<const regIOobject> csorted() const;
+        template<class Type, bool Strict=false>
+        UPtrList<const Type> cobjects() const;
 
-        //- Return sorted list of objects
+        //- Return unsorted list of objects with a class satisfying
+        //- \c isA\<Type\> or \c isType\<Type\> (with Strict)
         //  The lifetime of the returned content cannot exceed the parent!
-        UPtrList<const regIOobject> sorted() const;
+        template<class Type, bool Strict=false>
+        UPtrList<Type> objects();
 
-        //- Return sorted list of objects
+        //- Return unsorted list of objects with a class satisfying
+        //- \c isA\<Type\> that also have a matching object name.
         //  The lifetime of the returned content cannot exceed the parent!
-        UPtrList<regIOobject> sorted();
-
-        //- Return sorted list of objects with a class satisfying \c isA\<Type\>
-        //  The lifetime of the returned content cannot exceed the parent!
-        template<class Type>
-        UPtrList<const Type> csorted() const;
-
-        //- Return sorted list of objects with a class satisfying \c isA\<Type\>
-        //  The lifetime of the returned content cannot exceed the parent!
-        template<class Type>
-        UPtrList<const Type> sorted() const;
-
-        //- Return sorted list of objects with a class satisfying \c isA\<Type\>
-        //  The lifetime of the returned content cannot exceed the parent!
-        template<class Type>
-        UPtrList<Type> sorted();
+        template<class Type, class MatchPredicate>
+        UPtrList<const Type> cobjects(const MatchPredicate& matchName) const;
 
         //- Return sorted list of objects with a class satisfying \c isA\<Type\>
         //- that also have a matching object name.
         //  The lifetime of the returned content cannot exceed the parent!
         template<class Type, class MatchPredicate>
+        UPtrList<Type> objects(const MatchPredicate& matchName);
+
+
+    // List-wise access (sorted)
+
+        //- Return sorted list of objects with a class satisfying
+        //- \c isA\<Type\> or \c isType\<Type\> (with Strict)
+        //  The lifetime of the returned content cannot exceed the parent!
+        template<class Type, bool Strict=false>
+        UPtrList<const Type> csorted() const;
+
+        //- Return sorted list of objects with a class satisfying
+        //- \c isA\<Type\> or \c isType\<Type\> (with Strict)
+        //  The lifetime of the returned content cannot exceed the parent!
+        template<class Type, bool Strict=false>
+        UPtrList<Type> sorted();
+
+        //- Return sorted list of objects
+        //  The lifetime of the returned content cannot exceed the parent!
+        UPtrList<const regIOobject> csorted() const
+        {
+            return csorted<regIOobject>();
+        }
+
+        //- Return sorted list of objects
+        //  The lifetime of the returned content cannot exceed the parent!
+        UPtrList<regIOobject> sorted()
+        {
+            return sorted<regIOobject>();
+        }
+
+        //- Return sorted list of objects with a class satisfying
+        //- \c isA\<Type\> that also have a matching object name.
+        //  The lifetime of the returned content cannot exceed the parent!
+        template<class Type, class MatchPredicate>
         UPtrList<const Type> csorted(const MatchPredicate& matchName) const;
 
-        //- Return sorted list of objects with a class satisfying \c isA\<Type\>
-        //- that also have a matching object name.
-        //  The lifetime of the returned content cannot exceed the parent!
-        template<class Type, class MatchPredicate>
-        UPtrList<const Type> sorted(const MatchPredicate& matchName) const;
-
-        //- Return sorted list of objects with a class satisfying \c isA\<Type\>
-        //- that also have a matching object name.
+        //- Return sorted list of objects with a class satisfying
+        //- \c isA\<Type\> that also have a matching object name.
         //  The lifetime of the returned content cannot exceed the parent!
         template<class Type, class MatchPredicate>
         UPtrList<Type> sorted(const MatchPredicate& matchName);
@@ -351,7 +382,7 @@ public:
             const MatchPredicate2& matchName
         ) const;
 
-        //- The unsorted names of objects with a class satisfying \c isA\<Type\>.
+        //- The unsorted names of objects with a class satisfying \c isA\<Type\>
         //
         //  \note If \a Type is \c void, no isA check is used (always true).
         template<class Type>
@@ -417,17 +448,27 @@ public:
         ) const;
 
 
-        //- Return all objects with a class satisfying \c isA\<Type\>
-        //
-        //  \param strict use \c isType\<Type\> instead of \c isA\<Type\>
-        template<class Type>
-        HashTable<const Type*> lookupClass(const bool strict = false) const;
+        //- Return all objects with a class satisfying
+        //- \c isA\<Type\> or \c isType\<Type\> (with Strict)
+        template<class Type, bool Strict=false>
+        HashTable<const Type*> lookupClass() const;
+
+        //- Return all objects with a class satisfying
+        //- \c isA\<Type\> or \c isType\<Type\> (with Strict)
+        template<class Type, bool Strict=false>
+        HashTable<Type*> lookupClass();
 
         //- Return all objects with a class satisfying \c isA\<Type\>
         //
         //  \param strict use \c isType\<Type\> instead of \c isA\<Type\>
         template<class Type>
-        HashTable<Type*> lookupClass(const bool strict = false);
+        HashTable<const Type*> lookupClass(const bool strict) const;
+
+        //- Return all objects with a class satisfying \c isA\<Type\>
+        //
+        //  \param strict use \c isType\<Type\> instead of \c isA\<Type\>
+        template<class Type>
+        HashTable<Type*> lookupClass(const bool strict);
 
         //- Return const pointer to the regIOobject.
         //
@@ -673,6 +714,32 @@ public:
         {
             return this->getObjectPtr<Type>(name, recursive);
         }
+
+        //- Deprecated(2023-07) use csorted() method
+        //  \deprecated(2023-07) - use csorted() method
+        template<class Type>
+        FOAM_DEPRECATED_FOR(2023-07, "csorted() method")
+        UPtrList<const Type> sorted() const
+        {
+            return csorted<Type>();
+        }
+
+        //- Deprecated(2023-07) use csorted() method
+        //  \deprecated(2023-07) - use csorted() method
+        FOAM_DEPRECATED_FOR(2023-07, "csorted() method")
+        UPtrList<const regIOobject> sorted() const
+        {
+            return csorted<regIOobject>();
+        }
+
+        //- Deprecated(2023-07) use csorted() method
+        //  \deprecated(2023-07) - use csorted() method
+        template<class Type, class MatchPredicate>
+        FOAM_DEPRECATED_FOR(2023-07, "csorted() method")
+        UPtrList<const Type> sorted(const MatchPredicate& matchName) const
+        {
+            return csorted<Type>(matchName);
+        }
 };
 
 

src/OpenFOAM/db/objectRegistry/objectRegistryTemplates.C

@@ -184,13 +184,15 @@ Foam::wordList Foam::objectRegistry::namesTypeImpl
 }
 
 
-// Templated implementation for sorted()
+// Templated implementation for cobjects()/objects(), csorted()/sorted()
 template<class Type, class MatchPredicate>
 Foam::UPtrList<Type>
 Foam::objectRegistry::objectsTypeImpl
 (
+    const bool strict,
     const objectRegistry& list,
-    const MatchPredicate& matchName
+    const MatchPredicate& matchName,
+    const bool doSort
 )
 {
     typedef typename std::remove_cv<Type>::type BaseType;
@@ -200,9 +202,15 @@ Foam::objectRegistry::objectsTypeImpl
     label count = 0;
     forAllConstIters(list, iter)
     {
-        const BaseType* ptr = Foam::isA<BaseType>(*iter.val());
+        const regIOobject* obj = iter.val();
+        const BaseType* ptr = dynamic_cast<const BaseType*>(obj);
 
-        if (ptr && matchName(ptr->name()))
+        if
+        (
+            ptr
+         && (!strict || Foam::isType<BaseType>(*obj))
+         && matchName(ptr->name())
+        )
         {
             result.set(count, const_cast<BaseType*>(ptr));
             ++count;
@@ -211,7 +219,42 @@ Foam::objectRegistry::objectsTypeImpl
 
     result.resize(count);
 
+    if (doSort)
+    {
         Foam::sort(result, nameOp<Type>());  // Sort by object name()
+    }
+
+    return result;
+}
+
+
+// Templated implementation for lookupClass()
+template<class Type>
+Foam::HashTable<Type*>
+Foam::objectRegistry::lookupClassTypeImpl
+(
+    const bool strict,
+    const objectRegistry& list
+)
+{
+    typedef typename std::remove_cv<Type>::type BaseType;
+
+    HashTable<Type*> result(list.capacity());
+
+    forAllConstIters(list, iter)
+    {
+        const regIOobject* obj = iter.val();
+        const BaseType* ptr = dynamic_cast<const BaseType*>(obj);
+
+        if
+        (
+            ptr
+         && (!strict || Foam::isType<BaseType>(*obj))
+        )
+        {
+            result.insert(obj->name(), const_cast<BaseType*>(ptr));
+        }
+    }
 
     return result;
 }
@@ -294,27 +337,71 @@ Foam::label Foam::objectRegistry::count
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-template<class Type>
+template<class Type, bool Strict>
+Foam::UPtrList<const Type>
+Foam::objectRegistry::cobjects() const
+{
+    return objectsTypeImpl<const Type>
+    (
+        Strict, *this, predicates::always(), false  // doSort = false
+    );
+}
+
+
+template<class Type, bool Strict>
+Foam::UPtrList<Type>
+Foam::objectRegistry::objects()
+{
+    return objectsTypeImpl<Type>
+    (
+        Strict, *this, predicates::always(), false  // doSort = false
+    );
+}
+
+
+template<class Type, bool Strict>
 Foam::UPtrList<const Type>
 Foam::objectRegistry::csorted() const
 {
-    return objectsTypeImpl<const Type>(*this, predicates::always());
+    return objectsTypeImpl<const Type>
+    (
+        Strict, *this, predicates::always(), true  // doSort = true
+    );
 }
 
 
-template<class Type>
-Foam::UPtrList<const Type>
-Foam::objectRegistry::sorted() const
-{
-    return objectsTypeImpl<const Type>(*this, predicates::always());
-}
-
-
-template<class Type>
+template<class Type, bool Strict>
 Foam::UPtrList<Type>
 Foam::objectRegistry::sorted()
 {
-    return objectsTypeImpl<Type>(*this, predicates::always());
+    return objectsTypeImpl<Type>
+    (
+        Strict, *this, predicates::always(), true  // doSort = false
+    );
+}
+
+
+template<class Type, class MatchPredicate>
+Foam::UPtrList<const Type>
+Foam::objectRegistry::cobjects
+(
+    const MatchPredicate& matchName
+) const
+{
+    // doSort = false
+    return objectsTypeImpl<const Type>(false, *this, matchName, false);
+}
+
+
+template<class Type, class MatchPredicate>
+Foam::UPtrList<Type>
+Foam::objectRegistry::objects
+(
+    const MatchPredicate& matchName
+)
+{
+    // doSort = false
+    return objectsTypeImpl<Type>(false, *this, matchName, false);
 }
 
 
@@ -325,20 +412,10 @@ Foam::objectRegistry::csorted
     const MatchPredicate& matchName
 ) const
 {
-    return objectsTypeImpl<const Type>(*this, matchName);
+    return objectsTypeImpl<const Type>(false, *this, matchName, true);
 }
 
 
-template<class Type, class MatchPredicate>
-Foam::UPtrList<const Type>
-Foam::objectRegistry::sorted
-(
-    const MatchPredicate& matchName
-) const
-{
-    return objectsTypeImpl<const Type>(*this, matchName);
-}
-
 template<class Type, class MatchPredicate>
 Foam::UPtrList<Type>
 Foam::objectRegistry::sorted
@@ -346,7 +423,7 @@ Foam::objectRegistry::sorted
     const MatchPredicate& matchName
 )
 {
-    return objectsTypeImpl<Type>(*this, matchName);
+    return objectsTypeImpl<Type>(false, *this, matchName, true);
 }
 
 
@@ -428,30 +505,27 @@ Foam::wordList Foam::objectRegistry::sortedNames
 }
 
 
+template<class Type, bool Strict>
+Foam::HashTable<const Type*> Foam::objectRegistry::lookupClass() const
+{
+    return lookupClassTypeImpl<const Type>(Strict, *this);
+}
+
+
+template<class Type, bool Strict>
+Foam::HashTable<Type*> Foam::objectRegistry::lookupClass()
+{
+    return lookupClassTypeImpl<Type>(Strict, *this);
+}
+
+
 template<class Type>
 Foam::HashTable<const Type*> Foam::objectRegistry::lookupClass
 (
     const bool strict
 ) const
 {
-    HashTable<const Type*> objectsOfClass(size());
-
-    forAllConstIters(*this, iter)
-    {
-        const regIOobject* obj = iter.val();
-
-        if
-        (
-            strict
-          ? bool(Foam::isType<Type>(*obj))
-          : bool(Foam::isA<Type>(*obj))
-        )
-        {
-            objectsOfClass.insert(obj->name(), dynamic_cast<const Type*>(obj));
-        }
-    }
-
-    return objectsOfClass;
+    return lookupClassTypeImpl<const Type>(strict, *this);
 }
 
 
@@ -461,24 +535,7 @@ Foam::HashTable<Type*> Foam::objectRegistry::lookupClass
     const bool strict
 )
 {
-    HashTable<Type*> objectsOfClass(size());
-
-    forAllIters(*this, iter)
-    {
-        regIOobject* obj = iter.val();
-
-        if
-        (
-            strict
-          ? bool(Foam::isType<Type>(*obj))
-          : bool(Foam::isA<Type>(*obj))
-        )
-        {
-            objectsOfClass.insert(obj->name(), dynamic_cast<Type*>(obj));
-        }
-    }
-
-    return objectsOfClass;
+    return lookupClassTypeImpl<Type>(strict, *this);
 }
 
 

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

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2012 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -46,20 +46,23 @@ template<class Type, class MeshMapper, class GeoMesh>
 void MapDimensionedFields(const MeshMapper& mapper)
 {
     typedef DimensionedField<Type, GeoMesh> FieldType;
-    typedef HashTable<const FieldType*> TableType;
 
-    TableType fields(mapper.thisDb().template lookupClass<FieldType>(true));
+    // Note: use strict=true to avoid picking up volFields
+    const UPtrList<const FieldType> fields
+    (
+        mapper.thisDb().template csorted<FieldType, true>()
+    );
 
-    forAllConstIters(fields, fieldIter)
+    for (const auto& fld : fields)
     {
-        FieldType& field = const_cast<FieldType&>(*fieldIter());
+        FieldType& field = const_cast<FieldType&>(fld);
 
         if (&field.mesh() == &mapper.mesh())
         {
             if (polyMesh::debug)
             {
-                Info<< "Mapping " << field.typeName << ' ' << field.name()
-                    << endl;
+                Info<< "Mapping "
+                    << FieldType::typeName << ' ' << field.name() << endl;
             }
 
             MapInternalField<Type, MeshMapper, GeoMesh>()(field, mapper);
@@ -68,7 +71,8 @@ void MapDimensionedFields(const MeshMapper& mapper)
         }
         else if (polyMesh::debug)
         {
-            Info<< "Not mapping " << field.typeName << ' ' << field.name()
+            Info<< "Not mapping "
+                << FieldType::typeName << ' ' << field.name()
                 << " since originating mesh differs from that of mapper."
                 << endl;
         }

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

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2017-2019 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -49,8 +49,7 @@ class MapInternalField
 {
 public:
 
-    MapInternalField()
-    {}
+    MapInternalField() = default;
 
     void operator()
     (
@@ -77,10 +76,9 @@ void MapGeometricFields
 {
     typedef GeometricField<Type, PatchField, GeoMesh> FieldType;
 
-    HashTable<const FieldType*> fields
+    const UPtrList<const FieldType> fields
     (
-        mapper.thisDb().objectRegistry::template
-            lookupClass<FieldType>()
+        mapper.thisDb().objectRegistry::template csorted<FieldType>()
     );
 
     // It is necessary to enforce that all old-time fields are stored
@@ -88,39 +86,37 @@ void MapGeometricFields
     // old-time-level field is mapped before the field itself, sizes
     // will not match.
 
-    forAllConstIters(fields, fieldIter)
+    for (const auto& field : fields)
     {
-        FieldType& field = const_cast<FieldType&>(*fieldIter());
-
         //Note: check can be removed once pointFields are actually stored on
         //      the pointMesh instead of now on the polyMesh!
         if (&field.mesh() == &mapper.mesh())
         {
-            field.storeOldTimes();
+            const_cast<FieldType&>(field).storeOldTimes();
         }
     }
 
-    forAllConstIters(fields, fieldIter)
+    for (const auto& field : fields)
     {
-        FieldType& field = const_cast<FieldType&>(*fieldIter());
+        FieldType& fld = const_cast<FieldType&>(field);
 
         if (&field.mesh() == &mapper.mesh())
         {
             if (polyMesh::debug)
             {
-                Info<< "Mapping " << field.typeName << ' ' << field.name()
-                    << endl;
+                Info<< "Mapping "
+                    << FieldType::typeName << ' ' << field.name() << endl;
             }
 
             // Map the internal field
             MapInternalField<Type, MeshMapper, GeoMesh>()
             (
-                field.internalFieldRef(),
+                fld.internalFieldRef(),
                 mapper
             );
 
             // Map the patch fields
-            auto& bfield = field.boundaryFieldRef();
+            auto& bfield = fld.boundaryFieldRef();
 
             forAll(bfield, patchi)
             {
@@ -132,11 +128,12 @@ void MapGeometricFields
                 bfield[patchi].autoMap(mapper.boundaryMap()[patchi]);
             }
 
-            field.instance() = field.time().timeName();
+            fld.instance() = fld.time().timeName();
         }
         else if (polyMesh::debug)
         {
-            Info<< "Not mapping " << field.typeName << ' ' << field.name()
+            Info<< "Not mapping "
+                << FieldType::typeName << ' ' << field.name()
                 << " since originating mesh differs from that of mapper."
                 << endl;
         }

src/OpenFOAM/fields/ReadFields/ReadFields.H

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2016-2018 OpenCFD Ltd.
+    Copyright (C) 2016-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -36,11 +36,12 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef ReadFields_H
-#define ReadFields_H
+#ifndef Foam_ReadFields_H
+#define Foam_ReadFields_H
 
 #include "PtrList.H"
 #include "wordList.H"
+#include "DynamicList.H"
 #include "GeometricField.H"
 #include "HashSet.H"
 #include "LIFOStack.H"
@@ -113,27 +114,63 @@ static void ReadFields
     const word& registryName = "fieldsCache"
 );
 
-//- Read the selected GeometricFields of the templated type.
-//  The fields are transferred to the objectRegistry and a list of them is
-//  returned as a stack for later cleanup
-template<class GeoFieldType>
+
+//- Read the selected GeometricFields of the templated type
+//- and store on the objectRegistry.
+//  Returns a list of field pointers for later cleanup
+template<class GeoFieldType, class NameMatchPredicate>
 void readFields
 (
     const typename GeoFieldType::Mesh& mesh,
     const IOobjectList& objects,
-    const wordHashSet& selectedFields,
+    //! Restrict to fields with matching names
+    const NameMatchPredicate& selectedFields,
+    //! [out] List of field pointers for later cleanup
+    DynamicList<regIOobject*>& storedObjects
+);
+
+//- Read the selected UniformDimensionedFields of the templated type
+//- and store on the objectRegistry.
+//  Returns a list of field pointers for later cleanup
+template<class UniformFieldType, class NameMatchPredicate>
+void readUniformFields
+(
+    const IOobjectList& objects,
+    //! Restrict to fields with matching names
+    const NameMatchPredicate& selectedFields,
+    //! [out] List of field pointers for later cleanup
+    DynamicList<regIOobject*>& storedObjects,
+    const bool syncPar = true
+);
+
+
+// Housekeeping
+
+//- Read the selected GeometricFields of the templated type
+//- and store on the objectRegistry.
+//  \deprecated(2023-07) - prefer the DynamicList version
+//  Returns a stack of field pointers for later cleanup
+template<class GeoFieldType, class NameMatchPredicate>
+FOAM_DEPRECATED_FOR(2023-07, "DynamicList version")
+void readFields
+(
+    const typename GeoFieldType::Mesh& mesh,
+    const IOobjectList& objects,
+    const NameMatchPredicate& selectedFields,
     LIFOStack<regIOobject*>& storedObjects
 );
 
 
-//- Read the selected UniformDimensionedFields of the templated type.
-//  The fields are transferred to the objectRegistry and a list of them is
-//  returned as a stack for later cleanup
-template<class GeoFieldType>
+//- Read the selected UniformDimensionedFields of the templated type
+//- and store on the objectRegistry.
+//  \deprecated(2023-07) - prefer the DynamicList version
+//  Returns a stack of field pointers for later cleanup
+template<class UniformFieldType, class NameMatchPredicate>
+FOAM_DEPRECATED_FOR(2023-07, "DynamicList version")
 void readUniformFields
 (
     const IOobjectList& objects,
-    const wordHashSet& selectedFields,
+    const NameMatchPredicate& selectedFields,
     LIFOStack<regIOobject*>& storedObjects,
     const bool syncPar = true
 );

src/OpenFOAM/fields/ReadFields/ReadFieldsTemplates.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2014 OpenFOAM Foundation
-    Copyright (C) 2018 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -45,10 +45,10 @@ Foam::wordList Foam::ReadFields
     typedef GeometricField<Type, PatchField, GeoMesh> GeoField;
 
     // Names of GeoField objects, sorted order.
-    const wordList fieldNames(objects.names(GeoField::typeName, syncPar));
+    const wordList fieldNames(objects.sortedNames<GeoField>(syncPar));
 
     // Construct the fields - reading in consistent (master) order.
-    fields.resize(fieldNames.size());
+    fields.resize_null(fieldNames.size());
 
     label nFields = 0;
 
@@ -73,8 +73,8 @@ Foam::wordList Foam::ReadFields
                     io.instance(),
                     io.local(),
                     io.db(),
-                    IOobject::MUST_READ,
-                    IOobject::AUTO_WRITE,
+                    IOobjectOption::MUST_READ,
+                    IOobjectOption::AUTO_WRITE,
                     io.registerObject()
                 ),
                 mesh,
@@ -99,10 +99,10 @@ Foam::wordList Foam::ReadFields
 )
 {
     // Names of GeoField objects, sorted order.
-    const wordList fieldNames(objects.names(GeoField::typeName, syncPar));
+    const wordList fieldNames(objects.sortedNames<GeoField>(syncPar));
 
     // Construct the fields - reading in consistent (master) order.
-    fields.resize(fieldNames.size());
+    fields.resize_null(fieldNames.size());
 
     label nFields = 0;
 
@@ -127,8 +127,8 @@ Foam::wordList Foam::ReadFields
                     io.instance(),
                     io.local(),
                     io.db(),
-                    IOobject::MUST_READ,
-                    IOobject::AUTO_WRITE,
+                    IOobjectOption::MUST_READ,
+                    IOobjectOption::AUTO_WRITE,
                     io.registerObject()
                 ),
                 mesh
@@ -151,10 +151,10 @@ Foam::wordList Foam::ReadFields
 )
 {
     // Names of GeoField objects, sorted order.
-    const wordList fieldNames(objects.names(GeoField::typeName, syncPar));
+    const wordList fieldNames(objects.sortedNames<GeoField>(syncPar));
 
     // Construct the fields - reading in consistent (master) order.
-    fields.resize(fieldNames.size());
+    fields.resize_null(fieldNames.size());
 
     label nFields = 0;
 
@@ -179,8 +179,8 @@ Foam::wordList Foam::ReadFields
                     io.instance(),
                     io.local(),
                     io.db(),
-                    IOobject::MUST_READ,
-                    IOobject::AUTO_WRITE,
+                    IOobjectOption::MUST_READ,
+                    IOobjectOption::AUTO_WRITE,
                     io.registerObject()
                 )
             )
@@ -235,9 +235,9 @@ void Foam::ReadFields
                     timeName,
                     timeName,
                     fieldsCache,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE,
-                    IOobject::REGISTER
+                    IOobjectOption::NO_READ,
+                    IOobjectOption::NO_WRITE,
+                    IOobjectOption::REGISTER
                 )
             );
             timeCachePtr->store();
@@ -260,9 +260,9 @@ void Foam::ReadFields
                     fieldName,
                     timeName,
                     mesh.thisDb(),
-                    IOobject::MUST_READ,
-                    IOobject::NO_WRITE,
-                    IOobject::NO_REGISTER
+                    IOobjectOption::MUST_READ,
+                    IOobjectOption::NO_WRITE,
+                    IOobjectOption::NO_REGISTER
                 ),
                 mesh
             );
@@ -275,9 +275,9 @@ void Foam::ReadFields
                     fieldName,
                     timeName,
                     timeCache,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE,
-                    IOobject::REGISTER
+                    IOobjectOption::NO_READ,
+                    IOobjectOption::NO_WRITE,
+                    IOobjectOption::REGISTER
                 ),
                 loadedFld
             );
@@ -309,53 +309,51 @@ void Foam::ReadFields
 }
 
 
-template<class GeoFieldType>
+template<class GeoFieldType, class NameMatchPredicate>
 void Foam::readFields
 (
     const typename GeoFieldType::Mesh& mesh,
     const IOobjectList& objects,
-    const wordHashSet& selectedFields,
-    LIFOStack<regIOobject*>& storedObjects
+    const NameMatchPredicate& selectedFields,
+    DynamicList<regIOobject*>& storedObjects
 )
 {
-    // Names of GeoField objects, sorted order. Not synchronised.
-    const wordList fieldNames
+    // GeoField objects, sorted order. Not synchronised.
+    const UPtrList<const IOobject> fieldObjects
     (
-        objects.sortedNames
-        (
-            GeoFieldType::typeName,
-            selectedFields   // Only permit these
-        )
+        objects.csorted<GeoFieldType>(selectedFields)
     );
 
+
+    // pre-extend reserve
+    storedObjects.reserve(storedObjects.size() + fieldObjects.size());
+
     label nFields = 0;
 
-    for (const word& fieldName : fieldNames)
+    for (const IOobject& io : fieldObjects)
     {
-        const IOobject& io = *objects[fieldName];
-
         if (!nFields)
         {
             Info<< "    " << GeoFieldType::typeName << ':';
         }
-        Info<< ' ' << fieldName;
+        Info<< ' ' << io.name();
 
         GeoFieldType* fieldPtr = new GeoFieldType
         (
             IOobject
             (
-                fieldName,
+                io.name(),
                 io.instance(),
                 io.local(),
                 io.db(),
-                IOobject::MUST_READ,
-                IOobject::NO_WRITE,
-                IOobject::REGISTER
+                IOobjectOption::MUST_READ,
+                IOobjectOption::NO_WRITE,
+                IOobjectOption::REGISTER
             ),
             mesh
         );
         fieldPtr->store();
-        storedObjects.push(fieldPtr);
+        storedObjects.push_back(fieldPtr);
 
         ++nFields;
     }
@@ -364,53 +362,49 @@ void Foam::readFields
 }
 
 
-template<class UniformFieldType>
+template<class UniformFieldType, class NameMatchPredicate>
 void Foam::readUniformFields
 (
     const IOobjectList& objects,
-    const wordHashSet& selectedFields,
-    LIFOStack<regIOobject*>& storedObjects,
+    const NameMatchPredicate& selectedFields,
+    DynamicList<regIOobject*>& storedObjects,
     const bool syncPar
 )
 {
-    // Names of UniformField objects, sorted order.
-    const wordList fieldNames
+    // UniformField objects, sorted order, synchronised.
+    const UPtrList<const IOobject> fieldObjects
     (
-        objects.names
-        (
-            UniformFieldType::typeName,
-            selectedFields,  // Only permit these
-            syncPar
-        )
+        objects.csorted<UniformFieldType>(selectedFields, syncPar)
     );
 
+    // pre-extend reserve
+    storedObjects.reserve(storedObjects.size() + fieldObjects.size());
+
     label nFields = 0;
 
-    for (const word& fieldName : fieldNames)
+    for (const IOobject& io : fieldObjects)
     {
-        const IOobject& io = *objects[fieldName];
-
         if (!nFields)
         {
             Info<< "    " << UniformFieldType::typeName << ':';
         }
-        Info<< ' ' << fieldName;
+        Info<< ' ' << io.name();
 
         UniformFieldType* fieldPtr = new UniformFieldType
         (
             IOobject
             (
-                fieldName,
+                io.name(),
                 io.instance(),
                 io.local(),
                 io.db(),
-                IOobject::MUST_READ,
-                IOobject::NO_WRITE,
-                IOobject::REGISTER
+                IOobjectOption::MUST_READ,
+                IOobjectOption::NO_WRITE,
+                IOobjectOption::REGISTER
             )
         );
         fieldPtr->store();
-        storedObjects.push(fieldPtr);
+        storedObjects.push_back(fieldPtr);
 
         ++nFields;
     }
@@ -419,4 +413,58 @@ void Foam::readUniformFields
 }
 
 
+template<class GeoFieldType, class NameMatchPredicate>
+void Foam::readFields
+(
+    const typename GeoFieldType::Mesh& mesh,
+    const IOobjectList& objects,
+    const NameMatchPredicate& selectedFields,
+    LIFOStack<regIOobject*>& storedObjects
+)
+{
+    DynamicList<regIOobject*> newObjects;
+
+    readFields<GeoFieldType, NameMatchPredicate>
+    (
+        mesh,
+        objects,
+        selectedFields,
+        newObjects
+    );
+
+    // Transcribe from list to stack
+    for (regIOobject* fieldPtr : newObjects)
+    {
+        storedObjects.push(fieldPtr);
+    }
+}
+
+
+template<class UniformFieldType, class NameMatchPredicate>
+void Foam::readUniformFields
+(
+    const IOobjectList& objects,
+    const NameMatchPredicate& selectedFields,
+    LIFOStack<regIOobject*>& storedObjects,
+    const bool syncPar
+)
+{
+    DynamicList<regIOobject*> newObjects;
+
+    readUniformFields<UniformFieldType, NameMatchPredicate>
+    (
+        objects,
+        selectedFields,
+        newObjects,
+        syncPar
+    );
+
+    // Transcribe from list to stack
+    for (regIOobject* fieldPtr : newObjects)
+    {
+        storedObjects.push(fieldPtr);
+    }
+}
+
+
 // ************************************************************************* //

src/OpenFOAM/fields/cloud/mapClouds.H

@@ -34,8 +34,8 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef mapClouds_H
-#define mapClouds_H
+#ifndef Foam_mapClouds_H
+#define Foam_mapClouds_H
 
 #include "cloud.H"
 #include "objectRegistry.H"
@@ -50,18 +50,14 @@ namespace Foam
 //  fields depending on mesh type.
 inline void mapClouds(const objectRegistry& db, const mapPolyMesh& mapper)
 {
-    HashTable<const cloud*> clouds(db.lookupClass<cloud>());
-
-    forAllIters(clouds, iter)
+    for (const cloud& c : db.csorted<cloud>())
     {
-        cloud& c = const_cast<cloud&>(*iter());
-
         if (polyMesh::debug)
         {
             Info<< "Mapping cloud " << c.name() << endl;
         }
 
-        c.autoMap(mapper);
+        const_cast<cloud&>(c).autoMap(mapper);
     }
 }
 

src/OpenFOAM/meshes/Identifiers/patch/coupleGroupIdentifier.C

@@ -161,14 +161,10 @@ Foam::label Foam::coupleGroupIdentifier::findOtherPatchID
 
 
     // Loop over all regions to find other patch in coupleGroup
-    HashTable<const polyMesh*> meshSet = runTime.lookupClass<polyMesh>();
-
     label otherPatchID = -1;
 
-    forAllConstIters(meshSet, iter)
+    for (const polyMesh& mesh : runTime.cobjects<polyMesh>())
     {
-        const polyMesh& mesh = *iter();
-
         const label patchID = findOtherPatchID(mesh, thisPatch);
 
         if (patchID != -1)
@@ -178,15 +174,15 @@ Foam::label Foam::coupleGroupIdentifier::findOtherPatchID
                 FatalErrorInFunction
                     << "Couple patchGroup " << name()
                     << " should be present on only two patches"
-                    << " in any of the meshes in " << meshSet.sortedToc()
-                    << endl
+                    << " in any of the meshes in "
+                    << runTime.sortedNames<polyMesh>() << nl
                     << "    It seems to be present on patch "
                     << thisPatch.name()
                     << " in region " << thisMesh.name()
                     << ", on patch " << otherPatchID
                     << " in region " << otherRegion
                     << " and on patch " << patchID
-                    << " in region " << mesh.name()
+                    << " in region " << mesh.name() << endl
                     << exit(FatalError);
             }
             otherPatchID = patchID;
@@ -198,7 +194,8 @@ Foam::label Foam::coupleGroupIdentifier::findOtherPatchID
     {
         FatalErrorInFunction
             << "Couple patchGroup " << name()
-            << " not found in any of the other meshes " << meshSet.sortedToc()
+            << " not found in any of the other meshes "
+            << flatOutput(runTime.sortedNames<polyMesh>())
             << " on patch " << thisPatch.name()
             << " region " << thisMesh.name()
             << exit(FatalError);

src/OpenFOAM/meshes/MeshObject/MeshObject.C

@@ -206,7 +206,7 @@ void Foam::meshObject::updateMesh(objectRegistry& obr, const mapPolyMesh& mpm)
 
     forAllIters(meshObjects, iter)
     {
-        // isA<MoveableMeshObject<Mesh>>
+        // isA<UpdateableMeshObject<Mesh>>
         auto* objectPtr = dynamic_cast<UpdateableMeshObject<Mesh>*>(*iter);
 
         if (objectPtr)
@@ -277,7 +277,7 @@ void Foam::meshObject::clearUpto(objectRegistry& obr)
 
     forAllIters(meshObjects, iter)
     {
-        // isA<ToType<Mesh>
+        // isA<ToType<Mesh>>
         auto* objectPtr = dynamic_cast<ToType<Mesh>*>(*iter);
 
         if (!objectPtr)

src/OpenFOAM/parallel/fieldsDistributor/fieldsDistributorTemplates.C

@@ -65,10 +65,10 @@ void Foam::fieldsDistributor::readFields
     typedef GeometricField<Type, PatchField, GeoMesh> GeoField;
 
     // GeoField fields - sorted for consistent order on all processors
-    UPtrList<const IOobject> fieldObjects(objects.sorted<GeoField>());
+    const UPtrList<const IOobject> fieldObjects(objects.csorted<GeoField>());
 
     // Construct the fields
-    fields.resize(fieldObjects.size());
+    fields.resize_null(fieldObjects.size());
 
     forAll(fieldObjects, i)
     {
@@ -86,10 +86,10 @@ void Foam::fieldsDistributor::readFields
 )
 {
     // GeoField fields - sorted for consistent order on all processors
-    UPtrList<const IOobject> fieldObjects(objects.sorted<GeoField>());
+    const UPtrList<const IOobject> fieldObjects(objects.csorted<GeoField>());
 
     // Construct the fields
-    fields.resize(fieldObjects.size());
+    fields.resize_null(fieldObjects.size());
 
     forAll(fieldObjects, i)
     {
@@ -167,18 +167,16 @@ void Foam::fieldsDistributor::readFieldsImpl
         if (deregister)
         {
             // Extra safety - remove all such types
-            HashTable<const GeoField*> other
+            const UPtrList<const GeoField> other
             (
-                mesh.thisDb().objectRegistry::template lookupClass<GeoField>()
+                mesh.thisDb().objectRegistry::template cobjects<GeoField>()
             );
 
-            forAllConstIters(other, iter)
+            for (const GeoField& field : other)
             {
-                GeoField& fld = const_cast<GeoField&>(*iter.val());
-
-                if (!fld.ownedByRegistry())
+                if (!field.ownedByRegistry())
                 {
-                    fld.checkOut();
+                    const_cast<GeoField&>(field).checkOut();
                 }
             }
         }

src/dynamicFvMesh/dynamicRefineFvMesh/dynamicRefineFvMesh.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2018-2022 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -295,9 +295,9 @@ void Foam::dynamicRefineFvMesh::mapFields(const mapPolyMesh& mpm)
             Pout<< "Found " << masterFaces.count() << " split faces " << endl;
         }
 
-        HashTable<surfaceScalarField*> fluxes
+        UPtrList<surfaceScalarField> fluxes
         (
-            lookupClass<surfaceScalarField>()
+            this->objectRegistry::sorted<surfaceScalarField>()
         );
 
         // Remove surfaceInterpolation to allow re-calculation on demand
@@ -305,44 +305,39 @@ void Foam::dynamicRefineFvMesh::mapFields(const mapPolyMesh& mpm)
         // might need the old interpolation fields (weights, etc).
         surfaceInterpolation::clearOut();
 
-        forAllIters(fluxes, iter)
+        for (surfaceScalarField& phi : fluxes)
         {
-            if (!correctFluxes_.found(iter.key()))
+            const word& UName = correctFluxes_.lookup(phi.name(), word::null);
+
+            if (UName.empty())
             {
                 WarningInFunction
-                    << "Cannot find surfaceScalarField " << iter.key()
+                    << "Cannot find surfaceScalarField " << phi.name()
                     << " in user-provided flux mapping table "
                     << correctFluxes_ << endl
                     << "    The flux mapping table is used to recreate the"
                     << " flux on newly created faces." << endl
                     << "    Either add the entry if it is a flux or use ("
-                    << iter.key() << " none) to suppress this warning."
+                    << phi.name() << " none) to suppress this warning."
                     << endl;
                 continue;
             }
-
-            const word& UName = correctFluxes_[iter.key()];
-
             if (UName == "none")
             {
                 continue;
             }
-
-            surfaceScalarField& phi = *iter();
-
             if (UName == "NaN")
             {
-                Pout<< "Setting surfaceScalarField " << iter.key()
+                Pout<< "Setting surfaceScalarField " << phi.name()
                     << " to NaN" << endl;
 
                 sigFpe::fillNan(phi.primitiveFieldRef());
-
                 continue;
             }
 
             if (debug)
             {
-                Pout<< "Mapping flux " << iter.key()
+                Pout<< "Mapping flux " << phi.name()
                     << " using interpolated flux " << UName
                     << endl;
             }
@@ -374,7 +369,7 @@ void Foam::dynamicRefineFvMesh::mapFields(const mapPolyMesh& mpm)
             }
 
             // Recalculate new boundary faces.
-            surfaceScalarField::Boundary& phiBf = phi.boundaryFieldRef();
+            auto& phiBf = phi.boundaryFieldRef();
 
             forAll(phiBf, patchi)
             {
@@ -617,42 +612,39 @@ Foam::dynamicRefineFvMesh::unrefine
         const labelList& reversePointMap = map().reversePointMap();
         const labelList& reverseFaceMap = map().reverseFaceMap();
 
-        HashTable<surfaceScalarField*> fluxes
+        UPtrList<surfaceScalarField> fluxes
         (
-            lookupClass<surfaceScalarField>()
+            this->objectRegistry::sorted<surfaceScalarField>()
         );
-        forAllIters(fluxes, iter)
+
+        for (surfaceScalarField& phi : fluxes)
         {
-            if (!correctFluxes_.found(iter.key()))
+            const word& UName = correctFluxes_.lookup(phi.name(), word::null);
+
+            if (UName.empty())
             {
                 WarningInFunction
-                    << "Cannot find surfaceScalarField " << iter.key()
+                    << "Cannot find surfaceScalarField " << phi.name()
                     << " in user-provided flux mapping table "
                     << correctFluxes_ << endl
                     << "    The flux mapping table is used to recreate the"
                     << " flux on newly created faces." << endl
                     << "    Either add the entry if it is a flux or use ("
-                    << iter.key() << " none) to suppress this warning."
+                    << phi.name() << " none) to suppress this warning."
                     << endl;
                 continue;
             }
-
-            const word& UName = correctFluxes_[iter.key()];
-
             if (UName == "none")
             {
                 continue;
             }
 
             DebugInfo
-                << "Mapping flux " << iter.key()
+                << "Mapping flux " << phi.name()
                 << " using interpolated flux " << UName
                 << endl;
 
-
-            surfaceScalarField& phi = *iter();
-            surfaceScalarField::Boundary& phiBf =
-                phi.boundaryFieldRef();
+            auto& phiBf = phi.boundaryFieldRef();
 
             const surfaceScalarField phiU
             (

src/dynamicFvMesh/dynamicRefineFvMesh/dynamicRefineFvMeshTemplates.C

@@ -105,24 +105,20 @@ void Foam::dynamicRefineFvMesh::mapNewInternalFaces
 )
 {
     typedef GeometricField<T, fvsPatchField, surfaceMesh> GeoField;
-    HashTable<GeoField*> sFlds(this->objectRegistry::lookupClass<GeoField>());
 
-    forAllIters(sFlds, iter)
+    for (GeoField& sFld : this->objectRegistry::sorted<GeoField>())
     {
-        //if (mapSurfaceFields_.found(iter.key()))
+        //if (mapSurfaceFields_.found(sFld.name()))
         {
             DebugInfo
                 << "dynamicRefineFvMesh::mapNewInternalFaces():"
                 << " Mapping new internal faces by interpolation on "
-                << iter.key()<< endl;
-
-            GeoField& sFld = *iter();
+                << sFld.name()<< endl;
 
             if (sFld.is_oriented())
             {
                 WarningInFunction << "Ignoring mapping oriented field "
-                    << sFld.name() << " since of type " << sFld.type()
-                    << endl;
+                    << sFld.name() << " since of type " << sFld.type() << endl;
             }
             else
             {
@@ -141,28 +137,6 @@ void Foam::dynamicRefineFvMesh::mapNewInternalFaces
 )
 {
     typedef GeometricField<T, fvsPatchField, surfaceMesh> GeoField;
-    HashTable<GeoField*> sFlds(this->objectRegistry::lookupClass<GeoField>());
-
-    forAllIters(sFlds, iter)
-    {
-        //if (mapSurfaceFields_.found(iter.key()))
-        {
-            DebugInfo
-                << "dynamicRefineFvMesh::mapNewInternalFaces():"
-                << " Mapping new internal faces by interpolation on "
-                << iter.key() << endl;
-
-            GeoField& sFld = *iter();
-
-            if (sFld.is_oriented())
-            {
-                DebugInfo
-                    << "dynamicRefineFvMesh::mapNewInternalFaces(): "
-                    << "Converting oriented field " << iter.key()
-                    << " to intensive field and mapping" << endl;
-
-                // Assume any oriented field is face area weighted (i.e. a flux)
-                // Convert to intensive (& oriented) before mapping. Untested.
 
     typedef GeometricField
     <
@@ -171,6 +145,26 @@ void Foam::dynamicRefineFvMesh::mapNewInternalFaces
         surfaceMesh
     > NormalGeoField;
 
+
+    for (GeoField& sFld : this->objectRegistry::sorted<GeoField>())
+    {
+        //if (mapSurfaceFields_.found(sFld.name()))
+        {
+            DebugInfo
+                << "dynamicRefineFvMesh::mapNewInternalFaces():"
+                << " Mapping new internal faces by interpolation on "
+                << sFld.name() << endl;
+
+            if (sFld.is_oriented())
+            {
+                DebugInfo
+                    << "dynamicRefineFvMesh::mapNewInternalFaces(): "
+                    << "Converting oriented field " << sFld.name()
+                    << " to intensive field and mapping" << endl;
+
+                // Assume any oriented field is face area weighted (i.e. a flux)
+                // Convert to intensive (& oriented) before mapping. Untested.
+
                 // Convert to intensive and non oriented
                 NormalGeoField fFld(sFld*Sf/Foam::sqr(magSf));
 

src/dynamicMesh/fvMeshAdder/fvMeshAdderTemplates.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2015-2021 OpenCFD Ltd.
+    Copyright (C) 2015-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -272,14 +272,9 @@ void Foam::fvMeshAdder::MapVolFields
 {
     typedef GeometricField<Type, fvPatchField, volMesh> fldType;
 
-    HashTable<const fldType*> fields
+    const UPtrList<const fldType> fields
     (
-        mesh.objectRegistry::lookupClass<fldType>()
-    );
-
-    HashTable<const fldType*> fieldsToAdd
-    (
-        meshToAdd.objectRegistry::lookupClass<fldType>()
+        mesh.objectRegistry::csorted<fldType>()
     );
 
     // It is necessary to enforce that all old-time fields are stored
@@ -287,36 +282,35 @@ void Foam::fvMeshAdder::MapVolFields
     // old-time-level field is mapped before the field itself, sizes
     // will not match.
 
-    forAllIters(fields, fieldIter)
+    for (const auto& field : fields)
     {
-        fldType& fld = const_cast<fldType&>(*fieldIter());
-
         DebugPout
-            << "MapVolFields : Storing old time for " << fld.name() << endl;
+            << "MapVolFields : Storing old time for "
+            << field.name() << endl;
 
-        fld.storeOldTimes();
+        const_cast<fldType&>(field).storeOldTimes();
     }
 
 
-    forAllIters(fields, fieldIter)
+    for (const auto& field : fields)
     {
-        fldType& fld = const_cast<fldType&>(*fieldIter());
+        fldType& fld = const_cast<fldType&>(field);
 
-        if (fieldsToAdd.found(fld.name()))
+        const auto* toAdd =
+            meshToAdd.objectRegistry::cfindObject<fldType>(field.name());
+
+        if (toAdd)
         {
-            const fldType& fldToAdd = *fieldsToAdd[fld.name()];
-
             DebugPout
-                << "MapVolFields : mapping " << fld.name()
-                << " and " << fldToAdd.name() << endl;
+                << "MapVolFields : mapping " << field.name() << endl;
 
-            MapVolField<Type>(meshMap, fld, fldToAdd, fullyMapped);
+            MapVolField<Type>(meshMap, fld, *toAdd, fullyMapped);
         }
         else
         {
             WarningInFunction
-                << "Not mapping field " << fld.name()
-                << " since not present on mesh to add" << endl;
+                << "Not mapping field " << field.name()
+                << " - not present on mesh to add" << endl;
         }
     }
 }
@@ -582,14 +576,9 @@ void Foam::fvMeshAdder::MapSurfaceFields
 {
     typedef GeometricField<Type, fvsPatchField, surfaceMesh> fldType;
 
-    HashTable<const fldType*> fields
+    const UPtrList<const fldType> fields
     (
-        mesh.objectRegistry::lookupClass<fldType>()
-    );
-
-    HashTable<const fldType*> fieldsToAdd
-    (
-        meshToAdd.objectRegistry::lookupClass<fldType>()
+        mesh.objectRegistry::csorted<fldType>()
     );
 
     // It is necessary to enforce that all old-time fields are stored
@@ -597,36 +586,34 @@ void Foam::fvMeshAdder::MapSurfaceFields
     // old-time-level field is mapped before the field itself, sizes
     // will not match.
 
-    forAllIters(fields, fieldIter)
+    for (const auto& field : fields)
     {
-        fldType& fld = const_cast<fldType&>(*fieldIter());
-
         DebugPout
-            << "MapSurfaceFields : Storing old time for " << fld.name() << endl;
+            << "MapSurfaceFields : Storing old time for "
+            << field.name() << endl;
 
-        fld.storeOldTimes();
+        const_cast<fldType&>(field).storeOldTimes();
     }
 
-
-    forAllIters(fields, fieldIter)
+    for (const auto& field : fields)
     {
-        fldType& fld = const_cast<fldType&>(*fieldIter());
+        fldType& fld = const_cast<fldType&>(field);
 
-        if (fieldsToAdd.found(fld.name()))
+        const auto* toAdd =
+            meshToAdd.objectRegistry::cfindObject<fldType>(field.name());
+
+        if (toAdd)
         {
-            const fldType& fldToAdd = *fieldsToAdd[fld.name()];
-
             DebugPout
-                << "MapSurfaceFields : mapping " << fld.name()
-                << " and " << fldToAdd.name() << endl;
+                << "MapSurfaceFields : mapping " << field.name() << endl;
 
-            MapSurfaceField<Type>(meshMap, fld, fldToAdd, fullyMapped);
+            MapSurfaceField<Type>(meshMap, fld, *toAdd, fullyMapped);
         }
         else
         {
             WarningInFunction
-                << "Not mapping field " << fld.name()
-                << " since not present on mesh to add" << endl;
+                << "Not mapping field " << field.name()
+                << " - not present on mesh to add" << endl;
         }
     }
 }
@@ -663,37 +650,32 @@ void Foam::fvMeshAdder::MapDimFields
 {
     typedef DimensionedField<Type, volMesh> fldType;
 
-    // Note: use strict flag on lookupClass to avoid picking up
-    //       volFields
-    HashTable<const fldType*> fields
+    // NB: strict=true to avoid picking up volFields
+    const UPtrList<const fldType> fields
     (
-        mesh.objectRegistry::lookupClass<fldType>(true)
+        mesh.objectRegistry::csorted<fldType, true>()
     );
 
-    HashTable<const fldType*> fieldsToAdd
-    (
-        meshToAdd.objectRegistry::lookupClass<fldType>(true)
-    );
-
-    forAllIters(fields, fieldIter)
+    for (const auto& field : fields)
     {
-        fldType& fld = const_cast<fldType&>(*fieldIter());
+        fldType& fld = const_cast<fldType&>(field);
 
-        if (fieldsToAdd.found(fld.name()))
+        const auto* toAdd =
+            meshToAdd.objectRegistry::cfindObject<fldType>(field.name());
+
+        // Apply strict check (to avoid picking volFields)
+        if (toAdd && Foam::isType<fldType>(*toAdd))
         {
-            const fldType& fldToAdd = *fieldsToAdd[fld.name()];
-
             DebugPout
-                << "MapDimFields : mapping " << fld.name()
-                << " and " << fldToAdd.name() << endl;
+                << "MapDimFields : mapping " << field.name() << endl;
 
-            MapDimField<Type>(meshMap, fld, fldToAdd);
+            MapDimField<Type>(meshMap, fld, *toAdd);
         }
         else
         {
             WarningInFunction
-                << "Not mapping field " << fld.name()
-                << " since not present on mesh to add" << endl;
+                << "Not mapping field " << field.name()
+                << " - not present on mesh to add" << endl;
         }
     }
 }
@@ -1115,9 +1097,9 @@ void Foam::fvMeshAdder::MapVolFields
     }
     const auto& mesh0 = meshes[0];
 
-    HashTable<const fldType*> fields
+    const UPtrList<const fldType> fields
     (
-        mesh0.objectRegistry::lookupClass<fldType>()
+        mesh0.objectRegistry::csorted<fldType>()
     );
 
 
@@ -1126,19 +1108,19 @@ void Foam::fvMeshAdder::MapVolFields
     // old-time-level field is mapped before the field itself, sizes
     // will not match.
 
-    for (const auto& fld : fields)
+    for (const auto& field : fields)
     {
         DebugPout
-            << "MapVolFields : Storing old time for " << fld->name()
-            << endl;
+            << "MapVolFields : Storing old time for "
+            << field.name() << endl;
 
-        const_cast<fldType&>(*fld).storeOldTimes();
+        const_cast<fldType&>(field).storeOldTimes();
     }
 
 
-    for (const auto& fld : fields)
+    for (const auto& field : fields)
     {
-        const word& name0 = fld->name();
+        const word& name0 = field.name();
 
         DebugPout
             << "MapVolFields : mapping " << name0 << endl;
@@ -1177,7 +1159,6 @@ void Foam::fvMeshAdder::MapDimFields
 )
 {
     typedef DimensionedField<Type, volMesh> fldType;
-    typedef GeometricField<Type, fvPatchField, volMesh> excludeType;
 
     if (!meshes.test(0))
     {
@@ -1188,17 +1169,15 @@ void Foam::fvMeshAdder::MapDimFields
     }
     const auto& mesh0 = meshes[0];
 
-    HashTable<const fldType*> fields
+    // NB: strict=true to avoid picking up volFields
+    const UPtrList<const fldType> fields
     (
-        mesh0.objectRegistry::lookupClass<fldType>()
+        mesh0.objectRegistry::csorted<fldType, true>()
     );
 
-
-    for (const auto& fld : fields)
+    for (const auto& field : fields)
     {
-        if (!isA<excludeType>(*fld))
-        {
-            const word& name0 = fld->name();
+        const word& name0 = field.name();
 
         DebugPout
             << "MapDimFields : mapping " << name0 << endl;
@@ -1216,12 +1195,6 @@ void Foam::fvMeshAdder::MapDimFields
 
         MapDimField(meshToField, cellProcAddressing, fullyMapped);
     }
-        else
-        {
-            DebugPout
-                << "MapDimFields : ignoring " << fld->name() << endl;
-        }
-    }
 }
 
 
@@ -1250,9 +1223,9 @@ void Foam::fvMeshAdder::MapSurfaceFields
     }
     const auto& mesh0 = meshes[0];
 
-    HashTable<const fldType*> fields
+    const UPtrList<const fldType> fields
     (
-        mesh0.objectRegistry::lookupClass<fldType>()
+        mesh0.objectRegistry::csorted<fldType>()
     );
 
 
@@ -1261,22 +1234,22 @@ void Foam::fvMeshAdder::MapSurfaceFields
     // old-time-level field is mapped before the field itself, sizes
     // will not match.
 
-    for (const auto& fld : fields)
+    for (const auto& field : fields)
     {
         DebugPout
-            << "MapSurfaceFields : Storing old time for " << fld->name()
-            << endl;
+            << "MapSurfaceFields : Storing old time for "
+            << field.name() << endl;
 
-        const_cast<fldType&>(*fld).storeOldTimes();
+        const_cast<fldType&>(field).storeOldTimes();
     }
 
 
-    for (const auto& fld : fields)
+    for (const auto& field : fields)
     {
-        const word& name0 = fld->name();
+        const word& name0 = field.name();
 
         DebugPout
-            << "MapSurfaceFields : Mapping " << fld->name() << endl;
+            << "MapSurfaceFields : Mapping " << field.name() << endl;
 
         UPtrList<fldType> meshToField(meshes.size());
         forAll(meshes, meshi)

src/dynamicMesh/fvMeshDistribute/fvMeshDistributeTemplates.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2015-2022 OpenCFD Ltd.
+    Copyright (C) 2015-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -87,18 +87,12 @@ void Foam::fvMeshDistribute::printIntFieldInfo(const fvMesh& mesh)
         volMesh
     > excludeType;
 
-    const HashTable<const GeoField*> flds
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllConstIters(flds, iter)
+    for (const GeoField& field : mesh.objectRegistry::csorted<GeoField>())
     {
-        const GeoField& fld = *iter();
-        if (!isA<excludeType>(fld))
+        if (!isA<excludeType>(field))
         {
-            Pout<< "Field:" << iter.key() << " internalsize:" << fld.size()
-                //<< " value:" << fld
+            Pout<< "Field:" << field.name() << " size:" << field.size()
+                //<< " value:" << field
                 << endl;
         }
     }
@@ -108,20 +102,13 @@ void Foam::fvMeshDistribute::printIntFieldInfo(const fvMesh& mesh)
 template<class GeoField>
 void Foam::fvMeshDistribute::printFieldInfo(const fvMesh& mesh)
 {
-    const HashTable<const GeoField*> flds
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllConstIters(flds, iter)
+    for (const GeoField& field : mesh.objectRegistry::csorted<GeoField>())
     {
-        const GeoField& fld = *iter();
-
-        Pout<< "Field:" << iter.key() << " internalsize:" << fld.size()
-            //<< " value:" << fld
+        Pout<< "Field:" << field.name() << " size:" << field.size()
+            //<< " value:" << field
             << endl;
 
-        for (const auto& patchFld : fld.boundaryField())
+        for (const auto& patchFld : field.boundaryField())
         {
             Pout<< "    " << patchFld.patch().index()
                 << ' ' << patchFld.patch().name()
@@ -143,21 +130,19 @@ void Foam::fvMeshDistribute::saveBoundaryFields
 
     typedef GeometricField<T, fvsPatchField, Mesh> fldType;
 
-    HashTable<const fldType*> flds
+    const UPtrList<const fldType> flds
     (
-        mesh_.objectRegistry::lookupClass<const fldType>()
+        mesh_.objectRegistry::csorted<fldType>()
     );
 
-    bflds.resize(flds.size());
+    bflds.resize_null(flds.size());
 
-    label i = 0;
-    forAllConstIters(flds, iter)
+    label fieldi = 0;
+    for (const fldType& fld : flds)
     {
-        const fldType& fld = *iter();
+        bflds.set(fieldi, fld.boundaryField().clone());
 
-        bflds.set(i, fld.boundaryField().clone());
-
-        ++i;
+        ++fieldi;
     }
 }
 
@@ -176,9 +161,9 @@ void Foam::fvMeshDistribute::mapBoundaryFields
 
     typedef GeometricField<T, fvsPatchField, Mesh> fldType;
 
-    HashTable<fldType*> flds
+    UPtrList<fldType> flds
     (
-        mesh_.objectRegistry::lookupClass<fldType>()
+        mesh_.objectRegistry::sorted<fldType>()
     );
 
     if (flds.size() != oldBflds.size())
@@ -187,14 +172,10 @@ void Foam::fvMeshDistribute::mapBoundaryFields
             << abort(FatalError);
     }
 
-    label fieldi = 0;
-
-    forAllIters(flds, iter)
+    forAll(flds, fieldi)
     {
-        fldType& fld = *iter();
-        auto& bfld = fld.boundaryFieldRef();
-
-        const FieldField<fvsPatchField, T>& oldBfld = oldBflds[fieldi++];
+        auto& bfld = flds[fieldi].boundaryFieldRef();
+        const auto& oldBfld = oldBflds[fieldi];
 
         // Pull from old boundary field into bfld.
 
@@ -231,22 +212,16 @@ void Foam::fvMeshDistribute::saveInternalFields
 {
     typedef GeometricField<T, fvsPatchField, surfaceMesh> fldType;
 
-    HashTable<const fldType*> flds
+    const UPtrList<const fldType> fields
     (
-        mesh_.objectRegistry::lookupClass<const fldType>()
+        mesh_.objectRegistry::csorted<fldType>()
     );
 
-    iflds.resize(flds.size());
+    iflds.resize_null(fields.size());
 
-    label i = 0;
-
-    forAllConstIters(flds, iter)
+    forAll(fields, fieldi)
     {
-        const fldType& fld = *iter();
-
-        iflds.set(i, fld.primitiveField().clone());
-
-        ++i;
+        iflds.set(fieldi, fields[fieldi].primitiveField().clone());
     }
 }
 
@@ -264,9 +239,9 @@ void Foam::fvMeshDistribute::mapExposedFaces
 
     typedef GeometricField<T, fvsPatchField, surfaceMesh> fldType;
 
-    HashTable<fldType*> flds
+    UPtrList<fldType> flds
     (
-        mesh_.objectRegistry::lookupClass<fldType>()
+        mesh_.objectRegistry::sorted<fldType>()
     );
 
     if (flds.size() != oldFlds.size())
@@ -277,16 +252,15 @@ void Foam::fvMeshDistribute::mapExposedFaces
     }
 
 
-    label fieldI = 0;
-
-    forAllIters(flds, iter)
+    forAll(flds, fieldi)
     {
-        fldType& fld = *iter();
+        auto& fld = flds[fieldi];
+        const auto& oldInternal = oldFlds[fieldi];
+
         const bool oriented = fld.is_oriented();
 
-        typename fldType::Boundary& bfld = fld.boundaryFieldRef();
+        auto& bfld = fld.boundaryFieldRef();
 
-        const Field<T>& oldInternal = oldFlds[fieldI++];
 
         // Pull from old internal field into bfld.
 
@@ -322,16 +296,10 @@ void Foam::fvMeshDistribute::initPatchFields
 )
 {
     // Init patch fields of certain type
+    // - field order is irrelevant
 
-    HashTable<GeoField*> flds
-    (
-        mesh_.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllIters(flds, iter)
+    for (GeoField& fld : mesh_.objectRegistry::objects<GeoField>())
     {
-        GeoField& fld = *iter();
-
         auto& bfld = fld.boundaryFieldRef();
 
         forAll(bfld, patchi)
@@ -350,14 +318,8 @@ void Foam::fvMeshDistribute::initPatchFields
 //{
 //    // CorrectBoundaryConditions patch fields of certain type
 //
-//    HashTable<GeoField*> flds
-//    (
-//        mesh_.objectRegistry::lookupClass<GeoField>()
-//    );
-//
-//    forAllIters(flds, iter)
+//    for (GeoField& fld : mesh_.objectRegistry::sorted<GeoField>())
 //    {
-//        GeoField& fld = *iter();
 //        fld.correctBoundaryConditions();
 //    }
 //}
@@ -377,14 +339,17 @@ void Foam::fvMeshDistribute::getFieldNames
 
     if (!excludeType.empty())
     {
-        const wordList& excludeList = allFieldNames(excludeType);
+        const wordList& excludeList =
+            allFieldNames.lookup(excludeType, wordList::null());
 
+        if (!excludeList.empty())
+        {
             DynamicList<word> newList(list.size());
-        for(const auto& name : list)
+            for (const auto& name : list)
             {
-            if (!excludeList.found(name))
+                if (!excludeList.contains(name))
                 {
-                newList.append(name);
+                    newList.push_back(name);
                 }
             }
             if (newList.size() < list.size())
@@ -392,6 +357,7 @@ void Foam::fvMeshDistribute::getFieldNames
                 list = std::move(newList);
             }
         }
+    }
 
 
     // Check all procs have same names

src/dynamicMesh/polyMeshFilter/polyMeshFilter.H

@@ -92,10 +92,11 @@ class polyMeshFilter
 
     // Private Member Functions
 
-        template<class T>
+        //- Update all sets of the given type
+        template<class SetType>
         static void updateSets(const mapPolyMesh& map);
 
-        template<class T>
+        template<class SetType>
         static void copySets(const polyMesh& oldMesh, const polyMesh& newMesh);
 
         label filterFacesLoop(const label nOriginalBadFaces);

src/dynamicMesh/polyMeshFilter/polyMeshFilterTemplates.C

@@ -36,16 +36,26 @@ License
 template<class SetType>
 void Foam::polyMeshFilter::updateSets(const mapPolyMesh& map)
 {
-    HashTable<const SetType*> sets =
-        map.mesh().objectRegistry::lookupClass<const SetType>();
+    //
+    // Update all sets in memory
+    //
 
-    forAllIters(sets, iter)
+    const HashTable<const SetType*> sets
+    (
+        map.mesh().objectRegistry::lookupClass<const SetType>()
+    );
+
+    for (const auto& iter : sets.csorted())
     {
-        SetType& set = const_cast<SetType&>(*iter());
+        SetType& set = const_cast<SetType&>(*iter.val());
         set.updateMesh(map);
         set.sync(map.mesh());
     }
 
+    //
+    // Update all sets on disk
+    //
+
     IOobjectList objs
     (
         map.mesh().time(),
@@ -53,14 +63,12 @@ void Foam::polyMeshFilter::updateSets(const mapPolyMesh& map)
         "polyMesh/sets"
     );
 
-    IOobjectList fileSets(objs.lookupClass<SetType>());
-
-    forAllConstIters(fileSets, iter)
+    for (const IOobject& io : objs.csorted<SetType>())
     {
-        if (!sets.found(iter.key()))
+        if (!sets.contains(io.name()))
         {
             // Not in memory. Load it.
-            SetType set(*iter());
+            SetType set(io);
             set.updateMesh(map);
 
             set.write();
@@ -76,13 +84,8 @@ void Foam::polyMeshFilter::copySets
     const polyMesh& newMesh
 )
 {
-    HashTable<const SetType*> sets =
-        oldMesh.objectRegistry::lookupClass<const SetType>();
-
-    forAllConstIters(sets, iter)
+    for (const SetType& set : oldMesh.objectRegistry::csorted<SetType>())
     {
-        const SetType& set = *iter();
-
         auto* setPtr =
             newMesh.objectRegistry::getObjectPtr<SetType>(set.name());
 

src/dynamicMesh/setUpdater/setUpdater.H

@@ -57,9 +57,9 @@ class setUpdater
 {
     // Private Member Functions
 
-        //- Updates all sets
-        template<class Type>
-        void updateSets(const mapPolyMesh& morphMap) const;
+        //- Update all sets of the given type
+        template<class SetType>
+        static void updateSets(const mapPolyMesh& map);
 
         //- No copy construct
         setUpdater(const setUpdater&) = delete;

src/dynamicMesh/setUpdater/setUpdaterTemplates.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -32,27 +32,29 @@ License
 #include "mapPolyMesh.H"
 #include "IOobjectList.H"
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
 
-template<class Type>
-void Foam::setUpdater::updateSets(const mapPolyMesh& morphMap) const
+template<class SetType>
+void Foam::setUpdater::updateSets(const mapPolyMesh& map)
 {
     //
-    // Update all sets in memory.
+    // Update all sets in memory
     //
 
-    HashTable<const Type*> memSets =
-        morphMap.mesh().objectRegistry::lookupClass<Type>();
+    const HashTable<const SetType*> sets
+    (
+        map.mesh().objectRegistry::lookupClass<const SetType>()
+    );
 
-    forAllIters(memSets, iter)
+    for (const auto& iter : sets.csorted())
     {
-        Type& set = const_cast<Type&>(*iter());
+        SetType& set = const_cast<SetType&>(*iter.val());
 
         DebugPout
             << "Set:" << set.name() << " size:" << set.size()
             << " updated in memory" << endl;
 
-        set.updateMesh(morphMap);
+        set.updateMesh(map);
 
         // Write or not? Debatable.
         set.write();
@@ -66,35 +68,30 @@ void Foam::setUpdater::updateSets(const mapPolyMesh& morphMap) const
     // Get last valid mesh (discard points-only change)
     IOobjectList objs
     (
-        morphMap.mesh().time(),
-        morphMap.mesh().facesInstance(),
+        map.mesh().time(),
+        map.mesh().facesInstance(),
         "polyMesh/sets"
     );
 
-    IOobjectList fileSets(objs.lookupClass<Type>());
-
-    forAllConstIters(fileSets, iter)
+    for (const IOobject& io : objs.csorted<SetType>())
     {
-        if (!memSets.found(iter.key()))
+        if (!sets.contains(io.name()))
         {
             // Not in memory. Load it.
-            Type set(*iter());
+            SetType set(io);
 
-            if (debug)
-            {
-                Pout<< "Set:" << set.name() << " size:" << set.size()
+            DebugPout
+                << "Set:" << set.name() << " size:" << set.size()
                 << " updated on disk" << endl;
-            }
-
-            set.updateMesh(morphMap);
 
+            set.updateMesh(map);
             set.write();
         }
         else
         {
             DebugPout
-                << "Set:" << iter.key() << " already updated from memory"
-                << endl;
+                << "Set:" << io.name()
+                << " already updated from memory" << endl;
         }
     }
 }

src/fileFormats/vtk/read/vtkUnstructuredReaderTemplates.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2012 OpenFOAM Foundation
-    Copyright (C) 2021 OpenCFD Ltd.
+    Copyright (C) 2021-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -33,20 +33,18 @@ License
 template<class Type>
 void Foam::vtkUnstructuredReader::printFieldStats(const objectRegistry& obj)
 {
-    const wordList fieldNames(obj.sortedNames<Type>());
+    const UPtrList<const Type> fields(obj.csorted<Type>());
 
-    if (fieldNames.size())
+    if (!fields.empty())
     {
-        Info<< "Read " << fieldNames.size() << ' ' << Type::typeName
+        Info<< "Read " << fields.size() << ' ' << Type::typeName
             << " fields:" << nl
             << "Size\tName" << nl
             << "----\t----" << nl;
 
-        for (const word& fieldName : fieldNames)
+        for (const Type& field : fields)
         {
-            Info<< obj.lookupObject<Type>(fieldName).size()
-                << '\t' << fieldName
-                << nl;
+            Info<< field.size() << '\t' << field.name() << nl;
         }
         Info<< endl;
     }

src/finiteArea/distributed/faMeshDistributorTemplates.C

@@ -310,8 +310,8 @@ Foam::label Foam::faMeshDistributor::distributeAreaFields
         const IOobject& io :
         (
             selectedFields.empty()
-          ? objects.sorted<fieldType>()
-          : objects.sorted<fieldType>(selectedFields)
+          ? objects.csorted<fieldType>()
+          : objects.csorted<fieldType>(selectedFields)
         )
     )
     {
@@ -368,8 +368,8 @@ Foam::label Foam::faMeshDistributor::distributeEdgeFields
         const IOobject& io :
         (
             selectedFields.empty()
-          ? objects.sorted<fieldType>()
-          : objects.sorted<fieldType>(selectedFields)
+          ? objects.csorted<fieldType>()
+          : objects.csorted<fieldType>(selectedFields)
         )
     )
     {

src/finiteVolume/cfdTools/general/solutionControl/loopControl/loopControl.C

@@ -101,14 +101,16 @@ bool Foam::loopControl::checkConverged() const
         return false;
     }
 
-    HashTable<const fvMesh*> meshes = time_.lookupClass<const fvMesh>();
-
     bool achieved = true;
     bool checked = false; // safety that some checks were indeed performed
 
-    forAllConstIters(meshes, meshIter)
+    const objectRegistry& obr = time_;
+
+    forAllConstIters(obr, iter)
     {
-        const fvMesh& regionMesh = *(meshIter.val());
+        const fvMesh* meshPtr = dynamic_cast<const fvMesh*>(iter.val());
+        if (!meshPtr) continue;
+        const fvMesh& regionMesh = *meshPtr;
 
         const dictionary& solverDict = regionMesh.solverPerformanceDict();
         for (const entry& dataDictEntry : solverDict)

src/finiteVolume/cfdTools/general/solutionControl/solutionControl/solutionControlTemplates.C

@@ -37,12 +37,8 @@ void Foam::solutionControl::storePrevIter() const
 {
     typedef GeometricField<Type, fvPatchField, volMesh> GeoField;
 
-    HashTable<GeoField*> flds(mesh_.objectRegistry::lookupClass<GeoField>());
-
-    forAllIters(flds, iter)
+    for (GeoField& fld : mesh_.objectRegistry::sorted<GeoField>())
     {
-        GeoField& fld = *iter();
-
         const word& fldName = fld.name();
 
         if (!fldName.contains("PrevIter") && mesh_.relaxField(fldName))

src/finiteVolume/functionObjects/fieldSelections/fieldSelection/fieldInfo.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -32,8 +32,8 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef functionObjects_fieldInfo_H
-#define functionObjects_fieldInfo_H
+#ifndef Foam_functionObjects_fieldInfo_H
+#define Foam_functionObjects_fieldInfo_H
 
 #include "label.H"
 #include "wordRes.H"
@@ -57,7 +57,7 @@ Ostream& operator<<(Ostream&, const fieldInfo&);
 
 class fieldInfo
 {
-    // Pivate Data
+    // Private Data
 
         //- Pattern for the field name(s)
         wordRe name_;
@@ -65,8 +65,8 @@ class fieldInfo
         //- Field component
         label component_;
 
-        //- Found
-        mutable Switch found_;
+        //- Found the field
+        mutable bool found_;
 
 
 public:
@@ -81,9 +81,8 @@ public:
             found_(false)
         {}
 
-
         //- Construct from components
-        fieldInfo(const wordRe& name, const label component = -1)
+        explicit fieldInfo(const wordRe& name, const label component = -1)
         :
             name_(name),
             component_(component),
@@ -91,7 +90,7 @@ public:
         {}
 
         //- Construct from stream
-        fieldInfo(Istream& is)
+        explicit fieldInfo(Istream& is)
         :
             name_(is),
             component_(readLabel(is)),
@@ -105,27 +104,27 @@ public:
 
     // Member Functions
 
-        const wordRe& name() const
-        {
-            return name_;
-        }
+        //- Return the selector pattern for the field name(s)
+        const wordRe& name() const noexcept { return name_; }
 
-        label component() const
-        {
-            return component_;
-        }
+        //- Return the component
+        label component() const noexcept { return component_; }
+
+        //- Return the found state
+        bool found() const noexcept { return found_; }
+
+        //- Set the found state to be 'on'
+        void found(bool on) const noexcept { found_ = on; }
 
-        Switch& found() const
-        {
-            return found_;
-        }
 
         friend bool operator==(const fieldInfo& a, const fieldInfo& b)
         {
             return
-                a.name_ == b.name_
-             && a.component_ == b.component_
-             && a.found_ == b.found_;
+            (
+                a.found() == b.found()
+             && a.component() == b.component()
+             && a.name() == b.name()
+            );
         }
 
         friend bool operator!=(const fieldInfo& a, const fieldInfo& b)
@@ -143,7 +142,9 @@ public:
         }
         friend Ostream& operator<<(Ostream& os, const fieldInfo& fi)
         {
-            os  << fi.name_ << ' ' << fi.component_ << ' ' << fi.found_;
+            os  << fi.name_ << ' '
+                << fi.component_ << ' '
+                << Switch::name(fi.found_);
             return os;
         }
 };

src/finiteVolume/functionObjects/fieldSelections/fieldSelection/fieldSelection.C

@@ -37,27 +37,28 @@ Foam::functionObjects::fieldSelection::fieldSelection
     const bool includeComponents
 )
 :
-    List<fieldInfo>(),
     obr_(obr),
-    includeComponents_(includeComponents),
-    selection_()
+    includeComponents_(includeComponents)
 {}
 
 
-bool Foam::functionObjects::fieldSelection::resetFieldFilters
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Container>
+bool Foam::functionObjects::fieldSelection::resetFieldFiltersImpl
 (
-    const HashSet<wordRe>& names
+    const Container& names
 )
 {
-    static word cmptStr(".component(");
-    static string::size_type len(cmptStr.size());
+    static std::string cmptStr(".component(");
+    static std::string::size_type len(cmptStr.size());
 
     DynamicList<fieldInfo> nameAndComponent(names.size());
 
     for (const wordRe& name : names)
     {
-        string::size_type n = name.find(cmptStr);
-        if (n != string::npos)
+        const auto n = name.find(cmptStr);
+        if (n != std::string::npos)
         {
             // Field should be written <field>.component(i)
 
@@ -76,12 +77,12 @@ bool Foam::functionObjects::fieldSelection::resetFieldFilters
                     << exit(FatalError);
             }
 
-            word baseName = name.substr(0, n);
+            const word baseName(name.substr(0, n));
 
             // Extract the component - number between ()'s
-            string::size_type closei = name.find(')', n);
+            const auto closei = name.find(')', n);
 
-            if (closei == string::npos)
+            if (closei == std::string::npos)
             {
                 FatalErrorInFunction
                     << "Invalid field component specification for "
@@ -90,18 +91,18 @@ bool Foam::functionObjects::fieldSelection::resetFieldFilters
                     << exit(FatalError);
             }
 
-            string::size_type cmptWidth = closei - n - len;
+            const auto cmptWidth = (closei - n - len);
 
             label component
             (
-                readLabel(IStringStream(name.substr(n+len, cmptWidth))())
+                readLabel(name.substr(n+len, cmptWidth))
             );
 
-            nameAndComponent.append(fieldInfo(wordRe(baseName), component));
+            nameAndComponent.emplace_back(wordRe(baseName), component);
         }
         else
         {
-            nameAndComponent.append(fieldInfo(name));
+            nameAndComponent.emplace_back(name);
         }
     }
 
@@ -111,12 +112,23 @@ bool Foam::functionObjects::fieldSelection::resetFieldFilters
 }
 
 
+bool Foam::functionObjects::fieldSelection::resetFieldFilters
+(
+    const HashSet<wordRe>& names
+)
+{
+    return resetFieldFiltersImpl(names);
+}
+
+
 bool Foam::functionObjects::fieldSelection::resetFieldFilters
 (
     const wordRe& name
 )
 {
-    return resetFieldFilters(HashSet<wordRe>({name}));
+    List<wordRe> names(1, name);
+
+    return resetFieldFiltersImpl(names);
 }
 
 
@@ -124,7 +136,8 @@ bool Foam::functionObjects::fieldSelection::resetFieldFilters
 
 bool Foam::functionObjects::fieldSelection::read(const dictionary& dict)
 {
-    HashSet<wordRe> fields(dict.lookup("fields"));
+    HashSet<wordRe> fields(0);
+    dict.readEntry("fields", fields);
 
     return resetFieldFilters(fields);
 }

src/finiteVolume/functionObjects/fieldSelections/fieldSelection/fieldSelection.H

@@ -39,8 +39,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef functionObjects_fieldSelection_H
-#define functionObjects_fieldSelection_H
+#ifndef Foam_functionObjects_fieldSelection_H
+#define Foam_functionObjects_fieldSelection_H
 
 #include "fieldInfo.H"
 #include "DynamicList.H"
@@ -51,6 +51,7 @@ SourceFiles
 namespace Foam
 {
 
+// Forward Declarations
 class dictionary;
 class objectRegistry;
 
@@ -65,17 +66,19 @@ class fieldSelection
 :
     public List<fieldInfo>
 {
-private:
-
     // Private Member Functions
 
+        //- Reset the field filters to the given field names
+        template<class Container>
+        bool resetFieldFiltersImpl(const Container& names);
+
         //- No copy construct
         fieldSelection(const fieldSelection&) = delete;
 
 
 protected:
 
-    // Protected member data
+    // Protected Member Data
 
         //- Reference to the database
         const objectRegistry& obr_;
@@ -97,7 +100,7 @@ protected:
 public:
 
     //- Construct from object registry
-    fieldSelection
+    explicit fieldSelection
     (
         const objectRegistry& obr,
         const bool includeComponents = false
@@ -110,13 +113,17 @@ public:
 
     // Member Functions
 
-        //- Return the cuurent filters
+        //- The current field selection
+        const List<fieldInfo>& selection() const noexcept
+        {
+            return selection_;
+        }
+
+        //- Return the current filters
         inline HashSet<wordRe> filters() const;
 
-        inline const List<fieldInfo>& selection() const;
-
-        //- Return the current field selection
-        inline wordHashSet selectionNames() const;
+        //- Return the current field selection, in sorted order
+        inline wordList selectionNames() const;
 
         //- Reset the field filters to the given field names
         virtual bool resetFieldFilters(const HashSet<wordRe>& names);

src/finiteVolume/functionObjects/fieldSelections/fieldSelection/fieldSelectionI.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2019-2020 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,36 +25,34 @@ License
 
 \*---------------------------------------------------------------------------*/
 
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
 inline Foam::HashSet<Foam::wordRe>
 Foam::functionObjects::fieldSelection::filters() const
 {
-    HashSet<wordRe> f;
+    HashSet<wordRe> values(2*this->size());
     for (const fieldInfo& fi : *this)
     {
-        f.insert(fi.name());
+        values.insert(fi.name());
     }
 
-    return f;
-}
-
-// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
-
-inline const Foam::List<Foam::functionObjects::fieldInfo>&
-Foam::functionObjects::fieldSelection::selection() const
-{
-    return selection_;
+    return values;
 }
 
 
-inline Foam::wordHashSet
+inline Foam::wordList
 Foam::functionObjects::fieldSelection::selectionNames() const
 {
-    wordHashSet names;
+    DynamicList<word> values(selection_.size());
+
     for (const fieldInfo& fi : selection_)
     {
-        names.insert(fi.name());
+        values.push_uniq(fi.name());
     }
 
+    wordList names(std::move(values));
+    Foam::sort(names);  // Globally consistent order
+
     return names;
 }
 

src/finiteVolume/functionObjects/fieldSelections/fieldSelection/fieldSelectionTemplates.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2019 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -37,15 +37,14 @@ void Foam::functionObjects::fieldSelection::addRegistered
 {
     for (const fieldInfo& fi : *this)
     {
-        wordList names(obr_.names<Type>(fi.name()));
-        if (names.size())
+        const wordList names(obr_.sortedNames<Type>(fi.name()));
+        if (!names.empty())
         {
+            fi.found(true);
+        }
         for (const word& name : names)
         {
-                set.append(fieldInfo(wordRe(name), fi.component()));
-            }
-
-            fi.found() = true;
+            set.emplace_back(wordRe(name), fi.component());
         }
     }
 }

src/finiteVolume/functionObjects/fieldSelections/fileFieldSelection/fileFieldSelection.C

@@ -51,14 +51,13 @@ void Foam::functionObjects::fileFieldSelection::addFromFile
     {
         const wordList names(objects.sortedNames<Type>(fi.name()));
 
-        if (names.size())
+        if (!names.empty())
         {
+            fi.found(true);
+        }
         for (const word& name : names)
         {
-                set.append(fieldInfo(wordRe(name)));
-            }
-
-            fi.found() = true;
+            set.emplace_back(wordRe(name));
         }
     }
 }

src/finiteVolume/functionObjects/fieldSelections/fileFieldSelection/fileFieldSelection.H

@@ -34,8 +34,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef functionObjects_fileFieldSelection_H
-#define functionObjects_fileFieldSelection_H
+#ifndef Foam_functionObjects_fileFieldSelection_H
+#define Foam_functionObjects_fileFieldSelection_H
 
 #include "fieldSelection.H"
 
@@ -91,12 +91,12 @@ class fileFieldSelection
         ) const;
 
 
+public:
+
     //- No copy construct
     fileFieldSelection(const fileFieldSelection&) = delete;
 
 
-public:
-
     // Constructors
 
         //- Construct from object registry

src/finiteVolume/functionObjects/fieldSelections/solverFieldSelection/solverFieldSelection.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -69,11 +69,8 @@ bool Foam::functionObjects::solverFieldSelection::updateSelection()
         {
             if (fi.name().match(solvedField))
             {
-                newSelection.append
-                (
-                    fieldInfo(wordRe(solvedField), fi.component())
-                );
-                fi.found() = true;
+                fi.found(true);
+                newSelection.emplace_back(wordRe(solvedField), fi.component());
             }
         }
     }

src/finiteVolume/functionObjects/fieldSelections/solverFieldSelection/solverFieldSelection.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2019 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -34,8 +34,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef functionObjects_solverFieldSelection_H
-#define functionObjects_solverFieldSelection_H
+#ifndef Foam_functionObjects_solverFieldSelection_H
+#define Foam_functionObjects_solverFieldSelection_H
 
 #include "fieldSelection.H"
 
@@ -54,18 +54,14 @@ class solverFieldSelection
 :
     public fieldSelection
 {
-private:
-
-    // Private Member Functions
+public:
 
     //- No copy construct
     solverFieldSelection(const solverFieldSelection&) = delete;
 
 
-public:
-
     //- Construct from object registry
-    solverFieldSelection
+    explicit solverFieldSelection
     (
         const objectRegistry& obr,
         const bool includeComponents = false

src/finiteVolume/functionObjects/fieldSelections/volFieldSelection/volFieldSelection.H

@@ -34,8 +34,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef functionObjects_volFieldSelection_H
-#define functionObjects_volFieldSelection_H
+#ifndef Foam_functionObjects_volFieldSelection_H
+#define Foam_functionObjects_volFieldSelection_H
 
 #include "fieldSelection.H"
 
@@ -54,14 +54,6 @@ class volFieldSelection
 :
     public fieldSelection
 {
-private:
-
-    // Private Member Functions
-
-        //- No copy construct
-        volFieldSelection(const volFieldSelection&) = delete;
-
-
 protected:
 
     // Protected Member Functions
@@ -73,8 +65,12 @@ protected:
 
 public:
 
+    //- No copy construct
+    volFieldSelection(const volFieldSelection&) = delete;
+
+
     //- Construct from object registry
-    volFieldSelection
+    explicit volFieldSelection
     (
         const objectRegistry& obr,
         const bool includeComponents = false

src/finiteVolume/fvMesh/fvMeshTools/fvMeshToolsTemplates.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2012-2016 OpenFOAM Foundation
-    Copyright (C) 2019-2022 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -41,14 +41,8 @@ void Foam::fvMeshTools::addPatchFields
     const typename GeoField::value_type& defaultPatchValue
 )
 {
-    HashTable<GeoField*> flds
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllIters(flds, iter)
+    for (GeoField& fld : mesh.objectRegistry::sorted<GeoField>())
     {
-        GeoField& fld = *iter.val();
         auto& bfld = fld.boundaryFieldRef();
 
         const label newPatchi = bfld.size();
@@ -95,14 +89,8 @@ void Foam::fvMeshTools::setPatchFields
     const dictionary& patchFieldDict
 )
 {
-    HashTable<GeoField*> flds
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllIters(flds, iter)
+    for (GeoField& fld : mesh.objectRegistry::sorted<GeoField>())
     {
-        GeoField& fld = *iter.val();
         auto& bfld = fld.boundaryFieldRef();
 
         const dictionary* dict = patchFieldDict.findDict(fld.name());
@@ -132,14 +120,8 @@ void Foam::fvMeshTools::setPatchFields
     const typename GeoField::value_type& value
 )
 {
-    HashTable<GeoField*> flds
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllIters(flds, iter)
+    for (GeoField& fld : mesh.objectRegistry::sorted<GeoField>())
     {
-        GeoField& fld = *iter.val();
         auto& bfld = fld.boundaryFieldRef();
 
         bfld[patchi] == value;
@@ -151,15 +133,11 @@ void Foam::fvMeshTools::setPatchFields
 template<class GeoField>
 void Foam::fvMeshTools::trimPatchFields(fvMesh& mesh, const label nPatches)
 {
-    HashTable<GeoField*> flds
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllIters(flds, iter)
+    for (GeoField& fld : mesh.objectRegistry::sorted<GeoField>())
     {
-        GeoField& fld = *iter.val();
-        fld.boundaryFieldRef().resize(nPatches);
+        auto& bfld = fld.boundaryFieldRef();
+
+        bfld.resize(nPatches);
     }
 }
 
@@ -172,14 +150,8 @@ void Foam::fvMeshTools::reorderPatchFields
     const labelList& oldToNew
 )
 {
-    HashTable<GeoField*> flds
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllIters(flds, iter)
+    for (GeoField& fld : mesh.objectRegistry::sorted<GeoField>())
     {
-        GeoField& fld = *iter.val();
         auto& bfld = fld.boundaryFieldRef();
 
         bfld.reorder(oldToNew);

src/functionObjects/field/Curle/Curle.C

@@ -63,7 +63,6 @@ Foam::functionObjects::Curle::Curle
     fvMeshFunctionObject(name, runTime, dict),
     writeFile(mesh_, name),
     pName_("p"),
-    patchSet_(),
     observerPositions_(),
     c0_(0),
     rawFilePtrs_(),
@@ -78,6 +77,8 @@ Foam::functionObjects::Curle::Curle
 
 bool Foam::functionObjects::Curle::read(const dictionary& dict)
 {
+    const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
+
     if (!(fvMeshFunctionObject::read(dict) && writeFile::read(dict)))
     {
         return false;
@@ -85,14 +86,12 @@ bool Foam::functionObjects::Curle::read(const dictionary& dict)
 
     dict.readIfPresent("p", pName_);
 
-    patchSet_ = mesh_.boundaryMesh().patchSet(dict.get<wordRes>("patches"));
+    patchIDs_ = pbm.patchSet(dict.get<wordRes>("patches")).sortedToc();
 
-    if (patchSet_.empty())
+    if (patchIDs_.empty())
     {
         WarningInFunction
-            << "No patches defined"
-            << endl;
-
+            << "No patches defined" << endl;
         return false;
     }
 
@@ -117,8 +116,7 @@ bool Foam::functionObjects::Curle::read(const dictionary& dict)
     if (observerPositions_.empty())
     {
         WarningInFunction
-            << "No observer positions defined"
-            << endl;
+            << "No observer positions defined" << endl;
 
         return false;
     }
@@ -205,7 +203,7 @@ bool Foam::functionObjects::Curle::execute()
 
     scalarField pDash(observerPositions_.size(), 0);
 
-    for (auto patchi : patchSet_)
+    for (const label patchi : patchIDs_)
     {
         const scalarField& pp = pBf[patchi];
         const scalarField& dpdtp = dpdtBf[patchi];
@@ -228,7 +226,7 @@ bool Foam::functionObjects::Curle::execute()
 
     if (surfaceWriterPtr_)
     {
-        if (Pstream::master())
+        if (UPstream::master())
         {
             // Time-aware, with time spliced into the output path
             surfaceWriterPtr_->beginTime(time_);

src/functionObjects/field/Curle/Curle.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2020 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -124,8 +124,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef functionObjects_Curle_H
-#define functionObjects_Curle_H
+#ifndef Foam_functionObjects_Curle_H
+#define Foam_functionObjects_Curle_H
 
 #include "fvMeshFunctionObject.H"
 #include "writeFile.H"
@@ -163,8 +163,8 @@ class Curle
         //- Name of pressure field; default = p
         word pName_;
 
-        //- Patches to integrate forces over
-        labelHashSet patchSet_;
+        //- List of patches to process
+        labelList patchIDs_;
 
         //- Observer positions
         List<point> observerPositions_;

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

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021-2022 OpenCFD Ltd.
+    Copyright (C) 2021-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -122,12 +122,8 @@ Foam::binModel::binModel
     mesh_(mesh),
     decomposePatchValues_(false),
     cumulative_(false),
-    coordSysPtr_(),
-    nBin_(1),
-    patchSet_(),
-    fieldNames_(),
-    cellZoneIDs_(),
-    filePtrs_()
+    coordSysPtr_(nullptr),
+    nBin_(1)
 {}
 
 
@@ -135,19 +131,23 @@ Foam::binModel::binModel
 
 bool Foam::binModel::read(const dictionary& dict)
 {
+    const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
+
     if (!functionObjects::writeFile::read(dict))
     {
         return false;
     }
 
-    patchSet_ = mesh_.boundaryMesh().patchSet(dict.get<wordRes>("patches"));
+    // Can also use pbm.indices(), but no warnings...
+    patchIDs_ = pbm.patchSet(dict.get<wordRes>("patches")).sortedToc();
     fieldNames_ = dict.get<wordHashSet>("fields").sortedToc();
 
-    if (dict.found("cellZones"))
+    wordRes zoneNames;
+    if (dict.readIfPresent("cellZones", zoneNames))
     {
         DynamicList<label> zoneIDs;
         DynamicList<wordRe> czUnmatched;
-        for (const auto& cz : dict.get<wordRes>("cellZones"))
+        for (const auto& cz : zoneNames)
         {
             const labelList czi(mesh_.cellZones().indices(cz));
 
@@ -174,7 +174,7 @@ bool Foam::binModel::read(const dictionary& dict)
 
     decomposePatchValues_ = dict.getOrDefault("decomposePatchValues", false);
 
-    filePtrs_.setSize(fieldNames_.size());
+    filePtrs_.resize(fieldNames_.size());
     forAll(filePtrs_, i)
     {
         filePtrs_.set(i, newFileAtStartTime(fieldNames_[i] + "Bin"));

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

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021-2022 OpenCFD Ltd.
+    Copyright (C) 2021-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -84,7 +84,7 @@ protected:
         label nBin_;
 
         //- Indices of operand patches
-        labelHashSet patchSet_;
+        labelList patchIDs_;
 
         //- Names of operand fields
         wordList fieldNames_;

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

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021-2022 OpenCFD Ltd.
+    Copyright (C) 2021-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -46,46 +46,69 @@ void Foam::binModels::singleDirectionUniformBin::initialise()
 {
     const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
 
-    // Determine extents of patches in a given direction
-    scalar geomMin = GREAT;
-    scalar geomMax = -GREAT;
-    for (const label patchi : patchSet_)
+    // Use geometry limits if not specified by the user
+    const bool useGeomLimits
+    (
+        binLimits_.min() == GREAT
+     || binLimits_.max() == GREAT
+    );
+
+    if (useGeomLimits)
     {
-        const polyPatch& pp = pbm[patchi];
-        const scalarField d(pp.faceCentres() & binDir_);
-        geomMin = min(min(d), geomMin);
-        geomMax = max(max(d), geomMax);
+        // Determine extents of patches/cells in a given direction
+        scalarMinMax geomLimits;
+
+        for (const label patchi : patchIDs_)
+        {
+            for (const vector& p : pbm[patchi].faceCentres())
+            {
+                geomLimits.add(p & binDir_);
+            }
         }
 
         for (const label zonei : cellZoneIDs_)
         {
-        const cellZone& cZone = mesh_.cellZones()[zonei];
-        const vectorField cz(mesh_.C(), cZone);
-        const scalarField d(cz & binDir_);
-
-        geomMin = min(min(d), geomMin);
-        geomMax = max(max(d), geomMax);
+            for (const label celli : mesh_.cellZones()[zonei])
+            {
+                geomLimits.add(mesh_.C()[celli] & binDir_);
+            }
         }
 
-    reduce(geomMin, minOp<scalar>());
-    reduce(geomMax, maxOp<scalar>());
+        // Globally consistent
+        reduce(geomLimits, minMaxOp<scalar>());
+
+        if (!geomLimits.good())
+        {
+            FatalErrorInFunction
+                << "No patches/cellZones provided"
+                << exit(FatalError);
+        }
 
         // Slightly boost max so that region of interest is fully within bounds
-    geomMax = 1.0001*(geomMax - geomMin) + geomMin;
+        // TBD: also adjust min?
+        const scalar adjust(1e-4*geomLimits.span());
+        geomLimits.max() += adjust;
 
         // Use geometry limits if not specified by the user
-    if (binMin_ == GREAT) binMin_ = geomMin;
-    if (binMax_ == GREAT) binMax_ = geomMax;
+        if (binLimits_.min() == GREAT)
+        {
+            binLimits_.min() = geomLimits.min();
+        }
+        if (binLimits_.max() == GREAT)
+        {
+            binLimits_.max() = geomLimits.max();
+        }
+    }
 
-    binDx_ = (binMax_ - binMin_)/scalar(nBin_);
+    binWidth_ = binLimits_.span()/scalar(nBin_);
 
-    if (binDx_ <= 0)
+    if (binWidth_ <= 0)
     {
         FatalErrorInFunction
             << "Max bound must be greater than min bound" << nl
-            << "    d           = " << binDx_ << nl
-            << "    min         = " << binMin_ << nl
-            << "    max         = " << binMax_ << nl
+            << "    d           = " << binWidth_ << nl
+            << "    min         = " << binLimits_.min() << nl
+            << "    max         = " << binLimits_.max() << nl
             << exit(FatalError);
     }
 }
@@ -101,9 +124,8 @@ Foam::binModels::singleDirectionUniformBin::singleDirectionUniformBin
 )
 :
     binModel(dict, mesh, outputPrefix),
-    binDx_(0),
-    binMin_(GREAT),
-    binMax_(GREAT),
+    binWidth_(0),
+    binLimits_(GREAT),
     binDir_(Zero)
 {
     read(dict);
@@ -125,30 +147,30 @@ bool Foam::binModels::singleDirectionUniformBin::read(const dictionary& dict)
 
     nBin_ = binDict.getCheck<label>("nBin", labelMinMax::ge(1));
 
-    Info<< "    Employing " << nBin_ << " bins" << endl;
-    if (binDict.readIfPresent("min", binMin_))
+    Info<< "    Employing " << nBin_ << " bins" << nl;
+
+    if (binDict.readIfPresent("min", binLimits_.min()))
     {
-        Info<< "    - min        : " << binMin_ << endl;
+        Info<< "    - min        : " << binLimits_.min() << nl;
     }
-    if (binDict.readIfPresent("max", binMax_))
+    if (binDict.readIfPresent("max", binLimits_.max()))
     {
-        Info<< "    - max        : " << binMax_ << endl;
+        Info<< "    - max        : " << binLimits_.max() << nl;
     }
 
     cumulative_ = binDict.getOrDefault<bool>("cumulative", false);
-    Info<< "    - cumulative    : " << cumulative_ << endl;
-    Info<< "    - decomposePatchValues    : " << decomposePatchValues_ << endl;
+    Info<< "    - cumulative    : " << cumulative_ << nl
+        << "    - decomposePatchValues    : " << decomposePatchValues_ << nl;
 
     binDir_ = binDict.get<vector>("direction");
-    binDir_.normalise();
-
-    if (mag(binDir_) == 0)
+    if (binDir_.mag() < SMALL)
     {
         FatalIOErrorInFunction(dict)
             << "Input direction should not be zero valued" << nl
             << "    direction = " << binDir_ << nl
             << exit(FatalIOError);
     }
+    binDir_.normalise();
 
     Info<< "    - direction     : " << binDir_ << nl << endl;
 
@@ -163,11 +185,13 @@ void Foam::binModels::singleDirectionUniformBin::apply()
     forAll(fieldNames_, i)
     {
         const bool ok =
+        (
             processField<scalar>(i)
          || processField<vector>(i)
          || processField<sphericalTensor>(i)
          || processField<symmTensor>(i)
-         || processField<tensor>(i);
+         || processField<tensor>(i)
+        );
 
         if (!ok)
         {

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

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021-2022 OpenCFD Ltd.
+    Copyright (C) 2021-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -105,13 +105,10 @@ protected:
     // Protected Data
 
         //- Distance between bin divisions
-        scalar binDx_;
+        scalar binWidth_;
 
-        //- Minimum bin bound
-        scalar binMin_;
-
-        //- Maximum bin bound
-        scalar binMax_;
+        //- The min/max bounds for the bins
+        MinMax<scalar> binLimits_;
 
         //- Binning direction
         vector binDir_;

src/functionObjects/field/binField/binModels/singleDirectionUniformBin/singleDirectionUniformBinTemplates.C

@@ -25,7 +25,6 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-
 template<class Type>
 void Foam::binModels::singleDirectionUniformBin::writeFileHeader
 (
@@ -33,9 +32,9 @@ void Foam::binModels::singleDirectionUniformBin::writeFileHeader
 ) const
 {
     writeHeaderValue(os, "bins", nBin_);
-    writeHeaderValue(os, "start", binMin_);
-    writeHeaderValue(os, "end", binMax_);
-    writeHeaderValue(os, "delta", binDx_);
+    writeHeaderValue(os, "start", binLimits_.min());
+    writeHeaderValue(os, "end", binLimits_.max());
+    writeHeaderValue(os, "delta", binWidth_);
     writeHeaderValue(os, "direction", binDir_);
 
     // Compute and print bin end points in the binning direction
@@ -43,7 +42,7 @@ void Foam::binModels::singleDirectionUniformBin::writeFileHeader
     writeCommented(os, "x co-ords  :");
     forAll(binPoints, pointi)
     {
-        binPoints[pointi] = (binMin_ + (pointi + 1)*binDx_)*binDir_;
+        binPoints[pointi] = (binLimits_.min() + (pointi + 1)*binWidth_)*binDir_;
         os  << tab << binPoints[pointi].x();
     }
     os  << nl;
@@ -80,7 +79,6 @@ void Foam::binModels::singleDirectionUniformBin::writeFileHeader
         {
             writeTabbed(os, writeComponents<Type>("patch" + ibin));
         }
-
     }
 
     os  << endl;
@@ -130,50 +128,57 @@ bool Foam::binModels::singleDirectionUniformBin::processField
     List<List<Type>> data(nField);
     for (auto& binList : data)
     {
-        binList.setSize(nBin_, Zero);
+        binList.resize(nBin_, Zero);
     }
 
+    const auto whichBin = [&](const scalar d) -> label
+    {
+        if (d >= binLimits_.min() && d <= binLimits_.max())
+        {
+            // Find the bin division
+            label bini = floor
+            (
+                (d - binLimits_.min())/binWidth_
+            );
+            return min(max(bini, 0), nBin_ - 1);
+        }
+        else
+        {
+            return -1;
+        }
+    };
+
+
     for (const label zonei : cellZoneIDs_)
     {
         const cellZone& cZone = mesh_.cellZones()[zonei];
 
         for (const label celli : cZone)
         {
-            const scalar dd = mesh_.C()[celli] & binDir_;
+            const label bini = whichBin(mesh_.C()[celli] & binDir_);
 
-            if (dd < binMin_ || dd > binMax_)
+            if (bini >= 0)
             {
-                continue;
-            }
-
-            // Find the bin division corresponding to the cell
-            const label bini =
-                min(max(floor((dd - binMin_)/binDx_), 0), nBin_ - 1);
-
                 data[0][bini] += fld[celli];
             }
         }
+    }
 
-    forAllIters(patchSet_, iter)
+    for (const label patchi : patchIDs_)
     {
-        const label patchi = iter();
         const polyPatch& pp = mesh_.boundaryMesh()[patchi];
         const vectorField np(mesh_.boundary()[patchi].nf());
 
+        const auto& pts = pp.faceCentres();
+
         const scalarField dd(pp.faceCentres() & binDir_);
 
-        forAll(dd, facei)
+        forAll(pts, facei)
         {
-            // Avoid faces outside of the bin
-            if (dd[facei] < binMin_ || dd[facei] > binMax_)
+            const label bini = whichBin(pts[facei] & binDir_);
+
+            if (bini >= 0)
             {
-                continue;
-            }
-
-            // Find the bin division corresponding to the face
-            const label bini =
-                min(max(floor((dd[facei] - binMin_)/binDx_), 0), nBin_ - 1);
-
                 const Type& v = fld.boundaryField()[patchi][facei];
 
                 if (!decomposePatchValues(data, bini, v, np[facei]))
@@ -182,6 +187,7 @@ bool Foam::binModels::singleDirectionUniformBin::processField
                 }
             }
         }
+    }
 
     for (auto& binList : data)
     {

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

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021-2022 OpenCFD Ltd.
+    Copyright (C) 2021-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -45,70 +45,87 @@ void Foam::binModels::uniformBin::initialise()
 {
     const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
 
-    // Determine extents of patches in a given coordinate system
-    vector geomMin(GREAT, GREAT, GREAT);
-    vector geomMax(-GREAT, -GREAT, -GREAT);
-
-    for (const label patchi : patchSet_)
+    // Use geometry limits if not specified by the user
     {
-        const polyPatch& pp = pbm[patchi];
-        const vectorField ppcs(coordSysPtr_->localPosition(pp.faceCentres()));
+        // Determine extents of patches/cells
+        boundBox geomLimits;
 
-        for (direction i = 0; i < vector::nComponents; ++i)
+        for (const label patchi : patchIDs_)
         {
-            geomMin[i] = min(min(ppcs.component(i)), geomMin[i]);
-            geomMax[i] = max(max(ppcs.component(i)), geomMax[i]);
-        }
+            vectorField pts
+            (
+                coordSysPtr_->localPosition(pbm[patchi].faceCentres())
+            );
+
+            MinMax<vector> limits(pts);
+
+            geomLimits.add(limits.min());
+            geomLimits.add(limits.max());
         }
 
         for (const label zonei : cellZoneIDs_)
         {
             const cellZone& cZone = mesh_.cellZones()[zonei];
-        const vectorField d
+            const vectorField pts
             (
                 coordSysPtr_->localPosition(vectorField(mesh_.C(), cZone))
             );
 
-        for (direction i = 0; i < vector::nComponents; ++i)
-        {
-            geomMin[i] = min(min(d.component(i)), geomMin[i]);
-            geomMax[i] = max(max(d.component(i)), geomMax[i]);
-        }
+            MinMax<vector> limits(pts);
+
+            geomLimits.add(limits.min());
+            geomLimits.add(limits.max());
         }
 
-    reduce(geomMin, minOp<vector>());
-    reduce(geomMax, maxOp<vector>());
+        // Globally consistent
+        geomLimits.reduce();
 
-    for (direction i = 0; i < vector::nComponents; ++i)
-    {
         // Slightly boost max so that region of interest is fully within bounds
-        geomMax[i] = 1.0001*(geomMax[i] - geomMin[i]) + geomMin[i];
+        // TBD: could also adjust min?
+        const vector adjust(1e-4*geomLimits.span());
+        geomLimits.max() += adjust;
 
+        for (direction cmpt = 0; cmpt < vector::nComponents; ++cmpt)
+        {
             // Use geometry limits if not specified by the user
-        if (binMinMax_[i][0] == GREAT) binMinMax_[i][0] = geomMin[i];
-        if (binMinMax_[i][1] == GREAT) binMinMax_[i][1] = geomMax[i];
+            if (binLimits_.min()[cmpt] == GREAT)
+            {
+                binLimits_.min()[cmpt] = geomLimits.min()[cmpt];
+            }
+            if (binLimits_.max()[cmpt] == GREAT)
+            {
+                binLimits_.max()[cmpt] = geomLimits.max()[cmpt];
+            }
+        }
+    }
 
-        if (binMinMax_[i][0] > binMinMax_[i][1])
+    for (direction cmpt = 0; cmpt < vector::nComponents; ++cmpt)
+    {
+        if (binLimits_.min()[cmpt] > binLimits_.max()[cmpt])
         {
             FatalErrorInFunction
                 << "Max bounds must be greater than min bounds" << nl
-                << "    direction   = " << i << nl
-                << "    min         = " << binMinMax_[i][0] << nl
-                << "    max         = " << binMinMax_[i][1] << nl
+                << "    direction   = " << cmpt << nl
+                << "    min         = " << binLimits_.min()[cmpt] << nl
+                << "    max         = " << binLimits_.max()[cmpt] << nl
                 << exit(FatalError);
         }
 
         //- Compute bin widths in binning directions
-        binW_[i] = (binMinMax_[i][1] - binMinMax_[i][0])/scalar(nBins_[i]);
+        binWidth_[cmpt] =
+        (
+            (binLimits_.max()[cmpt] - binLimits_.min()[cmpt])
+          / scalar(nBins_[cmpt])
+        );
 
-        if (binW_[i] <= 0)
+        if (binWidth_[cmpt] <= 0)
         {
             FatalErrorInFunction
                 << "Bin widths must be greater than zero" << nl
-                << "    direction = " << i << nl
-                << "    min bound = " << binMinMax_[i][0] << nl
-                << "    max bound = " << binMinMax_[i][1] << nl
-                << "    bin width = " << binW_[i]
+                << "    direction = " << cmpt << nl
+                << "    min bound = " << binLimits_.min()[cmpt] << nl
+                << "    max bound = " << binLimits_.max()[cmpt] << nl
+                << "    bin width = " << binWidth_[cmpt] << nl
                 << exit(FatalError);
         }
     }
@@ -125,9 +142,13 @@ Foam::labelList Foam::binModels::uniformBin::binAddr(const vectorField& d) const
     {
         // Avoid elements outside of the bin
         bool faceInside = true;
-        for (direction j = 0; j < vector::nComponents; ++j)
+        for (direction cmpt = 0; cmpt < vector::nComponents; ++cmpt)
         {
-            if (d[i][j] < binMinMax_[j][0] || d[i][j] > binMinMax_[j][1])
+            if
+            (
+                d[i][cmpt] < binLimits_.min()[cmpt]
+             || d[i][cmpt] > binLimits_.max()[cmpt]
+            )
             {
                 faceInside = false;
                 break;
@@ -138,14 +159,18 @@ Foam::labelList Foam::binModels::uniformBin::binAddr(const vectorField& d) const
         {
             // Find the bin division corresponding to the element
             Vector<label> n(Zero);
-            for (direction j = 0; j < vector::nComponents; ++j)
+            for (direction cmpt = 0; cmpt < vector::nComponents; ++cmpt)
             {
-                n[j] = floor((d[i][j] - binMinMax_[j][0])/binW_[j]);
-                n[j] = min(max(n[j], 0), nBins_[j] - 1);
+                label bini = floor
+                (
+                    (d[i][cmpt] - binLimits_.min()[cmpt])/binWidth_[cmpt]
+                );
+
+                n[cmpt] = min(max(bini, 0), nBins_[cmpt] - 1);
             }
 
             // Order: (e1, e2, e3), the first varies the fastest
-            binIndices[i] = n[0] + nBins_[0]*n[1] + nBins_[0]*nBins_[1]*n[2];
+            binIndices[i] = n.x() + nBins_[0]*n.y() + nBins_[0]*nBins_[1]*n.z();
         }
         else
         {
@@ -159,19 +184,19 @@ Foam::labelList Foam::binModels::uniformBin::binAddr(const vectorField& d) const
 
 void Foam::binModels::uniformBin::setBinsAddressing()
 {
-    faceToBin_.setSize(mesh_.nBoundaryFaces());
+    faceToBin_.resize_nocopy(mesh_.nBoundaryFaces());
     faceToBin_ = -1;
 
-    forAllIters(patchSet_, iter)
+    for (const label patchi : patchIDs_)
     {
-        const polyPatch& pp = mesh_.boundaryMesh()[iter()];
+        const polyPatch& pp = mesh_.boundaryMesh()[patchi];
         const label i0 = pp.start() - mesh_.nInternalFaces();
 
         SubList<label>(faceToBin_, pp.size(), i0) =
             binAddr(coordSysPtr_->localPosition(pp.faceCentres()));
     }
 
-    cellToBin_.setSize(mesh_.nCells());
+    cellToBin_.resize_nocopy(mesh_.nCells());
     cellToBin_ = -1;
 
     for (const label zonei : cellZoneIDs_)
@@ -202,13 +227,8 @@ Foam::binModels::uniformBin::uniformBin
 :
     binModel(dict, mesh, outputPrefix),
     nBins_(Zero),
-    binW_(Zero),
-    binMinMax_
-    (
-        vector2D(GREAT, GREAT),
-        vector2D(GREAT, GREAT),
-        vector2D(GREAT, GREAT)
-    )
+    binWidth_(Zero),
+    binLimits_(vector::uniform(GREAT))
 {
     read(dict);
 }
@@ -238,36 +258,40 @@ bool Foam::binModels::uniformBin::read(const dictionary& dict)
     {
         FatalIOErrorInFunction(binDict)
             << "Number of bins must be greater than zero" << nl
-            << "    e1 bins = " << nBins_[0] << nl
-            << "    e2 bins = " << nBins_[1] << nl
-            << "    e3 bins = " << nBins_[2]
+            << "    e1 bins = " << nBins_.x() << nl
+            << "    e2 bins = " << nBins_.y() << nl
+            << "    e3 bins = " << nBins_.z()
             << exit(FatalIOError);
     }
 
     Info<< "    - Employing:" << nl
-        << "        " << nBins_[0] << " e1 bins," << nl
-        << "        " << nBins_[1] << " e2 bins," << nl
-        << "        " << nBins_[2] << " e3 bins"
+        << "        " << nBins_.x() << " e1 bins," << nl
+        << "        " << nBins_.y() << " e2 bins," << nl
+        << "        " << nBins_.z() << " e3 bins"
         << endl;
 
     cumulative_ = binDict.getOrDefault<bool>("cumulative", false);
     Info<< "    - cumulative    : " << cumulative_ << endl;
     Info<< "    - decomposePatchValues    : " << decomposePatchValues_ << endl;
 
-    if (binDict.found("minMax"))
-    {
-        const dictionary& minMaxDict = binDict.subDict("minMax");
+    const dictionary* minMaxDictPtr = binDict.findDict("minMax");
 
-        for (direction i = 0; i < vector::nComponents; ++i)
+    if (minMaxDictPtr)
     {
-            const word ei("e" + Foam::name(i));
+        const auto& minMaxDict = *minMaxDictPtr;
 
-            if (minMaxDict.readIfPresent(ei, binMinMax_[i]))
+        for (direction cmpt = 0; cmpt < vector::nComponents; ++cmpt)
         {
-                Info<< "    - " << ei << " min        : "
-                    << binMinMax_[i][0] << nl
-                    << "    - " << ei << " max        : "
-                    << binMinMax_[i][1] << endl;
+            const word ei("e" + Foam::name(cmpt));
+
+            scalarMinMax range;
+
+            if (minMaxDict.readIfPresent(ei, range))
+            {
+                binLimits_.min()[cmpt] = range.min();
+                binLimits_.max()[cmpt] = range.max();
+
+                Info<< "    - " << ei << " min/max    : " << range << nl;
             }
         }
     }
@@ -284,17 +308,18 @@ void Foam::binModels::uniformBin::apply()
     forAll(fieldNames_, i)
     {
         const bool ok =
+        (
             processField<scalar>(i)
          || processField<vector>(i)
          || processField<sphericalTensor>(i)
          || processField<symmTensor>(i)
-         || processField<tensor>(i);
+         || processField<tensor>(i)
+        );
 
         if (!ok)
         {
             WarningInFunction
-                << "Unable to find field " << fieldNames_[i]
-                << endl;
+                << "Unable to find field " << fieldNames_[i] << endl;
         }
     }
 

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

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2021-2022 OpenCFD Ltd.
+    Copyright (C) 2021-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -129,10 +129,10 @@ protected:
         Vector<label> nBins_;
 
         //- Equidistant bin widths in binning directions
-        vector binW_;
+        vector binWidth_;
 
-        //- Min-max bounds of bins in binning directions
-        Vector<vector2D> binMinMax_;
+        //- The geometric min/max bounds for the bins
+        MinMax<vector> binLimits_;
 
         //- Face index to bin index addressing
         labelList faceToBin_;

src/functionObjects/field/binField/binModels/uniformBin/uniformBinTemplates.C

@@ -39,9 +39,9 @@ void Foam::binModels::uniformBin::writeFileHeader
     for (direction i = 0; i < vector::nComponents; ++i)
     {
         writeHeaderValue(os, "e" + Foam::name(i) + " bins", nBins_[i]);
-        writeHeaderValue(os, "    start", binMinMax_[i][0]);
-        writeHeaderValue(os, "    end", binMinMax_[i][1]);
-        writeHeaderValue(os, "    delta", binW_[i]);
+        writeHeaderValue(os, "    start", binLimits_.min()[i]);
+        writeHeaderValue(os, "    end", binLimits_.max()[i]);
+        writeHeaderValue(os, "    delta", binWidth_[i]);
         writeHeaderValue(os, "    direction", R.col(i));
     }
     writeCommented(os, "bin end co-ordinates:");
@@ -50,12 +50,12 @@ void Foam::binModels::uniformBin::writeFileHeader
     // Compute and print bin end points in binning directions
     for (direction i = 0; i < vector::nComponents; ++i)
     {
-        scalar binEnd = binMinMax_[i][0];
+        scalar binEnd = binLimits_.min()[i];
 
         writeCommented(os, "e"+Foam::name(i)+" co-ords   :");
         for (label j = 0; j < nBins_[i]; ++j)
         {
-            binEnd += binW_[i];
+            binEnd += binWidth_[i];
             os  << tab << binEnd;
         }
         os  << nl;
@@ -124,7 +124,7 @@ bool Foam::binModels::uniformBin::processField(const label fieldi)
     List<List<Type>> data(nField);
     for (auto& binList : data)
     {
-        binList.setSize(nBin_, Zero);
+        binList.resize(nBin_, Zero);
     }
 
     for (const label zonei : cellZoneIDs_)
@@ -135,16 +135,15 @@ bool Foam::binModels::uniformBin::processField(const label fieldi)
         {
             const label bini = cellToBin_[celli];
 
-            if (bini != -1)
+            if (bini >= 0)
             {
                 data[0][bini] += fld[celli];
             }
         }
     }
 
-    forAllIters(patchSet_, iter)
+    for (const label patchi : patchIDs_)
     {
-        const label patchi = iter();
         const polyPatch& pp = mesh_.boundaryMesh()[patchi];
         const vectorField np(mesh_.boundary()[patchi].nf());
 
@@ -154,7 +153,7 @@ bool Foam::binModels::uniformBin::processField(const label fieldi)
                 pp.start() - mesh_.nInternalFaces() + facei;
             const label bini = faceToBin_[localFacei];
 
-            if (bini != -1)
+            if (bini >= 0)
             {
                 const Type& v = fld.boundaryField()[patchi][facei];
 

src/functionObjects/field/externalCoupled/externalCoupled.C

@@ -568,7 +568,7 @@ bool Foam::functionObjects::externalCoupled::read(const dictionary& dict)
     // Leave trigger intact
 
     // Get names of all fvMeshes (and derived types)
-    wordList allRegionNames(time_.lookupClass<fvMesh>().sortedToc());
+    wordList allRegionNames(time_.sortedNames<fvMesh>());
 
     const dictionary& allRegionsDict = dict.subDict("regions");
     for (const entry& dEntry : allRegionsDict)

src/functionObjects/field/fieldExtents/fieldExtents.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2020 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -111,8 +111,7 @@ Foam::functionObjects::fieldExtents::fieldExtents
     internalField_(true),
     threshold_(0),
     C0_(Zero),
-    fieldSet_(mesh_),
-    patchIDs_()
+    fieldSet_(mesh_)
 {
     read(dict);
 
@@ -125,6 +124,8 @@ Foam::functionObjects::fieldExtents::fieldExtents
 
 bool Foam::functionObjects::fieldExtents::read(const dictionary& dict)
 {
+    const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
+
     if (fvMeshFunctionObject::read(dict) && writeFile::read(dict))
     {
         dict.readIfPresent<bool>("internalField", internalField_);
@@ -133,28 +134,31 @@ bool Foam::functionObjects::fieldExtents::read(const dictionary& dict)
 
         dict.readIfPresent<vector>("referencePosition", C0_);
 
-        patchIDs_.clear();
-        const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
-
         wordRes patchNames;
         if (dict.readIfPresent("patches", patchNames))
         {
-            for (const wordRe& name : patchNames)
-            {
-                patchIDs_.insert(pbm.indices(name));
-            }
+            patchIDs_ = pbm.indices(patchNames);
         }
         else
         {
-            // Add all non-processor and non-empty patches
+            labelHashSet patchSet(2*pbm.size());
+
+            // All non-processor and non-empty patches
             forAll(pbm, patchi)
             {
                 const polyPatch& pp = pbm[patchi];
-                if (!isA<processorPolyPatch>(pp) && !isA<emptyPolyPatch>(pp))
+
+                if
+                (
+                    !isA<processorPolyPatch>(pp)
+                 && !isA<emptyPolyPatch>(pp)
+                )
                 {
-                    patchIDs_.insert(patchi);
+                    patchSet.insert(patchi);
                 }
             }
+
+            patchIDs_ = patchSet.sortedToc();
         }
 
         if (!internalField_ && patchIDs_.empty())