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

applications: Update ...ErrorIn -> ...ErrorInFunction

Browse Source 
Avoids the clutter and maintenance effort associated with providing the
function signature string.
This commit is contained in:
Henry Weller
2015-11-10 17:53:31 +00:00
parent 735ce9cce7
commit e2ef006b91
271 changed files with 851 additions and 1559 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
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 | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -45,10 +45,8 @@ Foam::autoPtr<Foam::PDRDragModel> Foam::PDRDragModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn
(
"PDRDragModel::New"
) << "Unknown PDRDragModel type "
FatalErrorInFunction
<< "Unknown PDRDragModel type "
<< modelType << nl << nl
<< "Valid PDRDragModels are : " << endl
<< dictionaryConstructorTablePtr_->sortedToc()

13
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 | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -44,15 +44,8 @@ Foam::autoPtr<Foam::XiEqModel> Foam::XiEqModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn
(
"XiEqModel::New"
"("
" const psiuReactionThermo& thermo,"
" const compressible::RASModel& turbulence,"
" const volScalarField& Su"
")"
) << "Unknown XiEqModel type "
FatalErrorInFunction
<< "Unknown XiEqModel type "
<< modelType << nl << nl
<< "Valid XiEqModels are : " << endl
<< dictionaryConstructorTablePtr_->sortedToc()

13
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 | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -44,15 +44,8 @@ Foam::autoPtr<Foam::XiGModel> Foam::XiGModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn
(
"XiGModel::New"
"("
" const psiuReactionThermo& thermo,"
" const compressible::RASModel& turbulence,"
" const volScalarField& Su"
")"
) << "Unknown XiGModel type "
FatalErrorInFunction
<< "Unknown XiGModel type "
<< modelType << nl << nl
<< "Valid XiGModels are : " << endl
<< dictionaryConstructorTablePtr_->sortedToc()

8
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 | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -47,10 +47,8 @@ Foam::autoPtr<Foam::XiModel> Foam::XiModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn
(
"XiModel::New"
) << "Unknown XiModel type "
FatalErrorInFunction
<< "Unknown XiModel type "
<< modelType << nl << nl
<< "Valid XiModels are : " << endl
<< dictionaryConstructorTablePtr_->sortedToc()

6
applications/solvers/combustion/PDRFoam/laminarFlameSpeed/SCOPE/SCOPELaminarFlameSpeed.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -172,7 +172,7 @@ inline Foam::scalar Foam::laminarFlameSpeedModels::SCOPE::SuRef
}
else
{
FatalErrorIn("laminarFlameSpeedModels::SCOPE::SuRef(scalar phi)")
FatalErrorInFunction
<< "phi = " << phi
<< " cannot be handled by SCOPE function with the "
"given coefficients"
@ -210,7 +210,7 @@ inline Foam::scalar Foam::laminarFlameSpeedModels::SCOPE::Ma
}
else
{
FatalErrorIn("laminarFlameSpeedModels::SCOPE::Ma(scalar phi)")
FatalErrorInFunction
<< "phi = " << phi
<< " cannot be handled by SCOPE function with the "
"given coefficients"

2
applications/solvers/combustion/chemFoam/createFields.H
View File

@ -1,6 +1,6 @@
if (mesh.nCells() != 1)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Solver only applicable to single cell cases"
<< exit(FatalError);
}

9
applications/solvers/compressible/rhoCentralFoam/BCs/T/smoluchowskiJumpTFvPatchScalarField.C
View File

@ -94,15 +94,8 @@ Foam::smoluchowskiJumpTFvPatchScalarField::smoluchowskiJumpTFvPatchScalarField
|| mag(accommodationCoeff_) > 2.0
)
{
FatalIOErrorIn
FatalIOErrorInFunction
(
"smoluchowskiJumpTFvPatchScalarField::"
"smoluchowskiJumpTFvPatchScalarField"
"("
" const fvPatch&,"
" const DimensionedField<scalar, volMesh>&,"
" const dictionary&"
")",
dict
) << "unphysical accommodationCoeff specified"
<< "(0 < accommodationCoeff <= 1)" << endl

10
applications/solvers/compressible/rhoCentralFoam/BCs/U/maxwellSlipUFvPatchVectorField.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -96,14 +96,8 @@ Foam::maxwellSlipUFvPatchVectorField::maxwellSlipUFvPatchVectorField
|| mag(accommodationCoeff_) > 2.0
)
{
FatalIOErrorIn
FatalIOErrorInFunction
(
"maxwellSlipUFvPatchScalarField::maxwellSlipUFvPatchScalarField"
"("
"const fvPatch&, "
"const DimensionedField<vector, volMesh>&, "
"const dictionary&"
")",
dict
) << "unphysical accommodationCoeff_ specified"
<< "(0 < accommodationCoeff_ <= 1)" << endl

6
applications/solvers/compressible/rhoCentralFoam/readFluxScheme.H
View File

@ -7,10 +7,8 @@ if (mesh.schemesDict().readIfPresent("fluxScheme", fluxScheme))
}
else
{
FatalErrorIn
(
"rhoCentralFoam::readFluxScheme"
) << "fluxScheme: " << fluxScheme
FatalErrorInFunction
<< "fluxScheme: " << fluxScheme
<< " is not a valid choice. "
<< "Options are: Tadmor, Kurganov"
<< abort(FatalError);

6
applications/solvers/incompressible/boundaryFoam/interrogateWallPatches.H
View File

@ -36,7 +36,7 @@ forAll(patches, patchi)
|| mag(wallNormal & wallNormal2) < 0.99
)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "wall faces are not parallel for patches "
<< patches[patchId].name() << " and "
<< currPatch.name() << nl
@ -45,7 +45,7 @@ forAll(patches, patchi)
}
else
{
FatalErrorIn(args.executable()) << "number of wall faces > 2"
FatalErrorInFunction
<< nl << exit(FatalError);
}
}
@ -54,7 +54,7 @@ forAll(patches, patchi)
if (nWallFaces == 0)
{
FatalErrorIn(args.executable()) << "No wall patches identified"
FatalErrorInFunction
<< exit(FatalError);
}
else

2
applications/solvers/lagrangian/coalChemistryFoam/createFields.H
View File

@ -17,7 +17,7 @@ const word inertSpecie(thermo.lookup("inertSpecie"));
if (!composition.contains(inertSpecie))
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Specified inert specie '" << inertSpecie << "' not found in "
<< "species list. Available species:" << composition.species()
<< exit(FatalError);

2
applications/solvers/lagrangian/reactingParcelFoam/createFields.H
View File

@ -17,7 +17,7 @@ const word inertSpecie(thermo.lookup("inertSpecie"));
if (!composition.contains(inertSpecie))
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Specified inert specie '" << inertSpecie << "' not found in "
<< "species list. Available species:" << composition.species()
<< exit(FatalError);

2
applications/solvers/lagrangian/reactingParcelFoam/simpleReactingParcelFoam/createFields.H
View File

@ -17,7 +17,7 @@ const word inertSpecie(thermo.lookup("inertSpecie"));
if (!composition.contains(inertSpecie))
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Specified inert specie '" << inertSpecie << "' not found in "
<< "species list. Available species:" << composition.species()
<< exit(FatalError);

2
applications/solvers/lagrangian/sprayFoam/createFields.H
View File

@ -17,7 +17,7 @@ const word inertSpecie(thermo.lookup("inertSpecie"));
if (!composition.contains(inertSpecie))
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Specified inert specie '" << inertSpecie << "' not found in "
<< "species list. Available species:" << composition.species()
<< exit(FatalError);

14
applications/solvers/multiphase/compressibleMultiphaseInterFoam/multiphaseMixtureThermo/multiphaseMixtureThermo.C
View File

