ENH: use FatalErrorInLookup macros (#1362)

applications/solvers/combustion/PDRFoam/PDRModels/dragModels/PDRDragModel/PDRDragModelNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -46,12 +46,12 @@ Foam::autoPtr<Foam::PDRDragModel> Foam::PDRDragModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown PDRDragModel type "
-            << modelType << nl << nl
-            << "Valid PDRDragModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "PDRDragModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<PDRDragModel>

applications/solvers/combustion/PDRFoam/XiModels/XiEqModels/XiEqModel/XiEqModelNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -45,12 +45,12 @@ Foam::autoPtr<Foam::XiEqModel> Foam::XiEqModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown XiEqModel type "
-            << modelType << nl << nl
-            << "Valid XiEqModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "XiEqModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<XiEqModel>(cstrIter()(propDict, thermo, turbulence, Su));

applications/solvers/combustion/PDRFoam/XiModels/XiGModels/XiGModel/XiGModelNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -45,12 +45,12 @@ Foam::autoPtr<Foam::XiGModel> Foam::XiGModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown XiGModel type "
-            << modelType << nl << nl
-            << "Valid XiGModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "XiGModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<XiGModel>(cstrIter()(propDict, thermo, turbulence, Su));

applications/solvers/combustion/PDRFoam/XiModels/XiModel/XiModelNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -48,12 +48,12 @@ Foam::autoPtr<Foam::XiModel> Foam::XiModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown XiModel type "
-            << modelType << nl << nl
-            << "Valid XiModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "XiModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<XiModel>

applications/solvers/multiphase/driftFluxFoam/mixtureViscosityModels/mixtureViscosityModel/mixtureViscosityModelNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2014-2015 OpenFOAM Foundation
@@ -47,12 +47,12 @@ Foam::autoPtr<Foam::mixtureViscosityModel> Foam::mixtureViscosityModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown mixtureViscosityModel type "
-            << modelType << nl << nl
-            << "Valid mixtureViscosityModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "mixtureViscosityModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<mixtureViscosityModel>

applications/solvers/multiphase/driftFluxFoam/relativeVelocityModels/relativeVelocityModel/relativeVelocityModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2014-2017 OpenFOAM Foundation
@@ -114,12 +114,12 @@ Foam::autoPtr<Foam::relativeVelocityModel> Foam::relativeVelocityModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown time scale model type "
-            << modelType << nl << nl
-            << "Valid time scale model types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << abort(FatalError);
+        FatalErrorInLookup
+        (
+            "relative velocity",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << abort(FatalError);
     }
 
     return

applications/solvers/multiphase/icoReactingMultiphaseInterFoam/laserDTRM/reflectionModel/reflectionModel/reflectionModelNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2017-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -43,11 +43,13 @@ Foam::radiation::reflectionModel::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(dict)
-            << "Unknown reflectionModel type " << modelType << nl << nl
-            << "Valid types :" << nl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            dict,
+            "reflectionModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     return autoPtr<reflectionModel>(cstrIter()(dict, mesh));

applications/solvers/multiphase/icoReactingMultiphaseInterFoam/massTransferModels/interfaceCompositionModel/interfaceCompositionModelNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2017 OpenFOAM Foundation
@@ -38,7 +38,7 @@ Foam::interfaceCompositionModel::New
     const phasePair& pair
 )
 {
-    word interfaceCompositionModelType
+    const word modelType
     (
         dict.get<word>("type")
       + "<"
@@ -49,19 +49,18 @@ Foam::interfaceCompositionModel::New
     );
 
     Info<< "Selecting interfaceCompositionModel for "
-        << pair << ": " << interfaceCompositionModelType << endl;
+        << pair << ": " << modelType << endl;
 
-    const auto cstrIter =
-        dictionaryConstructorTablePtr_->cfind(interfaceCompositionModelType);
+    const auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown interfaceCompositionModelType type "
-            << interfaceCompositionModelType << nl << nl
-            << "Valid interfaceCompositionModel types are : " << nl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "interfaceCompositionModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()(dict, pair);

applications/solvers/multiphase/icoReactingMultiphaseInterFoam/phasesSystem/interfaceModels/porousModels/porousModel/porousModelNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2017-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -43,12 +43,12 @@ Foam::autoPtr<Foam::porousModel> Foam::porousModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown modelType type "
-            << modelType << endl << endl
-            << "Valid porousModel types are : " << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "porousModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()(dict, mesh);

applications/solvers/multiphase/icoReactingMultiphaseInterFoam/phasesSystem/interfaceModels/surfaceTensionModels/surfaceTensionModel/surfaceTensionModelNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2017-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -43,12 +43,12 @@ Foam::autoPtr<Foam::surfaceTensionModel> Foam::surfaceTensionModel::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(dict)
-            << "Unknown surfaceTensionModel type "
-            << surfaceTensionModelType << endl << endl
-            << "Valid modelType types are : " << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalErrorInLookup
+        (
+            "surfaceTensionModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()(dict, pair, true);

applications/solvers/multiphase/icoReactingMultiphaseInterFoam/phasesSystem/phaseModel/phaseModel/phaseModelNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2017-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -43,12 +43,12 @@ Foam::autoPtr<Foam::phaseModel> Foam::phaseModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown phaseModel type "
-            << modelType << endl << endl
-            << "Valid phaseModel types are : " << endl
-            << phaseSystemConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "phaseModel",
+            modelType,
+            *phaseSystemConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()(fluid, phaseName);

applications/solvers/multiphase/icoReactingMultiphaseInterFoam/phasesSystem/phaseSystem/multiphaseSystem/multiphaseSystemNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2017-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -32,7 +32,7 @@ Foam::autoPtr<Foam::multiphaseSystem> Foam::multiphaseSystem::New
     const fvMesh& mesh
 )
 {
-    const word multiphaseSystemType
+    const word systemType
     (
         IOdictionary
         (
@@ -48,19 +48,18 @@ Foam::autoPtr<Foam::multiphaseSystem> Foam::multiphaseSystem::New
         ).get<word>("type")
     );
 
-    Info<< "Selecting multiphaseSystem " << multiphaseSystemType << endl;
+    Info<< "Selecting multiphaseSystem " << systemType << endl;
 
-    const auto cstrIter =
-        dictionaryConstructorTablePtr_->cfind(multiphaseSystemType);
+    const auto cstrIter = dictionaryConstructorTablePtr_->cfind(systemType);
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown multiphaseSystemType type "
-            << multiphaseSystemType << endl
-            << "Valid multiphaseSystem types are : " << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "multiphaseSystem",
+            systemType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<multiphaseSystem>(cstrIter()(mesh));

applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/temperaturePhaseChangeTwoPhaseMixtures/newtemperaturePhaseChangeTwoPhaseMixture.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2016 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2016-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -35,7 +35,9 @@ Foam::temperaturePhaseChangeTwoPhaseMixture::New
     const fvMesh& mesh
 )
 {
-    IOdictionary phaseChangePropertiesDict
+    const word modelType
+    (
+        IOdictionary
         (
             IOobject
             (
@@ -44,13 +46,9 @@ Foam::temperaturePhaseChangeTwoPhaseMixture::New
                 mesh,
                 IOobject::MUST_READ,
                 IOobject::NO_WRITE,
-            false
+                false // Do not register
             )
-    );
-
-    const word modelType
-    (
-        phaseChangePropertiesDict.get<word>("phaseChangeTwoPhaseModel")
+        ).get<word>("phaseChangeTwoPhaseModel")
     );
 
     Info<< "Selecting phaseChange model " << modelType << endl;
@@ -59,16 +57,19 @@ Foam::temperaturePhaseChangeTwoPhaseMixture::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown temperaturePhaseChangeTwoPhaseMixture type "
-            << modelType << nl << nl
-            << "Valid temperaturePhaseChangeTwoPhaseMixture types :" << endl
-            << componentsConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "temperaturePhaseChangeTwoPhaseMixture",
+            modelType,
+            *componentsConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
-    return autoPtr<temperaturePhaseChangeTwoPhaseMixture>
-        (cstrIter()(thermo, mesh));
+    return
+        autoPtr<temperaturePhaseChangeTwoPhaseMixture>
+        (
+            cstrIter()(thermo, mesh)
+        );
 }
 
 

applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/phaseChangeTwoPhaseMixture/newPhaseChangeTwoPhaseMixture.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -37,7 +37,9 @@ Foam::phaseChangeTwoPhaseMixture::New
     const surfaceScalarField& phi
 )
 {
-    IOdictionary transportPropertiesDict
+    const word modelType
+    (
+        IOdictionary
         (
             IOobject
             (
@@ -46,13 +48,9 @@ Foam::phaseChangeTwoPhaseMixture::New
                 U.db(),
                 IOobject::MUST_READ,
                 IOobject::NO_WRITE,
-            false
+                false // Do not register
             )
-    );
-
-    const word modelType
-    (
-        transportPropertiesDict.lookup("phaseChangeTwoPhaseMixture")
+        ).get<word>("phaseChangeTwoPhaseMixture")
     );
 
     Info<< "Selecting phaseChange model " << modelType << endl;
@@ -61,12 +59,12 @@ Foam::phaseChangeTwoPhaseMixture::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown phaseChangeTwoPhaseMixture type "
-            << modelType << nl << nl
-            << "Valid phaseChangeTwoPhaseMixture types :" << endl
-            << componentsConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "phaseChangeTwoPhaseMixture",
+            modelType,
+            *componentsConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<phaseChangeTwoPhaseMixture>(cstrIter()(U, phi));

applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/dragModel/newDragModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -47,12 +47,12 @@ Foam::autoPtr<Foam::dragModel> Foam::dragModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown dragModel type "
-            << modelType << nl << nl
-            << "Valid dragModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "dragModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()(interfaceDict, phase1, phase2);

applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/heatTransferModels/heatTransferModel/newHeatTransferModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -39,7 +39,7 @@ Foam::autoPtr<Foam::heatTransferModel> Foam::heatTransferModel::New
 {
     const word modelType
     (
-        interfaceDict.lookup("heatTransferModel" + phase1.name())
+        interfaceDict.get<word>("heatTransferModel" + phase1.name())
     );
 
     Info<< "Selecting heatTransferModel for phase "
@@ -51,12 +51,12 @@ Foam::autoPtr<Foam::heatTransferModel> Foam::heatTransferModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown heatTransferModel type "
-            << modelType << nl << nl
-            << "Valid heatTransferModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "heatTransferModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()(interfaceDict, alpha1, phase1, phase2);

applications/solvers/multiphase/multiphaseEulerFoam/multiphaseSystem/diameterModels/diameterModel/newDiameterModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2017 OpenFOAM Foundation
@@ -46,12 +46,12 @@ Foam::autoPtr<Foam::diameterModel> Foam::diameterModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-           << "Unknown diameterModel type "
-           << modelType << nl << nl
-           << "Valid diameterModel types :" << endl
-           << dictionaryConstructorTablePtr_->sortedToc()
-           << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "diameterModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()

applications/solvers/multiphase/reactingEulerFoam/functionObjects/sizeDistribution/sizeDistribution.C

@@ -2,8 +2,10 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2017-2019 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
+-------------------------------------------------------------------------------
+                            | Copyright (C) 2017-2019 OpenFOAM Foundation
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -106,9 +108,13 @@ void Foam::functionObjects::sizeDistribution::initialise
 
         default:
         {
-            FatalIOErrorInFunction(dict)
-               << "Unknown functionType. Valid types are:"
-                << functionTypeNames_ << nl << exit(FatalIOError);
+            FatalIOErrorInLookup
+            (
+                dict,
+                "functionType",
+                word::null,
+                functionTypeNames_
+            ) << exit(FatalIOError);
         }
     }
 
@@ -126,9 +132,13 @@ void Foam::functionObjects::sizeDistribution::initialise
 
         default:
         {
-            FatalIOErrorInFunction(dict)
-                << "Unknown abszissaType. Valid types are:"
-                << abszissaTypeNames_ << nl << exit(FatalIOError);
+            FatalIOErrorInLookup
+            (
+                dict,
+                "abszissaType",
+                word::null,
+                abszissaTypeNames_
+            ) << exit(FatalIOError);
         }
     }
 
