functionObjects: Removed the redundant "viable" member function

Construction failure and recovery is not handled with exceptions in functionObjectList

applications/utilities/postProcessing/dataConversion/foamToVTK/foamToVTK/writeVTK/writeVTK.C

@@ -54,23 +54,16 @@ Foam::functionObjects::writeVTK::writeVTK
     obr_(obr),
     objectNames_()
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 }
 
 
-bool Foam::functionObjects::writeVTK::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::writeVTK::~writeVTK()

applications/utilities/postProcessing/dataConversion/foamToVTK/foamToVTK/writeVTK/writeVTK.H

@@ -131,16 +131,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~writeVTK();

etc/codeTemplates/dynamicCode/functionObjectTemplate.C

@@ -76,18 +76,6 @@ ${typeName}FunctionObject::${typeName}FunctionObject
 }
 
 
-bool ${typeName}FunctionObject::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool
-)
-{
-    return true;
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 ${typeName}FunctionObject::~${typeName}FunctionObject()

etc/codeTemplates/dynamicCode/functionObjectTemplate.H

@@ -102,16 +102,6 @@ public:
             const bool loadFromFilesUnused = false
         );
 
-        //- Construct for given objectRegistry and dictionary.
-        //  Allow the possibility to load fields from files
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry& unused,
-            const dictionary&,
-            const bool loadFromFilesUnused = false
-        );
-
 
     //- Destructor
     virtual ~${typeName}FunctionObject();

etc/codeTemplates/functionObject/FUNCTIONOBJECT.C

@@ -30,7 +30,7 @@ License
 
 namespace Foam
 {
-defineTypeNameAndDebug(FUNCTIONOBJECT, 0);
+    defineTypeNameAndDebug(FUNCTIONOBJECT, 0);
 }
 
 
@@ -83,8 +83,7 @@ void Foam::FUNCTIONOBJECT::timeSet()
 
 
 void Foam::FUNCTIONOBJECT::write()
-{
+{}
-}
 
 
 // ************************************************************************* //

etc/codeTemplates/functionObject/FUNCTIONOBJECT.H

@@ -134,7 +134,7 @@ public:
     // Member Functions
 
         //- Return name of the FUNCTIONOBJECT
-        virtual const word& name() const
+        const word& name() const
         {
             return name_;
         }

src/OpenFOAM/db/functionObjects/IOOutputFilter/IOOutputFilter.C

@@ -66,32 +66,6 @@ Foam::IOOutputFilter<OutputFilter>::IOOutputFilter
 {}
 
 
-template<class OutputFilter>
-bool Foam::IOOutputFilter<OutputFilter>::viable
-(
-    const word& outputFilterName,
-    const objectRegistry& obr,
-    const word& dictName,
-    const IOobject::readOption rOpt,
-    const bool readFromFiles
-)
-{
-    IOdictionary dict
-    (
-        IOobject
-        (
-            dictName,
-            obr.time().system(),
-            obr,
-            rOpt,
-            IOobject::NO_WRITE
-        )
-    );
-
-    return OutputFilter::viable(outputFilterName, obr, dict, readFromFiles);
-}
-
-
 template<class OutputFilter>
 Foam::IOOutputFilter<OutputFilter>::IOOutputFilter
 (

src/OpenFOAM/db/functionObjects/IOOutputFilter/IOOutputFilter.H

@@ -94,16 +94,6 @@ public:
             const bool loadFromFile = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        static bool viable
-        (
-            const word& outputFilterName,
-            const objectRegistry&,
-            const word& dictName = OutputFilter::typeName() + "Dict",
-            const IOobject::readOption rOpt = IOobject::MUST_READ_IF_MODIFIED,
-            const bool loadFromFiles = false
-        );
-
         //- Construct for given objectRegistry and dictionary
         //  Dictionary read from full path.
         //  Allow the possibility to load fields from files

src/OpenFOAM/db/functionObjects/OutputFilterFunctionObject/OutputFilterFunctionObject.C

@@ -56,49 +56,27 @@ bool Foam::OutputFilterFunctionObject<OutputFilter>::allocateFilter()
 {
     if (dictName_.size())
     {
-        if
+        ptr_.reset
         (
-            IOOutputFilter<OutputFilter>::viable
+            new IOOutputFilter<OutputFilter>
             (
                 name(),
                 time_.lookupObject<objectRegistry>(regionName_),
                 dictName_
             )
-        )
+        );
-        {
-            ptr_.reset
-            (
-                new IOOutputFilter<OutputFilter>
-                (
-                    name(),
-                    time_.lookupObject<objectRegistry>(regionName_),
-                    dictName_
-                )
-            );
-        }
     }
     else
     {
-        if
+        ptr_.reset
         (
-            OutputFilter::viable
+            new OutputFilter
             (
                 name(),
                 time_.lookupObject<objectRegistry>(regionName_),
                 dict_
             )
-        )
+        );
-        {
-            ptr_.reset
-            (
-                new OutputFilter
-                (
-                    name(),
-                    time_.lookupObject<objectRegistry>(regionName_),
-                    dict_
-                )
-            );
-        }
     }
 
     return ptr_.valid();

