src/catalyst/areaMesh/catalystFaMesh.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2019 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -59,22 +59,22 @@ void Foam::catalyst::faMeshInput::update()
     // Backend requires a corresponding mesh
     backends_.filterKeys
     (
-        [this](const word& k){ return meshes_.found(k); }
+        [this](const word& k){ return meshes_.contains(k); }
     );
 
     forAllConstIters(meshes_, iter)
     {
-        const word& areaName(iter.key());
+        const word& name = iter.key();
+        const auto* mesh = iter.val();
 
-        if (!backends_.found(areaName))
+        if (!backends_.contains(name))
         {
-            auto backend =
-                autoPtr<Foam::vtk::faMeshAdaptor>::New(*(iter.val()));
+            auto backend = autoPtr<Foam::vtk::faMeshAdaptor>::New(*mesh);
 
             // Apply any configuration options
             // ...
 
-            backends_.set(areaName, backend);
+            backends_.set(name, backend);
         }
     }
 }
@@ -111,14 +111,22 @@ bool Foam::catalyst::faMeshInput::read(const dictionary& dict)
     selectFields_.clear();
     backends_.clear();
 
-    regionName_ =
-        dict.lookupOrDefault<word>("region", polyMesh::defaultRegion);
+    regionName_ = dict.getOrDefault<word>("region", polyMesh::defaultRegion);
 
-    const objectRegistry& obr =
-        time_.lookupObject<objectRegistry>(regionName_);
+    const polyMesh& pMesh = time_.lookupObject<polyMesh>(regionName_);
 
-    // All possible meshes for the given region
-    meshes_ = obr.lookupClass<faMesh>();
+    // Registry containing all finite-area meshes on the polyMesh
+    const auto* faRegistry = faMesh::registry(pMesh);
+
+    if (faRegistry)
+    {
+        // All possible meshes for the given region
+        meshes_ = faRegistry->lookupClass<faMesh>();
+    }
+    else
+    {
+        meshes_.clear();
+    }
 
     dict.readIfPresent("areas", selectAreas_);
 
@@ -127,18 +135,18 @@ bool Foam::catalyst::faMeshInput::read(const dictionary& dict)
         word areaName;
         if (!dict.readIfPresent("area", areaName))
         {
-            wordList available = obr.sortedNames<faMesh>();
+            wordList available = meshes_.sortedToc();
 
-            if (available.size())
+            if (!available.empty())
             {
-                areaName = available.first();
+                areaName = available.front();
             }
         }
 
         if (!areaName.empty())
         {
             selectAreas_.resize(1);
-            selectAreas_.first() = areaName;
+            selectAreas_.front() = areaName;
         }
     }
 
