ENH: simplify objectRegistry access names (issue #322)

New name:  findObject(), cfindObject()
  Old name:  lookupObjectPtr()

      Return a const pointer or nullptr on failure.

  New name:  findObject()
  Old name:  --

      Return a non-const pointer or nullptr on failure.

  New name:  getObjectPtr()
  Old name:  lookupObjectRefPtr()

      Return a non-const pointer or nullptr on failure.
      Can be called on a const object and it will perform a
      const_cast.

- use these updated names and functionality in more places

NB: The older methods names are deprecated, but continue to be defined.

applications/solvers/multiphase/icoReactingMultiphaseInterFoam/phasesSystem/phaseSystem/phaseSystem.H

@@ -260,13 +260,7 @@ public:
         virtual volScalarField& he()
         {
             NotImplemented;
-            return
+            return const_cast<volScalarField&>(volScalarField::null());
-            (
-                const_cast<volScalarField&>
-                (
-                    volScalarField::null()
-                )
-            );
         }
 
         //- Return access to the inernal energy field [J/Kg]
@@ -274,10 +268,7 @@ public:
         virtual const volScalarField& he() const
         {
            NotImplemented;
-           return
+           return volScalarField::null();
-           (
-                volScalarField::null()
-           );
         }
 
         //- Enthalpy/Internal energy

applications/solvers/multiphase/reactingEulerFoam/phaseSystems/PhaseSystems/ThermalPhaseChangePhaseSystem/ThermalPhaseChangePhaseSystem.C

@@ -131,19 +131,15 @@ Foam::ThermalPhaseChangePhaseSystem<BasePhaseSystem>::heatTransfer() const
             dimensionedScalar(dimensionSet(1,-1,-3,0,0), Zero)
         );
 
-        if
+        const volScalarField* alphatPtr =
-        (
+            otherPhase.mesh().findObject<volScalarField>
-            otherPhase.mesh().foundObject<volScalarField>
             (
                 "alphat." +  otherPhase.name()
-            )
+            );
-        )
+
+        if (alphatPtr)
         {
-            const volScalarField& alphat =
+            const volScalarField& alphat = *alphatPtr;
-                otherPhase.mesh().lookupObject<volScalarField>
-                (
-                    "alphat." +  otherPhase.name()
-                );
 
             const fvPatchList& patches = this->mesh().boundary();
             forAll(patches, patchi)
@@ -427,19 +423,15 @@ void Foam::ThermalPhaseChangePhaseSystem<BasePhaseSystem>::correctThermo()
             dimensionedScalar(dimDensity/dimTime, Zero)
         );
 
-        if
+        const volScalarField* alphatPtr =
-        (
+            phase2.mesh().findObject<volScalarField>
-            phase2.mesh().foundObject<volScalarField>
             (
-                "alphat." +  phase2.name()
+                "alphat." + phase2.name()
-            )
+            );
-        )
+
+        if (alphatPtr)
         {
-            const volScalarField& alphat =
+            const volScalarField& alphat = *alphatPtr;
-                phase2.mesh().lookupObject<volScalarField>
-                (
-                    "alphat." +  phase2.name()
-                );
 
             const fvPatchList& patches = this->mesh().boundary();
             forAll(patches, patchi)

src/OpenFOAM/db/functionObjects/regionFunctionObject/regionFunctionObject.C

@@ -52,10 +52,8 @@ Foam::functionObjects::regionFunctionObject::whichSubRegistry
     {
         return obr.lookupObject<objectRegistry>(subName);
     }
-    else
+
-    {
+    return obr;
-        return obr;
-    }
 }
 
 
@@ -71,22 +69,19 @@ bool Foam::functionObjects::regionFunctionObject::writeObject
     const word& fieldName
 )
 {
-    const regIOobject* objPtr =
+    const regIOobject* obj = this->findObject<regIOobject>(fieldName);
-        this->lookupObjectPtr<regIOobject>(fieldName);
 
-    if (objPtr)
+    if (obj)
     {
         Log << "    functionObjects::" << type() << " " << name()
-            << " writing field: " << objPtr->name() << endl;
+            << " writing field: " << obj->name() << endl;
 
-        objPtr->write();
+        obj->write();
 
         return true;
     }
-    else
+
-    {
+    return false;
-        return false;
-    }
 }
 
 
