STYLE: Code clean-up

src/functionObjects/field/pressure/pressure.C

@@ -228,13 +228,6 @@ Foam::functionObjects::pressure::pressure
     rhoInfInitialised_(false)
 {
     read(dict);
-
-    dimensionSet pDims(dimPressure);
-
-    if (calcCoeff_)
-    {
-        pDims /= dimPressure;
-    }
 }
 
 

src/functionObjects/field/wallShearStress/wallShearStress.C

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

src/genericPatchFields/genericPointPatchField/genericPointPatchField.C

@@ -308,12 +308,7 @@ Foam::genericPointPatchField<Type>::genericPointPatchField
     actualTypeName_(ptf.actualTypeName_),
     dict_(ptf.dict_)
 {
-    forAllConstIter
+    forAllConstIters(ptf.scalarFields_, iter)
-    (
-        HashPtrTable<scalarField>,
-        ptf.scalarFields_,
-        iter
-    )
     {
         scalarFields_.insert
         (
@@ -322,12 +317,7 @@ Foam::genericPointPatchField<Type>::genericPointPatchField
         );
     }
 
-    forAllConstIter
+    forAllConstIters(ptf.vectorFields_, iter)
-    (
-        HashPtrTable<vectorField>,
-        ptf.vectorFields_,
-        iter
-    )
     {
         vectorFields_.insert
         (
@@ -336,12 +326,7 @@ Foam::genericPointPatchField<Type>::genericPointPatchField
         );
     }
 
-    forAllConstIter
+    forAllConstIters(ptf.sphericalTensorFields_, iter)
-    (
-        HashPtrTable<sphericalTensorField>,
-        ptf.sphericalTensorFields_,
-        iter
-    )
     {
         sphericalTensorFields_.insert
         (
@@ -350,12 +335,7 @@ Foam::genericPointPatchField<Type>::genericPointPatchField
         );
     }
 
-    forAllConstIter
+    forAllConstIters(ptf.symmTensorFields_, iter)
-    (
-        HashPtrTable<symmTensorField>,
-        ptf.symmTensorFields_,
-        iter
-    )
     {
         symmTensorFields_.insert
         (
@@ -364,12 +344,7 @@ Foam::genericPointPatchField<Type>::genericPointPatchField
         );
     }
 
-    forAllConstIter
+    forAllConstIters(ptf.tensorFields_, iter)
-    (
-        HashPtrTable<tensorField>,
-        ptf.tensorFields_,
-        iter
-    )
     {
         tensorFields_.insert
         (
@@ -406,52 +381,27 @@ void Foam::genericPointPatchField<Type>::autoMap
     const pointPatchFieldMapper& m
 )
 {
-    forAllIter
+    forAllIters(scalarFields_, iter)
-    (
-        HashPtrTable<scalarField>,
-        scalarFields_,
-        iter
-    )
     {
         iter()->autoMap(m);
     }
 
-    forAllIter
+    forAllIters(vectorFields_, iter)
-    (
-        HashPtrTable<vectorField>,
-        vectorFields_,
-        iter
-    )
     {
         iter()->autoMap(m);
     }
 
-    forAllIter
+    forAllIters(sphericalTensorFields_, iter)
-    (
-        HashPtrTable<sphericalTensorField>,
-        sphericalTensorFields_,
-        iter
-    )
     {
         iter()->autoMap(m);
     }
 
-    forAllIter
+    forAllIters(symmTensorFields_, iter)
-    (
-        HashPtrTable<symmTensorField>,
-        symmTensorFields_,
-        iter
-    )
     {
         iter()->autoMap(m);
     }
 
-    forAllIter
+    forAllIters(tensorFields_, iter)
-    (
-        HashPtrTable<tensorField>,
-        tensorFields_,
-        iter
-    )
     {
         iter()->autoMap(m);
     }
@@ -468,76 +418,51 @@ void Foam::genericPointPatchField<Type>::rmap
     const genericPointPatchField<Type>& dptf =
         refCast<const genericPointPatchField<Type>>(ptf);
 
-    forAllIter
+    forAllIters(scalarFields_, iter)
-    (
-        HashPtrTable<scalarField>,
-        scalarFields_,
-        iter
-    )
     {
         HashPtrTable<scalarField>::const_iterator dptfIter =
             dptf.scalarFields_.find(iter.key());
 
-        if (dptfIter != scalarFields_.end())
+        if (dptfIter.found())
         {
             iter()->rmap(*dptfIter(), addr);
         }
     }
 
-    forAllIter
+    forAllIters(vectorFields_, iter)
-    (
-        HashPtrTable<vectorField>,
-        vectorFields_,
-        iter
-    )
     {
         HashPtrTable<vectorField>::const_iterator dptfIter =
             dptf.vectorFields_.find(iter.key());
 
-        if (dptfIter != vectorFields_.end())
+        if (dptfIter.found())
         {
             iter()->rmap(*dptfIter(), addr);
         }
     }
 
-    forAllIter
+    forAllIters(sphericalTensorFields_, iter)
-    (
-        HashPtrTable<sphericalTensorField>,
-        sphericalTensorFields_,
-        iter
-    )
     {
         HashPtrTable<sphericalTensorField>::const_iterator dptfIter =
             dptf.sphericalTensorFields_.find(iter.key());
 
-        if (dptfIter != sphericalTensorFields_.end())
+        if (dptfIter.found())
         {
             iter()->rmap(*dptfIter(), addr);
         }
     }
 
-    forAllIter
+    forAllIters(symmTensorFields_, iter)
-    (
-        HashPtrTable<symmTensorField>,
-        symmTensorFields_,
-        iter
-    )
     {
         HashPtrTable<symmTensorField>::const_iterator dptfIter =
             dptf.symmTensorFields_.find(iter.key());
 
-        if (dptfIter != symmTensorFields_.end())
+        if (dptfIter.found())
         {
             iter()->rmap(*dptfIter(), addr);
         }
     }
 
-    forAllIter
+    forAllIters(tensorFields_, iter)
-    (
-        HashPtrTable<tensorField>,
-        tensorFields_,
-        iter
-    )
     {
         HashPtrTable<tensorField>::const_iterator dptfIter =
             dptf.tensorFields_.find(iter.key());
@@ -578,28 +503,23 @@ void Foam::genericPointPatchField<Type>::write(Ostream& os) const
             {
                 if (scalarFields_.found(key))
                 {
-                    scalarFields_.find(key)()
+                    scalarFields_.find(key)()->writeEntry(key, os);
-                        ->writeEntry(key, os);
                 }
                 else if (vectorFields_.found(key))
                 {
-                    vectorFields_.find(key)()
+                    vectorFields_.find(key)()->writeEntry(key, os);
-                        ->writeEntry(key, os);
                 }
                 else if (sphericalTensorFields_.found(key))
                 {
-                    sphericalTensorFields_.find(key)()
+                    sphericalTensorFields_.find(key)()->writeEntry(key, os);
-                        ->writeEntry(key, os);
                 }
                 else if (symmTensorFields_.found(key))
                 {
-                    symmTensorFields_.find(key)()
+                    symmTensorFields_.find(key)()->writeEntry(key, os);
-                        ->writeEntry(key, os);
                 }
                 else if (tensorFields_.found(key))
                 {
-                    tensorFields_.find(key)()
+                    tensorFields_.find(key)()->writeEntry(key, os);
-                        ->writeEntry(key, os);
                 }
             }
             else

src/lagrangian/distributionModels/general/general.C

@@ -151,6 +151,7 @@ Foam::distributionModels::general::general(const general& p)
 :
     distributionModel(p),
     xy_(p.xy_),
+    meanValue_(p.meanValue_),
     integral_(p.integral_)
 {}
 

src/lagrangian/intermediate/submodels/CloudFunctionObjects/ParticleCollector/ParticleCollector.C

@@ -626,6 +626,7 @@ Foam::ParticleCollector<CloudType>::ParticleCollector
     nSector_(pc.nSector_),
     radius_(pc.radius_),
     coordSys_(pc.coordSys_),
+    area_(pc.area_),
     normal_(pc.normal_),
     negateParcelsOppositeNormal_(pc.negateParcelsOppositeNormal_),
     surfaceFormat_(pc.surfaceFormat_),

src/randomProcesses/windowModels/windowModel/windowModelNew.C

@@ -1,4 +1,4 @@
-#/*---------------------------------------------------------------------------*\
+/*---------------------------------------------------------------------------*\
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |