ENH: use objectRegistry/IOobjectList sorted instead of lookupClass

- in most cases a parallel-consistent order is required.
  Even when the order is not important, it will generally require
  fewer allocations to create a UPtrList of entries instead of a
  HashTable or even a wordList.

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/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,
+    const Type& exposedValue
-    PtrList<GeometricField<Type, fvPatchField, volMesh>>& subFields
 )
 {
     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 IOobject& io : fieldObjects)
-    for (const word& fieldName : objects.sortedNames<GeoField>())
     {
-        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 =
+            fvPatchField<Type>& fld = subField.boundaryFieldRef()[patchi];
-                subFields[nFields].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,
+    const Type& exposedValue
-    PtrList<GeometricField<Type, fvsPatchField, surfaceMesh>>& subFields
 )
 {
     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 IOobject& io : fieldObjects)
-    for (const word& fieldName : objects.sortedNames<GeoField>())
     {
-        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 =
+            fvsPatchField<Type>& fld = subField.boundaryFieldRef()[patchi];
-                subFields[nFields].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
+    for (const GeoField& field : mesh.objectRegistry::csorted<GeoField>())
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllIters(fields, fieldIter)
     {
-        GeoField& field = const_cast<GeoField&>(*fieldIter());
+        auto& fieldBf = const_cast<GeoField&>(field).boundaryFieldRef();
-
-        auto& fieldBf = 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));
+        forAll(map, i)
-        for (const label id : set)
         {
-            isSet.set(id);
+            if (set.contains(map[i]))
-        }
-
-        label nSet = 0;
-        for (const label id : map)
-        {
-            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.
-
+    PtrList<volScalarField> scalarFlds
-    wordList scalarNames(objects.sortedNames<volScalarField>());
-    PtrList<volScalarField> scalarFlds(scalarNames.size());
-    subsetVolFields
     (
-        subsetter,
+        subsetVolFields<scalar>
-        objects,
+        (
-        defaultPatchi,
+            subsetter,
-        scalar(Zero),
+            objects,
-        scalarFlds
+            defaultPatchi,
+            scalar(Zero)
+        )
     );
 
-    wordList vectorNames(objects.sortedNames<volVectorField>());
+    PtrList<volVectorField> vectorFlds
-    PtrList<volVectorField> vectorFlds(vectorNames.size());
-    subsetVolFields
     (
-        subsetter,
+        subsetVolFields<vector>
-        objects,
+        (
-        defaultPatchi,
+            subsetter,
-        vector(Zero),
+            objects,
-        vectorFlds
+            defaultPatchi,
+            vector(Zero)
+        )
     );
 
-    wordList sphTensorNames
-    (
-        objects.sortedNames<volSphericalTensorField>()
-    );
     PtrList<volSphericalTensorField> sphTensorFlds
     (
-        sphTensorNames.size()
+        subsetVolFields<sphericalTensor>
-    );
+        (
-    subsetVolFields
+            subsetter,
-    (
+            objects,
-        subsetter,
+            defaultPatchi,
-        objects,
+            sphericalTensor(Zero)
-        defaultPatchi,
+        )
-        sphericalTensor(Zero),
-        sphTensorFlds
     );
 
-    wordList symmTensorNames(objects.sortedNames<volSymmTensorField>());
+    PtrList<volSymmTensorField> symmTensorFlds
-    PtrList<volSymmTensorField> symmTensorFlds(symmTensorNames.size());
-    subsetVolFields
     (
-        subsetter,
+        subsetVolFields<symmTensor>
-        objects,
+        (
-        defaultPatchi,
+            subsetter,
-        symmTensor(Zero),
+            objects,
-        symmTensorFlds
+            defaultPatchi,
+            symmTensor(Zero)
+        )
     );
 
-    wordList tensorNames(objects.sortedNames<volTensorField>());
+    PtrList<volTensorField> tensorFlds
-    PtrList<volTensorField> tensorFlds(tensorNames.size());
-    subsetVolFields
     (
-        subsetter,
+        subsetVolFields<tensor>
-        objects,
+        (
-        defaultPatchi,
+            subsetter,
-        tensor(Zero),
+            objects,
-        tensorFlds
+            defaultPatchi,
+            tensor(Zero)
+        )
     );
 
     // Read surface fields and subset.
-
+    PtrList<surfaceScalarField> surfScalarFlds
-    wordList surfScalarNames(objects.sortedNames<surfaceScalarField>());
-    PtrList<surfaceScalarField> surfScalarFlds(surfScalarNames.size());
-    subsetSurfaceFields
     (
-        subsetter,
+        subsetSurfaceFields<scalar>
-        objects,
+        (
-        defaultPatchi,
+            subsetter,
-        scalar(Zero),
+            objects,
-        surfScalarFlds
+            defaultPatchi,
+            scalar(Zero)
+        )
     );
 
-    wordList surfVectorNames(objects.sortedNames<surfaceVectorField>());
+    PtrList<surfaceVectorField> surfVectorFlds
-    PtrList<surfaceVectorField> surfVectorFlds(surfVectorNames.size());
-    subsetSurfaceFields
     (
-        subsetter,
+        subsetSurfaceFields<vector>
-        objects,
+        (
-        defaultPatchi,
+            subsetter,
-        vector(Zero),
+            objects,
-        surfVectorFlds
+            defaultPatchi,
+            vector(Zero)
+        )
     );
 
-    wordList surfSphTensorNames
-    (
-        objects.sortedNames<surfaceSphericalTensorField>()
-    );
     PtrList<surfaceSphericalTensorField> surfSphericalTensorFlds
     (
-        surfSphTensorNames.size()
+        subsetSurfaceFields<sphericalTensor>
-    );
+        (
-    subsetSurfaceFields
+            subsetter,
-    (
+            objects,
-        subsetter,
+            defaultPatchi,
-        objects,
+            sphericalTensor(Zero)
-        defaultPatchi,
+        )
-        sphericalTensor(Zero),
-        surfSphericalTensorFlds
-    );
-
-    wordList surfSymmTensorNames
-    (
-        objects.sortedNames<surfaceSymmTensorField>()
     );
 
     PtrList<surfaceSymmTensorField> surfSymmTensorFlds
     (
-        surfSymmTensorNames.size()
+        subsetSurfaceFields<symmTensor>
+        (
+            subsetter,
+            objects,
+            defaultPatchi,
+            symmTensor(Zero)
+        )
     );
 
-    subsetSurfaceFields
+    PtrList<surfaceTensorField> surfTensorFlds
     (
-        subsetter,
+        subsetSurfaceFields<tensor>
-        objects,
+        (
-        defaultPatchi,
+            subsetter,
-        symmTensor(Zero),
+            objects,
-        surfSymmTensorFlds
+            defaultPatchi,
-    );
+            tensor(Zero)
-
+        )
-    wordList surfTensorNames(objects.sortedNames<surfaceTensorField>());
-    PtrList<surfaceTensorField> surfTensorFlds(surfTensorNames.size());
-    subsetSurfaceFields
-    (
-        subsetter,
-        objects,
-        defaultPatchi,
-        tensor(Zero),
-        surfTensorFlds
     );
 
 
@@ -1017,62 +1024,8 @@ int main(int argc, char *argv[])
         ++runTime;
     }
 
-    Info<< "Writing mesh without blockedCells to time " << runTime.value()
+    Info<< "Writing mesh without blockedCells to time "
-        << endl;
+        << 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);
-    }
 
     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
+    for (const IOobject& io : objects.csorted<GeoField>())
-    IOobjectList fields(objects.lookupClass<GeoField>());
-
-    forAllConstIters(fields, fieldIter)
     {
-        GeoField fld(*fieldIter(), mesh);
+        GeoField fld(io, mesh);
         Info<< "    Rotating " << fld.name() << endl;
         transform(fld, rotT, fld);
         fld.write();

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
+    for (const GeoField& fld : mesh.objectRegistry::csorted<GeoField>())
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-    forAllConstIters(fields, iter)
     {
-        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] ==
+                tSubFld.ref().boundaryFieldRef()[patchi] == Zero;
-                    typename GeoField::value_type(Zero);
             }
         }
 