@@ -95,12 +90,14 @@ bool Foam::functionObjects::regionFunctionObject::clearObject
     const word& fieldName
 )
 {
-    regIOobject* objPtr = lookupObjectRefPtr<regIOobject>(fieldName);
+    // Same as getObjectPtr, since the object is already non-const
-    if (objPtr)
+    regIOobject* obj = this->findObject<regIOobject>(fieldName);
+
+    if (obj)
     {
-        if (objPtr->ownedByRegistry())
+        if (obj->ownedByRegistry())
         {
-            return objPtr->checkOut();
+            return obj->checkOut();
         }
         else
         {

src/OpenFOAM/db/functionObjects/regionFunctionObject/regionFunctionObject.H

@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2016-2017 OpenCFD Ltd.
+     \\/     M anipulation  | Copyright (C) 2016-2018 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -94,6 +94,35 @@ protected:
         template<class ObjectType>
         bool foundObject(const word& fieldName) const;
 
+        //- Return const pointer to the object (eg, a field) in the
+        //- (sub) objectRegistry.
+        //
+        //  \return nullptr if the object was not found or had incorrect type.
+        template<class ObjectType>
+        const ObjectType* cfindObject(const word& fieldName) const;
+
+        //- Return const pointer to the object (eg, a field) in the
+        //- (sub) objectRegistry.
+        //
+        //  \return nullptr if the object was not found or had incorrect type.
+        template<class ObjectType>
+        const ObjectType* findObject(const word& fieldName) const;
+
+        //- Return non-const pointer to the object of the given Type,
+        //- (sub) objectRegistry.
+        //
+        //  \return nullptr if the object was not found or had incorrect type.
+        template<class ObjectType>
+        ObjectType* findObject(const word& fieldName);
+
+        //- Return non-const pointer to the object of the given Type,
+        //- using a const-cast to have it behave like a mutable.
+        //  Exercise caution when using.
+        //
+        //  \return nullptr if the object was not found or had incorrect type.
+        template<class ObjectType>
+        ObjectType* getObjectPtr(const word& fieldName) const;
+
         //- Lookup and return object (eg, a field) from the (sub) objectRegistry
         template<class ObjectType>
         const ObjectType& lookupObject(const word& fieldName) const;
@@ -102,18 +131,6 @@ protected:
         template<class ObjectType>
         ObjectType& lookupObjectRef(const word& fieldName) const;
 
-        //- Lookup and return pointer to the object,
-        //  otherwise nullptr if the object was not found,
-        //  or had the incorrect type.
-        template<class ObjectType>
-        const ObjectType* lookupObjectPtr(const word& fieldName) const;
-
-        //- Lookup and return non-const pointer to the object,
-        //  otherwise nullptr if the object was not found,
-        //  or had the incorrect type.
-        template<class ObjectType>
-        ObjectType* lookupObjectRefPtr(const word& fieldName) const;
-
         //- Store the field in the (sub) objectRegistry under the given name
         //  Note: sets the fieldName to tfield().name() if not already set
         template<class ObjectType>
@@ -177,6 +194,25 @@ public:
 
         //- Read optional controls
         virtual bool read(const dictionary& dict);
+
+
+    // Housekeeping
+
+        //- Same as findObject
+        //  \deprecated use findObject (OCT-2018)
+        template<class ObjectType>
+        const ObjectType* lookupObjectPtr(const word& fieldName) const
+        {
+            return this->cfindObject<ObjectType>(fieldName);
+        }
+
+        //- Same as getObjectPtr
+        //  \deprecated use getObjectPtr (OCT-2018)
+        template<class ObjectType>
+        ObjectType* lookupObjectRefPtr(const word& fieldName) const
+        {
+            return this->getObjectPtr<ObjectType>(fieldName);
+        }
 };
 
 

src/OpenFOAM/db/functionObjects/regionFunctionObject/regionFunctionObjectTemplates.C

@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
+     \\/     M anipulation  | Copyright (C) 2016-2018 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -38,6 +38,47 @@ bool Foam::functionObjects::regionFunctionObject::foundObject
 }
 
 
+template<class ObjectType>
+const ObjectType* Foam::functionObjects::regionFunctionObject::cfindObject
+(
+    const word& fieldName
+) const
+{
+    return obr().cfindObject<ObjectType>(fieldName);
+}
+
+
+template<class ObjectType>
+const ObjectType* Foam::functionObjects::regionFunctionObject::findObject
+(
+    const word& fieldName
+) const
+{
+    return obr().findObject<ObjectType>(fieldName);
+}
+
+
+template<class ObjectType>
+ObjectType* Foam::functionObjects::regionFunctionObject::findObject
+(
+    const word& fieldName
+)
+{
+    // Need getObjectPtr to bypass const access on the objectRegistry
+    return obr().getObjectPtr<ObjectType>(fieldName);
+}
+
+
+template<class ObjectType>
+ObjectType* Foam::functionObjects::regionFunctionObject::getObjectPtr
+(
+    const word& fieldName
+) const
+{
+    return obr().getObjectPtr<ObjectType>(fieldName);
+}
+
+
 template<class ObjectType>
 const ObjectType& Foam::functionObjects::regionFunctionObject::lookupObject
 (
@@ -58,26 +99,6 @@ ObjectType& Foam::functionObjects::regionFunctionObject::lookupObjectRef
 }
 
 
-template<class ObjectType>
-const ObjectType* Foam::functionObjects::regionFunctionObject::lookupObjectPtr
-(
-    const word& fieldName
-) const
-{
-    return obr().lookupObjectPtr<ObjectType>(fieldName);
-}
-
-
-template<class ObjectType>
-ObjectType* Foam::functionObjects::regionFunctionObject::lookupObjectRefPtr
-(
-    const word& fieldName
-) const
-{
-    return obr().lookupObjectRefPtr<ObjectType>(fieldName);
-}
-
-
 template<class ObjectType>
 bool Foam::functionObjects::regionFunctionObject::store
 (

src/OpenFOAM/db/objectRegistry/objectRegistry.H

@@ -231,8 +231,9 @@ public:
     // Lookup
 
         //- Lookup and return a const sub-objectRegistry.
-        //  Optionally create it if it does not exist.
+        //
-        //  If recursive, search parent registries.
+        //  \param forceCreate create it if it does not exist.
+        //  \param recursive search parent registries.
         const objectRegistry& subRegistry
         (
             const word& name,
@@ -250,7 +251,8 @@ public:
         HashTable<Type*> lookupClass(const bool strict = false);
 
         //- Is the named Type found?
-        //  If recursive, search parent registries.
+        //
+        //  \param recursive search parent registries
         template<class Type>
         bool foundObject
         (
@@ -258,8 +260,60 @@ public:
             const bool recursive = false
         ) const;
 
-        //- Lookup and return the object of the given Type.
+        //- Find const pointer to the object of the given Type.
-        //  If recursive, search parent registries.
+        //
+        //  \param recursive search parent registries
+        //
+        //  \return nullptr if the object was not found or had incorrect type.
+        template<class Type>
+        const Type* cfindObject
+        (
+            const word& name,
+            const bool recursive = false
+        ) const;
+
+        //- Return const pointer to the object of the given Type.
+        //
+        //  \param recursive search parent registries
+        //
+        //  \return nullptr if the object was not found or had incorrect type.
+        template<class Type>
+        const Type* findObject
+        (
+            const word& name,
+            const bool recursive = false
+        ) const;
+
+        //- Return non-const pointer to the object of the given Type.
+        //
+        //  \param recursive search parent registries
+        //
+        //  \return nullptr if the object was not found or had incorrect type.
+        template<class Type>
+        Type* findObject
+        (
+            const word& name,
+            const bool recursive = false
+        );
+
+        //- Return non-const pointer to the object of the given Type,
+        //- using a const-cast to have it behave like a mutable.
+        //  Exercise caution when using.
+        //
+        //  \param recursive search parent registries.
+        //
+        //  \return nullptr if the object was not found or had incorrect type.
+        template<class Type>
+        Type* getObjectPtr
+        (
+            const word& name,
+            const bool recursive = false
+        ) const;
+
+        //- Lookup and return const reference to the object
+        //- of the given Type. Fatal if not found or the wrong type.
+        //
+        //  \param recursive search parent registries.
         template<class Type>
         const Type& lookupObject
         (
@@ -267,8 +321,10 @@ public:
             const bool recursive = false
         ) const;
 
-        //- Lookup and return the object of the given Type.
+        //- Lookup and return non-const reference to the object
-        //  If recursive, search parent registries.
+        //- of the given Type. Fatal if not found or the wrong type.
+        //
+        //  \param recursive search parent registries.
         template<class Type>
         Type& lookupObjectRef
         (
@@ -276,30 +332,6 @@ public:
             const bool recursive = false
         ) const;
 
-        //- Lookup and return pointer to the object of the given Type,
-        //  otherwise nullptr if the object was not found,
-        //  or had the incorrect type.
-        //  If recursive, search parent registries.
-        template<class Type>
-        const Type* lookupObjectPtr
-        (
-            const word& name,
-            const bool recursive = false
-        ) const;
-
-
-        //- Lookup and return non-const pointer to the object
-        //  of the given Type,
-        //  otherwise nullptr if the object was not found,
-        //  or had the incorrect type.
-        //  If recursive, search parent registries.
-        template<class Type>
-        Type* lookupObjectRefPtr
-        (
-            const word& name,
-            const bool recursive = false
-        ) const;
-
 
     // Events
 
@@ -349,6 +381,34 @@ public:
             IOstream::compressionType cmp,
             const bool valid
         ) const;
+
+
+    // Housekeeping
+
+        //- Same as findObject
+        //  \deprecated use findObject (OCT-2018)
+        template<class Type>
+        const Type* lookupObjectPtr
+        (
+            const word& name,
+            bool recursive = false
+        ) const
+        {
+            return this->cfindObject<Type>(name, recursive);
+        }
+
+        //- Same as getObjectPtr
+        //
+        //  \deprecated use getObjectPtr (OCT-2018)
+        template<class Type>
+        Type* lookupObjectRefPtr
+        (
+            const word& name,
+            bool recursive = false
+        ) const
+        {
+            return this->getObjectPtr<Type>(name, recursive);
+        }
 };
 
 

src/OpenFOAM/db/objectRegistry/objectRegistryTemplates.C

@@ -156,7 +156,7 @@ Foam::HashTable<const Type*> Foam::objectRegistry::lookupClass
 
     forAllConstIters(*this, iter)
     {
-        if (strict ? isType<Type>(*iter()) : isA<Type>(*iter()))
+        if (strict ? isType<Type>(*iter()) : bool(isA<Type>(*iter())))
         {
             objectsOfClass.insert
             (
@@ -180,7 +180,7 @@ Foam::HashTable<Type*> Foam::objectRegistry::lookupClass
 
     forAllIters(*this, iter)
     {
-        if (strict ? isType<Type>(*iter()) : isA<Type>(*iter()))
+        if (strict ? isType<Type>(*iter()) : bool(isA<Type>(*iter())))
         {
             objectsOfClass.insert
             (
@@ -201,14 +201,71 @@ bool Foam::objectRegistry::foundObject
     const bool recursive
 ) const
 {
-    const Type* ptr = this->lookupObjectPtr<Type>(name, recursive);
+    return this->cfindObject<Type>(name, recursive);
+}
 
-    if (ptr)
+
+template<class Type>
+const Type* Foam::objectRegistry::cfindObject
+(
+    const word& name,
+    const bool recursive
+) const
+{
+    const_iterator iter = cfind(name);
+
+    if (iter.found())
     {
-        return true;
+        const Type* ptr = dynamic_cast<const Type*>(iter());
+
+        if (ptr)
+        {
+            return ptr;
+        }
+    }
+    else if (recursive && this->parentNotTime())
+    {
+        return parent_.cfindObject<Type>(name, recursive);
     }
 
-    return false;
+    return nullptr;
+}
+
+
+template<class Type>
+const Type* Foam::objectRegistry::findObject
+(
+    const word& name,
+    const bool recursive
+) const
+{
+    return this->cfindObject<Type>(name, recursive);
+}
+
+
+template<class Type>
+Type* Foam::objectRegistry::findObject
+(
+    const word& name,
+    const bool recursive
+)
+{
+    const Type* ptr = this->cfindObject<Type>(name, recursive);
+
+    return const_cast<Type*>(ptr);
+}
+
+
+template<class Type>
+Type* Foam::objectRegistry::getObjectPtr
+(
+    const word& name,
+    const bool recursive
+) const
+{
+    const Type* ptr = this->cfindObject<Type>(name, recursive);
+
+    return const_cast<Type*>(ptr);
 }
 
 
@@ -219,7 +276,7 @@ const Type& Foam::objectRegistry::lookupObject
     const bool recursive
 ) const
 {
-    const_iterator iter = find(name);
+    const_iterator iter = cfind(name);
 
     if (iter.found())
     {
@@ -270,44 +327,4 @@ Type& Foam::objectRegistry::lookupObjectRef
 }
 
 
-template<class Type>
-const Type* Foam::objectRegistry::lookupObjectPtr
-(
-    const word& name,
-    const bool recursive
-) const
-{
-    const_iterator iter = find(name);
-
-    if (iter.found())
-    {
-        const Type* ptr = dynamic_cast<const Type*>(iter());
-
-        if (ptr)
-        {
-            return ptr;
-        }
-    }
-    else if (recursive && this->parentNotTime())
-    {
-        return parent_.lookupObjectPtr<Type>(name, recursive);
-    }
-
-    return nullptr;
-}
-
-
-template<class Type>
-Type* Foam::objectRegistry::lookupObjectRefPtr
-(
-    const word& name,
-    const bool recursive
-) const
-{
-    const Type* ptr = this->lookupObjectPtr<Type>(name, recursive);
-
-    return const_cast<Type*>(ptr);
-}
-
-
 // ************************************************************************* //

src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrix.C

@@ -338,12 +338,12 @@ void Foam::lduMatrix::setResidualField
     }
 
     IOField<scalar>* residualPtr =
-        lduMesh_.thisDb().lookupObjectRefPtr<IOField<scalar>>(lookupName);
+        lduMesh_.thisDb().getObjectPtr<IOField<scalar>>(lookupName);
 
     if (residualPtr)
     {
         const IOdictionary* dataPtr =
-            lduMesh_.thisDb().lookupObjectPtr<IOdictionary>("data");
+            lduMesh_.thisDb().findObject<IOdictionary>("data");
 
         if (dataPtr)
         {

src/TurbulenceModels/compressible/turbulentFluidThermoModels/derivedFvPatchFields/outletMachNumberPressure/outletMachNumberPressureFvPatchScalarField.C

@@ -165,7 +165,7 @@ void Foam::outletMachNumberPressureFvPatchScalarField::updateCoeffs()
     }
 
     const fluidThermo* thermoPtr =
-        db().lookupObjectPtr<fluidThermo>(basicThermo::dictName);
+        db().findObject<fluidThermo>(basicThermo::dictName);
 
     const volVectorField& U = db().lookupObject<volVectorField>(UName_);
 

src/TurbulenceModels/compressible/turbulentFluidThermoModels/derivedFvPatchFields/turbulentTemperatureRadCoupledMixed/turbulentTemperatureRadCoupledMixedFvPatchScalarField.C

@@ -240,7 +240,7 @@ void turbulentTemperatureRadCoupledMixedFvPatchScalarField::updateCoeffs()
 
         {
             const basicThermo* thermo =
-                nbrMesh.lookupObjectPtr<basicThermo>(basicThermo::dictName);
+                nbrMesh.findObject<basicThermo>(basicThermo::dictName);
 
             if (thermo)
             {
@@ -269,7 +269,7 @@ void turbulentTemperatureRadCoupledMixedFvPatchScalarField::updateCoeffs()
         // Local inertia therm
         {
             const basicThermo* thermo =
-                mesh.lookupObjectPtr<basicThermo>(basicThermo::dictName);
+                mesh.findObject<basicThermo>(basicThermo::dictName);
 
             if (thermo)
             {

src/TurbulenceModels/turbulenceModels/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonWallFunction/epsilonWallFunctionFvPatchScalarField.C

@@ -448,11 +448,7 @@ void Foam::epsilonWallFunctionFvPatchScalarField::updateCoeffs()
 
     typedef DimensionedField<scalar, volMesh> FieldType;
 
-    FieldType& G =
+    FieldType& G = db().lookupObjectRef<FieldType>(turbModel.GName());
-        const_cast<FieldType&>
-        (
-            db().lookupObject<FieldType>(turbModel.GName())
-        );
 
     FieldType& epsilon = const_cast<FieldType&>(internalField());
 

src/dynamicFvMesh/dynamicInkJetFvMesh/dynamicInkJetFvMesh.C

@@ -117,9 +117,7 @@ bool Foam::dynamicInkJetFvMesh::update()
 
     fvMesh::movePoints(newPoints);
 
-    volVectorField& U =
+    lookupObjectRef<volVectorField>("U").correctBoundaryConditions();
-        const_cast<volVectorField&>(lookupObject<volVectorField>("U"));
-    U.correctBoundaryConditions();
 
     return true;
 }

src/dynamicFvMesh/dynamicMotionSolverListFvMesh/dynamicMotionSolverListFvMesh.C

@@ -91,10 +91,11 @@ bool Foam::dynamicMotionSolverListFvMesh::update()
 
         fvMesh::movePoints(points() + disp);
 
-        if (foundObject<volVectorField>("U"))
+        volVectorField* Uptr = getObjectPtr<volVectorField>("U");
+
+        if (Uptr)
         {
-            const_cast<volVectorField&>(lookupObject<volVectorField>("U"))
+            Uptr->correctBoundaryConditions();
-            .correctBoundaryConditions();
         }
     }
 

src/dynamicFvMesh/dynamicMultiMotionSolverFvMesh/dynamicMultiMotionSolverFvMesh.C

@@ -182,8 +182,7 @@ bool Foam::dynamicMultiMotionSolverFvMesh::update()
 
     if (foundObject<volVectorField>("U"))
     {
-        const_cast<volVectorField&>(lookupObject<volVectorField>("U"))
+        lookupObjectRef<volVectorField>("U").correctBoundaryConditions();
-            .correctBoundaryConditions();
     }
     else if (!hasWarned)
     {

src/engine/engineMesh/fvMotionSolverEngineMesh/fvMotionSolverEngineMesh.C

@@ -91,8 +91,7 @@ void Foam::fvMotionSolverEngineMesh::move()
     if (engineDB_.foundObject<surfaceScalarField>("phi"))
     {
         surfaceScalarField& phi =
-            const_cast<surfaceScalarField&>
+            engineDB_.lookupObjectRef<surfaceScalarField>("phi");
-            (engineDB_.lookupObject<surfaceScalarField>("phi"));
 
         const volScalarField& rho =
             engineDB_.lookupObject<volScalarField>("rho");

src/engine/engineMesh/layeredEngineMesh/layeredEngineMesh.C

@@ -86,8 +86,7 @@ void Foam::layeredEngineMesh::move()
     if (engineDB_.foundObject<surfaceScalarField>("phi"))
     {
         surfaceScalarField& phi =
-            const_cast<surfaceScalarField&>
+            engineDB_.lookupObjectRef<surfaceScalarField>("phi");
-            (engineDB_.lookupObject<surfaceScalarField>("phi"));
 
         const volScalarField& rho =
             engineDB_.lookupObject<volScalarField>("rho");

src/finiteVolume/fields/fvPatchFields/derived/pressurePIDControlInletVelocity/pressurePIDControlInletVelocityFvPatchVectorField.C

@@ -37,27 +37,19 @@ License
 const Foam::surfaceScalarField&
 Foam::pressurePIDControlInletVelocityFvPatchVectorField::facePressure() const
 {
-    const volScalarField& p(db().lookupObject<volScalarField>(pName_));
-
     const word pfName(pName_ + "f");
 
-    if (!db().foundObject<surfaceScalarField>(pfName))
+    const volScalarField& p = db().lookupObject<volScalarField>(pName_);
-    {
-        surfaceScalarField* pfPtr
-        (
-            new surfaceScalarField(pfName, linearInterpolate(p))
-        );
 
+    surfaceScalarField* pfPtr = db().getObjectPtr<surfaceScalarField>(pfName);
+
+    if (!pfPtr)
+    {
+        pfPtr = new surfaceScalarField(pfName, linearInterpolate(p));
         pfPtr->store();
     }
 
-    surfaceScalarField& pf
+    surfaceScalarField& pf = *pfPtr;
-    (
-        const_cast<surfaceScalarField&>
-        (
-            db().lookupObject<surfaceScalarField>(pfName)
-        )
-    );
 
     if (!pf.upToDate(p))
     {

src/finiteVolume/fields/fvPatchFields/derived/waveSurfacePressure/waveSurfacePressureFvPatchScalarField.C

@@ -144,11 +144,7 @@ void Foam::waveSurfacePressureFvPatchScalarField::updateCoeffs()
     const scalar dt = db().time().deltaTValue();
 
     // retrieve non-const access to zeta field from the database
-    volVectorField& zeta =
+    volVectorField& zeta = db().lookupObjectRef<volVectorField>(zetaName_);
-        const_cast<volVectorField&>
-        (
-            db().lookupObject<volVectorField>(zetaName_)
-        );
     vectorField& zetap = zeta.boundaryFieldRef()[patchi];
 
     // lookup d/dt scheme from database for zeta

src/finiteVolume/finiteVolume/ddtSchemes/CrankNicolsonDdtScheme/CrankNicolsonDdtScheme.C

@@ -171,10 +171,7 @@ CrankNicolsonDdtScheme<Type>::ddt0_
 
     DDt0Field<GeoField>& ddt0 = static_cast<DDt0Field<GeoField>&>
     (
-        const_cast<GeoField&>
+        mesh().objectRegistry::template lookupObjectRef<GeoField>(name)
-        (
-            mesh().objectRegistry::template lookupObject<GeoField>(name)
-        )
     );
 
     return ddt0;

src/finiteVolume/finiteVolume/gradSchemes/gradScheme/gradScheme.C

@@ -103,10 +103,11 @@ Foam::fv::gradScheme<Type>::grad
         }
 
         solution::cachePrintMessage("Retrieving", name, vsf);
-        GradFieldType& gGrad = const_cast<GradFieldType&>
+        GradFieldType& gGrad =
-        (
+            mesh().objectRegistry::template lookupObjectRef<GradFieldType>
-            mesh().objectRegistry::template lookupObject<GradFieldType>(name)
+            (
-        );
+                name
+            );
 
         if (gGrad.upToDate(vsf))
         {
@@ -123,13 +124,11 @@ Foam::fv::gradScheme<Type>::grad
 
             solution::cachePrintMessage("Storing", name, vsf);
             regIOobject::store(tgGrad.ptr());
-            GradFieldType& gGrad = const_cast<GradFieldType&>
+            GradFieldType& gGrad =
-            (
+                mesh().objectRegistry::template lookupObjectRef<GradFieldType>
-                mesh().objectRegistry::template lookupObject<GradFieldType>
                 (
                     name
-                )
+                );
-            );
 
             return gGrad;
         }
@@ -138,13 +137,11 @@ Foam::fv::gradScheme<Type>::grad
     {
         if (mesh().objectRegistry::template foundObject<GradFieldType>(name))
         {
-            GradFieldType& gGrad = const_cast<GradFieldType&>
+            GradFieldType& gGrad =
-            (
+                mesh().objectRegistry::template lookupObjectRef<GradFieldType>
-                mesh().objectRegistry::template lookupObject<GradFieldType>
                 (
                     name
-                )
+                );
-            );
 
             if (gGrad.ownedByRegistry())
             {

src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/LimitedScheme/LimitedScheme.C

@@ -171,13 +171,7 @@ Foam::LimitedScheme<Type, Limiter, LimitFunc>::limiter
         }
 
         surfaceScalarField& limiterField =
-            const_cast<surfaceScalarField&>
+            mesh.lookupObjectRef<surfaceScalarField>(limiterFieldName);
-            (
-                mesh.lookupObject<surfaceScalarField>
-                (
-                    limiterFieldName
-                )
-            );
 
         calcLimiter(phi, limiterField);
 

src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolate.C

@@ -372,20 +372,17 @@ Foam::volPointInterpolation::interpolate
     const pointMesh& pm = pointMesh::New(vf.mesh());
 
     // Construct tmp<pointField>
-    tmp<GeometricField<Type, pointPatchField, pointMesh>> tpf
+    auto tpf = tmp<GeometricField<Type, pointPatchField, pointMesh>>::New
     (
-        new GeometricField<Type, pointPatchField, pointMesh>
+        IOobject
         (
-            IOobject
+            "volPointInterpolate(" + vf.name() + ')',
-            (
+            vf.instance(),
-                "volPointInterpolate(" + vf.name() + ')',
+            pm.thisDb()
-                vf.instance(),
+        ),
-                pm.thisDb()
+        pm,
-            ),
+        vf.dimensions(),
-            pm,
+        patchFieldTypes
-            vf.dimensions(),
-            patchFieldTypes
-        )
     );
 
     interpolateInternalField(vf, tpf.ref());
@@ -427,73 +424,60 @@ Foam::volPointInterpolation::interpolate
     const pointMesh& pm = pointMesh::New(vf.mesh());
     const objectRegistry& db = pm.thisDb();
 
+    PointFieldType* pfPtr =
+        db.objectRegistry::template getObjectPtr<PointFieldType>(name);
+
     if (!cache || vf.mesh().changing())
     {
         // Delete any old occurrences to avoid double registration
-        if (db.objectRegistry::template foundObject<PointFieldType>(name))
+        if (pfPtr && pfPtr->ownedByRegistry())
         {
-            PointFieldType& pf = const_cast<PointFieldType&>
+            solution::cachePrintMessage("Deleting", name, vf);
-            (
+            pfPtr->release();
-                db.objectRegistry::template lookupObject<PointFieldType>(name)
+            delete pfPtr;
-            );
-
-            if (pf.ownedByRegistry())
-            {
-                solution::cachePrintMessage("Deleting", name, vf);
-                pf.release();
-                delete &pf;
-            }
         }
 
-
+        auto tpf = tmp<GeometricField<Type, pointPatchField, pointMesh>>::New
-        tmp<GeometricField<Type, pointPatchField, pointMesh>> tpf
         (
-            new GeometricField<Type, pointPatchField, pointMesh>
+            IOobject
             (
-                IOobject
+                name,
-                (
+                vf.instance(),
-                    name,
+                pm.thisDb()
-                    vf.instance(),
+            ),
-                    pm.thisDb()
+            pm,
-                ),
+            vf.dimensions()
-                pm,
-                vf.dimensions()
-            )
         );
 
         interpolate(vf, tpf.ref());
 
         return tpf;
     }
+
+
+    if (!pfPtr)
+    {
+        solution::cachePrintMessage("Calculating and caching", name, vf);
+
+        pfPtr = interpolate(vf, name, false).ptr();
+        regIOobject::store(pfPtr);
+    }
     else
     {
-        if (!db.objectRegistry::template foundObject<PointFieldType>(name))
+        PointFieldType& pf = *pfPtr;
+
+        if (pf.upToDate(vf))    //TBD: , vf.mesh().points()))
         {
-            solution::cachePrintMessage("Calculating and caching", name, vf);
+            solution::cachePrintMessage("Reusing", name, vf);
-            tmp<PointFieldType> tpf = interpolate(vf, name, false);
-            PointFieldType* pfPtr = tpf.ptr();
-            regIOobject::store(pfPtr);
-            return *pfPtr;
         }
         else
         {
-            PointFieldType& pf = const_cast<PointFieldType&>
+            solution::cachePrintMessage("Updating", name, vf);
-            (
+            interpolate(vf, pf);
-                db.objectRegistry::template lookupObject<PointFieldType>(name)
-            );
-
-            if (pf.upToDate(vf))    //TBD: , vf.mesh().points()))
-            {
-                solution::cachePrintMessage("Reusing", name, vf);
-            }
-            else
-            {
-                solution::cachePrintMessage("Updating", name, vf);
-                interpolate(vf, pf);
-            }
-            return pf;
         }
     }
+
+    return *pfPtr;
 }
 
 
@@ -537,74 +521,61 @@ Foam::volPointInterpolation::interpolate
     const pointMesh& pm = pointMesh::New(vf.mesh());
     const objectRegistry& db = pm.thisDb();
 
+
+    PointFieldType* pfPtr =
+        db.objectRegistry::template getObjectPtr<PointFieldType>(name);
+
     if (!cache || vf.mesh().changing())
     {
         // Delete any old occurrences to avoid double registration
-        if (db.objectRegistry::template foundObject<PointFieldType>(name))
+        if (pfPtr && pfPtr->ownedByRegistry())
         {
-            PointFieldType& pf = const_cast<PointFieldType&>
+            solution::cachePrintMessage("Deleting", name, vf);
-            (
+            pfPtr->release();
-                db.objectRegistry::template lookupObject<PointFieldType>(name)
+            delete pfPtr;
-            );
-
-            if (pf.ownedByRegistry())
-            {
-                solution::cachePrintMessage("Deleting", name, vf);
-                pf.release();
-                delete &pf;
-            }
         }
 
-
+        auto tpf = tmp<DimensionedField<Type, pointMesh>>::New
-        tmp<DimensionedField<Type, pointMesh>> tpf
         (
-            new DimensionedField<Type, pointMesh>
+            IOobject
             (
-                IOobject
+                name,
-                (
+                vf.instance(),
-                    name,
+                pm.thisDb()
-                    vf.instance(),
+            ),
-                    pm.thisDb()
+            pm,
-                ),
+            vf.dimensions()
-                pm,
-                vf.dimensions()
-            )
         );
 
         interpolateDimensionedInternalField(vf, tpf.ref());
 
         return tpf;
     }
+
+
+    if (!pfPtr)
+    {
+        solution::cachePrintMessage("Calculating and caching", name, vf);
+        pfPtr = interpolate(vf, name, false).ptr();
+
+        regIOobject::store(pfPtr);
+    }
     else
     {
-        if (!db.objectRegistry::template foundObject<PointFieldType>(name))
+        PointFieldType& pf = *pfPtr;
+
+        if (pf.upToDate(vf))    //TBD: , vf.mesh().points()))
         {
-            solution::cachePrintMessage("Calculating and caching", name, vf);
+            solution::cachePrintMessage("Reusing", name, vf);
-            tmp<PointFieldType> tpf = interpolate(vf, name, false);
-            PointFieldType* pfPtr = tpf.ptr();
-            regIOobject::store(pfPtr);
-            return *pfPtr;
         }
         else
         {
-            PointFieldType& pf = const_cast<PointFieldType&>
+            solution::cachePrintMessage("Updating", name, vf);
-            (
+            interpolateDimensionedInternalField(vf, pf);
-                db.objectRegistry::template lookupObject<PointFieldType>(name)
-            );
-
-            if (pf.upToDate(vf))    //TBD: , vf.mesh().points()))
-            {
-                solution::cachePrintMessage("Reusing", name, vf);
-            }
-            else
-            {
-                solution::cachePrintMessage("Updating", name, vf);
-                interpolateDimensionedInternalField(vf, pf);
-            }
-
-            return pf;
         }
     }
+
+    return *pfPtr;
 }
 
 

src/functionObjects/field/externalCoupled/externalCoupled.C

@@ -415,7 +415,7 @@ void Foam::functionObjects::externalCoupled::initCoupling()
         UPtrList<const fvMesh> meshes(regionNames.size());
         forAll(regionNames, regi)
         {
-            meshes.set(regi, time_.lookupObjectPtr<fvMesh>(regionNames[regi]));
+            meshes.set(regi, time_.findObject<fvMesh>(regionNames[regi]));
         }
 
         const labelList& groups = regionToGroups_[compName];
@@ -692,7 +692,7 @@ void Foam::functionObjects::externalCoupled::readDataMaster()
         UPtrList<const fvMesh> meshes(regionNames.size());
         forAll(regionNames, regi)
         {
-            meshes.set(regi, time_.lookupObjectPtr<fvMesh>(regionNames[regi]));
+            meshes.set(regi, time_.findObject<fvMesh>(regionNames[regi]));
         }
 
         const labelList& groups = regionToGroups_[compName];
@@ -736,7 +736,7 @@ void Foam::functionObjects::externalCoupled::writeDataMaster() const
         UPtrList<const fvMesh> meshes(regionNames.size());
         forAll(regionNames, regi)
         {
-            meshes.set(regi, time_.lookupObjectPtr<fvMesh>(regionNames[regi]));
+            meshes.set(regi, time_.findObject<fvMesh>(regionNames[regi]));
         }
 
         const labelList& groups = regionToGroups_[compName];

src/functionObjects/field/externalCoupled/externalCoupledTemplates.C

@@ -82,8 +82,7 @@ bool Foam::functionObjects::externalCoupled::readData
     label nFound = 0;
     for (const fvMesh& mesh : meshes)
     {
-        const volFieldType* vfptr =
+        const volFieldType* vfptr = mesh.findObject<volFieldType>(fieldName);
-            mesh.lookupObjectPtr<volFieldType>(fieldName);
 
         if (!vfptr)
         {
@@ -358,8 +357,7 @@ bool Foam::functionObjects::externalCoupled::writeData
 
     for (const fvMesh& mesh : meshes)
     {
-        const volFieldType* vfptr =
+        const volFieldType* vfptr = mesh.findObject<volFieldType>(fieldName);
-            mesh.lookupObjectPtr<volFieldType>(fieldName);
 
         if (!vfptr)
         {

src/functionObjects/field/fieldAverage/fieldAverageItem/fieldAverageItemTemplates.C

@@ -37,7 +37,7 @@ bool Foam::functionObjects::fieldAverageItem::calculateMeanField
         return false;
     }
 
-    const Type* baseFieldPtr = obr.lookupObjectPtr<Type>(fieldName_);
+    const Type* baseFieldPtr = obr.findObject<Type>(fieldName_);
 
     if (!baseFieldPtr)
     {
@@ -122,7 +122,7 @@ bool Foam::functionObjects::fieldAverageItem::calculateMeanField
                     {
                         const word& fieldName = nameIter();
                         const scalar dt = timeIter();
-                        const Type* w = obr.lookupObjectPtr<Type>(fieldName);
+                        const Type* w = obr.findObject<Type>(fieldName);
 
                         meanField += dt*(*w);
 
@@ -173,7 +173,7 @@ bool Foam::functionObjects::fieldAverageItem::calculatePrime2MeanField
         return false;
     }
 
-    const Type1* baseFieldPtr = obr.lookupObjectPtr<Type1>(fieldName_);
+    const Type1* baseFieldPtr = obr.findObject<Type1>(fieldName_);
 
     if (!baseFieldPtr)
     {
@@ -258,7 +258,7 @@ bool Foam::functionObjects::fieldAverageItem::calculatePrime2MeanField
             {
                 const word& fieldName = nameIter();
                 const scalar dt = timeIter();
-                const Type1* w = obr.lookupObjectPtr<Type1>(fieldName);
+                const Type1* w = obr.findObject<Type1>(fieldName);
 
                 prime2MeanField += dt*(sqr((*w) - meanField));
 

src/functionObjects/field/fieldAverage/fieldAverageTemplates.C

@@ -119,7 +119,7 @@ void Foam::functionObjects::fieldAverage::restoreWindowFieldsType
 
     const word& fieldName = item.fieldName();
 
-    const Type* fieldPtr = lookupObjectPtr<Type>(fieldName);
+    const Type* fieldPtr = findObject<Type>(fieldName);
 
     if (!fieldPtr)
     {

src/functionObjects/field/fieldExtents/fieldExtentsTemplates.C

@@ -54,7 +54,7 @@ void Foam::functionObjects::fieldExtents::calcFieldExtents
     typedef GeometricField<Type, fvPatchField, volMesh> VolFieldType;
 
     const VolFieldType* fieldPtr =
-        obr_.lookupObjectPtr<VolFieldType>(fieldName);
+        obr_.findObject<VolFieldType>(fieldName);
 
     if (!fieldPtr)
     {

src/functionObjects/field/fluxSummary/fluxSummary.C

@@ -129,7 +129,7 @@ void Foam::functionObjects::fluxSummary::initialiseSurface
     DynamicList<boolList>& faceFlip
 ) const
 {
-    const surfMesh* sPtr = mesh_.lookupObjectPtr<surfMesh>(surfName);
+    const surfMesh* sPtr = mesh_.findObject<surfMesh>(surfName);
     if (!sPtr)
     {
         FatalErrorInFunction
@@ -154,7 +154,7 @@ void Foam::functionObjects::fluxSummary::initialiseSurfaceAndDirection
     DynamicList<boolList>& faceFlip
 ) const
 {
-    const surfMesh* sPtr = mesh_.lookupObjectPtr<surfMesh>(surfName);
+    const surfMesh* sPtr = mesh_.findObject<surfMesh>(surfName);
     if (!sPtr)
     {
         FatalErrorInFunction

src/functionObjects/field/readFields/readFieldsTemplates.C

@@ -47,13 +47,15 @@ bool Foam::functionObjects::readFields::loadField(const word& fieldName)
     }
     else if (foundObject<SurfaceFieldType>(fieldName))
     {
-        DebugInfo<< "readFields: " << SurfaceFieldType::typeName
+        DebugInfo
+            << "readFields: " << SurfaceFieldType::typeName
             << " " << fieldName << " already exists in database"
             << " already in database" << endl;
     }
     else if (foundObject<SurfFieldType>(fieldName))
     {
-        DebugInfo<< "readFields: " << SurfFieldType::typeName
+        DebugInfo
+            << "readFields: " << SurfFieldType::typeName
             << " " << fieldName << " already exists in database"
             << " already in database" << endl;
     }

src/functionObjects/field/reference/referenceTemplates.C

@@ -30,7 +30,7 @@ bool Foam::functionObjects::reference::calcType()
 {
     typedef GeometricField<Type, fvPatchField, volMesh> VolFieldType;
 
-    const VolFieldType* vfPtr = lookupObjectPtr<VolFieldType>(fieldName_);
+    const VolFieldType* vfPtr = findObject<VolFieldType>(fieldName_);
 
     if (vfPtr)
     {

src/functionObjects/field/setFlow/setFlow.C

@@ -66,7 +66,7 @@ Foam::functionObjects::setFlow::modeTypeNames
 void Foam::functionObjects::setFlow::setPhi(const volVectorField& U)
 {
     surfaceScalarField* phiptr =
-        mesh_.lookupObjectRefPtr<surfaceScalarField>(phiName_);
+        mesh_.getObjectPtr<surfaceScalarField>(phiName_);
 
     if (!phiptr)
     {
@@ -76,7 +76,7 @@ void Foam::functionObjects::setFlow::setPhi(const volVectorField& U)
     if (rhoName_ != "none")
     {
         const volScalarField* rhoptr =
-            mesh_.lookupObjectPtr<volScalarField>(rhoName_);
+            mesh_.findObject<volScalarField>(rhoName_);
 
         if (rhoptr)
         {
@@ -207,10 +207,11 @@ bool Foam::functionObjects::setFlow::read(const dictionary& dict)
 
 bool Foam::functionObjects::setFlow::execute()
 {
-    volVectorField* Uptr = mesh_.lookupObjectRefPtr<volVectorField>(UName_);
+    volVectorField* Uptr =
+        mesh_.getObjectPtr<volVectorField>(UName_);
 
     surfaceScalarField* phiptr =
-        mesh_.lookupObjectRefPtr<surfaceScalarField>(phiName_);
+        mesh_.getObjectPtr<surfaceScalarField>(phiName_);
 
     Log << nl << name() << ":" << nl;
 
@@ -431,13 +432,13 @@ bool Foam::functionObjects::setFlow::execute()
 
 bool Foam::functionObjects::setFlow::write()
 {
-    const auto& Uptr = mesh_.lookupObjectRefPtr<volVectorField>(UName_);
+    const auto* Uptr = mesh_.findObject<volVectorField>(UName_);
     if (Uptr)
     {
         Uptr->write();
     }
 
-    const auto& phiptr = mesh_.lookupObjectRefPtr<surfaceScalarField>(phiName_);
+    const auto* phiptr = mesh_.findObject<surfaceScalarField>(phiName_);
     if (phiptr)
     {
         phiptr->write();

src/functionObjects/field/stabilityBlendingFactor/stabilityBlendingFactor.C

@@ -102,8 +102,7 @@ bool Foam::functionObjects::stabilityBlendingFactor::calc()
 
 bool Foam::functionObjects::stabilityBlendingFactor::init(bool first)
 {
-    const IOField<scalar>* residualPtr =
+    const auto* residualPtr = mesh_.findObject<IOField<scalar>>(residualName_);
-        mesh_.lookupObjectPtr<IOField<scalar>>(residualName_);
 
     if (residuals_)
     {
@@ -164,7 +163,7 @@ bool Foam::functionObjects::stabilityBlendingFactor::init(bool first)
     }
 
     const volScalarField* nonOrthPtr =
-        mesh_.lookupObjectPtr<volScalarField>(nonOrthogonalityName_);
+        mesh_.findObject<volScalarField>(nonOrthogonalityName_);
 
     if (nonOrthogonality_)
     {
@@ -200,7 +199,7 @@ bool Foam::functionObjects::stabilityBlendingFactor::init(bool first)
     }
 
     const volScalarField* skewnessPtr =
-        mesh_.lookupObjectPtr<volScalarField>(skewnessName_);
+        mesh_.findObject<volScalarField>(skewnessName_);
 
     if (skewness_)
     {
@@ -235,7 +234,7 @@ bool Foam::functionObjects::stabilityBlendingFactor::init(bool first)
     }
 
     const volScalarField* faceWeightsPtr =
-        mesh_.lookupObjectPtr<volScalarField>(faceWeightName_);
+        mesh_.findObject<volScalarField>(faceWeightName_);
 
     if (faceWeight_)
     {
@@ -342,7 +341,7 @@ bool Foam::functionObjects::stabilityBlendingFactor::init(bool first)
 
 
     const volVectorField* UNamePtr =
-        mesh_.lookupObjectPtr<volVectorField>(UName_);
+        mesh_.findObject<volVectorField>(UName_);
 
     if (Co_)
     {
@@ -520,7 +519,7 @@ Foam::functionObjects::stabilityBlendingFactor::stabilityBlendingFactor
     store(resultName_, faceBlendedPtr);
 
     const volScalarField* nonOrthPtr =
-        mesh_.lookupObjectPtr<volScalarField>(nonOrthogonalityName_);
+        mesh_.findObject<volScalarField>(nonOrthogonalityName_);
 
     if (nonOrthogonality_)
     {
@@ -552,7 +551,7 @@ Foam::functionObjects::stabilityBlendingFactor::stabilityBlendingFactor
 
 
     const volScalarField* faceWeightsPtr =
-        mesh_.lookupObjectPtr<volScalarField>(faceWeightName_);
+        mesh_.findObject<volScalarField>(faceWeightName_);
 
     if (faceWeight_)
     {
@@ -583,7 +582,7 @@ Foam::functionObjects::stabilityBlendingFactor::stabilityBlendingFactor
     }
 
     const volScalarField* skewnessPtr =
-        mesh_.lookupObjectPtr<volScalarField>(skewnessName_);
+        mesh_.findObject<volScalarField>(skewnessName_);
 
     if (skewness_)
     {

src/functionObjects/field/surfaceInterpolate/surfaceInterpolate.C

@@ -107,14 +107,12 @@ bool Foam::functionObjects::surfaceInterpolate::write()
     {
         const word& fieldName = fieldSet_[i].second();
 
-        if (mesh_.foundObject<regIOobject>(fieldName))
+        const regIOobject* ioptr = obr_.findObject<regIOobject>(fieldName);
+
+        if (ioptr)
         {
             Log << "        " << fieldName << nl;
-
+            ioptr->write();
-            const regIOobject& field =
-                obr_.lookupObject<regIOobject>(fieldName);
-
-            field.write();
         }
         else
         {

src/functionObjects/field/turbulenceFields/turbulenceFields.C

@@ -103,12 +103,10 @@ bool Foam::functionObjects::turbulenceFields::compressible()
     {
         return false;
     }
-    else
+
-    {
+    FatalErrorInFunction
-        FatalErrorInFunction
+        << "Turbulence model not found in database, deactivating"
-            << "Turbulence model not found in database, deactivating"
+        << exit(FatalError);
-            << exit(FatalError);
-    }
 
     return false;
 }

src/functionObjects/field/turbulenceFields/turbulenceFieldsTemplates.C

@@ -38,10 +38,11 @@ void Foam::functionObjects::turbulenceFields::processField
 
     const word scopedName = modelName + ':' + fieldName;
 
-    if (obr_.foundObject<FieldType>(scopedName))
+    FieldType* fldPtr = obr_.getObjectPtr<FieldType>(scopedName);
+
+    if (fldPtr)
     {
-        FieldType& fld = obr_.lookupObjectRef<FieldType>(scopedName);
+        (*fldPtr) == tvalue();
-        fld == tvalue();
     }
     else if (obr_.found(scopedName))
     {

src/functionObjects/field/vorticity/vorticity.C

@@ -57,12 +57,8 @@ bool Foam::functionObjects::vorticity::calc()
             fvc::curl(lookupObject<volVectorField>(fieldName_))
         );
     }
-    else
-    {
-        return false;
-    }
 
-    return true;
+    return false;
 }
 
 

src/functionObjects/field/wallShearStress/wallShearStress.C

@@ -183,28 +183,48 @@ bool Foam::functionObjects::wallShearStress::execute()
     volVectorField& wallShearStress =
         mesh_.lookupObjectRef<volVectorField>(type());
 
-    const word& turbModelName = turbulenceModel::propertiesName;
+    bool ok = false;
-    auto cmpModelPtr =
-        mesh_.lookupObjectPtr<compressible::turbulenceModel>(turbModelName);
-    auto icoModelPtr =
-        mesh_.lookupObjectPtr<incompressible::turbulenceModel>(turbModelName);
 
-    if (cmpModelPtr)
+    // compressible
+    if (!ok)
     {
-        calcShearStress(cmpModelPtr->devRhoReff(), wallShearStress);
+        typedef compressible::turbulenceModel turbType;
+
+        const turbType* modelPtr =
+            findObject<turbType>(turbulenceModel::propertiesName);
+
+        ok = modelPtr;
+
+        if (ok)
+        {
+            calcShearStress(modelPtr->devRhoReff(), wallShearStress);
+        }
     }
-    else if (icoModelPtr)
+
+    // incompressible
+    if (!ok)
     {
-        calcShearStress(icoModelPtr->devReff(), wallShearStress);
+        typedef incompressible::turbulenceModel turbType;
+
+        const turbType* modelPtr =
+            findObject<turbType>(turbulenceModel::propertiesName);
+
+        ok = modelPtr;
+
+        if (ok)
+        {
+            calcShearStress(modelPtr->devReff(), wallShearStress);
+        }
     }
-    else
+
+    if (!ok)
     {
         FatalErrorInFunction
             << "Unable to find turbulence model in the "
             << "database" << exit(FatalError);
     }
 
-    return true;
+    return ok;
 }
 
 

src/functionObjects/field/zeroGradient/zeroGradient.C

@@ -176,16 +176,15 @@ bool Foam::functionObjects::zeroGradient::write()
     }
 
     // Consistent output order
-    const wordList outputList = results_.sortedToc();
+    for (const word& fieldName : results_.sortedToc())
-    for (const word& fieldName : outputList)
     {
-        if (foundObject<regIOobject>(fieldName))
+        const regIOobject* ioptr = findObject<regIOobject>(fieldName);
-        {
-            const regIOobject& io = lookupObject<regIOobject>(fieldName);
 
+        if (ioptr)
+        {
             Log << "    " << fieldName << endl;
 
-            io.write();
+            ioptr->write();
         }
     }
 

src/functionObjects/lagrangian/vtkCloud/vtkCloud.C

@@ -106,7 +106,7 @@ bool Foam::functionObjects::vtkCloud::writeCloud
     const word& cloudName
 )
 {
-    const auto* objPtr = mesh_.lookupObjectPtr<cloud>(cloudName);
+    const auto* objPtr = mesh_.findObject<cloud>(cloudName);
     if (!objPtr)
     {
         return false;
@@ -127,7 +127,7 @@ bool Foam::functionObjects::vtkCloud::writeCloud
 
     objPtr->writeObjects(obrTmp);
 
-    const auto* pointsPtr = obrTmp.lookupObjectPtr<vectorField>("position");
+    const auto* pointsPtr = obrTmp.findObject<vectorField>("position");
 
     if (!pointsPtr)
     {

src/functionObjects/lagrangian/vtkCloud/vtkCloudTemplates.C

@@ -52,7 +52,7 @@ Foam::wordList Foam::functionObjects::vtkCloud::writeFields
 
     for (const word& fieldName : fieldNames)
     {
-        const auto* fldPtr = obrTmp.lookupObjectPtr<IOField<Type>>(fieldName);
+        const auto* fldPtr = obrTmp.findObject<IOField<Type>>(fieldName);
 
         if (Pstream::master())
         {

src/functionObjects/solvers/energyTransport/energyTransport.C

@@ -83,7 +83,7 @@ Foam::functionObjects::energyTransport::kappaEff() const
     {
         typedef incompressible::turbulenceModel turbType;
 
-        const turbType* turbPtr = lookupObjectPtr<turbType>
+        const turbType* turbPtr = findObject<turbType>
         (
             turbulenceModel::propertiesName
         );
@@ -305,7 +305,7 @@ Foam::functionObjects::energyTransport::energyTransport
             phases_.set
             (
                 i,
-                mesh_.lookupObjectRefPtr<volScalarField>(phaseNames_[i])
+                mesh_.getObjectPtr<volScalarField>(phaseNames_[i])
             );
         }
 

src/functionObjects/solvers/scalarTransport/scalarTransport.C

@@ -88,10 +88,7 @@ Foam::tmp<Foam::volScalarField> Foam::functionObjects::scalarTransport::D
     const surfaceScalarField& phi
 ) const
 {
-    typedef incompressible::turbulenceModel icoModel;
+    const word Dname("D" + s.name());
-    typedef compressible::turbulenceModel cmpModel;
-
-    word Dname("D" + s.name());
 
     if (constantD_)
     {
@@ -109,38 +106,49 @@ Foam::tmp<Foam::volScalarField> Foam::functionObjects::scalarTransport::D
             dimensionedScalar(Dname, phi.dimensions()/dimLength, D_)
         );
     }
-    else if (nutName_ != "none")
+
+    if (nutName_ != "none")
     {
         const volScalarField& nutMean =
             mesh_.lookupObject<volScalarField>(nutName_);
 
         return tmp<volScalarField>::New(Dname, nutMean);
     }
-    else if (foundObject<icoModel>(turbulenceModel::propertiesName))
-    {
-        const icoModel& model = lookupObject<icoModel>
-        (
-            turbulenceModel::propertiesName
-        );
 
-        return tmp<volScalarField>::New
+    // Incompressible
-        (
+    {
-            Dname,
+        const auto* turb =
-            alphaD_*model.nu() + alphaDt_*model.nut()
+            findObject<incompressible::turbulenceModel>
-        );
+            (
+                turbulenceModel::propertiesName
+            );
+
+        if (turb)
+        {
+            return tmp<volScalarField>::New
+            (
+                Dname,
+                alphaD_ * turb->nu() + alphaDt_ * turb->nut()
+            );
+        }
     }
-    else if (foundObject<cmpModel>(turbulenceModel::propertiesName))
-    {
-        const cmpModel& model = lookupObject<cmpModel>
-        (
-            turbulenceModel::propertiesName
-        );
 
-        return tmp<volScalarField>::New
+    // Compressible
-        (
+    {
-            Dname,
+        const auto* turb =
-            alphaD_*model.mu() + alphaDt_*model.mut()
+            findObject<compressible::turbulenceModel>
-        );
+            (
+                turbulenceModel::propertiesName
+            );
+
+        if (turb)
+        {
+            return tmp<volScalarField>::New
+            (
+                Dname,
+                alphaD_ * turb->mu() + alphaDt_ * turb->mut()
+            );
+        }
     }
 
 

src/functionObjects/utilities/ensightWrite/ensightWriteTemplates.C

@@ -38,10 +38,16 @@ int Foam::functionObjects::ensightWrite::writeVolField
     // State: return 0 (not-processed), -1 (skip), +1 ok
     typedef GeometricField<Type, fvPatchField, volMesh> VolFieldType;
 
-    const VolFieldType* fldPtr;
+    // Already done
+    if (state)
+    {
+        return state;
+    }
 
-    // Already done, or not available
+    const VolFieldType* fldPtr = findObject<VolFieldType>(inputName);
-    if (state || !(fldPtr = lookupObjectPtr<VolFieldType>(inputName)))
+
+    // Not available
+    if (!fldPtr)
     {
         return state;
     }

src/functionObjects/utilities/removeRegisteredObject/removeRegisteredObject.C

@@ -82,22 +82,18 @@ bool Foam::functionObjects::removeRegisteredObject::read(const dictionary& dict)
 
 bool Foam::functionObjects::removeRegisteredObject::execute()
 {
-    forAll(objectNames_, i)
+    for (const word& objName : objectNames_)
     {
-        if (foundObject<regIOobject>(objectNames_[i]))
+        regIOobject* ptr = getObjectPtr<regIOobject>(objName);
+
+        if (ptr && ptr->ownedByRegistry())
         {
-            const regIOobject& obj =
+            Log << type() << " " << name() << " output:" << nl
-                lookupObject<regIOobject>(objectNames_[i]);
+                << "    removing object " << ptr->name() << nl
+                << endl;
 
-            if (obj.ownedByRegistry())
+            ptr->release();
-            {
+            delete ptr;
-                Log << type() << " " << name() << " output:" << nl
-                    << "    removing object " << obj.name() << nl
-                    << endl;
-
-                const_cast<regIOobject&>(obj).release();
-                delete &obj;
-            }
         }
     }
 

src/functionObjects/utilities/residuals/residuals.C

@@ -113,8 +113,7 @@ void Foam::functionObjects::residuals::writeField(const word& fieldName) const
 {
     const word residualName("initialResidual:" + fieldName);
 
-    const IOField<scalar>* residualPtr =
+    const auto* residualPtr = mesh_.findObject<IOField<scalar>>(residualName);
-        mesh_.lookupObjectPtr<IOField<scalar>>(residualName);
 
     if (residualPtr)
     {

src/functionObjects/utilities/writeDictionary/writeDictionary.C

@@ -160,10 +160,12 @@ bool Foam::functionObjects::writeDictionary::write()
     bool firstDict = true;
     forAll(dictNames_, i)
     {
-        if (obr_.foundObject<dictionary>(dictNames_[i]))
+        const dictionary* dictptr =
+            obr_.findObject<dictionary>(dictNames_[i]);
+
+        if (dictptr)
         {
-            const dictionary& dict =
+            const dictionary& dict = *dictptr;
-                obr_.lookupObject<dictionary>(dictNames_[i]);
 
             if (dict.digest() != digests_[i])
             {

src/fvMotionSolver/pointPatchFields/derived/uniformInterpolatedDisplacement/uniformInterpolatedDisplacementPointPatchVectorField.C

@@ -211,13 +211,9 @@ void uniformInterpolatedDisplacementPointPatchVectorField::updateCoeffs()
                 >(*fieldsCacheIter());
 
 
-                pointVectorField& d = const_cast<pointVectorField&>
+                pointVectorField& d =
-                (
+                    timeCache.lookupObjectRef<pointVectorField>(fieldName_);
-                    timeCache.lookupObject<pointVectorField>
+
-                    (
-                        fieldName_
-                    )
-                );
                 d.correctBoundaryConditions();
             }
         }

src/fvOptions/sources/derived/viscousDissipation/viscousDissipation.C

@@ -106,7 +106,7 @@ Foam::fv::viscousDissipation::viscousDissipation
     )
 {
     const basicThermo* thermoPtr =
-        mesh_.lookupObjectPtr<basicThermo>(basicThermo::dictName);
+        mesh_.findObject<basicThermo>(basicThermo::dictName);
 
     if (thermoPtr)
     {
@@ -136,7 +136,7 @@ Foam::fv::viscousDissipation::devRhoReff() const
     // Incompressible
     {
         const auto* turbPtr =
-            mesh_.lookupObjectPtr<incompressible::turbulenceModel>
+            mesh_.findObject<incompressible::turbulenceModel>
             (
                 turbulenceModel::propertiesName
             );
@@ -150,7 +150,7 @@ Foam::fv::viscousDissipation::devRhoReff() const
     // Compressible
     {
         const auto* turbPtr =
-            mesh_.lookupObjectPtr<compressible::turbulenceModel>
+            mesh_.findObject<compressible::turbulenceModel>
             (
                 turbulenceModel::propertiesName
             );
@@ -196,8 +196,7 @@ void Foam::fv::viscousDissipation::addSup
     );
 
     // Cached?
-    const GradFieldType* gradUPtr =
+    const GradFieldType* gradUPtr = mesh_.findObject<GradFieldType>(gradUName);
-        mesh_.lookupObjectPtr<GradFieldType>(gradUName);
 
     if (gradUPtr)
     {

src/fvOptions/sources/interRegion/interRegionHeatTransfer/interRegionHeatTransferModel/interRegionHeatTransferModel.C

@@ -206,10 +206,12 @@ void Foam::fv::interRegionHeatTransferModel::addSup
     {
         if (he.dimensions() == dimEnergy/dimMass)
         {
-            if (mesh_.foundObject<basicThermo>(basicThermo::dictName))
+            const basicThermo* thermoPtr =
+                mesh_.findObject<basicThermo>(basicThermo::dictName);
+
+            if (thermoPtr)
             {
-                const basicThermo& thermo =
+                const basicThermo& thermo = *thermoPtr;
-                   mesh_.lookupObject<basicThermo>(basicThermo::dictName);
 
                 volScalarField htcByCpv(htc_/thermo.Cpv());
 

src/lagrangian/intermediate/submodels/Kinematic/ParticleForces/Interface/InterfaceForce.C

@@ -101,10 +101,10 @@ void Foam::InterfaceForce<CloudType>::cacheFields(const bool store)
 
         if (fieldExists)
         {
-            const volVectorField& gradInterForce = this->mesh().template
+            volVectorField& gradInterForce =
-                lookupObject<volVectorField>(fName);
+                this->mesh().template lookupObjectRef<volVectorField>(fName);
 
-            const_cast<volVectorField&>(gradInterForce).checkOut();
+            gradInterForce.checkOut();
         }
     }
 }

src/lagrangian/intermediate/submodels/Kinematic/ParticleForces/Lift/LiftForce/LiftForce.C

@@ -116,10 +116,10 @@ void Foam::LiftForce<CloudType>::cacheFields(const bool store)
 
         if (fieldExists)
         {
-            const volVectorField& curlUc = this->mesh().template
+            volVectorField& curlUc =
-                lookupObject<volVectorField>(fName);
+                this->mesh().template lookupObjectRef<volVectorField>(fName);
 
-            const_cast<volVectorField&>(curlUc).checkOut();
+            curlUc.checkOut();
         }
     }
 }

src/lagrangian/intermediate/submodels/Kinematic/ParticleForces/PressureGradient/PressureGradientForce.C

@@ -106,10 +106,10 @@ void Foam::PressureGradientForce<CloudType>::cacheFields(const bool store)
 
         if (fieldExists)
         {
-            const volVectorField& DUcDt = this->mesh().template
+            volVectorField& DUcDt =
-                lookupObject<volVectorField>(fName);
+                this->mesh().template lookupObjectRef<volVectorField>(fName);
 
-            const_cast<volVectorField&>(DUcDt).checkOut();
+            DUcDt.checkOut();
         }
     }
 }

src/lagrangian/turbulence/submodels/Kinematic/DispersionModel/DispersionRASModel/DispersionRASModel.C

@@ -41,11 +41,11 @@ Foam::DispersionRASModel<CloudType>::kModel() const
             this->owner().U().group()
         );
 
-    if (obr.foundObject<turbulenceModel>(turbName))
+    const turbulenceModel* turb = obr.findObject<turbulenceModel>(turbName);
+
+    if (turb)
     {
-        const turbulenceModel& model =
+        return turb->k();
-            obr.lookupObject<turbulenceModel>(turbName);
-        return model.k();
     }
 
     FatalErrorInFunction
@@ -69,11 +69,11 @@ Foam::DispersionRASModel<CloudType>::epsilonModel() const
             this->owner().U().group()
         );
 
-    if (obr.foundObject<turbulenceModel>(turbName))
+    const turbulenceModel* turb = obr.findObject<turbulenceModel>(turbName);
+
+    if (turb)
     {
-        const turbulenceModel& model =
+        return turb->epsilon();
-            obr.lookupObject<turbulenceModel>(turbName);
-        return model.epsilon();
     }
 
     FatalErrorInFunction

src/lagrangian/turbulence/submodels/Thermodynamic/ParticleForces/BrownianMotion/BrownianMotionForce.C

@@ -64,11 +64,11 @@ Foam::BrownianMotionForce<CloudType>::kModel() const
             this->owner().U().group()
         );
 
-    if (obr.foundObject<turbulenceModel>(turbName))
+    const turbulenceModel* turb = obr.findObject<turbulenceModel>(turbName);
+
+    if (turb)
     {
-        const turbulenceModel& model =
+        return turb->k();
-            obr.lookupObject<turbulenceModel>(turbName);
-        return model.k();
     }
 
     FatalErrorInFunction

src/lumpedPointMotion/lumpedPointIOMovement.C

@@ -39,7 +39,7 @@ namespace Foam
 const Foam::lumpedPointIOMovement*
 Foam::lumpedPointIOMovement::lookupInRegistry(const objectRegistry& obr)
 {
-    return obr.lookupObjectPtr<lumpedPointIOMovement>
+    return obr.findObject<lumpedPointIOMovement>
     (
         lumpedPointMovement::canonicalName
     );

src/lumpedPointMotion/lumpedPointMovement.C

@@ -495,7 +495,7 @@ bool Foam::lumpedPointMovement::forcesAndMoments
     // Calculated force per patch - cache
     PtrMap<vectorField> forceOnPatches;
 
-    const volScalarField* pPtr = pmesh.lookupObjectPtr<volScalarField>(pName);
+    const volScalarField* pPtr = pmesh.findObject<volScalarField>(pName);
 
     // fvMesh and has pressure field
     if (isA<fvMesh>(pmesh) && pPtr)

src/meshTools/coordinate/systems/coordinateSystems.C

@@ -240,8 +240,7 @@ const Foam::coordinateSystems& Foam::coordinateSystems::New
 {
     // Previously registered?
 
-    const coordinateSystems* ptr =
+    const coordinateSystems* ptr = obr.findObject<coordinateSystems>(typeName);
-        obr.lookupObjectPtr<coordinateSystems>(typeName);
 
     if (ptr)
     {

src/meshTools/regionCoupled/GAMG/interfaces/regionCoupledGAMGInterface/regionCoupledBaseGAMGInterface.C

@@ -100,19 +100,16 @@ Foam::regionCoupledBaseGAMGInterface::regionCoupledBaseGAMGInterface
         const polyMesh& nbrMesh =
             fineRegionCoupledLduInterface_.nbrMesh();
 
-        if
+        const GAMGAgglomeration* nbrAggPtr = nbrMesh.thisDb().findObject
-        (
+            <GAMGAgglomeration>
-            nbrMesh.foundObject<GAMGAgglomeration>(GAMGAgglomeration::typeName)
-        )
-        {
-            const GAMGAgglomeration& nbrAgg = nbrMesh.thisDb().lookupObject
-            <
-                GAMGAgglomeration
-            >
             (
                 GAMGAgglomeration::typeName
             );
 
+        if (nbrAggPtr)
+        {
+            const GAMGAgglomeration& nbrAgg = *nbrAggPtr;
+
             label nbrLevel(-1);
             if (nbrAgg.size() > fineLevelIndex)
             {

src/meshTools/regionCoupled/patches/regionCoupledPolyPatch/regionCoupledBase.C

@@ -187,19 +187,15 @@ Foam::label Foam::regionCoupledBase::neighbPatchID() const
 {
     if (nbrPatchID_ == -1)
     {
-        if
+        const polyMesh* meshPtr =
-        (
+            patch_.boundaryMesh().mesh().time().findObject<polyMesh>
-            patch_.boundaryMesh().mesh().time().foundObject<polyMesh>
             (
                 nbrRegionName_
-            )
+            );
-        )
+
+        if (meshPtr)
         {
-            const polyMesh& mesh =
+            const polyMesh& mesh = *meshPtr;
-                patch_.boundaryMesh().mesh().time().lookupObject<polyMesh>
-                (
-                    nbrRegionName_
-                );
 
             nbrPatchID_ = mesh.boundaryMesh().findPatchID(nbrPatchName_);
 

src/meshTools/searchableSurfaces/searchableSurfaceCollection/searchableSurfaceCollection.C

@@ -205,8 +205,8 @@ Foam::searchableSurfaceCollection::searchableSurfaceCollection
             const word subGeomName(subDict.get<word>("surface"));
             //Pout<< "Trying to find " << subGeomName << endl;
 
-            const searchableSurface& s =
+            searchableSurface& s =
-                io.db().lookupObject<searchableSurface>(subGeomName);
+                io.db().lookupObjectRef<searchableSurface>(subGeomName);
 
             // I don't know yet how to handle the globalSize combined with
             // regionOffset. Would cause non-consecutive indices locally
@@ -218,7 +218,7 @@ Foam::searchableSurfaceCollection::searchableSurfaceCollection
                     << exit(FatalError);
             }
 
-            subGeom_.set(surfI, &(const_cast<searchableSurface&>(s)));
+            subGeom_.set(surfI, &s);
 
             indexOffset_[surfI] = startIndex;
             startIndex += subGeom_[surfI].size();

src/meshTools/searchableSurfaces/searchableSurfaceWithGaps/searchableSurfaceWithGaps.C

@@ -189,7 +189,7 @@ Foam::searchableSurfaceWithGaps::searchableSurfaceWithGaps
     subGeom_.set
     (
         0,
-        io.db().lookupObjectRefPtr<searchableSurface>(subGeomName)
+        io.db().getObjectPtr<searchableSurface>(subGeomName)
     );
 
     bounds() = subGeom_[0].bounds();

src/meshTools/searchableSurfaces/triSurfaceMesh/triSurfaceMesh.C

@@ -803,14 +803,15 @@ void Foam::triSurfaceMesh::getNormal
 
 void Foam::triSurfaceMesh::setField(const labelList& values)
 {
+    auto* fldPtr = getObjectPtr<triSurfaceLabelField>("values");
 
-    if (foundObject<triSurfaceLabelField>("values"))
+    if (fldPtr)
     {
-        lookupObjectRef<triSurfaceLabelField>("values").field() = values;
+        (*fldPtr).field() = values;
     }
     else
     {
-        auto fldPtr = autoPtr<triSurfaceLabelField>::New
+        fldPtr = new triSurfaceLabelField
         (
             IOobject
             (
@@ -827,7 +828,7 @@ void Foam::triSurfaceMesh::setField(const labelList& values)
         );
 
         // Store field on triMesh
-        fldPtr.ptr()->store();
+        fldPtr->store();
     }
 }
 
@@ -838,9 +839,11 @@ void Foam::triSurfaceMesh::getField
     labelList& values
 ) const
 {
-    if (foundObject<triSurfaceLabelField>("values"))
+    const auto* fldPtr = getObjectPtr<triSurfaceLabelField>("values");
+
+    if (fldPtr)
     {
-        const auto& fld = lookupObject<triSurfaceLabelField>("values");
+        const auto& fld = *fldPtr;
 
         values.setSize(info.size());
 

src/parallel/decompose/decompositionMethods/decompositionConstraints/refinementHistory/refinementHistoryConstraint.C

@@ -84,24 +84,13 @@ void Foam::refinementHistoryConstraint::add
     List<labelPair>& explicitConnections
 ) const
 {
-    autoPtr<const refinementHistory> storagePtr;
+    const refinementHistory* refPtr =
-    refinementHistory const* refPtr = nullptr;
+        mesh.findObject<refinementHistory>("refinementHistory");
 
-    if (mesh.foundObject<refinementHistory>("refinementHistory"))
+    autoPtr<const refinementHistory> storagePtr;
+
+    if (!refPtr)
     {
-        if (decompositionConstraint::debug)
-        {
-            Info<< type() << " : found refinementHistory" << endl;
-        }
-        refPtr = &mesh.lookupObject<refinementHistory>("refinementHistory");
-    }
-    else
-    {
-        if (decompositionConstraint::debug)
-        {
-            Info<< type() << " : reading refinementHistory from time "
-                << mesh.facesInstance() << endl;
-        }
         storagePtr.reset
         (
             new refinementHistory
@@ -120,6 +109,19 @@ void Foam::refinementHistoryConstraint::add
         );
     }
 
+    if (decompositionConstraint::debug)
+    {
+        if (refPtr)
+        {
+            Info<< type() << " : found refinementHistory" << nl;
+        }
+        else
+        {
+            Info<< type() << " : reading refinementHistory from time "
+                << mesh.facesInstance() << nl;
+        }
+    }
+
     const refinementHistory& history =
     (
         storagePtr.valid()
@@ -151,24 +153,13 @@ void Foam::refinementHistoryConstraint::apply
     labelList& decomposition
 ) const
 {
-    autoPtr<const refinementHistory> storagePtr;
+    const refinementHistory* refPtr =
-    refinementHistory const* refPtr = nullptr;
+        mesh.findObject<refinementHistory>("refinementHistory");
 
-    if (mesh.foundObject<refinementHistory>("refinementHistory"))
+    autoPtr<const refinementHistory> storagePtr;
+
+    if (!refPtr)
     {
-        //if (decompositionConstraint::debug)
-        //{
-        //    Info<< type() << " : found refinementHistory" << endl;
-        //}
-        refPtr = &mesh.lookupObject<refinementHistory>("refinementHistory");
-    }
-    else
-    {
-        //if (decompositionConstraint::debug)
-        //{
-        //    Info<< type() << " : reading refinementHistory from time "
-        //        << mesh.facesInstance() << endl;
-        //}
         storagePtr.reset
         (
             new refinementHistory

src/parallel/distributed/distributedTriSurfaceMesh/distributedTriSurfaceMesh.C

@@ -808,7 +808,7 @@ Foam::distributedTriSurfaceMesh::independentlyDistributedBbs
         // here since we've only got Time and not a mesh.
 
         const auto* dictPtr =
-            searchableSurface::time().lookupObjectPtr<IOdictionary>
+            searchableSurface::time().findObject<IOdictionary>
             (
                 // == decompositionModel::canonicalName
                 "decomposeParDict"
@@ -1914,13 +1914,11 @@ void Foam::distributedTriSurfaceMesh::getField
         return;
     }
 
-    if (foundObject<triSurfaceLabelField>("values"))
+    const auto* fldPtr = findObject<triSurfaceLabelField>("values");
-    {
-        const triSurfaceLabelField& fld = lookupObject<triSurfaceLabelField>
-        (
-            "values"
-        );
 
+    if (fldPtr)
+    {
+        const triSurfaceLabelField& fld = *fldPtr;
 
         // Get query data (= local index of triangle)
         // ~~~~~~~~~~~~~~

src/regionCoupled/derivedFvPatchFields/energyRegionCoupled/energyRegionCoupledFvPatchScalarField.C

@@ -67,23 +67,19 @@ void Foam::energyRegionCoupledFvPatchScalarField::setMethod() const
     if (!nbrThermoPtr_)
     {
         nbrThermoPtr_ =
-        (
+            regionCoupledPatch_.nbrMesh().findObject<basicThermo>
-            &regionCoupledPatch_.nbrMesh().lookupObject<basicThermo>
             (
                 basicThermo::dictName
-            )
+            );
-        );
     }
 
     if (!thermoPtr_)
     {
         thermoPtr_ =
-        (
+            this->db().findObject<basicThermo>
-            &this->db().lookupObject<basicThermo>
             (
                 basicThermo::dictName
-            )
+            );
-        );
     }
 }
 

src/regionModels/regionCoupling/derivedFvPatchFields/filmPyrolysisTemperatureCoupled/filmPyrolysisTemperatureCoupledFvPatchScalarField.C

@@ -123,35 +123,37 @@ void Foam::filmPyrolysisTemperatureCoupledFvPatchScalarField::updateCoeffs()
         return;
     }
 
-    typedef regionModels::surfaceFilmModels::surfaceFilmRegionModel
+    // Film model
-        filmModelType;
+    const auto* filmModelPtr = db().time().findObject
+        <regionModels::surfaceFilmModels::surfaceFilmRegionModel>
+        (filmRegionName_);
+
+    // Pyrolysis model
+    const auto* pyrModelPtr = db().time().findObject
+        <regionModels::pyrolysisModels::pyrolysisModel>
+        (pyrolysisRegionName_);
+
+    if (!filmModelPtr || !pyrModelPtr)
+    {
+        // Do nothing on construction - film model doesn't exist yet
+        return;
+    }
+
+    const auto& filmModel = *filmModelPtr;
+    const auto& pyrModel = *pyrModelPtr;
 
-    typedef regionModels::pyrolysisModels::pyrolysisModel pyrModelType;
 
     // Since we're inside initEvaluate/evaluate there might be processor
     // comms underway. Change the tag we use.
     int oldTag = UPstream::msgType();
     UPstream::msgType() = oldTag+1;
 
-    bool filmOk = db().time().foundObject<filmModelType>(filmRegionName_);
-
-
-    bool pyrOk = db().time().foundObject<pyrModelType>(pyrolysisRegionName_);
-
-    if (!filmOk || !pyrOk)
-    {
-        // Do nothing on construction - film model doesn't exist yet
-        return;
-    }
 
     scalarField& Tp = *this;
 
     const label patchi = patch().index();
 
-    // Retrieve film model
+    // The film model
-    const filmModelType& filmModel =
-        db().time().lookupObject<filmModelType>(filmRegionName_);
-
     const label filmPatchi = filmModel.regionPatchID(patchi);
 
     scalarField alphaFilm = filmModel.alpha().boundaryField()[filmPatchi];
@@ -160,10 +162,7 @@ void Foam::filmPyrolysisTemperatureCoupledFvPatchScalarField::updateCoeffs()
     scalarField TFilm = filmModel.Ts().boundaryField()[filmPatchi];
     filmModel.toPrimary(filmPatchi, TFilm);
 
-    // Retrieve pyrolysis model
+    // The pyrolysis model
-    const pyrModelType& pyrModel =
-        db().time().lookupObject<pyrModelType>(pyrolysisRegionName_);
-
     const label pyrPatchi = pyrModel.regionPatchID(patchi);
 
     scalarField TPyr = pyrModel.T().boundaryField()[pyrPatchi];

src/regionModels/regionCoupling/derivedFvPatchFields/filmPyrolysisVelocityCoupled/filmPyrolysisVelocityCoupledFvPatchVectorField.C

@@ -123,35 +123,38 @@ void Foam::filmPyrolysisVelocityCoupledFvPatchVectorField::updateCoeffs()
         return;
     }
 
-    typedef regionModels::surfaceFilmModels::surfaceFilmRegionModel
+    // Film model
-        filmModelType;
+    const auto* filmModelPtr = db().time().findObject
+        <regionModels::surfaceFilmModels::surfaceFilmRegionModel>
+        (filmRegionName_);
+
+    // Pyrolysis model
+    const auto* pyrModelPtr = db().time().findObject
+        <regionModels::pyrolysisModels::pyrolysisModel>
+        (pyrolysisRegionName_);
+
+
+    if (!filmModelPtr || !pyrModelPtr)
+    {
+        // Do nothing on construction - film model doesn't exist yet
+        return;
+    }
+
+    const auto& filmModel = *filmModelPtr;
+    const auto& pyrModel = *pyrModelPtr;
 
-    typedef regionModels::pyrolysisModels::pyrolysisModel pyrModelType;
 
     // Since we're inside initEvaluate/evaluate there might be processor
     // comms underway. Change the tag we use.
     int oldTag = UPstream::msgType();
     UPstream::msgType() = oldTag+1;
 
-    bool foundFilm = db().time().foundObject<filmModelType>(filmRegionName_);
-
-    bool foundPyrolysis =
-        db().time().foundObject<pyrModelType>(pyrolysisRegionName_);
-
-    if (!foundFilm || !foundPyrolysis)
-    {
-        // Do nothing on construction - film model doesn't exist yet
-        return;
-    }
 
     vectorField& Up = *this;
 
     const label patchi = patch().index();
 
-    // Retrieve film model
+    // The film model
-    const filmModelType& filmModel =
-        db().time().lookupObject<filmModelType>(filmRegionName_);
-
     const label filmPatchi = filmModel.regionPatchID(patchi);
 
     scalarField alphaFilm = filmModel.alpha().boundaryField()[filmPatchi];
@@ -160,10 +163,7 @@ void Foam::filmPyrolysisVelocityCoupledFvPatchVectorField::updateCoeffs()
     vectorField UFilm = filmModel.Us().boundaryField()[filmPatchi];
     filmModel.toPrimary(filmPatchi, UFilm);
 
-    // Retrieve pyrolysis model
+    // The pyrolysis model
-    const pyrModelType& pyrModel =
-        db().time().lookupObject<pyrModelType>(pyrolysisRegionName_);
-
     const label pyrPatchi = pyrModel.regionPatchID(patchi);
 
     scalarField phiPyr = pyrModel.phiGas().boundaryField()[pyrPatchi];

src/regionModels/regionModel/regionModel/regionModelI.H

@@ -60,14 +60,16 @@ inline const Foam::word& Foam::regionModels::regionModel::modelName() const
 
 inline const Foam::fvMesh& Foam::regionModels::regionModel::regionMesh() const
 {
-    if (time_.foundObject<fvMesh>(regionName_))
+    const fvMesh* regionPtr = time_.findObject<fvMesh>(regionName_);
+
+    if (regionPtr)
     {
-        return time_.lookupObject<fvMesh>(regionName_);
+        return *regionPtr;
     }
     else if (!regionMeshPtr_.valid())
     {
         FatalErrorInFunction
-         << "Region mesh not available" << abort(FatalError);
+            << "Region mesh not available" << abort(FatalError);
     }
 
     return *regionMeshPtr_;
@@ -76,17 +78,16 @@ inline const Foam::fvMesh& Foam::regionModels::regionModel::regionMesh() const
 
 inline Foam::fvMesh& Foam::regionModels::regionModel::regionMesh()
 {
-    if (time_.foundObject<fvMesh>(regionName_))
+    fvMesh* regionPtr = time_.getObjectPtr<fvMesh>(regionName_);
+
+    if (regionPtr)
     {
-        return const_cast<fvMesh&>
+        return *regionPtr;
-        (
-            time_.lookupObject<fvMesh>(regionName_)
-        );
     }
     else if (!regionMeshPtr_.valid())
     {
         FatalErrorInFunction
-         << "Region mesh not available" << abort(FatalError);
+            << "Region mesh not available" << abort(FatalError);
     }
 
     return *regionMeshPtr_;

src/regionModels/regionModel/regionModel/regionModelTemplates.C

@@ -87,15 +87,7 @@ Foam::regionModels::regionModel::mapRegionPatchField
     {
         const polyPatch& p = regionMesh().boundaryMesh()[regionPatchi];
 
-        return
+        return tmp<Field<Type>>::New(p.size(), Zero);
-            tmp<Field<Type>>
-            (
-                new Field<Type>
-                (
-                    p.size(),
-                    Zero
-                )
-            );
     }
 }
 
@@ -143,15 +135,7 @@ Foam::regionModels::regionModel::mapRegionPatchInternalField
     {
         const polyPatch& p = regionMesh().boundaryMesh()[regionPatchi];
 
-        return
+        return tmp<Field<Type>>::New(p.size(), Zero);
-            tmp<Field<Type>>
-            (
-                new Field<Type>
-                (
-                    p.size(),
-                    Zero
-                )
-            );
     }
 }
 

src/regionModels/surfaceFilmModels/derivedFvPatchFields/wallFunctions/alphatFilmWallFunction/alphatFilmWallFunctionFvPatchScalarField.C

@@ -142,27 +142,27 @@ void alphatFilmWallFunctionFvPatchScalarField::updateCoeffs()
         return;
     }
 
-    typedef regionModels::surfaceFilmModels::surfaceFilmRegionModel modelType;
+    const auto* filmModelPtr = db().time().findObject
+        <regionModels::surfaceFilmModels::surfaceFilmRegionModel>
+        (filmRegionName_);
+
+    if (!filmModelPtr)
+    {
+        // Do nothing on construction - film model doesn't exist yet
+        return;
+    }
+
+    const auto& filmModel = *filmModelPtr;
+
 
     // Since we're inside initEvaluate/evaluate there might be processor
     // comms underway. Change the tag we use.
     int oldTag = UPstream::msgType();
     UPstream::msgType() = oldTag+1;
 
-    bool foundFilm = db().time().foundObject<modelType>(filmRegionName_);
-
-    if (!foundFilm)
-    {
-        // Do nothing on construction - film model doesn't exist yet
-        return;
-    }
-
     const label patchi = patch().index();
 
     // Retrieve phase change mass from surface film model
-    const modelType& filmModel =
-        db().time().lookupObject<modelType>(filmRegionName_);
-
     const label filmPatchi = filmModel.regionPatchID(patchi);
 
     tmp<volScalarField> mDotFilm(filmModel.primaryMassTrans());

src/regionModels/surfaceFilmModels/derivedFvPatchFields/wallFunctions/nutkFilmWallFunction/nutkFilmWallFunctionFvPatchScalarField.C

@@ -48,14 +48,14 @@ tmp<scalarField> nutkFilmWallFunctionFvPatchScalarField::calcUTau
     const scalarField& magGradU
 ) const
 {
-    tmp<scalarField> tuTau(new scalarField(patch().size(), 0.0));
+    tmp<scalarField> tuTau(new scalarField(patch().size(), Zero));
     scalarField& uTau = tuTau.ref();
 
-    typedef regionModels::surfaceFilmModels::surfaceFilmRegionModel modelType;
+    const auto* filmModelPtr = db().time().findObject
+        <regionModels::surfaceFilmModels::surfaceFilmRegionModel>
+        (filmRegionName_);
 
-    bool foundFilm = db().time().foundObject<modelType>(filmRegionName_);
+    if (!filmModelPtr)
-
-    if (!foundFilm)
     {
         // Do nothing on construction - film model doesn't exist yet
         return tuTau;
@@ -64,8 +64,7 @@ tmp<scalarField> nutkFilmWallFunctionFvPatchScalarField::calcUTau
     const label patchi = patch().index();
 
     // Retrieve phase change mass from surface film model
-    const modelType& filmModel =
+    const auto& filmModel = *filmModelPtr;
-        db().time().lookupObject<modelType>(filmRegionName_);
 
     const label filmPatchi = filmModel.regionPatchID(patchi);
 

src/regionModels/surfaceFilmModels/submodels/kinematic/filmThermoModel/liquidFilmThermo/liquidFilmThermo.C

@@ -78,19 +78,23 @@ void liquidFilmThermo::initLiquid(const dictionary& dict)
 
     dict.readEntry("liquid", name_);
 
-    if (filmModel_.primaryMesh().foundObject<SLGThermo>("SLGThermo"))
+    const SLGThermo* thermoPtr =
+        filmModel_.primaryMesh().findObject<SLGThermo>("SLGThermo");
+
+    if (thermoPtr)
     {
-        // retrieve from film thermo
+        // Retrieve from film thermo
         ownLiquid_ = false;
 
-        const SLGThermo& thermo =
+        const SLGThermo& thermo = *thermoPtr;
-            filmModel_.primaryMesh().lookupObject<SLGThermo>("SLGThermo");
+
-        label id = thermo.liquidId(name_);
+        const label id = thermo.liquidId(name_);
+
         liquidPtr_ = &thermo.liquids().properties()[id];
     }
     else
     {
-        // new liquid create
+        // New liquid create
         ownLiquid_ = true;
 
         liquidPtr_ =

src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C

@@ -52,27 +52,22 @@ void Foam::sampledIsoSurface::getIsoFields() const
     // Get volField
     // ~~~~~~~~~~~~
 
-    if (fvm.foundObject<volScalarField>(isoField_))
+    volFieldPtr_ = fvm.getObjectPtr<volScalarField>(isoField_);
+
+    if (volFieldPtr_)
     {
-        if (debug)
+        DebugInFunction
-        {
+            << "Lookup volField " << isoField_ << endl;
-            InfoInFunction
+
-                << "Lookup volField " << isoField_ << endl;
-        }
         storedVolFieldPtr_.clear();
-        volFieldPtr_ = &fvm.lookupObject<volScalarField>(isoField_);
     }
     else
     {
         // Bit of a hack. Read field and store.
 
-        if (debug)
+        DebugInFunction
-        {
+            << "Checking " << isoField_
-            InfoInFunction
+            << " for same time " << fvm.time().timeName() << endl;
-                << "Checking " << isoField_
-                << " for same time " << fvm.time().timeName()
-                << endl;
-        }
 
         if
         (
@@ -80,13 +75,9 @@ void Foam::sampledIsoSurface::getIsoFields() const
          || (fvm.time().timeName() != storedVolFieldPtr_().instance())
         )
         {
-            if (debug)
+            DebugInFunction
-            {
+                << "Reading volField " << isoField_
-                InfoInFunction
+                << " from time " << fvm.time().timeName() << endl;
-                    << "Reading volField " << isoField_
-                    << " from time " << fvm.time().timeName()
-                    << endl;
-            }
 
             IOobject vfHeader
             (
@@ -141,61 +132,45 @@ void Foam::sampledIsoSurface::getIsoFields() const
           + isoField_
           + ')';
 
-        if (fvm.foundObject<pointScalarField>(pointFldName))
-        {
-            if (debug)
-            {
-                InfoInFunction
-                    << "lookup pointField " << pointFldName << endl;
-            }
-            const pointScalarField& pfld = fvm.lookupObject<pointScalarField>
-            (
-                pointFldName
-            );
 
-            if (!pfld.upToDate(*volFieldPtr_))
+        pointFieldPtr_ = fvm.getObjectPtr<pointScalarField>(pointFldName);
+
+        if (pointFieldPtr_)
+        {
+            DebugInFunction
+                << "lookup pointField " << pointFldName << endl;
+
+            if (!pointFieldPtr_->upToDate(*volFieldPtr_))
             {
-                if (debug)
+                DebugInFunction
-                {
+                    << "updating pointField " << pointFldName << endl;
-                    InfoInFunction
+
-                        << "updating pointField "
-                        << pointFldName << endl;
-                }
                 // Update the interpolated value
                 volPointInterpolation::New(fvm).interpolate
                 (
                     *volFieldPtr_,
-                    const_cast<pointScalarField&>(pfld)
+                    const_cast<pointScalarField&>(*pointFieldPtr_)
                 );
             }
-
-            pointFieldPtr_ = &pfld;
         }
         else
         {
             // Not in registry. Interpolate.
 
-            if (debug)
+            DebugInFunction
-            {
+                << "creating pointField " << pointFldName << endl;
-                InfoInFunction
-                    << "Checking pointField " << pointFldName
-                    << " for same time " << fvm.time().timeName()
-                    << endl;
-            }
 
             // Interpolate without cache. Note that we're registering it
             // below so next time round it goes into the condition
             // above.
-            tmp<pointScalarField> tpfld
+            pointFieldPtr_ =
-            (
                 volPointInterpolation::New(fvm).interpolate
                 (
                     *volFieldPtr_,
                     pointFldName,
                     false
-                )
+                ).ptr();
-            );
+
-            pointFieldPtr_ = tpfld.ptr();
             const_cast<pointScalarField*>(pointFieldPtr_)->store();
         }
 
@@ -212,17 +187,13 @@ void Foam::sampledIsoSurface::getIsoFields() const
         }
 
 
-        if (debug)
+        DebugInFunction
-        {
+            << "volField " << volFieldPtr_->name()
-            InfoInFunction
+            << " min:" << min(*volFieldPtr_).value()
-                << "volField " << volFieldPtr_->name()
+            << " max:" << max(*volFieldPtr_).value() << nl
-                << " min:" << min(*volFieldPtr_).value()
+            << "pointField " << pointFieldPtr_->name()
-                << " max:" << max(*volFieldPtr_).value() << endl;
+            << " min:" << gMin(pointFieldPtr_->primitiveField())
-            InfoInFunction
+            << " max:" << gMax(pointFieldPtr_->primitiveField()) << endl;
-                << "pointField " << pointFieldPtr_->name()
-                << " min:" << gMin(pointFieldPtr_->primitiveField())
-                << " max:" << gMax(pointFieldPtr_->primitiveField()) << endl;
-        }
     }
     else
     {
@@ -231,24 +202,20 @@ void Foam::sampledIsoSurface::getIsoFields() const
 
         // Either lookup on the submesh or subset the whole-mesh volField
 
-        if (subFvm.foundObject<volScalarField>(isoField_))
+        volSubFieldPtr_ = subFvm.getObjectPtr<volScalarField>(isoField_);
+
+        if (volSubFieldPtr_)
         {
-            if (debug)
+            DebugInFunction
-            {
+                << "Sub-mesh lookup volField " << isoField_ << endl;
-                InfoInFunction
+
-                    << "Sub-mesh lookup volField "
-                    << isoField_ << endl;
-            }
             storedVolSubFieldPtr_.clear();
-            volSubFieldPtr_ = &subFvm.lookupObject<volScalarField>(isoField_);
         }
         else
         {
-            if (debug)
+            DebugInFunction
-            {
+                << "Sub-setting volField " << isoField_ << endl;
-                InfoInFunction
+
-                    << "Sub-setting volField " << isoField_ << endl;
-            }
             storedVolSubFieldPtr_.reset
             (
                 subMeshPtr_().interpolate
@@ -270,53 +237,40 @@ void Foam::sampledIsoSurface::getIsoFields() const
           + volSubFieldPtr_->name()
           + ')';
 
-        if (subFvm.foundObject<pointScalarField>(pointFldName))
-        {
-            if (debug)
-            {
-                InfoInFunction
-                    << "Sub-mesh lookup pointField " << pointFldName << endl;
-            }
-            const pointScalarField& pfld = subFvm.lookupObject<pointScalarField>
-            (
-                pointFldName
-            );
 
-            if (!pfld.upToDate(*volSubFieldPtr_))
+        pointFieldPtr_ = subFvm.getObjectPtr<pointScalarField>(pointFldName);
+
+        if (pointFieldPtr_)
+        {
+            DebugInFunction
+                << "Sub-mesh lookup pointField " << pointFldName << endl;
+
+            if (!pointFieldPtr_->upToDate(*volSubFieldPtr_))
             {
-                if (debug)
+                DebugInFunction
-                {
+                    << "Updating submesh pointField " << pointFldName << endl;
-                    Info<< "sampledIsoSurface::getIsoFields() :"
+
-                        << " updating submesh pointField "
-                        << pointFldName << endl;
-                }
                 // Update the interpolated value
                 volPointInterpolation::New(subFvm).interpolate
                 (
                     *volSubFieldPtr_,
-                    const_cast<pointScalarField&>(pfld)
+                    const_cast<pointScalarField&>(*pointFieldPtr_)
                 );
             }
-
-            pointFieldPtr_ = &pfld;
         }
         else
         {
-            if (debug)
+            DebugInFunction
-            {
+                << "Interpolating submesh volField "
-                InfoInFunction
+                << volSubFieldPtr_->name()
-                    << "Interpolating submesh volField "
+                << " to get submesh pointField " << pointFldName << endl;
-                    << volSubFieldPtr_->name()
+
-                    << " to get submesh pointField " << pointFldName << endl;
+            pointSubFieldPtr_ =
-            }
-            tmp<pointScalarField> tpfld
-            (
                 volPointInterpolation::New
                 (
                     subFvm
-                ).interpolate(*volSubFieldPtr_)
+                ).interpolate(*volSubFieldPtr_).ptr();
-            );
+
-            pointSubFieldPtr_ = tpfld.ptr();
             const_cast<pointScalarField*>(pointSubFieldPtr_)->store();
         }
 
@@ -333,19 +287,15 @@ void Foam::sampledIsoSurface::getIsoFields() const
         }
 
 
-        if (debug)
+        DebugInFunction
-        {
+            << "volSubField "
-            InfoInFunction
+            << volSubFieldPtr_->name()
-                << "volSubField "
+            << " min:" << min(*volSubFieldPtr_).value()
-                << volSubFieldPtr_->name()
+            << " max:" << max(*volSubFieldPtr_).value() << nl
-                << " min:" << min(*volSubFieldPtr_).value()
+            << "pointSubField "
-                << " max:" << max(*volSubFieldPtr_).value() << endl;
+            << pointSubFieldPtr_->name()
-            InfoInFunction
+            << " min:" << gMin(pointSubFieldPtr_->primitiveField())
-                << "pointSubField "
+            << " max:" << gMax(pointSubFieldPtr_->primitiveField()) << endl;
-                << pointSubFieldPtr_->name()
-                << " min:" << gMin(pointSubFieldPtr_->primitiveField())
-                << " max:" << gMax(pointSubFieldPtr_->primitiveField()) << endl;
-        }
     }
 }
 

src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceCell.C

@@ -64,7 +64,7 @@ bool Foam::sampledIsoSurfaceCell::updateGeometry() const
 
     // Use field from database, or try to read it in
 
-    const auto* cellFldPtr = fvm.lookupObjectPtr<volScalarField>(isoField_);
+    const auto* cellFldPtr = fvm.findObject<volScalarField>(isoField_);
 
     if (debug)
     {

src/sampling/sampledSurface/thresholdCellFaces/sampledThresholdCellFaces.C

@@ -61,7 +61,7 @@ bool Foam::sampledThresholdCellFaces::updateGeometry() const
 
     // Use volField from database, or try to read it in
 
-    const auto* cellFldPtr = fvm.lookupObjectPtr<volScalarField>(fieldName_);
+    const auto* cellFldPtr = fvm.findObject<volScalarField>(fieldName_);
 
     if (debug)
     {

src/sampling/surfMeshSample/distanceSurface/surfMeshSampleDistanceSurfaceTemplates.C

@@ -53,7 +53,7 @@ bool Foam::surfMeshSampleDistanceSurface::sampleType
 {
     typedef GeometricField<Type, fvPatchField, volMesh> VolFieldType;
 
-    const auto* volFldPtr = mesh().lookupObjectPtr<VolFieldType>(fieldName);
+    const auto* volFldPtr = mesh().findObject<VolFieldType>(fieldName);
 
     if (!volFldPtr)
     {

src/sampling/surfMeshSample/plane/surfMeshSamplePlaneTemplates.C

@@ -53,7 +53,7 @@ bool Foam::surfMeshSamplePlane::sampleType
 {
     typedef GeometricField<Type, fvPatchField, volMesh> VolFieldType;
 
-    const auto* volFldPtr = mesh().lookupObjectPtr<VolFieldType>(fieldName);
+    const auto* volFldPtr = mesh().findObject<VolFieldType>(fieldName);
 
     if (!volFldPtr)
     {

src/sampling/surfMeshSample/surfMeshSample/surfMeshSampleTemplates.C

@@ -76,7 +76,7 @@ Foam::surfMeshSample::getOrCreateSurfField
     const surfMesh& surf  = surface();
     const word& fieldName = vField.name();
 
-    SurfFieldType* ptr = surf.lookupObjectRefPtr<SurfFieldType>(fieldName);
+    SurfFieldType* ptr = surf.getObjectPtr<SurfFieldType>(fieldName);
     if (!ptr)
     {
         ptr = new SurfFieldType

src/sampling/surfMeshSample/surfMeshSamplers/surfMeshSamplers.C

@@ -109,7 +109,7 @@ bool Foam::surfMeshSamplers::add_rhoU(const word& derivedName)
 
     // rhoU = rho * U
 
-    const auto* rhoPtr = mesh_.lookupObjectPtr<volScalarField>("rho");
+    const auto* rhoPtr = mesh_.findObject<volScalarField>("rho");
     const volVectorField& U = mesh_.lookupObject<volVectorField>("U");
 
     tmp<volVectorField> tresult;
@@ -152,7 +152,7 @@ bool Foam::surfMeshSamplers::add_pTotal(const word& derivedName)
 
     // pTotal = p + rho * U^2 / 2
 
-    const auto* rhoPtr = mesh_.lookupObjectPtr<volScalarField>("rho");
+    const auto* rhoPtr = mesh_.findObject<volScalarField>("rho");
     const volScalarField& p = mesh_.lookupObject<volScalarField>("p");
     const volVectorField& U = mesh_.lookupObject<volVectorField>("U");
 

src/sampling/surfMeshSample/triSurfaceMesh/surfMeshSampleDiscreteTemplates.C

@@ -60,7 +60,7 @@ bool Foam::surfMeshSampleDiscrete::sampleType
     typedef GeometricField<Type, fvPatchField, volMesh> VolFieldType;
 
     const auto* volFldPtr =
-        SurfaceSource::mesh().lookupObjectPtr<VolFieldType>(fieldName);
+        SurfaceSource::mesh().findObject<VolFieldType>(fieldName);
 
     if (!volFldPtr)
     {

src/sampling/surface/triSurfaceMesh/discreteSurfaceTemplates.C

@@ -40,7 +40,7 @@ bool Foam::discreteSurface::sampleType
     typedef DimensionedField<Type, surfGeoMesh> SurfFieldType;
     typedef IOField<Type> TmpFieldType;
 
-    const auto* volFldPtr = mesh().lookupObjectPtr<VolFieldType>(fieldName);
+    const auto* volFldPtr = mesh().findObject<VolFieldType>(fieldName);
 
     if (!volFldPtr)
     {
@@ -57,7 +57,7 @@ bool Foam::discreteSurface::sampleType
     {
         const surfMesh& surf = dynamicCast<const surfMesh>(obr);
 
-        SurfFieldType* ptr = surf.lookupObjectRefPtr<SurfFieldType>(fieldName);
+        SurfFieldType* ptr = surf.getObjectPtr<SurfFieldType>(fieldName);
         if (!ptr)
         {
             // Doesn't exist or the wrong type
@@ -83,7 +83,7 @@ bool Foam::discreteSurface::sampleType
     }
     else
     {
-        TmpFieldType* ptr = obr.lookupObjectRefPtr<TmpFieldType>(fieldName);
+        TmpFieldType* ptr = obr.getObjectPtr<TmpFieldType>(fieldName);
         if (!ptr)
         {
             // Doesn't exist or the wrong type
@@ -121,7 +121,7 @@ Foam::discreteSurface::sampleType
 {
     typedef GeometricField<Type, fvPatchField, volMesh> VolFieldType;
 
-    const auto* volFldPtr = mesh().lookupObjectPtr<VolFieldType>(fieldName);
+    const auto* volFldPtr = mesh().findObject<VolFieldType>(fieldName);
 
     if (volFldPtr)
     {

src/sixDoFRigidBodyMotion/pointPatchFields/derived/uncoupledSixDoFRigidBodyDisplacement/uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField.C

@@ -165,7 +165,7 @@ void uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField::updateCoeffs()
     if (db().foundObject<uniformDimensionedVectorField>("g"))
     {
         uniformDimensionedVectorField g =
-        db().lookupObject<uniformDimensionedVectorField>("g");
+            db().lookupObject<uniformDimensionedVectorField>("g");
 
         gravity = g.value();
     }

src/surfMesh/surfaceFormats/vtk/VTKsurfaceFormat.C

@@ -147,7 +147,7 @@ bool Foam::fileFormats::VTKsurfaceFormat<Face>::read
     for (auto fieldName : { "region", "STLSolidLabeling" })
     {
         const labelIOField* lptr =
-            reader.cellData().lookupObjectPtr<labelIOField>(fieldName);
+            reader.cellData().findObject<labelIOField>(fieldName);
 
         if (lptr)
         {
@@ -160,7 +160,7 @@ bool Foam::fileFormats::VTKsurfaceFormat<Face>::read
         }
 
         const scalarIOField* sptr =
-            reader.cellData().lookupObjectPtr<scalarIOField>(fieldName);
+            reader.cellData().findObject<scalarIOField>(fieldName);
 
         if (sptr)
         {

src/thermophysicalModels/basic/basicThermo/basicThermo.C

@@ -130,37 +130,31 @@ Foam::volScalarField& Foam::basicThermo::lookupOrConstruct
     bool& isOwner
 )
 {
-    const volScalarField* p =
+    volScalarField* ptr =
-        mesh.objectRegistry::lookupObjectPtr<volScalarField>(name);
+        mesh.objectRegistry::getObjectPtr<volScalarField>(name);
 
-    isOwner = !p;
+    isOwner = !ptr;
 
-    if (!p)
+    if (!ptr)
     {
-        volScalarField* fPtr
+        ptr = new volScalarField
         (
-            new volScalarField
+            IOobject
             (
-                IOobject
+                name,
-                (
+                mesh.time().timeName(),
-                    name,
+                mesh,
-                    mesh.time().timeName(),
+                IOobject::MUST_READ,
-                    mesh,
+                IOobject::AUTO_WRITE
-                    IOobject::MUST_READ,
+            ),
-                    IOobject::AUTO_WRITE
+            mesh
-                ),
-                mesh
-            )
         );
 
         // Transfer ownership of this object to the objectRegistry
-        fPtr->store(fPtr);
+        ptr->store(ptr);
-        return *fPtr;
-    }
-    else
-    {
-        return const_cast<volScalarField&>(*p);
     }
+
+    return *ptr;
 }
 
 
@@ -341,30 +335,25 @@ const Foam::basicThermo& Foam::basicThermo::lookupThermo
     const fvPatchScalarField& pf
 )
 {
-    if (pf.db().foundObject<basicThermo>(dictName))
+    const basicThermo* thermo = pf.db().findObject<basicThermo>(dictName);
-    {
-        return pf.db().lookupObject<basicThermo>(dictName);
-    }
-    else
-    {
-        HashTable<const basicThermo*> thermos =
-            pf.db().lookupClass<basicThermo>();
 
-        for
+    if (thermo)
+    {
+        return *thermo;
+    }
+
+    HashTable<const basicThermo*> thermos =
+        pf.db().lookupClass<basicThermo>();
+
+    forAllConstIters(thermos, iter)
+    {
+        if
         (
-            HashTable<const basicThermo*>::iterator iter = thermos.begin();
+            &(iter()->he().internalField())
-            iter != thermos.end();
+         == &(pf.internalField())
-            ++iter
         )
         {
-            if
+            return *iter();
-            (
-                &(iter()->he().internalField())
-              == &(pf.internalField())
-            )
-            {
-                return *iter();
-            }
         }
     }
 

src/thermophysicalModels/radiation/submodels/absorptionEmissionModel/greyMeanAbsorptionEmission/greyMeanAbsorptionEmission.C

@@ -118,58 +118,53 @@ Foam::radiation::greyMeanAbsorptionEmission::greyMeanAbsorptionEmission
     // look-up table and save the corresponding indices of the look-up table
 
     label j = 0;
-    forAllConstIter(HashTable<label>, speciesNames_, iter)
+    forAllConstIters(speciesNames_, iter)
     {
+        const word& specieName = iter.key();
+        const label index = iter.object();
+
+        volScalarField* fldPtr = mesh.getObjectPtr<volScalarField>(specieName);
+
         if (!lookUpTablePtr_.empty())
         {
-            if (lookUpTablePtr_().found(iter.key()))
+            if (lookUpTablePtr_().found(specieName))
             {
-                label index = lookUpTablePtr_().findFieldIndex(iter.key());
+                const label fieldIndex =
+                    lookUpTablePtr_().findFieldIndex(specieName);
 
-                Info<< "specie: " << iter.key() << " found on look-up table "
+                Info<< "specie: " << specieName << " found on look-up table "
-                    << " with index: " << index << endl;
+                    << " with index: " << fieldIndex << endl;
 
-                specieIndex_[iter()] = index;
+                specieIndex_[index] = fieldIndex;
             }
-            else if (mesh.foundObject<volScalarField>(iter.key()))
+            else if (fldPtr)
             {
-                volScalarField& Y =
+                Yj_.set(j, fldPtr);
-                    const_cast<volScalarField&>
+                specieIndex_[index] = 0;
-                    (
-                        mesh.lookupObject<volScalarField>(iter.key())
-                    );
-                Yj_.set(j, &Y);
-                specieIndex_[iter()] = 0;
                 j++;
                 Info<< "specie: " << iter.key() << " is being solved" << endl;
             }
             else
             {
                 FatalErrorInFunction
-                    << "specie: " << iter.key()
+                    << "specie: " << specieName
                     << " is neither in look-up table: "
                     << lookUpTablePtr_().tableName()
                     << " nor is being solved" << nl
                     << exit(FatalError);
             }
         }
-        else if (mesh.foundObject<volScalarField>(iter.key()))
+        else if (fldPtr)
         {
-            volScalarField& Y =
+            Yj_.set(j, fldPtr);
-                const_cast<volScalarField&>
+            specieIndex_[index] = 0;
-                (
-                    mesh.lookupObject<volScalarField>(iter.key())
-                );
-
-            Yj_.set(j, &Y);
-            specieIndex_[iter()] = 0;
             j++;
         }
         else
         {
             FatalErrorInFunction
-                << " there is not lookup table and the specie" << nl
+                << "There is no lookup table and the specie" << nl
-                << iter.key() << nl
+                << specieName << nl
                 << " is not found " << nl
                 << exit(FatalError);
         }
@@ -292,10 +287,11 @@ Foam::radiation::greyMeanAbsorptionEmission::ECont(const label bandI) const
         )
     );
 
-    if (mesh_.foundObject<volScalarField>("Qdot"))
+    const volScalarField* QdotPtr = mesh_.findObject<volScalarField>("Qdot");
+
+    if (QdotPtr)
     {
-        const volScalarField& Qdot =
+        const volScalarField& Qdot = *QdotPtr;
-            mesh_.lookupObject<volScalarField>("Qdot");
 
         if (Qdot.dimensions() == dimEnergy/dimTime)
         {

src/thermophysicalModels/radiation/submodels/absorptionEmissionModel/wideBandAbsorptionEmission/wideBandAbsorptionEmission.C

@@ -132,48 +132,53 @@ Foam::radiation::wideBandAbsorptionEmission::wideBandAbsorptionEmission
     // look-up table and save the corresponding indices of the look-up table
 
     label j = 0;
-    forAllConstIter(HashTable<label>, speciesNames_, iter)
+    forAllConstIters(speciesNames_, iter)
     {
+        const word& specieName = iter.key();
+        const label index = iter.object();
+
+        volScalarField* fldPtr = mesh.getObjectPtr<volScalarField>(specieName);
+
         if (!lookUpTablePtr_.empty())
         {
-            if (lookUpTablePtr_().found(iter.key()))
+            if (lookUpTablePtr_().found(specieName))
             {
-                const label index =
+                const label fieldIndex =
-                    lookUpTablePtr_().findFieldIndex(iter.key());
+                    lookUpTablePtr_().findFieldIndex(specieName);
 
-                Info<< "specie: " << iter.key() << " found on look-up table "
+                Info<< "specie: " << specieName << " found on look-up table "
-                    << " with index: " << index << endl;
+                    << " with index: " << fieldIndex << endl;
 
-                specieIndex_[iter()] = index;
+                specieIndex_[index] = fieldIndex;
             }
-            else if (mesh.foundObject<volScalarField>(iter.key()))
+            else if (fldPtr)
             {
-                Yj_.set(j, &mesh.lookupObjectRef<volScalarField>(iter.key()));
+                Yj_.set(j, fldPtr);
-                specieIndex_[iter()] = 0;
+                specieIndex_[index] = 0;
                 j++;
-                Info<< "specie: " << iter.key() << " is being solved" << endl;
+                Info<< "specie: " << specieName << " is being solved" << endl;
             }
             else
             {
                 FatalErrorInFunction
-                    << "specie: " << iter.key()
+                    << "specie: " << specieName
                     << " is neither in look-up table: "
                     << lookUpTablePtr_().tableName()
                     << " nor is being solved" << nl
                     << exit(FatalError);
             }
         }
-        else if (mesh.foundObject<volScalarField>(iter.key()))
+        else if (fldPtr)
         {
-            Yj_.set(j, &mesh.lookupObjectRef<volScalarField>(iter.key()));
+            Yj_.set(j, fldPtr);
-            specieIndex_[iter()] = 0;
+            specieIndex_[index] = 0;
             j++;
         }
         else
         {
             FatalErrorInFunction
-                << " there is no lookup table and the specie" << nl
+                << "There is no lookup table and the specie" << nl
-                << iter.key() << nl
+                << specieName << nl
                 << " is not found " << nl
                 << exit(FatalError);
 
@@ -300,10 +305,11 @@ Foam::radiation::wideBandAbsorptionEmission::ECont(const label bandi) const
         )
     );
 
-    if (mesh().foundObject<volScalarField>("Qdot"))
+    const volScalarField* QdotPtr = mesh().findObject<volScalarField>("Qdot");
+
+    if (QdotPtr)
     {
-        const volScalarField& Qdot =
+        const volScalarField& Qdot = *QdotPtr;
-            mesh().lookupObject<volScalarField>("Qdot");
 
         if (Qdot.dimensions() == dimEnergy/dimTime)
         {

src/thermophysicalModels/reactionThermo/functionObjects/moleFractions/moleFractions.C

@@ -64,12 +64,12 @@ Foam::moleFractions<ThermoType>::moleFractions
 :
     fvMeshFunctionObject(name, runTime, dict)
 {
-    if (mesh_.foundObject<ThermoType>(basicThermo::dictName))
+    const ThermoType* thermo =
-    {
+        mesh_.findObject<ThermoType>(basicThermo::dictName);
-        const ThermoType& thermo =
-            mesh_.lookupObject<ThermoType>(basicThermo::dictName);
 
-        const PtrList<volScalarField>& Y = thermo.composition().Y();
+    if (thermo)
+    {
+        const PtrList<volScalarField>& Y = thermo->composition().Y();
 
         X_.setSize(Y.size());
 

src/thermophysicalModels/thermophysicalPropertiesFvPatchFields/liquidProperties/humidityTemperatureCoupledMixed/humidityTemperatureCoupledMixedFvPatchScalarField.C

@@ -93,33 +93,28 @@ Foam::humidityTemperatureCoupledMixedFvPatchScalarField::thicknessField
     const fvMesh& mesh
 )
 {
-    if (!mesh.foundObject<volScalarField>(fieldName))
+    volScalarField* ptr = mesh.getObjectPtr<volScalarField>(fieldName);
+
+    if (!ptr)
     {
-        tmp<volScalarField> tField
+        ptr = new volScalarField
         (
-            new volScalarField
+            IOobject
             (
-                IOobject
+                fieldName,
-                (
+                mesh.time().timeName(),
-                    fieldName,
-                    mesh.time().timeName(),
-                    mesh,
-                    IOobject::NO_READ,
-                    IOobject::AUTO_WRITE
-                ),
                 mesh,
-                dimensionedScalar(dimLength, Zero)
+                IOobject::NO_READ,
-            )
+                IOobject::AUTO_WRITE
+            ),
+            mesh,
+            dimensionedScalar(dimLength, Zero)
         );
 
-        tField.ptr()->store();
+        ptr->store();
     }
 
-    return
+    return *ptr;
-        const_cast<volScalarField&>
-        (
-            mesh.lookupObject<volScalarField>(fieldName)
-        );
 }
 
 

src/topoChangerFvMesh/rawTopoChangerFvMesh/rawTopoChangerFvMesh.C

@@ -141,11 +141,10 @@ bool Foam::rawTopoChangerFvMesh::update()
         // Special handling for phi: set unmapped faces to recreated phi
         Info<< "rawTopoChangerFvMesh :"
             << " recreating phi for unmapped boundary values." << endl;
+
         const volVectorField& U = lookupObject<volVectorField>("U");
-        surfaceScalarField& phi = const_cast<surfaceScalarField&>
+        surfaceScalarField& phi = lookupObjectRef<surfaceScalarField>("phi");
-        (
+
-            lookupObject<surfaceScalarField>("phi")
-        );
         setUnmappedValues
         (
             phi,

src/topoChangerFvMesh/rawTopoChangerFvMesh/rawTopoChangerFvMeshTemplates.C

@@ -75,10 +75,7 @@ void Foam::rawTopoChangerFvMesh::zeroUnmappedValues
     {
         //Pout<< "Checking field " << fldNames[i] << endl;
 
-        FieldType& fld = const_cast<FieldType&>
+        FieldType& fld = lookupObjectRef<FieldType>(fldNames[i]);
-        (
-            lookupObject<FieldType>(fldNames[i])
-        );
 
         setUnmappedValues
         (

src/transportModels/incompressible/viscosityModels/Arrhenius/Arrhenius.C

@@ -60,12 +60,11 @@ Foam::viscosityModels::Arrhenius<ViscousModel>::Arrhenius
     fieldName_(ArrheniusCoeffs_.lookupOrDefault<word>("field","T")),
     mesh_(U.mesh())
 {
-    const volScalarField* fieldPtr =
+    const auto* fldPtr = mesh_.findObject<volScalarField>(fieldName_);
-        mesh_.lookupObjectPtr<volScalarField>(fieldName_);
 
-    if (fieldPtr)
+    if (fldPtr)
     {
-        this->nu_ *= calcNu(*fieldPtr);
+        this->nu_ *= calcNu(*fldPtr);
     }
 }
 

src/transportModels/incompressible/viscosityModels/Arrhenius/Arrhenius.H

@@ -113,12 +113,11 @@ public:
         {
             ViscousModel::correct();
 
-            const volScalarField* fieldPtr =
+            const auto* fldPtr = mesh_.findObject<volScalarField>(fieldName_);
-                mesh_.lookupObjectPtr<volScalarField>(fieldName_);
 
-            if (fieldPtr)
+            if (fldPtr)
             {
-                this->nu_ *= calcNu(*fieldPtr);
+                this->nu_ *= calcNu(*fldPtr);
             }
         }
 

src/waveModels/waveModel/waveModelNew.C

@@ -87,15 +87,16 @@ Foam::tmp<Foam::waveModel> Foam::waveModel::lookupOrCreate
 {
     const word modelName = waveModel::modelName(patch.name());
 
-    if (!mesh.foundObject<waveModel>(modelName))
+    waveModel* modelPtr = mesh.getObjectPtr<waveModel>(modelName);
+
+    if (!modelPtr)
     {
-        autoPtr<waveModel> model(waveModel::New(waveDictName, mesh, patch));
+        modelPtr = waveModel::New(waveDictName, mesh, patch).ptr();
-        waveModel* waveModelPtr = model.ptr();
+        modelPtr->store();
-        waveModelPtr->store();
+        modelPtr->info(Info);
-        waveModelPtr->info(Info);
     }
 
-    return mesh.lookupObject<waveModel>(modelName);
+    return *modelPtr;
 }
 
 

tutorials/compressible/rhoPimpleAdiabaticFoam/rutlandVortex2D/system/preProcess

@@ -38,8 +38,7 @@ functions
             scalar gamma = 1.4;
             scalar A = -0.3*D*UInf;
             const dimensionedScalar rhoRef("rhoRef", dimDensity, 1);
-            const volScalarField& rho =
+            const auto& rho = mesh().lookupObject<volScalarField>("rho");
-                mesh().lookupObject<volScalarField>("rho");
 
             const vectorField& C = mesh().C();
             const scalarField x(C.component(0));
@@ -47,19 +46,15 @@ functions
             const scalar r2 = sqr(0.5*D/(Foam::sqrt(Foam::log(10.0))));
             const scalarField Psi(A*exp(-0.5/r2*(sqr(x) + sqr(y))));
 
-            volVectorField* Uptr =
+            auto* Uptr = mesh().getObjectPtr<volVectorField>("U");
-                mesh().lookupObjectRefPtr<volVectorField>("U");
+            auto* pPtr = mesh().getObjectPtr<volScalarField>("p");
-            volScalarField* pPtr =
+            auto* TPtr = mesh().getObjectPtr<volScalarField>("T");
-                mesh().lookupObjectRefPtr<volScalarField>("p");
-            volScalarField* TPtr =
-                mesh().lookupObjectRefPtr<volScalarField>("T");
-
 
             if (Uptr && pPtr && TPtr)
             {
-                volVectorField& U = *Uptr;
+                auto& U = *Uptr;
-                volScalarField& p = *pPtr;
+                auto& p = *pPtr;
-                volScalarField& T = *TPtr;
+                auto& T = *TPtr;
 
                 vectorField& Uc = U.primitiveFieldRef();
                 Uc.replace(0, UInf - rhoRef/rho()*Psi/r2*y);