@@ -139,7 +149,7 @@ void Foam::functionObjects::sizeDistribution::initialise
         FatalIOErrorInFunction(dict)
             << type() << " " << name() << ": "
             << selectionModeTypeNames_[selectionModeType_]
-            << "(" << selectionModeTypeName_ << "):" << nl
+            << '(' << selectionModeTypeName_ << "):" << nl
             << "    Selection has no cells" << exit(FatalIOError);
     }
 
@@ -147,7 +157,7 @@ void Foam::functionObjects::sizeDistribution::initialise
 
     Info<< type() << " " << name() << ":"
         << selectionModeTypeNames_[selectionModeType_]
-        << "(" << selectionModeTypeName_ << "):" << nl
+        << '(' << selectionModeTypeName_ << "):" << nl
         << "    total cells  = " << nCells_ << nl
         << "    total volume = " << volume_
         << nl << endl;
@@ -160,7 +170,7 @@ void Foam::functionObjects::sizeDistribution::setCellZoneCells()
     {
         case rtCellZone:
         {
-            dict().lookup("cellZone") >> selectionModeTypeName_;
+            dict().readEntry("cellZone", selectionModeTypeName_);
 
             label zoneId =
                 mesh().cellZones().findZoneID(selectionModeTypeName_);
@@ -188,9 +198,13 @@ void Foam::functionObjects::sizeDistribution::setCellZoneCells()
 
         default:
         {
-            FatalIOErrorInFunction(dict_)
-               << "Unknown selectionMode type. Valid selectionMode types are:"
-                << selectionModeTypeNames_ << nl << exit(FatalIOError);
+            FatalIOErrorInLookup
+            (
+                dict_,
+                "selectionMode",
+                word::null,
+                selectionModeTypeNames_
+            ) << exit(FatalIOError);
         }
     }
 }

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/aspectRatioModel/newAspectRatioModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2014-2015 OpenFOAM Foundation
@@ -46,12 +46,12 @@ Foam::aspectRatioModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown aspectRatioModel type "
-            << modelType << nl << nl
-            << "Valid aspectRatioModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "aspectRatioModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()(dict, pair);

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/dragModel/newDragModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -45,12 +45,12 @@ Foam::autoPtr<Foam::dragModel> Foam::dragModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown dragModel type "
-            << modelType << nl << nl
-            << "Valid dragModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "dragModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()(dict, pair, true);

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/heatTransferModels/heatTransferModel/newHeatTransferModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -45,12 +45,12 @@ Foam::autoPtr<Foam::heatTransferModel> Foam::heatTransferModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown heatTransferModel type "
-            << modelType << nl << nl
-            << "Valid heatTransferModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "heatTransferModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()(dict, pair);

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/liftModels/liftModel/newLiftModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2014-2015 OpenFOAM Foundation
@@ -45,12 +45,12 @@ Foam::autoPtr<Foam::liftModel> Foam::liftModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown liftModel type "
-            << modelType << nl << nl
-            << "Valid liftModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "liftModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()(dict, pair);

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/swarmCorrections/swarmCorrection/newSwarmCorrection.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2014-2015 OpenFOAM Foundation
@@ -46,12 +46,12 @@ Foam::swarmCorrection::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown swarmCorrection type "
-            << modelType << nl << nl
-            << "Valid swarmCorrection types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "swarmCorrection",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()(dict, pair);

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/turbulentDispersionModels/turbulentDispersionModel/newTurbulentDispersionModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2014-2015 OpenFOAM Foundation
@@ -46,12 +46,12 @@ Foam::turbulentDispersionModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown turbulentDispersionModel type "
-            << modelType << nl << nl
-            << "Valid turbulentDispersionModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "turbulentDispersionModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()(dict, pair);

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/virtualMassModels/virtualMassModel/newVirtualMassModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2014-2015 OpenFOAM Foundation
@@ -45,12 +45,12 @@ Foam::autoPtr<Foam::virtualMassModel> Foam::virtualMassModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown virtualMassModel type "
-            << modelType << nl << nl
-            << "Valid virtualMassModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "virtualMassModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()(dict, pair, true);

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/wallLubricationModels/wallLubricationModel/newWallLubricationModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2014-2015 OpenFOAM Foundation
@@ -45,12 +45,12 @@ Foam::autoPtr<Foam::wallLubricationModel> Foam::wallLubricationModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown wallLubricationModel type "
-            << modelType << nl << nl
-            << "Valid wallLubricationModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "wallLubricationModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()(dict, pair);

applications/solvers/multiphase/twoPhaseEulerFoam/phaseCompressibleTurbulenceModels/kineticTheoryModels/conductivityModel/conductivityModel/newConductivityModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -43,12 +43,12 @@ Foam::kineticTheoryModels::conductivityModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown conductivityModel type "
-            << modelType << nl << nl
-            << "Valid conductivityModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "conductivityModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<conductivityModel>(cstrIter()(dict));

applications/solvers/multiphase/twoPhaseEulerFoam/phaseCompressibleTurbulenceModels/kineticTheoryModels/frictionalStressModel/frictionalStressModel/newFrictionalStressModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -43,12 +43,12 @@ Foam::kineticTheoryModels::frictionalStressModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown frictionalStressModel type "
-            << modelType << nl << nl
-            << "Valid frictionalStressModelType types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "frictionalStressModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<frictionalStressModel>(cstrIter()(dict));

applications/solvers/multiphase/twoPhaseEulerFoam/phaseCompressibleTurbulenceModels/kineticTheoryModels/granularPressureModel/granularPressureModel/newGranularPressureModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -43,12 +43,12 @@ Foam::kineticTheoryModels::granularPressureModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown granularPressureModel type "
-            << modelType << nl << nl
-            << "Valid granularPressureModel types :" << nl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "granularPressureModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<granularPressureModel>(cstrIter()(dict));

applications/solvers/multiphase/twoPhaseEulerFoam/phaseCompressibleTurbulenceModels/kineticTheoryModels/radialModel/radialModel/newRadialModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -43,12 +43,12 @@ Foam::kineticTheoryModels::radialModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown radialModel type "
-            << modelType << nl << nl
-            << "Valid radialModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "radialModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<radialModel>(cstrIter()(dict));

applications/solvers/multiphase/twoPhaseEulerFoam/phaseCompressibleTurbulenceModels/kineticTheoryModels/viscosityModel/viscosityModel/newViscosityModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -35,20 +35,20 @@ Foam::kineticTheoryModels::viscosityModel::New
     const dictionary& dict
 )
 {
-    const word modelName(dict.get<word>("viscosityModel"));
+    const word modelType(dict.get<word>("viscosityModel"));
 
-    Info<< "Selecting viscosityModel " << modelName << endl;
+    Info<< "Selecting viscosityModel " << modelType << endl;
 
-    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelName);
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown viscosityModel type "
-            << modelName << nl << nl
-            << "Valid viscosityModel types :" << nl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "viscosityModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<viscosityModel>(cstrIter()(dict));