@@ -218,14 +211,8 @@ void subsetSurfaceFields
 {
     const labelList patchMap(identity(mesh.boundaryMesh().size()));
 
-    HashTable<const GeoField*> fields
+    for (const GeoField& fld : mesh.objectRegistry::csorted<GeoField>())
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-    forAllConstIters(fields, iter)
     {
-        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] ==
+                tSubFld.ref().boundaryFieldRef()[patchi] == Zero;
-                    typename GeoField::value_type(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
+// Subset DimensionedField/GeometricField
-// in the availableFields hashtable.
 //
-template<class Type, template<class> class PatchField, class GeoMesh>
+template<class FieldType>
-void subsetFields
+PtrList<FieldType> subsetFields
 (
     const fvMeshSubset& subsetter,
-    HashTable<wordHashSet>& availableFields,
+    const IOobjectList& objects
-    PtrList<GeometricField<Type, PatchField, GeoMesh>>& subFields
 )
 {
-    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,
+                IOobjectOption::MUST_READ,
-                IOobject::NO_WRITE
+                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);
+        subField.rename(io.name());
-
-        ++nFields;
     }
 
     if (nFields)
     {
         Info<< ')' << nl;
     }
+
+    return subFields;
 }
 
 
-template<class Type>
+// Subset point fields
-void subsetPointFields
+template<class FieldType>
+PtrList<FieldType> subsetFields
 (
     const fvMeshSubset& subsetter,
-    const pointMesh& pMesh,
+    const IOobjectList& objects,
-    HashTable<wordHashSet>& availableFields,
+    const pointMesh& pMesh
-    PtrList<GeometricField<Type, pointPatchField, pointMesh>>& subFields
 )
 {
-    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,
+                IOobjectOption::MUST_READ,
-                IOobject::NO_WRITE
+                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);
+        subField.rename(io.name());
-
-        ++nFields;
     }
 
     if (nFields)
     {
         Info<< ')' << nl;
     }
-}
 
-
+    return subFields;
-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;
-    }
 }
 
 
@@ -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 "
+        FixedList<label, 2> cellCount;
-            << returnReduce(subsetter.subMesh().nCells(), sumOp<label>())
+        cellCount[0] = subsetter.subMesh().nCells();
-            << " of "
+        cellCount[1] = mesh.nCells();
-            << returnReduce(mesh.nCells(), sumOp<label>())
+        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
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~
-
+    createSubsetFields(volScalarField, vScalarFlds);
-    PtrList<volScalarField> vScalarFlds;
+    createSubsetFields(volVectorField, vVectorFlds);
-    subsetFields(subsetter, availableFields, vScalarFlds);
+    createSubsetFields(volSphericalTensorField, vSphTensorFlds);
-
+    createSubsetFields(volSymmTensorField, vSymmTensorFlds);
-    PtrList<volVectorField> vVectorFlds;
+    createSubsetFields(volTensorField, vTensorFlds);
-    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);
-
 
     // Read surface fields and subset
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    createSubsetFields(surfaceScalarField, sScalarFlds);
+    createSubsetFields(surfaceVectorField, sVectorFlds);
+    createSubsetFields(surfaceSphericalTensorField, sSphTensorFlds);
+    createSubsetFields(surfaceSymmTensorField, sSymmTensorFlds);
+    createSubsetFields(surfaceTensorField, sTensorFlds);
 
-    PtrList<surfaceScalarField> sScalarFlds;
+    // Read dimensioned fields and subset
-    subsetFields(subsetter, availableFields, sScalarFlds);
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
+    createSubsetFields(volScalarField::Internal, dScalarFlds);
-    PtrList<surfaceVectorField> sVectorFlds;
+    createSubsetFields(volVectorField::Internal, dVectorFlds);
-    subsetFields(subsetter, availableFields, sVectorFlds);
+    createSubsetFields(volSphericalTensorField::Internal, dSphTensorFlds);
-
+    createSubsetFields(volSymmTensorField::Internal, dSymmTensorFlds);
-    PtrList<surfaceSphericalTensorField> sSphTensorFlds;
+    createSubsetFields(volTensorField::Internal, dTensorFlds);
-    subsetFields(subsetter, availableFields, sSphTensorFlds);
-
-    PtrList<surfaceSymmTensorField> sSymmTensorFlds;
-    subsetFields(subsetter, availableFields, sSymmTensorFlds);
-
-    PtrList<surfaceTensorField> sTensorFlds;
-    subsetFields(subsetter, availableFields, sTensorFlds);
 
 
     // Read point fields and subset
@@ -623,39 +572,20 @@ int main(int argc, char *argv[])
 
     const pointMesh& pMesh = pointMesh::New(mesh);
 
-    PtrList<pointScalarField> pScalarFlds;
+    #undef  createSubsetFields
-    subsetPointFields(subsetter, pMesh, availableFields, pScalarFlds);
+    #define createSubsetFields(FieldType, Variable)             \
+    PtrList<FieldType> Variable                                 \
+    (                                                           \
+        subsetFields<FieldType>(subsetter, objects, pMesh)      \
+    );
 
-    PtrList<pointVectorField> pVectorFlds;
+    createSubsetFields(pointScalarField, pScalarFlds);
-    subsetPointFields(subsetter, pMesh, availableFields, pVectorFlds);
+    createSubsetFields(pointVectorField, pVectorFlds);
+    createSubsetFields(pointSphericalTensorField, pSphTensorFlds);
+    createSubsetFields(pointSymmTensorField, pSymmTensorFlds);
+    createSubsetFields(pointTensorField, pTensorFlds);
 
-    PtrList<pointSphericalTensorField> pSphTensorFlds;
+    #undef createSubsetFields
-    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);
 
 
     // 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
+        const IOobjectList objects(mesh, runTime.timeName());
-        (
+
-            IOobjectList(mesh, runTime.timeName()).sortedNames()
+        Info<< "Reading fields:" << endl;
+
+        // Read fields
+        #undef  createFields
+        #define createFields(FieldType, Variable)                   \
+        PtrList<FieldType> Variable                                 \
+        (                                                           \
+            readFields<FieldType>(objects, mesh)                    \
         );
 
-        PtrList<volScalarField> vsf(objNames.size());
+        createFields(volScalarField, vsf);
-        PtrList<volVectorField> vvf(objNames.size());
+        createFields(volVectorField, vvf);
-        PtrList<volSphericalTensorField> vsptf(objNames.size());
+        createFields(volSphericalTensorField, vsptf);
-        PtrList<volSymmTensorField> vsytf(objNames.size());
+        createFields(volSymmTensorField, vsytf);
-        PtrList<volTensorField> vtf(objNames.size());
+        createFields(volTensorField, vtf);
 
-        PtrList<pointScalarField> psf(objNames.size());
+        // Point fields
-        PtrList<pointVectorField> pvf(objNames.size());
+        const pointMesh& pMesh = pointMesh::New(mesh);
-        PtrList<pointSphericalTensorField> psptf(objNames.size());
-        PtrList<pointSymmTensorField> psytf(objNames.size());
-        PtrList<pointTensorField> ptf(objNames.size());
 
-        Info<< "Valid fields:" << endl;
+        #undef  createFields
+        #define createFields(FieldType, Variable)                   \
+        PtrList<FieldType> Variable                                 \
+        (                                                           \
+            readFields<FieldType>(objects, pMesh)                   \
+        );
 
-        forAll(objNames, objI)
+        createFields(pointScalarField, psf);
-        {
+        createFields(pointVectorField, pvf);
-            IOobject obj
+        createFields(pointSphericalTensorField, psptf);
-            (
+        createFields(pointSymmTensorField, psytf);
-                objNames[objI],
+        createFields(pointTensorField, ptf);
-                runTime.timeName(),
-                mesh,
-                IOobject::MUST_READ
-            );
 
-            if (obj.typeHeaderOk<volScalarField>(false))
+        #undef createFields
-            {
-                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);
-
-                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));
-            }
-        }
 
         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());
+                    for (const label patchi : nonGroupPatches.sortedToc())
-                    forAll(sortedPatches, i)
                     {
-                        Info<< bm[sortedPatches[i]].type()
+                        Info<< bm[patchi].type()
-                            << "\t: " << bm[sortedPatches[i]].name() << nl;
+                            << "\t: " << bm[patchi].name() << nl;
                     }
