diff --git a/src/postProcessing/foamCalcFunctions/field/components/components.C b/src/postProcessing/foamCalcFunctions/field/components/components.C
index 8b5c54e8bf..35254bbca2 100644
--- a/src/postProcessing/foamCalcFunctions/field/components/components.C
+++ b/src/postProcessing/foamCalcFunctions/field/components/components.C
@@ -57,8 +57,8 @@ Foam::calcTypes::components::~components()
 
 void Foam::calcTypes::components::init()
 {
-    Foam::argList::validArgs.append("components");
-    argList::validArgs.append("fieldName1 .. fieldNameN");
+    argList::validArgs.append("components");
+    argList::validArgs.append("fieldName");
 }
 
 
@@ -68,14 +68,7 @@ void Foam::calcTypes::components::preCalc
     const Time& runTime,
     const fvMesh& mesh
 )
-{
-    if (args.additionalArgs().size() < 2)
-    {
-        Info<< nl << "must specify one or more fields" << nl;
-        args.printUsage();
-        FatalError.exit();
-    }
-}
+{}
 
 
 void Foam::calcTypes::components::calc
@@ -85,49 +78,39 @@ void Foam::calcTypes::components::calc
     const fvMesh& mesh
 )
 {
-    const stringList& params = args.additionalArgs();
+    const word& fieldName = args.additionalArgs()[1];
 
-    for (label fieldi=1; fieldi<params.size(); fieldi++)
+    IOobject fieldHeader
+    (
+        fieldName,
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ
+    );
+
+    // Check field exists
+    if (fieldHeader.headerOk())
     {
-        const word fieldName(params[fieldi]);
+        bool processed = false;
 
-        IOobject fieldHeader
-        (
-            fieldName,
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ
-        );
+        writeComponentFields<vector>(fieldHeader, mesh, processed);
+        writeComponentFields<sphericalTensor>(fieldHeader, mesh, processed);
+        writeComponentFields<symmTensor>(fieldHeader, mesh, processed);
+        writeComponentFields<tensor>(fieldHeader, mesh, processed);
 
-        // Check field exists
-        if (fieldHeader.headerOk())
+        if (!processed)
         {
-            bool processed = false;
-
-            writeComponentFields<vector>(fieldHeader, mesh, processed);
-            writeComponentFields<sphericalTensor>
-            (
-                fieldHeader,
-                mesh,
-                processed
-            );
-            writeComponentFields<symmTensor>(fieldHeader, mesh, processed);
-            writeComponentFields<tensor>(fieldHeader, mesh, processed);
-
-            if (!processed)
-            {
-                FatalError
-                    << "Unable to process " << fieldName << nl
-                    << "No call to components for fields of type "
-                    << fieldHeader.headerClassName() << nl << nl
-                    << exit(FatalError);
-            }
-        }
-        else
-        {
-            Info<< "    No " << fieldName << endl;
+            FatalError
+                << "Unable to process " << fieldName << nl
+                << "No call to components for fields of type "
+                << fieldHeader.headerClassName() << nl << nl
+                << exit(FatalError);
         }
     }
+    else
+    {
+        Info<< "    No " << fieldName << endl;
+    }
 }
 
 
diff --git a/src/postProcessing/foamCalcFunctions/field/div/div.C b/src/postProcessing/foamCalcFunctions/field/div/div.C
index e99182f061..0b1492dc39 100644
--- a/src/postProcessing/foamCalcFunctions/field/div/div.C
+++ b/src/postProcessing/foamCalcFunctions/field/div/div.C
@@ -57,8 +57,8 @@ Foam::calcTypes::div::~div()
 
 void Foam::calcTypes::div::init()
 {
-    Foam::argList::validArgs.append("div");
-    argList::validArgs.append("fieldName1 .. fieldNameN");
+    argList::validArgs.append("div");
+    argList::validArgs.append("fieldName");
 }
 
 
@@ -68,14 +68,7 @@ void Foam::calcTypes::div::preCalc
     const Time& runTime,
     const fvMesh& mesh
 )
-{
-    if (args.additionalArgs().size() < 2)
-    {
-        Info<< nl << "must specify one or more fields" << nl;
-        args.printUsage();
-        FatalError.exit();
-    }
-}
+{}
 
 
 void Foam::calcTypes::div::calc
@@ -85,42 +78,37 @@ void Foam::calcTypes::div::calc
     const fvMesh& mesh
 )
 {
-    const stringList& params = args.additionalArgs();
+    const word& fieldName = args.additionalArgs()[1];
 
-    for (label fieldi=1; fieldi<params.size(); fieldi++)
+    IOobject fieldHeader
+    (
+        fieldName,
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ
+    );
+
+    // Check field exists
+    if (fieldHeader.headerOk())
     {
-        const word fieldName(params[fieldi]);
+        bool processed = false;
 
-        IOobject fieldHeader
-        (
-            fieldName,
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ
-        );
+        writeDivField<surfaceScalarField>(fieldHeader, mesh, processed);
+        writeDivField<volVectorField>(fieldHeader, mesh, processed);
 
-        // Check field exists
-        if (fieldHeader.headerOk())
+        if (!processed)
         {
-            bool processed = false;
-
-            writeDivField<surfaceScalarField>(fieldHeader, mesh, processed);
-            writeDivField<volVectorField>(fieldHeader, mesh, processed);
-
-            if (!processed)
-            {
-                 FatalError
-                     << "Unable to process " << fieldName << nl
-                     << "No call to div for fields of type "
-                     << fieldHeader.headerClassName() << nl << nl
-                     << exit(FatalError);
-            }
-        }
-        else
-        {
-            Info<< "    No " << fieldName << endl;
+                FatalError
+                    << "Unable to process " << fieldName << nl
+                    << "No call to div for fields of type "
+                    << fieldHeader.headerClassName() << nl << nl
+                    << exit(FatalError);
         }
     }
+    else
+    {
+        Info<< "    No " << fieldName << endl;
+    }
 }
 
 
diff --git a/src/postProcessing/foamCalcFunctions/field/interpolate/interpolate.C b/src/postProcessing/foamCalcFunctions/field/interpolate/interpolate.C
index d9126c6c03..aa319343ae 100644
--- a/src/postProcessing/foamCalcFunctions/field/interpolate/interpolate.C
+++ b/src/postProcessing/foamCalcFunctions/field/interpolate/interpolate.C
@@ -58,7 +58,7 @@ Foam::calcTypes::interpolate::~interpolate()
 void Foam::calcTypes::interpolate::init()
 {
     Foam::argList::validArgs.append("interpolate");
-    argList::validArgs.append("fieldName1 .. fieldNameN");
+    argList::validArgs.append("fieldName");
 }
 
 
@@ -68,14 +68,7 @@ void Foam::calcTypes::interpolate::preCalc
     const Time& runTime,
     const fvMesh& mesh
 )
-{
-    if (args.additionalArgs().size() < 2)
-    {
-        Info<< nl << "must specify one or more fields" << nl;
-        args.printUsage();
-        FatalError.exit();
-    }
-}
+{}
 
 
 void Foam::calcTypes::interpolate::calc
@@ -85,50 +78,40 @@ void Foam::calcTypes::interpolate::calc
     const fvMesh& mesh
 )
 {
-    const stringList& params = args.additionalArgs();
+    const word& fieldName = args.additionalArgs()[1];
 
-    for (label fieldi=1; fieldi<params.size(); fieldi++)
+    IOobject fieldHeader
+    (
+        fieldName,
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ
+    );
+
+    // Check field exists
+    if (fieldHeader.headerOk())
     {
-        const word fieldName(params[fieldi]);
+        bool processed = false;
 
-        IOobject fieldHeader
-        (
-            fieldName,
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ
-        );
+        writeInterpolateField<scalar>(fieldHeader, mesh, processed);
+        writeInterpolateField<vector>(fieldHeader, mesh, processed);
+        writeInterpolateField<sphericalTensor>(fieldHeader, mesh, processed);
+        writeInterpolateField<symmTensor>(fieldHeader, mesh, processed);
+        writeInterpolateField<tensor>(fieldHeader, mesh, processed);
 
-        // Check field exists
-        if (fieldHeader.headerOk())
+        if (!processed)
         {
-            bool processed = false;
-
-            writeInterpolateField<scalar>(fieldHeader, mesh, processed);
-            writeInterpolateField<vector>(fieldHeader, mesh, processed);
-            writeInterpolateField<sphericalTensor>
-            (
-                fieldHeader,
-                mesh,
-                processed
-            );
-            writeInterpolateField<symmTensor>(fieldHeader, mesh, processed);
-            writeInterpolateField<tensor>(fieldHeader, mesh, processed);
-
-            if (!processed)
-            {
-                 FatalError
-                     << "Unable to process " << fieldName << nl
-                     << "No call to interpolate for fields of type "
-                     << fieldHeader.headerClassName() << nl << nl
-                     << exit(FatalError);
-            }
-        }
-        else
-        {
-            Info<< "    No " << fieldName << endl;
+            FatalError
+                << "Unable to process " << fieldName << nl
+                << "No call to interpolate for fields of type "
+                << fieldHeader.headerClassName() << nl << nl
+                << exit(FatalError);
         }
     }
+    else
+    {
+        Info<< "    No " << fieldName << endl;
+    }
 }
 
 
diff --git a/src/postProcessing/foamCalcFunctions/field/mag/mag.C b/src/postProcessing/foamCalcFunctions/field/mag/mag.C
index 0f2a19eb05..cc86e8fa89 100644
--- a/src/postProcessing/foamCalcFunctions/field/mag/mag.C
+++ b/src/postProcessing/foamCalcFunctions/field/mag/mag.C
@@ -57,8 +57,8 @@ Foam::calcTypes::mag::~mag()
 
 void Foam::calcTypes::mag::init()
 {
-    Foam::argList::validArgs.append("mag");
-    argList::validArgs.append("fieldName1 .. fieldNameN");
+    argList::validArgs.append("mag");
+    argList::validArgs.append("fieldName");
 }
 
 
@@ -68,14 +68,7 @@ void Foam::calcTypes::mag::preCalc
     const Time& runTime,
     const fvMesh& mesh
 )
-{
-    if (args.additionalArgs().size() < 2)
-    {
-        Info<< nl << "must specify one or more fields" << nl;
-        args.printUsage();
-        FatalError.exit();
-    }
-}
+{}
 
 
 void Foam::calcTypes::mag::calc
@@ -85,45 +78,40 @@ void Foam::calcTypes::mag::calc
     const fvMesh& mesh
 )
 {
-    const stringList& params = args.additionalArgs();
+    const word& fieldName = args.additionalArgs()[1];
 
-    for (label fieldi=1; fieldi<params.size(); fieldi++)
+    IOobject fieldHeader
+    (
+        fieldName,
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ
+    );
+
+    // Check field exists
+    if (fieldHeader.headerOk())
     {
-        const word fieldName(params[fieldi]);
+        bool processed = false;
 
-        IOobject fieldHeader
-        (
-            fieldName,
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ
-        );
+        writeMagField<scalar>(fieldHeader, mesh, processed);
+        writeMagField<vector>(fieldHeader, mesh, processed);
+        writeMagField<sphericalTensor>(fieldHeader, mesh, processed);
+        writeMagField<symmTensor>(fieldHeader, mesh, processed);
+        writeMagField<tensor>(fieldHeader, mesh, processed);
 
-        // Check field exists
-        if (fieldHeader.headerOk())
+        if (!processed)
         {
-            bool processed = false;
-
-            writeMagField<scalar>(fieldHeader, mesh, processed);
-            writeMagField<vector>(fieldHeader, mesh, processed);
-            writeMagField<sphericalTensor>(fieldHeader, mesh, processed);
-            writeMagField<symmTensor>(fieldHeader, mesh, processed);
-            writeMagField<tensor>(fieldHeader, mesh, processed);
-
-            if (!processed)
-            {
-                 FatalError
-                     << "Unable to process " << fieldName << nl
-                     << "No call to mag for fields of type "
-                     << fieldHeader.headerClassName() << nl << nl
-                     << exit(FatalError);
-            }
-        }
-        else
-        {
-            Info<< "    No " << fieldName << endl;
+            FatalError
+                << "Unable to process " << fieldName << nl
+                << "No call to mag for fields of type "
+                << fieldHeader.headerClassName() << nl << nl
+                << exit(FatalError);
         }
     }
+    else
+    {
+        Info<< "    No " << fieldName << endl;
+    }
 }
 
 
diff --git a/src/postProcessing/foamCalcFunctions/field/magGrad/magGrad.C b/src/postProcessing/foamCalcFunctions/field/magGrad/magGrad.C
index 33b767c396..92722d917c 100644
--- a/src/postProcessing/foamCalcFunctions/field/magGrad/magGrad.C
+++ b/src/postProcessing/foamCalcFunctions/field/magGrad/magGrad.C
@@ -57,8 +57,8 @@ Foam::calcTypes::magGrad::~magGrad()
 
 void Foam::calcTypes::magGrad::init()
 {
-    Foam::argList::validArgs.append("magGrad");
-    argList::validArgs.append("fieldName1 .. fieldNameN");
+    argList::validArgs.append("magGrad");
+    argList::validArgs.append("fieldName");
 }
 
 
@@ -68,14 +68,7 @@ void Foam::calcTypes::magGrad::preCalc
     const Time& runTime,
     const fvMesh& mesh
 )
-{
-    if (args.additionalArgs().size() < 2)
-    {
-        Info<< nl << "must specify one or more fields" << nl;
-        args.printUsage();
-        FatalError.exit();
-    }
-}
+{}
 
 
 void Foam::calcTypes::magGrad::calc
@@ -85,42 +78,37 @@ void Foam::calcTypes::magGrad::calc
     const fvMesh& mesh
 )
 {
-    const stringList& params = args.additionalArgs();
+    const word& fieldName = args.additionalArgs()[1];
 
-    for (label fieldi=1; fieldi<params.size(); fieldi++)
+    IOobject fieldHeader
+    (
+        fieldName,
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ
+    );
+
+    // Check field exists
+    if (fieldHeader.headerOk())
     {
-        const word fieldName(params[fieldi]);
+        bool processed = false;
 
-        IOobject fieldHeader
-        (
-            fieldName,
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ
-        );
+        writeMagGradField<scalar>(fieldHeader, mesh, processed);
+        writeMagGradField<vector>(fieldHeader, mesh, processed);
 
-        // Check field exists
-        if (fieldHeader.headerOk())
+        if (!processed)
         {
-            bool processed = false;
-
-            writeMagGradField<scalar>(fieldHeader, mesh, processed);
-            writeMagGradField<vector>(fieldHeader, mesh, processed);
-
-            if (!processed)
-            {
-                 FatalError
-                     << "Unable to process " << fieldName << nl
-                     << "No call to magGrad for fields of type "
-                     << fieldHeader.headerClassName() << nl << nl
-                     << exit(FatalError);
-            }
-        }
-        else
-        {
-            Info<< "    No " << fieldName << endl;
+            FatalError
+                << "Unable to process " << fieldName << nl
+                << "No call to magGrad for fields of type "
+                << fieldHeader.headerClassName() << nl << nl
+                << exit(FatalError);
         }
     }
+    else
+    {
+        Info<< "    No " << fieldName << endl;
+    }
 }
 
 
diff --git a/src/postProcessing/foamCalcFunctions/field/magSqr/magSqr.C b/src/postProcessing/foamCalcFunctions/field/magSqr/magSqr.C
index 872fbf1f80..5bce397e07 100644
--- a/src/postProcessing/foamCalcFunctions/field/magSqr/magSqr.C
+++ b/src/postProcessing/foamCalcFunctions/field/magSqr/magSqr.C
@@ -58,7 +58,7 @@ Foam::calcTypes::magSqr::~magSqr()
 void Foam::calcTypes::magSqr::init()
 {
     Foam::argList::validArgs.append("magSqr");
-    argList::validArgs.append("fieldName1 .. fieldNameN");
+    argList::validArgs.append("fieldName");
 }
 
 
@@ -68,14 +68,7 @@ void Foam::calcTypes::magSqr::preCalc
     const Time& runTime,
     const fvMesh& mesh
 )
-{
-    if (args.additionalArgs().size() < 2)
-    {
-        Info<< nl << "must specify one or more fields" << nl;
-        args.printUsage();
-        FatalError.exit();
-    }
-}
+{}
 
 
 void Foam::calcTypes::magSqr::calc
@@ -85,47 +78,43 @@ void Foam::calcTypes::magSqr::calc
     const fvMesh& mesh
 )
 {
-    const stringList& params = args.additionalArgs();
+    const word& fieldName = args.additionalArgs()[1];
 
-    for (label fieldi=1; fieldi<params.size(); fieldi++)
+    IOobject fieldHeader
+    (
+        fieldName,
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ
+    );
+
+    // Check field exists
+    if (fieldHeader.headerOk())
     {
-        const word fieldName(params[fieldi]);
+        bool processed = false;
 
-        IOobject fieldHeader
-        (
-            fieldName,
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ
-        );
+        writeMagSqrField<scalar>(fieldHeader, mesh, processed);
+        writeMagSqrField<vector>(fieldHeader, mesh, processed);
+        writeMagSqrField<sphericalTensor>(fieldHeader, mesh, processed);
+        writeMagSqrField<symmTensor>(fieldHeader, mesh, processed);
+        writeMagSqrField<tensor>(fieldHeader, mesh, processed);
 
-        // Check field exists
-        if (fieldHeader.headerOk())
+        if (!processed)
         {
-            bool processed = false;
-
-            writeMagSqrField<scalar>(fieldHeader, mesh, processed);
-            writeMagSqrField<vector>(fieldHeader, mesh, processed);
-            writeMagSqrField<sphericalTensor>(fieldHeader, mesh, processed);
-            writeMagSqrField<symmTensor>(fieldHeader, mesh, processed);
-            writeMagSqrField<tensor>(fieldHeader, mesh, processed);
-
-            if (!processed)
-            {
-                 FatalError
-                     << "Unable to process " << fieldName << nl
-                     << "No call to magSqr for fields of type "
-                     << fieldHeader.headerClassName() << nl << nl
-                     << exit(FatalError);
-            }
-        }
-        else
-        {
-            Info<< "    No " << fieldName << endl;
+            FatalError
+                << "Unable to process " << fieldName << nl
+                << "No call to magSqr for fields of type "
+                << fieldHeader.headerClassName() << nl << nl
+               << exit(FatalError);
         }
     }
+    else
+    {
+        Info<< "    No " << fieldName << endl;
+    }
 }
 
 
+
 // ************************************************************************* //
 
diff --git a/src/postProcessing/foamCalcFunctions/field/randomise/randomise.C b/src/postProcessing/foamCalcFunctions/field/randomise/randomise.C
index f8f7ef68ec..7c218e1b77 100644
--- a/src/postProcessing/foamCalcFunctions/field/randomise/randomise.C
+++ b/src/postProcessing/foamCalcFunctions/field/randomise/randomise.C
@@ -59,7 +59,7 @@ void Foam::calcTypes::randomise::init()
 {
     argList::validArgs.append("randomise");
     argList::validArgs.append("perturbation");
-    argList::validArgs.append("fieldName1 .. fieldNameN");
+    argList::validArgs.append("fieldName");
 }
 
 
@@ -69,17 +69,7 @@ void Foam::calcTypes::randomise::preCalc
     const Time& runTime,
     const fvMesh& mesh
 )
-{
-    if (args.additionalArgs().size() < 3)
-    {
-        Info<< nl
-            << "must specify perturbation magnitude and one"
-            << "or more fields"
-            << nl;
-        args.printUsage();
-        FatalError.exit();
-    }
-}
+{}
 
 
 void Foam::calcTypes::randomise::calc
@@ -91,73 +81,69 @@ void Foam::calcTypes::randomise::calc
 {
     const stringList& params = args.additionalArgs();
     const scalar pertMag = readScalar(IStringStream(params[1])());
+    const word& fieldName = params[2];
 
     Random rand(1234567);
 
-    for (label fieldi=2; fieldi<params.size(); fieldi++)
-    {
-        const word fieldName(params[fieldi]);
+    IOobject fieldHeader
+    (
+        fieldName,
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ
+    );
 
-        IOobject fieldHeader
+    // Check field exists
+    if (fieldHeader.headerOk())
+    {
+        bool processed = false;
+
+        writeRandomField<vector>
         (
-            fieldName,
-            runTime.timeName(),
+            fieldHeader,
+            pertMag,
+            rand,
             mesh,
-            IOobject::MUST_READ
+            processed
+        );
+        writeRandomField<sphericalTensor>
+        (
+            fieldHeader,
+            pertMag,
+            rand,
+            mesh,
+            processed
+        );
+        writeRandomField<symmTensor>
+        (
+            fieldHeader,
+            pertMag,
+            rand,
+            mesh,
+            processed
+        );
+        writeRandomField<tensor>
+        (
+            fieldHeader,
+            pertMag,
+            rand,
+            mesh,
+            processed
         );
 
-        // Check field exists
-        if (fieldHeader.headerOk())
+        if (!processed)
         {
-            bool processed = false;
-
-            writeRandomField<vector>
-            (
-                fieldHeader,
-                pertMag,
-                rand,
-                mesh,
-                processed
-            );
-            writeRandomField<sphericalTensor>
-            (
-                fieldHeader,
-                pertMag,
-                rand,
-                mesh,
-                processed
-            );
-            writeRandomField<symmTensor>
-            (
-                fieldHeader,
-                pertMag,
-                rand,
-                mesh,
-                processed
-            );
-            writeRandomField<tensor>
-            (
-                fieldHeader,
-                pertMag,
-                rand,
-                mesh,
-                processed
-            );
-
-            if (!processed)
-            {
-                FatalError
-                    << "Unable to process " << fieldName << nl
-                    << "No call to randomise for fields of type "
-                    << fieldHeader.headerClassName() << nl << nl
-                    << exit(FatalError);
-            }
-        }
-        else
-        {
-            Info<< "    No " << fieldName << endl;
+            FatalError
+                << "Unable to process " << fieldName << nl
+                << "No call to randomise for fields of type "
+                << fieldHeader.headerClassName() << nl << nl
+                << exit(FatalError);
         }
     }
+    else
+    {
+        Info<< "    No " << fieldName << endl;
+    }
 }