@@ -155,15 +163,21 @@ void Foam::catalyst::faMeshInput::update(polyMesh::readUpdateState state)
 {
     // Trigger change of state
 
-    const objectRegistry& obr =
-        time_.lookupObject<objectRegistry>(regionName_);
+    const polyMesh& pMesh = time_.lookupObject<polyMesh>(regionName_);
+
+    // Registry containing all finite-area meshes on the polyMesh
+    const auto* faRegistry = faMesh::registry(pMesh);
 
     // Be really paranoid and verify if the mesh actually exists
-    const wordList areaNames(backends_.toc());
+    const wordList areaNames(backends_.sortedToc());
 
     for (const word& areaName : areaNames)
     {
-        if (meshes_.found(areaName) && obr.found(areaName))
+        if
+        (
+            meshes_.contains(areaName)
+         && faRegistry && faRegistry->cfindObject<faMesh>(areaName)
+        )
         {
             backends_[areaName]->updateState(state);
         }
@@ -207,7 +221,7 @@ bool Foam::catalyst::faMeshInput::convert
     const word channelName(name());
     const wordList areaNames(backends_.sortedToc());
 
-    if (areaNames.empty() || !dataq.found(channelName))
+    if (areaNames.empty() || !dataq.contains(channelName))
     {
         // Not available, or not requested
         return false;

src/catalyst/areaMesh/catalystFaMesh.H

@@ -74,8 +74,8 @@ SourceFiles
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef catalyst_faMeshInput_H
-#define catalyst_faMeshInput_H
+#ifndef Foam_catalyst_faMeshInput_H
+#define Foam_catalyst_faMeshInput_H
 
 #include "wordRes.H"
 #include "HashPtrTable.H"
@@ -104,7 +104,7 @@ protected:
         //- Reference to the time database
         const Time& time_;
 
-        //- The region name for the area meshes
+        //- The polyMesh region for the area meshes
         word regionName_;
 
         //- Requested names of areas to process

src/catalyst/areaMesh/foamVtkFaMeshAdaptor.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2019 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -99,10 +99,10 @@ Foam::vtk::faMeshAdaptor::output(const wordRes& select)
     label rank = 0;
     label nproc = 1;
 
-    if (Pstream::parRun())
+    if (UPstream::parRun())
     {
-        rank  = Pstream::myProcNo();
-        nproc = Pstream::nProcs();
+        rank  = UPstream::myProcNo();
+        nproc = UPstream::nProcs();
     }
 
     auto output = vtkSmartPointer<vtkMultiPieceDataSet>::New();
@@ -113,7 +113,7 @@ Foam::vtk::faMeshAdaptor::output(const wordRes& select)
     {
         const auto& longName = internalName;
         auto iter = cachedVtp_.find(longName);
-        if (iter.found() && iter.val().dataset)
+        if (iter.good() && iter.val().dataset)
         {
             vtkmesh = iter.val().dataset;
         }

src/catalyst/areaMesh/foamVtkFaMeshAdaptor.H

@@ -103,7 +103,7 @@ private:
 
     // Private Data
 
-        //- OpenFOAM mesh
+        //- OpenFOAM finite-area mesh
         const faMesh& mesh_;
 
         //- Track changes in mesh geometry

src/catalyst/areaMesh/foamVtkFaMeshAdaptorFieldTemplates.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2019 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -45,16 +45,13 @@ void Foam::vtk::faMeshAdaptor::convertAreaFields
     const wordRes& selectFields
 )
 {
-    const auto& obr = mesh_.mesh();
+    const auto& obr = mesh_.thisDb();
 
     typedef GeometricField<Type, faPatchField, areaMesh> fieldType;
 
-    for (const word& fieldName : obr.sortedNames<fieldType>(selectFields))
+    for (const auto& fld : obr.csorted<fieldType>(selectFields))
     {
-        convertAreaField
-        (
-            obr.lookupObject<fieldType>(fieldName)
-        );
+        convertAreaField(fld);
     }
 }
 
@@ -68,7 +65,7 @@ void Foam::vtk::faMeshAdaptor::convertAreaField
     const auto& longName = internalName;
 
     auto iter = cachedVtp_.find(longName);
-    if (!iter.found() || !iter.val().dataset)
+    if (!iter.good() || !iter.val().dataset)
     {
         // Should not happen, but for safety require a vtk geometry
         return;

src/catalyst/areaMesh/foamVtkFaMeshAdaptorFields.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -45,7 +45,7 @@ Foam::wordHashSet Foam::vtk::faMeshAdaptor::knownFields
 {
     // Quick exit if no volume fields can be converted.
     // This could be refined
-    HashTable<wordHashSet> objects = mesh_.mesh().classes(selectFields);
+    HashTable<wordHashSet> objects = mesh_.thisDb().classes(selectFields);
 
     wordHashSet allFields(2*objects.size());
 
@@ -53,7 +53,7 @@ Foam::wordHashSet Foam::vtk::faMeshAdaptor::knownFields
     {
         const word& clsName = iter.key();
 
-        if (fieldTypes::area.found(clsName))
+        if (fieldTypes::area.contains(clsName))
         {
             allFields += iter.val();
         }
@@ -70,7 +70,7 @@ void Foam::vtk::faMeshAdaptor::convertAreaFields
 {
     // Quick exit if no fields can be converted.
     // This could be refined
-    HashTable<wordHashSet> objects = mesh_.mesh().classes(selectFields);
+    HashTable<wordHashSet> objects = mesh_.thisDb().classes(selectFields);
 
     if (objects.empty())
     {

src/catalyst/catalystCoprocess.C

@@ -68,7 +68,7 @@ bool Foam::catalyst::coprocess::processImpl
 
     for (const word& channel : dataq.names())
     {
-        if (outputs.found(channel))
+        if (outputs.contains(channel))
         {
             auto* input = descrip->GetInputDescriptionByName(channel.c_str());
 

src/catalyst/catalystFunctionObject.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
     Copyright (C) 2018 CINECA
 -------------------------------------------------------------------------------
 License
@@ -30,7 +30,7 @@ License
 #include "catalystCoprocess.H"
 #include "stringOps.H"
 #include "OSHA1stream.H"
-#include "OSspecific.H"
+#include "OSspecific.H"  // For isFile, mkDir
 #include "sigFpe.H"
 #include "addToRunTimeSelectionTable.H"
 
@@ -75,7 +75,7 @@ Foam::label Foam::functionObjects::catalystFunctionObject::expand
         stringOps::inplaceExpand(s, dict, true, true);
         fileName::clean(s);  // Remove trailing, repeated slashes etc.
 
-        if (isFile(s))
+        if (Foam::isFile(s))
         {
             if (nscript != scripti)
             {
@@ -172,7 +172,7 @@ bool Foam::functionObjects::catalystFunctionObject::read(const dictionary& dict)
         catalyst::coprocess::debug = debugLevel;
     }
 
-    if (Pstream::master())
+    if (UPstream::master())
     {
         fileName dir;
         if (dict.readIfPresent("mkdir", dir))
@@ -192,7 +192,7 @@ bool Foam::functionObjects::catalystFunctionObject::read(const dictionary& dict)
     dict.readIfPresent("outputDir", outputDir_);
     outputDir_.expand();
     outputDir_.clean();
-    if (Pstream::master())
+    if (UPstream::master())
     {
         Foam::mkDir(outputDir_);
     }

src/catalyst/catalystInput.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -60,20 +60,21 @@ Foam::catalyst::catalystInput::New
     const dictionary& dict
 )
 {
-    const word modelType(dict.lookupOrDefault<word>("type", "default"));
+    const word type(dict.getOrDefault<word>("type", "default"));
 
-    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
+    auto* ctorPtr = dictionaryConstructorTable(type);
 
-    if (!cstrIter.found())
+    if (!ctorPtr)
     {
-        FatalErrorInFunction
-            << "Unknown catalystInput " << modelType << nl << nl
-            << "Valid inputs:" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "catalystInput",
+            type,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
-    return autoPtr<catalystInput>(cstrIter()(name, runTime, dict));
+    return autoPtr<catalystInput>(ctorPtr(name, runTime, dict));
 }
 
 

src/catalyst/catalystTools.C

@@ -102,7 +102,7 @@ void Foam::catalyst::dataQuery::set
 {
     auto iter = fields_.find(channel);
 
-    if (iter.found())
+    if (iter.good())
     {
         *iter = fields;
     }
@@ -170,7 +170,7 @@ Foam::label Foam::catalyst::dataQuery::query(vtkCPProcessor* coproc)
 
     for (const word& channel : inputNames)
     {
-        if (currChannels.found(channel))
+        if (currChannels.contains(channel))
         {
             continue;
         }

src/catalyst/catalystTools.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -148,18 +148,18 @@ public:
         inline void clear();
 
         //- Empty if there are no active channels
-        inline bool empty() const;
+        inline bool empty() const noexcept;
 
         //- The number of active channels
-        inline label size() const;
+        inline label size() const noexcept;
 
-        //- True if given channel exists (in fields or active)
-        inline bool found(const word& channel) const;
+        //- True if given channel exists (in fields)
+        inline bool contains(const word& channel) const;
 
         //- The active channel numbers
         inline List<label> active() const;
 
-        //- The channel names
+        //- The (active) channel names
         inline wordList names() const;
 
         //- Fields for the given channel

src/catalyst/catalystToolsI.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -41,21 +41,21 @@ inline void Foam::catalyst::dataQuery::clear()
 }
 
 
-inline bool Foam::catalyst::dataQuery::empty() const
+inline bool Foam::catalyst::dataQuery::empty() const noexcept
 {
     return active_.empty();
 }
 
 
-inline Foam::label Foam::catalyst::dataQuery::size() const
+inline Foam::label Foam::catalyst::dataQuery::size() const noexcept
 {
     return active_.size();
 }
 
 
-inline bool Foam::catalyst::dataQuery::found(const word& channel) const
+inline bool Foam::catalyst::dataQuery::contains(const word& channel) const
 {
-    return fields_.found(channel);
+    return fields_.contains(channel);
 }
 
 
@@ -77,7 +77,7 @@ inline const Foam::wordHashSet&
 Foam::catalyst::dataQuery::fields(const word& channel) const
 {
     const auto iter = fields_.cfind(channel);
-    if (iter.found())
+    if (iter.good())
     {
         return *iter;
     }

src/catalyst/cloud/catalystCloud.C

@@ -77,8 +77,7 @@ bool Foam::catalyst::cloudInput::read(const dictionary& dict)
 {
     catalystInput::read(dict);
 
-    regionName_ =
-        dict.lookupOrDefault<word>("region", polyMesh::defaultRegion);
+    regionName_ = dict.getOrDefault<word>("region", polyMesh::defaultRegion);
 
     selectClouds_.clear();
     dict.readIfPresent("clouds", selectClouds_);
@@ -86,8 +85,8 @@ bool Foam::catalyst::cloudInput::read(const dictionary& dict)
     if (selectClouds_.empty())
     {
         selectClouds_.resize(1);
-        selectClouds_.first() =
-            dict.lookupOrDefault<word>("cloud", cloud::defaultName);
+        selectClouds_.front() =
+            dict.getOrDefault<word>("cloud", cloud::defaultName);
     }
 
     selectFields_.clear();
@@ -126,7 +125,7 @@ bool Foam::catalyst::cloudInput::convert
     const fvMesh& fvm = time_.lookupObject<fvMesh>(regionName_);
     const wordList cloudNames(fvm.sortedNames<cloud>(selectClouds_));
 
-    if (cloudNames.empty() || !dataq.found(channelName))
+    if (cloudNames.empty() || !dataq.contains(channelName))
     {
         // Not available, or not requested
         return false;

src/catalyst/cloud/foamVtkCloudAdaptor.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2020 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -65,10 +65,10 @@ Foam::vtk::cloudAdaptor::getCloudImpl
     label rank = 0;
     label nproc = 1;
 
-    if (Pstream::parRun())
+    if (UPstream::parRun())
     {
-        rank  = Pstream::myProcNo();
-        nproc = Pstream::nProcs();
+        rank  = UPstream::myProcNo();
+        nproc = UPstream::nProcs();
     }
 
     auto output = vtkSmartPointer<vtkMultiPieceDataSet>::New();
@@ -88,7 +88,7 @@ Foam::vtk::cloudAdaptor::getCloudImpl
             mesh,
             IOobject::NO_READ,
             IOobject::NO_WRITE,
-            false
+            IOobject::NO_REGISTER
         )
     );
 
@@ -106,8 +106,11 @@ Foam::vtk::cloudAdaptor::getCloudImpl
         (
             [](const word& k)
             {
-                return k.startsWith("position")
-                    || k.startsWith("coordinate");
+                return
+                (
+                    k.starts_with("position")
+                 || k.starts_with("coordinate")
+                );
             },
             true  // prune
         );

src/catalyst/cloud/foamVtkCloudAdaptorTemplates.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -43,10 +43,8 @@ Foam::label Foam::vtk::cloudAdaptor::convertLagrangianFields
 
     label nFields = 0;
 
-    for (const word& fieldName : obr.sortedNames<fieldType>())
+    for (const auto& fld : obr.csorted<fieldType>())
     {
-        const auto& fld = obr.lookupObject<fieldType>(fieldName);
-
         vtkSmartPointer<vtkFloatArray> data = vtk::Tools::convertFieldToVTK
         (
             fld.name(),

src/catalyst/volMesh/catalystFvMesh.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2019 OpenCFD Ltd.
+    Copyright (C) 2018-2023 OpenCFD Ltd.
     Copyright (C) 2018 CINECA
 -------------------------------------------------------------------------------
 License
@@ -58,14 +58,14 @@ void Foam::catalyst::fvMeshInput::update()
     // Backend requires a corresponding mesh
     backends_.filterKeys
     (
-        [this](const word& k){ return meshes_.found(k); }
+        [this](const word& k){ return meshes_.contains(k); }
     );
 
     forAllConstIters(meshes_, iter)
     {
         const word& regionName = iter.key();
 
-        if (!backends_.found(regionName))
+        if (!backends_.contains(regionName))
         {
             auto backend =
                 autoPtr<Foam::vtk::fvMeshAdaptor>::New
@@ -118,15 +118,15 @@ bool Foam::catalyst::fvMeshInput::read(const dictionary& dict)
     selectRegions_.clear();
     selectPatches_.clear();
     selectFields_.clear();
-    decomposeOpt_ = dict.lookupOrDefault("decompose", false);
+    decomposeOpt_ = dict.getOrDefault("decompose", false);
 
     unsigned selected(channelType::NONE);
 
-    if (dict.lookupOrDefault("internal", true))
+    if (dict.getOrDefault("internal", true))
     {
         selected |= channelType::INTERNAL;
     }
-    if (dict.lookupOrDefault("boundary", true))
+    if (dict.getOrDefault("boundary", true))
     {
         selected |= channelType::BOUNDARY;
     }
@@ -152,8 +152,8 @@ bool Foam::catalyst::fvMeshInput::read(const dictionary& dict)
     if (selectRegions_.empty())
     {
         selectRegions_.resize(1);
-        selectRegions_.first() =
-            dict.lookupOrDefault<word>("region", polyMesh::defaultRegion);
+        selectRegions_.front() =
+            dict.getOrDefault<word>("region", polyMesh::defaultRegion);
     }
 
     // Restrict to specified meshes
@@ -174,7 +174,7 @@ void Foam::catalyst::fvMeshInput::update(polyMesh::readUpdateState state)
 
     for (const word& regionName : regionNames)
     {
-        if (meshes_.found(regionName) && time_.found(regionName))
+        if (meshes_.contains(regionName) && time_.contains(regionName))
         {
             backends_[regionName]->updateState(state);
         }
@@ -224,7 +224,7 @@ bool Foam::catalyst::fvMeshInput::convert
     const word channelName(name());
     const wordList regionNames(backends_.sortedToc());
 
-    if (regionNames.empty() || !dataq.found(channelName))
+    if (regionNames.empty() || !dataq.contains(channelName))
     {
         // Not available, or not requested
         return false;

src/catalyst/volMesh/foamVtkFvMeshAdaptor.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2019 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -78,8 +78,8 @@ void Foam::vtk::fvMeshAdaptor::definePatchIds()
     // Restrict to non-processor patches.
     // This value is invariant across all processors.
 
-    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
-    const label nNonProcessor = patches.nNonProcessor();
+    const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
+    const label nNonProcessor = pbm.nNonProcessor();
 
     if (patchPatterns_.empty())
     {
@@ -88,7 +88,7 @@ void Foam::vtk::fvMeshAdaptor::definePatchIds()
     else
     {
         // Don't warn if not found, use patch groups
-        labelHashSet ids(patches.patchSet(patchPatterns_, false, true));
+        labelHashSet ids(pbm.patchSet(patchPatterns_, false, true));
 
         // Restricted to non-processor patches
         ids.filterKeys
@@ -129,7 +129,7 @@ void Foam::vtk::fvMeshAdaptor::setChannels(const wordList& chanNames)
     unsigned chanIds = 0;
     for (const word& chan : chanNames)
     {
-        if (channelNames.found(chan))
+        if (channelNames.contains(chan))
         {
             chanIds |= channelNames[chan];
         }
@@ -215,8 +215,8 @@ void Foam::vtk::fvMeshAdaptor::updateContent(const wordRes& selectFields)
     // Restrict to non-processor patches.
     // This value is invariant across all processors.
 
-    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
-    const label nNonProcessor = patches.nNonProcessor();
+    const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
+    const label nNonProcessor = pbm.nNonProcessor();
 
 
     // Update cached, saved, unneed values.
@@ -235,7 +235,7 @@ void Foam::vtk::fvMeshAdaptor::updateContent(const wordRes& selectFields)
     {
         for (label patchId=0; patchId < nNonProcessor; ++patchId)
         {
-            const polyPatch& pp = patches[patchId];
+            const polyPatch& pp = pbm[patchId];
             nowActive.insert(pp.name());
         }
     }
@@ -294,10 +294,10 @@ Foam::vtk::fvMeshAdaptor::output(const wordRes& select)
     label rank = 0;
     label nproc = 1;
 
-    if (Pstream::parRun())
+    if (UPstream::parRun())
     {
-        rank  = Pstream::myProcNo();
-        nproc = Pstream::nProcs();
+        rank  = UPstream::myProcNo();
+        nproc = UPstream::nProcs();
     }
 
 
@@ -312,7 +312,7 @@ Foam::vtk::fvMeshAdaptor::output(const wordRes& select)
         {
             const auto& longName = internalName();
             auto iter = cachedVtu_.find(longName);
-            if (!iter.found() || !iter.val().dataset)
+            if (!iter.good() || !iter.val().dataset)
             {
                 Pout<<"Cache miss for VTU " << longName << endl;
                 break; // Should never happen
@@ -344,15 +344,15 @@ Foam::vtk::fvMeshAdaptor::output(const wordRes& select)
 
         auto output = vtkSmartPointer<vtkMultiBlockDataSet>::New();
 
-        const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+        const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
 
         for (const label patchId : patchIds_)
         {
-            const polyPatch& pp = patches[patchId];
+            const polyPatch& pp = pbm[patchId];
             const word& longName = pp.name();
 
             auto iter = cachedVtp_.find(longName);
-            if (!iter.found() || !iter.val().dataset)
+            if (!iter.good() || !iter.val().dataset)
             {
                 Pout<<"Cache miss for VTP patch " << longName << endl;
                 break; // Should never happen

src/catalyst/volMesh/foamVtkFvMeshAdaptorFieldTemplates.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2020 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -77,7 +77,7 @@ void Foam::vtk::fvMeshAdaptor::convertVolField
         const word& longName = pp.name();
 
         auto iter = cachedVtp_.find(longName);
-        if (!iter.found() || !iter.val().dataset)
+        if (!iter.good() || !iter.val().dataset)
         {
             // Should not happen, but for safety require a vtk geometry
             Pout<<"Cache miss for VTP patch " << longName << endl;
@@ -179,17 +179,9 @@ void Foam::vtk::fvMeshAdaptor::convertVolFields
 
     // Restrict to GeometricField<Type, ...>
 
-    for
-    (
-        const word& fieldName
-      : mesh_.sortedNames<fieldType>(selectFields)
-    )
+    for (const auto& fld : mesh_.thisDb().csorted<fieldType>(selectFields))
     {
-        convertVolField
-        (
-            patchInterpList,
-            mesh_.lookupObject<fieldType>(fieldName)
-        );
+        convertVolField(patchInterpList, fld);
     }
 }
 
@@ -209,7 +201,7 @@ void Foam::vtk::fvMeshAdaptor::convertVolFieldInternal
     const auto& longName = internalName();
 
     auto iter = cachedVtu_.find(longName);
-    if (!iter.found() || !iter.val().dataset)
+    if (!iter.good() || !iter.val().dataset)
     {
         // Should not happen, but for safety require a vtk geometry
         Pout<<"Cache miss for VTU " << longName << endl;

src/catalyst/volMesh/foamVtkFvMeshAdaptorFields.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2019 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -43,7 +43,7 @@ Foam::wordHashSet Foam::vtk::fvMeshAdaptor::knownFields
 {
     // Quick exit if no volume fields can be converted.
     // This could be refined
-    HashTable<wordHashSet> objects = mesh_.classes(selectFields);
+    HashTable<wordHashSet> objects = mesh_.thisDb().classes(selectFields);
 
     wordHashSet allFields(2*objects.size());
 
@@ -53,9 +53,9 @@ Foam::wordHashSet Foam::vtk::fvMeshAdaptor::knownFields
 
         if
         (
-            fieldTypes::volume.found(clsName)
+            fieldTypes::volume.contains(clsName)
             // TODO
-            // || fieldTypes::internal.found(clsName)
+            // || fieldTypes::internal.contains(clsName)
         )
         {
             allFields += iter.val();
@@ -73,7 +73,7 @@ void Foam::vtk::fvMeshAdaptor::convertVolFields
 {
     // Quick exit if no volume fields can be converted.
     // This could be refined
-    HashTable<wordHashSet> objects = mesh_.classes(selectFields);
+    HashTable<wordHashSet> objects = mesh_.thisDb().classes(selectFields);
 
     if (objects.empty())
     {
@@ -87,9 +87,9 @@ void Foam::vtk::fvMeshAdaptor::convertVolFields
         // NOTE: this would be broken with processor patches,
         // but we don't allow them for the catalyst adaptor anyhow
 
-        // patchIds_ are sorted, so the last one is also the max
+        // patchIds_ are sorted, so the last one is also the max Id
 
-        interpLst.setSize(patchIds_.last() + 1);
+        interpLst.resize(patchIds_.back() + 1);
 
         for (const label patchId : patchIds_)
         {

src/catalyst/volMesh/foamVtkFvMeshAdaptorGeom.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2020 OpenCFD Ltd.
+    Copyright (C) 2017-2023 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -157,7 +157,7 @@ void Foam::vtk::fvMeshAdaptor::applyGhostingInternal(const labelUList& types)
     const auto& longName = internalName();
 
     auto iter = cachedVtu_.find(longName);
-    if (!iter.found() || !iter.val().dataset)
+    if (!iter.good() || !iter.val().dataset)
     {
         // Should not happen, but for safety require a vtk geometry
         Pout<<"Cache miss for VTU " << longName << endl;
@@ -233,7 +233,7 @@ void Foam::vtk::fvMeshAdaptor::applyGhostingBoundary(const labelUList& types)
         const word& longName = pp.name();
 
         auto iter = cachedVtp_.find(longName);
-        if (!iter.found() || !iter.val().dataset)
+        if (!iter.good() || !iter.val().dataset)
         {
             // Should not happen, but for safety require a vtk geometry
             Pout<<"Cache miss for VTP patch " << longName << endl;