@ -717,10 +717,8 @@ Foam::multiphaseMixtureThermo::surfaceTensionForce() const
if (sigma == sigmas_.end())
{
FatalErrorIn
(
"multiphaseMixtureThermo::surfaceTensionForce() const"
) << "Cannot find interface " << interfacePair(alpha1, alpha2)
FatalErrorInFunction
<< "Cannot find interface " << interfacePair(alpha1, alpha2)
<< " in list of sigma values"
<< exit(FatalError);
}
@ -848,12 +846,8 @@ void Foam::multiphaseMixtureThermo::correctContactAngle
if (tp == acap.thetaProps().end())
{
FatalErrorIn
(
"multiphaseMixtureThermo::correctContactAngle"
"(const phaseModel& alpha1, const phaseModel& alpha2, "
"fvPatchVectorFieldField& nHatb) const"
) << "Cannot find interface " << interfacePair(alpha1, alpha2)
FatalErrorInFunction
<< "Cannot find interface " << interfacePair(alpha1, alpha2)
<< "\n in table of theta properties for patch "
<< acap.patch().name()
<< exit(FatalError);

9
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 | Copyright (C) 2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -46,11 +46,8 @@ Foam::autoPtr<Foam::mixtureViscosityModel> Foam::mixtureViscosityModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn
(
"mixtureViscosityModel::New(const volVectorField&, "
"const surfaceScalarField&)"
) << "Unknown mixtureViscosityModel type "
FatalErrorInFunction
<< "Unknown mixtureViscosityModel type "
<< modelType << nl << nl
<< "Valid mixtureViscosityModels are : " << endl
<< dictionaryConstructorTablePtr_->sortedToc()

11
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 | Copyright (C) 2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -82,13 +82,8 @@ Foam::autoPtr<Foam::relativeVelocityModel> Foam::relativeVelocityModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn
(
"relativeVelocityModel::New"
"("
"const dictionary&"
")"
) << "Unknown time scale model type " << modelType
FatalErrorInFunction
<< "Unknown time scale model type " << modelType
<< ", constructor not in hash table" << nl << nl
<< " Valid time scale model types are:" << nl
<< dictionaryConstructorTablePtr_->sortedToc()

4
applications/solvers/multiphase/interFoam/alphaEqn.H
View File

@ -25,7 +25,7 @@
{
if (nAlphaSubCycles > 1)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Sub-cycling is not supported "
"with the CrankNicolson ddt scheme"
<< exit(FatalError);
@ -36,7 +36,7 @@
}
else
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Only Euler and CrankNicolson ddt schemes are supported"
<< exit(FatalError);
}