-                    if (groups.size())
+                    for (const word& groupName : groups)
                     {
-                        forAll(groups, i)
+                        Info<< "group\t: " << groupName << nl;
-                        {
-                            Info<< "group\t: " << groups[i] << 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]);
+                    const label patchi = patchIDs[0];
-                    outputFieldList(pvf, patchIDs[0]);
+
-                    outputFieldList(psptf, patchIDs[0]);
+                    outputFieldList(vsf, patchi);
-                    outputFieldList(psytf, patchIDs[0]);
+                    outputFieldList(vvf, patchi);
-                    outputFieldList(ptf, patchIDs[0]);
+                    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 IOobjectList& objects,
-    const IOobject& obj,
-    const label fieldi,
     const typename GeoField::Mesh& mesh
 )
 {
-    if (obj.isHeaderClass<GeoField>())
+    const UPtrList<const IOobject> fieldObjects
+    (
+        objects.csorted<GeoField>()
+    );
+
+    PtrList<GeoField> fields(fieldObjects.size());
+
+    label nFields = 0;
+    for (const IOobject& io : fieldObjects)
     {
-        fieldList.set
+        if (!nFields)
-        (
+        {
-            fieldi,
+            Info<< "    " << GeoField::typeName << " (";
-            new GeoField(obj, mesh)
+        }
-        );
+        else
-        Info<< "    " << GeoField::typeName << tab << obj.name() << endl;
+        {
+            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
+#ifndef Foam_patchSummaryTemplates_H
-#define 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,
-        const typename GeoField::Mesh& mesh
-    );
 
-    template<class GeoField>
+template<class GeoField>
-    void outputFieldList
+PtrList<GeoField> readFields
-    (
+(
-        const PtrList<GeoField>& fieldList,
+    const IOobjectList& objects,
-        const label patchi
+    const typename GeoField::Mesh& mesh
-    );
+);
+
+template<class GeoField>
+void outputFieldList
+(
+    const UPtrList<GeoField>& fieldList,
+    const label patchi
+);
+
+template<class GeoField>
+void collectFieldList
+(
+    const UPtrList<GeoField>& fieldList,
+    const label patchi,
+    HashTable<word>& fieldToType
+);
 
-    template<class GeoField>
-    void collectFieldList
-    (
-        const PtrList<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>());
+            cellSets.emplace_back(io);
-            forAllConstIters(sets, iter)
-            {
-                cellSets.append(new cellSet(*(iter.val())));
-            }
         }
+        for (const IOobject& io : objects.csorted<faceSet>())
         {
-            IOobjectList sets(objects.lookupClass<faceSet>());
+            faceSets.emplace_back(io);
-            forAllConstIters(sets, iter)
-            {
-                faceSets.append(new faceSet(*(iter.val())));
-            }
         }
+        for (const IOobject& io : objects.csorted<pointSet>())
         {
-            IOobjectList sets(objects.lookupClass<pointSet>());
+            pointSets.emplace_back(io);
-            forAllConstIters(sets, iter)
-            {
-                pointSets.append(new pointSet(*(iter.val())));
-            }
         }
     }
 
@@ -219,9 +210,9 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
             facesInstance(),
             polyMesh::meshSubDir,
             *this,
-            IOobject::READ_IF_PRESENT,
+            IOobjectOption::READ_IF_PRESENT,
-            IOobject::NO_WRITE,
+            IOobjectOption::NO_WRITE,
-            IOobject::NO_REGISTER
+            IOobjectOption::NO_REGISTER
         )
     );
 

applications/utilities/parallelProcessing/reconstructPar/reconstructPar.C

@@ -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());
                     }
                 }
 

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 =
-    (
-        selectedFields.empty()
-      ? objects.sortedNames<fieldType>()
-      : objects.sortedNames<fieldType>(selectedFields)
-    );
-
     label nFields = 0;
