ENH: avoid raw dictionary lookup in functionObjects (issue #762)

Style changes:
    - use lookupObjectRef instead of using const_cast
    - use tmp::New factory

src/functionObjects/field/CourantNo/CourantNo.C

@@ -59,11 +59,9 @@ Foam::functionObjects::CourantNo::byRho
     {
         return Co/obr_.lookupObject<volScalarField>(rhoName_);
     }
-    else
+
-    {
     return Co;
 }
-}
 
 
 bool Foam::functionObjects::CourantNo::calc()
@@ -85,22 +83,15 @@ bool Foam::functionObjects::CourantNo::calc()
 
         if (foundObject<volScalarField>(resultName_, false))
         {
-            volScalarField& Co
+            volScalarField& Co =
-            (
+                lookupObjectRef<volScalarField>(resultName_);
-                const_cast<volScalarField&>
-                (
-                    lookupObject<volScalarField>(resultName_)
-                )
-            );
 
             Co.ref() = Coi();
             Co.correctBoundaryConditions();
         }
         else
         {
-            tmp<volScalarField> tCo
+            auto tCo = tmp<volScalarField>::New
-            (
-                new volScalarField
             (
                 IOobject
                 (
@@ -113,7 +104,6 @@ bool Foam::functionObjects::CourantNo::calc()
                 mesh_,
                 dimensionedScalar(dimless, Zero),
                 zeroGradientFvPatchScalarField::typeName
-                )
             );
             tCo.ref().ref() = Coi();
             tCo.ref().correctBoundaryConditions();
@@ -122,11 +112,9 @@ bool Foam::functionObjects::CourantNo::calc()
 
         return true;
     }
-    else
+
-    {
     return false;
 }
-}
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //

src/functionObjects/field/Curle/Curle.C

@@ -75,9 +75,7 @@ bool Foam::functionObjects::Curle::calc()
 
         const volVectorField& C = mesh_.C();
 
-        tmp<volScalarField> tpDash
+        auto tpDash = tmp<volScalarField>::New
-        (
-            new volScalarField
         (
             IOobject
             (
@@ -89,20 +87,17 @@ bool Foam::functionObjects::Curle::calc()
             ),
             mesh_,
             dimensionedScalar(p.dimensions(), Zero)
-            )
         );
+        auto& pDash = tpDash.ref();
 
-        volScalarField& pDash = tpDash.ref();
         const volVectorField d(scopedName("d"), C - x0_);
         pDash = (d/magSqr(d) & dfdt)/(4.0*mathematical::pi*c0_);
 
         return store(resultName_, tpDash);
     }
-    else
+
-    {
     return false;
 }
-}
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -136,8 +131,7 @@ bool Foam::functionObjects::Curle::read(const dictionary& dict)
 {
     if (fieldExpression::read(dict))
     {
-        patchSet_ =
+        patchSet_ = mesh_.boundaryMesh().patchSet(dict.get<wordRes>("patches"));
-            mesh_.boundaryMesh().patchSet(wordReList(dict.lookup("patches")));
 
         if (patchSet_.empty())
         {
@@ -149,7 +143,7 @@ bool Foam::functionObjects::Curle::read(const dictionary& dict)
         }
 
         // Read the reference speed of sound
-        dict.lookup("c0") >> c0_;
+        dict.readEntry("c0", c0_);
 
 
         // Set the location of the effective point source to the area-average

src/functionObjects/field/DESModelRegions/DESModelRegions.C

@@ -75,10 +75,7 @@ Foam::functionObjects::DESModelRegions::DESModelRegions
 {
     read(dict);
 
-    tmp<volScalarField> tDESModelRegions
+    auto tmodelRegions = tmp<volScalarField>::New
-    (
-        (
-            new volScalarField
     (
         IOobject
         (
@@ -90,11 +87,9 @@ Foam::functionObjects::DESModelRegions::DESModelRegions
         ),
         mesh_,
         dimensionedScalar(dimless, Zero)
-            )
-        )
     );
 
-    store(resultName_, tDESModelRegions);
+    store(resultName_, tmodelRegions);
 
     writeFileHeader(file());
 }
@@ -124,10 +119,7 @@ bool Foam::functionObjects::DESModelRegions::execute()
     Log << type() << " " << name() <<  " execute:" << nl;
 
     volScalarField& DESModelRegions =
-        const_cast<volScalarField&>
+        lookupObjectRef<volScalarField>(resultName_);
-        (
-            lookupObject<volScalarField>(resultName_)
-        );
 
 
     if (foundObject<DESModelBase>(turbulenceModel::propertiesName))

src/functionObjects/field/PecletNo/PecletNo.C

@@ -57,11 +57,9 @@ Foam::tmp<Foam::surfaceScalarField> Foam::functionObjects::PecletNo::rhoScale
     {
         return phi/fvc::interpolate(lookupObject<volScalarField>(rhoName_));
     }
-    else
+
-    {
     return phi;
 }
-}
 
 
 bool Foam::functionObjects::PecletNo::calc()
@@ -84,10 +82,7 @@ bool Foam::functionObjects::PecletNo::calc()
             const dictionary& model =
                 mesh_.lookupObject<dictionary>("transportProperties");
 
-            nuEff =
+            nuEff = tmp<volScalarField>::New
-                tmp<volScalarField>
-                (
-                    new volScalarField
             (
                 IOobject
                 (
@@ -99,7 +94,6 @@ bool Foam::functionObjects::PecletNo::calc()
                 ),
                 mesh_,
                 dimensionedScalar(model.lookup("nu"))
-                    )
             );
         }
         else

src/functionObjects/field/blendingFactor/blendingFactor.C

@@ -81,9 +81,7 @@ Foam::functionObjects::blendingFactor::blendingFactor
     writeFileHeader(file());
     setResultName(typeName, "");
 
-    tmp<volScalarField> indicatorPtr
+    auto indicatorPtr = tmp<volScalarField>::New
-    (
-        new volScalarField
     (
         IOobject
         (
@@ -96,7 +94,6 @@ Foam::functionObjects::blendingFactor::blendingFactor
         mesh_,
         dimensionedScalar(dimless, Zero),
         zeroGradientFvPatchScalarField::typeName
-        )
     );
 
     store(resultName_, indicatorPtr);

src/functionObjects/field/blendingFactor/blendingFactorTemplates.C

@@ -72,10 +72,8 @@ void Foam::functionObjects::blendingFactor::calcBlendingFactor
     // - factor applied to 1st scheme, and (1-factor) to 2nd scheme
     // - not using the store(...) mechanism due to need to correct BCs
     volScalarField& indicator =
-        const_cast<volScalarField&>
+        lookupObjectRef<volScalarField>(resultName_);
-        (
+
-            lookupObject<volScalarField>(resultName_)
-        );
     indicator = 1 - fvc::cellReduce(factorf, minEqOp<scalar>(), GREAT);
     indicator.correctBoundaryConditions();
 }

src/functionObjects/field/ddt2/ddt2.C

@@ -134,7 +134,7 @@ bool Foam::functionObjects::ddt2::read(const dictionary& dict)
         return false;
     }
 
-    dict.lookup("fields") >> selectFields_;
+    dict.readEntry("fields", selectFields_);
     selectFields_.uniq();
 
     Info<< type() << " fields: " << selectFields_ << nl;

src/functionObjects/field/ddt2/ddt2Templates.C

@@ -56,9 +56,7 @@ int Foam::functionObjects::ddt2::apply(const word& inputName, int& state)
           : magSqr(input.dimensions()/dimTime)
         );
 
-        tmp<volScalarField> tddt2
+        auto tddt2 = tmp<volScalarField>::New
-        (
-            new volScalarField
         (
             IOobject
             (
@@ -70,14 +68,12 @@ int Foam::functionObjects::ddt2::apply(const word& inputName, int& state)
             ),
             mesh_,
             dimensionedScalar(dims, Zero)
-            )
         );
 
         store(outputName, tddt2);
     }
 