applications/solvers/multiphase/twoPhaseEulerFoam/twoPhaseSystem/BlendedInterfacialModel/blendingMethods/blendingMethod/newBlendingMethod.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2014-2015 OpenFOAM Foundation
@@ -35,21 +35,21 @@ Foam::autoPtr<Foam::blendingMethod> Foam::blendingMethod::New
     const wordList& phaseNames
 )
 {
-    const word methodName(dict.get<word>("type"));
+    const word modelType(dict.get<word>("type"));
 
     Info<< "Selecting " << dict.dictName() << " blending method: "
-        << methodName << endl;
+        << modelType << endl;
 
-    auto cstrIter = dictionaryConstructorTablePtr_->cfind(methodName);
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown blendingMethod type "
-            << methodName << nl << nl
-            << "Valid blendingMethod types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "blendingMethod",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()(dict, phaseNames);

applications/solvers/multiphase/twoPhaseEulerFoam/twoPhaseSystem/diameterModels/IATE/IATEsources/IATEsource/IATEsource.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2018 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2018-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -57,12 +57,13 @@ Foam::diameterModels::IATEsource::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(dict)
-            << "Unknown IATE source type "
-            << type << nl << nl
-            << "Valid IATE source types :" << nl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            dict,
+            "IATEsource",
+            type,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     return autoPtr<IATEsource>(cstrIter()(iate, dict));

applications/solvers/multiphase/twoPhaseEulerFoam/twoPhaseSystem/diameterModels/diameterModel/newDiameterModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2017 OpenFOAM Foundation
@@ -46,12 +46,12 @@ Foam::autoPtr<Foam::diameterModel> Foam::diameterModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-           << "Unknown diameterModel type "
-           << modelType << nl << nl
-           << "Valid diameterModel types :" << endl
-           << dictionaryConstructorTablePtr_->sortedToc()
-           << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "diameterModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2012-2015 OpenFOAM Foundation
@@ -43,7 +43,7 @@ Foam::cellSizeAndAlignmentControl::cellSizeAndAlignmentControl
 (
     const Time& runTime,
     const word& name,
-    const dictionary& controlFunctionDict,
+    const dictionary& dict,
     const conformationSurfaces& geometryToConformTo,
     const scalar& defaultCellSize
 )
@@ -52,7 +52,7 @@ Foam::cellSizeAndAlignmentControl::cellSizeAndAlignmentControl
     defaultCellSize_(defaultCellSize),
     forceInitialPointInsertion_
     (
-        controlFunctionDict.lookupOrDefault<Switch>
+        dict.lookupOrDefault<Switch>
         (
             "forceInitialPointInsertion",
             Switch::OFF
@@ -69,26 +69,26 @@ Foam::cellSizeAndAlignmentControl::New
 (
     const Time& runTime,
     const word& name,
-    const dictionary& controlFunctionDict,
+    const dictionary& dict,
     const conformationSurfaces& geometryToConformTo,
     const scalar& defaultCellSize
 )
 {
-    const word controlType(controlFunctionDict.get<word>("type"));
+    const word modelType(dict.get<word>("type"));
 
     Info<< indent << "Selecting cellSizeAndAlignmentControl "
-        << controlType << endl;
+        << modelType << endl;
 
-    auto cstrIter = dictionaryConstructorTablePtr_->cfind(controlType);
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown cellSizeAndAlignmentControl type "
-            << controlType << nl << nl
-            << "Valid cellSizeAndAlignmentControl types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "cellSizeAndAlignmentControl",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<cellSizeAndAlignmentControl>
@@ -97,7 +97,7 @@ Foam::cellSizeAndAlignmentControl::New
         (
             runTime,
             name,
-            controlFunctionDict,
+            dict,
             geometryToConformTo,
             defaultCellSize
         )

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2012-2017 OpenFOAM Foundation
@@ -123,37 +123,33 @@ Foam::cellSizeFunction::cellSizeFunction
 
 Foam::autoPtr<Foam::cellSizeFunction> Foam::cellSizeFunction::New
 (
-    const dictionary& cellSizeFunctionDict,
+    const dictionary& dict,
     const searchableSurface& surface,
     const scalar& defaultCellSize,
     const labelList regionIndices
 )
 {
-    const word functionName
-    (
-        cellSizeFunctionDict.get<word>("cellSizeFunction")
-    );
+    const word modelType(dict.get<word>("cellSizeFunction"));
 
-    Info<< indent << "Selecting cellSizeFunction "
-        << functionName << endl;
+    Info<< indent << "Selecting cellSizeFunction " << modelType << endl;
 
-    auto cstrIter = dictionaryConstructorTablePtr_->cfind(functionName);
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown cellSizeFunction type "
-            << functionName << nl << nl
-            << "Valid cellSizeFunction types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "cellSizeFunction",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<cellSizeFunction>
     (
         cstrIter()
         (
-            cellSizeFunctionDict,
+            dict,
             surface,
             defaultCellSize,
             regionIndices

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/cellSizeCalculationType/cellSizeCalculationType.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2012-2015 OpenFOAM Foundation
@@ -57,34 +57,30 @@ Foam::cellSizeCalculationType::cellSizeCalculationType
 
 Foam::autoPtr<Foam::cellSizeCalculationType> Foam::cellSizeCalculationType::New
 (
-    const dictionary& cellSizeCalculationTypeDict,
+    const dictionary& dict,
     const triSurfaceMesh& surface,
     const scalar& defaultCellSize
 )
 {
-    const word calculationType
-    (
-        cellSizeCalculationTypeDict.get<word>("cellSizeCalculationType")
-    );
+    const word modelType(dict.get<word>("cellSizeCalculationType"));
 
-    Info<< indent << "Selecting cellSizeCalculationType "
-        << calculationType << endl;
+    Info<< indent << "Selecting cellSizeCalculationType " << modelType << endl;
 
-    auto cstrIter = dictionaryConstructorTablePtr_->cfind(calculationType);
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown cellSizeCalculationType type "
-            << calculationType << nl << nl
-            << "Valid cellSizeCalculationType types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "cellSizeCalculationType",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<cellSizeCalculationType>
     (
-        cstrIter()(cellSizeCalculationTypeDict, surface, defaultCellSize)
+        cstrIter()(dict, surface, defaultCellSize)
     );
 }
 

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/surfaceCellSizeFunction/surfaceCellSizeFunction.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2012-2017 OpenFOAM Foundation
@@ -62,34 +62,33 @@ Foam::surfaceCellSizeFunction::surfaceCellSizeFunction
 
 Foam::autoPtr<Foam::surfaceCellSizeFunction> Foam::surfaceCellSizeFunction::New
 (
-    const dictionary& surfaceCellSizeFunctionDict,
+    const dictionary& dict,
     const searchableSurface& surface,
     const scalar& defaultCellSize
 )
 {
-    const word functionName
+    const word modelType
     (
-        surfaceCellSizeFunctionDict.get<word>("surfaceCellSizeFunction")
+        dict.get<word>("surfaceCellSizeFunction")
     );
 
-    Info<< indent << "Selecting surfaceCellSizeFunction "
-        << functionName << endl;
+    Info<< indent << "Selecting surfaceCellSizeFunction " << modelType << endl;
 
-    auto cstrIter = dictionaryConstructorTablePtr_->cfind(functionName);
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown surfaceCellSizeFunction type "
-            << functionName << nl << nl
-            << "Valid surfaceCellSizeFunction types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "surfaceCellSizeFunction",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<surfaceCellSizeFunction>
     (
-        cstrIter()(surfaceCellSizeFunctionDict, surface, defaultCellSize)
+        cstrIter()(dict, surface, defaultCellSize)
     );
 }
 

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/faceAreaWeightModel/faceAreaWeightModel/faceAreaWeightModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2012-2017 OpenFOAM Foundation
@@ -64,12 +64,12 @@ Foam::autoPtr<Foam::faceAreaWeightModel> Foam::faceAreaWeightModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown faceAreaWeightModel type "
-            << modelType << nl << nl
-            << "Valid faceAreaWeightModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "faceAreaWeightModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<faceAreaWeightModel>(cstrIter()(relaxationDict));

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/initialPointsMethod/initialPointsMethod/initialPointsMethod.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2012-2017 OpenFOAM Foundation
@@ -79,21 +79,20 @@ Foam::autoPtr<Foam::initialPointsMethod> Foam::initialPointsMethod::New
     const autoPtr<backgroundMeshDecomposition>& decomposition
 )
 {
-    const word methodName(initialPointsDict.get<word>("initialPointsMethod"));
+    const word modelType(initialPointsDict.get<word>("initialPointsMethod"));
 
-    Info<< nl << "Selecting initialPointsMethod "
-        << methodName << endl;
+    Info<< nl << "Selecting initialPointsMethod " << modelType << endl;
 
-    auto cstrIter = dictionaryConstructorTablePtr_->cfind(methodName);
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown initialPointsMethod type "
-            << methodName << nl << nl
-            << "Valid initialPointsMethod types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "initialPointsMethod",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/relaxationModel/relaxationModel/relaxationModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2012-2017 OpenFOAM Foundation
@@ -68,12 +68,12 @@ Foam::autoPtr<Foam::relaxationModel> Foam::relaxationModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown relaxationModel type "
-            << modelType << nl << nl
-            << "Valid relaxationModel types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "relaxationModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<relaxationModel>(cstrIter()(relaxationDict, runTime));

applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/searchableSurfaceFeatures/searchableSurfaceFeatures.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2013-2015 OpenFOAM Foundation
@@ -45,18 +45,18 @@ Foam::searchableSurfaceFeatures::New
     const dictionary& dict
 )
 {
-    const word featuresType = surface.type() + "Features";
+    const word modelType(surface.type() + "Features");
 
-    auto cstrIter = dictConstructorTablePtr_->cfind(featuresType);
+    auto cstrIter = dictConstructorTablePtr_->cfind(modelType);
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown searchableSurfaceFeatures type "
-            << featuresType << nl << nl
-            << "Valid searchableSurfaceFeatures types :" << endl
-            << dictConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "searchableSurfaceFeatures",
+            modelType,
+            *dictConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<searchableSurfaceFeatures>(cstrIter()(surface, dict));

applications/utilities/mesh/manipulation/createBaffles/faceSelection/faceSelection.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2012-2016 OpenFOAM Foundation
@@ -68,18 +68,18 @@ Foam::autoPtr<Foam::faceSelection> Foam::faceSelection::New
     const dictionary& dict
 )
 {
-    const word sampleType(dict.get<word>("type"));
+    const word modelType(dict.get<word>("type"));
 
-    auto cstrIter = dictionaryConstructorTablePtr_->cfind(sampleType);
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown faceSelection type "
-            << sampleType << nl << nl
-            << "Valid faceSelection types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "faceSelection",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<faceSelection>(cstrIter()(name, mesh, dict));

applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunctionNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -44,11 +44,12 @@ Foam::tabulatedWallFunctions::tabulatedWallFunction::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown tabulatedWallFunction type " << functionName
-            << nl << nl << "Valid tabulatedWallFunction types are:" << nl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "tabulatedWallFunction",
+            functionName,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<tabulatedWallFunction>(cstrIter()(dict, mesh));

applications/utilities/surface/surfaceFeatureExtract/extractionMethod/surfaceFeaturesExtraction.C

@@ -68,17 +68,19 @@ Foam::surfaceFeaturesExtraction::method::New
     const dictionary& dict
 )
 {
-    const word methodName(dict.get<word>("extractionMethod"));
+    const word modelType(dict.get<word>("extractionMethod"));
 
-    auto cstrIter = dictionaryConstructorTablePtr_->cfind(methodName);
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(dict)
-            << "Unknown extractionMethod " << methodName << nl << nl
-            << "Valid extraction methods:" << nl
-            << flatOutput(dictionaryConstructorTablePtr_->sortedToc())
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            dict,
+            "extractionMethod",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     return autoPtr<method>(cstrIter.val()(dict));

applications/utilities/surface/surfacePatch/searchableSurfaceModifier/searchableSurfaceModifier.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2014 OpenFOAM Foundation
@@ -70,12 +70,12 @@ Foam::searchableSurfaceModifier::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown searchableSurfaceModifier type "
-            << type << nl << nl
-            << "Valid searchableSurfaceModifier types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "searchableSurfaceModifier",
+            type,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<searchableSurfaceModifier>(cstrIter()(geometry, dict));

src/ODE/ODESolvers/ODESolver/ODESolverNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -42,12 +42,12 @@ Foam::autoPtr<Foam::ODESolver> Foam::ODESolver::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown ODESolver type "
-            << solverType << nl << nl
-            << "Valid ODESolver types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "ODESolver",
+            solverType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<ODESolver>(cstrIter()(odes, dict));

src/OpenFOAM/db/IOstreams/token/token.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2017-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -62,12 +62,13 @@ Foam::autoPtr<Foam::token::compound> Foam::token::compound::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(is)
-            << "Unknown compound type "
-            << compoundType << nl << nl
-            << "Valid compound types:" << endl
-            << IstreamConstructorTablePtr_->sortedToc()
-            << abort(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            is,
+            "compound",
+            compoundType,
+            *IstreamConstructorTablePtr_
+        ) << abort(FatalIOError);
     }
 
     return autoPtr<Foam::token::compound>(cstrIter()(is));

src/OpenFOAM/db/functionObjects/functionObject/functionObject.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2017-2018 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2017-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -112,12 +112,12 @@ Foam::autoPtr<Foam::functionObject> Foam::functionObject::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown function type "
-            << functionType << nl << nl
-            << "Valid function types :" << nl
-            << dictionaryConstructorTablePtr_->sortedToc() << endl
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "function",
+            functionType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<functionObject>(cstrIter()(name, runTime, dict));

src/OpenFOAM/fields/pointPatchFields/pointPatchField/pointPatchFieldNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         |2011 OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -36,21 +36,18 @@ Foam::autoPtr<Foam::pointPatchField<Type>> Foam::pointPatchField<Type>::New
     const DimensionedField<Type, pointMesh>& iF
 )
 {
-    if (debug)
-    {
-        InfoInFunction << "Constructing pointPatchField<Type>" << endl;
-    }
+    DebugInFunction << "Constructing pointPatchField<Type>" << endl;
 
     auto cstrIter = pointPatchConstructorTablePtr_->cfind(patchFieldType);
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown patchFieldType type "
-            << patchFieldType << nl << nl
-            << "Valid patchField types :" << endl
-            << pointPatchConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "patchFieldType",
+            patchFieldType,
+            *pointPatchConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     autoPtr<pointPatchField<Type>> pfPtr(cstrIter()(p, iF));
@@ -111,10 +108,7 @@ Foam::autoPtr<Foam::pointPatchField<Type>> Foam::pointPatchField<Type>::New
     const dictionary& dict
 )
 {
-    if (debug)
-    {
-        InfoInFunction << "Constructing pointPatchField<Type>" << endl;
-    }
+    DebugInFunction << "Constructing pointPatchField<Type>" << endl;
 
     const word patchFieldType(dict.get<word>("type"));
 
@@ -184,21 +178,18 @@ Foam::autoPtr<Foam::pointPatchField<Type>> Foam::pointPatchField<Type>::New
     const pointPatchFieldMapper& pfMapper
 )
 {
-    if (debug)
-    {
-        InfoInFunction << "Constructing pointPatchField<Type>" << endl;
-    }
+    DebugInFunction << "Constructing pointPatchField<Type>" << endl;
 
     auto cstrIter = patchMapperConstructorTablePtr_->cfind(ptf.type());
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown patchField type "
-            << ptf.type() << nl << nl
-            << "Valid patchField types :" << endl
-            << patchMapperConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "patchField",
+            ptf.type(),
+            *patchMapperConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return cstrIter()(ptf, p, iF, pfMapper);

src/OpenFOAM/global/fileOperations/fileOperation/fileOperation.C

@@ -436,12 +436,12 @@ Foam::autoPtr<Foam::fileOperation> Foam::fileOperation::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown fileHandler type "
-            << handlerType << nl << nl
-            << "Valid fileHandler types :" << endl
-            << wordConstructorTablePtr_->sortedToc()
-            << abort(FatalError);
+        FatalErrorInLookup
+        (
+            "fileHandler",
+            handlerType,
+            *wordConstructorTablePtr_
+        ) << abort(FatalError);
     }
 
     return autoPtr<fileOperation>(cstrIter()(verbose));

src/OpenFOAM/global/fileOperations/fileOperationInitialise/fileOperationInitialise.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2017-2018 OpenFOAM Foundation
@@ -58,21 +58,18 @@ Foam::fileOperations::fileOperationInitialise::New
     char**& argv
 )
 {
-    if (debug)
-    {
-        InfoInFunction << "Constructing fileOperationInitialise" << endl;
-    }
+    DebugInFunction << "Constructing fileOperationInitialise" << endl;
 
     auto cstrIter = wordConstructorTablePtr_->cfind(type);
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown fileOperationInitialise type "
-            << type << nl << nl
-            << "Valid fileOperationInitialise types are" << endl
-            << wordConstructorTablePtr_->sortedToc()
-            << abort(FatalError);
+        FatalErrorInLookup
+        (
+            "fileOperationInitialise",
+            type,
+            *wordConstructorTablePtr_
+        ) << abort(FatalError);
     }
 
     return autoPtr<fileOperationInitialise>(cstrIter()(argc, argv));

src/OpenFOAM/graph/graph.C

@@ -222,12 +222,12 @@ Foam::autoPtr<Foam::graph::writer> Foam::graph::writer::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown graph format "
-            << graphFormat << nl << nl
-            << "Valid graph formats :" << endl
-            << wordConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "graph",
+            graphFormat,
+            *wordConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<graph::writer>(cstrIter()());

src/OpenFOAM/interpolations/interpolationTable/tableReaders/tableReader.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -45,12 +45,12 @@ Foam::autoPtr<Foam::tableReader<Type>> Foam::tableReader<Type>::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown reader type "
-            << readerType << nl << nl
-            << "Valid reader types :" << nl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "reader",
+            readerType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<tableReader<Type>>(cstrIter()(spec));

src/OpenFOAM/interpolations/interpolationWeights/interpolationWeights/interpolationWeights.C

@@ -54,23 +54,18 @@ Foam::autoPtr<Foam::interpolationWeights> Foam::interpolationWeights::New
     const scalarField& samples
 )
 {
-    if (debug)
-    {
-        InfoInFunction
-            << "Selecting interpolationWeights "
-            << type << endl;
-    }
+    DebugInFunction << "Selecting interpolationWeights " << type << endl;
 
     auto cstrIter = wordConstructorTablePtr_->cfind(type);
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown interpolationWeights type "
-            << type << nl << nl
-            << "Valid interpolationWeights types :" << endl
-            << wordConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "interpolationWeights",
+            type,
+            *wordConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<interpolationWeights>(cstrIter()(samples));

src/OpenFOAM/matrices/LduMatrix/LduMatrix/LduMatrixPreconditioner.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -49,12 +49,13 @@ Foam::LduMatrix<Type, DType, LUType>::preconditioner::New
 
         if (!cstrIter.found())
         {
-            FatalIOErrorInFunction(preconditionerDict)
-                << "Unknown symmetric matrix preconditioner "
-                << preconditionerName << endl << endl
-                << "Valid symmetric matrix preconditioners are :" << endl
-                << symMatrixConstructorTablePtr_->sortedToc()
-                << exit(FatalIOError);
+            FatalIOErrorInLookup
+            (
+                preconditionerDict,
+                "symmetric matrix preconditioner",
+                preconditionerName,
+                *symMatrixConstructorTablePtr_
+            ) << exit(FatalIOError);
         }
 
         return autoPtr<typename LduMatrix<Type, DType, LUType>::preconditioner>
@@ -73,12 +74,13 @@ Foam::LduMatrix<Type, DType, LUType>::preconditioner::New
 
         if (!cstrIter.found())
         {
-            FatalIOErrorInFunction(preconditionerDict)
-                << "Unknown asymmetric matrix preconditioner "
-                << preconditionerName << endl << endl
-                << "Valid asymmetric matrix preconditioners are :" << endl
-                << asymMatrixConstructorTablePtr_->sortedToc()
-                << exit(FatalIOError);
+            FatalIOErrorInLookup
+            (
+                preconditionerDict,
+                "asymmetric matrix preconditioner",
+                preconditionerName,
+                *asymMatrixConstructorTablePtr_
+            ) << exit(FatalIOError);
         }
 
         return autoPtr<typename LduMatrix<Type, DType, LUType>::preconditioner>

src/OpenFOAM/matrices/LduMatrix/LduMatrix/LduMatrixSmoother.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -46,12 +46,13 @@ Foam::LduMatrix<Type, DType, LUType>::smoother::New
 
         if (!cstrIter.found())
         {
-            FatalIOErrorInFunction(smootherDict)
-                << "Unknown symmetric matrix smoother " << smootherName
-                << endl << endl
-                << "Valid symmetric matrix smoothers are :" << endl
-                << symMatrixConstructorTablePtr_->sortedToc()
-                << exit(FatalIOError);
+            FatalIOErrorInLookup
+            (
+                smootherDict,
+                "symmetric matrix smoother",
+                smootherName,
+                *symMatrixConstructorTablePtr_
+            ) << exit(FatalIOError);
         }
 
         return autoPtr<typename LduMatrix<Type, DType, LUType>::smoother>
@@ -69,12 +70,13 @@ Foam::LduMatrix<Type, DType, LUType>::smoother::New
 
         if (!cstrIter.found())
         {
-            FatalIOErrorInFunction(smootherDict)
-                << "Unknown asymmetric matrix smoother " << smootherName
-                << endl << endl
-                << "Valid asymmetric matrix smoothers are :" << endl
-                << asymMatrixConstructorTablePtr_->sortedToc()
-                << exit(FatalIOError);
+            FatalIOErrorInLookup
+            (
+                smootherDict,
+                "asymmetric matrix smoother",
+                smootherName,
+                *asymMatrixConstructorTablePtr_
+            ) << exit(FatalIOError);
         }
 
         return autoPtr<typename LduMatrix<Type, DType, LUType>::smoother>

src/OpenFOAM/matrices/LduMatrix/LduMatrix/LduMatrixSolver.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2017 OpenFOAM Foundation
@@ -59,12 +59,13 @@ Foam::LduMatrix<Type, DType, LUType>::solver::New
 
         if (!cstrIter.found())
         {
-            FatalIOErrorInFunction(solverDict)
-                << "Unknown symmetric matrix solver " << solverName
-                << endl << endl
-                << "Valid symmetric matrix solvers are :" << endl
-                << symMatrixConstructorTablePtr_->sortedToc()
-                << exit(FatalIOError);
+            FatalIOErrorInLookup
+            (
+                solverDict,
+                "symmetric matrix solver",
+                solverName,
+                *symMatrixConstructorTablePtr_
+            ) << exit(FatalIOError);
         }
 
         return autoPtr<typename LduMatrix<Type, DType, LUType>::solver>
@@ -83,12 +84,13 @@ Foam::LduMatrix<Type, DType, LUType>::solver::New
 
         if (!cstrIter.found())
         {
-            FatalIOErrorInFunction(solverDict)
-                << "Unknown asymmetric matrix solver " << solverName
-                << endl << endl
-                << "Valid asymmetric matrix solvers are :" << endl
-                << asymMatrixConstructorTablePtr_->sortedToc()
-                << exit(FatalIOError);
+            FatalIOErrorInLookup
+            (
+                solverDict,
+                "asymmetric matrix solver",
+                solverName,
+                *asymMatrixConstructorTablePtr_
+            ) << exit(FatalIOError);
         }
 
         return autoPtr<typename LduMatrix<Type, DType, LUType>::solver>

src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrixPreconditioner.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -93,12 +93,13 @@ Foam::lduMatrix::preconditioner::New
 
         if (!cstrIter.found())
         {
-            FatalIOErrorInFunction(controls)
-                << "Unknown symmetric matrix preconditioner "
-                << name << nl << nl
-                << "Valid symmetric matrix preconditioners :" << endl
-                << symMatrixConstructorTablePtr_->sortedToc()
-                << exit(FatalIOError);
+            FatalIOErrorInLookup
+            (
+                controls,
+                "symmetric matrix preconditioner",
+                name,
+                *symMatrixConstructorTablePtr_
+            ) << exit(FatalIOError);
         }
 
         return autoPtr<lduMatrix::preconditioner>
@@ -116,12 +117,13 @@ Foam::lduMatrix::preconditioner::New
 
         if (!cstrIter.found())
         {
-            FatalIOErrorInFunction(controls)
-                << "Unknown asymmetric matrix preconditioner "
-                << name << nl << nl
-                << "Valid asymmetric matrix preconditioners :" << endl
-                << asymMatrixConstructorTablePtr_->sortedToc()
-                << exit(FatalIOError);
+            FatalIOErrorInLookup
+            (
+                controls,
+                "asymmetric matrix preconditioner",
+                name,
+                *asymMatrixConstructorTablePtr_
+            ) << exit(FatalIOError);
         }
 
         return autoPtr<lduMatrix::preconditioner>

src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrixSmoother.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -96,12 +96,13 @@ Foam::autoPtr<Foam::lduMatrix::smoother> Foam::lduMatrix::smoother::New
 
         if (!cstrIter.found())
         {
-            FatalIOErrorInFunction(solverControls)
-                << "Unknown symmetric matrix smoother "
-                << name << nl << nl
-                << "Valid symmetric matrix smoothers are :" << endl
-                << symMatrixConstructorTablePtr_->sortedToc()
-                << exit(FatalIOError);
+            FatalIOErrorInLookup
+            (
+                solverControls,
+                "symmetric matrix smoother",
+                name,
+                *symMatrixConstructorTablePtr_
+            ) << exit(FatalIOError);
         }
 
         return autoPtr<lduMatrix::smoother>
@@ -122,12 +123,13 @@ Foam::autoPtr<Foam::lduMatrix::smoother> Foam::lduMatrix::smoother::New
 
         if (!cstrIter.found())
         {
-            FatalIOErrorInFunction(solverControls)
-                << "Unknown asymmetric matrix smoother "
-                << name << nl << nl
-                << "Valid asymmetric matrix smoothers are :" << endl
-                << asymMatrixConstructorTablePtr_->sortedToc()
-                << exit(FatalIOError);
+            FatalIOErrorInLookup
+            (
+                solverControls,
+                "asymmetric matrix smoother",
+                name,
+                *asymMatrixConstructorTablePtr_
+            ) << exit(FatalIOError);
         }
 
         return autoPtr<lduMatrix::smoother>

src/OpenFOAM/matrices/lduMatrix/lduMatrix/lduMatrixSolver.C

@@ -73,11 +73,13 @@ Foam::autoPtr<Foam::lduMatrix::solver> Foam::lduMatrix::solver::New
 
         if (!cstrIter.found())
         {
-            FatalIOErrorInFunction(solverControls)
-                << "Unknown symmetric matrix solver " << name << nl << nl
-                << "Valid symmetric matrix solvers are :" << endl
-                << symMatrixConstructorTablePtr_->sortedToc()
-                << exit(FatalIOError);
+            FatalIOErrorInLookup
+            (
+                solverControls,
+                "symmetric matrix solver",
+                name,
+                *symMatrixConstructorTablePtr_
+            ) << exit(FatalIOError);
         }
 
         return autoPtr<lduMatrix::solver>
@@ -99,11 +101,13 @@ Foam::autoPtr<Foam::lduMatrix::solver> Foam::lduMatrix::solver::New
 
         if (!cstrIter.found())
         {
-            FatalIOErrorInFunction(solverControls)
-                << "Unknown asymmetric matrix solver " << name << nl << nl
-                << "Valid asymmetric matrix solvers are :" << endl
-                << asymMatrixConstructorTablePtr_->sortedToc()
-                << exit(FatalIOError);
+            FatalIOErrorInLookup
+            (
+                solverControls,
+                "asymmetric matrix solver",
+                name,
+                *asymMatrixConstructorTablePtr_
+            ) << exit(FatalIOError);
         }
 
         return autoPtr<lduMatrix::solver>

src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGProcAgglomerations/GAMGProcAgglomeration/GAMGProcAgglomeration.C

@@ -360,10 +360,7 @@ Foam::autoPtr<Foam::GAMGProcAgglomeration> Foam::GAMGProcAgglomeration::New
     const dictionary& controlDict
 )
 {
-    if (debug)
-    {
-        InfoInFunction << "Constructing GAMGProcAgglomeration" << endl;
-    }
+    DebugInFunction << "Constructing GAMGProcAgglomeration" << endl;
 
     auto cstrIter = GAMGAgglomerationConstructorTablePtr_->cfind(type);
 

src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaceFields/GAMGInterfaceField/GAMGInterfaceFieldNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -41,12 +41,12 @@ Foam::autoPtr<Foam::GAMGInterfaceField> Foam::GAMGInterfaceField::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown GAMGInterfaceField type "
-            << coupleType << nl
-            << "Valid GAMGInterfaceField types :"
-            << lduInterfaceFieldConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "GAMGInterfaceField",
+            coupleType,
+            *lduInterfaceFieldConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<GAMGInterfaceField>(cstrIter()(GAMGCp, fineInterface));
@@ -66,12 +66,12 @@ Foam::autoPtr<Foam::GAMGInterfaceField> Foam::GAMGInterfaceField::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown GAMGInterfaceField type "
-            << coupleType << nl
-            << "Valid GAMGInterfaceField types :"
-            << lduInterfaceConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "GAMGInterfaceField",
+            coupleType,
+            *lduInterfaceConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<GAMGInterfaceField>(cstrIter()(GAMGCp, doTransform, rank));

src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaces/GAMGInterface/GAMGInterfaceNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -49,11 +49,12 @@ Foam::autoPtr<Foam::GAMGInterface> Foam::GAMGInterface::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown GAMGInterface type " << coupleType << ".\n"
-            << "Valid GAMGInterface types :"
-            << lduInterfaceConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "GAMGInterface",
+            coupleType,
+            *lduInterfaceConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<GAMGInterface>
@@ -84,11 +85,12 @@ Foam::autoPtr<Foam::GAMGInterface> Foam::GAMGInterface::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown GAMGInterface type " << coupleType << ".\n"
-            << "Valid GAMGInterface types :"
-            << IstreamConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "GAMGInterface",
+            coupleType,
+            *IstreamConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<GAMGInterface>(cstrIter()(index, coarseInterfaces, is));

src/OpenFOAM/meshes/pointMesh/pointPatches/facePointPatch/facePointPatchNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -35,21 +35,18 @@ Foam::autoPtr<Foam::facePointPatch> Foam::facePointPatch::New
     const pointBoundaryMesh& bm
 )
 {
-    if (debug)
-    {
-        InfoInFunction << "Constructing facePointPatch" << endl;
-    }
+    DebugInFunction << "Constructing facePointPatch" << endl;
 
     auto cstrIter = polyPatchConstructorTablePtr_->cfind(patch.type());
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown facePointPatch type "
-            << patch.type() << nl << nl
-            << "Valid facePointPatch types :" << endl
-            << polyPatchConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "facePointPatch",
+            patch.type(),
+            *polyPatchConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<facePointPatch>(cstrIter()(patch, bm));

src/OpenFOAM/meshes/polyMesh/polyPatches/polyPatch/polyPatchNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -40,21 +40,18 @@ Foam::autoPtr<Foam::polyPatch> Foam::polyPatch::New
     const polyBoundaryMesh& bm
 )
 {
-    if (debug)
-    {
-        InfoInFunction << "Constructing polyPatch" << endl;
-    }
+    DebugInFunction << "Constructing polyPatch" << endl;
 
     auto cstrIter = wordConstructorTablePtr_->cfind(patchType);
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown polyPatch type "
-            << patchType << " for patch " << name << nl << nl
-            << "Valid polyPatch types :" << endl
-            << wordConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "polyPatch",
+            patchType,
+            *wordConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<polyPatch>
@@ -80,10 +77,7 @@ Foam::autoPtr<Foam::polyPatch> Foam::polyPatch::New
     const polyBoundaryMesh& bm
 )
 {
-    if (debug)
-    {
-        InfoInFunction << "Constructing polyPatch" << endl;
-    }
+    DebugInFunction << "Constructing polyPatch" << endl;
 
     word patchType(dict.get<word>("type"));
     dict.readIfPresent("geometricType", patchType);
@@ -101,10 +95,7 @@ Foam::autoPtr<Foam::polyPatch> Foam::polyPatch::New
     const polyBoundaryMesh& bm
 )
 {
-    if (debug)
-    {
-        InfoInFunction << "Constructing polyPatch" << endl;
-    }
+    DebugInFunction << "Constructing polyPatch" << endl;
 
     auto cstrIter = dictionaryConstructorTablePtr_->cfind(patchType);
 
@@ -117,12 +108,13 @@ Foam::autoPtr<Foam::polyPatch> Foam::polyPatch::New
 
         if (!cstrIter.found())
         {
-            FatalIOErrorInFunction(dict)
-                << "Unknown polyPatch type "
-                << patchType << " for patch " << name << nl << nl
-                << "Valid polyPatch types :" << endl
-                << dictionaryConstructorTablePtr_->sortedToc()
-                << exit(FatalIOError);
+            FatalIOErrorInLookup
+            (
+                dict,
+                "polyPatch",
+                patchType,
+                *dictionaryConstructorTablePtr_
+            ) << exit(FatalIOError);
         }
     }
 

src/OpenFOAM/meshes/polyMesh/zones/cellZone/cellZoneNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -38,10 +38,7 @@ Foam::autoPtr<Foam::cellZone> Foam::cellZone::New
     const cellZoneMesh& zm
 )
 {
-    if (debug)
-    {
-        InfoInFunction << "Constructing cellZone " << name << endl;
-    }
+    DebugInFunction << "Constructing cellZone " << name << endl;
 
     const word zoneType(dict.get<word>("type"));
 
@@ -49,12 +46,13 @@ Foam::autoPtr<Foam::cellZone> Foam::cellZone::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(dict)
-            << "Unknown cellZone type "
-            << zoneType << nl << nl
-            << "Valid cellZone types :" << nl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            dict,
+            "cellZone",
+            zoneType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     return autoPtr<cellZone>(cstrIter()(name, dict, index, zm));

src/OpenFOAM/meshes/polyMesh/zones/faceZone/faceZoneNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -38,10 +38,7 @@ Foam::autoPtr<Foam::faceZone> Foam::faceZone::New
     const faceZoneMesh& zm
 )
 {
-    if (debug)
-    {
-        InfoInFunction << "Constructing faceZone " << name << endl;
-    }
+    DebugInFunction << "Constructing faceZone " << name << endl;
 
     const word zoneType(dict.get<word>("type"));
 
@@ -49,12 +46,13 @@ Foam::autoPtr<Foam::faceZone> Foam::faceZone::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(dict)
-            << "Unknown faceZone type "
-            << zoneType << nl << nl
-            << "Valid faceZone types :" << nl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            dict,
+            "faceZone",
+            zoneType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     return autoPtr<faceZone>(cstrIter()(name, dict, index, zm));

src/OpenFOAM/meshes/polyMesh/zones/pointZone/pointZoneNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -38,10 +38,7 @@ Foam::autoPtr<Foam::pointZone> Foam::pointZone::New
     const pointZoneMesh& zm
 )
 {
-    if (debug)
-    {
-        InfoInFunction << "Constructing pointZone " << name << endl;
-    }
+    DebugInFunction << "Constructing pointZone " << name << endl;
 
     const word zoneType(dict.get<word>("type"));
 
@@ -49,12 +46,13 @@ Foam::autoPtr<Foam::pointZone> Foam::pointZone::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(dict)
-            << "Unknown pointZone type "
-            << zoneType << nl << nl
-            << "Valid pointZone types :" << nl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            dict,
+            "pointZone",
+            zoneType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     return autoPtr<pointZone>(cstrIter()(name, dict, index, zm));

src/OpenFOAM/primitives/functions/Function1/Function1/Function1New.C

@@ -54,7 +54,7 @@ Foam::autoPtr<Foam::Function1<Type>> Foam::Function1<Type>::New
         {
             FatalIOErrorInFunction(dict)
                 << "Unknown Function1 type "
-                << Function1Type << " for Function1 "
+                << Function1Type << " for "
                 << entryName << nl << nl
                 << "Valid Function1 types :" << nl
                 << dictionaryConstructorTablePtr_->sortedToc() << nl
@@ -110,7 +110,7 @@ Foam::autoPtr<Foam::Function1<Type>> Foam::Function1<Type>::New
         {
             FatalIOErrorInFunction(dict)
                 << "Unknown Function1 type "
-                << Function1Type << " for Function1 "
+                << Function1Type << " for "
                 << entryName << nl << nl
                 << "Valid Function1 types :" << nl
                 << dictionaryConstructorTablePtr_->sortedToc() << nl

src/TurbulenceModels/turbulenceModels/LES/LESModel/LESModel.C

@@ -135,8 +135,6 @@ Foam::LESModel<BasicTurbulenceModel>::New
     const word& propertiesName
 )
 {
-    // get model name, but do not register the dictionary
-    // otherwise it is registered in the database twice
     const word modelType
     (
         IOdictionary
@@ -148,7 +146,7 @@ Foam::LESModel<BasicTurbulenceModel>::New
                 U.db(),
                 IOobject::MUST_READ_IF_MODIFIED,
                 IOobject::NO_WRITE,
-                false
+                false // Do not register
             )
         ).subDict("LES").get<word>("LESModel")
     );
@@ -159,12 +157,12 @@ Foam::LESModel<BasicTurbulenceModel>::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown LESModel type "
-            << modelType << nl << nl
-            << "Valid LESModel types:" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "LESModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<LESModel>

src/TurbulenceModels/turbulenceModels/LES/LESdeltas/LESdelta/LESdelta.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -80,12 +80,12 @@ Foam::autoPtr<Foam::LESdelta> Foam::LESdelta::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown LESdelta type "
-            << deltaType << nl << nl
-            << "Valid LESdelta types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "LESdelta",
+            deltaType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<LESdelta>(cstrIter()(name, turbulence, dict));
@@ -119,13 +119,13 @@ Foam::autoPtr<Foam::LESdelta> Foam::LESdelta::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown LESdelta type "
-            << deltaType << nl << nl
-            << "Valid LESdelta types :" << endl
-            << additionalConstructors.sortedToc()
-            << " and "
-            << dictionaryConstructorTablePtr_->sortedToc()
+        FatalErrorInLookup
+        (
+            "LESdelta",
+            deltaType,
+            additionalConstructors
+        )
+            << " and " << dictionaryConstructorTablePtr_->sortedToc()
             << exit(FatalError);
     }
 

src/TurbulenceModels/turbulenceModels/LES/LESfilters/LESfilter/LESfilter.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -52,12 +52,12 @@ Foam::autoPtr<Foam::LESfilter> Foam::LESfilter::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown LESfilter type "
-            << filterType << nl << nl
-            << "Valid LESfilter types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "LESfilter",
+            filterType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<LESfilter>(cstrIter()(mesh, dict));

src/TurbulenceModels/turbulenceModels/RAS/RASModel/RASModel.C

@@ -125,8 +125,6 @@ Foam::RASModel<BasicTurbulenceModel>::New
     const word& propertiesName
 )
 {
-    // get model name, but do not register the dictionary
-    // otherwise it is registered in the database twice
     const word modelType
     (
         IOdictionary
@@ -138,7 +136,7 @@ Foam::RASModel<BasicTurbulenceModel>::New
                 U.db(),
                 IOobject::MUST_READ_IF_MODIFIED,
                 IOobject::NO_WRITE,
-                false
+                false // Do not register
             )
         ).subDict("RAS").get<word>("RASModel")
     );
