zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-12-28 03:37:59 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

ENH: use FatalErrorInLookup macros (#1362)

Browse Source
This commit is contained in:
Mark Olesen
2019-07-12 18:00:00 +02:00
committed by Andrew Heather
parent 1d86fc4f6b
commit fb09f56aba
290 changed files with 2634 additions and 2736 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
applications/solvers/combustion/PDRFoam/PDRModels/dragModels/PDRDragModel/PDRDragModelNew.C
View File

@ -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>

14
applications/solvers/combustion/PDRFoam/XiModels/XiEqModels/XiEqModel/XiEqModelNew.C
View File

@ -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));

14
applications/solvers/combustion/PDRFoam/XiModels/XiGModels/XiGModel/XiGModelNew.C
View File

@ -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));

14
applications/solvers/combustion/PDRFoam/XiModels/XiModel/XiModelNew.C
View File

@ -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>

14
applications/solvers/multiphase/driftFluxFoam/mixtureViscosityModels/mixtureViscosityModel/mixtureViscosityModelNew.C
View File

@ -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>

14
applications/solvers/multiphase/driftFluxFoam/relativeVelocityModels/relativeVelocityModel/relativeVelocityModel.C
View File

@ -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

14
applications/solvers/multiphase/icoReactingMultiphaseInterFoam/laserDTRM/reflectionModel/reflectionModel/reflectionModelNew.C
View File

@ -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));

21
applications/solvers/multiphase/icoReactingMultiphaseInterFoam/massTransferModels/interfaceCompositionModel/interfaceCompositionModelNew.C
View File

@ -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);

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

@ -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);

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

@ -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);

14
applications/solvers/multiphase/icoReactingMultiphaseInterFoam/phasesSystem/phaseModel/phaseModel/phaseModelNew.C
View File

@ -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);

23
applications/solvers/multiphase/icoReactingMultiphaseInterFoam/phasesSystem/phaseSystem/multiphaseSystem/multiphaseSystemNew.C
View File

@ -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,22 +48,21 @@ 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));
return autoPtr<multiphaseSystem>(cstrIter()(mesh));
}

47
applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/temperaturePhaseChangeTwoPhaseMixtures/newtemperaturePhaseChangeTwoPhaseMixture.C
View File

@ -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,22 +35,20 @@ Foam::temperaturePhaseChangeTwoPhaseMixture::New
const fvMesh& mesh
)
{
IOdictionary phaseChangePropertiesDict
(
IOobject
(
"phaseChangeProperties",
mesh.time().constant(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
);
const word modelType
(
phaseChangePropertiesDict.get<word>("phaseChangeTwoPhaseModel")
IOdictionary
(
IOobject
(
"phaseChangeProperties",
mesh.time().constant(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false // Do not register
)
).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)
);
}

40
applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/phaseChangeTwoPhaseMixture/newPhaseChangeTwoPhaseMixture.C
View File

@ -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,22 +37,20 @@ Foam::phaseChangeTwoPhaseMixture::New
const surfaceScalarField& phi
)
{
IOdictionary transportPropertiesDict
(
IOobject
(
"transportProperties",
U.time().constant(),
U.db(),
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
);
const word modelType
(
transportPropertiesDict.lookup("phaseChangeTwoPhaseMixture")
IOdictionary
(
IOobject
(
"transportProperties",
U.time().constant(),
U.db(),
IOobject::MUST_READ,
IOobject::NO_WRITE,
false // Do not register
)
).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));

14
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/dragModels/dragModel/newDragModel.C
View File

@ -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);

16
applications/solvers/multiphase/multiphaseEulerFoam/interfacialModels/heatTransferModels/heatTransferModel/newHeatTransferModel.C
View File

@ -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);

14
applications/solvers/multiphase/multiphaseEulerFoam/multiphaseSystem/diameterModels/diameterModel/newDiameterModel.C
View File

@ -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()

40
applications/solvers/multiphase/reactingEulerFoam/functionObjects/sizeDistribution/sizeDistribution.C
View File

@ -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);
}
}
}

14
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/aspectRatioModel/newAspectRatioModel.C
View File

@ -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);

14
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/dragModel/newDragModel.C
View File

@ -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);

14
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/heatTransferModels/heatTransferModel/newHeatTransferModel.C
View File

@ -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);

14
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/liftModels/liftModel/newLiftModel.C
View File

@ -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);

14
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/swarmCorrections/swarmCorrection/newSwarmCorrection.C
View File

@ -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);

14
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/turbulentDispersionModels/turbulentDispersionModel/newTurbulentDispersionModel.C
View File

@ -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);

14
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/virtualMassModels/virtualMassModel/newVirtualMassModel.C
View File

@ -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);

14
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/wallLubricationModels/wallLubricationModel/newWallLubricationModel.C
View File

@ -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);

14
applications/solvers/multiphase/twoPhaseEulerFoam/phaseCompressibleTurbulenceModels/kineticTheoryModels/conductivityModel/conductivityModel/newConductivityModel.C
View File

@ -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));

14
applications/solvers/multiphase/twoPhaseEulerFoam/phaseCompressibleTurbulenceModels/kineticTheoryModels/frictionalStressModel/frictionalStressModel/newFrictionalStressModel.C
View File

@ -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));

14
applications/solvers/multiphase/twoPhaseEulerFoam/phaseCompressibleTurbulenceModels/kineticTheoryModels/granularPressureModel/granularPressureModel/newGranularPressureModel.C
View File

@ -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));

14
applications/solvers/multiphase/twoPhaseEulerFoam/phaseCompressibleTurbulenceModels/kineticTheoryModels/radialModel/radialModel/newRadialModel.C
View File

@ -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));

20
applications/solvers/multiphase/twoPhaseEulerFoam/phaseCompressibleTurbulenceModels/kineticTheoryModels/viscosityModel/viscosityModel/newViscosityModel.C
View File

@ -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));

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

@ -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);

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

@ -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));

14
applications/solvers/multiphase/twoPhaseEulerFoam/twoPhaseSystem/diameterModels/diameterModel/newDiameterModel.C
View File

@ -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()

28
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl.C
View File

@ -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
)

28
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.C
View File

@ -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

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

@ -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)
);
}

27
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/surfaceCellSizeFunction/surfaceCellSizeFunction.C
View File

@ -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)
);
}

14
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/faceAreaWeightModel/faceAreaWeightModel/faceAreaWeightModel.C
View File

@ -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));

21
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/initialPointsMethod/initialPointsMethod/initialPointsMethod.C
View File

@ -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

14
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/relaxationModel/relaxationModel/relaxationModel.C
View File

@ -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));

18
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/searchableSurfaceFeatures/searchableSurfaceFeatures.C
View File

@ -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));

18
applications/utilities/mesh/manipulation/createBaffles/faceSelection/faceSelection.C
View File

@ -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));

13
applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunctionNew.C
View File

@ -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));

16
applications/utilities/surface/surfaceFeatureExtract/extractionMethod/surfaceFeaturesExtraction.C
View File

@ -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));

14
applications/utilities/surface/surfacePatch/searchableSurfaceModifier/searchableSurfaceModifier.C
View File

@ -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));