-    volScalarField& output =
+    volScalarField& output = lookupObjectRef<volScalarField>(outputName);
-        const_cast<volScalarField&>(lookupObject<volScalarField>(outputName));
 
     if (mag_)
     {

src/functionObjects/field/externalCoupled/externalCoupled.C

@@ -606,8 +606,8 @@ bool Foam::functionObjects::externalCoupled::read(const dictionary& dict)
             const dictionary& groupDict = regionIter().dict();
 
             const label nGroups = groupNames_.size();
-            const wordList readFields(groupDict.lookup("readFields"));
+            const wordList readFields(groupDict.get<wordList>("readFields"));
-            const wordList writeFields(groupDict.lookup("writeFields"));
+            const wordList writeFields(groupDict.get<wordList>("writeFields"));
 
             auto fnd = regionToGroups_.find(regionGroupNames_.last());
             if (fnd.found())

src/functionObjects/field/externalCoupled/externalCoupledTemplates.C

@@ -278,8 +278,8 @@ Foam::functionObjects::externalCoupled::gatherAndCombine
     Pstream::gatherList(gatheredValues);
 
 
-    tmp<Field<Type>> tresult(new Field<Type>(0));
+    auto tresult = tmp<Field<Type>>::New();
-    Field<Type>& result = tresult.ref();
+    auto& result = tresult.ref();
 
     if (Pstream::master())
     {

src/functionObjects/field/extractEulerianParticles/extractEulerianParticles/extractEulerianParticles.C

@@ -584,8 +584,8 @@ bool Foam::functionObjects::extractEulerianParticles::read
 
     if (fvMeshFunctionObject::read(dict) && writeFile::read(dict))
     {
-        dict.lookup("faceZone") >> faceZoneName_;
+        dict.readEntry("faceZone", faceZoneName_);
-        dict.lookup("alpha") >> alphaName_;
+        dict.readEntry("alpha", alphaName_);
 
         dict.readIfPresent("alphaThreshold", alphaThreshold_);
         dict.readIfPresent("U", UName_);

src/functionObjects/field/fieldAverage/fieldAverage.C

@@ -305,13 +305,13 @@ bool Foam::functionObjects::fieldAverage::read(const dictionary& dict)
     dict.readIfPresent("restartOnRestart", restartOnRestart_);
     dict.readIfPresent("restartOnOutput",  restartOnOutput_);
     dict.readIfPresent("periodicRestart",  periodicRestart_);
-    dict.lookup("fields") >> faItems_;
+    dict.readEntry("fields", faItems_);
 
     const scalar currentTime = obr().time().value();
 
     if (periodicRestart_)
     {
-        scalar userRestartPeriod = readScalar(dict.lookup("restartPeriod"));
+        scalar userRestartPeriod = dict.get<scalar>("restartPeriod");
         restartPeriod_ = obr().time().userTimeToTime(userRestartPeriod);
 
         if (restartPeriod_ > 0)

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

@@ -192,13 +192,13 @@ void Foam::functionObjects::fieldAverageItem::clear
 
 bool Foam::functionObjects::fieldAverageItem::readState(const dictionary& dict)
 {
-    dict.lookup("totalIter") >> totalIter_;
+    dict.readEntry("totalIter", totalIter_);
-    dict.lookup("totalTime") >> totalTime_;
+    dict.readEntry("totalTime", totalTime_);
 
     if (window_ > 0)
     {
-        dict.lookup("windowTimes") >> windowTimes_;
+        dict.readEntry("windowTimes", windowTimes_);
-        dict.lookup("windowFieldNames") >> windowFieldNames_;
+        dict.readEntry("windowFieldNames", windowFieldNames_);
     }
 
     return true;

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

@@ -66,8 +66,8 @@ Foam::Istream& Foam::functionObjects::operator>>
 
     faItem.active_ = false;
     faItem.fieldName_ = entry.keyword();
-    faItem.mean_ = readBool(entry.lookup("mean"));
+    faItem.mean_ = entry.get<bool>("mean");
-    faItem.prime2Mean_ = readBool(entry.lookup("prime2Mean"));
+    faItem.prime2Mean_ = entry.get<bool>("prime2Mean");
     faItem.base_ = faItem.baseTypeNames_.lookup("base", entry);
     faItem.window_ = entry.lookupOrDefault<scalar>("window", -1.0);
 
@@ -94,7 +94,7 @@ Foam::Istream& Foam::functionObjects::operator>>
 
             if (faItem.windowType_ == fieldAverageItem::windowType::EXACT)
             {
-                faItem.allowRestart_ = readBool(entry.lookup("allowRestart"));
+                faItem.allowRestart_ = entry.get<bool>("allowRestart");
 
                 if (!faItem.allowRestart_)
                 {

src/functionObjects/field/fieldExpression/fieldExpression.C

@@ -97,12 +97,12 @@ bool Foam::functionObjects::fieldExpression::read(const dictionary& dict)
 
     if (fieldName_.empty() || dict.found("field"))
     {
-        dict.lookup("field") >> fieldName_;
+        dict.readEntry("field", fieldName_);
     }
 
     if (dict.found("result"))
     {
-        dict.lookup("result") >> resultName_;
+        dict.readEntry("result", resultName_);
     }
 
     return true;

src/functionObjects/field/fieldValues/fieldValue/fieldValue.C

@@ -95,8 +95,8 @@ bool Foam::functionObjects::fieldValue::read(const dictionary& dict)
     fvMeshFunctionObject::read(dict);
     writeFile::read(dict);
 
-    dict.lookup("fields") >> fields_;
+    dict.readEntry("fields", fields_);
-    dict.lookup("writeFields") >> writeFields_;
+    dict.readEntry("writeFields", writeFields_);
     scaleFactor_ = dict.lookupOrDefault<scalar>("scaleFactor", 1.0);
 
     return true;

src/functionObjects/field/fieldValues/fieldValue/fieldValueNew.C

@@ -36,7 +36,7 @@ Foam::functionObjects::fieldValue::New
     const bool output
 )
 {
-    const word modelType(dict.lookup("type"));
+    const word modelType(dict.get<word>("type"));
 
     if (output)
     {

src/functionObjects/field/fieldValues/surfaceFieldValue/surfaceFieldValue.C

@@ -484,7 +484,7 @@ void Foam::functionObjects::fieldValues::surfaceFieldValue::initialise
     const dictionary& dict
 )
 {
-    dict.lookup("name") >> regionName_;
+    dict.readEntry("name", regionName_);
 
     switch (regionType_)
     {
@@ -616,7 +616,7 @@ void Foam::functionObjects::fieldValues::surfaceFieldValue::initialise
     surfaceWriterPtr_.clear();
     if (writeFields_)
     {
-        const word surfaceFormat(dict.lookup("surfaceFormat"));
+        const word surfaceFormat(dict.get<word>("surfaceFormat"));
 
         if (surfaceFormat != "none")
         {
@@ -687,12 +687,12 @@ Foam::functionObjects::fieldValues::surfaceFieldValue::processValues
     {
         case opSumDirection:
         {
-            const vector n(dict_.lookup("direction"));
+            const vector n(dict_.get<vector>("direction"));
             return gSum(pos0(values*(Sf & n))*mag(values));
         }
         case opSumDirectionBalance:
         {
-            const vector n(dict_.lookup("direction"));
+            const vector n(dict_.get<vector>("direction"));
             const scalarField nv(values*(Sf & n));
 
             return gSum(pos0(nv)*mag(values) - neg(nv)*mag(values));
@@ -758,16 +758,14 @@ Foam::functionObjects::fieldValues::surfaceFieldValue::processValues
     {
         case opSumDirection:
         {
-            vector n(dict_.lookup("direction"));
+            const vector n(dict_.get<vector>("direction").normalise());
-            n /= mag(n) + ROOTVSMALL;
 
             const scalarField nv(n & values);
             return gSum(pos0(nv)*n*(nv));
         }
         case opSumDirectionBalance:
         {
-            vector n(dict_.lookup("direction"));
+            const vector n(dict_.get<vector>("direction").normalise());
-            n /= mag(n) + ROOTVSMALL;
 
             const scalarField nv(n & values);
             return gSum(pos0(nv)*n*(nv));

src/functionObjects/field/fieldValues/surfaceFieldValue/surfaceFieldValueTemplates.C

@@ -178,7 +178,6 @@ processSameTypeValues
             if (canWeight(weightField))
             {
                 tmp<scalarField> weight(weightingFactor(weightField));
-
                 result = gSum(weight*values);
             }
             else
@@ -466,8 +465,8 @@ Foam::functionObjects::fieldValues::surfaceFieldValue::filterField
     const GeometricField<Type, fvPatchField, volMesh>& field
 ) const
 {
-    tmp<Field<Type>> tvalues(new Field<Type>(faceId_.size()));
+    auto tvalues = tmp<Field<Type>>::New(faceId_.size());
-    Field<Type>& values = tvalues.ref();
+    auto& values = tvalues.ref();
 
     forAll(values, i)
     {
@@ -501,8 +500,8 @@ Foam::functionObjects::fieldValues::surfaceFieldValue::filterField
     const GeometricField<Type, fvsPatchField, surfaceMesh>& field
 ) const
 {
-    tmp<Field<Type>> tvalues(new Field<Type>(faceId_.size()));
+    auto tvalues = tmp<Field<Type>>::New(faceId_.size());
-    Field<Type>& values = tvalues.ref();
+    auto& values = tvalues.ref();
 
     forAll(values, i)
     {

src/functionObjects/field/fieldsExpression/fieldsExpression.C

@@ -111,12 +111,12 @@ bool Foam::functionObjects::fieldsExpression::read(const dictionary& dict)
 
     if (fieldNames_.empty() || dict.found("fields"))
     {
-        dict.lookup("fields") >> fieldNames_;
+        dict.readEntry("fields", fieldNames_);
     }
 
     if (dict.found("result"))
     {
-        dict.lookup("result") >> resultName_;
+        dict.readEntry("result", resultName_);
     }
 
     return true;

src/functionObjects/field/fluxSummary/fluxSummary.C

@@ -448,8 +448,7 @@ void Foam::functionObjects::fluxSummary::initialiseCellZoneAndDirection
 
         if (((own != -1) && (nbr == -1)) || ((own == -1) && (nbr != -1)))
         {
-            vector n = mesh_.faces()[facei].normal(mesh_.points());
+            vector n = mesh_.faces()[facei].unitNormal(mesh_.points());
-            n /= mag(n) + ROOTVSMALL;
 
             if ((n & refDir) > tolerance_)
             {
@@ -481,8 +480,7 @@ void Foam::functionObjects::fluxSummary::initialiseCellZoneAndDirection
 
             if ((own != -1) && (nbr == -1))
             {
-                vector n = mesh_.faces()[facei].normal(mesh_.points());
+                vector n = mesh_.faces()[facei].unitNormal(mesh_.points());
-                n /= mag(n) + ROOTVSMALL;
 
                 if ((n & refDir) > tolerance_)
                 {
@@ -835,7 +833,7 @@ bool Foam::functionObjects::fluxSummary::read(const dictionary& dict)
     {
         case mdFaceZone:
         {
-            List<word> zones(dict.lookup("faceZones"));
+            wordList zones(dict.get<wordList>("faceZones"));
 
             forAll(zones, i)
             {
@@ -853,8 +851,8 @@ bool Foam::functionObjects::fluxSummary::read(const dictionary& dict)
         }
         case mdFaceZoneAndDirection:
         {
-            List<Tuple2<word, vector>>
+            List<Tuple2<word, vector>> zoneAndDirection;
-                zoneAndDirection(dict.lookup("faceZoneAndDirection"));
+            dict.readEntry("faceZoneAndDirection", zoneAndDirection);
 
             forAll(zoneAndDirection, i)
             {
@@ -873,8 +871,8 @@ bool Foam::functionObjects::fluxSummary::read(const dictionary& dict)
         }
         case mdCellZoneAndDirection:
         {
-            List<Tuple2<word, vector>>
+            List<Tuple2<word, vector>> zoneAndDirection;
-                zoneAndDirection(dict.lookup("cellZoneAndDirection"));
+            dict.readEntry("cellZoneAndDirection", zoneAndDirection);
 
             forAll(zoneAndDirection, i)
             {
@@ -893,7 +891,7 @@ bool Foam::functionObjects::fluxSummary::read(const dictionary& dict)
         }
         case mdSurface:
         {
-            List<word> surfs(dict.lookup("surfaces"));
+            wordList surfs(dict.get<wordList>("surfaces"));
 
             forAll(surfs, i)
             {
@@ -909,8 +907,8 @@ bool Foam::functionObjects::fluxSummary::read(const dictionary& dict)
         }
         case mdSurfaceAndDirection:
         {
-            List<Tuple2<word, vector>>
+            List<Tuple2<word, vector>> surfAndDirection;
-                surfAndDirection(dict.lookup("surfaceAndDirection"));
+            dict.readEntry("surfaceAndDirection", surfAndDirection);
 
             forAll(surfAndDirection, i)
             {

src/functionObjects/field/heatTransferCoeff/heatTransferCoeffModels/ReynoldsAnalogy/ReynoldsAnalogy.C

@@ -164,12 +164,8 @@ Foam::heatTransferCoeffModels::ReynoldsAnalogy::Cf() const
     const volVectorField& U = mesh_.lookupObject<volVectorField>(UName_);
     const volVectorField::Boundary& Ubf = U.boundaryField();
 
-    tmp<FieldField<Field, scalar>> tCf
+    auto tCf = tmp<FieldField<Field, scalar>>::New(Ubf.size());
-    (
+    auto& Cf = tCf.ref();
-        new FieldField<Field, scalar>(Ubf.size())
-    );
-
-    FieldField<Field, scalar>& Cf = tCf.ref();
 
     forAll(Cf, patchi)
     {
@@ -179,7 +175,7 @@ Foam::heatTransferCoeffModels::ReynoldsAnalogy::Cf() const
     const volSymmTensorField R(devReff());
     const volSymmTensorField::Boundary& Rbf = R.boundaryField();
 
-    for (label patchi : patchSet_)
+    for (const label patchi : patchSet_)
     {
         const fvPatchVectorField& Up = Ubf[patchi];
 
@@ -226,18 +222,18 @@ bool Foam::heatTransferCoeffModels::ReynoldsAnalogy::read
 {
     if (heatTransferCoeffModel::read(dict))
     {
-        dict.lookup("UInf") >> URef_;
+        dict.readEntry("UInf", URef_);
 
         dict.readIfPresent("Cp", CpName_);
         if (CpName_ == "CpInf")
         {
-            dict.lookup("CpInf") >> CpRef_;
+            dict.readEntry("CpInf", CpRef_);
         }
 
         dict.readIfPresent("rho", rhoName_);
         if (rhoName_ == "rhoInf")
         {
-            dict.lookup("rhoInf") >> rhoRef_;
+            dict.readEntry("rhoInf", rhoRef_);
         }
 
         return true;
@@ -253,9 +249,9 @@ void Foam::heatTransferCoeffModels::ReynoldsAnalogy::htc(volScalarField& htc)
     const scalar magU = mag(URef_);
 
     volScalarField::Boundary& htcBf = htc.boundaryFieldRef();
-    forAllConstIters(patchSet_, iter)
+
+    for (const label patchi : patchSet_)
     {
-        label patchi = iter.key();
         const scalarField rhop(rho(patchi));
         const scalarField Cpp(Cp(patchi));
 

src/functionObjects/field/heatTransferCoeff/heatTransferCoeffModels/fixedReferenceTemperature/fixedReferenceTemperature.C

@@ -68,7 +68,7 @@ bool Foam::heatTransferCoeffModels::fixedReferenceTemperature::read
 {
     if (heatTransferCoeffModel::read(dict))
     {
-        dict.lookup("TRef") >> TRef_;
+        dict.readEntry("TRef", TRef_);
 
         return true;
     }

src/functionObjects/field/heatTransferCoeff/heatTransferCoeffModels/heatTransferCoeffModel/heatTransferCoeffModel.C

@@ -46,16 +46,12 @@ Foam::heatTransferCoeffModel::q() const
     const volScalarField& T = mesh_.lookupObject<volScalarField>(TName_);
     const volScalarField::Boundary& Tbf = T.boundaryField();
 
-    tmp<FieldField<Field, scalar>> tq
+    auto tq = tmp<FieldField<Field, scalar>>::New(Tbf.size());
-    (
+    auto& q = tq.ref();
-        new FieldField<Field, scalar>(Tbf.size())
-    );
-
-    FieldField<Field, scalar>& q = tq.ref();
 
     forAll(q, patchi)
     {
-        q.set(patchi, new Field<scalar>(Tbf[patchi].size(), 0));
+        q.set(patchi, new Field<scalar>(Tbf[patchi].size(), Zero));
     }
 
     typedef compressible::turbulenceModel cmpTurbModel;
@@ -71,7 +67,7 @@ Foam::heatTransferCoeffModel::q() const
         const volScalarField alphaEff(turb.alphaEff());
         const volScalarField::Boundary& alphaEffbf = alphaEff.boundaryField();
 
-        for (label patchi : patchSet_)
+        for (const label patchi : patchSet_)
         {
             q[patchi] = alphaEffbf[patchi]*hebf[patchi].snGrad();
         }
@@ -105,7 +101,7 @@ Foam::heatTransferCoeffModel::q() const
         const volScalarField& qr = mesh_.lookupObject<volScalarField>(qrName_);
         const volScalarField::Boundary& qrbf = qr.boundaryField();
 
-        for (label patchi : patchSet_)
+        for (const label patchi : patchSet_)
         {
             q[patchi] += qrbf[patchi];
         }
@@ -135,8 +131,7 @@ Foam::heatTransferCoeffModel::heatTransferCoeffModel
 
 bool Foam::heatTransferCoeffModel::read(const dictionary& dict)
 {
-    patchSet_ =
+    patchSet_ = mesh_.boundaryMesh().patchSet(dict.get<wordRes>("patches"));
-        mesh_.boundaryMesh().patchSet(wordReList(dict.lookup("patches")));
 
     dict.readIfPresent("qr", qrName_);
 

src/functionObjects/field/heatTransferCoeff/heatTransferCoeffModels/heatTransferCoeffModel/heatTransferCoeffModelNew.C

@@ -36,7 +36,7 @@ Foam::autoPtr<Foam::heatTransferCoeffModel> Foam::heatTransferCoeffModel::New
     const word& TName
 )
 {
-    const word modelType(dict.lookup("htcModel"));
+    const word modelType(dict.get<word>("htcModel"));
 
     Info<< "Selecting heat transfer coefficient model " << modelType << endl;
 

src/functionObjects/field/histogram/histogram.C

@@ -105,13 +105,13 @@ bool Foam::functionObjects::histogram::read(const dictionary& dict)
     fvMeshFunctionObject::read(dict);
     writeFile::read(dict);
 
-    dict.lookup("field") >> fieldName_;
+    dict.readEntry("field", fieldName_);
 
     max_ = dict.lookupOrDefault<scalar>("max", -GREAT);
     min_ = dict.lookupOrDefault<scalar>("min", GREAT);
-    dict.lookup("nBins") >> nBins_;
+    dict.readEntry("nBins", nBins_);
 
-    word format(dict.lookup("setFormat"));
+    const word format(dict.get<word>("setFormat"));
     formatterPtr_ = writer<scalar>::New(format);
 
     return true;

src/functionObjects/field/mapFields/mapFields.C

@@ -53,7 +53,7 @@ void Foam::functionObjects::mapFields::createInterpolation
 )
 {
     const fvMesh& meshTarget = mesh_;
-    const word mapRegionName(dict.lookup("mapRegion"));
+    const word mapRegionName(dict.get<word>("mapRegion"));
 
     Info<< name() << ':' << nl
         << "    Reading mesh " << mapRegionName << endl;
@@ -71,7 +71,7 @@ void Foam::functionObjects::mapFields::createInterpolation
         )
     );
     const fvMesh& mapRegion = mapRegionPtr_();
-    const word mapMethodName(dict.lookup("mapMethod"));
+    const word mapMethodName(dict.get<word>("mapMethod"));
     if (!meshToMesh::interpolationMethodNames_.found(mapMethodName))
     {
         FatalErrorInFunction
@@ -100,11 +100,9 @@ void Foam::functionObjects::mapFields::createInterpolation
         Info<< "    Patch mapping method: " << patchMapMethodName << endl;
     }
 
-    bool consistent = readBool(dict.lookup("consistent"));
-
     Info<< "    Creating mesh to mesh interpolation" << endl;
 
-    if (consistent)
+    if (dict.get<bool>("consistent"))
     {
         interpPtr_.reset
         (
@@ -119,8 +117,11 @@ void Foam::functionObjects::mapFields::createInterpolation
     }
     else
     {
-        HashTable<word> patchMap(dict.lookup("patchMap"));
+        HashTable<word> patchMap;
-        wordList cuttingPatches(dict.lookup("cuttingPatches"));
+        wordList cuttingPatches;
+
+        dict.readEntry("patchMap", patchMap);
+        dict.readEntry("cuttingPatches", cuttingPatches);
 
         interpPtr_.reset
         (
@@ -162,7 +163,7 @@ bool Foam::functionObjects::mapFields::read(const dictionary& dict)
 {
     fvMeshFunctionObject::read(dict);
 
-    dict.lookup("fields") >> fieldNames_;
+    dict.readEntry("fields", fieldNames_);
     createInterpolation(dict);
     return true;
 }

src/functionObjects/field/nearWallFields/nearWallFields.C

@@ -260,10 +260,9 @@ bool Foam::functionObjects::nearWallFields::read(const dictionary& dict)
 {
     fvMeshFunctionObject::read(dict);
 
-    dict.lookup("fields") >> fieldSet_;
+    dict.readEntry("fields", fieldSet_);
-    patchSet_ =
+    patchSet_ = mesh_.boundaryMesh().patchSet(dict.get<wordRes>("patches"));
-        mesh_.boundaryMesh().patchSet(wordReList(dict.lookup("patches")));
+    distance_ = dict.get<scalar>("distance");
-    distance_ = readScalar(dict.lookup("distance"));
 
 
     // Clear out any previously loaded fields

src/functionObjects/field/nearWallFields/nearWallFieldsTemplates.C

@@ -37,9 +37,9 @@ void Foam::functionObjects::nearWallFields::createFields
 
     HashTable<const VolFieldType*> flds(obr_.lookupClass<VolFieldType>());
 
-    forAllConstIter(typename HashTable<const VolFieldType*>, flds, iter)
+    forAllConstIters(flds, iter)
     {
-        const VolFieldType& fld = *iter();
+        const VolFieldType& fld = *(iter.object());
 
         if (fieldMap_.found(fld.name()))
         {

src/functionObjects/field/particleDistribution/particleDistribution.C

@@ -80,10 +80,10 @@ bool Foam::functionObjects::particleDistribution::read(const dictionary& dict)
 {
     if (fvMeshFunctionObject::read(dict) && writeFile::read(dict))
     {
-        dict.lookup("cloud") >> cloudName_;
+        dict.readEntry("cloud", cloudName_);
-        dict.lookup("nameVsBinWidth") >> nameVsBinWidth_;
+        dict.readEntry("nameVsBinWidth", nameVsBinWidth_);
         dict.readIfPresent("tagField", tagFieldName_);
-        word format(dict.lookup("setFormat"));
+        const word format(dict.get<word>("setFormat"));
         writerPtr_ = writer<scalar>::New(format);
 
         Info<< type() << " " << name() << " output:" << nl

src/functionObjects/field/pressure/pressure.C

@@ -70,9 +70,7 @@ Foam::tmp<Foam::volScalarField> Foam::functionObjects::pressure::rhoScale
 {
     if (p.dimensions() == dimPressure)
     {
-        return tmp<volScalarField>
+        return tmp<volScalarField>::New
-        (
-            new volScalarField
         (
             IOobject
             (
@@ -85,7 +83,6 @@ Foam::tmp<Foam::volScalarField> Foam::functionObjects::pressure::rhoScale
             ),
             p,
             fvPatchField<scalar>::calculatedType()
-            )
         );
     }
     else
@@ -115,11 +112,9 @@ Foam::tmp<Foam::volScalarField> Foam::functionObjects::pressure::rhoScale
     {
         return lookupObject<volScalarField>(rhoName_)*tsf;
     }
-    else
+
-    {
     return dimensionedScalar("rhoInf", dimDensity, rhoInf_)*tsf;
 }
-}
 
 
 Foam::tmp<Foam::volScalarField> Foam::functionObjects::pressure::pRef
@@ -192,9 +187,7 @@ bool Foam::functionObjects::pressure::calc()
     {
         const volScalarField& p = lookupObject<volScalarField>(fieldName_);
 
-        tmp<volScalarField> tp
+        auto tp = tmp<volScalarField>::New
-        (
-            new volScalarField
         (
             IOobject
             (
@@ -205,16 +198,13 @@ bool Foam::functionObjects::pressure::calc()
                 IOobject::NO_WRITE
             ),
             coeff(pRef(pDyn(p, rhoScale(p))))
-            )
         );
 
         return store(resultName_, tp);
     }
-    else
+
-    {
     return false;
 }
-}
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
@@ -265,22 +255,22 @@ bool Foam::functionObjects::pressure::read(const dictionary& dict)
 
     if (rhoName_ == "rhoInf")
     {
-        dict.lookup("rhoInf") >> rhoInf_;
+        dict.readEntry("rhoInf", rhoInf_);
         rhoInfInitialised_ = true;
     }
 
-    dict.lookup("calcTotal") >> calcTotal_;
+    dict.readEntry("calcTotal", calcTotal_);
     if (calcTotal_)
     {
         pRef_ = dict.lookupOrDefault<scalar>("pRef", 0.0);
     }
 
-    dict.lookup("calcCoeff") >> calcCoeff_;
+    dict.readEntry("calcCoeff", calcCoeff_);
     if (calcCoeff_)
     {
-        dict.lookup("pInf") >> pInf_;
+        dict.readEntry("pInf", pInf_);
-        dict.lookup("UInf") >> UInf_;
+        dict.readEntry("UInf", UInf_);
-        dict.lookup("rhoInf") >> rhoInf_;
+        dict.readEntry("rhoInf", rhoInf_);
 
         scalar zeroCheck = 0.5*rhoInf_*magSqr(UInf_) + pInf_;
 

src/functionObjects/field/processorField/processorField.C

@@ -91,10 +91,10 @@ bool Foam::functionObjects::processorField::read(const dictionary& dict)
 
 bool Foam::functionObjects::processorField::execute()
 {
-    const volScalarField& procField =
+    volScalarField& procField =
-        mesh_.lookupObject<volScalarField>("processorID");
+        mesh_.lookupObjectRef<volScalarField>("processorID");
 
-    const_cast<volScalarField&>(procField) ==
+    procField ==
         dimensionedScalar("proci", dimless, Pstream::myProcNo());
 
     return true;

src/functionObjects/field/randomise/randomise.C

@@ -81,7 +81,7 @@ bool Foam::functionObjects::randomise::read(const dictionary& dict)
 {
     fieldExpression::read(dict);
 
-    dict.lookup("magPerturbation") >> magPerturbation_;
+    dict.readEntry("magPerturbation", magPerturbation_);
 
     return true;
 }

src/functionObjects/field/randomise/randomiseTemplates.C

@@ -39,27 +39,26 @@ bool Foam::functionObjects::randomise::calcRandomised()
 
         resultName_ = fieldName_ & "Random";
 
-        tmp<VolFieldType> rfieldt(new VolFieldType(field));
+        auto trfield = tmp<VolFieldType>::New(field);
-        VolFieldType& rfield = rfieldt.ref();
+        auto& rfield = trfield.ref();
 
         Random rand(1234567);
 
-        forAll(field, celli)
+        for (Type& cellval : rfield)
         {
             Type rndPert;
             rand.randomise01(rndPert);
             rndPert = 2.0*rndPert - pTraits<Type>::one;
             rndPert /= mag(rndPert);
-            rfield[celli] += magPerturbation_*rndPert;
+
+            cellval += magPerturbation_*rndPert;
         }
 
-        return store(resultName_, rfieldt);
+        return store(resultName_, trfield);
     }
-    else
+
-    {
     return false;
 }
-}
 
 
 // ************************************************************************* //

src/functionObjects/field/reactionSensitivityAnalysis/reactionsSensitivityAnalysis.C

@@ -78,9 +78,7 @@ calculateSpeciesRR
     const basicChemistryModel& basicChemistry
 )
 {
-    tmp<DimensionedField<scalar, volMesh>> RRt
+    auto RRt = tmp<DimensionedField<scalar, volMesh>>::New
-    (
-        new DimensionedField<scalar, volMesh>
     (
         IOobject
         (
@@ -92,10 +90,8 @@ calculateSpeciesRR
         ),
         mesh_,
         dimensionedScalar(dimMass/dimVolume/dimTime, Zero)
-        )
     );
-
+    auto& RR = RRt.ref();
-    DimensionedField<scalar, volMesh>& RR = RRt.ref();
 
     scalar dt = time_.deltaT().value();
 

src/functionObjects/field/readFields/readFields.C

@@ -74,7 +74,7 @@ bool Foam::functionObjects::readFields::read(const dictionary& dict)
 {
     fvMeshFunctionObject::read(dict);
 
-    dict.lookup("fields") >> fieldSet_;
+    dict.readEntry("fields", fieldSet_);
     dict.readIfPresent("readOnStart", readOnStart_);
 
     return true;

src/functionObjects/field/regionSizeDistribution/regionSizeDistribution.C

@@ -209,8 +209,8 @@ Foam::functionObjects::regionSizeDistribution::divide
     const scalarField& denom
 )
 {
-    tmp<scalarField> tresult(new scalarField(num.size()));
+    auto tresult = tmp<scalarField>::New(num.size());
-    scalarField& result = tresult.ref();
+    auto& result = tresult.ref();
 
     forAll(denom, i)
     {
@@ -317,8 +317,8 @@ Foam::functionObjects::regionSizeDistribution::regionSizeDistribution
 :
     fvMeshFunctionObject(name, runTime, dict),
     writeFile(obr_, name),
-    alphaName_(dict.lookup("field")),
+    alphaName_(dict.get<word>("field")),
-    patchNames_(dict.lookup("patches")),
+    patchNames_(dict.get<wordRes>("patches")),
     isoPlanes_(dict.lookupOrDefault("isoPlanes", false))
 {
     read(dict);
@@ -338,16 +338,16 @@ bool Foam::functionObjects::regionSizeDistribution::read(const dictionary& dict)
     fvMeshFunctionObject::read(dict);
     writeFile::read(dict);
 
-    dict.lookup("field") >> alphaName_;
+    dict.readEntry("field", alphaName_);
-    dict.lookup("patches") >> patchNames_;
+    dict.readEntry("patches", patchNames_);
-    dict.lookup("threshold") >> threshold_;
+    dict.readEntry("threshold", threshold_);
-    dict.lookup("maxDiameter") >> maxDiam_;
+    dict.readEntry("maxDiameter", maxDiam_);
     minDiam_ = 0.0;
     dict.readIfPresent("minDiameter", minDiam_);
-    dict.lookup("nBins") >> nBins_;
+    dict.readEntry("nBins", nBins_);
-    dict.lookup("fields") >> fields_;
+    dict.readEntry("fields", fields_);
 
-    word format(dict.lookup("setFormat"));
+    const word format(dict.get<word>("setFormat"));
     formatterPtr_ = writer<scalar>::New(format);
 
     if (dict.found("coordinateSystem"))
@@ -360,12 +360,12 @@ bool Foam::functionObjects::regionSizeDistribution::read(const dictionary& dict)
 
     if (isoPlanes_)
     {
-         dict.lookup("origin") >> origin_;
+         dict.readEntry("origin", origin_);
-         dict.lookup("direction") >> direction_;
+         dict.readEntry("direction", direction_);
-         dict.lookup("maxDiameter") >> maxDiameter_;
+         dict.readEntry("maxDiameter", maxDiameter_);
-         dict.lookup("nDownstreamBins") >> nDownstreamBins_;
+         dict.readEntry("nDownstreamBins", nDownstreamBins_);
-         dict.lookup("maxDownstream") >> maxDownstream_;
+         dict.readEntry("maxDownstream", maxDownstream_);
-         direction_ /= mag(direction_);
+         direction_.normalise();
     }
 
     return true;
@@ -458,6 +458,7 @@ bool Foam::functionObjects::regionSizeDistribution::write()
             {
                 tmp<scalarField> townFld(fvp.patchInternalField());
                 const scalarField& ownFld = townFld();
+
                 tmp<scalarField> tnbrFld(fvp.patchNeighbourField());
                 const scalarField& nbrFld = tnbrFld();
 

src/functionObjects/field/setFlow/setFlow.C

@@ -137,7 +137,7 @@ bool Foam::functionObjects::setFlow::read(const dictionary& dict)
     if (fvMeshFunctionObject::read(dict))
     {
         Info<< name() << ":" << endl;
-        mode_ = modeTypeNames.read(dict.lookup("mode"));
+        mode_ = modeTypeNames.lookup("mode", dict);
 
         Info<< "    operating mode: " << modeTypeNames[mode_] << endl;
 
@@ -176,22 +176,21 @@ bool Foam::functionObjects::setFlow::read(const dictionary& dict)
             case modeType::ROTATION:
             {
                 omegaPtr_ = Function1<scalar>::New("omega", dict);
-                dict.lookup("origin") >> origin_;
+
-                vector refDir(dict.lookup("refDir"));
+                dict.readEntry("origin", origin_);
-                refDir /= mag(refDir) + ROOTVSMALL;
+                const vector refDir(dict.get<vector>("refDir").normalise());
-                vector axis(dict.lookup("axis"));
+                const vector axis(dict.get<vector>("axis").normalise());
-                axis /= mag(axis) + ROOTVSMALL;
+
                 R_ = tensor(refDir, axis, refDir^axis);
                 break;
             }
             case modeType::VORTEX2D:
             case modeType::VORTEX3D:
             {
-                dict.lookup("origin") >> origin_;
+                dict.readEntry("origin", origin_);
-                vector refDir(dict.lookup("refDir"));
+                const vector refDir(dict.get<vector>("refDir").normalise());
-                refDir /= mag(refDir) + ROOTVSMALL;
+                const vector axis(dict.get<vector>("axis").normalise());
-                vector axis(dict.lookup("axis"));
+
-                axis /= mag(axis) + ROOTVSMALL;
                 R_ = tensor(refDir, axis, refDir^axis);
                 break;
             }

src/functionObjects/field/stabilityBlendingFactor/stabilityBlendingFactor.C

@@ -279,9 +279,7 @@ bool Foam::functionObjects::stabilityBlendingFactor::init(bool first)
                 << exit(FatalError);
         }
 
-        tmp<volScalarField> magGradCCPtr
+        auto tmagGradCC = tmp<volScalarField>::New
-        (
-            new volScalarField
         (
             IOobject
             (
@@ -294,8 +292,8 @@ bool Foam::functionObjects::stabilityBlendingFactor::init(bool first)
             mesh_,
             dimensionedScalar(dimless, Zero),
             zeroGradientFvPatchScalarField::typeName
-            )
         );
+        auto& magGradCC = tmagGradCC.ref();
 
         for (direction i=0; i<vector::nComponents; i++)
         {
@@ -316,12 +314,12 @@ bool Foam::functionObjects::stabilityBlendingFactor::init(bool first)
             );
             cci = mesh_.C().component(i);
             cci.correctBoundaryConditions();
-            magGradCCPtr.ref() +=  mag(fvc::grad(cci)).ref();
+            magGradCC += mag(fvc::grad(cci)).ref();
         }
 
         if (first)
         {
-            Log << "    Max magGradCc :  " << max(magGradCCPtr.ref()).value()
+            Log << "    Max magGradCc :  " << max(magGradCC.ref()).value()
                 << endl;
         }
 
@@ -334,7 +332,7 @@ bool Foam::functionObjects::stabilityBlendingFactor::init(bool first)
                     max
                     (
                         scalar(0),
-                        (magGradCCPtr.ref() - maxGradCc_)
+                        (magGradCC - maxGradCc_)
                       / (minGradCc_ - maxGradCc_)
                     ),
                     scalar(1)
@@ -355,9 +353,7 @@ bool Foam::functionObjects::stabilityBlendingFactor::init(bool first)
                 << exit(FatalError);
         }
 
-        tmp<volScalarField> CoPtr
+        auto CoPtr = tmp<volScalarField>::New
-        (
-            new volScalarField
         (
             IOobject
             (
@@ -370,10 +366,9 @@ bool Foam::functionObjects::stabilityBlendingFactor::init(bool first)
             mesh_,
             dimensionedScalar(dimless, Zero),
             zeroGradientFvPatchScalarField::typeName
-            )
         );
 
-        volScalarField& Co = CoPtr.ref();
+        auto& Co = CoPtr.ref();
 
         Co.primitiveFieldRef() =
             mesh_.time().deltaT()*mag(*UNamePtr)/pow(mesh_.V(), 1.0/3.0);
@@ -417,12 +412,10 @@ bool Foam::functionObjects::stabilityBlendingFactor::init(bool first)
     indicator_.max(0.0);
 
     // Update the blended surface field
-    surfaceScalarField* surBlendedPtr =
+    surfaceScalarField& surBlended =
-    (
+        mesh_.lookupObjectRef<surfaceScalarField>(resultName_);
-        mesh_.lookupObjectRefPtr<surfaceScalarField>(resultName_)
-    );
 
-    *surBlendedPtr = fvc::interpolate(indicator_);
+    surBlended = fvc::interpolate(indicator_);
 
     return true;
 }
@@ -511,9 +504,7 @@ Foam::functionObjects::stabilityBlendingFactor::stabilityBlendingFactor
     read(dict);
     setResultName(typeName, "");
 
-    tmp<surfaceScalarField> faceBlendedPtr
+    auto faceBlendedPtr = tmp<surfaceScalarField>::New
-    (
-        new surfaceScalarField
     (
         IOobject
         (
@@ -525,7 +516,6 @@ Foam::functionObjects::stabilityBlendingFactor::stabilityBlendingFactor
         ),
         mesh_,
         dimensionedScalar(dimless, Zero)
-        )
     );
     store(resultName_, faceBlendedPtr);
 
@@ -653,12 +643,12 @@ bool Foam::functionObjects::stabilityBlendingFactor::read
 {
     if (fieldExpression::read(dict) && writeFile::read(dict))
     {
-        dict.lookup("switchNonOrtho") >> nonOrthogonality_;
+        dict.readEntry("switchNonOrtho", nonOrthogonality_);
-        dict.lookup("switchGradCc") >> gradCc_;
+        dict.readEntry("switchGradCc", gradCc_);
-        dict.lookup("switchResiduals") >> residuals_;
+        dict.readEntry("switchResiduals", residuals_);
-        dict.lookup("switchFaceWeight") >> faceWeight_;
+        dict.readEntry("switchFaceWeight", faceWeight_);
-        dict.lookup("switchSkewness") >> skewness_;
+        dict.readEntry("switchSkewness", skewness_);
-        dict.lookup("switchCo") >> Co_;
+        dict.readEntry("switchCo", Co_);
 
         dict.readIfPresent("maxNonOrthogonality", maxNonOrthogonality_);
         dict.readIfPresent("maxGradCc", maxGradCc_);

src/functionObjects/field/streamFunction/streamFunction.C

@@ -71,9 +71,7 @@ Foam::tmp<Foam::pointScalarField> Foam::functionObjects::streamFunction::calc
 
     const pointMesh& pMesh = pointMesh::New(mesh_);
 
-    tmp<pointScalarField> tstreamFunction
+    auto tstreamFunction = tmp<pointScalarField>::New
-    (
-        new pointScalarField
     (
         IOobject
         (
@@ -83,15 +81,11 @@ Foam::tmp<Foam::pointScalarField> Foam::functionObjects::streamFunction::calc
         ),
         pMesh,
         dimensionedScalar(phi.dimensions(), Zero)
-        )
     );
     pointScalarField& streamFunction = tstreamFunction.ref();
 
-    labelList visitedPoint(mesh_.nPoints());
+    labelList visitedPoint(mesh_.nPoints(), Zero);
-    forAll(visitedPoint, pointi)
+
-    {
-        visitedPoint[pointi] = 0;
-    }
     label nVisited = 0;
     label nVisitedOld = 0;
 
@@ -263,7 +257,7 @@ Foam::tmp<Foam::pointScalarField> Foam::functionObjects::streamFunction::calc
                                     points[curBPoints[pointi]]
                                   - currentBStreamPoint;
                                 edgeHat.replace(slabDir, 0);
-                                edgeHat /= mag(edgeHat);
+                                edgeHat.normalise();
 
                                 vector nHat = unitAreas[facei];
 
@@ -356,7 +350,7 @@ Foam::tmp<Foam::pointScalarField> Foam::functionObjects::streamFunction::calc
                                 points[curPoints[pointi]] - currentStreamPoint;
 
                             edgeHat.replace(slabDir, 0);
-                            edgeHat /= mag(edgeHat);
+                            edgeHat.normalise();
 
                             vector nHat = unitAreas[facei];
 

src/functionObjects/field/streamLine/streamLineBase.C

@@ -865,7 +865,7 @@ bool Foam::functionObjects::streamLineBase::read(const dictionary& dict)
 
     if (fields_.empty())
     {
-        dict.lookup("fields") >> fields_;
+        dict.readEntry("fields", fields_);
 
         if (!fields_.found(UName_))
         {
@@ -878,8 +878,8 @@ bool Foam::functionObjects::streamLineBase::read(const dictionary& dict)
 
     Info<< "    Employing velocity field " << UName_ << endl;
 
-    dict.lookup("trackForward") >> trackForward_;
+    dict.readEntry("trackForward", trackForward_);
-    dict.lookup("lifeTime") >> lifeTime_;
+    dict.readEntry("lifeTime", lifeTime_);
     if (lifeTime_ < 1)
     {
         FatalErrorInFunction
@@ -916,8 +916,8 @@ bool Foam::functionObjects::streamLineBase::read(const dictionary& dict)
     sampledSetPtr_.clear();
     sampledSetAxis_.clear();
 
-    scalarFormatterPtr_ = writer<scalar>::New(dict.lookup("setFormat"));
+    scalarFormatterPtr_ = writer<scalar>::New(dict.get<word>("setFormat"));
-    vectorFormatterPtr_ = writer<vector>::New(dict.lookup("setFormat"));
+    vectorFormatterPtr_ = writer<vector>::New(dict.get<word>("setFormat"));
 
     return true;
 }

src/functionObjects/field/surfaceInterpolate/surfaceInterpolate.C

@@ -76,7 +76,7 @@ bool Foam::functionObjects::surfaceInterpolate::read
 {
     fvMeshFunctionObject::read(dict);
 
-    dict.lookup("fields") >> fieldSet_;
+    dict.readEntry("fields", fieldSet_);
 
     return true;
 }

src/functionObjects/field/turbulenceFields/turbulenceFields.C

@@ -144,11 +144,11 @@ bool Foam::functionObjects::turbulenceFields::read(const dictionary& dict)
 
     if (dict.found("field"))
     {
-        fieldSet_.insert(word(dict.lookup("field")));
+        fieldSet_.insert(dict.get<word>("field"));
     }
     else
     {
-        fieldSet_.insert(wordList(dict.lookup("fields")));
+        fieldSet_.insert(dict.get<wordList>("fields"));
     }
 
     Info<< type() << " " << name() << ": ";

src/functionObjects/field/turbulenceFields/turbulenceFieldsTemplates.C

@@ -40,8 +40,7 @@ void Foam::functionObjects::turbulenceFields::processField
 
     if (obr_.foundObject<FieldType>(scopedName))
     {
-        FieldType& fld =
+        FieldType& fld = obr_.lookupObjectRef<FieldType>(scopedName);
-            const_cast<FieldType&>(obr_.lookupObject<FieldType>(scopedName));
         fld == tvalue();
     }
     else if (obr_.found(scopedName))

src/functionObjects/field/valueAverage/valueAverage.C

@@ -87,7 +87,7 @@ Foam::functionObjects::valueAverage::valueAverage
             if (dict.found(fieldName))
             {
                 const dictionary& valueDict = dict.subDict(fieldName);
-                totalTime_[fieldi] = readScalar(valueDict.lookup("totalTime"));
+                totalTime_[fieldi] = valueDict.get<scalar>("totalTime");
             }
         }
     }
@@ -112,8 +112,8 @@ bool Foam::functionObjects::valueAverage::read(const dictionary& dict)
     // Make certain that the values are consistent with the defaults:
     resetOnRestart_ = false;
 
-    dict.lookup("functionObject") >> functionObjectName_;
+    dict.readEntry("functionObject", functionObjectName_);
-    dict.lookup("fields") >> fieldNames_;
+    dict.readEntry("fields", fieldNames_);
     if (dict.readIfPresent("window", window_))
     {
         window_ = obr().time().userTimeToTime(window_);

src/functionObjects/field/wallBoundedStreamLine/wallBoundedParticle.C

@@ -316,8 +316,7 @@ Foam::scalar Foam::wallBoundedParticle::trackFaceTri
 
         // Outwards pointing normal
         vector edgeNormal = (pt1 - pt0)^n;
-
+        edgeNormal.normalise();
-        edgeNormal /= mag(edgeNormal) + VSMALL;
 
         // Determine whether position and end point on either side of edge.
         scalar sEnd = (endPosition - pt0)&edgeNormal;

src/functionObjects/field/wallBoundedStreamLine/wallBoundedParticleTemplates.C

@@ -166,8 +166,7 @@ Foam::scalar Foam::wallBoundedParticle::trackToEdge
         }
 
         const triFace tri(currentTetIndices().faceTriIs(mesh(), false));
-        vector n = tri.normal(mesh().points());
+        const vector n = tri.unitNormal(mesh().points());
-        n /= mag(n);
 
         point projectedEndPosition = endPosition;
 

src/functionObjects/field/yPlus/yPlus.C

@@ -120,10 +120,7 @@ bool Foam::functionObjects::yPlus::read(const dictionary& dict)
 bool Foam::functionObjects::yPlus::execute()
 {
     volScalarField& yPlus =
-        const_cast<volScalarField&>
+        lookupObjectRef<volScalarField>(typeName);
-        (
-            lookupObject<volScalarField>(typeName)
-        );
 
     if (foundObject<turbulenceModel>(turbulenceModel::propertiesName))
     {

src/functionObjects/field/zeroGradient/zeroGradient.C

@@ -112,7 +112,7 @@ bool Foam::functionObjects::zeroGradient::read(const dictionary& dict)
 {
     fvMeshFunctionObject::read(dict);
 
-    dict.lookup("fields") >> selectFields_;
+    dict.readEntry("fields", selectFields_);
     selectFields_.uniq();
 
     Info<< type() << " fields: " << selectFields_ << nl;

src/functionObjects/field/zeroGradient/zeroGradientTemplates.C

@@ -83,9 +83,7 @@ int Foam::functionObjects::zeroGradient::apply
 
     if (!foundObject<VolFieldType>(outputName))
     {
-        tmp<VolFieldType> tzg
+        auto tzeroGrad = tmp<VolFieldType>::New
-        (
-            new VolFieldType
         (
             IOobject
             (
@@ -98,14 +96,12 @@ int Foam::functionObjects::zeroGradient::apply
             mesh_,
             dimensioned<Type>(input.dimensions(), Zero),
             zeroGradientFvPatchField<Type>::typeName
-            )
         );
 
-        store(outputName, tzg);
+        store(outputName, tzeroGrad);
     }
 
-    VolFieldType& output =
+    VolFieldType& output = lookupObjectRef<VolFieldType>(outputName);
-        const_cast<VolFieldType&>(lookupObject<VolFieldType>(outputName));
 
     output = input;
     output.correctBoundaryConditions();

src/functionObjects/forces/forceCoeffs/forceCoeffs.C

@@ -243,24 +243,24 @@ bool Foam::functionObjects::forceCoeffs::read(const dictionary& dict)
     forces::read(dict);
 
     // Directions for lift and drag forces, and pitch moment
-    dict.lookup("liftDir") >> liftDir_;
+    dict.readEntry("liftDir", liftDir_);
-    dict.lookup("dragDir") >> dragDir_;
+    dict.readEntry("dragDir", dragDir_);
-    dict.lookup("pitchAxis") >> pitchAxis_;
+    dict.readEntry("pitchAxis", pitchAxis_);
 
     // Free stream velocity magnitude
-    dict.lookup("magUInf") >> magUInf_;
+    dict.readEntry("magUInf", magUInf_);
 
     // If case is compressible we must read rhoInf (store in rhoRef_) to
     // calculate the reference dynamic pressure
     // - note: for incompressible, rhoRef_ is already initialised
     if (rhoName_ != "rhoInf")
     {
-        dict.lookup("rhoInf") >> rhoRef_;
+        dict.readEntry("rhoInf", rhoRef_);
     }
 
     // Reference length and area scales
-    dict.lookup("lRef") >> lRef_;
+    dict.readEntry("lRef", lRef_);
-    dict.lookup("Aref") >> Aref_;
+    dict.readEntry("Aref", Aref_);
 
     if (writeFields_)
     {
@@ -402,16 +402,10 @@ bool Foam::functionObjects::forceCoeffs::execute()
             lookupObject<volVectorField>(fieldName("moment"));
 
         volVectorField& forceCoeff =
-            const_cast<volVectorField&>
+            lookupObjectRef<volVectorField>(fieldName("forceCoeff"));
-            (
-                lookupObject<volVectorField>(fieldName("forceCoeff"))
-            );
 
         volVectorField& momentCoeff =
-            const_cast<volVectorField&>
+            lookupObjectRef<volVectorField>(fieldName("momentCoeff"));
-            (
-                lookupObject<volVectorField>(fieldName("momentCoeff"))
-            );
 
         dimensionedScalar f0("f0", dimForce, Aref_*pDyn);
         dimensionedScalar m0("m0", dimForce*dimLength, Aref_*lRef_*pDyn);

src/functionObjects/forces/forces/forces.C

@@ -292,18 +292,12 @@ void Foam::functionObjects::forces::resetFields()
     if (writeFields_)
     {
         volVectorField& force =
-            const_cast<volVectorField&>
+            lookupObjectRef<volVectorField>(fieldName("force"));
-            (
-                lookupObject<volVectorField>(fieldName("force"))
-            );
 
         force == dimensionedVector(force.dimensions(), Zero);
 
         volVectorField& moment =
-            const_cast<volVectorField&>
+            lookupObjectRef<volVectorField>(fieldName("moment"));
-            (
-                lookupObject<volVectorField>(fieldName("moment"))
-            );
 
         moment == dimensionedVector(moment.dimensions(), Zero);
     }
@@ -415,9 +409,7 @@ Foam::tmp<Foam::volScalarField> Foam::functionObjects::forces::rho() const
 {
     if (rhoName_ == "rhoInf")
     {
-        return tmp<volScalarField>
+        return tmp<volScalarField>::New
-        (
-            new volScalarField
         (
             IOobject
             (
@@ -427,14 +419,11 @@ Foam::tmp<Foam::volScalarField> Foam::functionObjects::forces::rho() const
             ),
             mesh_,
             dimensionedScalar("rho", dimDensity, rhoRef_)
-            )
         );
     }
-    else
+
-    {
     return(lookupObject<volScalarField>(rhoName_));
 }
-}
 
 
 Foam::scalar Foam::functionObjects::forces::rho(const volScalarField& p) const
@@ -443,8 +432,7 @@ Foam::scalar Foam::functionObjects::forces::rho(const volScalarField& p) const
     {
         return 1.0;
     }
-    else
+
-    {
     if (rhoName_ != "rhoInf")
     {
         FatalErrorInFunction
@@ -454,7 +442,6 @@ Foam::scalar Foam::functionObjects::forces::rho(const volScalarField& p) const
 
     return rhoRef_;
 }
-}
 
 
 void Foam::functionObjects::forces::applyBins
@@ -509,19 +496,13 @@ void Foam::functionObjects::forces::addToFields
     }
 
     volVectorField& force =
-        const_cast<volVectorField&>
+        lookupObjectRef<volVectorField>(fieldName("force"));
-        (
-            lookupObject<volVectorField>(fieldName("force"))
-        );
 
     vectorField& pf = force.boundaryFieldRef()[patchi];
     pf += fN + fT + fP;
 
     volVectorField& moment =
-        const_cast<volVectorField&>
+        lookupObjectRef<volVectorField>(fieldName("moment"));
-        (
-            lookupObject<volVectorField>(fieldName("moment"))
-        );
 
     vectorField& pm = moment.boundaryFieldRef()[patchi];
     pm += Md;
@@ -543,16 +524,10 @@ void Foam::functionObjects::forces::addToFields
     }
 
     volVectorField& force =
-        const_cast<volVectorField&>
+        lookupObjectRef<volVectorField>(fieldName("force"));
-        (
-            lookupObject<volVectorField>(fieldName("force"))
-        );
 
     volVectorField& moment =
-        const_cast<volVectorField&>
+        lookupObjectRef<volVectorField>(fieldName("moment"));
-        (
-            lookupObject<volVectorField>(fieldName("moment"))
-        );
 
     forAll(cellIDs, i)
     {
@@ -851,7 +826,7 @@ bool Foam::functionObjects::forces::read(const dictionary& dict)
 
     const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
 
-    patchSet_ = pbm.patchSet(wordReList(dict.lookup("patches")));
+    patchSet_ = pbm.patchSet(dict.get<wordRes>("patches"));
 
     if (directForceDensity_)
     {
@@ -868,7 +843,7 @@ bool Foam::functionObjects::forces::read(const dictionary& dict)
         // Reference density needed for incompressible calculations
         if (rhoName_ == "rhoInf")
         {
-            dict.lookup("rhoInf") >> rhoRef_;
+            dict.readEntry("rhoInf", rhoRef_);
         }
 
         // Reference pressure, 0 by default
@@ -899,7 +874,7 @@ bool Foam::functionObjects::forces::read(const dictionary& dict)
     if (dict.found("binData"))
     {
         const dictionary& binDict(dict.subDict("binData"));
-        binDict.lookup("nBin") >> nBin_;
+        binDict.readEntry("nBin", nBin_);
 
         if (nBin_ < 0)
         {
@@ -914,9 +889,9 @@ bool Foam::functionObjects::forces::read(const dictionary& dict)
         }
         else
         {
-            binDict.lookup("cumulative") >> binCumulative_;
+            binDict.readEntry("cumulative", binCumulative_);
-            binDict.lookup("direction") >> binDir_;
+            binDict.readEntry("direction", binDir_);
-            binDir_ /= mag(binDir_);
+            binDir_.normalise();
         }
     }
 
@@ -1062,7 +1037,7 @@ void Foam::functionObjects::forces::calcForcesMoment()
                 << endl;
         }
 
-        forAllConstIter(HashTable<const porosityModel*>, models, iter)
+        forAllConstIters(models, iter)
         {
             // Non-const access required if mesh is changing
             porosityModel& pm = const_cast<porosityModel&>(*iter());

src/functionObjects/graphics/runTimePostProcessing/fieldVisualisationBase.C

@@ -484,7 +484,7 @@ Foam::functionObjects::fieldVisualisationBase::fieldVisualisationBase
 )
 :
     colours_(colours),
-    fieldName_(dict.lookup("field")),
+    fieldName_(dict.get<word>("field")),
     colourBy_(cbColour),
     colourMap_(cmRainbow),
     range_()
@@ -500,7 +500,7 @@ Foam::functionObjects::fieldVisualisationBase::fieldVisualisationBase
         }
         case cbField:
         {
-            dict.lookup("range") >> range_;
+            dict.readEntry("range", range_);
 
             if (dict.found("colourMap"))
             {
@@ -508,15 +508,15 @@ Foam::functionObjects::fieldVisualisationBase::fieldVisualisationBase
             }
 
             const dictionary& sbarDict = dict.subDict("scalarBar");
-            sbarDict.lookup("visible") >> scalarBar_.visible_;
+            sbarDict.readEntry("visible", scalarBar_.visible_);
             if (scalarBar_.visible_)
             {
-                sbarDict.lookup("vertical") >> scalarBar_.vertical_;
+                sbarDict.readEntry("vertical", scalarBar_.vertical_);
-                sbarDict.lookup("position") >> scalarBar_.position_;
+                sbarDict.readEntry("position", scalarBar_.position_);
-                sbarDict.lookup("title") >> scalarBar_.title_;
+                sbarDict.readEntry("title", scalarBar_.title_);
-                sbarDict.lookup("fontSize") >> scalarBar_.fontSize_;
+                sbarDict.readEntry("fontSize", scalarBar_.fontSize_);
-                sbarDict.lookup("labelFormat") >> scalarBar_.labelFormat_;
+                sbarDict.readEntry("labelFormat", scalarBar_.labelFormat_);
-                sbarDict.lookup("numberOfLabels") >> scalarBar_.numberOfLabels_;
+                sbarDict.readEntry("numberOfLabels", scalarBar_.numberOfLabels_);
             }
             break;
         }

src/functionObjects/graphics/runTimePostProcessing/functionObjectBase.C

@@ -86,7 +86,7 @@ Foam::functionObjects::runTimePostPro::functionObjectBase::functionObjectBase
 :
     fieldVisualisationBase(dict, colours),
     state_(state),
-    functionObjectName_(dict.lookup("functionObject")),
+    functionObjectName_(dict.get<word>("functionObject")),
     clearObjects_(dict.lookupOrDefault("clearObjects", false))
 {}
 

src/functionObjects/graphics/runTimePostProcessing/functionObjectCloud.C

@@ -65,9 +65,9 @@ Foam::functionObjects::runTimePostPro::functionObjectCloud::functionObjectCloud
 :
     pointData(parent, dict, colours),
     functionObjectBase(parent, dict, colours),
-    cloudName_(dict.lookup("cloud")),
+    cloudName_(dict.get<word>("cloud")),
     inputFileName_(),
-    colourFieldName_(dict.lookup("colourField")),
+    colourFieldName_(dict.get<word>("colourField")),
     actor_()
 {
     actor_ = vtkSmartPointer<vtkActor>::New();

src/functionObjects/graphics/runTimePostProcessing/geometryBase.C

@@ -86,7 +86,7 @@ Foam::functionObjects::runTimePostPro::geometryBase::geometryBase
 :
     parent_(parent),
     name_(dict.dictName()),
-    visible_(readBool(dict.lookup("visible"))),
+    visible_(dict.get<bool>("visible")),
     renderMode_(rmGouraud),
     opacity_(nullptr),
     colours_(colours)

src/functionObjects/graphics/runTimePostProcessing/geometrySurface.C

@@ -140,8 +140,10 @@ Foam::functionObjects::runTimePostPro::geometrySurface::geometrySurface
 )
 :
     surface(parent, dict, colours),
-    fileNames_(dict.lookup("files"))
+    fileNames_()
-{}
+{
+    dict.readEntry("files", fileNames_);
+}
 
 
 Foam::functionObjects::runTimePostPro::geometrySurface::geometrySurface

src/functionObjects/graphics/runTimePostProcessing/pathline.C

@@ -155,7 +155,7 @@ Foam::functionObjects::runTimePostPro::pathline::pathline
         }
         case rtTube:
         {
-            dict.lookup("tubeRadius") >> tubeRadius_;
+            dict.readEntry("tubeRadius", tubeRadius_);
             break;
         }
         case rtVector:

src/functionObjects/graphics/runTimePostProcessing/pointData.C

@@ -101,7 +101,7 @@ Foam::functionObjects::runTimePostPro::pointData::pointData
     (
         representationTypeNames.lookup("representation", dict)
     ),
-    maxGlyphLength_(readScalar(dict.lookup("maxGlyphLength"))),
+    maxGlyphLength_(dict.get<scalar>("maxGlyphLength")),
     pointColour_(nullptr)
 {
     if (dict.found("pointColour"))

src/functionObjects/graphics/runTimePostProcessing/runTimePostProcessing.C

@@ -97,9 +97,9 @@ bool Foam::functionObjects::runTimePostProcessing::read(const dictionary& dict)
     scene_.read(dict);
 
     const dictionary& outputDict = dict.subDict("output");
-    outputDict.lookup("name") >> output_.name_;
+    outputDict.readEntry("name", output_.name_);
-    outputDict.lookup("width") >> output_.width_;
+    outputDict.readEntry("width", output_.width_);
-    outputDict.lookup("height") >> output_.height_;
+    outputDict.readEntry("height", output_.height_);
 
 
     readObjects(dict.subOrEmptyDict("points"), points_);
@@ -117,11 +117,14 @@ bool Foam::functionObjects::runTimePostProcessing::read(const dictionary& dict)
                 << exit(FatalIOError);
         }
 
-        text_.append(new runTimePostPro::text
+        text_.append
+        (
+            new runTimePostPro::text
             (
                 *this,
                 iter().dict(),
-            scene_.colours())
+                scene_.colours()
+            )
         );
     }
 

src/functionObjects/graphics/runTimePostProcessing/runTimePostProcessingTemplates.C

@@ -44,7 +44,7 @@ void Foam::functionObjects::runTimePostProcessing::readObjects
         }
 
         const dictionary& objectDict(iter().dict());
-        word objectType = objectDict.lookup("type");
+        const word objectType = objectDict.get<word>("type");
 
         objects.append
         (

src/functionObjects/graphics/runTimePostProcessing/scene.C

@@ -87,7 +87,7 @@ void Foam::functionObjects::runTimePostPro::scene::readCamera
     cameraUp_ = Function1<vector>::New("up", dict);
 
     dict.readIfPresent("clipBox", clipBox_);
-    dict.lookup("parallelProjection") >> parallelProjection_;
+    dict.readEntry("parallelProjection", parallelProjection_);
     if (!parallelProjection_)
     {
         if (dict.found("viewAngle"))

src/functionObjects/graphics/runTimePostProcessing/surface.C

@@ -184,11 +184,11 @@ Foam::functionObjects::runTimePostPro::surface::surface
 
     if (representation_ == rtGlyph)
     {
-        dict.lookup("maxGlyphLength") >> maxGlyphLength_;
+        dict.readEntry("maxGlyphLength", maxGlyphLength_);
     }
     else
     {
-        dict.lookup("featureEdges") >> featureEdges_;
+        dict.readEntry("featureEdges", featureEdges_);
     }
 }
 

src/functionObjects/graphics/runTimePostProcessing/text.C

@@ -44,13 +44,15 @@ Foam::functionObjects::runTimePostPro::text::text
 )
 :
     geometryBase(parent, dict, colours),
-    string_(dict.lookup("string")),
+    string_(dict.get<string>("string")),
-    position_(dict.lookup("position")),
+    position_(),
-    size_(readScalar(dict.lookup("size"))),
+    size_(dict.get<scalar>("size")),
     colour_(nullptr),
-    bold_(readBool(dict.lookup("bold"))),
+    bold_(dict.get<bool>("bold")),
     timeStamp_(dict.lookupOrDefault("timeStamp", false))
 {
+    dict.readEntry("position", position_);
+
     if (dict.found("colour"))
     {
         colour_.reset(Function1<vector>::New("colour", dict).ptr());

src/functionObjects/lagrangian/cloudInfo/cloudInfo.C

@@ -90,7 +90,7 @@ bool Foam::functionObjects::cloudInfo::read(const dictionary& dict)
 {
     if (regionFunctionObject::read(dict) && logFiles::read(dict))
     {
-        logFiles::resetNames(dict.lookup("clouds"));
+        logFiles::resetNames(dict.get<wordList>("clouds"));
 
         Info<< type() << " " << name() << ": ";
         if (writeToFile() && names().size())

src/functionObjects/lagrangian/vtkCloud/vtkCloud.C

@@ -364,7 +364,7 @@ bool Foam::functionObjects::vtkCloud::read(const dictionary& dict)
     writeOpts_.ascii
     (
         dict.found("format")
-     && (IOstream::formatEnum(dict.lookup("format")) == IOstream::ASCII)
+     && (IOstream::formatEnum(dict.get<word>("format")) == IOstream::ASCII)
     );
 
     writeOpts_.append(false);  // No append supported

src/functionObjects/solvers/energyTransport/energyTransport.C

@@ -57,9 +57,7 @@ Foam::volScalarField& Foam::functionObjects::energyTransport::transportedField()
 {
     if (!foundObject<volScalarField>(fieldName_))
     {
-        tmp<volScalarField> tfldPtr
+        auto tfldPtr = tmp<volScalarField>::New
-        (
-            new volScalarField
         (
             IOobject
             (
@@ -70,7 +68,6 @@ Foam::volScalarField& Foam::functionObjects::energyTransport::transportedField()
                 IOobject::AUTO_WRITE
             ),
             mesh_
-            )
         );
         store(fieldName_, tfldPtr);
     }
@@ -113,9 +110,7 @@ Foam::functionObjects::energyTransport::kappaEff() const
 Foam::tmp<Foam::volScalarField>
 Foam::functionObjects::energyTransport::rho() const
 {
-    tmp<volScalarField> trho
+    auto trho = tmp<volScalarField>::New
-    (
-        new volScalarField
     (
         IOobject
         (
@@ -127,7 +122,6 @@ Foam::functionObjects::energyTransport::rho() const
         ),
         mesh_,
         rho_
-        )
     );
 
     if (phases_.size())
@@ -152,9 +146,7 @@ Foam::functionObjects::energyTransport::Cp() const
         return tCp;
     }
 
-    tmp<volScalarField> tCp
+    return tmp<volScalarField>::New
-    (
-        new volScalarField
     (
         IOobject
         (
@@ -166,10 +158,7 @@ Foam::functionObjects::energyTransport::Cp() const
         ),
         mesh_,
         Cp_
-        )
     );
-
-    return tCp;
 }
 
 
@@ -187,9 +176,7 @@ Foam::functionObjects::energyTransport::kappa() const
         return tkappa;
     }
 
-    tmp<volScalarField> tkappa
+    return tmp<volScalarField>::New
-    (
-        new volScalarField
     (
         IOobject
         (
@@ -201,10 +188,7 @@ Foam::functionObjects::energyTransport::kappa() const
         ),
         mesh_,
         kappa_
-        )
     );
-
-    return tkappa;
 }
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
@@ -430,9 +414,7 @@ bool Foam::functionObjects::energyTransport::execute()
 
         const surfaceScalarField CpPhi(rhoCp*phi);
 
-        tmp<volScalarField> trhoCp
+        auto trhoCp = tmp<volScalarField>::New
-        (
-            new volScalarField
         (
             IOobject
             (
@@ -444,7 +426,6 @@ bool Foam::functionObjects::energyTransport::execute()
             ),
             mesh_,
             rhoCp
-            )
         );
 
         for (label i = 0; i <= nCorr_; i++)

src/functionObjects/solvers/scalarTransport/scalarTransport.C

@@ -58,9 +58,7 @@ Foam::volScalarField& Foam::functionObjects::scalarTransport::transportedField()
 {
     if (!foundObject<volScalarField>(fieldName_))
     {
-        tmp<volScalarField> tfldPtr
+        auto tfldPtr = tmp<volScalarField>::New
-        (
-            new volScalarField
         (
             IOobject
             (
@@ -71,7 +69,6 @@ Foam::volScalarField& Foam::functionObjects::scalarTransport::transportedField()
                 IOobject::AUTO_WRITE
             ),
             mesh_
-            )
         );
         store(fieldName_, tfldPtr);
 
@@ -81,10 +78,7 @@ Foam::volScalarField& Foam::functionObjects::scalarTransport::transportedField()
         }
     }
 
-    return const_cast<volScalarField&>
+    return lookupObjectRef<volScalarField>(fieldName_);
-    (
-        lookupObject<volScalarField>(fieldName_)
-    );
 }
 
 

src/functionObjects/utilities/ensightWrite/ensightWrite.C

@@ -109,19 +109,16 @@ bool Foam::functionObjects::ensightWrite::read(const dictionary& dict)
     //
     writeOpts_.noPatches(dict.lookupOrDefault("noPatches", false));
 
-    if (dict.found("patches"))
+    wordRes list;
+    if (dict.readIfPresent("patches", list))
     {
-        wordRes list(dict.lookup("patches"));
         list.uniq();
-
         writeOpts_.patchSelection(list);
     }
 
-    if (dict.found("faceZones"))
+    if (dict.readIfPresent("faceZones", list))
     {
-        wordRes list(dict.lookup("faceZones"));
         list.uniq();
-
         writeOpts_.faceZoneSelection(list);
     }
 
@@ -147,7 +144,7 @@ bool Foam::functionObjects::ensightWrite::read(const dictionary& dict)
     //
     // output fields
     //
-    dict.lookup("fields") >> selectFields_;
+    dict.readEntry("fields", selectFields_);
     selectFields_.uniq();
 
     return true;

src/functionObjects/utilities/removeRegisteredObject/removeRegisteredObject.C

@@ -74,7 +74,7 @@ bool Foam::functionObjects::removeRegisteredObject::read(const dictionary& dict)
 {
     regionFunctionObject::read(dict);
 
-    dict.lookup("objects") >> objectNames_;
+    dict.readEntry("objects", objectNames_);
 
     return true;
 }

src/functionObjects/utilities/runTimeControl/runTimeCondition/averageCondition/averageCondition.C

@@ -53,9 +53,9 @@ Foam::functionObjects::runTimeControls::averageCondition::averageCondition
 )
 :
     runTimeCondition(name, obr, dict, state),
-    functionObjectName_(dict.lookup("functionObject")),
+    functionObjectName_(dict.get<word>("functionObject")),
-    fieldNames_(dict.lookup("fields")),
+    fieldNames_(dict.get<wordList>("fields")),
-    tolerance_(readScalar(dict.lookup("tolerance"))),
+    tolerance_(dict.get<scalar>("tolerance")),
     window_(dict.lookupOrDefault<scalar>("window", -1)),
     totalTime_(fieldNames_.size(), obr_.time().deltaTValue()),
     resetOnRestart_(false)
@@ -71,7 +71,7 @@ Foam::functionObjects::runTimeControls::averageCondition::averageCondition
             if (dict.found(fieldName))
             {
                 const dictionary& valueDict = dict.subDict(fieldName);
-                totalTime_[fieldi] = readScalar(valueDict.lookup("totalTime"));
+                valueDict.readEntry("totalTime", totalTime_[fieldi]);
             }
         }
     }

src/functionObjects/utilities/runTimeControl/runTimeCondition/equationInitialResidualCondition/equationInitialResidualCondition.C

@@ -76,8 +76,8 @@ equationInitialResidualCondition
 )
 :
     runTimeCondition(name, obr, dict, state),
-    fieldNames_(dict.lookup("fields")),
+    fieldNames_(dict.get<wordList>("fields")),
-    value_(readScalar(dict.lookup("value"))),
+    value_(dict.get<scalar>("value")),
     timeStart_(dict.lookupOrDefault("timeStart", -GREAT)),
     mode_(operatingModeNames.lookup("mode", dict))
 {

src/functionObjects/utilities/runTimeControl/runTimeCondition/equationMaxIterCondition/equationMaxIterCondition.C

@@ -60,8 +60,8 @@ equationMaxIterCondition
 )
 :
     runTimeCondition(name, obr, dict, state),
-    fieldNames_(dict.lookup("fields")),
+    fieldNames_(dict.get<wordList>("fields")),
-    threshold_(readLabel(dict.lookup("threshold"))),
+    threshold_(dict.get<label>("threshold")),
     startIter_(dict.lookupOrDefault("startIter", 2))
 {
     if (!fieldNames_.size())

src/functionObjects/utilities/runTimeControl/runTimeCondition/minMaxCondition/minMaxCondition.C

@@ -83,10 +83,10 @@ Foam::functionObjects::runTimeControls::minMaxCondition::minMaxCondition
 )
 :
     runTimeCondition(name, obr, dict, state),
-    functionObjectName_(dict.lookup("functionObject")),
+    functionObjectName_(dict.get<word>("functionObject")),
     mode_(modeTypeNames_.lookup("mode", dict)),
-    fieldNames_(dict.lookup("fields")),
+    fieldNames_(dict.get<wordList>("fields")),
-    value_(readScalar(dict.lookup("value")))
+    value_(dict.get<scalar>("value"))
 {}
 
 

src/functionObjects/utilities/runTimeControl/runTimeCondition/minTimeStepCondition/minTimeStepCondition.C

@@ -59,7 +59,7 @@ minTimeStepCondition
 )
 :
     runTimeCondition(name, obr, dict, state),
-    minValue_(readScalar(dict.lookup("minValue")))
+    minValue_(dict.get<scalar>("minValue"))
 {}
 
 

src/functionObjects/utilities/runTimeControl/runTimeCondition/runTimeCondition/runTimeConditionNew.C

@@ -36,7 +36,7 @@ Foam::functionObjects::runTimeControls::runTimeCondition::New
     stateFunctionObject& state
 )
 {
-    const word conditionType(dict.lookup("type"));
+    const word conditionType(dict.get<word>("type"));
 
     Info<< "Selecting runTimeCondition " << conditionType << endl;
 
@@ -52,7 +52,8 @@ Foam::functionObjects::runTimeControls::runTimeCondition::New
             << exit(FatalError);
     }
 
-    return autoPtr<runTimeCondition>
+    return
+        autoPtr<runTimeCondition>
         (
             cstrIter()(conditionName, obr, dict, state)
         );

src/functionObjects/utilities/thermoCoupleProbes/thermoCoupleProbes.C

@@ -56,7 +56,7 @@ Foam::functionObjects::thermoCoupleProbes::thermoCoupleProbes
     probes(name, runTime, dict, loadFromFiles, false),
     ODESystem(),
     UName_(dict.lookupOrDefault<word>("U", "U")),
-    radiationFieldName_(dict.lookup("radiationField")),
+    radiationFieldName_(dict.get<word>("radiationField")),
     thermo_(mesh_.lookupObject<fluidThermo>(basicThermo::dictName)),
     odeSolver_(nullptr),
     Ttc_()
@@ -71,7 +71,7 @@ Foam::functionObjects::thermoCoupleProbes::thermoCoupleProbes
     dictionary probeDict;
     if (getDict(typeName, probeDict))
     {
-        probeDict.lookup("Tc") >> Ttc_;
+        probeDict.readEntry("Tc", Ttc_);
     }
     else
     {
@@ -198,10 +198,10 @@ bool Foam::functionObjects::thermoCoupleProbes::read(const dictionary& dict)
 {
     if (probes::read(dict))
     {
-        rho_ = readScalar(dict.lookup("rho"));
+        dict.readEntry("rho", rho_);
-        Cp_ = readScalar(dict.lookup("Cp"));
+        dict.readEntry("Cp", Cp_);
-        d_ = readScalar(dict.lookup("d"));
+        dict.readEntry("d", d_);
-        epsilon_ = readScalar(dict.lookup("epsilon"));
+        dict.readEntry("epsilon", epsilon_);
         return true;
     }
 

src/functionObjects/utilities/timeActivatedFileUpdate/timeActivatedFileUpdate.C

@@ -115,8 +115,8 @@ bool Foam::functionObjects::timeActivatedFileUpdate::read
 {
     functionObject::read(dict);
 
-    dict.lookup("fileToUpdate") >> fileToUpdate_;
+    dict.readEntry("fileToUpdate", fileToUpdate_);
-    dict.lookup("timeVsFile") >> timeVsFile_;
+    dict.readEntry("timeVsFile", timeVsFile_);
 
     lastIndex_ = -1;
     fileToUpdate_.expand();

src/functionObjects/utilities/vtkWrite/vtkWrite.C

@@ -87,7 +87,7 @@ bool Foam::functionObjects::vtkWrite::read(const dictionary& dict)
     writeOpts_.ascii
     (
         dict.found("format")
-     && (IOstream::formatEnum(dict.lookup("format")) == IOstream::ASCII)
+     && (IOstream::formatEnum(dict.get<word>("format")) == IOstream::ASCII)
     );
 
     // FUTURE?
@@ -115,7 +115,7 @@ bool Foam::functionObjects::vtkWrite::read(const dictionary& dict)
     //
     // output fields
     //
-    dict.lookup("fields") >> selectFields_;
+    dict.readEntry("fields", selectFields_);
     selectFields_.uniq();
 
     return true;

src/functionObjects/utilities/writeDictionary/writeDictionary.C

@@ -125,7 +125,7 @@ bool Foam::functionObjects::writeDictionary::read(const dictionary& dict)
 {
     regionFunctionObject::read(dict);
 
-    wordList dictNames(dict.lookup("dictNames"));
+    wordList dictNames(dict.get<wordList>("dictNames"));
     wordHashSet uniqueNames(dictNames);
     dictNames_ = uniqueNames.toc();
 
@@ -134,9 +134,9 @@ bool Foam::functionObjects::writeDictionary::read(const dictionary& dict)
     Info<< type() << " " << name() << ": monitoring dictionaries:" << nl;
     if (dictNames_.size())
     {
-        forAll(dictNames_, i)
+        for (const word & dictName : dictNames_)
         {
-            Info<< "    " << dictNames_[i] << endl;
+            Info<< "    " << dictName << endl;
         }
     }
     else

src/functionObjects/utilities/writeObjects/writeObjects.C

@@ -90,15 +90,15 @@ bool Foam::functionObjects::writeObjects::read(const dictionary& dict)
     if (dict.found("field"))
     {
         objectNames_.setSize(1);
-        dict.lookup("field") >> objectNames_[0];
+        dict.readEntry("field", objectNames_[0]);
     }
     else if (dict.found("fields"))
     {
-        dict.lookup("fields") >> objectNames_;
+        dict.readEntry("fields", objectNames_);
     }
     else
     {
-        dict.lookup("objects") >> objectNames_;
+        dict.readEntry("objects", objectNames_);
     }
 
     writeOption_ = writeOptionNames_.lookupOrDefault