@@ -149,12 +147,12 @@ Foam::RASModel<BasicTurbulenceModel>::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown RASModel type "
-            << modelType << nl << nl
-            << "Valid RASModel types:" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "RASModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<RASModel>

src/TurbulenceModels/turbulenceModels/TurbulenceModel/TurbulenceModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2013-2017 OpenFOAM Foundation
@@ -87,8 +87,6 @@ Foam::TurbulenceModel<Alpha, Rho, BasicTurbulenceModel, TransportModel>::New
     const word& propertiesName
 )
 {
-    // get model name, but do not register the dictionary
-    // otherwise it is registered in the database twice
     const word modelType
     (
         IOdictionary
@@ -100,7 +98,7 @@ Foam::TurbulenceModel<Alpha, Rho, BasicTurbulenceModel, TransportModel>::New
                 U.db(),
                 IOobject::MUST_READ_IF_MODIFIED,
                 IOobject::NO_WRITE,
-                false
+                false // Do not register
             )
         ).get<word>("simulationType")
     );
@@ -111,12 +109,12 @@ Foam::TurbulenceModel<Alpha, Rho, BasicTurbulenceModel, TransportModel>::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown simulationType "
-            << modelType << nl << nl
-            << "Valid simulation types:" << nl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "simulationType",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<TurbulenceModel>

src/TurbulenceModels/turbulenceModels/laminar/laminarModel/laminarModel.C

@@ -101,14 +101,12 @@ Foam::laminarModel<BasicTurbulenceModel>::New
             U.db(),
             IOobject::MUST_READ_IF_MODIFIED,
             IOobject::NO_WRITE,
-            false
+            false // Do not register
         )
     );
 
     if (modelDict.found("laminar"))
     {
-        // get model name, but do not register the dictionary
-        // otherwise it is registered in the database twice
         const word modelType
         (
             modelDict.subDict("laminar").get<word>("laminarModel")
@@ -120,12 +118,12 @@ Foam::laminarModel<BasicTurbulenceModel>::New
 
         if (!cstrIter.found())
         {
-            FatalErrorInFunction
-                << "Unknown laminarModel type "
-                << modelType << nl << nl
-                << "Valid laminarModel types :" << endl
-                << dictionaryConstructorTablePtr_->sortedToc()
-                << exit(FatalError);
+            FatalErrorInLookup
+            (
+                "laminarModel",
+                modelType,
+                *dictionaryConstructorTablePtr_
+            ) << exit(FatalError);
         }
 
         return autoPtr<laminarModel>

src/combustionModels/FSD/reactionRateFlameAreaModels/reactionRateFlameArea/reactionRateFlameAreaNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -48,12 +48,13 @@ Foam::autoPtr<Foam::reactionRateFlameArea> Foam::reactionRateFlameArea::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(dict)
-            << "Unknown reactionRateFlameArea type "
-            << modelType << nl << nl
-            << "Valid reaction rate flame area types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            dict,
+            "reactionRateFlameArea",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     const word className = modelType.substr(0, modelType.find('<'));

src/dynamicFvMesh/dynamicFvMesh/dynamicFvMeshNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2017 OpenFOAM Foundation
@@ -46,7 +46,7 @@ Foam::autoPtr<Foam::dynamicFvMesh> Foam::dynamicFvMesh::New(const IOobject& io)
         io.db(),
         IOobject::MUST_READ_IF_MODIFIED,
         IOobject::NO_WRITE,
-        false
+        false // Do not register
     );
 
     if (dictHeader.typeHeaderOk<IOdictionary>(true))
@@ -75,12 +75,13 @@ Foam::autoPtr<Foam::dynamicFvMesh> Foam::dynamicFvMesh::New(const IOobject& io)
 
         if (!cstrIter.found())
         {
-            FatalIOErrorInFunction(dict)
-                << "Unknown dynamicFvMesh type "
-                << modelType << nl << nl
-                << "Valid dynamicFvMesh types are :" << endl
-                << IOobjectConstructorTablePtr_->sortedToc()
-                << exit(FatalIOError);
+            FatalIOErrorInLookup
+            (
+                dict,
+                "dynamicFvMesh",
+                modelType,
+                *IOobjectConstructorTablePtr_
+            ) << exit(FatalIOError);
         }
 
         return autoPtr<dynamicFvMesh>(cstrIter()(io));

src/dynamicMesh/meshCut/cellLooper/cellLooper.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -51,12 +51,12 @@ Foam::autoPtr<Foam::cellLooper> Foam::cellLooper::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown cellLooper type "
-            << type << nl << nl
-            << "Valid cellLooper types :" << endl
-            << wordConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "cellLooper",
+            type,
+            *wordConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<cellLooper>(cstrIter()(mesh));

src/dynamicMesh/motionSolvers/displacement/displacement/displacementMotionSolver.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2016 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2016-2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2012-2016 OpenFOAM Foundation
@@ -113,12 +113,12 @@ Foam::displacementMotionSolver::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown solver type "
-            << solverTypeName << nl << nl
-            << "Valid solver types :" << endl
-            << displacementConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "solver",
+            solverTypeName,
+            *displacementConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<displacementMotionSolver>

src/dynamicMesh/motionSolvers/displacement/solidBody/solidBodyMotionFunctions/solidBodyMotionFunction/solidBodyMotionFunctionNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -43,12 +43,12 @@ Foam::autoPtr<Foam::solidBodyMotionFunction> Foam::solidBodyMotionFunction::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown solidBodyMotionFunction type "
-            << motionType << nl << nl
-            << "Valid solidBodyMotionFunction types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "solidBodyMotionFunction",
+            motionType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<solidBodyMotionFunction>(cstrIter()(SBMFCoeffs, runTime));

src/dynamicMesh/motionSolvers/motionSolver/motionSolver.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2017 OpenFOAM Foundation
@@ -134,12 +134,12 @@ Foam::autoPtr<Foam::motionSolver> Foam::motionSolver::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown solver type "
-            << solverName << nl << nl
-            << "Valid solver types :" << nl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "solver",
+            solverName,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<motionSolver>(cstrIter()(mesh, solverDict));

src/dynamicMesh/polyTopoChange/polyMeshModifier/polyMeshModifierNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -38,23 +38,21 @@ Foam::autoPtr<Foam::polyMeshModifier> Foam::polyMeshModifier::New
     const polyTopoChanger& mme
 )
 {
-    if (debug)
-    {
-        InfoInFunction << "Constructing polyMeshModifier" << endl;
-    }
+    DebugInFunction << "Constructing polyMeshModifier" << endl;
 
-    const word modifierType(dict.get<word>("type"));
+    const word modelType(dict.get<word>("type"));
 
-    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modifierType);
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(dict)
-            << "Unknown polyMeshModifier type "
-            << modifierType << nl << nl
-            << "Valid polyMeshModifier types :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            dict,
+            "polyMeshModifier",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     return autoPtr<polyMeshModifier>(cstrIter()(name, dict, index, mme));

src/engine/engineMesh/engineMesh/engineMeshNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -35,8 +35,6 @@ Foam::autoPtr<Foam::engineMesh> Foam::engineMesh::New
     const Foam::IOobject& io
 )
 {
-    // get model name, but do not register the dictionary
-    // otherwise it is registered in the database twice
     const word modelType
     (
         IOdictionary
@@ -48,9 +46,9 @@ Foam::autoPtr<Foam::engineMesh> Foam::engineMesh::New
                 io.db(),
                 IOobject::MUST_READ_IF_MODIFIED,
                 IOobject::NO_WRITE,
-                false
+                false // Do not register
             )
-        ).lookup("engineMesh")
+        ).get<word>("engineMesh")
     );
 
     Info<< "Selecting engineMesh " << modelType << endl;
@@ -59,12 +57,12 @@ Foam::autoPtr<Foam::engineMesh> Foam::engineMesh::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown engineMesh type "
-            << modelType << nl << nl
-            << "Valid engineMesh types :" << endl
-            << IOobjectConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "engineMesh",
+            modelType,
+            *IOobjectConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<engineMesh>(cstrIter()(io));

src/engine/engineTime/engineTime/engineTimeNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2017 OpenFOAM Foundation
@@ -55,12 +55,12 @@ Foam::autoPtr<Foam::engineTime> Foam::engineTime::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown engine type "
-            << engineType << nl << nl
-            << "Valid engine types are :" << nl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "engine",
+            engineType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<engineTime>

