STYLE: electricPotential: simplify read function

- change 'fieldName' to 'Vname' for better clarity

src/functionObjects/solvers/electricPotential/electricPotential.C

@@ -201,11 +201,11 @@ Foam::functionObjects::electricPotential::electricPotential
             )
         )
     ),
-    fieldName_
+    Vname_
     (
         dict.getOrDefault<word>
         (
-            "field",
+            "V",
             IOobject::scopedName(typeName, "V")
         )
     ),
@@ -216,7 +216,7 @@ Foam::functionObjects::electricPotential::electricPotential
 
     // Force creation of transported field so any BCs using it can
     // look it up
-    volScalarField& eV = getOrReadField(fieldName_);
+    volScalarField& eV = getOrReadField(Vname_);
     eV.correctBoundaryConditions();
 }
 
@@ -225,88 +225,88 @@ Foam::functionObjects::electricPotential::electricPotential
 
 bool Foam::functionObjects::electricPotential::read(const dictionary& dict)
 {
-    if (fvMeshFunctionObject::read(dict))
+    if (!fvMeshFunctionObject::read(dict))
     {
-        Log << type() << " read: " << name() << endl;
+        return false;
+    }
 
-        dict.readIfPresent("sigma", sigma_);
+    Log << type() << " read: " << name() << endl;
-        dict.readIfPresent("epsilonr", epsilonr_);
-        dict.readIfPresent("nCorr", nCorr_);
-        dict.readIfPresent("writeDerivedFields", writeDerivedFields_);
 
-        // If flow is multiphase
+    dict.readIfPresent("sigma", sigma_);
-        if (!phasesDict_.empty())
+    dict.readIfPresent("epsilonr", epsilonr_);
+    dict.readIfPresent("nCorr", nCorr_);
+    dict.readIfPresent("writeDerivedFields", writeDerivedFields_);
+
+    // If flow is multiphase
+    if (!phasesDict_.empty())
+    {
+        phaseNames_.setSize(phasesDict_.size());
+        phases_.setSize(phasesDict_.size());
+        sigmas_.setSize(phasesDict_.size());
+
+        if (writeDerivedFields_)
         {
-            phaseNames_.setSize(phasesDict_.size());
+            epsilonrs_.setSize(phasesDict_.size());
-            phases_.setSize(phasesDict_.size());
+        }
-            sigmas_.setSize(phasesDict_.size());
+
+        label phasei = 0;
+        for (const entry& dEntry : phasesDict_)
+        {
+            const word& key = dEntry.keyword();
+
+            if (!dEntry.isDict())
+            {
+                FatalIOErrorInFunction(phasesDict_)
+                    << "Entry " << key << " is not a dictionary" << nl
+                    << exit(FatalIOError);
+            }
+
+            const dictionary& subDict = dEntry.dict();
+
+            phaseNames_[phasei] = key;
+
+            sigmas_.set
+            (
+                phasei,
+                new dimensionedScalar
+                (
+                    sqr(dimCurrent)*pow3(dimTime)/(dimMass*pow3(dimLength)),
+                    subDict.getCheck<scalar>
+                    (
+                        "sigma",
+                        scalarMinMax::ge(SMALL)
+                    )
+                )
+            );
 
             if (writeDerivedFields_)
             {
-                epsilonrs_.setSize(phasesDict_.size());
+                epsilonrs_.set
-            }
-
-            label phasei = 0;
-            for (const entry& dEntry : phasesDict_)
-            {
-                const word& key = dEntry.keyword();
-
-                if (!dEntry.isDict())
-                {
-                    FatalIOErrorInFunction(phasesDict_)
-                        << "Entry " << key << " is not a dictionary" << nl
-                        << exit(FatalIOError);
-                }
-
-                const dictionary& subDict = dEntry.dict();
-
-                phaseNames_[phasei] = key;
-
-                sigmas_.set
                 (
                     phasei,
                     new dimensionedScalar
                     (
-                        sqr(dimCurrent)*pow3(dimTime)/(dimMass*pow3(dimLength)),
+                        dimless,
                         subDict.getCheck<scalar>
                         (
-                            "sigma",
+                            "epsilonr",
                             scalarMinMax::ge(SMALL)
                         )
                     )
                 );
-
-                if (writeDerivedFields_)
-                {
-                    epsilonrs_.set
-                    (
-                        phasei,
-                        new dimensionedScalar
-                        (
-                            dimless,
-                            subDict.getCheck<scalar>
-                            (
-                                "epsilonr",
-                                scalarMinMax::ge(SMALL)
-                            )
-                        )
-                    );
-                }
-
-                ++phasei;
             }
 
-            forAll(phaseNames_, i)
+            ++phasei;
-            {
-                phases_.set
-                (
-                    i,
-                    mesh_.getObjectPtr<volScalarField>(phaseNames_[i])
-                );
-            }
         }
 
-        return true;
+        forAll(phaseNames_, i)
+        {
+            phases_.set
+            (
+                i,
+                mesh_.getObjectPtr<volScalarField>(phaseNames_[i])
+            );
+        }
     }
 
     return false;
@@ -318,11 +318,11 @@ bool Foam::functionObjects::electricPotential::execute()
     Log << type() << " execute: " << name() << endl;
 
     tmp<volScalarField> tsigma = this->sigma();
-    const volScalarField& sigma = tsigma();
+    const auto& sigma = tsigma();
 
-    volScalarField& eV = getOrReadField(fieldName_);
+    volScalarField& eV = getOrReadField(Vname_);
 
-    for (label i = 1; i <= nCorr_; ++i)
+    for (int i = 1; i <= nCorr_; ++i)
     {
         fvScalarMatrix eVEqn
         (
@@ -343,10 +343,10 @@ bool Foam::functionObjects::electricPotential::execute()
 bool Foam::functionObjects::electricPotential::write()
 {
     Log << type() << " write: " << name() << nl
-        << tab << fieldName_
+        << tab << Vname_
         << endl;
 
-    volScalarField& eV = getOrReadField(fieldName_);
+    volScalarField& eV = getOrReadField(Vname_);
 
     if (writeDerivedFields_)
     {

src/functionObjects/solvers/electricPotential/electricPotential.H

@@ -118,9 +118,9 @@ Usage
             }
 
         // Optional entries
-        nCorr                 <label>;
+        nCorr                 <int>;
         writeDerivedFields    <bool>;
-        fieldName             <word>;
+        V                     <word>;
 
         // Inherited entries
         ...
@@ -134,9 +134,9 @@ Usage
       libs      | Library name: solverFunctionObjects | word | yes  | -
       sigma     | Isotropic electrical conductivity of phase | scalar | yes | -
       epsilonr  | Isotropic relative permittivity of phase   | scalar | no  | -
-      nCorr     | Number of corrector iterations     | label | no   | 1
+      nCorr     | Number of corrector iterations      | int  | no   | 1
       writeDerivedFields | Flag to write extra fields | bool | no   | false
-      fieldName | Name of operand field   | word | no | electricPotential:V
+      V    | Name of electric potential field | word | no | electricPotential:V
     \endtable
 
     The inherited entries are elaborated in:
@@ -199,11 +199,11 @@ class electricPotential
         //- Isotropic relative permittivity of a single phase
         dimensionedScalar epsilonr_;
 
-        //- Name of the operand field
+        //- Name of electric potential field
-        word fieldName_;
+        word Vname_;
 
         //- Number of corrector iterations
-        label nCorr_;
+        int nCorr_;
 
         //- Flag to write derived fields of
         //- electric field, current density and free-charge density