8
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 | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -62,10 +62,8 @@ Foam::phaseChangeTwoPhaseMixture::New
if (cstrIter == componentsConstructorTablePtr_->end())
{
FatalErrorIn
(
"phaseChangeTwoPhaseMixture::New"
) << "Unknown phaseChangeTwoPhaseMixture type "
FatalErrorInFunction
<< "Unknown phaseChangeTwoPhaseMixture type "
<< phaseChangeTwoPhaseMixtureTypeName << endl << endl
<< "Valid phaseChangeTwoPhaseMixtures are : " << endl
<< componentsConstructorTablePtr_->sortedToc()

4
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 | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -46,7 +46,7 @@ Foam::autoPtr<Foam::dragModel> Foam::dragModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("dragModel::New")
FatalErrorInFunction
<< "Unknown dragModelType type "
<< dragModelType << endl << endl
<< "Valid dragModel types are : " << endl

4
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 | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -50,7 +50,7 @@ Foam::autoPtr<Foam::heatTransferModel> Foam::heatTransferModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("heatTransferModel::New")
FatalErrorInFunction
<< "Unknown heatTransferModelType type "
<< heatTransferModelType << endl << endl
<< "Valid heatTransferModel types are : " << endl

4
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 | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -48,7 +48,7 @@ Foam::autoPtr<Foam::diameterModel> Foam::diameterModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("diameterModel::New")
FatalErrorInFunction
<< "Unknown diameterModelType type "
<< diameterModelType << endl << endl
<< "Valid diameterModel types are : " << endl

16
applications/solvers/multiphase/multiphaseEulerFoam/multiphaseSystem/multiphaseSystem.C
View File

@ -295,12 +295,8 @@ void Foam::multiphaseSystem::correctContactAngle
if (tp == acap.thetaProps().end())
{
FatalErrorIn
(
"multiphaseSystem::correctContactAngle"
"(const phaseModel& phase1, const phaseModel& phase2, "
"fvPatchVectorFieldField& nHatb) const"
) << "Cannot find interface " << interfacePair(phase1, phase2)
FatalErrorInFunction
<< "Cannot find interface " << interfacePair(phase1, phase2)
<< "\n in table of theta properties for patch "
<< acap.patch().name()
<< exit(FatalError);
@ -478,12 +474,8 @@ Foam::multiphaseSystem::multiphaseSystem
if (cAlpha == cAlphas_.end())
{
WarningIn
(
"multiphaseSystem::multiphaseSystem"
"(const volVectorField& U,"
"const surfaceScalarField& phi)"
) << "Compression coefficient not specified for "
WarningInFunction
<< "Compression coefficient not specified for "
"phase pair ("
<< phase1.name() << ' ' << phase2.name()
<< ") for which a surface tension "

10
applications/solvers/multiphase/multiphaseInterFoam/multiphaseMixture/multiphaseMixture.C
View File

@ -288,7 +288,7 @@ Foam::multiphaseMixture::surfaceTensionForce() const
if (sigma == sigmas_.end())
{
FatalErrorIn("multiphaseMixture::surfaceTensionForce() const")
FatalErrorInFunction
<< "Cannot find interface " << interfacePair(alpha1, alpha2)
<< " in list of sigma values"
<< exit(FatalError);
@ -442,12 +442,8 @@ void Foam::multiphaseMixture::correctContactAngle
if (tp == acap.thetaProps().end())
{
FatalErrorIn
(
"multiphaseMixture::correctContactAngle"
"(const phase& alpha1, const phase& alpha2, "
"fvPatchVectorFieldField& nHatb) const"
) << "Cannot find interface " << interfacePair(alpha1, alpha2)
FatalErrorInFunction
<< "Cannot find interface " << interfacePair(alpha1, alpha2)
<< "\n in table of theta properties for patch "
<< acap.patch().name()
<< exit(FatalError);

12
applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/interfaceCompositionModels/Henry/Henry.C
View File

@ -50,16 +50,8 @@ Foam::interfaceCompositionModels::Henry<Thermo, OtherThermo>::Henry
{
if (k_.size() != this->speciesNames_.size())
{
FatalErrorIn
(
"template<class Thermo, class OtherThermo> "
"Foam::interfaceCompositionModels::Henry<Thermo, OtherThermo>:: "
"Henry "
"( "
"const dictionary& dict, "
"const phasePair& pair "
")"
) << "Differing number of species and solubilities"
FatalErrorInFunction
<< "Differing number of species and solubilities"
<< exit(FatalError);
}
}

13
applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/interfaceCompositionModels/NonRandomTwoLiquid/NonRandomTwoLiquid.C
View File

@ -63,17 +63,8 @@ NonRandomTwoLiquid
{
if (this->speciesNames_.size() != 2)
{
FatalErrorIn
(
"template<class Thermo, class OtherThermo>"
"Foam::interfaceCompositionModels::"
"NonRandomTwoLiquid<Thermo, OtherThermo>::"
"NonRandomTwoLiquid"
"( "
"const dictionary& dict, "
"const phasePair& pair "
")"
) << "NonRandomTwoLiquid model is suitable for two species only."
FatalErrorInFunction
<< "NonRandomTwoLiquid model is suitable for two species only."
<< exit(FatalError);
}

12
applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/interfaceCompositionModels/Saturated/Saturated.C
View File

@ -64,16 +64,8 @@ Foam::interfaceCompositionModels::Saturated<Thermo, OtherThermo>::Saturated
{
if (this->speciesNames_.size() != 1)
{
FatalErrorIn
(
"template<class Thermo, class OtherThermo>"
"Foam::interfaceCompositionModels::Saturated<Thermo, OtherThermo>::"
"Saturated"
"( "
"const dictionary& dict, "
"const phasePair& pair "
")"
) << "Saturated model is suitable for one species only."
FatalErrorInFunction
<< "Saturated model is suitable for one species only."
<< exit(FatalError);
}
}

2
applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/interfaceCompositionModels/interfaceCompositionModel/newInterfaceCompositionModel.C
View File

@ -54,7 +54,7 @@ Foam::interfaceCompositionModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("interfaceCompositionModel::New")
FatalErrorInFunction
<< "Unknown interfaceCompositionModelType type "
<< interfaceCompositionModelType << endl << endl
<< "Valid interfaceCompositionModel types are : " << endl

2
applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/massTransferModels/massTransferModel/newMassTransferModel.C
View File

@ -44,7 +44,7 @@ Foam::autoPtr<Foam::massTransferModel> Foam::massTransferModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("massTransferModel::New")
FatalErrorInFunction
<< "Unknown massTransferModelType type "
<< massTransferModelType << endl << endl
<< "Valid massTransferModel types are : " << endl

2
applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/saturationModels/saturationModel/newSaturationModel.C
View File

@ -42,7 +42,7 @@ Foam::autoPtr<Foam::saturationModel> Foam::saturationModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("saturationModel::New")
FatalErrorInFunction
<< "Unknown saturationModelType type "
<< saturationModelType << endl << endl
<< "Valid saturationModel types are : " << endl

2
applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/surfaceTensionModel/newSurfaceTensionModel.C
View File

@ -45,7 +45,7 @@ Foam::surfaceTensionModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("surfaceTensionModel::New")
FatalErrorInFunction
<< "Unknown surfaceTensionModelType type "
<< surfaceTensionModelType << endl << endl
<< "Valid surfaceTensionModel types are : " << endl

2
applications/solvers/multiphase/reactingEulerFoam/interfacialModels/aspectRatioModels/aspectRatioModel/newAspectRatioModel.C
View File

@ -45,7 +45,7 @@ Foam::aspectRatioModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("aspectRatioModel::New")
FatalErrorInFunction
<< "Unknown aspectRatioModelType type "
<< aspectRatioModelType << endl << endl
<< "Valid aspectRatioModel types are : " << endl

2
applications/solvers/multiphase/reactingEulerFoam/interfacialModels/dragModels/dragModel/newDragModel.C
View File

@ -44,7 +44,7 @@ Foam::autoPtr<Foam::dragModel> Foam::dragModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("dragModel::New")
FatalErrorInFunction
<< "Unknown dragModelType type "
<< dragModelType << endl << endl
<< "Valid dragModel types are : " << endl

2
applications/solvers/multiphase/reactingEulerFoam/interfacialModels/dragModels/segregated/segregated.C
View File

@ -66,7 +66,7 @@ Foam::dragModels::segregated::~segregated()
Foam::tmp<Foam::volScalarField> Foam::dragModels::segregated::CdRe() const
{
FatalErrorIn("Foam::dragModels::segregated::CdRe() const")
FatalErrorInFunction
<< "Not implemented."
<< "Drag coefficient not defined for the segregated model."
<< exit(FatalError);

2
applications/solvers/multiphase/reactingEulerFoam/interfacialModels/heatTransferModels/heatTransferModel/newHeatTransferModel.C
View File

@ -44,7 +44,7 @@ Foam::autoPtr<Foam::heatTransferModel> Foam::heatTransferModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("heatTransferModel::New")
FatalErrorInFunction
<< "Unknown heatTransferModelType type "
<< heatTransferModelType << endl << endl
<< "Valid heatTransferModel types are : " << endl

7
applications/solvers/multiphase/reactingEulerFoam/interfacialModels/liftModels/Moraga/Moraga.C
View File

@ -79,11 +79,8 @@ Foam::tmp<Foam::volScalarField> Foam::liftModels::Moraga::Cl() const
|| max(sqrSr).value() > 0.04
)
{
WarningIn
(
"Foam::tmp<Foam::volScalarField> "
"Foam::liftModels::Moraga::Cl() const"
) << "Re and/or Sr are out of the range of applicability of the "
WarningInFunction
<< "Re and/or Sr are out of the range of applicability of the "
<< "Moraga model. Clamping to range bounds"
<< endl;
}

2
applications/solvers/multiphase/reactingEulerFoam/interfacialModels/liftModels/liftModel/newLiftModel.C
View File

@ -44,7 +44,7 @@ Foam::autoPtr<Foam::liftModel> Foam::liftModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("liftModel::New")
FatalErrorInFunction
<< "Unknown liftModelType type "
<< liftModelType << endl << endl
<< "Valid liftModel types are : " << endl

2
applications/solvers/multiphase/reactingEulerFoam/interfacialModels/swarmCorrections/swarmCorrection/newSwarmCorrection.C
View File

@ -45,7 +45,7 @@ Foam::swarmCorrection::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("swarmCorrection::New")
FatalErrorInFunction
<< "Unknown swarmCorrectionType type "
<< swarmCorrectionType << endl << endl
<< "Valid swarmCorrection types are : " << endl

2
applications/solvers/multiphase/reactingEulerFoam/interfacialModels/turbulentDispersionModels/turbulentDispersionModel/newTurbulentDispersionModel.C
View File

@ -45,7 +45,7 @@ Foam::turbulentDispersionModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("turbulentDispersionModel::New")
FatalErrorInFunction
<< "Unknown turbulentDispersionModelType type "
<< turbulentDispersionModelType << endl << endl
<< "Valid turbulentDispersionModel types are : " << endl

2
applications/solvers/multiphase/reactingEulerFoam/interfacialModels/virtualMassModels/virtualMassModel/newVirtualMassModel.C
View File

@ -44,7 +44,7 @@ Foam::autoPtr<Foam::virtualMassModel> Foam::virtualMassModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("virtualMassModel::New")
FatalErrorInFunction
<< "Unknown virtualMassModelType type "
<< virtualMassModelType << endl << endl
<< "Valid virtualMassModel types are : " << endl

2
applications/solvers/multiphase/reactingEulerFoam/interfacialModels/wallLubricationModels/wallLubricationModel/newWallLubricationModel.C
View File

@ -44,7 +44,7 @@ Foam::autoPtr<Foam::wallLubricationModel> Foam::wallLubricationModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("wallLubricationModel::New")
FatalErrorInFunction
<< "Unknown wallLubricationModelType type "
<< wallLubricationModelType << endl << endl
<< "Valid wallLubricationModel types are : " << endl

2
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/BlendedInterfacialModel/blendingMethods/blendingMethod/newBlendingMethod.C
View File

@ -43,7 +43,7 @@ Foam::autoPtr<Foam::blendingMethod> Foam::blendingMethod::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("blendingMethod::New")
FatalErrorInFunction
<< "Unknown blendingMethodType type "
<< blendingMethodType << endl << endl
<< "Valid blendingMethod types are : " << endl

10
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/BlendedInterfacialModel/blendingMethods/linear/linear.C
View File

@ -93,14 +93,8 @@ Foam::blendingMethods::linear::linear
< minPartlyContinuousAlpha_[*iter]
)
{
FatalErrorIn
(
"Foam::blendingMethods::linear::linear"
"("
"const dictionary& dict,"
"const wordList& phaseNames"
")"
) << "The supplied fully continuous volume fraction for "
FatalErrorInFunction
<< "The supplied fully continuous volume fraction for "
<< *iter
<< " is less than the partly continuous value."
<< endl << exit(FatalError);

2
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/diameterModels/diameterModel/newDiameterModel.C
View File

@ -48,7 +48,7 @@ Foam::autoPtr<Foam::diameterModel> Foam::diameterModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("diameterModel::New")
FatalErrorInFunction
<< "Unknown diameterModelType type "
<< diameterModelType << endl << endl
<< "Valid diameterModel types are : " << endl

2
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/phaseModel/phaseModel/newPhaseModel.C
View File

@ -45,7 +45,7 @@ Foam::autoPtr<Foam::phaseModel> Foam::phaseModel::New
if (cstrIter == phaseSystemConstructorTablePtr_->end())
{
FatalErrorIn("phaseModel::New")
FatalErrorInFunction
<< "Unknown phaseModelType type "
<< phaseModelType << endl << endl
<< "Valid phaseModel types are : " << endl

4
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/phaseModel/phaseModel/phaseModel.C
View File

@ -175,7 +175,7 @@ const Foam::tmp<Foam::volScalarField>& Foam::phaseModel::divU() const
void Foam::phaseModel::divU(const tmp<volScalarField>& divU)
{
WarningIn("phaseModel::divU(const tmp<volScalarField>& divU)")
WarningInFunction
<< "Attempt to set the dilatation rate of an incompressible phase"
<< endl;
}
@ -196,7 +196,7 @@ const Foam::surfaceScalarField& Foam::phaseModel::DbyA() const
void Foam::phaseModel::DbyA(const tmp<surfaceScalarField>& DbyA)
{
WarningIn("phaseModel::DbyA(const surfaceScalarField& DbyA)")
WarningInFunction
<< "Attempt to set the dilatation rate of an incompressible phase"
<< endl;
}

6
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/phasePair/phasePair/phasePair.C
View File

@ -67,7 +67,7 @@ Foam::phasePair::~phasePair()
const Foam::phaseModel& Foam::phasePair::dispersed() const
{
FatalErrorIn("Foam::phasePair::dispersed() const")
FatalErrorInFunction
<< "Requested dispersed phase from an unordered pair."
<< exit(FatalError);
@ -77,7 +77,7 @@ const Foam::phaseModel& Foam::phasePair::dispersed() const
const Foam::phaseModel& Foam::phasePair::continuous() const
{
FatalErrorIn("Foam::phasePair::dispersed() const")
FatalErrorInFunction
<< "Requested continuous phase from an unordered pair."
<< exit(FatalError);
@ -191,7 +191,7 @@ Foam::tmp<Foam::volScalarField> Foam::phasePair::Ta() const
Foam::tmp<Foam::volScalarField> Foam::phasePair::E() const
{
FatalErrorIn("Foam::phasePair::E() const")
FatalErrorInFunction
<< "Requested aspect ratio of the dispersed phase in an unordered pair"
<< exit(FatalError);

10
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/phasePair/phasePairKey/phasePairKey.C
View File

@ -133,14 +133,8 @@ Foam::Istream& Foam::operator>>(Istream& is, phasePairKey& key)
}
else
{
FatalErrorIn
(
"friend Istream& operator>>"
"("
"Istream& is, "
"phasePairKey& key"
")"
) << "Phase pair type is not recognised. "
FatalErrorInFunction
<< "Phase pair type is not recognised. "
<< temp
<< "Use (phaseDispersed in phaseContinuous) for an ordered"
<< "pair, or (phase1 and pase2) for an unordered pair."

8
applications/solvers/multiphase/reactingEulerFoam/reactingMultiphaseEulerFoam/multiphaseSystem/multiphaseSystem.C
View File

@ -400,12 +400,8 @@ void Foam::multiphaseSystem::correctContactAngle
if (tp == acap.thetaProps().end())
{
FatalErrorIn
(
"multiphaseSystem::correctContactAngle"
"(const phaseModel& phase1, const phaseModel& phase2, "
"fvPatchVectorFieldField& nHatb) const"
) << "Cannot find interface "
FatalErrorInFunction
<< "Cannot find interface "
<< phasePairKey(phase1.name(), phase2.name())
<< "\n in table of theta properties for patch "
<< acap.patch().name()

2
applications/solvers/multiphase/reactingEulerFoam/reactingMultiphaseEulerFoam/multiphaseSystem/newMultiphaseSystem.C
View File

@ -56,7 +56,7 @@ Foam::autoPtr<Foam::multiphaseSystem> Foam::multiphaseSystem::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("multiphaseSystem::New")
FatalErrorInFunction
<< "Unknown multiphaseSystemType type "
<< multiphaseSystemType << endl << endl
<< "Valid multiphaseSystem types are : " << endl

6
applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseCompressibleTurbulenceModels/derivedFvPatchFields/alphatFixedDmdtWallBoilingWallFunction/alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField.C
View File

@ -56,11 +56,7 @@ void alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField::checkType()
{
if (!isA<wallFvPatch>(patch()))
{
FatalErrorIn
(
"alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField"
"::checkType()"
)
FatalErrorInFunction
<< "Patch type for patch " << patch().name() << " must be wall\n"
<< "Current patch type is " << patch().type() << nl
<< exit(FatalError);

12
applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseCompressibleTurbulenceModels/kineticTheoryModels/derivedFvPatchFields/JohnsonJacksonParticleSlip/JohnsonJacksonParticleSlipFvPatchVectorField.C
View File

@ -89,16 +89,8 @@ JohnsonJacksonParticleSlipFvPatchVectorField
|| (specularityCoefficient_.value() > 1)
)
{
FatalErrorIn
(
"("
"Foam::JohnsonJacksonParticleSlipFvPatchVectorField::"
"JohnsonJacksonParticleSlipFvPatchVectorField"
"const fvPatch& p,"
"const DimensionedField<scalar, volMesh>& iF,"
"const dictionary& dict"
")"
) << "The specularity coefficient has to be between 0 and 1"
FatalErrorInFunction
<< "The specularity coefficient has to be between 0 and 1"
<< abort(FatalError);
}

24
applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseCompressibleTurbulenceModels/kineticTheoryModels/derivedFvPatchFields/JohnsonJacksonParticleTheta/JohnsonJacksonParticleThetaFvPatchScalarField.C
View File

@ -97,16 +97,8 @@ JohnsonJacksonParticleThetaFvPatchScalarField
|| (restitutionCoefficient_.value() > 1)
)
{
FatalErrorIn
(
"Foam::JohnsonJacksonParticleThetaFvPatchScalarField::"
"JohnsonJacksonParticleThetaFvPatchScalarField"
"("
"const fvPatch& p,"
"const DimensionedField<scalar, volMesh>& iF,"
"const dictionary& dict"
")"
) << "The restitution coefficient has to be between 0 and 1"
FatalErrorInFunction
<< "The restitution coefficient has to be between 0 and 1"
<< abort(FatalError);
}
@ -116,16 +108,8 @@ JohnsonJacksonParticleThetaFvPatchScalarField
|| (specularityCoefficient_.value() > 1)
)
{
FatalErrorIn
(
"Foam::JohnsonJacksonParticleThetaFvPatchScalarField::"
"JohnsonJacksonParticleThetaFvPatchScalarField"
"("
"const fvPatch& p,"
"const DimensionedField<scalar, volMesh>& iF,"
"const dictionary& dict"
")"
) << "The specularity coefficient has to be between 0 and 1"
FatalErrorInFunction
<< "The specularity coefficient has to be between 0 and 1"
<< abort(FatalError);
}

7
applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseSystem/diameterModels/IATE/IATEsources/IATEsource/IATEsource.C
View File

@ -55,11 +55,8 @@ Foam::diameterModels::IATEsource::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn
(
"IATEsource::New"
"(const word& type, const IATE&, const dictionary&)"
) << "Unknown IATE source type "
FatalErrorInFunction
<< "Unknown IATE source type "
<< type << nl << nl
<< "Valid IATE source types : " << endl
<< dictionaryConstructorTablePtr_->sortedToc()

2
applications/solvers/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseSystem/newTwoPhaseSystem.C
View File

@ -56,7 +56,7 @@ Foam::autoPtr<Foam::twoPhaseSystem> Foam::twoPhaseSystem::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("twoPhaseSystem::New")
FatalErrorInFunction
<< "Unknown twoPhaseSystemType type "
<< twoPhaseSystemType << endl << endl
<< "Valid twoPhaseSystem types are : " << endl

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

@ -45,7 +45,7 @@ Foam::aspectRatioModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("aspectRatioModel::New")
FatalErrorInFunction
<< "Unknown aspectRatioModelType type "
<< aspectRatioModelType << endl << endl
<< "Valid aspectRatioModel types are : " << endl

4
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 | Copyright (C) 2011-2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -44,7 +44,7 @@ Foam::autoPtr<Foam::dragModel> Foam::dragModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("dragModel::New")
FatalErrorInFunction
<< "Unknown dragModelType type "
<< dragModelType << endl << endl
<< "Valid dragModel types are : " << endl

2
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/segregated/segregated.C
View File

@ -66,7 +66,7 @@ Foam::dragModels::segregated::~segregated()
Foam::tmp<Foam::volScalarField> Foam::dragModels::segregated::CdRe() const
{
FatalErrorIn("Foam::dragModels::segregated::CdRe() const")
FatalErrorInFunction
<< "Not implemented."
<< "Drag coefficient not defined for the segregated model."
<< exit(FatalError);

4
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 | Copyright (C) 2011-2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -44,7 +44,7 @@ Foam::autoPtr<Foam::heatTransferModel> Foam::heatTransferModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("heatTransferModel::New")
FatalErrorInFunction
<< "Unknown heatTransferModelType type "
<< heatTransferModelType << endl << endl
<< "Valid heatTransferModel types are : " << endl

7
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/liftModels/Moraga/Moraga.C
View File

@ -79,11 +79,8 @@ Foam::tmp<Foam::volScalarField> Foam::liftModels::Moraga::Cl() const
|| max(sqrSr).value() > 0.04
)
{
WarningIn
(
"Foam::tmp<Foam::volScalarField> "
"Foam::liftModels::Moraga::Cl() const"
) << "Re and/or Sr are out of the range of applicability of the "
WarningInFunction
<< "Re and/or Sr are out of the range of applicability of the "
<< "Moraga model. Clamping to range bounds"
<< endl;
}

4
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 | Copyright (C) 2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -44,7 +44,7 @@ Foam::autoPtr<Foam::liftModel> Foam::liftModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("liftModel::New")
FatalErrorInFunction
<< "Unknown liftModelType type "
<< liftModelType << endl << endl
<< "Valid liftModel types are : " << endl

4
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 | Copyright (C) 2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -45,7 +45,7 @@ Foam::swarmCorrection::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("swarmCorrection::New")
FatalErrorInFunction
<< "Unknown swarmCorrectionType type "
<< swarmCorrectionType << endl << endl
<< "Valid swarmCorrection types are : " << endl

4
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 | Copyright (C) 2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -45,7 +45,7 @@ Foam::turbulentDispersionModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("turbulentDispersionModel::New")
FatalErrorInFunction
<< "Unknown turbulentDispersionModelType type "
<< turbulentDispersionModelType << endl << endl
<< "Valid turbulentDispersionModel types are : " << endl

4
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 | Copyright (C) 2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -44,7 +44,7 @@ Foam::autoPtr<Foam::virtualMassModel> Foam::virtualMassModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("virtualMassModel::New")
FatalErrorInFunction
<< "Unknown virtualMassModelType type "
<< virtualMassModelType << endl << endl
<< "Valid virtualMassModel types are : " << endl

4
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 | Copyright (C) 2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -44,7 +44,7 @@ Foam::autoPtr<Foam::wallLubricationModel> Foam::wallLubricationModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("wallLubricationModel::New")
FatalErrorInFunction
<< "Unknown wallLubricationModelType type "
<< wallLubricationModelType << endl << endl
<< "Valid wallLubricationModel types are : " << endl

12
applications/solvers/multiphase/twoPhaseEulerFoam/phaseCompressibleTurbulenceModels/kineticTheoryModels/derivedFvPatchFields/JohnsonJacksonParticleSlip/JohnsonJacksonParticleSlipFvPatchVectorField.C
View File

@ -89,16 +89,8 @@ JohnsonJacksonParticleSlipFvPatchVectorField
|| (specularityCoefficient_.value() > 1)
)
{
FatalErrorIn
(
"("
"Foam::JohnsonJacksonParticleSlipFvPatchVectorField::"
"JohnsonJacksonParticleSlipFvPatchVectorField"
"const fvPatch& p,"
"const DimensionedField<scalar, volMesh>& iF,"
"const dictionary& dict"
")"
) << "The specularity coefficient has to be between 0 and 1"
FatalErrorInFunction
<< "The specularity coefficient has to be between 0 and 1"
<< abort(FatalError);
}

24
applications/solvers/multiphase/twoPhaseEulerFoam/phaseCompressibleTurbulenceModels/kineticTheoryModels/derivedFvPatchFields/JohnsonJacksonParticleTheta/JohnsonJacksonParticleThetaFvPatchScalarField.C
View File

@ -97,16 +97,8 @@ JohnsonJacksonParticleThetaFvPatchScalarField
|| (restitutionCoefficient_.value() > 1)
)
{
FatalErrorIn
(
"Foam::JohnsonJacksonParticleThetaFvPatchScalarField::"
"JohnsonJacksonParticleThetaFvPatchScalarField"
"("
"const fvPatch& p,"
"const DimensionedField<scalar, volMesh>& iF,"
"const dictionary& dict"
")"
) << "The restitution coefficient has to be between 0 and 1"
FatalErrorInFunction
<< "The restitution coefficient has to be between 0 and 1"
<< abort(FatalError);
}
@ -116,16 +108,8 @@ JohnsonJacksonParticleThetaFvPatchScalarField
|| (specularityCoefficient_.value() > 1)
)
{
FatalErrorIn
(
"Foam::JohnsonJacksonParticleThetaFvPatchScalarField::"
"JohnsonJacksonParticleThetaFvPatchScalarField"
"("
"const fvPatch& p,"
"const DimensionedField<scalar, volMesh>& iF,"
"const dictionary& dict"
")"
) << "The specularity coefficient has to be between 0 and 1"
FatalErrorInFunction
<< "The specularity coefficient has to be between 0 and 1"
<< abort(FatalError);
}

4
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 | Copyright (C) 2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -43,7 +43,7 @@ Foam::autoPtr<Foam::blendingMethod> Foam::blendingMethod::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("blendingMethod::New")
FatalErrorInFunction
<< "Unknown blendingMethodType type "
<< blendingMethodType << endl << endl
<< "Valid blendingMethod types are : " << endl

12
applications/solvers/multiphase/twoPhaseEulerFoam/twoPhaseSystem/BlendedInterfacialModel/blendingMethods/linear/linear.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -93,14 +93,8 @@ Foam::blendingMethods::linear::linear
> maxPartlyDispersedAlpha_[*iter]
)
{
FatalErrorIn
(
"Foam::blendingMethods::linear::linear"
"("
"const dictionary& dict,"
"const wordList& phaseNames"
")"
) << "The supplied fully dispersed volume fraction for "
FatalErrorInFunction
<< "The supplied fully dispersed volume fraction for "
<< *iter
<< " is greater than the partly dispersed value."
<< endl << exit(FatalError);

9
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) 2011-2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -56,11 +56,8 @@ Foam::diameterModels::IATEsource::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn
(
"IATEsource::New"
"(const word& type, const IATE&, const dictionary&)"
) << "Unknown IATE source type "
FatalErrorInFunction
<< "Unknown IATE source type "
<< type << nl << nl
<< "Valid IATE source types : " << endl
<< dictionaryConstructorTablePtr_->sortedToc()

4
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 | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -48,7 +48,7 @@ Foam::autoPtr<Foam::diameterModel> Foam::diameterModel::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn("diameterModel::New")
FatalErrorInFunction
<< "Unknown diameterModelType type "
<< diameterModelType << endl << endl
<< "Valid diameterModel types are : " << endl

4
applications/solvers/multiphase/twoPhaseEulerFoam/twoPhaseSystem/phasePair/orderedPhasePair/orderedPhasePair.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -85,7 +85,7 @@ Foam::tmp<Foam::volScalarField> Foam::orderedPhasePair::E() const
{
if (!aspectRatio_.valid())
{
FatalErrorIn("Foam::orderedPhasePair::E() const")
FatalErrorInFunction
<< "Aspect ratio model not specified for " << *this << "."
<< exit(FatalError);
}

6
applications/solvers/multiphase/twoPhaseEulerFoam/twoPhaseSystem/phasePair/phasePair/phasePair.C
View File

@ -82,7 +82,7 @@ Foam::phasePair::~phasePair()
const Foam::phaseModel& Foam::phasePair::dispersed() const
{
FatalErrorIn("Foam::phasePair::dispersed() const")
FatalErrorInFunction
<< "Requested dispersed phase from an unordered pair."
<< exit(FatalError);
@ -92,7 +92,7 @@ const Foam::phaseModel& Foam::phasePair::dispersed() const
const Foam::phaseModel& Foam::phasePair::continuous() const
{
FatalErrorIn("Foam::phasePair::dispersed() const")
FatalErrorInFunction
<< "Requested continuous phase from an unordered pair."
<< exit(FatalError);
@ -185,7 +185,7 @@ Foam::tmp<Foam::volScalarField> Foam::phasePair::Ta() const
Foam::tmp<Foam::volScalarField> Foam::phasePair::E() const
{
FatalErrorIn("Foam::phasePair::E() const")
FatalErrorInFunction
<< "Requested aspect ratio of the dispersed phase in an unordered pair"
<< exit(FatalError);

12
applications/solvers/multiphase/twoPhaseEulerFoam/twoPhaseSystem/phasePair/phasePairKey/phasePairKey.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2014-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -125,14 +125,8 @@ Foam::Istream& Foam::operator>>(Istream& is, phasePairKey& key)
}
else
{
FatalErrorIn
(
"friend Istream& operator>>"
"("
"Istream& is, "
"phasePairKey& key"
")"
) << "Phase pair type is not recognised. "
FatalErrorInFunction
<< "Phase pair type is not recognised. "
<< temp
<< "Use (phaseDispersed in phaseContinuous) for an ordered"
<< "pair, or (phase1 and pase2) for an unordered pair."

18
applications/solvers/stressAnalysis/solidDisplacementFoam/readMechanicalProperties.H
View File

@ -61,10 +61,8 @@
}
else
{
FatalErrorIn
(
"readMechanicalProperties.H"
) << "Valid type entries are uniform or field for rho"
FatalErrorInFunction
<< "Valid type entries are uniform or field for rho"
<< abort(FatalError);
}
@ -119,10 +117,8 @@
}
else
{
FatalErrorIn
(
"readMechanicalProperties.H"
) << "Valid type entries are uniform or field for E"
FatalErrorInFunction
<< "Valid type entries are uniform or field for E"
<< abort(FatalError);
}
@ -175,10 +171,8 @@
}
else
{
FatalErrorIn
(
"readMechanicalProperties.H"
) << "Valid type entries are uniform or field for nu"
FatalErrorInFunction
<< "Valid type entries are uniform or field for nu"
<< abort(FatalError);
}

18
applications/solvers/stressAnalysis/solidDisplacementFoam/readThermalProperties.H
View File

@ -96,10 +96,8 @@ if (thermalStress)
}
else
{
FatalErrorIn
(
"readThermalProperties.H"
) << "Valid type entries are uniform or field for C"
FatalErrorInFunction
<< "Valid type entries are uniform or field for C"
<< abort(FatalError);
}
@ -154,10 +152,8 @@ if (thermalStress)
}
else
{
FatalErrorIn
(
"readThermalProperties.H"
) << "Valid type entries are uniform or field for K"
FatalErrorInFunction
<< "Valid type entries are uniform or field for K"
<< abort(FatalError);
}
@ -212,10 +208,8 @@ if (thermalStress)
}
else
{
FatalErrorIn
(
"readThermalProperties.H"
) << "Valid type entries are uniform or field for alpha"
FatalErrorInFunction
<< "Valid type entries are uniform or field for alpha"
<< abort(FatalError);
}

4
applications/test/GAMGAgglomeration/Test-GAMGAgglomeration.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -130,7 +130,7 @@ int main(int argc, char *argv[])
);
if (!ok)
{
WarningIn(args.executable())
WarningInFunction
<< "At level " << level
<< " there are " << coarseSize
<< " agglomerated cells but " << newCoarseSize

10
applications/test/fieldMapping/Test-fieldMapping.C
View File

@ -225,7 +225,7 @@ int main(int argc, char *argv[])
{
if (mesh.V().size() != mesh.nCells())
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Volume not mapped. V:" << mesh.V().size()
<< " nCells:" << mesh.nCells()
<< exit(FatalError);
@ -238,7 +238,7 @@ int main(int argc, char *argv[])
if (mag(newVol-totalVol)/totalVol > 1e-10)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Volume loss: old volume:" << totalVol
<< " new volume:" << newVol
<< exit(FatalError);
@ -260,7 +260,7 @@ int main(int argc, char *argv[])
if (notEqual(max, 1.0, 1e-10) || notEqual(min, 1.0, 1e-10))
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Uniform volVectorField not preserved."
<< " Min and max should both be 1.0. min:" << min
<< " max:" << max
@ -284,7 +284,7 @@ int main(int argc, char *argv[])
if (notEqual(max, 0.0, 1e-10) || notEqual(min, 0.0, 1e-10))
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Linear profile not preserved."
<< " Min and max should both be 0.0. min:" << min
<< " max:" << max
@ -307,7 +307,7 @@ int main(int argc, char *argv[])
if (notEqual(max, 1.0, 1e-10) || notEqual(min, 1.0, 1e-10))
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Uniform surfaceScalarField not preserved."
<< " Min and max should both be 1.0. min:" << min
<< " max:" << max

22
applications/test/globalIndex/Test-globalIndex.C
View File

@ -53,14 +53,14 @@ int main(int argc, char *argv[])
if (globalNumbering.localSize() != mesh.nCells())
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Problem." << abort(FatalError);
}
if (!Pstream::parRun())
{
WarningIn(args.executable())
WarningInFunction
<< "globalIndex class is only useful in parallel code."
<< endl;
}
@ -77,14 +77,14 @@ int main(int argc, char *argv[])
if (procI != Pstream::myProcNo() || localCellI != cellI)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Problem. cellI:" << cellI << " localCellI:" << localCellI
<< " procI:" << procI << abort(FatalError);
}
if (!globalNumbering.isLocal(globalCellI))
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Problem. cellI:" << cellI << " globalCellI:" << globalCellI
<< " not local" << abort(FatalError);
}
@ -95,7 +95,7 @@ int main(int argc, char *argv[])
if (mesh.nCells() < 1)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Test needs to be run on a case with at least one"
<< " cell per processor." << abort(FatalError);
}
@ -109,7 +109,7 @@ int main(int argc, char *argv[])
if (procI != Pstream::myProcNo()-1)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Problem. global:" << prevProcCellI
<< " expected on processor:" << Pstream::myProcNo()-1
<< " but is calculated to be on procI:" << procI
@ -118,14 +118,14 @@ int main(int argc, char *argv[])
if (globalNumbering.isLocal(prevProcCellI))
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Problem. globalCellI:" << prevProcCellI
<< " calculated as local" << abort(FatalError);
}
if (!globalNumbering.isLocal(procI, prevProcCellI))
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Problem. globalCellI:" << prevProcCellI
<< " not calculated as local on processor:" << procI
<< abort(FatalError);
@ -140,7 +140,7 @@ int main(int argc, char *argv[])
if (procI != Pstream::myProcNo()+1)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Problem. global:" << nextProcCellI
<< " expected on processor:" << Pstream::myProcNo()+1
<< " but is calculated to be on procI:" << procI
@ -149,14 +149,14 @@ int main(int argc, char *argv[])
if (globalNumbering.isLocal(nextProcCellI))
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Problem. globalCellI:" << nextProcCellI
<< " calculated as local" << abort(FatalError);
}
if (!globalNumbering.isLocal(procI, nextProcCellI))
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Problem. globalCellI:" << nextProcCellI
<< " not calculated as local on processor:" << procI
<< abort(FatalError);