-    for (const word& fieldName : fieldNames)
+    for
+    (
+        const IOobject& io :
+        (
+            selectedFields.empty()
+          ? 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 =
-    (
-        selectedFields.empty()
-      ? objects.sortedNames<fieldType>()
-      : objects.sortedNames<fieldType>(selectedFields)
-    );
-
     label nFields = 0;
-    for (const word& fieldName : fieldNames)
+    for
+    (
+        const IOobject& io :
+        (
+            selectedFields.empty()
+          ? 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 =
-    (
-        selectedFields.empty()
-      ? objects.sortedNames<fieldType>()
-      : objects.sortedNames<fieldType>(selectedFields)
-    );
-
     label nFields = 0;
-    for (const word& fieldName : fieldNames)
+    for
+    (
+        const IOobject& io :
+        (
+            selectedFields.empty()
+          ? 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/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,
+                IOobjectOption::MUST_READ,
-                IOobject::NO_WRITE
+                IOobjectOption::NO_WRITE,
+                IOobjectOption::NO_REGISTER
             )
         );
 
@@ -115,44 +117,21 @@ int main(int argc, char *argv[])
         IOobjectList objects(mesh, runTime.timeName());
 
 
-        // volScalarField
+        readFieldsAndWriteFluent<volScalarField>
-        for (const word& fieldName : objects.sortedNames<volScalarField>())
+        (
-        {
+            foamDataToFluentDict,
-            // Lookup field from dictionary and convert field
+            objects,
-            label unitNumber;
+            mesh,
-            if
+            fluentDataFile
-            (
+        );
-                foamDataToFluentDict.readIfPresent(fieldName, unitNumber)
-             && unitNumber > 0
-            )
-            {
-                // Read field
-                volScalarField field(*(objects[fieldName]), mesh);
 
-                Info<< "    Converting field " << fieldName << nl;
+        readFieldsAndWriteFluent<volVectorField>
-                writeFluentField(field, unitNumber, fluentDataFile);
+        (
-            }
+            foamDataToFluentDict,
-        }
+            objects,
-
+            mesh,
-
+            fluentDataFile
-        // volVectorField
+        );
-        for (const word& fieldName : objects.sortedNames<volVectorField>())
-        {
-            // Lookup field from dictionary and convert field
-            label unitNumber;
-            if
-            (
-                foamDataToFluentDict.readIfPresent(fieldName, unitNumber)
-             && unitNumber > 0
-            )
-            {
-                // Read field
-                volVectorField field(*(objects[fieldName]), mesh);
-
-                Info<< "    Converting field " << fieldName << nl;
-                writeFluentField(field, unitNumber, fluentDataFile);
-            }
-        }
 
         Info<< endl;
     }

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

@@ -28,10 +28,12 @@ InClass
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef writeFluentFields_H
+#ifndef Foam_writeFluentFields_H
-#define 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 Foam::writeFluentField
-{
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void 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 Foam::writeFluentField
-{
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-void 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() << " "
+            << val.x() << ' ' << val.y() << ' ' << val.z() << nl;
-            << phiInternal[celli].y() << " "
-            << phiInternal[celli].z() << " "
-            << endl;
     }
 
     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() << " "
+                << val.x() << ' ' << val.y() << ' ' << val.z() << nl;
-                << patchPhi[facei].y() << " "
-                << patchPhi[facei].z() << " "
-                << endl;
         }
 
         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
+#ifndef ensight_readFields_H
-#define 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
+    // Objects of wanted type
-    IOobjectList fieldObjects(objects.lookupClass(ReadGeoField::typeName));
+    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()
+        Info<< "Converting "
-            << endl;
+            << 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,
+                    IOobjectOption::NO_READ,
-                    IOobject::AUTO_WRITE,
+                    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.readOpt(IOobjectOption::NO_READ);
-            newIO.writeOpt(IOobject::NO_WRITE);
+            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,24 +108,12 @@ 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);
+        Info<< "        reading field " << io.name() << endl;
+        IOField<Type> field(io);
 
-        if (!io)
+        writeVTKField<Type>(os, field, addr);
-        {
-            FatalErrorInFunction
-                << "Could not read field:" << fldName
-                << " type:" << IOField<Type>::typeName
-                << abort(FatalError);
-        }
-        else
-        {
-            Info<< "        reading field " << fldName << 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;
+    label nFields = 0;
-
+    for
-    const wordList fieldNames =
     (
-        selectedFields_.empty()
+        const IOobject& io :
-      ? objects_.sortedNames(clsName)
+        (
-      : objects_.sortedNames(clsName, selectedFields_)
+            selectedFields_.empty()
-    );
+          ? objects_.csorted<GeoFieldType>()
-
+          : objects_.csorted<GeoFieldType>(selectedFields_)
-    if (fieldNames.size())
+        )
+    )
     {
-        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/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
+        rewriteFields(volScalarField);
-        (
+        rewriteFields(volVectorField);
-            dryrun,
+        rewriteFields(volSphericalTensorField);
-            runTime,
+        rewriteFields(volSymmTensorField);
-            objects.names(volScalarField::typeName),
+        rewriteFields(volTensorField);
-            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
-        );
-
 
         // pointFields
         // ~~~~~~~~~~~
 
-        rewriteFields
+        rewriteFields(pointScalarField);
-        (
+        rewriteFields(pointVectorField);
-            dryrun,
+        rewriteFields(pointSphericalTensorField);
-            runTime,
+        rewriteFields(pointSymmTensorField);
-            objects.names(pointScalarField::typeName),
+        rewriteFields(pointTensorField);
-            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
-        );
 
 
         // surfaceFields
-        // ~~~~~~~~~~~
+        // ~~~~~~~~~~~~~
 
-        rewriteFields
+        rewriteFields(surfaceScalarField);
-        (
+        rewriteFields(surfaceVectorField);
-            dryrun,
+        rewriteFields(surfaceSphericalTensorField);
-            runTime,
+        rewriteFields(surfaceSymmTensorField);
-            objects.names(surfaceScalarField::typeName),
+        rewriteFields(surfaceTensorField);
-            thisNames,
+
-            nbrNames
+        #undef rewriteFields
-        );
-        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
-        );
 
         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);
+    for (const IOobject& io : objects.csorted<fieldType>())
-
-    forAllConstIters(fields, fieldIter)
     {
-        Info<< "    interpolating " << (*fieldIter)->name()
+        Info<< "    interpolating " << io.name() << endl;
-            << 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,
+            IOobjectOption::MUST_READ,
-            IOobject::AUTO_WRITE
+            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
+#ifndef Foam_MapLagrangianFields_H
-#define 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();
 
-    {
+    MapLagrangianFields
-        IOobjectList fields = objects.lookupClass(IOField<Type>::typeName);
+    <
+        IOField<Type>,
+        IOField<Type>
+    >
+    (
+        cloudName,
+        objects,
+        meshToMesh0Interp,
+        addParticles,
+        "Field"
+    );
 
-        forAllConstIters(fields, fieldIter)
+    // Target is CompactIOField to automatically write in
-        {
+    // compact form for binary format.
-            Info<< "    mapping lagrangian field "
+    MapLagrangianFields
-                << (*fieldIter)->name() << endl;
+    <
+        IOField<Field<Type>>,
+        CompactIOField<Field<Type>, Type>
+    >
+    (
+        cloudName,
+        objects,
+        meshToMesh0Interp,
+        addParticles,
+        "FieldField"
+    );
 
-            // Read field (does not need mesh)
+    MapLagrangianFields
-            IOField<Type> fieldSource(*fieldIter());
+    <
-
+        CompactIOField<Field<Type>, Type>,
-            // Map
+        CompactIOField<Field<Type>, Type>
-            IOField<Type> fieldTarget
+    >
-            (
+    (
-                IOobject
+        cloudName,
-                (
+        objects,
-                    (*fieldIter)->name(),
+        meshToMesh0Interp,
-                    meshTarget.time().timeName(),
+        addParticles,
-                    cloud::prefix/cloudName,
+        "FieldField"
-                    meshTarget,
+    );
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE,
-                    IOobject::NO_REGISTER
-                ),
-                addParticles.size()
-            );
-
-            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
-            // compact form for binary format.
-            CompactIOField<Field<Type>, Type> fieldTarget
-            (
-                IOobject
-                (
-                    (*fieldIter)->name(),
-                    meshTarget.time().timeName(),
-                    cloud::prefix/cloudName,
-                    meshTarget,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE,
-                    IOobject::NO_REGISTER
-                ),
-                addParticles.size()
-            );
-
-            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
-            (
-                IOobject
-                (
-                    (*fieldIter)->name(),
-                    meshTarget.time().timeName(),
-                    cloud::prefix/cloudName,
-                    meshTarget,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE,
-                    IOobject::NO_REGISTER
-                ),
-                addParticles.size()
-            );
-
-            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);
+    for (const IOobject& io : objects.csorted<fieldType>())
-
-    forAllConstIters(fields, fieldIter)
     {
         IOobject fieldTargetIOobject
         (
-            (*fieldIter)->name(),
+            io.name(),
             meshTarget.time().timeName(),
             meshTarget,
-            IOobject::MUST_READ,
+            IOobjectOption::MUST_READ,
-            IOobject::AUTO_WRITE
+            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);
+    for (const IOobject& io : objects.csorted<Type>())
-
-    forAllConstIters(fields, fieldIter)
     {
-        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
+#ifndef Foam_MapLagrangianFields_H
-#define 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
 )
 {
-    {
+    MapLagrangianFields
-        IOobjectList fields = objects.lookupClass(IOField<Type>::typeName);
+    <
+        IOField<Type>,
+        IOField<Type>
+    >
+    (
+        cloudName,
+        objects,
+        meshTarget,
+        addParticles,
+        "Field"
+    );
 
-        forAllConstIters(fields, fieldIter)
+    // Target is CompactIOField to automatically write in
-        {
+    // compact form for binary format.
-            const word& fieldName = (*fieldIter)->name();
+    MapLagrangianFields
+    <
+        IOField<Field<Type>>,
+        CompactIOField<Field<Type>, Type>
+    >
+    (
+        cloudName,
+        objects,
+        meshTarget,
+        addParticles,
+        "FieldField"
+    );
 
-            Info<< "    mapping lagrangian field " << fieldName << endl;
+    MapLagrangianFields
-
+    <
-            // Read field (does not need mesh)
+        CompactIOField<Field<Type>, Type>,
-            IOField<Type> fieldSource(*fieldIter());
+        CompactIOField<Field<Type>, Type>
-
+    >
-            // Map
+    (
-            IOField<Type> fieldTarget
+        cloudName,
-            (
+        objects,
-                IOobject
+        meshTarget,
-                (
+        addParticles,
-                    fieldName,
+        "FieldField"
-                    meshTarget.time().timeName(),
+    );
-                    cloud::prefix/cloudName,
-                    meshTarget,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE,
-                    IOobject::NO_REGISTER
-                ),
-                addParticles.size()
-            );
-
-            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
-            // compact form for binary format.
-            CompactIOField<Field<Type>, Type> fieldTarget
-            (
-                IOobject
-                (
-                    fieldName,
-                    meshTarget.time().timeName(),
-                    cloud::prefix/cloudName,
-                    meshTarget,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE,
-                    IOobject::NO_REGISTER
-                ),
-                min(fieldSource.size(), addParticles.size()) // handle 0 size
-            );
-
-            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
-            (
-                IOobject
-                (
-                    fieldName,
-                    meshTarget.time().timeName(),
-                    cloud::prefix/cloudName,
-                    meshTarget,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE,
-                    IOobject::NO_REGISTER
-                ),
-                min(fieldSource.size(), addParticles.size()) // handle 0 size
-            );
-
-            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
     (
-        selectedFields.empty()
+        const IOobject& io :
-      ? objects.sortedNames<fieldType>()
+        (
-      : objects.sortedNames<fieldType>(selectedFields)
+            selectedFields.empty()
-    );
+          ? objects.csorted<fieldType>()
-
+          : objects.csorted<fieldType>(selectedFields)
-    for (const word& fieldName : fieldNames)
+        )
+    )
     {
-        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);
+    for (const IOobject& io : objects.csorted<Type>())
-
-    forAllConstIters(fields, fieldIter)
     {
-        mvBak((*fieldIter)->objectPath(), "unmapped");
+        mvBak(io.objectPath(), "unmapped");
     }
 }
 

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()
+                Info<< "Mapping "
-                    << endl;
+                    << 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
+        mapper.thisDb().objectRegistry::template csorted<FieldType>()
-            lookupClass<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()
+                Info<< "Mapping "
-                    << endl;
+                    << 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/ReadFieldsTemplates.C

@@ -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,
+                    IOobjectOption::MUST_READ,
-                    IOobject::AUTO_WRITE,
+                    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,
+                    IOobjectOption::MUST_READ,
-                    IOobject::AUTO_WRITE,
+                    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,
+                    IOobjectOption::MUST_READ,
-                    IOobject::AUTO_WRITE,
+                    IOobjectOption::AUTO_WRITE,
                     io.registerObject()
                 )
             )
@@ -235,9 +235,9 @@ void Foam::ReadFields
                     timeName,
                     timeName,
                     fieldsCache,
-                    IOobject::NO_READ,
+                    IOobjectOption::NO_READ,
-                    IOobject::NO_WRITE,
+                    IOobjectOption::NO_WRITE,
-                    IOobject::REGISTER
+                    IOobjectOption::REGISTER
                 )
             );
             timeCachePtr->store();
@@ -260,9 +260,9 @@ void Foam::ReadFields
                     fieldName,
                     timeName,
                     mesh.thisDb(),
-                    IOobject::MUST_READ,
+                    IOobjectOption::MUST_READ,
-                    IOobject::NO_WRITE,
+                    IOobjectOption::NO_WRITE,
-                    IOobject::NO_REGISTER
+                    IOobjectOption::NO_REGISTER
                 ),
                 mesh
             );
@@ -275,9 +275,9 @@ void Foam::ReadFields
                     fieldName,
                     timeName,
                     timeCache,
-                    IOobject::NO_READ,
+                    IOobjectOption::NO_READ,
-                    IOobject::NO_WRITE,
+                    IOobjectOption::NO_WRITE,
-                    IOobject::REGISTER
+                    IOobjectOption::REGISTER
                 ),
                 loadedFld
             );
@@ -318,39 +318,37 @@ void Foam::readFields
     DynamicList<regIOobject*>& storedObjects
 )
 {
-    // Names of GeoField objects, sorted order. Not synchronised.
+    // GeoField objects, sorted order. Not synchronised.
-    const wordList fieldNames
+    const UPtrList<const IOobject> fieldObjects
     (
-        objects.sortedNames<GeoFieldType>(selectedFields)
+        objects.csorted<GeoFieldType>(selectedFields)
     );
 
 
     // pre-extend reserve
-    storedObjects.reserve(storedObjects.size() + fieldNames.size());
+    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,
+                IOobjectOption::MUST_READ,
-                IOobject::NO_WRITE,
+                IOobjectOption::NO_WRITE,
-                IOobject::REGISTER
+                IOobjectOption::REGISTER
             ),
             mesh
         );
@@ -373,38 +371,36 @@ void Foam::readUniformFields
     const bool syncPar
 )
 {
-    // Names of UniformField objects, sorted order.
+    // UniformField objects, sorted order, synchronised.
-    const wordList fieldNames
+    const UPtrList<const IOobject> fieldObjects
     (
-        objects.names<UniformFieldType>(selectedFields, syncPar)
+        objects.csorted<UniformFieldType>(selectedFields, syncPar)
     );
 
     // pre-extend reserve
-    storedObjects.reserve(storedObjects.size() + fieldNames.size());
+    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,
+                IOobjectOption::MUST_READ,
-                IOobject::NO_WRITE,
+                IOobjectOption::NO_WRITE,
-                IOobject::REGISTER
+                IOobjectOption::REGISTER
             )
         );
         fieldPtr->store();

src/OpenFOAM/fields/cloud/mapClouds.H