src/postProcessing/functionObjects/field/div/div.C

@@ -92,23 +92,16 @@ Foam::functionObjects::div::div
     fieldName_("undefined-fieldName"),
     resultName_("undefined-resultName")
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 }
 
 
-bool Foam::functionObjects::div::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::div::~div()

src/postProcessing/functionObjects/field/div/div.H

@@ -125,16 +125,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~div();

src/postProcessing/functionObjects/field/fieldAverage/fieldAverage/fieldAverage.C

@@ -277,23 +277,16 @@ Foam::functionObjects::fieldAverage::fieldAverage
     totalTime_(),
     periodIndex_(1)
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 }
 
 
-bool Foam::functionObjects::fieldAverage::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::fieldAverage::~fieldAverage()

src/postProcessing/functionObjects/field/fieldAverage/fieldAverage/fieldAverage.H

@@ -301,16 +301,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~fieldAverage();

src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/fieldCoordinateSystemTransform.C

@@ -53,6 +53,12 @@ fieldCoordinateSystemTransform
     fieldSet_(),
     coordSys_(obr, dict)
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 
     Info<< type() << " " << name_ << ":" << nl
@@ -61,19 +67,6 @@ fieldCoordinateSystemTransform
 }
 
 
-bool Foam::functionObjects::fieldCoordinateSystemTransform::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::fieldCoordinateSystemTransform::

src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/fieldCoordinateSystemTransform.H

@@ -155,16 +155,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~fieldCoordinateSystemTransform();

src/postProcessing/functionObjects/field/fieldMinMax/fieldMinMax.C

@@ -68,23 +68,16 @@ Foam::functionObjects::fieldMinMax::fieldMinMax
     mode_(mdMag),
     fieldSet_()
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 }
 
 
-bool Foam::functionObjects::fieldMinMax::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::fieldMinMax::~fieldMinMax()

src/postProcessing/functionObjects/field/fieldMinMax/fieldMinMax.H

@@ -181,16 +181,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~fieldMinMax();

src/postProcessing/functionObjects/field/fieldValues/cellSource/cellSource.C

@@ -218,23 +218,16 @@ Foam::functionObjects::fieldValues::cellSource::cellSource
     weightFieldName_("none"),
     writeVolume_(dict.lookupOrDefault("writeVolume", false))
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 }
 
 
-bool Foam::functionObjects::fieldValues::cellSource::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::fieldValues::cellSource::~cellSource()

src/postProcessing/functionObjects/field/fieldValues/cellSource/cellSource.H

@@ -250,16 +250,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~cellSource();

src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.C

@@ -660,23 +660,16 @@ Foam::functionObjects::fieldValues::faceSource::faceSource
     facePatchId_(),
     faceSign_()
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 }
 
 
-bool Foam::functionObjects::fieldValues::faceSource::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::fieldValues::faceSource::~faceSource()

src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.H

@@ -350,16 +350,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~faceSource();

src/postProcessing/functionObjects/field/fieldValues/fieldValueDelta/fieldValueDelta.C

@@ -118,23 +118,16 @@ Foam::functionObjects::fieldValues::fieldValueDelta::fieldValueDelta
     source1Ptr_(NULL),
     source2Ptr_(NULL)
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 }
 
 
-bool Foam::functionObjects::fieldValues::fieldValueDelta::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::fieldValues::fieldValueDelta::~fieldValueDelta()

src/postProcessing/functionObjects/field/fieldValues/fieldValueDelta/fieldValueDelta.H