src/fileFormats/sampledSetWriters/writer.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2016 OpenFOAM Foundation
@@ -42,12 +42,12 @@ Foam::autoPtr<Foam::writer<Type>> Foam::writer<Type>::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown write type "
-            << writeType << nl << nl
-            << "Valid write types :" << endl
-            << wordConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "writer",
+            writeType,
+            *wordConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<writer<Type>>(cstrIter()());

src/finiteArea/faMesh/faPatches/faPatch/faPatchNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2016-2017 Wikki Ltd
@@ -38,8 +38,7 @@ Foam::autoPtr<Foam::faPatch> Foam::faPatch::New
     const faBoundaryMesh& bm
 )
 {
-    DebugInFunction
-        << "constructing faPatch" << endl;
+    DebugInFunction << "Constructing faPatch" << endl;
 
     const word patchType(dict.get<word>("type"));
 
@@ -47,11 +46,13 @@ Foam::autoPtr<Foam::faPatch> Foam::faPatch::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(dict)
-            << "Unknown faPatch type " << patchType << nl << nl
-            << "Valid faPatch types are :" << nl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            dict,
+            "faPatch",
+            patchType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     return autoPtr<faPatch>(cstrIter()(name, dict, index, bm));

src/finiteArea/fields/faPatchFields/faPatchField/faPatchFieldNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2016-2017 Wikki Ltd
@@ -36,19 +36,18 @@ Foam::tmp<Foam::faPatchField<Type>> Foam::faPatchField<Type>::New
     const DimensionedField<Type, areaMesh>& iF
 )
 {
-    DebugInFunction
-        << "constructing faPatchField<Type>"
-        << endl;
+    DebugInFunction << "Constructing faPatchField<Type>" << endl;
 
     auto cstrIter = patchConstructorTablePtr_->cfind(patchFieldType);
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown patchTypefield type " << patchFieldType << nl << nl
-            << "Valid patchField types are :" << nl
-            << patchConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "patchField",
+            patchFieldType,
+            *patchConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     auto patchTypeCstrIter = patchConstructorTablePtr_->cfind(p.type());
@@ -68,8 +67,8 @@ Foam::tmp<Foam::faPatchField<Type>> Foam::faPatchField<Type>::New
             return cstrIter()(p, iF);
         }
     }
-    else
-    {
+
+
     tmp<faPatchField<Type>> tfap = cstrIter()(p, iF);
 
     // Check if constraint type override and store patchType if so
@@ -79,7 +78,6 @@ Foam::tmp<Foam::faPatchField<Type>> Foam::faPatchField<Type>::New
     }
     return tfap;
 }
-}
 
 
 template<class Type>
@@ -102,9 +100,7 @@ Foam::tmp<Foam::faPatchField<Type>> Foam::faPatchField<Type>::New
     const dictionary& dict
 )
 {
-    DebugInFunction
-        << "constructing faPatchField<Type>"
-        << endl;
+    DebugInFunction << "Constructing faPatchField<Type>" << endl;
 
     const word patchFieldType(dict.get<word>("type"));
 
@@ -152,19 +148,18 @@ Foam::tmp<Foam::faPatchField<Type>> Foam::faPatchField<Type>::New
     const faPatchFieldMapper& pfMapper
 )
 {
-    DebugInFunction
-        << "constructing faPatchField<Type>"
-        << endl;
+    DebugInFunction << "Constructing faPatchField<Type>" << endl;
 
     auto cstrIter = patchMapperConstructorTablePtr_->cfind(ptf.type());
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "unknown patchTypefield type " << ptf.type() << nl << nl
-            << "Valid patchField types are :" << nl
-            << patchMapperConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "patchField",
+            ptf.type(),
+            *patchMapperConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     auto patchTypeCstrIter = patchMapperConstructorTablePtr_->cfind(p.type());
@@ -173,11 +168,9 @@ Foam::tmp<Foam::faPatchField<Type>> Foam::faPatchField<Type>::New
     {
         return patchTypeCstrIter()(ptf, p, iF, pfMapper);
     }
-    else
-    {
+
     return cstrIter()(ptf, p, iF, pfMapper);
 }
-}
 
 
 // ************************************************************************* //