@@ -34,8 +34,8 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef mapClouds_H
+#ifndef Foam_mapClouds_H
-#define 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>());
+    for (const cloud& c : db.csorted<cloud>())
-
-    forAllIters(clouds, iter)
     {
-        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()
+                    << " in any of the meshes in "
-                    << endl
+                    << 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/parallel/fieldsDistributor/fieldsDistributorTemplates.C

@@ -68,7 +68,7 @@ void Foam::fieldsDistributor::readFields
     const UPtrList<const IOobject> fieldObjects(objects.csorted<GeoField>());
 
     // Construct the fields
-    fields.resize(fieldObjects.size());
+    fields.resize_null(fieldObjects.size());
 
     forAll(fieldObjects, i)
     {
@@ -89,7 +89,7 @@ void Foam::fieldsDistributor::readFields
     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 (!field.ownedByRegistry())
-
-                if (!fld.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;
 
-
+            auto& phiBf = phi.boundaryFieldRef();
-            surfaceScalarField& phi = *iter();
-            surfaceScalarField::Boundary& 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;
+                << sFld.name()<< endl;
-
-            GeoField& sFld = *iter();
 
             if (sFld.is_oriented())
             {
                 WarningInFunction << "Ignoring mapping oriented field "
-                    << sFld.name() << " since of type " << sFld.type()
+                    << sFld.name() << " since of type " << sFld.type() << endl;
-                    << endl;
             }
             else
             {
@@ -141,36 +137,34 @@ void Foam::dynamicRefineFvMesh::mapNewInternalFaces
 )
 {
     typedef GeometricField<T, fvsPatchField, surfaceMesh> GeoField;
-    HashTable<GeoField*> sFlds(this->objectRegistry::lookupClass<GeoField>());
 
-    forAllIters(sFlds, iter)
+    typedef GeometricField
+    <
+        typename outerProduct<vector, T>::type,
+        fvsPatchField,
+        surfaceMesh
+    > NormalGeoField;
+
+
+    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;
+                << sFld.name() << endl;
-
-            GeoField& sFld = *iter();
 
             if (sFld.is_oriented())
             {
                 DebugInfo
                     << "dynamicRefineFvMesh::mapNewInternalFaces(): "
-                    << "Converting oriented field " << iter.key()
+                    << "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.
 
-                typedef GeometricField
-                <
-                    typename outerProduct<vector, T>::type,
-                    fvsPatchField,
-                    surfaceMesh
-                > NormalGeoField;
-
                 // 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>()
+        mesh.objectRegistry::csorted<fldType>()
-    );
-
-    HashTable<const fldType*> fieldsToAdd
-    (
-        meshToAdd.objectRegistry::lookupClass<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()
+                << "MapVolFields : mapping " << field.name() << endl;
-                << " and " << fldToAdd.name() << endl;
 
-            MapVolField<Type>(meshMap, fld, fldToAdd, fullyMapped);
+            MapVolField<Type>(meshMap, fld, *toAdd, fullyMapped);
         }
         else
         {
             WarningInFunction
-                << "Not mapping field " << fld.name()
+                << "Not mapping field " << field.name()
-                << " since not present on mesh to add" << endl;
+                << " - 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>()
+        mesh.objectRegistry::csorted<fldType>()
-    );
-
-    HashTable<const fldType*> fieldsToAdd
-    (
-        meshToAdd.objectRegistry::lookupClass<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();
     }
 
-
+    for (const auto& field : fields)
-    forAllIters(fields, fieldIter)
     {
-        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()
+                << "MapSurfaceFields : mapping " << field.name() << endl;
-                << " and " << fldToAdd.name() << endl;
 
-            MapSurfaceField<Type>(meshMap, fld, fldToAdd, fullyMapped);
+            MapSurfaceField<Type>(meshMap, fld, *toAdd, fullyMapped);
         }
         else
         {
             WarningInFunction
-                << "Not mapping field " << fld.name()
+                << "Not mapping field " << field.name()
-                << " since not present on mesh to add" << endl;
+                << " - 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
+    // NB: strict=true to avoid picking up volFields
-    //       volFields
+    const UPtrList<const fldType> fields
-    HashTable<const fldType*> fields
     (
-        mesh.objectRegistry::lookupClass<fldType>(true)
+        mesh.objectRegistry::csorted<fldType, true>()
     );
 
-    HashTable<const fldType*> fieldsToAdd
+    for (const auto& field : fields)
-    (
-        meshToAdd.objectRegistry::lookupClass<fldType>(true)
-    );
-
-    forAllIters(fields, fieldIter)
     {
-        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()
+                << "MapDimFields : mapping " << field.name() << endl;
-                << " and " << fldToAdd.name() << endl;
 
-            MapDimField<Type>(meshMap, fld, fldToAdd);
+            MapDimField<Type>(meshMap, fld, *toAdd);
         }
         else
         {
             WarningInFunction
-                << "Not mapping field " << fld.name()
+                << "Not mapping field " << field.name()
-                << " since not present on mesh to add" << endl;
+                << " - 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()
+            << "MapVolFields : Storing old time for "
-            << endl;
+            << 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,39 +1169,31 @@ 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& field : fields)
-    for (const auto& fld : fields)
     {
-        if (!isA<excludeType>(*fld))
+        const word& name0 = field.name();
+
+        DebugPout
+            << "MapDimFields : mapping " << name0 << endl;
+
+        UPtrList<fldType> meshToField(meshes.size());
+        forAll(meshes, meshi)
         {
-            const word& name0 = fld->name();
+            if (meshes.set(meshi))
-
-            DebugPout
-                << "MapDimFields : mapping " << name0 << endl;
-
-            UPtrList<fldType> meshToField(meshes.size());
-            forAll(meshes, meshi)
             {
-                if (meshes.set(meshi))
+                auto& meshFld = meshes[meshi].
-                {
+                    objectRegistry::lookupObjectRef<fldType>(name0);
-                    auto& meshFld = meshes[meshi].
+                meshToField.set(meshi, &meshFld);
-                        objectRegistry::lookupObjectRef<fldType>(name0);
-                    meshToField.set(meshi, &meshFld);
-                }
             }
+        }
 
-            MapDimField(meshToField, cellProcAddressing, fullyMapped);
+        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()
+            << "MapSurfaceFields : Storing old time for "
-            << endl;
+            << 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
+    for (const GeoField& field : mesh.objectRegistry::csorted<GeoField>())
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllConstIters(flds, iter)
     {
-        const GeoField& fld = *iter();
+        if (!isA<excludeType>(field))
-        if (!isA<excludeType>(fld))
         {
-            Pout<< "Field:" << iter.key() << " internalsize:" << fld.size()
+            Pout<< "Field:" << field.name() << " size:" << field.size()
-                //<< " value:" << fld
+                //<< " 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
+    for (const GeoField& field : mesh.objectRegistry::csorted<GeoField>())
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllConstIters(flds, iter)
     {
-        const GeoField& fld = *iter();
+        Pout<< "Field:" << field.name() << " size:" << field.size()
-
+            //<< " value:" << field
-        Pout<< "Field:" << iter.key() << " internalsize:" << fld.size()
-            //<< " value:" << fld
             << 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;
+    label fieldi = 0;
-    forAllConstIters(flds, iter)
+    for (const fldType& fld : flds)
     {
-        const fldType& fld = *iter();
+        bflds.set(fieldi, fld.boundaryField().clone());
 
-        bflds.set(i, fld.boundaryField().clone());
+        ++fieldi;
-
-        ++i;
     }
 }
 
@@ -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;
+    forAll(flds, fieldi)
-
-    forAllIters(flds, iter)
     {
-        fldType& fld = *iter();
+        auto& bfld = flds[fieldi].boundaryFieldRef();
-        auto& bfld = fld.boundaryFieldRef();
+        const auto& oldBfld = oldBflds[fieldi];
-
-        const FieldField<fvsPatchField, T>& 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;
+    forAll(fields, fieldi)
-
-    forAllConstIters(flds, iter)
     {
-        const fldType& fld = *iter();
+        iflds.set(fieldi, fields[fieldi].primitiveField().clone());
-
-        iflds.set(i, fld.primitiveField().clone());
-
-        ++i;
     }
 }
 
@@ -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;
+    forAll(flds, fieldi)
-
-    forAllIters(flds, iter)
     {
-        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
+    for (GeoField& fld : mesh_.objectRegistry::objects<GeoField>())
-    (
-        mesh_.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllIters(flds, iter)
     {
-        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
+//    for (GeoField& fld : mesh_.objectRegistry::sorted<GeoField>())
-//    (
-//        mesh_.objectRegistry::lookupClass<GeoField>()
-//    );
-//
-//    forAllIters(flds, iter)
 //    {
-//        GeoField& fld = *iter();
 //        fld.correctBoundaryConditions();
 //    }
 //}
@@ -377,19 +339,23 @@ void Foam::fvMeshDistribute::getFieldNames
 
     if (!excludeType.empty())
     {
-        const wordList& excludeList = allFieldNames(excludeType);
+        const wordList& excludeList =
+            allFieldNames.lookup(excludeType, wordList::null());
 
-        DynamicList<word> newList(list.size());
+        if (!excludeList.empty())
-        for(const auto& name : list)
         {
-            if (!excludeList.found(name))
+            DynamicList<word> newList(list.size());
+            for (const auto& name : list)
             {
-                newList.append(name);
+                if (!excludeList.contains(name))
+                {
+                    newList.push_back(name);
+                }
+            }
+            if (newList.size() < list.size())
+            {
+                list = std::move(newList);
             }
-        }
-        if (newList.size() < list.size())
-        {
-            list = std::move(newList);
         }
     }
 

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>());
+    for (const IOobject& io : objs.csorted<SetType>())
-
-    forAllConstIters(fileSets, iter)
     {
-        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 =
+    for (const SetType& set : oldMesh.objectRegistry::csorted<SetType>())
-        oldMesh.objectRegistry::lookupClass<const SetType>();
-
-    forAllConstIters(sets, iter)
     {
-        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
+        //- Update all sets of the given type
-        template<class Type>
+        template<class SetType>
-        void updateSets(const mapPolyMesh& morphMap) const;
+        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>
+template<class SetType>
-void Foam::setUpdater::updateSets(const mapPolyMesh& morphMap) const
+void Foam::setUpdater::updateSets(const mapPolyMesh& map)
 {
     //
-    // Update all sets in memory.
+    // Update all sets in memory
     //
 
-    HashTable<const Type*> memSets =
+    const HashTable<const SetType*> sets
-        morphMap.mesh().objectRegistry::lookupClass<Type>();
+    (
+        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(),
+        map.mesh().time(),
-        morphMap.mesh().facesInstance(),
+        map.mesh().facesInstance(),
         "polyMesh/sets"
     );
 
-    IOobjectList fileSets(objs.lookupClass<Type>());
+    for (const IOobject& io : objs.csorted<SetType>())
-
-    forAllConstIters(fileSets, iter)
     {
-        if (!memSets.found(iter.key()))
+        if (!sets.contains(io.name()))
         {
             // Not in memory. Load it.
-            Type set(*iter());
+            SetType set(io);
 
-            if (debug)
+            DebugPout
-            {
+                << "Set:" << set.name() << " size:" << set.size()
-                Pout<< "Set:" << set.name() << " size:" << set.size()
+                << " updated on disk" << endl;
-                    << " updated on disk" << endl;
-            }
-
-            set.updateMesh(morphMap);
 
+            set.updateMesh(map);
             set.write();
         }
         else
         {
             DebugPout
-                << "Set:" << iter.key() << " already updated from memory"
+                << "Set:" << io.name()
-                << endl;
+                << " 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()
+            Info<< field.size() << '\t' << field.name() << nl;
-                << '\t' << fieldName
-                << nl;
         }
         Info<< endl;
     }

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>());
+    for (GeoField& fld : mesh_.objectRegistry::sorted<GeoField>())
-
-    forAllIters(flds, iter)
     {
-        GeoField& fld = *iter();
-
         const word& fldName = fld.name();
 
         if (!fldName.contains("PrevIter") && mesh_.relaxField(fldName))

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
+    for (GeoField& fld : mesh.objectRegistry::sorted<GeoField>())
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllIters(flds, iter)
     {
-        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
+    for (GeoField& fld : mesh.objectRegistry::sorted<GeoField>())
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllIters(flds, iter)
     {
-        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
+    for (GeoField& fld : mesh.objectRegistry::sorted<GeoField>())
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllIters(flds, iter)
     {
-        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
+    for (GeoField& fld : mesh.objectRegistry::sorted<GeoField>())
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllIters(flds, iter)
     {
-        GeoField& fld = *iter.val();
+        auto& bfld = fld.boundaryFieldRef();
-        fld.boundaryFieldRef().resize(nPatches);
+
+        bfld.resize(nPatches);
     }
 }
 
@@ -172,14 +150,8 @@ void Foam::fvMeshTools::reorderPatchFields
     const labelList& oldToNew
 )
 {
-    HashTable<GeoField*> flds
+    for (GeoField& fld : mesh.objectRegistry::sorted<GeoField>())
-    (
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllIters(flds, iter)
     {
-        GeoField& fld = *iter.val();
         auto& bfld = fld.boundaryFieldRef();
 
         bfld.reorder(oldToNew);

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/mapFields/mapFieldsTemplates.C

@@ -119,14 +119,12 @@ bool Foam::functionObjects::mapFields::mapFieldType() const
 
     const fvMesh& mapRegion = mapRegionPtr_();
 
-    wordList fieldNames(this->mesh_.names(VolFieldType::typeName));
+    wordList fieldNames(this->mesh_.sortedNames<VolFieldType>(fieldNames_));
 
-    const labelList selected(fieldNames_.matching(fieldNames));
+    const bool processed = !fieldNames.empty();
 
-    for (const label fieldi : selected)
+    for (const word& fieldName : fieldNames)
     {
-        const word& fieldName = fieldNames[fieldi];
-
         const VolFieldType& field = lookupObject<VolFieldType>(fieldName);
 
         auto* mapFieldPtr = mapRegion.getObjectPtr<VolFieldType>(fieldName);
@@ -159,7 +157,7 @@ bool Foam::functionObjects::mapFields::mapFieldType() const
         evaluateConstraintTypes(mappedField);
     }
 
-    return !selected.empty();
+    return processed;
 }
 
 
@@ -170,14 +168,12 @@ bool Foam::functionObjects::mapFields::writeFieldType() const
 
     const fvMesh& mapRegion = mapRegionPtr_();
 
-    wordList fieldNames(this->mesh_.names(VolFieldType::typeName));
+    wordList fieldNames(this->mesh_.sortedNames<VolFieldType>(fieldNames_));
 
-    const labelList selected(fieldNames_.matching(fieldNames));
+    const bool processed = !fieldNames.empty();
 
-    for (const label fieldi : selected)
+    for (const word& fieldName : fieldNames)
     {
-        const word& fieldName = fieldNames[fieldi];
-
         const VolFieldType& mappedField =
             mapRegion.template lookupObject<VolFieldType>(fieldName);
 
@@ -186,7 +182,7 @@ bool Foam::functionObjects::mapFields::writeFieldType() const
         Log << "    " << fieldName << ": written";
     }
 
-    return !selected.empty();
+    return processed;
 }
 
 

src/functionObjects/field/nearWallFields/nearWallFieldsTemplates.C

@@ -38,15 +38,13 @@ void Foam::functionObjects::nearWallFields::createFields
 {
     typedef GeometricField<Type, fvPatchField, volMesh> VolFieldType;
 
-    HashTable<const VolFieldType*> flds(obr_.lookupClass<VolFieldType>());
+    for (const VolFieldType& fld : obr_.csorted<VolFieldType>())
-
-    forAllConstIters(flds, iter)
     {
-        const VolFieldType& fld = *(iter.val());
+        const auto fieldMapIter = fieldMap_.cfind(fld.name());
 
-        if (fieldMap_.found(fld.name()))
+        if (fieldMapIter.good())
         {
-            const word& sampleFldName = fieldMap_[fld.name()];
+            const word& sampleFldName = fieldMapIter.val();
 
             if (obr_.found(sampleFldName))
             {
@@ -57,19 +55,18 @@ void Foam::functionObjects::nearWallFields::createFields
             }
             else
             {
-                label sz = sflds.size();
-                sflds.setSize(sz+1);
-
                 IOobject io(fld);
-                io.readOpt(IOobject::NO_READ);
+                io.readOpt(IOobjectOption::NO_READ);
-                io.writeOpt(IOobject::NO_WRITE);
+                io.writeOpt(IOobjectOption::NO_WRITE);
-
                 io.rename(sampleFldName);
 
                 // Override bc to be calculated
+                const label newFieldi = sflds.size();
+                sflds.resize(newFieldi+1);
+
                 sflds.set
                 (
-                    sz,
+                    newFieldi,
                     new VolFieldType
                     (
                         io,
@@ -79,7 +76,7 @@ void Foam::functionObjects::nearWallFields::createFields
                     )
                 );
 
-                Log << "    created " << sflds[sz].name()
+                Log << "    created " << io.name()
                     << " to sample " << fld.name() << endl;
             }
         }

src/functionObjects/field/particleDistribution/particleDistribution.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.
@@ -107,7 +107,9 @@ bool Foam::functionObjects::particleDistribution::write()
 {
     Log << type() << " " << name() << " output:" << endl;
 
-    if (!mesh_.foundObject<cloud>(cloudName_))
+    const cloud* cloudPtr = mesh_.cfindObject<cloud>(cloudName_);
+
+    if (!cloudPtr)
     {
         WarningInFunction
             << "Unable to find cloud " << cloudName_
@@ -117,7 +119,7 @@ bool Foam::functionObjects::particleDistribution::write()
         return false;
     }
 
-    const cloud& c = mesh_.lookupObject<cloud>(cloudName_);
+    const cloud& c = *cloudPtr;
 
     objectRegistry cloudObr
     (

src/functionObjects/field/regionSizeDistribution/regionSizeDistribution.C

@@ -907,16 +907,15 @@ bool Foam::functionObjects::regionSizeDistribution::write()
         {
             for
             (
-                const word& fldName
+                const volScalarField& vfield
-              : obr_.sortedNames<volScalarField>(fields_)
+              : obr_.csorted<volScalarField>(fields_)
             )
             {
+                const word& fldName = vfield.name();
+
                 Log << "    Scalar field " << fldName << endl;
 
-                tmp<Field<scalar>> tfld
+                tmp<Field<scalar>> tfld(vfield.primitiveField());
-                (
-                    obr_.lookupObject<volScalarField>(fldName).primitiveField()
-                );
                 const auto& fld = tfld();
 
                 writeGraphs
@@ -938,23 +937,21 @@ bool Foam::functionObjects::regionSizeDistribution::write()
         {
             for
             (
-                const word& fldName
+                const volVectorField& vfield
-              : obr_.sortedNames<volVectorField>(fields_)
+              : obr_.csorted<volVectorField>(fields_)
             )
             {
+                const word& fldName = vfield.name();
+
                 Log << "    Vector field " << fldName << endl;
 
-                tmp<Field<vector>> tfld
+                tmp<Field<vector>> tfld(vfield.primitiveField());
-                (
-                    obr_.lookupObject<volVectorField>(fldName).primitiveField()
-                );
 
                 if (csysPtr_)
                 {
                     Log << "Transforming vector field " << fldName
                         << " with coordinate system "
-                        << csysPtr_->name()
+                        << csysPtr_->name() << endl;
-                        << endl;
 
                     tfld = csysPtr_->localVector(tfld());
                 }

src/functionObjects/field/setFlow/setFlow.C

@@ -84,7 +84,7 @@ void Foam::functionObjects::setFlow::setPhi(const volVectorField& U)
             FatalErrorInFunction
                 << "Unable to find rho field'" << rhoName_
                 << "' in the mesh database.  Available fields are:"
-                << mesh_.names<volScalarField>()
+                << flatOutput(mesh_.sortedNames<volScalarField>())
                 << exit(FatalError);
         }
     }

src/functionObjects/field/surfaceInterpolate/surfaceInterpolateTemplates.C

@@ -45,12 +45,8 @@ void Foam::functionObjects::surfaceInterpolate::interpolateFields()
     }
 
 
-    HashTable<const VolFieldType*> flds(obr_.lookupClass<VolFieldType>());
+    for (const VolFieldType& fld : obr_.csorted<VolFieldType>())
-
-    forAllConstIters(flds, iter)
     {
-        const VolFieldType& fld = *iter();
-
         if (fieldMap.found(fld.name()))
         {
             // const word sName = "interpolate(" + fld.name() + ')';
@@ -62,8 +58,8 @@ void Foam::functionObjects::surfaceInterpolate::interpolateFields()
             }
             else
             {
-                Log << "        interpolating " << fld.name() << " to create "
+                Log << "        interpolating "
-                    << sName << endl;
+                    << fld.name() << " to create " << sName << endl;
             }
 
             store(sName, linearInterpolate(fld));

src/functionObjects/forces/forces/forces.C

@@ -756,7 +756,10 @@ void Foam::functionObjects::forces::calcForcesMoments()
         const volScalarField rho(this->rho());
         const volScalarField mu(this->mu());
 
-        const auto models = obr_.lookupClass<porosityModel>();
+        const UPtrList<const porosityModel> models
+        (
+            obr_.csorted<porosityModel>()
+        );
 
         if (models.empty())
         {
@@ -766,10 +769,10 @@ void Foam::functionObjects::forces::calcForcesMoments()
                 << endl;
         }
 
-        forAllConstIters(models, iter)
+        for (const porosityModel& mdl : models)
         {
             // Non-const access required if mesh is changing
-            auto& pm = const_cast<porosityModel&>(*iter());
+            auto& pm = const_cast<porosityModel&>(mdl);
 
             const vectorField fPTot(pm.force(U, rho, mu));
 

src/functionObjects/forces/propellerInfo/propellerInfo.C

@@ -220,7 +220,7 @@ const Foam::volVectorField& Foam::functionObjects::propellerInfo::U() const
         FatalErrorInFunction
             << "Unable to find velocity field " << UName_
             << " . Available vector fields are: "
-            << mesh_.names<volVectorField>()
+            << flatOutput(mesh_.sortedNames<volVectorField>())
             << exit(FatalError);
     }
 

src/mesh/snappyHexMesh/meshRefinement/meshRefinementTemplates.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2019-2020 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -203,26 +203,22 @@ void Foam::meshRefinement::addPatchFields
     const word& patchFieldType
 )
 {
-    HashTable<GeoField*> flds
+    // Field order is irrelevant...
-    (
+    for (GeoField& fld : mesh.objectRegistry::objects<GeoField>())
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllIters(flds, iter)
     {
-        GeoField& fld = *iter();
+        auto& bfld = fld.boundaryFieldRef();
-        auto& fldBf = fld.boundaryFieldRef();
 
-        label sz = fldBf.size();
+        const label newPatchi = bfld.size();
-        fldBf.setSize(sz+1);
+        bfld.resize(newPatchi+1);
-        fldBf.set
+
+        bfld.set
         (
-            sz,
+            newPatchi,
             GeoField::Patch::New
             (
                 patchFieldType,
-                mesh.boundary()[sz],
+                mesh.boundary()[newPatchi],
-                fld()
+                fld.internalField()
             )
         );
     }
@@ -236,14 +232,10 @@ void Foam::meshRefinement::reorderPatchFields
     const labelList& oldToNew
 )
 {
-    HashTable<GeoField*> flds
+    // Field order is irrelevant...
-    (
+    for (GeoField& fld : mesh.objectRegistry::objects<GeoField>())
-        mesh.objectRegistry::lookupClass<GeoField>()
-    );
-
-    forAllIters(flds, iter)
     {
-        iter()->boundaryFieldRef().reorder(oldToNew);
+        fld.boundaryFieldRef().reorder(oldToNew);
     }
 }
 

src/overset/cellCellStencil/cellCellStencil/cellCellStencilTemplates.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.
@@ -116,10 +116,10 @@ void Foam::cellCellStencil::interpolate
 {
     const cellCellStencil& overlap = *this;
 
-    auto flds(mesh.lookupClass<GeoField>());
+    for (const GeoField& field : mesh.thisDb().csorted<GeoField>())
-    for (auto fldPtr : flds)
     {
-        const word& name = fldPtr->name();
+        const word& name = field.name();
+
         if (!suppressed.found(baseName(name)))
         {
             if (debug)
@@ -128,7 +128,7 @@ void Foam::cellCellStencil::interpolate
                     << name << endl;
             }
 
-            auto& fld = const_cast<GeoField&>(*fldPtr);
+            auto& fld = const_cast<GeoField&>(field);
 
             interpolate
             (
@@ -142,8 +142,8 @@ void Foam::cellCellStencil::interpolate
         {
             if (debug)
             {
-                Pout<< "cellCellStencil::interpolate: skipping : " << name
+                Pout<< "cellCellStencil::interpolate: skipping : "
-                    << endl;
+                    << name << endl;
             }
         }
     }

src/parallel/distributed/distributedTriSurfaceMesh/distributedTriSurfaceMeshTemplates.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2013 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -88,15 +88,8 @@ void Foam::distributedTriSurfaceMesh::distributeFields
 {
     typedef DimensionedField<Type, triSurfaceGeoMesh> fieldType;
 
-    HashTable<fieldType*> fields
+    for (fieldType& field : objectRegistry::sorted<fieldType>())
-    (
-        objectRegistry::lookupClass<fieldType>()
-    );
-
-    forAllIters(fields, fieldIter)
     {
-        fieldType& field = *fieldIter();
-
         const label oldSize = field.size();
 
         map.distribute(field);

src/regionFaModels/functionObjects/setTimeStep/setTimeStepFaRegionsFunctionObject.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2020 OpenCFD Ltd.
+    Copyright (C) 2020-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -114,25 +114,20 @@ bool Foam::functionObjects::setTimeStepFaRegionsFunctionObject::read
 Foam::scalar Foam::functionObjects::setTimeStepFaRegionsFunctionObject::
 regionDeltaT() const
 {
-    const wordList names(time_.sortedNames<regionFaModel>());
+    bool adjust = false;
+    scalar Co = 0;
 
-    scalar Co = 0.0;
+    for (const regionFaModel& reg : time_.cobjects<regionFaModel>())
-
-    forAll (names, i)
     {
-        const auto* regionFa = time_.cfindObject<regionFaModel>(names[i]);
+        const scalar regionCo = reg.CourantNumber();
-
+        if (Co < regionCo)
-        if (regionFa)
         {
-            const scalar regionCo = regionFa->CourantNumber();
+            Co = regionCo;
-            if (regionCo > Co)
+            adjust = true;
-            {
-                Co = regionCo;
-            }
         }
     }
 
-    if (names.size() > 0)
+    if (adjust)
     {
         const scalar regionFaMaxCo =
             time_.controlDict().get<scalar>("regionFaMaxCo");

src/regionModels/regionCoupling/derivedFvPatchFields/filmPyrolysisRadiativeCoupledMixed/filmPyrolysisRadiativeCoupledMixedFvPatchScalarField.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2013-2017 OpenFOAM Foundation
-    Copyright (C) 2019-2020 OpenCFD Ltd.
+    Copyright (C) 2019-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -41,21 +41,25 @@ const filmPyrolysisRadiativeCoupledMixedFvPatchScalarField::filmModelType&
 filmPyrolysisRadiativeCoupledMixedFvPatchScalarField::
 filmModel() const
 {
-    HashTable<const filmModelType*> models
+    typedef filmModelType ModelType;
-        = db().time().lookupClass<filmModelType>();
 
-    forAllConstIters(models, iter)
+    const UPtrList<const ModelType> models
+    (
+        db().time().csorted<ModelType>()
+    );
+
+    for (const ModelType& mdl : models)
     {
-        if (iter()->regionMesh().name() == filmRegionName_)
+        if (mdl.regionMesh().name() == filmRegionName_)
         {
-            return *iter();
+            return mdl;
         }
     }
 
-    DynamicList<word> modelNames;
+    DynamicList<word> modelNames(models.size());
-    forAllConstIters(models, iter)
+    for (const ModelType& mdl : models)
     {
-        modelNames.append(iter()->regionMesh().name());
+        modelNames.push_back(mdl.regionMesh().name());
     }
 
     FatalErrorInFunction
@@ -63,7 +67,7 @@ filmModel() const
         << ".  Available regions include: " << modelNames
         << abort(FatalError);
 
-    return **models.begin();
+    return models.front();  // Failure
 }
 
 
@@ -72,21 +76,25 @@ pyrolysisModelType&
 filmPyrolysisRadiativeCoupledMixedFvPatchScalarField::
 pyrModel() const
 {
-    HashTable<const pyrolysisModelType*> models =
+    typedef pyrolysisModelType ModelType;
-        db().time().lookupClass<pyrolysisModelType>();
 
-    forAllConstIters(models, iter)
+    const UPtrList<const ModelType> models
+    (
+        db().time().csorted<ModelType>()
+    );
+
+    for (const ModelType& mdl : models)
     {
-        if (iter()->regionMesh().name() == pyrolysisRegionName_)
+        if (mdl.regionMesh().name() == pyrolysisRegionName_)
         {
-            return *iter();
+            return mdl;
         }
     }
 
-    DynamicList<word> modelNames;
+    DynamicList<word> modelNames(models.size());
-    forAllConstIters(models, iter)
+    for (const ModelType& mdl : models)
     {
-        modelNames.append(iter()->regionMesh().name());
+        modelNames.push_back(mdl.regionMesh().name());
     }
 
     FatalErrorInFunction
@@ -94,7 +102,7 @@ pyrModel() const
         << ".  Available regions include: " << modelNames
         << abort(FatalError);
 
-    return **models.begin();
+    return models.front();  // Failure
 }
 
 

src/regionModels/regionCoupling/derivedFvPatchFields/filmPyrolysisRadiativeCoupledMixed/filmPyrolysisRadiativeCoupledMixedFvPatchScalarField.H

@@ -113,7 +113,7 @@ public:
 
 private:
 
-    // Private data
+    // Private Data
 
         //- Name of film region
         const word filmRegionName_;
@@ -136,10 +136,13 @@ private:
         //- Maximum delta film to be considered wet
         const scalar filmDeltaWet_;
 
-        //- Retrieve film model from the database
+
+    // Private Member Functions
+
+        //- Retrieve film model from the database, or FatalError
         const filmModelType& filmModel() const;
 
-        //- Retrieve pyrolysis model from the database
+        //- Retrieve pyrolysis model from the database, or FatalError
         const pyrolysisModelType& pyrModel() const;
 
 

src/sampling/sampledSet/sampledSets/sampledSets.C

@@ -155,8 +155,7 @@ void Foam::sampledSets::gatherAllSets()
 
     const PtrList<sampledSet>& localSets = *this;
 
-    gatheredSets_.free();
+    gatheredSets_.resize_null(localSets.size());
-    gatheredSets_.resize(localSets.size());
     gatheredSorting_.resize_nocopy(localSets.size());
     globalIndices_.resize_nocopy(localSets.size());
 

src/thermophysicalModels/basic/basicThermo/basicThermo.C

@@ -456,29 +456,26 @@ const Foam::basicThermo& Foam::basicThermo::lookupThermo
     const fvPatchScalarField& pf
 )
 {
-    const basicThermo* thermo = pf.db().findObject<basicThermo>(dictName);
+    const basicThermo* thermoPtr = pf.db().cfindObject<basicThermo>(dictName);
 
-    if (thermo)
+    if (thermoPtr)
     {
-        return *thermo;
+        return *thermoPtr;
     }
 
-    HashTable<const basicThermo*> thermos =
+    for (const basicThermo& thermo : pf.db().cobjects<basicThermo>())
-        pf.db().lookupClass<basicThermo>();
-
-    forAllConstIters(thermos, iter)
     {
-        thermo = iter.val();
         if
         (
-            &(thermo->he().internalField())
+            &(thermo.he().internalField())
          == &(pf.internalField())
         )
         {
-            return *thermo;
+            return thermo;
         }
     }
 
+    // Failure
     return pf.db().lookupObject<basicThermo>(dictName);
 }