@@ -174,16 +174,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~fieldValueDelta();

src/postProcessing/functionObjects/field/grad/grad.C

@@ -54,23 +54,16 @@ Foam::functionObjects::grad::grad
     fieldName_("undefined-fieldName"),
     resultName_("undefined-resultName")
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 }
 
 
-bool Foam::functionObjects::grad::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::grad::~grad()

src/postProcessing/functionObjects/field/grad/grad.H

@@ -128,16 +128,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~grad();

src/postProcessing/functionObjects/field/histogram/histogram.C

@@ -77,23 +77,16 @@ Foam::functionObjects::histogram::histogram
     functionObjectFile(obr, typeName),
     name_(name)
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 }
 
 
-bool Foam::functionObjects::histogram::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::histogram::~histogram()

src/postProcessing/functionObjects/field/histogram/histogram.H

@@ -149,16 +149,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     // Destructor
 

src/postProcessing/functionObjects/field/mag/mag.C

@@ -54,23 +54,16 @@ Foam::functionObjects::mag::mag
     fieldName_("undefined-fieldName"),
     resultName_("undefined-resultName")
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 }
 
 
-bool Foam::functionObjects::mag::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::mag::~mag()

src/postProcessing/functionObjects/field/mag/mag.H

@@ -122,16 +122,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~mag();

src/postProcessing/functionObjects/field/nearWallFields/nearWallFields.C

@@ -233,23 +233,16 @@ Foam::functionObjects::nearWallFields::nearWallFields
     obr_(obr),
     fieldSet_()
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 }
 
 
-bool Foam::functionObjects::nearWallFields::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::nearWallFields::~nearWallFields()

src/postProcessing/functionObjects/field/nearWallFields/nearWallFields.H

@@ -196,16 +196,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~nearWallFields();

src/postProcessing/functionObjects/field/processorField/processorField.C

@@ -51,6 +51,12 @@ Foam::functionObjects::processorField::processorField
     name_(name),
     obr_(obr)
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 
     const fvMesh& mesh = refCast<const fvMesh>(obr_);
@@ -76,20 +82,6 @@ Foam::functionObjects::processorField::processorField
 }
 
 
-bool Foam::functionObjects::processorField::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::processorField::~processorField()

src/postProcessing/functionObjects/field/processorField/processorField.H

@@ -124,16 +124,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~processorField();

src/postProcessing/functionObjects/field/readFields/readFields.C

@@ -51,23 +51,16 @@ Foam::functionObjects::readFields::readFields
     obr_(obr),
     fieldSet_()
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 }
 
 
-bool Foam::functionObjects::readFields::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::readFields::~readFields()

src/postProcessing/functionObjects/field/readFields/readFields.H

@@ -155,16 +155,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~readFields();

src/postProcessing/functionObjects/field/regionSizeDistribution/regionSizeDistribution.C

@@ -333,23 +333,16 @@ Foam::functionObjects::regionSizeDistribution::regionSizeDistribution
     alphaName_(dict.lookup("field")),
     patchNames_(dict.lookup("patches"))
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 }
 
 
-bool Foam::functionObjects::regionSizeDistribution::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::regionSizeDistribution::~regionSizeDistribution()

src/postProcessing/functionObjects/field/regionSizeDistribution/regionSizeDistribution.H

@@ -255,16 +255,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     // Destructor
 

src/postProcessing/functionObjects/field/streamLine/streamLine.C

@@ -337,23 +337,16 @@ Foam::functionObjects::streamLine::streamLine
     loadFromFiles_(loadFromFiles),
     nSubCycle_(0)
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict_);
 }
 
 
-bool Foam::functionObjects::streamLine::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::streamLine::~streamLine()

src/postProcessing/functionObjects/field/streamLine/streamLine.H

@@ -243,16 +243,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~streamLine();

src/postProcessing/functionObjects/field/surfaceInterpolateFields/surfaceInterpolateFields.C

@@ -50,23 +50,16 @@ Foam::functionObjects::surfaceInterpolateFields::surfaceInterpolateFields
     obr_(obr),
     fieldSet_()
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 }
 
 
-bool Foam::functionObjects::surfaceInterpolateFields::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::surfaceInterpolateFields::~surfaceInterpolateFields()

src/postProcessing/functionObjects/field/surfaceInterpolateFields/surfaceInterpolateFields.H

@@ -151,16 +151,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~surfaceInterpolateFields();

src/postProcessing/functionObjects/field/wallBoundedStreamLine/wallBoundedStreamLine.C

@@ -448,23 +448,16 @@ Foam::functionObjects::wallBoundedStreamLine::wallBoundedStreamLine
     obr_(obr),
     loadFromFiles_(loadFromFiles)
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict_);
 }
 
 
-bool Foam::functionObjects::wallBoundedStreamLine::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::wallBoundedStreamLine::~wallBoundedStreamLine()

src/postProcessing/functionObjects/field/wallBoundedStreamLine/wallBoundedStreamLine.H

@@ -249,16 +249,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~wallBoundedStreamLine();

src/postProcessing/functionObjects/forces/forceCoeffs/forceCoeffs.C

@@ -139,21 +139,13 @@ Foam::functionObjects::forceCoeffs::forceCoeffs
     lRef_(0.0),
     Aref_(0.0)
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
-    Info<< endl;
-}
-
-
-bool Foam::functionObjects::forceCoeffs::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
 }
 
 

src/postProcessing/functionObjects/forces/forceCoeffs/forceCoeffs.H

@@ -171,16 +171,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~forceCoeffs();

src/postProcessing/functionObjects/forces/forces/forces.C

@@ -553,27 +553,19 @@ Foam::functionObjects::forces::forces
     binCumulative_(true),
     initialised_(false)
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     if (readFields)
     {
         read(dict);
-        Info<< endl;
     }
 }
 
 
-bool Foam::functionObjects::forces::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 Foam::functionObjects::forces::forces
 (
     const word& name,

src/postProcessing/functionObjects/forces/forces/forces.H

@@ -292,16 +292,6 @@ public:
             const bool readFields = true
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
         //- Construct from components
         forces
         (

src/postProcessing/functionObjects/forces/pressureTools/pressureTools.C

@@ -203,6 +203,12 @@ Foam::functionObjects::pressureTools::pressureTools
     UInf_(Zero),
     rhoInf_(0.0)
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 
     dimensionSet pDims(dimPressure);
@@ -235,19 +241,6 @@ Foam::functionObjects::pressureTools::pressureTools
 }
 
 
-bool Foam::functionObjects::pressureTools::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::pressureTools::~pressureTools()

src/postProcessing/functionObjects/forces/pressureTools/pressureTools.H

@@ -218,16 +218,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~pressureTools();

src/postProcessing/functionObjects/forces/wallShearStress/wallShearStress.C

@@ -108,6 +108,12 @@ Foam::functionObjects::wallShearStress::wallShearStress
     log_(true),
     patchSet_()
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     const fvMesh& mesh = refCast<const fvMesh>(obr_);
 
     volVectorField* wallShearStressPtr
@@ -138,19 +144,6 @@ Foam::functionObjects::wallShearStress::wallShearStress
 }
 
 
-bool Foam::functionObjects::wallShearStress::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::wallShearStress::~wallShearStress()

src/postProcessing/functionObjects/forces/wallShearStress/wallShearStress.H

@@ -159,16 +159,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~wallShearStress();

src/postProcessing/functionObjects/lagrangian/cloudInfo/cloudInfo.C

@@ -68,18 +68,6 @@ Foam::functionObjects::cloudInfo::cloudInfo
 }
 
 
-bool Foam::functionObjects::cloudInfo::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    return true;
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::cloudInfo::~cloudInfo()

src/postProcessing/functionObjects/lagrangian/cloudInfo/cloudInfo.H

@@ -144,16 +144,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~cloudInfo();

src/postProcessing/functionObjects/utilities/CourantNo/CourantNo.C

@@ -73,6 +73,12 @@ Foam::functionObjects::CourantNo::CourantNo
     phiName_("phi"),
     rhoName_("rho")
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 
     const fvMesh& mesh = refCast<const fvMesh>(obr_);
@@ -99,19 +105,6 @@ Foam::functionObjects::CourantNo::CourantNo
 }
 
 
-bool Foam::functionObjects::CourantNo::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::CourantNo::~CourantNo()

src/postProcessing/functionObjects/utilities/CourantNo/CourantNo.H

@@ -110,16 +110,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~CourantNo();