src/finiteArea/fields/faePatchFields/faePatchField/faePatchFieldNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2016-2017 Wikki Ltd
@@ -35,19 +35,18 @@ Foam::tmp<Foam::faePatchField<Type>> Foam::faePatchField<Type>::New
     const DimensionedField<Type, edgeMesh>& iF
 )
 {
-    DebugInFunction
-        << "constructing faePatchField<Type>"
-        << endl;
+    DebugInFunction << "Constructing faePatchField" << endl;
 
     auto cstrIter = patchConstructorTablePtr_->cfind(patchFieldType);
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown patchTypefield type " << patchFieldType << nl << nl
-            << "Valid patchField types are :" << nl
-            << patchConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "patchField",
+            patchFieldType,
+            *patchConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     auto patchTypeCstrIter = patchConstructorTablePtr_->cfind(p.type());
@@ -71,9 +70,7 @@ Foam::tmp<Foam::faePatchField<Type>> Foam::faePatchField<Type>::New
     const dictionary& dict
 )
 {
-    DebugInFunction
-        << "constructing faePatchField<Type>"
-        << endl;
+    DebugInFunction << "Constructing faePatchField" << endl;
 
     const word patchFieldType(dict.get<word>("type"));
 
@@ -121,19 +118,18 @@ Foam::tmp<Foam::faePatchField<Type>> Foam::faePatchField<Type>::New
     const faPatchFieldMapper& pfMapper
 )
 {
-    DebugInFunction
-        << "constructing faePatchField<Type>"
-        << endl;
+    DebugInFunction << "Constructing faePatchField<Type>" << endl;
 
     auto cstrIter = patchMapperConstructorTablePtr_->cfind(ptf.type());
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "unknown patchTypefield type " << ptf.type() << endl << endl
-            << "Valid patchField types are :" << endl
-            << patchMapperConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "patchField",
+            ptf.type(),
+            *patchMapperConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     auto patchTypeCstrIter = patchMapperConstructorTablePtr_->cfind(p.type());
@@ -142,11 +138,9 @@ Foam::tmp<Foam::faePatchField<Type>> Foam::faePatchField<Type>::New
     {
         return patchTypeCstrIter()(ptf, p, iF, pfMapper);
     }
-    else
-    {
+
     return cstrIter()(ptf, p, iF, pfMapper);
 }
-}
 
 
 // ************************************************************************* //

src/finiteArea/finiteArea/convectionSchemes/faConvectionScheme/faConvectionScheme.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2016-2017 Wikki Ltd
@@ -61,11 +61,13 @@ Foam::fa::convectionScheme<Type>::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(schemeData)
-            << "Unknown convection scheme " << schemeName << nl << nl
-            << "Valid convection schemes are :" << nl
-            << IstreamConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            schemeData,
+            "convection",
+            schemeName,
+            *IstreamConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     return cstrIter()(mesh, faceFlux, schemeData);

src/finiteArea/finiteArea/d2dt2Schemes/faD2dt2Scheme/faD2dt2Scheme.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2017 Volkswagen AG
@@ -72,11 +72,13 @@ tmp<faD2dt2Scheme<Type>> faD2dt2Scheme<Type>::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(schemeData)
-            << "Unknown d2dt2 scheme " << schemeName << nl << nl
-            << "Valid d2dt2 schemes are :" << endl
-            << IstreamConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            schemeData,
+            "d2dt2",
+            schemeName,
+            *IstreamConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     return cstrIter()(mesh, schemeData);

src/finiteArea/finiteArea/ddtSchemes/faDdtScheme/faDdtScheme.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2016-2017 Wikki Ltd
@@ -69,11 +69,13 @@ tmp<faDdtScheme<Type>> faDdtScheme<Type>::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(schemeData)
-            << "Unknown ddt scheme " << schemeName << nl << nl
-            << "Valid ddt schemes are :" << nl
-            << IstreamConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            schemeData,
+            "ddt",
+            schemeName,
+            *IstreamConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     return cstrIter()(mesh, schemeData);

src/finiteArea/finiteArea/divSchemes/faDivScheme/faDivScheme.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2016-2017 Wikki Ltd
@@ -70,12 +70,13 @@ tmp<divScheme<Type>> divScheme<Type>::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(schemeData)
-            << "Unknown div scheme "
-            << schemeName << nl << nl
-            << "Valid div schemes are :" << nl
-            << IstreamConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            schemeData,
+            "div",
+            schemeName,
+            *IstreamConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     return cstrIter()(mesh, schemeData);

src/finiteArea/finiteArea/gradSchemes/faGradScheme/faGradScheme.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2016-2017 Wikki Ltd
@@ -69,11 +69,13 @@ tmp<gradScheme<Type>> gradScheme<Type>::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(schemeData)
-            << "Unknown grad scheme " << schemeName << nl << nl
-            << "Valid grad schemes are :" << nl
-            << IstreamConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            schemeData,
+            "grad",
+            schemeName,
+            *IstreamConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     return cstrIter()(mesh, schemeData);

src/finiteArea/finiteArea/laplacianSchemes/faLaplacianScheme/faLaplacianScheme.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2016-2017 Wikki Ltd
@@ -70,11 +70,13 @@ tmp<laplacianScheme<Type>> laplacianScheme<Type>::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(schemeData)
-            << "Unknown laplacian scheme " << schemeName << nl << nl
-            << "Valid laplacian schemes are :" << nl
-            << IstreamConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            schemeData,
+            "laplacian",
+            schemeName,
+            *IstreamConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     return cstrIter()(mesh, schemeData);

src/finiteArea/finiteArea/lnGradSchemes/lnGradScheme/lnGradScheme.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2016-2017 Wikki Ltd
@@ -60,7 +60,7 @@ tmp<lnGradScheme<Type>> lnGradScheme<Type>::New
     if (schemeData.eof())
     {
         FatalIOErrorInFunction(schemeData)
-            << "Discretisation scheme not specified" << nl << nl
+            << "Grad scheme not specified" << nl << nl
             << "Valid schemes are :" << endl
             << MeshConstructorTablePtr_->sortedToc()
             << exit(FatalIOError);
@@ -72,12 +72,13 @@ tmp<lnGradScheme<Type>> lnGradScheme<Type>::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(schemeData)
-            << "Unknown discretisation scheme "
-            << schemeName << nl << nl
-            << "Valid schemes are :" << nl
-            << MeshConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            schemeData,
+            "grad",
+            schemeName,
+            *MeshConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     return cstrIter()(mesh, schemeData);

src/finiteArea/interpolation/edgeInterpolation/edgeInterpolationScheme/edgeInterpolationScheme.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2016-2017 Wikki Ltd
@@ -64,12 +64,13 @@ Foam::edgeInterpolationScheme<Type>::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(schemeData)
-            << "Unknown discretisation scheme "
-            << schemeName << nl << nl
-            << "Valid schemes are :" << nl
-            << MeshConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            schemeData,
+            "discretisation",
+            schemeName,
+            *MeshConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     return cstrIter()(mesh, schemeData);
@@ -108,12 +109,13 @@ Foam::edgeInterpolationScheme<Type>::New
 
     if (!cstrIter.found())
     {
-        FatalIOErrorInFunction(schemeData)
-            << "Unknown discretisation scheme "
-            << schemeName << nl << nl
-            << "Valid schemes are :" << endl
-            << MeshFluxConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
+        FatalIOErrorInLookup
+        (
+            schemeData,
+            "discretisation",
+            schemeName,
+            *MeshFluxConstructorTablePtr_
+        ) << exit(FatalIOError);
     }
 
     return cstrIter()(mesh, faceFlux, schemeData);

src/finiteVolume/cfdTools/general/SRF/SRFModel/SRFModel/SRFModelNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2015 OpenFOAM Foundation
@@ -34,8 +34,6 @@ Foam::autoPtr<Foam::SRF::SRFModel> Foam::SRF::SRFModel::New
     const volVectorField& Urel
 )
 {
-    // get model name, but do not register the dictionary
-    // otherwise it is registered in the database twice
     const word modelType
     (
         IOdictionary
@@ -47,9 +45,9 @@ Foam::autoPtr<Foam::SRF::SRFModel> Foam::SRF::SRFModel::New
                 Urel.db(),
                 IOobject::MUST_READ_IF_MODIFIED,
                 IOobject::NO_WRITE,
-                false
+                false // Do not register
             )
-        ).lookup("SRFModel")
+        ).get<word>("SRFModel")
     );
 
     Info<< "Selecting SRFModel " << modelType << endl;
@@ -58,12 +56,12 @@ Foam::autoPtr<Foam::SRF::SRFModel> Foam::SRF::SRFModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown SRFModel type "
-            << modelType << nl << nl
-            << "Valid SRFModel types :" << nl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "SRFModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<SRFModel>(cstrIter()(Urel));

src/finiteVolume/cfdTools/general/fvOptions/fvOption.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2011-2017 OpenFOAM Foundation
@@ -88,12 +88,12 @@ Foam::autoPtr<Foam::fv::option> Foam::fv::option::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown fvOption model type "
-            << modelType << nl << nl
-            << "Valid fvOption types are:" << nl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            "fvOption",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<option>(cstrIter()(name, modelType, coeffs, mesh));

src/finiteVolume/cfdTools/general/porosityModel/porosityModel/porosityModelNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           |
+    \\  /    A nd           | Copyright (C) 2019 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
                             | Copyright (C) 2012-2015 OpenFOAM Foundation
@@ -46,11 +46,12 @@ Foam::autoPtr<Foam::porosityModel> Foam::porosityModel::New
 
     if (!cstrIter.found())
     {
-        FatalErrorInFunction
-            << "Unknown " << typeName << " type " << modelType << nl << nl
-            << "Valid types are:" << nl
-            << meshConstructorTablePtr_->sortedToc()
-            << exit(FatalError);
+        FatalErrorInLookup
+        (
+            typeName,
+            modelType,
+            *meshConstructorTablePtr_
+        ) << exit(FatalError);
     }
 
     return autoPtr<porosityModel>