8
applications/test/hexRef8/Test-hexRef8.C
View File

@ -309,7 +309,7 @@ int main(int argc, char *argv[])
{
if (mesh.V().size() != mesh.nCells())
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Volume not mapped. V:" << mesh.V().size()
<< " nCells:" << mesh.nCells()
<< exit(FatalError);
@ -322,7 +322,7 @@ int main(int argc, char *argv[])
if (mag(newVol-totalVol)/totalVol > 1e-10)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Volume loss: old volume:" << totalVol
<< " new volume:" << newVol
<< exit(FatalError);
@ -344,7 +344,7 @@ int main(int argc, char *argv[])
if (notEqual(max, 1.0, 1e-10) || notEqual(min, 1.0, 1e-10))
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Uniform volVectorField not preserved."
<< " Min and max should both be 1.0. min:" << min
<< " max:" << max
@ -389,7 +389,7 @@ int main(int argc, char *argv[])
if (notEqual(max, 1.0, 1e-10) || notEqual(min, 1.0, 1e-10))
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Uniform surfaceScalarField not preserved."
<< " Min and max should both be 1.0. min:" << min
<< " max:" << max

2
applications/test/parallel-nonBlocking/Test-parallel-nonBlocking.C
View File

@ -169,7 +169,7 @@ int main(int argc, char *argv[])
if (data != procI)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "From processor " << procI << " received " << data
<< " but expected " << procI
<< exit(FatalError);

2
applications/test/primitivePatch/Test-PrimitivePatch.C
View File

@ -71,7 +71,7 @@ void checkFaceEdges
if (edges[myEdges[fp]] != edge(f[fp], f[fp1]))
{
FatalErrorIn("checkFaceEdges")
FatalErrorInFunction
<< "Edges of face not in face point order:"
<< "face:" << faceI << " localF:" << f
<< " faceEdges:" << myEdges

9
applications/test/router/Gather/GatherBase.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -70,11 +70,8 @@ IndexType GatherBase::offset
{
if (values.size() != indices.size())
{
FatalErrorIn
(
"GatherBase::offset(const List<DataType>&, "
"const List<IndexType>&, AddOp)"
) << "Input data and indices lists not equal size." << endl
FatalErrorInFunction
<< "Input data and indices lists not equal size." << endl
<< "data size:" << values.size()
<< " indices:" << indices.size()
<< abort(FatalError);

2
applications/test/router/Test-processorRouter.C
View File

@ -103,7 +103,7 @@ int main(int argc, char *argv[])
if (!Pstream::parRun())
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Please run in parallel" << exit(FatalError);
}

21
applications/test/router/router.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -125,12 +125,8 @@ void Foam::router::fixWeights
if (minNodeI == -1)
{
WarningIn
(
"Foam::router::fixWeights"
"(const label startNodeI, const label endNodeI,"
"const label nodeI, const label prevNodeI)"
) << "Cannot route from node " << nodeI
WarningInFunction
<< "Cannot route from node " << nodeI
<< " since all neigbours of node "
<< "already allocated:" << endl;
@ -138,12 +134,7 @@ void Foam::router::fixWeights
{
label nbrNodeI = myNeighbours[neighbourI];
WarningIn
(
"Foam::router::fixWeights"
"(const label startNodeI, const label endNodeI,"
"const label nodeI, const label prevNodeI)"
) << " neighbour:" << nbrNodeI
WarningInFunction
<< " weight:" << weights_[nbrNodeI] << endl;
}
return;
@ -292,7 +283,7 @@ bool Foam::router::route(const labelList& path, const label pathValue)
{
if (pathValue >= 0)
{
FatalErrorIn("router::route(const labelList&, const label)")
FatalErrorInFunction
<< "Illegal pathValue " << pathValue << exit(FatalError);
}
@ -382,7 +373,7 @@ Foam::labelList Foam::router::getRoute(const label pathValue) const
if (pathNodeI == -1)
{
FatalErrorIn("router::getRoute(const label)")
FatalErrorInFunction
<< "No route with value " << pathValue << endl;
}

33
applications/test/syncTools/Test-syncTools.C
View File

@ -29,7 +29,6 @@ Description
\*---------------------------------------------------------------------------*/
#include "syncTools.H"
#include "argList.H"
#include "polyMesh.H"
@ -81,7 +80,7 @@ void testPackedList(const polyMesh& mesh, Random& rndGen)
|| maxEdgeValues[i] != label(maxBits.get(i))
)
{
FatalErrorIn("testPackedList()")
FatalErrorInFunction
<< "edge:" << i
<< " minlabel:" << edgeValues[i]
<< " minbits:" << bits.get(i)
@ -128,7 +127,7 @@ void testPackedList(const polyMesh& mesh, Random& rndGen)
|| maxPointValues[i] != label(maxBits.get(i))
)
{
FatalErrorIn("testPackedList()")
FatalErrorInFunction
<< "point:" << i
<< " at:" << mesh.points()[i]
<< " minlabel:" << pointValues[i]
@ -170,7 +169,7 @@ void testPackedList(const polyMesh& mesh, Random& rndGen)
|| maxFaceValues[faceI] != label(maxBits.get(faceI))
)
{
FatalErrorIn("testPackedList()")
FatalErrorInFunction
<< "face:" << faceI
<< " minlabel:" << faceValues[faceI]
<< " minbits:" << bits.get(faceI)
@ -187,7 +186,7 @@ void testSparseData(const polyMesh& mesh, Random& rndGen)
{
Info<< nl << "Testing Map synchronisation." << endl;
WarningIn("testSparseData()")
WarningInFunction
<< "Position test of sparse data only correct for cases without cyclics"
<< " with shared points." << endl;
@ -252,7 +251,7 @@ void testSparseData(const polyMesh& mesh, Random& rndGen)
if (fullPt != sparsePt)
{
FatalErrorIn("testSparseData()")
FatalErrorInFunction
<< "point:" << meshPointI
<< " full:" << fullPt
<< " sparse:" << sparsePt
@ -270,7 +269,7 @@ void testSparseData(const polyMesh& mesh, Random& rndGen)
if (fullPt != sparsePt)
{
FatalErrorIn("testSparseData()")
FatalErrorInFunction
<< "point:" << meshPointI
<< " full:" << fullPt
<< " sparse:" << sparsePt
@ -335,7 +334,7 @@ void testSparseData(const polyMesh& mesh, Random& rndGen)
if (fullPt != sparsePt)
{
FatalErrorIn("testSparseData()")
FatalErrorInFunction
<< "edge:" << meshEdgeI
<< " points:" << mesh.edges()[meshEdgeI]
<< " full:" << fullPt
@ -359,7 +358,7 @@ void testSparseData(const polyMesh& mesh, Random& rndGen)
if (fullPt != sparsePt)
{
FatalErrorIn("testSparseData()")
FatalErrorInFunction
<< "Extra edge:" << meshEdgeI
<< " points:" << mesh.edges()[meshEdgeI]
<< " full:" << fullPt
@ -392,7 +391,7 @@ void testPointSync(const polyMesh& mesh, Random& rndGen)
{
if (mag(syncedPoints[pointI] - mesh.points()[pointI]) > SMALL)
{
FatalErrorIn("testPointSync()")
FatalErrorInFunction
<< "Point " << pointI
<< " original location " << mesh.points()[pointI]
<< " synced location " << syncedPoints[pointI]
@ -428,13 +427,11 @@ void testPointSync(const polyMesh& mesh, Random& rndGen)
{
if (nMasters[pointI] != 1)
{
//FatalErrorIn("testPointSync()")
WarningIn("testPointSync()")
WarningInFunction
<< "Point " << pointI
<< " original location " << mesh.points()[pointI]
<< " has " << nMasters[pointI]
<< " masters."
//<< exit(FatalError);
<< endl;
}
}
@ -470,7 +467,7 @@ void testEdgeSync(const polyMesh& mesh, Random& rndGen)
if (mag(syncedMids[edgeI] - eMid) > SMALL)
{
FatalErrorIn("testEdgeSync()")
FatalErrorInFunction
<< "Edge " << edgeI
<< " original midpoint " << eMid
<< " synced location " << syncedMids[edgeI]
@ -507,13 +504,11 @@ void testEdgeSync(const polyMesh& mesh, Random& rndGen)
if (nMasters[edgeI] != 1)
{
const edge& e = edges[edgeI];
//FatalErrorIn("testEdgeSync()")
WarningIn("testEdgeSync()")
WarningInFunction
<< "Edge " << edgeI
<< " at:" << mesh.points()[e[0]] << mesh.points()[e[1]]
<< " has " << nMasters[edgeI]
<< " masters."
//<< exit(FatalError);
<< endl;
}
}
@ -541,7 +536,7 @@ void testFaceSync(const polyMesh& mesh, Random& rndGen)
{
if (mag(syncedFc[faceI] - mesh.faceCentres()[faceI]) > SMALL)
{
FatalErrorIn("testFaceSync()")
FatalErrorInFunction
<< "Face " << faceI
<< " original centre " << mesh.faceCentres()[faceI]
<< " synced centre " << syncedFc[faceI]
@ -576,7 +571,7 @@ void testFaceSync(const polyMesh& mesh, Random& rndGen)
{
if (nMasters[faceI] != 1)
{
FatalErrorIn("testFaceSync()")
FatalErrorInFunction
<< "Face " << faceI
<< " centre " << mesh.faceCentres()[faceI]
<< " has " << nMasters[faceI]

4
applications/test/tetTetOverlap/Test-tetTetOverlap.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2012-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -152,7 +152,7 @@ int main(int argc, char *argv[])
if (mag(volInside+volOutside-tetA.mag()) > SMALL)
{
FatalErrorIn("Test-tetetOverlap")
FatalErrorInFunction
<< "Tet volumes do not sum up to input tet."
<< exit(FatalError);
}

14
applications/utilities/mesh/advanced/PDRMesh/PDRMesh.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -530,7 +530,7 @@ label findPatch(const polyBoundaryMesh& patches, const word& patchName)
if (patchI == -1)
{
FatalErrorIn("findPatch(const polyBoundaryMesh&, const word&)")
FatalErrorInFunction
<< "Illegal patch " << patchName
<< nl << "Valid patches are " << patches.names()
<< exit(FatalError);
@ -543,7 +543,7 @@ label findPatch(const polyBoundaryMesh& patches, const word& patchName)
if (newPatch != patchI)
{
FatalErrorIn("findPatch(const polyBoundaryMesh&, const word&)")
FatalErrorInFunction
<< "Patch " << patchName
<< " should have the same patch index on all processors." << nl
<< "On my processor it has index " << patchI
@ -651,7 +651,7 @@ int main(int argc, char *argv[])
{
if (wantedPatch[iter.key()] != -1)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Face " << iter.key()
<< " is in faceSet " << setsAndPatches[setI][0]
<< " destined for patch " << setsAndPatches[setI][1]
@ -689,7 +689,7 @@ int main(int argc, char *argv[])
{
if (coupledWantedPatch[iter.key()] != -1)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Face " << iter.key()
<< " is in faceSet " << coupledAndPatches[setI][0]
<< " destined for patch " << coupledAndPatches[setI][1]
@ -1151,7 +1151,7 @@ int main(int argc, char *argv[])
if (cellRegion.nRegions() > 1)
{
WarningIn(args.executable())
WarningInFunction
<< "Removing blocked faces and cells created "
<< cellRegion.nRegions()
<< " regions that are not connected via a face." << nl
@ -1167,7 +1167,7 @@ int main(int argc, char *argv[])
if (startFrom != "latestTime")
{
WarningIn(args.executable())
WarningInFunction
<< "To run splitMeshRegions please set your"
<< " startFrom entry to latestTime" << endl;
}

6
applications/utilities/mesh/advanced/autoRefineMesh/autoRefineMesh.C
View File

@ -365,7 +365,7 @@ bool limitRefinementLevel
{
if (refLevel[cellI] - refLevel[nbr] >= limitDiff)
{
FatalErrorIn("limitRefinementLevel")
FatalErrorInFunction
<< "Level difference between neighbouring cells "
<< cellI << " and " << nbr
<< " greater than or equal to " << limitDiff << endl
@ -705,7 +705,7 @@ int main(int argc, char *argv[])
if (nCutLayers > 0 && selectInside)
{
WarningIn(args.executable())
WarningInFunction
<< "Illogical settings : Both nCutLayers>0 and selectInside true."
<< endl
<< "This would mean that inside cells get removed but should be"
@ -728,7 +728,7 @@ int main(int argc, char *argv[])
if (queryMesh.findCell(outsidePoint, -1, false) == -1)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "outsidePoint " << outsidePoint
<< " is not inside any cell"
<< exit(FatalError);

2
applications/utilities/mesh/advanced/collapseEdges/collapseEdges.C
View File

@ -98,7 +98,7 @@ int main(int argc, char *argv[])
if (collapseFaces && collapseFaceSet)
{
FatalErrorIn("main(int, char*[])")
FatalErrorInFunction
<< "Both face zone collapsing and face collapsing have been"
<< "selected. Choose only one of:" << nl
<< " -collapseFaces" << nl

2
applications/utilities/mesh/advanced/combinePatchFaces/combinePatchFaces.C
View File

@ -177,7 +177,7 @@ label mergePatchFaces
if (newVertI < 0)
{
FatalErrorIn("mergePatchFaces")
FatalErrorInFunction
<< "In set:" << setI << " old face labels:"
<< allFaceSets[setI] << " new face vertices:"
<< setFaceVerts[i] << " are unmapped vertices!"

2
applications/utilities/mesh/advanced/modifyMesh/modifyMesh.C
View File

@ -399,7 +399,7 @@ int main(int argc, char *argv[])
|| (collapseEdge && cellsToSplit)
)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Used more than one mesh modifying module "
<< "(boundary cutting, cell splitting, edge collapsing)" << nl
<< "Please do them in separate passes." << exit(FatalError);

2
applications/utilities/mesh/advanced/refineWallLayer/refineWallLayer.C
View File

@ -86,7 +86,7 @@ int main(int argc, char *argv[])
if (!patchSet.size())
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Cannot find any patches in set " << patches << endl
<< "Valid patches are " << mesh.boundaryMesh().names()
<< exit(FatalError);

4
applications/utilities/mesh/advanced/refinementLevel/refinementLevel.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -240,7 +240,7 @@ int main(int argc, char *argv[])
if (!readLevel && refHeader.headerOk())
{
WarningIn(args.executable())
WarningInFunction
<< "Detected " << refHeader.name() << " file in "
<< polyMesh::defaultRegion << " directory. Please remove to"
<< " recreate it or use the -readLevel option to use it"

4
applications/utilities/mesh/advanced/selectCells/selectCells.C
View File

@ -174,7 +174,7 @@ void cutBySurface
}
else
{
FatalErrorIn("cutBySurface")
FatalErrorInFunction
<< "Multiple mesh regions in original mesh" << endl
<< "Please use splitMeshRegions to separate these"
<< exit(FatalError);
@ -393,7 +393,7 @@ int main(int argc, char *argv[])
label cellI = queryMesh.findCell(outsidePoint, -1, false);
if (returnReduce(cellI, maxOp<label>()) == -1)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "outsidePoint " << outsidePoint
<< " is not inside any cell"
<< exit(FatalError);

4
applications/utilities/mesh/advanced/splitCells/splitCells.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -261,7 +261,7 @@ bool splitHex
if (leftI == -1 || rightI == -1)
{
FatalErrorIn("splitHex") << "Problem : leftI:" << leftI
FatalErrorInFunction
<< " rightI:" << rightI << abort(FatalError);
}

16
applications/utilities/mesh/conversion/Optional/ccm26ToFoam/ccm26ToFoam.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -164,7 +164,7 @@ void CheckError(CCMIOError const &err, const Foam::string& str)
{
if (err != kCCMIONoErr)
{
FatalErrorIn("CheckError")
FatalErrorInFunction
<< str << exit(FatalError);
}
}
@ -625,14 +625,14 @@ int main(int argc, char *argv[])
if (!isFile(ccmFile))
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Cannot read file " << ccmFile
<< exit(FatalError);
}
if (ccmExt != "ccm" && ccmExt != "ccmg")
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Illegal extension " << ccmExt << " for file " << ccmFile
<< nl << "Allowed extensions are '.ccm', '.ccmg'"
<< exit(FatalError);
@ -697,7 +697,7 @@ int main(int argc, char *argv[])
);
if (err != kCCMIONoErr)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Could not read the file."
<< exit(FatalError);
}
@ -838,7 +838,7 @@ int main(int argc, char *argv[])
if (nbr >= foamCellType.size() || own >= foamCellType.size())
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "face:" << faceI
<< " nbr:" << nbr
<< " own:" << own
@ -864,7 +864,7 @@ int main(int argc, char *argv[])
{
if (f[fp] < 0 || f[fp] >= foamPoints.size())
{
FatalErrorIn(args.executable()) << "face:" << faceI
FatalErrorInFunction
<< " f:" << f << abort(FatalError);
}
}
@ -1002,7 +1002,7 @@ int main(int argc, char *argv[])
if (meshFaceI != foamOwner.size())
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "meshFaceI:" << meshFaceI
<< " nFaces:" << foamOwner.size()
<< abort(FatalError);

4
applications/utilities/mesh/conversion/ansysToFoam/ansysToFoam.L
View File

@ -285,7 +285,7 @@ label findFace(const polyMesh& mesh, const face& f)
}
}
FatalErrorIn("findFace(const polyMesh&, const face&)")
FatalErrorInFunction
<< "Cannot find a face matching " << f
<< exit(FatalError);
@ -320,7 +320,7 @@ int main(int argc, char *argv[])
if (!ansysStream)
{
FatalErrorIn("ansysToFoam::main(int argc, char *argv[])")
FatalErrorInFunction
<< args.executable()
<< ": file " << ansysFile << " not found"
<< exit(FatalError);

12
applications/utilities/mesh/conversion/cfx4ToFoam/cfx4ToFoam.C
View File

@ -235,7 +235,7 @@ int main(int argc, char *argv[])
if (blockPFaces.size() != blockNFaces.size())
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Inconsistent number of faces for glue pair "
<< glueI << " between blocks " << blockPlabel + 1
<< " and " << blockNlabel + 1
@ -417,7 +417,7 @@ int main(int argc, char *argv[])
if (changedPointMerge == true)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Point merging failed after max number of passes."
<< abort(FatalError);
}
@ -448,7 +448,7 @@ int main(int argc, char *argv[])
if (pointMergeList[PpointLabel] == -1)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Unable to merge point " << blockPFacePointI
<< " of face " << blockPFaceLabel
<< " of block " << blockPlabel
@ -470,7 +470,7 @@ int main(int argc, char *argv[])
if (pointMergeList[NpointLabel] == -1)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Unable to merge point " << blockNFacePointI
<< " of face " << blockNFaceLabel
<< " of block " << blockNlabel
@ -489,7 +489,7 @@ int main(int argc, char *argv[])
{
if (pointMergeList[pointLabel] > pointLabel)
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "ouch" << abort(FatalError);
}
@ -692,7 +692,7 @@ int main(int argc, char *argv[])
}
else
{
FatalErrorIn(args.executable())
FatalErrorInFunction
<< "Unrecognised CFX patch type "
<< cfxPatchTypes[patchI]
<< abort(FatalError);

22
applications/utilities/mesh/conversion/cfx4ToFoam/hexBlock.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -136,7 +136,7 @@ labelListList hexBlock::blockCells() const
}
else
{
FatalErrorIn("hexBlock::cellShapes()")
FatalErrorInFunction
<< "Unable to determine block handedness as points "
<< "have not been read in yet"
<< abort(FatalError);
@ -155,10 +155,8 @@ faceList hexBlock::patchFaces(const label direc, const labelList& range) const
{
if (range.size() != 6)
{
FatalErrorIn
(
"patchFaces(const label direc, const labelList& range) const"
) << "Invalid size of the range array: " << range.size()
FatalErrorInFunction
<< "Invalid size of the range array: " << range.size()
<< ". Should be 6 (xMin, xMax, yMin, yMax, zMin, zMax"
<< abort(FatalError);
}
@ -351,10 +349,8 @@ faceList hexBlock::patchFaces(const label direc, const labelList& range) const
default:
{
FatalErrorIn
(
"patchFaces(const label direc, const labelList& range) const"
) << "direction out of range (1 to 6): " << direc
FatalErrorInFunction
<< "direction out of range (1 to 6): " << direc
<< abort(FatalError);
}
}
@ -363,10 +359,8 @@ faceList hexBlock::patchFaces(const label direc, const labelList& range) const
// Do nothing for the right-handed block
if (blockHandedness_ == noPoints)
{
FatalErrorIn
(
"patchFaces(const label direc, const labelList& range) const"
) << "Unable to determine block handedness as points "
FatalErrorInFunction
<< "Unable to determine block handedness as points "
<< "have not been read in yet"
<< abort(FatalError);
}

Some files were not shown because too many files have changed in this diff Show More