src/postProcessing/functionObjects/utilities/Lambda2/Lambda2.C

@@ -54,6 +54,12 @@ Foam::functionObjects::Lambda2::Lambda2
     obr_(obr),
     UName_("U")
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 
     const fvMesh& mesh = refCast<const fvMesh>(obr_);
@@ -79,19 +85,6 @@ Foam::functionObjects::Lambda2::Lambda2
 }
 
 
-bool Foam::functionObjects::Lambda2::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::Lambda2::~Lambda2()

src/postProcessing/functionObjects/utilities/Lambda2/Lambda2.H

@@ -104,16 +104,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~Lambda2();

src/postProcessing/functionObjects/utilities/Peclet/Peclet.C

@@ -57,6 +57,12 @@ Foam::functionObjects::Peclet::Peclet
     phiName_("phi"),
     rhoName_("rho")
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 
     const fvMesh& mesh = refCast<const fvMesh>(obr_);
@@ -82,19 +88,6 @@ Foam::functionObjects::Peclet::Peclet
 }
 
 
-bool Foam::functionObjects::Peclet::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::Peclet::~Peclet()

src/postProcessing/functionObjects/utilities/Peclet/Peclet.H

@@ -106,16 +106,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~Peclet();

src/postProcessing/functionObjects/utilities/Q/Q.C

@@ -53,6 +53,12 @@ Foam::functionObjects::Q::Q
     obr_(obr),
     UName_("U")
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 
     const fvMesh& mesh = refCast<const fvMesh>(obr_);
@@ -78,19 +84,6 @@ Foam::functionObjects::Q::Q
 }
 
 
-bool Foam::functionObjects::Q::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::Q::~Q()

src/postProcessing/functionObjects/utilities/Q/Q.H

@@ -107,16 +107,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~Q();

src/postProcessing/functionObjects/utilities/abort/abort.C

@@ -97,19 +97,6 @@ Foam::functionObjects::abort::abort
 }
 
 
-bool Foam::functionObjects::abort::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    return true;
-}
-
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::abort::~abort()

src/postProcessing/functionObjects/utilities/abort/abort.H

@@ -126,16 +126,6 @@ public:
             const bool loadFromFilesUnused = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~abort();

src/postProcessing/functionObjects/utilities/blendingFactor/blendingFactor.C

@@ -52,23 +52,16 @@ Foam::functionObjects::blendingFactor::blendingFactor
     phiName_("unknown-phiName"),
     fieldName_("unknown-fieldName")
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 }
 
 
-bool Foam::functionObjects::blendingFactor::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::blendingFactor::~blendingFactor()

src/postProcessing/functionObjects/utilities/blendingFactor/blendingFactor.H

@@ -119,17 +119,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
-
 
     //- Destructor
     virtual ~blendingFactor();

src/postProcessing/functionObjects/utilities/dsmcFields/dsmcFields.C

@@ -56,23 +56,16 @@ Foam::functionObjects::dsmcFields::dsmcFields
     name_(name),
     obr_(obr)
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 }
 
 
-bool Foam::functionObjects::dsmcFields::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::dsmcFields::~dsmcFields()

src/postProcessing/functionObjects/utilities/dsmcFields/dsmcFields.H

@@ -101,16 +101,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~dsmcFields();

src/postProcessing/functionObjects/utilities/partialWrite/partialWrite.C

@@ -58,19 +58,6 @@ Foam::functionObjects::partialWrite::partialWrite
 }
 
 
-bool Foam::functionObjects::partialWrite::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::partialWrite::~partialWrite()

src/postProcessing/functionObjects/utilities/partialWrite/partialWrite.H

@@ -170,16 +170,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~partialWrite();

src/postProcessing/functionObjects/utilities/removeRegisteredObject/removeRegisteredObject.C

@@ -56,18 +56,6 @@ Foam::functionObjects::removeRegisteredObject::removeRegisteredObject
 }
 
 
-bool Foam::functionObjects::removeRegisteredObject::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    return true;
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::removeRegisteredObject::~removeRegisteredObject()

src/postProcessing/functionObjects/utilities/removeRegisteredObject/removeRegisteredObject.H

@@ -127,16 +127,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~removeRegisteredObject();

src/postProcessing/functionObjects/utilities/residuals/residuals.C

@@ -54,23 +54,16 @@ Foam::functionObjects::residuals::residuals
     obr_(obr),
     fieldSet_()
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 }
 
 
-bool Foam::functionObjects::residuals::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::residuals::~residuals()

src/postProcessing/functionObjects/utilities/residuals/residuals.H

@@ -145,16 +145,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~residuals();

src/postProcessing/functionObjects/utilities/scalarTransport/scalarTransport.C

@@ -176,6 +176,12 @@ Foam::functionObjects::scalarTransport::scalarTransport
         boundaryTypes()
     )
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 
     if (resetOnStartUp_)
@@ -185,19 +191,6 @@ Foam::functionObjects::scalarTransport::scalarTransport
 }
 
 
-bool Foam::functionObjects::scalarTransport::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::scalarTransport::~scalarTransport()

src/postProcessing/functionObjects/utilities/scalarTransport/scalarTransport.H

@@ -144,16 +144,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~scalarTransport();

src/postProcessing/functionObjects/utilities/systemCall/systemCall.C

@@ -57,18 +57,6 @@ Foam::functionObjects::systemCall::systemCall
 }
 
 
-bool Foam::functionObjects::systemCall::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    return true;
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::systemCall::~systemCall()

src/postProcessing/functionObjects/utilities/systemCall/systemCall.H

@@ -154,16 +154,6 @@ public:
             const bool loadFromFilesUnused = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~systemCall();

src/postProcessing/functionObjects/utilities/timeActivatedFileUpdate/timeActivatedFileUpdate.C

@@ -84,18 +84,6 @@ Foam::functionObjects::timeActivatedFileUpdate::timeActivatedFileUpdate
 }
 
 
-bool Foam::functionObjects::timeActivatedFileUpdate::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    return true;
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::timeActivatedFileUpdate::~timeActivatedFileUpdate()

src/postProcessing/functionObjects/utilities/timeActivatedFileUpdate/timeActivatedFileUpdate.H

@@ -129,16 +129,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~timeActivatedFileUpdate();

src/postProcessing/functionObjects/utilities/turbulenceFields/turbulenceFields.C

@@ -125,36 +125,24 @@ Foam::functionObjects::turbulenceFields::turbulenceFields
     obr_(obr),
     fieldSet_()
 {
-    read(dict);
-}
-
-
-bool Foam::functionObjects::turbulenceFields::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
     if (!isA<fvMesh>(obr))
     {
-        return false;
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
     }
 
     if
     (
-        obr.foundObject<compressible::turbulenceModel>(modelName)
+       !obr.foundObject<compressible::turbulenceModel>(modelName)
-     || obr.foundObject<incompressible::turbulenceModel>(modelName)
+    && !obr.foundObject<incompressible::turbulenceModel>(modelName)
     )
     {
-        return true;
+        FatalErrorInFunction
-    }
+            << "Cannot find turbulenceModel in objectRegistry"
-    else
+            << exit(FatalError);
-    {
-        return false;
     }
+
+    read(dict);
 }
 
 

src/postProcessing/functionObjects/utilities/turbulenceFields/turbulenceFields.H

@@ -196,16 +196,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~turbulenceFields();

src/postProcessing/functionObjects/utilities/vorticity/vorticity.C

@@ -54,6 +54,12 @@ Foam::functionObjects::vorticity::vorticity
     UName_("U"),
     outputName_(typeName)
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     read(dict);
 
     const fvMesh& mesh = refCast<const fvMesh>(obr_);
@@ -79,19 +85,6 @@ Foam::functionObjects::vorticity::vorticity
 }
 
 
-bool Foam::functionObjects::vorticity::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::vorticity::~vorticity()

src/postProcessing/functionObjects/utilities/vorticity/vorticity.H

@@ -102,16 +102,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~vorticity();

src/postProcessing/functionObjects/utilities/writeDictionary/writeDictionary.C

@@ -107,18 +107,6 @@ Foam::functionObjects::writeDictionary::writeDictionary
 }
 
 
-bool Foam::functionObjects::writeDictionary::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    return true;
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::writeDictionary::~writeDictionary()

src/postProcessing/functionObjects/utilities/writeDictionary/writeDictionary.H

@@ -119,16 +119,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~writeDictionary();

src/postProcessing/functionObjects/utilities/writeRegisteredObject/writeRegisteredObject.C

@@ -57,18 +57,6 @@ Foam::functionObjects::writeRegisteredObject::writeRegisteredObject
 }
 
 
-bool Foam::functionObjects::writeRegisteredObject::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    return true;
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::writeRegisteredObject::~writeRegisteredObject()

src/postProcessing/functionObjects/utilities/writeRegisteredObject/writeRegisteredObject.H

@@ -142,16 +142,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~writeRegisteredObject();

src/postProcessing/functionObjects/utilities/yPlus/yPlus.C

@@ -70,6 +70,12 @@ Foam::functionObjects::yPlus::yPlus
     log_(true),
     phiName_("phi")
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     const fvMesh& mesh = refCast<const fvMesh>(obr_);
 
     volScalarField* yPlusPtr
@@ -93,19 +99,6 @@ Foam::functionObjects::yPlus::yPlus
 }
 
 
-bool Foam::functionObjects::yPlus::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::functionObjects::yPlus::~yPlus()

src/postProcessing/functionObjects/utilities/yPlus/yPlus.H

@@ -120,16 +120,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~yPlus();

src/sampling/probes/patchProbes.C

@@ -202,18 +202,6 @@ Foam::patchProbes::patchProbes
 }
 
 
-bool Foam::patchProbes::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    return true;
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::patchProbes::~patchProbes()

src/sampling/probes/patchProbes.H

@@ -138,20 +138,11 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~patchProbes();
 
+
     //- Public members
 
         //- Sample and write

src/sampling/probes/probes.C

@@ -287,18 +287,6 @@ Foam::probes::probes
 }
 
 
-bool Foam::probes::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    return true;
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::probes::~probes()

src/sampling/probes/probes.H

@@ -210,16 +210,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~probes();

src/sampling/sampledSet/sampledSets/sampledSets.C

@@ -35,8 +35,9 @@ License
 
 namespace Foam
 {
-defineTypeNameAndDebug(sampledSets, 0);
+    defineTypeNameAndDebug(sampledSets, 0);
-bool sampledSets::verbose_ = false;
+
+    bool sampledSets::verbose_ = false;
 }
 
 
@@ -162,18 +163,6 @@ Foam::sampledSets::sampledSets
 }
 
 
-bool Foam::sampledSets::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    return true;
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::sampledSets::~sampledSets()

src/sampling/sampledSet/sampledSets/sampledSets.H

@@ -266,16 +266,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~sampledSets();

src/sampling/sampledSurface/sampledSurfaces/sampledSurfaces.C

@@ -115,19 +115,6 @@ Foam::sampledSurfaces::sampledSurfaces
 }
 
 
-bool Foam::sampledSurfaces::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    return true;
-}
-
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::sampledSurfaces::~sampledSurfaces()

src/sampling/sampledSurface/sampledSurfaces/sampledSurfaces.H

@@ -186,16 +186,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~sampledSurfaces();

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

@@ -60,6 +60,12 @@ Foam::moleFractions<ThermoType>::moleFractions
     name_(name),
     mesh_(refCast<const fvMesh>(obr))
 {
+    if (!isA<fvMesh>(obr))
+    {
+        FatalErrorInFunction
+            << "objectRegistry is not an fvMesh" << exit(FatalError);
+    }
+
     if (mesh_.foundObject<ThermoType>(basicThermo::dictName))
     {
         const ThermoType& thermo =
@@ -102,20 +108,6 @@ Foam::moleFractions<ThermoType>::moleFractions
 }
 
 
-template<class ThermoType>
-bool Foam::moleFractions<ThermoType>::viable
-(
-    const word& name,
-    const objectRegistry& obr,
-    const dictionary& dict,
-    const bool loadFromFiles
-)
-{
-    // Construction is viable if the available mesh is an fvMesh
-    return isA<fvMesh>(obr);
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 template<class ThermoType>

src/thermophysicalModels/reactionThermo/functionObjects/moleFractions/moleFractions.H

@@ -119,16 +119,6 @@ public:
             const bool loadFromFiles = false
         );
 
-        //- Return true if the construction of this functionObject is viable
-        //  i.e. the prerequisites for construction are available
-        static bool viable
-        (
-            const word& name,
-            const objectRegistry&,
-            const dictionary&,
-            const bool loadFromFiles = false
-        );
-
 
     //- Destructor
     virtual ~moleFractions();