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

Completed 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-11 09:03:39 +00:00
parent dc43311e62
commit c4d5f65a10
678 changed files with 3357 additions and 8219 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.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
@ -63,15 +63,7 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolationMethodToWord
}
default:
{
FatalErrorIn
(
"const Foam::word"
"Foam::AMIInterpolation<SourcePatch, TargetPatch>::"
"interpolationMethodToWord"
"("
"const interpolationMethod&"
")"
)
FatalErrorInFunction
<< "Unhandled interpolationMethod enumeration " << method
<< abort(FatalError);
}
@ -121,16 +113,7 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::wordTointerpolationMethod
}
else
{
FatalErrorIn
(
"Foam::AMIInterpolation<SourcePatch, TargetPatch>::"
"interpolationMethod"
"Foam::AMIInterpolation<SourcePatch, TargetPatch>::"
"wordTointerpolationMethod"
"("
"const word&"
")"
)
FatalErrorInFunction
<< "Invalid interpolationMethod " << im
<< ". Valid methods are:" << methods
<< exit(FatalError);
@ -176,15 +159,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::projectPointsToSurface
if (nMiss > 0)
{
FatalErrorIn
(
"void Foam::AMIInterpolation<SourcePatch, TargetPatch>::"
"projectPointsToSurface"
"("
"const searchableSurface&, "
"pointField&"
") const"
)
FatalErrorInFunction
<< "Error projecting points to surface: "
<< nMiss << " faces could not be determined"
<< abort(FatalError);
@ -786,15 +761,8 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
|| fineAMI.tgtAddress().size() != targetRestrictAddressing.size()
)
{
FatalErrorIn
(
"AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation"
"("
"const AMIInterpolation<SourcePatch, TargetPatch>&, "
"const labelList&, "
"const labelList&"
")"
) << "Size mismatch." << nl
FatalErrorInFunction
<< "Size mismatch." << nl
<< "Source patch size:" << fineAMI.srcAddress().size() << nl
<< "Source agglomeration size:"
<< sourceRestrictAddressing.size() << nl
@ -1143,16 +1111,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
{
if (fld.size() != srcAddress_.size())
{
FatalErrorIn
(
"AMIInterpolation::interpolateToTarget"
"("
"const UList<Type>&, "
"const CombineOp&, "
"List<Type>&, "
"const UList<Type>&"
") const"
) << "Supplied field size is not equal to source patch size" << nl
FatalErrorInFunction
<< "Supplied field size is not equal to source patch size" << nl
<< " source patch = " << srcAddress_.size() << nl
<< " target patch = " << tgtAddress_.size() << nl
<< " supplied field = " << fld.size()
@ -1163,16 +1123,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
{
if (defaultValues.size() != tgtAddress_.size())
{
FatalErrorIn
(
"AMIInterpolation::interpolateToTarget"
"("
"const UList<Type>&, "
"const CombineOp&, "
"List<Type>&, "
"const UList<Type>&"
") const"
) << "Employing default values when sum of weights falls below "
FatalErrorInFunction
<< "Employing default values when sum of weights falls below "
<< lowWeightCorrection_
<< " but supplied default field size is not equal to target "
<< "patch size" << nl
@ -1244,16 +1196,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
{
if (fld.size() != tgtAddress_.size())
{
FatalErrorIn
(
"AMIInterpolation::interpolateToSource"
"("
"const UList<Type>&, "
"const CombineOp&, "
"List<Type>&, "
"const UList<Type>&"
") const"
) << "Supplied field size is not equal to target patch size" << nl
FatalErrorInFunction
<< "Supplied field size is not equal to target patch size" << nl
<< " source patch = " << srcAddress_.size() << nl
<< " target patch = " << tgtAddress_.size() << nl
<< " supplied field = " << fld.size()
@ -1264,16 +1208,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
{
if (defaultValues.size() != srcAddress_.size())
{
FatalErrorIn
(
"AMIInterpolation::interpolateToSource"
"("
"const UList<Type>&, "
"const CombineOp&, "
"List<Type>&, "
"const UList<Type>&"
") const"
) << "Employing default values when sum of weights falls below "
FatalErrorInFunction
<< "Employing default values when sum of weights falls below "
<< lowWeightCorrection_
<< " but supplied default field size is not equal to target "
<< "patch size" << nl

31
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethod.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013-2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2013-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -54,7 +54,7 @@ void Foam::AMIMethod<SourcePatch, TargetPatch>::checkPatches() const
if (!bbTgtInf.contains(bbSrc))
{
WarningIn("AMIMethod<SourcePatch, TargetPatch>::checkPatches()")
WarningInFunction
<< "Source and target patch bounding boxes are not similar"
<< nl
<< " source box span : " << bbSrc.span() << nl
@ -94,18 +94,7 @@ bool Foam::AMIMethod<SourcePatch, TargetPatch>::initialise
}
else if (!tgtPatch_.size())
{
WarningIn
(
"void Foam::AMIMethod<SourcePatch, TargetPatch>::initialise"
"("
"labelListList&, "
"scalarListList&, "
"labelListList&, "
"scalarListList&, "
"label&, "
"label&"
")"
)
WarningInFunction
<< srcPatch_.size() << " source faces but no target faces" << endl;
return false;
@ -135,18 +124,8 @@ bool Foam::AMIMethod<SourcePatch, TargetPatch>::initialise
{
if (requireMatch_)
{
FatalErrorIn
(
"void Foam::AMIMethod<SourcePatch, TargetPatch>::initialise"
"("
"labelListList&, "
"scalarListList&, "
"labelListList&, "
"scalarListList&, "
"label&, "
"label&"
")"
) << "Unable to find initial target face"
FatalErrorInFunction
<< "Unable to find initial target face"
<< abort(FatalError);
}

18
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethodNew.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013-2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2013-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -49,20 +49,8 @@ Foam::AMIMethod<SourcePatch, TargetPatch>::New
if (cstrIter == componentsConstructorTablePtr_->end())
{
FatalErrorIn
(
"AMIMethod<SourcePatch, TargetPatch>::New"
"("
"const word&, "
"const SourcePatch&, "
"const TargetPatch&, "
"const scalarField&, "
"const scalarField&, "
"const faceAreaIntersect::triangulationMode&, "
"const bool, "
"const bool"
")"
) << "Unknown AMIMethod type "
FatalErrorInFunction
<< "Unknown AMIMethod type "
<< methodName << nl << nl
<< "Valid AMIMethod types are:" << nl
<< componentsConstructorTablePtr_->sortedToc() << exit(FatalError);

29
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/faceAreaWeightAMI/faceAreaWeightAMI.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013-2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2013-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -284,20 +284,8 @@ void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::setNextFaces
if (errorOnNotFound)
{
FatalErrorIn
(
"void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::"
"setNextFaces"
"("
"label&, "
"label&, "
"label&, "
"const boolList&, "
"labelList&, "
"const DynamicList<label>&, "
"bool"
") const"
) << "Unable to set source and target faces" << abort(FatalError);
FatalErrorInFunction
<< "Unable to set source and target faces" << abort(FatalError);
}
}
}
@ -348,15 +336,8 @@ Foam::scalar Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::interArea
}
else
{
WarningIn
(
"void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::"
"interArea"
"("
"const label, "
"const label"
") const"
) << "Invalid normal for source face " << srcFaceI
WarningInFunction
<< "Invalid normal for source face " << srcFaceI
<< " points " << UIndirectList<point>(srcPoints, src)
<< " target face " << tgtFaceI
<< " points " << UIndirectList<point>(tgtPoints, tgt)

14
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/mapNearestAMI/mapNearestAMI.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013-2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2013-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -108,17 +108,7 @@ void Foam::mapNearestAMI<SourcePatch, TargetPatch>::setNextNearestFaces
{
const vectorField& srcCf = this->srcPatch_.faceCentres();
FatalErrorIn
(
"void Foam::mapNearestAMI<SourcePatch, TargetPatch>::"
"setNextNearestFaces"
"("
"boolList&, "
"label&, "
"label&, "
"label&"
") const"
)
FatalErrorInFunction
<< "Unable to find target face for source face "
<< srcFaceI << " with face centre " << srcCf[srcFaceI]
<< abort(FatalError);

14
src/meshTools/AMIInterpolation/faceAreaIntersect/faceAreaIntersect.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
@ -355,16 +355,8 @@ Foam::scalar Foam::faceAreaIntersect::calc
}
default:
{
FatalErrorIn
(
"Foam::scalar Foam::faceAreaIntersect::calc"
"("
"const face&, "
"const face&, "
"const vector&, "
"const triangulationMode&"
")"
) << "Unknown triangulation mode enumeration"
FatalErrorInFunction
<< "Unknown triangulation mode enumeration"
<< abort(FatalError);
}
}

22
src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPointPatchField/cyclicACMIPointPatchField.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2013-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -59,14 +59,8 @@ Foam::cyclicACMIPointPatchField<Type>::cyclicACMIPointPatchField
{
if (!isType<cyclicACMIPointPatch>(p))
{
FatalIOErrorIn
FatalIOErrorInFunction
(
"cyclicACMIPointPatchField<Type>::cyclicACMIPointPatchField\n"
"(\n"
" const pointPatch&,\n"
" const DimensionedField<Type, pointMesh>&,\n"
" const dictionary&\n"
")\n",
dict
) << "patch " << this->patch().index() << " not cyclicACMI type. "
<< "Patch type = " << p.type()
@ -91,16 +85,8 @@ Foam::cyclicACMIPointPatchField<Type>::cyclicACMIPointPatchField
{
if (!isType<cyclicACMIPointPatch>(this->patch()))
{
FatalErrorIn
(
"cyclicACMIPointPatchField<Type>::cyclicACMIPointPatchField\n"
"(\n"
" const cyclicACMIPointPatchField<Type>&,\n"
" const pointPatch&,\n"
" const DimensionedField<Type, pointMesh>&,\n"
" const pointPatchFieldMapper&\n"
")\n"
) << "Field type does not correspond to patch type for patch "
FatalErrorInFunction
<< "Field type does not correspond to patch type for patch "
<< this->patch().index() << "." << endl
<< "Field type: " << typeName << endl
<< "Patch type: " << this->patch().type()

35
src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.C
View File

@ -135,7 +135,7 @@ void Foam::cyclicACMIPolyPatch::setNeighbourFaceAreas() const
}
else
{
WarningIn("cyclicACMIPolyPatch::setNeighbourFaceAreas() const")
WarningInFunction
<< "Target mask size differs to that of the neighbour patch\n"
<< " May occur when decomposing." << endl;
}
@ -259,16 +259,8 @@ Foam::cyclicACMIPolyPatch::cyclicACMIPolyPatch
if (nonOverlapPatchName_ == name)
{
FatalIOErrorIn
FatalIOErrorInFunction
(
"cyclicACMIPolyPatch::cyclicACMIPolyPatch"
"("
"const word&, "
"const dictionary&, "
"const label, "
"const polyBoundaryMesh&, "
"const word&"
")",
dict
) << "Non-overlapping patch name " << nonOverlapPatchName_
<< " cannot be the same as this patch " << name
@ -324,16 +316,8 @@ Foam::cyclicACMIPolyPatch::cyclicACMIPolyPatch
if (nonOverlapPatchName_ == name())
{
FatalErrorIn
(
"const cyclicACMIPolyPatch& "
"const polyBoundaryMesh&, "
"const label, "
"const label, "
"const label, "
"const word&, "
"const word&"
) << "Non-overlapping patch name " << nonOverlapPatchName_
FatalErrorInFunction
<< "Non-overlapping patch name " << nonOverlapPatchName_
<< " cannot be the same as this patch " << name()
<< exit(FatalError);
}
@ -388,7 +372,7 @@ Foam::label Foam::cyclicACMIPolyPatch::nonOverlapPatchID() const
if (nonOverlapPatchID_ == -1)
{
FatalErrorIn("cyclicPolyAMIPatch::neighbPatchID() const")
FatalErrorInFunction
<< "Illegal non-overlapping patch name " << nonOverlapPatchName_
<< nl << "Valid patch names are "
<< this->boundaryMesh().names()
@ -397,7 +381,7 @@ Foam::label Foam::cyclicACMIPolyPatch::nonOverlapPatchID() const
if (nonOverlapPatchID_ < index())
{
FatalErrorIn("cyclicPolyAMIPatch::neighbPatchID() const")
FatalErrorInFunction
<< "Boundary ordering error: " << type()
<< " patch must be defined prior to its non-overlapping patch"
<< nl
@ -434,11 +418,8 @@ Foam::label Foam::cyclicACMIPolyPatch::nonOverlapPatchID() const
if (!ok)
{
FatalErrorIn
(
"Foam::label "
"Foam::cyclicACMIPolyPatch::nonOverlapPatchID() const"
) << "Inconsistent ACMI patches " << name() << " and "
FatalErrorInFunction
<< "Inconsistent ACMI patches " << name() << " and "
<< noPp.name() << ". Patches should have identical topology"
<< exit(FatalError);
}

22
src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatchField/cyclicAMIPointPatchField.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
@ -59,14 +59,8 @@ Foam::cyclicAMIPointPatchField<Type>::cyclicAMIPointPatchField
{
if (!isType<cyclicAMIPointPatch>(p))
{
FatalIOErrorIn
FatalIOErrorInFunction
(
"cyclicAMIPointPatchField<Type>::cyclicAMIPointPatchField\n"
"(\n"
" const pointPatch&,\n"
" const DimensionedField<Type, pointMesh>&,\n"
" const dictionary&\n"
")\n",
dict
) << "patch " << this->patch().index() << " not cyclicAMI type. "
<< "Patch type = " << p.type()
@ -91,16 +85,8 @@ Foam::cyclicAMIPointPatchField<Type>::cyclicAMIPointPatchField
{
if (!isType<cyclicAMIPointPatch>(this->patch()))
{
FatalErrorIn
(
"cyclicAMIPointPatchField<Type>::cyclicAMIPointPatchField\n"
"(\n"
" const cyclicAMIPointPatchField<Type>&,\n"
" const pointPatch&,\n"
" const DimensionedField<Type, pointMesh>&,\n"
" const pointPatchFieldMapper&\n"
")\n"
) << "Field type does not correspond to patch type for patch "
FatalErrorInFunction
<< "Field type does not correspond to patch type for patch "
<< this->patch().index() << "." << endl
<< "Field type: " << typeName << endl
<< "Patch type: " << this->patch().type()

62
src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
View File

@ -116,7 +116,7 @@ void Foam::cyclicAMIPolyPatch::calcTransforms
{
if (transform() != neighbPatch().transform())
{
FatalErrorIn("cyclicAMIPolyPatch::calcTransforms()")
FatalErrorInFunction
<< "Patch " << name()
<< " has transform type " << transformTypeNames[transform()]
<< ", neighbour patch " << neighbPatchName()
@ -188,17 +188,8 @@ void Foam::cyclicAMIPolyPatch::calcTransforms
if (areaError > matchTolerance())
{
WarningIn
(
"void Foam::cyclicAMIPolyPatch::calcTransforms"
"("
"const primitivePatch&, "
"const pointField&, "
"const vectorField&, "
"const pointField&, "
"const vectorField&"
")"
) << "Patch areas are not consistent within "
WarningInFunction
<< "Patch areas are not consistent within "
<< 100*matchTolerance()
<< " % indicating a possible error in the specified "
<< "angle of rotation" << nl
@ -538,15 +529,8 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
{
if (nbrPatchName_ == word::null && !coupleGroup_.valid())
{
FatalIOErrorIn
FatalIOErrorInFunction
(
"cyclicAMIPolyPatch::cyclicAMIPolyPatch"
"("
"const word&, "
"const dictionary&, "
"const label, "
"const polyBoundaryMesh&"
")",
dict
) << "No \"neighbourPatch\" or \"coupleGroup\" provided."
<< exit(FatalIOError);
@ -554,15 +538,8 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
if (nbrPatchName_ == name)
{
FatalIOErrorIn
FatalIOErrorInFunction
(
"cyclicAMIPolyPatch::cyclicAMIPolyPatch"
"("
"const word&, "
"const dictionary&, "
"const label, "
"const polyBoundaryMesh&"
")",
dict
) << "Neighbour patch name " << nbrPatchName_
<< " cannot be the same as this patch " << name
@ -590,15 +567,8 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
scalar magRot = mag(rotationAxis_);
if (magRot < SMALL)
{
FatalIOErrorIn
FatalIOErrorInFunction
(
"cyclicAMIPolyPatch::cyclicAMIPolyPatch"
"("
"const word&, "
"const dictionary&, "
"const label, "
"const polyBoundaryMesh&"
")",
dict
) << "Illegal rotationAxis " << rotationAxis_ << endl
<< "Please supply a non-zero vector."
@ -679,15 +649,8 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
{
if (nbrPatchName_ == name())
{
FatalErrorIn
(
"const cyclicAMIPolyPatch& "
"const polyBoundaryMesh&, "
"const label, "
"const label, "
"const label, "
"const word&"
) << "Neighbour patch name " << nbrPatchName_
FatalErrorInFunction
<< "Neighbour patch name " << nbrPatchName_
<< " cannot be the same as this patch " << name()
<< exit(FatalError);
}
@ -740,7 +703,7 @@ Foam::label Foam::cyclicAMIPolyPatch::neighbPatchID() const
if (nbrPatchID_ == -1)
{
FatalErrorIn("cyclicPolyAMIPatch::neighbPatchID() const")
FatalErrorInFunction
<< "Illegal neighbourPatch name " << neighbPatchName()
<< nl << "Valid patch names are "
<< this->boundaryMesh().names()
@ -756,7 +719,7 @@ Foam::label Foam::cyclicAMIPolyPatch::neighbPatchID() const
if (nbrPatch.neighbPatchName() != name())
{
WarningIn("cyclicAMIPolyPatch::neighbPatchID() const")
WarningInFunction
<< "Patch " << name()
<< " specifies neighbour patch " << neighbPatchName()
<< nl << " but that in return specifies "
@ -817,10 +780,7 @@ const Foam::AMIPatchToPatchInterpolation& Foam::cyclicAMIPolyPatch::AMI() const
{
if (!owner())
{
FatalErrorIn
(
"const AMIPatchToPatchInterpolation& cyclicAMIPolyPatch::AMI()"
)
FatalErrorInFunction
<< "AMI interpolator only available to owner patch"
<< abort(FatalError);
}

41
src/meshTools/algorithms/MeshWave/FaceCellWave.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
@ -274,11 +274,7 @@ void Foam::FaceCellWave<Type, TrackingData>::checkCyclic
)
)
{
FatalErrorIn
(
"FaceCellWave<Type, TrackingData>"
"::checkCyclic(const polyPatch&)"
) << "problem: i:" << i1 << " otheri:" << i2
FatalErrorInFunction
<< " faceInfo:" << allFaceInfo_[i1]
<< " otherfaceInfo:" << allFaceInfo_[i2]
<< abort(FatalError);
@ -286,11 +282,7 @@ void Foam::FaceCellWave<Type, TrackingData>::checkCyclic
if (changedFace_[i1] != changedFace_[i2])
{
FatalErrorIn
(
"FaceCellWave<Type, TrackingData>"
"::checkCyclic(const polyPatch&)"
) << " problem: i:" << i1 << " otheri:" << i2
FatalErrorInFunction
<< " faceInfo:" << allFaceInfo_[i1]
<< " otherfaceInfo:" << allFaceInfo_[i2]
<< " changedFace:" << changedFace_[i1]
@ -847,12 +839,8 @@ Foam::FaceCellWave<Type, TrackingData>::FaceCellWave
|| allCellInfo.size() != mesh_.nCells()
)
{
FatalErrorIn
(
"FaceCellWave<Type, TrackingData>::FaceCellWave"
"(const polyMesh&, const labelList&, const List<Type>,"
" UList<Type>&, UList<Type>&, const label maxIter)"
) << "face and cell storage not the size of mesh faces, cells:"
FatalErrorInFunction
<< "face and cell storage not the size of mesh faces, cells:"
<< endl
<< " allFaceInfo :" << allFaceInfo.size() << endl
<< " mesh_.nFaces():" << mesh_.nFaces() << endl
@ -902,12 +890,8 @@ Foam::FaceCellWave<Type, TrackingData>::FaceCellWave
|| allCellInfo.size() != mesh_.nCells()
)
{
FatalErrorIn
(
"FaceCellWave<Type, TrackingData>::FaceCellWave"
"(const polyMesh&, const labelList&, const List<Type>,"
" UList<Type>&, UList<Type>&, const label maxIter)"
) << "face and cell storage not the size of mesh faces, cells:"
FatalErrorInFunction
<< "face and cell storage not the size of mesh faces, cells:"
<< endl
<< " allFaceInfo :" << allFaceInfo.size() << endl
<< " mesh_.nFaces():" << mesh_.nFaces() << endl
@ -924,12 +908,7 @@ Foam::FaceCellWave<Type, TrackingData>::FaceCellWave
if ((maxIter > 0) && (iter >= maxIter))
{
FatalErrorIn
(
"FaceCellWave<Type, TrackingData>::FaceCellWave"
"(const polyMesh&, const labelList&, const List<Type>,"
" UList<Type>&, UList<Type>&, const label maxIter)"
)
FatalErrorInFunction
<< "Maximum number of iterations reached. Increase maxIter." << endl
<< " maxIter:" << maxIter << endl
<< " nChangedCells:" << nChangedCells_ << endl
@ -975,7 +954,7 @@ Foam::label Foam::FaceCellWave<Type, TrackingData>::faceToCell()
label faceI = changedFaces_[changedFaceI];
if (!changedFace_[faceI])
{
FatalErrorIn("FaceCellWave<Type, TrackingData>::faceToCell()")
FatalErrorInFunction
<< "Face " << faceI
<< " not marked as having been changed"
<< abort(FatalError);
@ -1058,7 +1037,7 @@ Foam::label Foam::FaceCellWave<Type, TrackingData>::cellToFace()
label cellI = changedCells_[changedCellI];
if (!changedCell_[cellI])
{
FatalErrorIn("FaceCellWave<Type, TrackingData>::cellToFace()")
FatalErrorInFunction
<< "Cell " << cellI << " not marked as having been changed"
<< abort(FatalError);
}

30
src/meshTools/algorithms/PatchEdgeFaceWave/PatchEdgeFaceWave.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
@ -328,12 +328,8 @@ PatchEdgeFaceWave
if (allEdgeInfo_.size() != patch_.nEdges())
{
FatalErrorIn
(
"PatchEdgeFaceWave<Type, TrackingData>::PatchEdgeFaceWave"
"(const polyMesh&, const labelList&, const List<Type>,"
" List<Type>&, List<Type>&, const label maxIter)"
) << "size of edgeInfo work array is not equal to the number"
FatalErrorInFunction
<< "size of edgeInfo work array is not equal to the number"
<< " of edges in the patch" << endl
<< " edgeInfo :" << allEdgeInfo_.size() << endl
<< " patch.nEdges:" << patch_.nEdges()
@ -341,12 +337,8 @@ PatchEdgeFaceWave
}
if (allFaceInfo_.size() != patch_.size())
{
FatalErrorIn
(
"PatchEdgeFaceWave<Type, TrackingData>::PatchEdgeFaceWave"
"(const polyMesh&, const labelList&, const List<Type>,"
" List<Type>&, List<Type>&, const label maxIter)"
) << "size of edgeInfo work array is not equal to the number"
FatalErrorInFunction
<< "size of edgeInfo work array is not equal to the number"
<< " of faces in the patch" << endl
<< " faceInfo :" << allFaceInfo_.size() << endl
<< " patch.size:" << patch_.size()
@ -367,12 +359,8 @@ PatchEdgeFaceWave
if ((maxIter > 0) && (iter >= maxIter))
{
FatalErrorIn
(
"PatchEdgeFaceWave<Type, TrackingData>::PatchEdgeFaceWave"
"(const polyMesh&, const labelList&, const List<Type>,"
" List<Type>&, List<Type>&, const label maxIter)"
) << "Maximum number of iterations reached. Increase maxIter." << endl
FatalErrorInFunction
<< "Maximum number of iterations reached. Increase maxIter." << endl
<< " maxIter:" << maxIter << endl
<< " changedEdges:" << changedEdges_.size() << endl
<< " changedFaces:" << changedFaces_.size() << endl
@ -511,7 +499,7 @@ faceToEdge()
if (!changedFace_[faceI])
{
FatalErrorIn("PatchEdgeFaceWave<Type, TrackingData>::faceToEdge()")
FatalErrorInFunction
<< "face " << faceI
<< " not marked as having been changed" << nl
<< "This might be caused by multiple occurences of the same"
@ -576,7 +564,7 @@ edgeToFace()
if (!changedEdge_[edgeI])
{
FatalErrorIn("PatchEdgeFaceWave<Type, TrackingData>::edgeToFace()")
FatalErrorInFunction
<< "edge " << edgeI
<< " not marked as having been changed" << nl
<< "This might be caused by multiple occurences of the same"

4
src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegionI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2012-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -39,7 +39,7 @@ inline bool Foam::patchEdgeFaceRegion::update
{
if (!w2.valid(td))
{
FatalErrorIn("patchEdgeFaceRegion::update(..)")
FatalErrorInFunction
<< "problem." << abort(FatalError);
}

8
src/meshTools/algorithms/PatchEdgeFaceWave/patchEdgeFaceRegionsI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2013-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -110,7 +110,7 @@ inline bool Foam::patchEdgeFaceRegions::updateEdge
if (!faceInfo.valid(td))
{
FatalErrorIn("patchEdgeFaceRegions::updateEdge(..)")
FatalErrorInFunction
<< "problem." << abort(FatalError);
}
@ -157,7 +157,7 @@ inline bool Foam::patchEdgeFaceRegions::updateEdge
if (!edgeInfo.valid(td))
{
FatalErrorIn("patchEdgeFaceRegions::updateEdge(..)")
FatalErrorInFunction
<< "problem." << abort(FatalError);
}
@ -217,7 +217,7 @@ inline bool Foam::patchEdgeFaceRegions::updateFace
if (!edgeInfo.valid(td))
{
FatalErrorIn("patchEdgeFaceRegions::updateFace(..)")
FatalErrorInFunction
<< "problem." << abort(FatalError);
}

37
src/meshTools/algorithms/PointEdgeWave/PointEdgeWave.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
@ -134,11 +134,8 @@ void Foam::PointEdgeWave<Type, TrackingData>::transform
}
else
{
FatalErrorIn
(
"PointEdgeWave<Type, TrackingData>::transform"
"(const tensorField&, List<Type>&)"
) << "Non-uniform transformation on patch " << patch.name()
FatalErrorInFunction
<< "Non-uniform transformation on patch " << patch.name()
<< " of type " << patch.type()
<< " not supported for point fields"
<< abort(FatalError);
@ -638,12 +635,8 @@ Foam::PointEdgeWave<Type, TrackingData>::PointEdgeWave
{
if (allPointInfo_.size() != mesh_.nPoints())
{
FatalErrorIn
(
"PointEdgeWave<Type, TrackingData>::PointEdgeWave"
"(const polyMesh&, const labelList&, const List<Type>,"
" List<Type>&, List<Type>&, const label maxIter)"
) << "size of pointInfo work array is not equal to the number"
FatalErrorInFunction
<< "size of pointInfo work array is not equal to the number"
<< " of points in the mesh" << endl
<< " pointInfo :" << allPointInfo_.size() << endl
<< " mesh.nPoints:" << mesh_.nPoints()
@ -651,12 +644,8 @@ Foam::PointEdgeWave<Type, TrackingData>::PointEdgeWave
}
if (allEdgeInfo_.size() != mesh_.nEdges())
{
FatalErrorIn
(
"PointEdgeWave<Type, TrackingData>::PointEdgeWave"
"(const polyMesh&, const labelList&, const List<Type>,"
" List<Type>&, List<Type>&, const label maxIter)"
) << "size of edgeInfo work array is not equal to the number"
FatalErrorInFunction
<< "size of edgeInfo work array is not equal to the number"
<< " of edges in the mesh" << endl
<< " edgeInfo :" << allEdgeInfo_.size() << endl
<< " mesh.nEdges:" << mesh_.nEdges()
@ -678,12 +667,8 @@ Foam::PointEdgeWave<Type, TrackingData>::PointEdgeWave
if ((maxIter > 0) && (iter >= maxIter))
{
FatalErrorIn
(
"PointEdgeWave<Type, TrackingData>::PointEdgeWave"
"(const polyMesh&, const labelList&, const List<Type>,"
" List<Type>&, List<Type>&, const label maxIter)"
) << "Maximum number of iterations reached. Increase maxIter." << endl
FatalErrorInFunction
<< "Maximum number of iterations reached. Increase maxIter." << endl
<< " maxIter:" << maxIter << endl
<< " nChangedPoints:" << nChangedPoints_ << endl
<< " nChangedEdges:" << nChangedEdges_ << endl
@ -794,7 +779,7 @@ Foam::label Foam::PointEdgeWave<Type, TrackingData>::edgeToPoint()
if (!changedEdge_[edgeI])
{
FatalErrorIn("PointEdgeWave<Type, TrackingData>::edgeToPoint()")
FatalErrorInFunction
<< "edge " << edgeI
<< " not marked as having been changed" << nl
<< "This might be caused by multiple occurences of the same"
@ -872,7 +857,7 @@ Foam::label Foam::PointEdgeWave<Type, TrackingData>::pointToEdge()
if (!changedPoint_[pointI])
{
FatalErrorIn("PointEdgeWave<Type, TrackingData>::pointToEdge()")
FatalErrorInFunction
<< "Point " << pointI
<< " not marked as having been changed" << nl
<< "This might be caused by multiple occurences of the same"

16
src/meshTools/cellClassification/cellClassification.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
@ -287,11 +287,8 @@ void Foam::cellClassification::markCells
if (returnReduce(cellI, maxOp<label>()) == -1)
{
FatalErrorIn
(
"List<cellClassification::cType> markCells"
"(const meshSearch&, const boolList&, const pointField&)"
) << "outsidePoint " << outsidePts[outsidePtI]
FatalErrorInFunction
<< "outsidePoint " << outsidePts[outsidePtI]
<< " is not inside any cell"
<< nl << "It might be on a face or outside the geometry"
<< exit(FatalError);
@ -513,11 +510,8 @@ Foam::cellClassification::cellClassification
{
if (mesh_.nCells() != size())
{
FatalErrorIn
(
"cellClassification::cellClassification"
"(const polyMesh&, const labelList&)"
) << "Number of elements of cellType argument is not equal to the"
FatalErrorInFunction
<< "Number of elements of cellType argument is not equal to the"
<< " number of cells" << abort(FatalError);
}
}

6
src/meshTools/cellClassification/cellInfoI.H
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
@ -46,7 +46,7 @@ inline bool Foam::cellInfo::update
|| (w2.type() == cellClassification::CUT)
)
{
FatalErrorIn("cellInfo::update(const cellInfo&)")
FatalErrorInFunction
<< "Problem: trying to propagate NOTSET or CUT type:" << w2.type()
<< " into cell/face with type:" << type() << endl
<< "thisFaceI:" << thisFaceI
@ -77,7 +77,7 @@ inline bool Foam::cellInfo::update
}
// Two conflicting types
FatalErrorIn("cellInfo::update(const cellInfo&)")
FatalErrorInFunction
<< "Problem: trying to propagate conflicting types:" << w2.type()
<< " into cell/face with type:" << type() << endl
<< "thisFaceI:" << thisFaceI

12
src/meshTools/cellDist/cellDistFuncs.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
@ -186,25 +186,25 @@ Foam::label Foam::cellDistFuncs::getPointNeighbours
if (!nbs.found(nb))
{
SeriousErrorIn("Foam::cellDistFuncs::getPointNeighbours")
SeriousErrorInFunction
<< "getPointNeighbours : patchFaceI:" << patchFaceI
<< " verts:" << f << endl;
forAll(f, fp)
{
SeriousErrorIn("Foam::cellDistFuncs::getPointNeighbours")
SeriousErrorInFunction
<< "point:" << f[fp] << " pointFaces:"
<< patch.pointFaces()[f[fp]] << endl;
}
for (label i = 0; i < nNeighbours; i++)
{
SeriousErrorIn("Foam::cellDistFuncs::getPointNeighbours")
SeriousErrorInFunction
<< "fast nbr:" << neighbours[i]
<< endl;
}
FatalErrorIn("getPointNeighbours")
FatalErrorInFunction
<< "Problem: fast pointNeighbours routine included " << nb
<< " which is not in proper neigbour list " << nbs.toc()
<< abort(FatalError);
@ -214,7 +214,7 @@ Foam::label Foam::cellDistFuncs::getPointNeighbours
if (nbs.size())
{
FatalErrorIn("getPointNeighbours")
FatalErrorInFunction
<< "Problem: fast pointNeighbours routine did not find "
<< nbs.toc() << abort(FatalError);
}

42
src/meshTools/cellFeatures/cellFeatures.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
@ -53,10 +53,8 @@ bool Foam::cellFeatures::faceAlignedEdge(const label faceI, const label edgeI)
}
}
FatalErrorIn
(
"cellFeatures::faceAlignedEdge(const label, const label)"
) << "Can not find edge " << mesh_.edges()[edgeI]
FatalErrorInFunction
<< "Can not find edge " << mesh_.edges()[edgeI]
<< " on face " << faceI << abort(FatalError);
return false;
@ -101,11 +99,8 @@ Foam::label Foam::cellFeatures::nextEdge
}
}
FatalErrorIn
(
"cellFeatures::nextEdge(const label, const Map<label>"
", const labelHashSet&, const label, const label, const label)"
) << "Can not find edge in " << featureEdge_ << " connected to edge "
FatalErrorInFunction
<< "Can not find edge in " << featureEdge_ << " connected to edge "
<< thisEdgeI << " at vertex " << thisVertI << endl
<< "This might mean that the externalEdges do not form a closed loop"
<< abort(FatalError);
@ -359,7 +354,7 @@ void Foam::cellFeatures::calcSuperFaces() const
if (superFace.size() <= 2)
{
WarningIn("cellFeatures::calcSuperFaces")
WarningInFunction
<< " Can not collapse faces " << faceMap_[superFaceI]
<< " into one big face on cell " << cellI_ << endl
<< "Try decreasing minCos:" << minCos_ << endl;
@ -427,10 +422,8 @@ bool Foam::cellFeatures::isFeaturePoint(const label edge0, const label edge1)
|| (edge1 >= mesh_.nEdges())
)
{
FatalErrorIn
(
"cellFeatures::isFeatureVertex(const label, const label)"
) << "Illegal edge labels : edge0:" << edge0 << " edge1:" << edge1
FatalErrorInFunction
<< "Illegal edge labels : edge0:" << edge0 << " edge1:" << edge1
<< abort(FatalError);
}
@ -468,11 +461,8 @@ bool Foam::cellFeatures::isFeaturePoint(const label edge0, const label edge1)
{
cosAngle = GREAT; // satisfy compiler
FatalErrorIn
(
"cellFeatures::isFeaturePoint(const label, const label"
", const label)"
) << "Edges do not share common vertex. e0:" << e0
FatalErrorInFunction
<< "Edges do not share common vertex. e0:" << e0
<< " e1:" << e1 << abort(FatalError);
}
@ -499,10 +489,8 @@ bool Foam::cellFeatures::isFeatureVertex(const label faceI, const label vertI)
|| (vertI >= mesh_.nPoints())
)
{
FatalErrorIn
(
"cellFeatures::isFeatureVertex(const label, const label)"
) << "Illegal face " << faceI << " or vertex " << vertI
FatalErrorInFunction
<< "Illegal face " << faceI << " or vertex " << vertI
<< abort(FatalError);
}
@ -533,10 +521,8 @@ bool Foam::cellFeatures::isFeatureVertex(const label faceI, const label vertI)
if (edge1 == -1)
{
FatalErrorIn
(
"cellFeatures::isFeatureVertex(const label, const label)"
) << "Did not find two edges sharing vertex " << vertI
FatalErrorInFunction
<< "Did not find two edges sharing vertex " << vertI
<< " on face " << faceI << " vertices:" << mesh_.faces()[faceI]
<< abort(FatalError);
}

18
src/meshTools/coordinateSystems/coordinateRotation/axesRotation.C
View File

@ -57,7 +57,7 @@ void Foam::axesRotation::calcTransform
if (mag(b) < SMALL)
{
FatalErrorIn("axesRotation::calcTransform()")
FatalErrorInFunction
<< "axis1, axis2 appear co-linear: "
<< axis1 << ", " << axis2 << endl
<< abort(FatalError);
@ -86,15 +86,7 @@ void Foam::axesRotation::calcTransform
}
default:
{
FatalErrorIn
(
"axesRotation::calcTransform"
"("
"const vector&,"
"const vector&,"
"const axisOrder&"
")"
)
FatalErrorInFunction
<< "Unhandled axes specifictation" << endl
<< abort(FatalError);
@ -294,10 +286,8 @@ void Foam::axesRotation::operator=(const dictionary& dict)
}
else
{
FatalErrorIn
(
"axesRotation::operator=(const dictionary&) "
) << "not entry of the type (e1, e2) or (e2, e3) or (e3, e1) "
FatalErrorInFunction
<< "not entry of the type (e1, e2) or (e2, e3) or (e3, e1) "
<< "found "
<< exit(FatalError);
}

15
src/meshTools/coordinateSystems/coordinateRotation/coordinateRotationNew.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
@ -47,13 +47,8 @@ Foam::autoPtr<Foam::coordinateRotation> Foam::coordinateRotation::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalIOErrorIn
FatalIOErrorInFunction
(
"coordinateRotation::New"
"("
" const dictionary&, "
" const objectRegistry& "
")",
dict
) << "Unknown coordinateRotation type "
<< rotType << nl << nl
@ -86,12 +81,8 @@ Foam::autoPtr<Foam::coordinateRotation> Foam::coordinateRotation::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalIOErrorIn
FatalIOErrorInFunction
(
"coordinateRotation::New"
"("
" const dictionary&, "
")",
dict
) << "Unknown coordinateRotation type "
<< rotType << nl << nl

26
src/meshTools/coordinateSystems/coordinateRotation/cylindrical.C
View File

@ -152,7 +152,7 @@ Foam::cylindrical::cylindrical(const dictionary& dict)
origin_(),
e3_()
{
FatalErrorIn("cylindrical(const dictionary&)")
FatalErrorInFunction
<< " cylindrical can not be constructed from dictionary "
<< " use the construtctor : "
"("
@ -210,10 +210,7 @@ Foam::tmp<Foam::vectorField> Foam::cylindrical::transform
{
if (Rptr_->size() != vf.size())
{
FatalErrorIn
(
"tmp<vectorField> cylindrical::transform(const vectorField&)"
)
FatalErrorInFunction
<< "vectorField st has different size to tensorField "
<< abort(FatalError);
}
@ -272,13 +269,7 @@ Foam::tmp<Foam::tensorField> Foam::cylindrical::transformTensor
{
if (Rptr_->size() != tf.size())
{
FatalErrorIn
(
"tmp<tensorField> cylindrical::transformTensor"
"("
"const tensorField&"
")"
)
FatalErrorInFunction
<< "tensorField st has different size to tensorField Tr"
<< abort(FatalError);
}
@ -305,14 +296,7 @@ Foam::tmp<Foam::tensorField> Foam::cylindrical::transformTensor
{
if (cellMap.size() != tf.size())
{
FatalErrorIn
(
"tmp<tensorField> cylindrical::transformTensor"
"("
"const tensorField&, "
"const labelList&"
")"
)
FatalErrorInFunction
<< "tensorField tf has different size to tensorField Tr"
<< abort(FatalError);
}
@ -338,7 +322,7 @@ Foam::tmp<Foam::symmTensorField> Foam::cylindrical::transformVector
{
if (Rptr_->size() != vf.size())
{
FatalErrorIn("cylindrical::transformVector(const vectorField&)")
FatalErrorInFunction
<< "tensorField vf has different size to tensorField Tr"
<< abort(FatalError);
}

9
src/meshTools/coordinateSystems/coordinateSystem.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
@ -147,11 +147,8 @@ Foam::coordinateSystem::coordinateSystem
if (index < 0)
{
FatalErrorIn
(
"coordinateSystem::coordinateSystem"
"(const objectRegistry&, const dictionary&):"
) << "could not find coordinate system: " << key << nl
FatalErrorInFunction
<< "could not find coordinate system: " << key << nl
<< "available coordinate systems: " << lst.toc() << nl << nl
<< exit(FatalError);
}

5
src/meshTools/coordinateSystems/coordinateSystemNew.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
@ -42,9 +42,8 @@ Foam::autoPtr<Foam::coordinateSystem> Foam::coordinateSystem::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalIOErrorIn
FatalIOErrorInFunction
(
"coordinateSystem::New(const objectRegistry&, const dictionary&)",
dict
) << "Unknown coordinateSystem type "
<< coordType << nl << nl

22
src/meshTools/edgeFaceCirculator/edgeFaceCirculatorI.H
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
@ -44,10 +44,8 @@ void Foam::edgeFaceCirculator::setFace
if (!isBoundaryEdge_ && !mesh_.isInternalFace(faceI))
{
FatalErrorIn
(
"edgeFaceCirculator::setFace(const label, const label)"
) << "Edge is not defined as boundary edge but still walked to"
FatalErrorInFunction
<< "Edge is not defined as boundary edge but still walked to"
<< " boundary face:" << faceI << " on cell:" << cellI
<< abort(FatalError);
}
@ -79,7 +77,7 @@ void Foam::edgeFaceCirculator::otherFace(const label cellI)
}
}
FatalErrorIn("edgeFaceCirculator::otherFace(const label)")
FatalErrorInFunction
<< "Could not find next face stepping"
<< " through cell along edge." << endl
<< "face:" << faceLabel_ << " index in face:" << index_
@ -197,10 +195,8 @@ bool Foam::edgeFaceCirculator::sameOrder(const label v0, const label v1) const
if (fp != index_)
{
FatalErrorIn
(
"edgeFaceCirculator::sameOrder(const label, const label) const"
) << "v0:" << v1 << " and v1:" << v1
FatalErrorInFunction
<< "v0:" << v1 << " and v1:" << v1
<< " not on position:" << index_ << " on face:" << faceLabel_
<< " verts:" << f << " or not consecutive." << abort(FatalError);
}
@ -255,7 +251,7 @@ void Foam::edgeFaceCirculator::setCanonical()
{
const face& f = mesh_.faces()[faceLabel_];
FatalErrorIn("Foam::edgeFaceCirculator::setCanonical()")
FatalErrorInFunction
<< "Walked " << i << " cells around edge "
<< mesh_.points()[f[index_]]
<< mesh_.points()[f.nextLabel(index_)]
@ -289,7 +285,7 @@ void Foam::edgeFaceCirculator::setCanonical()
{
const face& f = mesh_.faces()[faceLabel_];
FatalErrorIn("Foam::edgeFaceCirculator::setCanonical()")
FatalErrorInFunction
<< "Reached boundary face " << faceLabel_
<< " when walking around internal edge "
<< mesh_.points()[f[index_]]
@ -357,7 +353,7 @@ Foam::edgeFaceCirculator::operator++()
{
if (faceLabel_ == -1)
{
FatalErrorIn("edgeFaceCirculator::operator++()")
FatalErrorInFunction
<< "Already reached end(). Cannot walk any further."
<< abort(FatalError);
}

7
src/meshTools/indexedOctree/treeDataFace.C
View File

@ -202,11 +202,8 @@ Foam::volumeType Foam::treeDataFace::getVolumeType
if (info.index() == -1)
{
FatalErrorIn
(
"treeDataFace::getSampleType"
"(indexedOctree<treeDataFace>&, const point&)"
) << "Could not find " << sample << " in octree."
FatalErrorInFunction
<< "Could not find " << sample << " in octree."
<< abort(FatalError);
}

19
src/meshTools/indexedOctree/treeDataPrimitivePatch.C
View File

@ -171,11 +171,8 @@ Foam::volumeType Foam::treeDataPrimitivePatch<PatchType>::getVolumeType
if (info.index() == -1)
{
FatalErrorIn
(
"treeDataPrimitivePatch::getSampleType"
"(indexedOctree<treeDataPrimitivePatch>&, const point&)"
) << "Could not find " << sample << " in octree."
FatalErrorInFunction
<< "Could not find " << sample << " in octree."
<< abort(FatalError);
}
@ -588,16 +585,8 @@ bool Foam::treeDataPrimitivePatch<PatchType>::findSelfIntersectOp::operator()
{
if (edgeID_ == -1)
{
FatalErrorIn
(
"findSelfIntersectOp::operator()\n"
"(\n"
" const label index,\n"
" const point& start,\n"
" const point& end,\n"
" point& intersectionPoint\n"
") const"
) << "EdgeID not set. Please set edgeID to the index of"
FatalErrorInFunction
<< "EdgeID not set. Please set edgeID to the index of"
<< " the edge you are testing"
<< exit(FatalError);
}

11
src/meshTools/indexedOctree/treeDataTriSurface.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
@ -40,11 +40,8 @@ Foam::volumeType Foam::treeDataPrimitivePatch<Foam::triSurface>::getVolumeType
if (info.index() == -1)
{
FatalErrorIn
(
"treeDataPrimitivePatch::getSampleType"
"(indexedOctree<treeDataPrimitivePatch>&, const point&)"
) << "Could not find " << sample << " in octree."
FatalErrorInFunction
<< "Could not find " << sample << " in octree."
<< abort(FatalError);
}
@ -72,7 +69,7 @@ Foam::volumeType Foam::treeDataPrimitivePatch<Foam::triSurface>::getVolumeType
}
else
{
FatalErrorIn("treeDataPrimitivePatch<PatchType>::getVolumeType(..)")
FatalErrorInFunction
<< "problem" << abort(FatalError);
return volumeType::UNKNOWN;
}

88
src/meshTools/mappedPatches/mappedPolyPatch/mappedPatchBase.C
View File

@ -208,11 +208,8 @@ void Foam::mappedPatchBase::findSamples
{
if (samplePatch_.size() && samplePatch_ != "none")
{
FatalErrorIn
(
"mappedPatchBase::findSamples(const pointField&,"
" labelList&, labelList&, pointField&) const"
) << "No need to supply a patch name when in "
FatalErrorInFunction
<< "No need to supply a patch name when in "
<< sampleModeNames_[mode] << " mode." << exit(FatalError);
}
@ -251,11 +248,8 @@ void Foam::mappedPatchBase::findSamples
{
if (samplePatch_.size() && samplePatch_ != "none")
{
FatalErrorIn
(
"mappedPatchBase::findSamples(const pointField&,"
" labelList&, labelList&, pointField&) const"
) << "No need to supply a patch name when in "
FatalErrorInFunction
<< "No need to supply a patch name when in "
<< sampleModeNames_[mode] << " mode." << exit(FatalError);
}
@ -426,11 +420,8 @@ void Foam::mappedPatchBase::findSamples
{
if (samplePatch().size() && samplePatch() != "none")
{
FatalErrorIn
(
"mappedPatchBase::findSamples(const pointField&,"
" labelList&, labelList&, pointField&) const"
) << "No need to supply a patch name when in "
FatalErrorInFunction
<< "No need to supply a patch name when in "
<< sampleModeNames_[mode] << " mode." << exit(FatalError);
}
@ -474,7 +465,7 @@ void Foam::mappedPatchBase::findSamples
default:
{
FatalErrorIn("mappedPatchBase::findSamples(..)")
FatalErrorInFunction
<< "problem." << abort(FatalError);
}
}
@ -530,7 +521,7 @@ void Foam::mappedPatchBase::calcMapping() const
static bool hasWarned = false;
if (mapPtr_.valid())
{
FatalErrorIn("mappedPatchBase::calcMapping() const")
FatalErrorInFunction
<< "Mapping already calculated" << exit(FatalError);
}
@ -556,17 +547,8 @@ void Foam::mappedPatchBase::calcMapping() const
if (sampleMyself && coincident)
{
WarningIn
(
"mappedPatchBase::mappedPatchBase\n"
"(\n"
" const polyPatch& pp,\n"
" const word& sampleRegion,\n"
" const sampleMode mode,\n"
" const word& samplePatch,\n"
" const vector& offset\n"
")\n"
) << "Invalid offset " << d << endl
WarningInFunction
<< "Invalid offset " << d << endl
<< "Offset is the vector added to the patch face centres to"
<< " find the patch face supplying the data." << endl
<< "Setting it to " << d
@ -618,17 +600,8 @@ void Foam::mappedPatchBase::calcMapping() const
{
if (!hasWarned)
{
WarningIn
(
"mappedPatchBase::mappedPatchBase\n"
"(\n"
" const polyPatch& pp,\n"
" const word& sampleRegion,\n"
" const sampleMode mode,\n"
" const word& samplePatch,\n"
" const vector& offset\n"
")\n"
) << "Did not find " << nNotFound
WarningInFunction
<< "Did not find " << nNotFound
<< " out of " << sampleProcs.size() << " total samples."
<< " Sampling these on owner cell centre instead." << endl
<< "On patch " << patch_.name()
@ -772,7 +745,7 @@ void Foam::mappedPatchBase::calcMapping() const
}
else
{
FatalErrorIn("mappedPatchBase::calcMapping() const")
FatalErrorInFunction
<< "On patch " << patch_.name()
<< " patchface " << faceI
<< " is assigned to more than once."
@ -784,7 +757,7 @@ void Foam::mappedPatchBase::calcMapping() const
{
if (used[faceI] == 0)
{
FatalErrorIn("mappedPatchBase::calcMapping() const")
FatalErrorInFunction
<< "On patch " << patch_.name()
<< " patchface " << faceI
<< " is never assigned to."
@ -831,7 +804,7 @@ void Foam::mappedPatchBase::calcAMI() const
{
if (AMIPtr_.valid())
{
FatalErrorIn("mappedPatchBase::calcAMI() const")
FatalErrorInFunction
<< "AMI already calculated" << exit(FatalError);
}
@ -914,10 +887,8 @@ Foam::tmp<Foam::pointField> Foam::mappedPatchBase::readListOrField
is >> static_cast<List<vector>&>(fld);
if (fld.size() != size)
{
FatalIOErrorIn
FatalIOErrorInFunction
(
"mappedPatchBase::readListOrField"
"(const word& keyword, const dictionary&, const label)",
dict
) << "size " << fld.size()
<< " is not equal to the given value of " << size
@ -926,10 +897,8 @@ Foam::tmp<Foam::pointField> Foam::mappedPatchBase::readListOrField
}
else
{
FatalIOErrorIn
FatalIOErrorInFunction
(
"mappedPatchBase::readListOrField"
"(const word& keyword, const dictionary&, const label)",
dict
) << "expected keyword 'uniform' or 'nonuniform', found "
<< firstToken.wordToken()
@ -940,10 +909,8 @@ Foam::tmp<Foam::pointField> Foam::mappedPatchBase::readListOrField
{
if (is.version() == 2.0)
{
IOWarningIn
IOWarningInFunction
(
"mappedPatchBase::readListOrField"
"(const word& keyword, const dictionary&, const label)",
dict
) << "expected keyword 'uniform' or 'nonuniform', "
"assuming List format for backwards compatibility."
@ -1135,13 +1102,8 @@ Foam::mappedPatchBase::mappedPatchBase
}
else if (mode_ != NEARESTPATCHFACE && mode_ != NEARESTPATCHFACEAMI)
{
FatalIOErrorIn
FatalIOErrorInFunction
(
"mappedPatchBase::mappedPatchBase\n"
"(\n"
" const polyPatch&,\n"
" const dictionary&\n"
")\n",
dict
) << "Please supply the offsetMode as one of "
<< NamedEnum<offsetMode, 3>::words()
@ -1175,14 +1137,8 @@ Foam::mappedPatchBase::mappedPatchBase
{
if (mode != NEARESTPATCHFACE && mode != NEARESTPATCHFACEAMI)
{
FatalIOErrorIn
FatalIOErrorInFunction
(
"mappedPatchBase::mappedPatchBase\n"
"(\n"
" const polyPatch&,\n"
" const sampleMode,\n"
" const dictionary&\n"
")\n",
dict
) << "Construct from sampleMode and dictionary only applicable for "
<< " collocated patches in modes "
@ -1293,7 +1249,7 @@ const Foam::polyPatch& Foam::mappedPatchBase::samplePolyPatch() const
if (patchI == -1)
{
FatalErrorIn("mappedPatchBase::samplePolyPatch()")
FatalErrorInFunction
<< "Cannot find patch " << samplePatch()
<< " in region " << sampleRegion_ << endl
<< "Valid patches are " << nbrMesh.boundaryMesh().names()
@ -1418,7 +1374,7 @@ Foam::pointIndexHit Foam::mappedPatchBase::facePoint
default:
{
FatalErrorIn("mappedPatchBase::facePoint()")
FatalErrorInFunction
<< "problem" << abort(FatalError);
return pointIndexHit();
}

8
src/meshTools/mappedPatches/mappedPolyPatch/mappedPatchBaseI.H
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
@ -36,7 +36,7 @@ inline const Foam::word& Foam::mappedPatchBase::sampleRegion() const
{
if (!coupleGroup_.valid())
{
FatalErrorIn("mappedPatchBase::sampleRegion()")
FatalErrorInFunction
<< "Supply either a regionName or a coupleGroup"
<< " for patch " << patch_.name()
<< " in region " << patch_.boundaryMesh().mesh().name()
@ -62,7 +62,7 @@ inline const Foam::word& Foam::mappedPatchBase::samplePatch() const
{
if (!coupleGroup_.valid())
{
FatalErrorIn("mappedPatchBase::samplePolyPatch()")
FatalErrorInFunction
<< "Supply either a patchName or a coupleGroup"
<< " for patch " << patch_.name()
<< " in region " << patch_.boundaryMesh().mesh().name()
@ -115,7 +115,7 @@ inline Foam::label Foam::mappedPatchBase::sampleSize() const
}
default:
{
FatalErrorIn("mappedPatchBase::sampleSize()")
FatalErrorInFunction
<< "problem." << abort(FatalError);
return -1;
}

25
src/meshTools/meshSearch/meshSearch.C
View File

@ -146,10 +146,8 @@ Foam::label Foam::meshSearch::findNearestCellWalk
{
if (seedCellI < 0)
{
FatalErrorIn
(
"meshSearch::findNearestCellWalk(const point&, const label)"
) << "illegal seedCell:" << seedCellI << exit(FatalError);
FatalErrorInFunction
<< "illegal seedCell:" << seedCellI << exit(FatalError);
}
// Walk in direction of face that decreases distance
@ -245,10 +243,8 @@ Foam::label Foam::meshSearch::findNearestFaceWalk
{
if (seedFaceI < 0)
{
FatalErrorIn
(
"meshSearch::findNearestFaceWalk(const point&, const label)"
) << "illegal seedFace:" << seedFaceI << exit(FatalError);
FatalErrorInFunction
<< "illegal seedFace:" << seedFaceI << exit(FatalError);
}
const vectorField& centres = mesh_.faceCentres();
@ -335,10 +331,8 @@ Foam::label Foam::meshSearch::findCellWalk
{
if (seedCellI < 0)
{
FatalErrorIn
(
"meshSearch::findCellWalk(const point&, const label)"
) << "illegal seedCell:" << seedCellI << exit(FatalError);
FatalErrorInFunction
<< "illegal seedCell:" << seedCellI << exit(FatalError);
}
if (mesh_.pointInCell(location, seedCellI, cellDecompMode_))
@ -408,11 +402,8 @@ Foam::label Foam::meshSearch::findNearestBoundaryFaceWalk
{
if (seedFaceI < 0)
{
FatalErrorIn
(
"meshSearch::findNearestBoundaryFaceWalk"
"(const point&, const label)"
) << "illegal seedFace:" << seedFaceI << exit(FatalError);
FatalErrorInFunction
<< "illegal seedFace:" << seedFaceI << exit(FatalError);
}
// Start off from seedFaceI

74
src/meshTools/meshTools/meshTools.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
@ -82,10 +82,8 @@ Foam::vectorField Foam::meshTools::calcBoxPointNormals(const primitivePatch& pp)
}
else
{
WarningIn
(
"Foam::meshTools::calcBoxPointNormals(const primitivePatch& pp)"
) << "Average point normal not visible for point:"
WarningInFunction
<< "Average point normal not visible for point:"
<< pp.meshPoints()[pointI] << endl;
label visOctant =
@ -176,11 +174,8 @@ Foam::vectorField Foam::meshTools::calcBoxPointNormals(const primitivePatch& pp)
{
pn[pointI] = vector::zero;
WarningIn
(
"Foam::meshTools::calcBoxPointNormals"
"(const primitivePatch& pp)"
) << "No visible octant for point:" << pp.meshPoints()[pointI]
WarningInFunction
<< "No visible octant for point:" << pp.meshPoints()[pointI]
<< " cooord:" << pp.points()[pp.meshPoints()[pointI]] << nl
<< "Normal set to " << pn[pointI] << endl;
}
@ -412,11 +407,8 @@ Foam::label Foam::meshTools::getSharedEdge
}
}
}
FatalErrorIn
(
"meshTools::getSharedEdge(const primitiveMesh&, const label"
", const label)"
) << "Faces " << f0 << " and " << f1 << " do not share an edge"
FatalErrorInFunction
<< "Faces " << f0 << " and " << f1 << " do not share an edge"
<< abort(FatalError);
return -1;
@ -451,11 +443,8 @@ Foam::label Foam::meshTools::getSharedFace
}
FatalErrorIn
(
"meshTools::getSharedFace(const primitiveMesh&, const label"
", const label)"
) << "No common face for"
FatalErrorInFunction
<< "No common face for"
<< " cell0I:" << cell0I << " faces:" << cFaces
<< " cell1I:" << cell1I << " faces:"
<< mesh.cells()[cell1I]
@ -501,11 +490,8 @@ void Foam::meshTools::getEdgeFaces
if ((face0 == -1) || (face1 == -1))
{
FatalErrorIn
(
"meshTools::getEdgeFaces(const primitiveMesh&, const label"
", const label, label&, label&"
) << "Can not find faces using edge " << mesh.edges()[edgeI]
FatalErrorInFunction
<< "Can not find faces using edge " << mesh.edges()[edgeI]
<< " on cell " << cellI << abort(FatalError);
}
}
@ -535,11 +521,8 @@ Foam::label Foam::meshTools::otherEdge
}
}
FatalErrorIn
(
"meshTools::otherEdge(const primitiveMesh&, const labelList&"
", const label, const label)"
) << "Can not find edge in "
FatalErrorInFunction
<< "Can not find edge in "
<< UIndirectList<edge>(mesh.edges(), edgeLabels)()
<< " connected to edge "
<< thisEdgeI << " with vertices " << mesh.edges()[thisEdgeI]
@ -584,11 +567,8 @@ Foam::label Foam::meshTools::otherCell
{
if (!mesh.isInternalFace(faceI))
{
FatalErrorIn
(
"meshTools::otherCell(const primitiveMesh&, const label"
", const label)"
) << "Face " << faceI << " is not internal"
FatalErrorInFunction
<< "Face " << faceI << " is not internal"
<< abort(FatalError);
}
@ -774,10 +754,8 @@ Foam::vector Foam::meshTools::edgeToCutDir
{
if (!hexMatcher().isA(mesh, cellI))
{
FatalErrorIn
(
"Foam::meshTools::getCutDir(const label, const label)"
) << "Not a hex : cell:" << cellI << abort(FatalError);
FatalErrorInFunction
<< "Not a hex : cell:" << cellI << abort(FatalError);
}
@ -824,10 +802,8 @@ Foam::label Foam::meshTools::cutDirToEdge
{
if (!hexMatcher().isA(mesh, cellI))
{
FatalErrorIn
(
"Foam::meshTools::getCutDir(const label, const vector&)"
) << "Not a hex : cell:" << cellI << abort(FatalError);
FatalErrorInFunction
<< "Not a hex : cell:" << cellI << abort(FatalError);
}
const labelList& cEdges = mesh.cellEdges()[cellI];
@ -871,10 +847,8 @@ Foam::label Foam::meshTools::cutDirToEdge
{
if (!doneEdges.found(cEdges[cEdgeI]))
{
FatalErrorIn
(
"meshTools::cutDirToEdge(const label, const vector&)"
) << "Cell:" << cellI << " edges:" << cEdges << endl
FatalErrorInFunction
<< "Cell:" << cellI << " edges:" << cEdges << endl
<< "Edge:" << cEdges[cEdgeI] << " not yet handled"
<< abort(FatalError);
}
@ -882,10 +856,8 @@ Foam::label Foam::meshTools::cutDirToEdge
if (maxEdgeI == -1)
{
FatalErrorIn
(
"meshTools::cutDirToEdge(const label, const vector&)"
) << "Problem : did not find edge aligned with " << cutDir
FatalErrorInFunction
<< "Problem : did not find edge aligned with " << cutDir
<< " on cell " << cellI << abort(FatalError);
}

19
src/meshTools/polyMeshZipUpCells/polyMeshZipUpCells.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
@ -117,7 +117,7 @@ bool Foam::polyMeshZipUpCells(polyMesh& mesh)
}
else if (edgeUsage[edgeI] != 2)
{
WarningIn("void polyMeshZipUpCells(polyMesh& mesh)")
WarningInFunction
<< "edge " << cellEdges[edgeI] << " in cell " << cellI
<< " used " << edgeUsage[edgeI] << " times. " << nl
<< "Should be 1 or 2 - serious error "
@ -494,7 +494,7 @@ bool Foam::polyMeshZipUpCells(polyMesh& mesh)
{
if (orderedEdge[checkI] == orderedEdge[checkJ])
{
WarningIn("void polyMeshZipUpCells(polyMesh& mesh)")
WarningInFunction
<< "Duplicate point found in edge to insert. "
<< nl << "Point: " << orderedEdge[checkI]
<< " edge: " << orderedEdge << endl;
@ -688,13 +688,7 @@ bool Foam::polyMeshZipUpCells(polyMesh& mesh)
{
if (newFace[checkI] == newFace[checkJ])
{
WarningIn
(
"void polyMeshZipUpCells"
"("
"polyMesh& mesh"
")"
)
WarningInFunction
<< "Duplicate point found "
<< "in the new face. " << nl
<< "Point: "
@ -729,7 +723,7 @@ bool Foam::polyMeshZipUpCells(polyMesh& mesh)
labelList toc(problemCells.toc());
sort(toc);
FatalErrorIn("void polyMeshZipUpCells(polyMesh& mesh)")
FatalErrorInFunction
<< "Found " << problemCells.size() << " problem cells." << nl
<< "Cells: " << toc
<< abort(FatalError);
@ -781,8 +775,7 @@ bool Foam::polyMeshZipUpCells(polyMesh& mesh)
if (nChangedFacesInMesh > 0)
{
FatalErrorIn("void polyMeshZipUpCells(polyMesh& mesh)")
<< "cell zip-up failed after 100 cycles. Probable problem "
FatalErrorInFunction
<< "with the original mesh"
<< abort(FatalError);
}

102
src/meshTools/primitiveMeshGeometry/primitiveMeshGeometry.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
@ -318,12 +318,8 @@ bool Foam::primitiveMeshGeometry::checkFaceDotProduct
// Non-orthogonality greater than 90 deg
if (report)
{
WarningIn
(
"primitiveMeshGeometry::checkFaceDotProduct"
"(const bool, const scalar, const labelList&"
", labelHashSet*)"
) << "Severe non-orthogonality detected for face "
WarningInFunction
<< "Severe non-orthogonality detected for face "
<< faceI
<< " between cells " << own[faceI] << " and "
<< nei[faceI]
@ -383,11 +379,8 @@ bool Foam::primitiveMeshGeometry::checkFaceDotProduct
{
if (report)
{
SeriousErrorIn
(
"primitiveMeshGeometry::checkFaceDotProduct"
"(const bool, const scalar, const labelList&, labelHashSet*)"
) << "Error in non-orthogonality detected" << endl;
SeriousErrorInFunction
<< "Error in non-orthogonality detected" << endl;
}
return true;
@ -497,12 +490,8 @@ bool Foam::primitiveMeshGeometry::checkFacePyramids
{
if (report)
{
SeriousErrorIn
(
"primitiveMeshGeometry::checkFacePyramids("
"const bool, const scalar, const pointField&"
", const labelList&, labelHashSet*)"
) << "Error in face pyramids: faces pointing the wrong way!"
SeriousErrorInFunction
<< "Error in face pyramids: faces pointing the wrong way!"
<< endl;
}
@ -638,11 +627,7 @@ bool Foam::primitiveMeshGeometry::checkFaceSkewness
{
if (report)
{
WarningIn
(
"primitiveMeshGeometry::checkFaceSkewness"
"(const bool, const scalar, const labelList&, labelHashSet*)"
) << "Large face skewness detected. Max skewness = "
WarningInFunction
<< 100*maxSkew
<< " percent.\nThis may impair the quality of the result." << nl
<< nWarnSkew << " highly skew faces detected."
@ -725,11 +710,7 @@ bool Foam::primitiveMeshGeometry::checkFaceWeights
{
if (report)
{
WarningIn
(
"primitiveMeshGeometry::checkFaceWeights"
"(const bool, const scalar, const labelList&, labelHashSet*)"
) << "Small interpolation weight detected. Min weight = "
WarningInFunction
<< minWeight << '.' << nl
<< nWarnWeight << " faces with small weights detected."
<< endl;
@ -767,12 +748,8 @@ bool Foam::primitiveMeshGeometry::checkFaceAngles
{
if (maxDeg < -SMALL || maxDeg > 180+SMALL)
{
FatalErrorIn
(
"primitiveMeshGeometry::checkFaceAngles"
"(const bool, const scalar, const pointField&, const labelList&"
", labelHashSet*)"
) << "maxDeg should be [0..180] but is now " << maxDeg
FatalErrorInFunction
<< "maxDeg should be [0..180] but is now " << maxDeg
<< abort(FatalError);
}
@ -874,12 +851,8 @@ bool Foam::primitiveMeshGeometry::checkFaceAngles
{
if (report)
{
WarningIn
(
"primitiveMeshGeometry::checkFaceAngles"
"(const bool, const scalar, const pointField&"
", const labelList&, labelHashSet*)"
) << nConcave << " face points with severe concave angle (> "
WarningInFunction
<< nConcave << " face points with severe concave angle (> "
<< maxDeg << " deg) found.\n"
<< endl;
}
@ -910,12 +883,8 @@ bool Foam::primitiveMeshGeometry::checkFaceAngles
//{
// if (warnFlatness < 0 || warnFlatness > 1)
// {
// FatalErrorIn
// (
// "primitiveMeshGeometry::checkFaceFlatness"
// "(const bool, const scalar, const pointField&"
// ", const labelList&, labelHashSet*)"
// ) << "warnFlatness should be [0..1] but is now " << warnFlatness
// FatalErrorInFunction
// << "warnFlatness should be [0..1] but is now " << warnFlatness
// << abort(FatalError);
// }
//
@ -1011,12 +980,8 @@ bool Foam::primitiveMeshGeometry::checkFaceAngles
// {
// if (report)
// {
// WarningIn
// (
// "primitiveMeshGeometry::checkFaceFlatness"
// "(const bool, const scalar, const pointField&"
// ", const labelList&, labelHashSet*)"
// ) << nWarped << " faces with severe warpage (flatness < "
// WarningInFunction
// << nWarped << " faces with severe warpage (flatness < "
// << warnFlatness << ") found.\n"
// << endl;
// }
@ -1047,12 +1012,8 @@ bool Foam::primitiveMeshGeometry::checkFaceTwist
{
if (minTwist < -1-SMALL || minTwist > 1+SMALL)
{
FatalErrorIn
(
"primitiveMeshGeometry::checkFaceTwist"
"(const bool, const scalar, const primitiveMesh&, const pointField&"
", const labelList&, labelHashSet*)"
) << "minTwist should be [-1..1] but is now " << minTwist
FatalErrorInFunction
<< "minTwist should be [-1..1] but is now " << minTwist
<< abort(FatalError);
}
@ -1129,12 +1090,8 @@ bool Foam::primitiveMeshGeometry::checkFaceTwist
{
if (report)
{
WarningIn
(
"primitiveMeshGeometry::checkFaceTwist"
"(const bool, const scalar, const primitiveMesh&"
", const pointField&, const labelList&, labelHashSet*)"
) << nWarped << " faces with severe warpage "
WarningInFunction
<< nWarped << " faces with severe warpage "
<< "(cosine of the angle between triangle normal and "
<< "face normal < " << minTwist << ") found.\n"
<< endl;
@ -1195,12 +1152,8 @@ bool Foam::primitiveMeshGeometry::checkFaceArea
{
if (report)
{
WarningIn
(
"primitiveMeshGeometry::checkFaceArea"
"(const bool, const scalar, const primitiveMesh&"
", const pointField&, const labelList&, labelHashSet*)"
) << nZeroArea << " faces with area < " << minArea
WarningInFunction
<< nZeroArea << " faces with area < " << minArea
<< " found.\n"
<< endl;
}
@ -1300,13 +1253,8 @@ bool Foam::primitiveMeshGeometry::checkCellDeterminant
{
if (report)
{
WarningIn
(
"primitiveMeshGeometry::checkCellDeterminant"
"(const bool, const scalar, const primitiveMesh&"
", const pointField&, const labelList&, const labelList&"
", labelHashSet*)"
) << nWarnDet << " cells with determinant < " << warnDet
WarningInFunction
<< nWarnDet << " cells with determinant < " << warnDet
<< " found.\n"
<< endl;
}

24
src/meshTools/regionCoupled/GAMG/interfaces/regionCoupledGAMGInterface/regionCoupledBaseGAMGInterface.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
@ -191,19 +191,8 @@ Foam::regionCoupledBaseGAMGInterface::regionCoupledBaseGAMGInterface
}
else
{
FatalErrorIn
(
"regionCoupledBaseGAMGInterface::"
"regionCoupledBaseGAMGInterface"
"("
"const label index,"
"const lduInterfacePtrsList& coarseInterfaces,"
"const lduInterface& fineInterface,"
"const labelField& localRestrictAddressing,"
"const labelField& neighbourRestrictAddressing,"
"const label fineLevelIndex"
")"
) << " GAMGAgglomeration was not found in the nbr mesh. "
FatalErrorInFunction
<< " GAMGAgglomeration was not found in the nbr mesh. "
<< " Check on the cacheAgglomeration flag in fvSolution"
<< exit(FatalError);
}
@ -228,13 +217,6 @@ internalFieldTransfer
const labelUList& iF
) const
{
// WarningIn
// (
// "regionCoupledBaseGAMGInterface::internalFieldTransfer"
// "( const Pstream::commsTypes, const labelUList&)"
// " the internal field can not be transfered "
// " as the neighbFvPatch are in different meshes "
// );
/*
//const labelUList& nbrFaceCells = neighbPatch().faceCells();

9
src/meshTools/regionCoupled/patches/regionCoupledPolyPatch/regionCoupledBase.C
View File

@ -205,7 +205,7 @@ Foam::label Foam::regionCoupledBase::neighbPatchID() const
if (nbrPatchID_ == -1)
{
FatalErrorIn("cyclicPolyAMIPatch::neighbPatchID() const")
FatalErrorInFunction
<< "Illegal neighbourPatch name " << nbrPatchName_
<< nl << "Valid patch names are "
<< mesh.boundaryMesh().names()
@ -221,7 +221,7 @@ Foam::label Foam::regionCoupledBase::neighbPatchID() const
if (nbrPatch.nbrPatchName() != patch_.name())
{
WarningIn("regionCoupledBase::neighbPatchID() const")
WarningInFunction
<< "Patch " << patch_.name()
<< " specifies neighbour patch " << nbrPatchName()
<< nl << " but that in return specifies "
@ -283,10 +283,7 @@ const Foam::AMIPatchToPatchInterpolation& Foam::regionCoupledBase::AMI() const
{
if (!owner())
{
FatalErrorIn
(
"const AMIPatchToPatchInterpolation& regionCoupledBase::AMI()"
)
FatalErrorInFunction
<< "AMI interpolator only available to owner patch"
<< abort(FatalError);
}

24
src/meshTools/regionSplit/localPointRegion.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
@ -127,7 +127,7 @@ void Foam::localPointRegion::countPointRegions
if (minRegion[faceI].empty())
{
FatalErrorIn("localPointRegion::countPointRegions(..)")
FatalErrorInFunction
<< "Face from candidateFace without minRegion set." << endl
<< "Face:" << faceI << " fc:" << mesh.faceCentres()[faceI]
<< " verts:" << f << abort(FatalError);
@ -535,11 +535,8 @@ Foam::labelList Foam::localPointRegion::findDuplicateFaces
if (isDuplicate(f, otherF, true))
{
FatalErrorIn
(
"findDuplicateFaces(const primitiveMesh&"
", const labelList&)"
) << "Face:" << bFaceI + mesh.nInternalFaces()
FatalErrorInFunction
<< "Face:" << bFaceI + mesh.nInternalFaces()
<< " has local points:" << f
<< " which are in same order as face:"
<< otherFaceI + mesh.nInternalFaces()
@ -557,11 +554,8 @@ Foam::labelList Foam::localPointRegion::findDuplicateFaces
|| duplicateFace[otherFaceI] != -1
)
{
FatalErrorIn
(
"findDuplicateFaces(const primitiveMesh&"
", const labelList&)"
) << "One of two duplicate faces already marked"
FatalErrorInFunction
<< "One of two duplicate faces already marked"
<< " as duplicate." << nl
<< "This means that three or more faces share"
<< " the same points and this is illegal." << nl
@ -623,10 +617,8 @@ Foam::List<Foam::labelPair> Foam::localPointRegion::findDuplicateFacePairs
|| (patch1 != -1 && isA<processorPolyPatch>(patches[patch1]))
)
{
FatalErrorIn
(
"localPointRegion::findDuplicateFacePairs(const polyMesh&)"
) << "One of two duplicate faces is on"
FatalErrorInFunction
<< "One of two duplicate faces is on"
<< " processorPolyPatch."
<< "This is not allowed." << nl
<< "Face:" << meshFace0

19
src/meshTools/regionSplit/regionSplit.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
@ -64,11 +64,8 @@ void Foam::regionSplit::transferCoupledFaceRegion
}
else if (faceRegion[otherFaceI] != faceRegion[faceI])
{
FatalErrorIn
(
"regionSplit::transferCoupledFaceRegion"
"(const label, const label, labelList&, labelList&) const"
) << "Problem : coupled face " << faceI
FatalErrorInFunction
<< "Problem : coupled face " << faceI
<< " on patch " << mesh().boundaryMesh().whichPatch(faceI)
<< " has region " << faceRegion[faceI]
<< " but coupled face " << otherFaceI
@ -280,10 +277,8 @@ Foam::label Foam::regionSplit::calcLocalRegionSplit
{
if (syncBlockedFace[faceI] != blockedFace[faceI])
{
FatalErrorIn
(
"regionSplit::calcLocalRegionSplit(..)"
) << "Face " << faceI << " not synchronised. My value:"
FatalErrorInFunction
<< "Face " << faceI << " not synchronised. My value:"
<< blockedFace[faceI] << " coupled value:"
<< syncBlockedFace[faceI]
<< abort(FatalError);
@ -356,7 +351,7 @@ Foam::label Foam::regionSplit::calcLocalRegionSplit
{
if (cellRegion[cellI] < 0)
{
FatalErrorIn("regionSplit::calcLocalRegionSplit(..)")
FatalErrorInFunction
<< "cell:" << cellI << " region:" << cellRegion[cellI]
<< abort(FatalError);
}
@ -366,7 +361,7 @@ Foam::label Foam::regionSplit::calcLocalRegionSplit
{
if (faceRegion[faceI] == -1)
{
FatalErrorIn("regionSplit::calcLocalRegionSplit(..)")
FatalErrorInFunction
<< "face:" << faceI << " region:" << faceRegion[faceI]
<< abort(FatalError);
}

24
src/meshTools/searchableSurface/searchableBox.C
View File

@ -58,7 +58,7 @@ void Foam::searchableBox::projectOntoCoordPlane
}
else
{
FatalErrorIn("searchableBox::projectOntoCoordPlane(..)")
FatalErrorInFunction
<< "Point on plane " << planePt
<< " is not on coordinate " << min()[dir]
<< " nor " << max()[dir] << abort(FatalError);
@ -172,14 +172,8 @@ Foam::searchableBox::searchableBox
{
if (!contains(midpoint()))
{
FatalErrorIn
(
"Foam::searchableBox::searchableBox\n"
"(\n"
" const IOobject& io,\n"
" const treeBoundBox& bb\n"
")\n"
) << "Illegal bounding box specification : "
FatalErrorInFunction
<< "Illegal bounding box specification : "
<< static_cast<const treeBoundBox>(*this) << exit(FatalError);
}
@ -198,14 +192,8 @@ Foam::searchableBox::searchableBox
{
if (!contains(midpoint()))
{
FatalErrorIn
(
"Foam::searchableBox::searchableBox\n"
"(\n"
" const IOobject& io,\n"
" const treeBoundBox& bb\n"
")\n"
) << "Illegal bounding box specification : "
FatalErrorInFunction
<< "Illegal bounding box specification : "
<< static_cast<const treeBoundBox>(*this) << exit(FatalError);
}
@ -433,7 +421,7 @@ Foam::pointIndexHit Foam::searchableBox::findLine
if (info.index() == -1)
{
FatalErrorIn("searchableBox::findLine(const point&, const point&)")
FatalErrorInFunction
<< "point " << info.rawPoint()
<< " on segment " << start << end
<< " should be on face of " << *this

9
src/meshTools/searchableSurface/searchableDisk.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
@ -317,11 +317,8 @@ void Foam::searchableDisk::getVolumeType
List<volumeType>& volType
) const
{
FatalErrorIn
(
"searchableDisk::getVolumeType(const pointField&"
", List<volumeType>&) const"
) << "Volume type not supported for disk."
FatalErrorInFunction
<< "Volume type not supported for disk."
<< exit(FatalError);
}

9
src/meshTools/searchableSurface/searchablePlane.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
@ -256,11 +256,8 @@ void Foam::searchablePlane::getVolumeType
List<volumeType>& volType
) const
{
FatalErrorIn
(
"searchableCollection::getVolumeType(const pointField&"
", List<volumeType>&) const"
) << "Volume type not supported for plane."
FatalErrorInFunction
<< "Volume type not supported for plane."
<< exit(FatalError);
}

15
src/meshTools/searchableSurface/searchablePlate.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
@ -48,7 +48,7 @@ Foam::direction Foam::searchablePlate::calcNormal(const point& span)
{
if (span[dir] < 0)
{
FatalErrorIn("searchablePlate::calcNormal()")
FatalErrorInFunction
<< "Span should have two positive and one zero entry. Now:"
<< span << exit(FatalError);
}
@ -69,7 +69,7 @@ Foam::direction Foam::searchablePlate::calcNormal(const point& span)
if (normalDir == 3)
{
FatalErrorIn("searchablePlate::calcNormal()")
FatalErrorInFunction
<< "Span should have two positive and one zero entry. Now:"
<< span << exit(FatalError);
}
@ -190,7 +190,7 @@ Foam::pointIndexHit Foam::searchablePlate::findLine
if (!bb.contains(info.hitPoint()))
{
FatalErrorIn("searchablePlate::findLine(..)")
FatalErrorInFunction
<< "bb:" << bb << endl
<< "origin_:" << origin_ << endl
<< "span_:" << span_ << endl
@ -440,11 +440,8 @@ void Foam::searchablePlate::getVolumeType
List<volumeType>& volType
) const
{
FatalErrorIn
(
"searchableCollection::getVolumeType(const pointField&"
", List<volumeType>&) const"
) << "Volume type not supported for plate."
FatalErrorInFunction
<< "Volume type not supported for plate."
<< exit(FatalError);
}

9
src/meshTools/searchableSurface/searchableSurface.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
@ -48,11 +48,8 @@ Foam::autoPtr<Foam::searchableSurface> Foam::searchableSurface::New
if (cstrIter == dictConstructorTablePtr_->end())
{
FatalErrorIn
(
"searchableSurface::New(const word&,"
" const IOobject&, const dictionary&)"
) << "Unknown searchableSurface type " << searchableSurfaceType
FatalErrorInFunction
<< "Unknown searchableSurface type " << searchableSurfaceType
<< endl << endl
<< "Valid searchableSurface types : " << endl
<< dictConstructorTablePtr_->sortedToc()

22
src/meshTools/searchableSurface/searchableSurfaceCollection.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
@ -218,11 +218,8 @@ Foam::searchableSurfaceCollection::searchableSurfaceCollection
// if all indices offset by globalSize() of the local region...
if (s.size() != s.globalSize())
{
FatalErrorIn
(
"searchableSurfaceCollection::searchableSurfaceCollection"
"(const IOobject&, const dictionary&)"
) << "Cannot use a distributed surface in a collection."
FatalErrorInFunction
<< "Cannot use a distributed surface in a collection."
<< exit(FatalError);
}
@ -532,10 +529,8 @@ void Foam::searchableSurfaceCollection::findLine
if (s < 0 || s > 1)
{
FatalErrorIn
(
"searchableSurfaceCollection::findLine(..)"
) << "point:" << info[pointI]
FatalErrorInFunction
<< "point:" << info[pointI]
<< " s:" << s
<< " outside vector "
<< " start:" << start[pointI]
@ -702,11 +697,8 @@ void Foam::searchableSurfaceCollection::getVolumeType
List<volumeType>& volType
) const
{
FatalErrorIn
(
"searchableSurfaceCollection::getVolumeType(const pointField&"
", List<volumeType>&) const"
) << "Volume type not supported for collection."
FatalErrorInFunction
<< "Volume type not supported for collection."
<< exit(FatalError);
}

35
src/meshTools/searchableSurface/searchableSurfaces.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
@ -136,11 +136,8 @@ Foam::searchableSurfaces::searchableSurfaces(const label size)
//
// if (index == -1)
// {
// FatalErrorIn
// (
// "searchableSurfaces::searchableSurfaces"
// "( const IOobject&, const dictionary&)"
// ) << "Unknown region name " << key
// FatalErrorInFunction
// << "Unknown region name " << key
// << " for surface " << s.name() << endl
// << "Valid region names are " << localNames
// << exit(FatalError);
@ -191,11 +188,8 @@ Foam::searchableSurfaces::searchableSurfaces
if (!topDict.isDict(key))
{
FatalErrorIn
(
"searchableSurfaces::searchableSurfaces"
"( const IOobject&, const dictionary&)"
) << "Found non-dictionary entry " << iter()
FatalErrorInFunction
<< "Found non-dictionary entry " << iter()
<< " in top-level dictionary " << topDict
<< exit(FatalError);
}
@ -264,11 +258,8 @@ Foam::searchableSurfaces::searchableSurfaces
if (index == -1)
{
FatalErrorIn
(
"searchableSurfaces::searchableSurfaces"
"( const IOobject&, const dictionary&)"
) << "Unknown region name " << key
FatalErrorInFunction
<< "Unknown region name " << key
<< " for surface " << s.name() << endl
<< "Valid region names are " << localNames
<< exit(FatalError);
@ -926,10 +917,8 @@ const Foam::searchableSurface& Foam::searchableSurfaces::operator[]
if (surfI < 0)
{
FatalErrorIn
(
"searchableSurfaces::operator[](const word&) const"
) << "Surface named " << surfName << " not found." << nl
FatalErrorInFunction
<< "Surface named " << surfName << " not found." << nl
<< "Available surface names: " << names_ << endl
<< abort(FatalError);
}
@ -947,10 +936,8 @@ Foam::searchableSurface& Foam::searchableSurfaces::operator[]
if (surfI < 0)
{
FatalErrorIn
(
"searchableSurfaces::operator[](const word&)"
) << "Surface named " << surfName << " not found." << nl
FatalErrorInFunction
<< "Surface named " << surfName << " not found." << nl
<< "Available surface names: " << names_ << endl
<< abort(FatalError);
}

11
src/meshTools/searchableSurface/searchableSurfacesQueries.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
@ -810,7 +810,7 @@ void Foam::searchableSurfacesQueries::signedDistance
}
default:
{
FatalErrorIn("signedDistance()")
FatalErrorInFunction
<< "getVolumeType failure,"
<< " neither INSIDE or OUTSIDE."
<< " point:" << surfPoints[i]
@ -879,11 +879,8 @@ Foam::pointIndexHit Foam::searchableSurfacesQueries::facesIntersection
}
else
{
FatalErrorIn
(
"searchableSurfacesQueries::facesIntersection"
"(const labelList&, const scalar, const scalar, const point&)"
) << "Did not find point within distance "
FatalErrorInFunction
<< "Did not find point within distance "
<< initDistSqr << " of starting point " << start
<< " on surface "
<< allSurfaces[surfacesToTest[i]].IOobject::name()

15
src/meshTools/searchableSurface/triSurfaceMesh.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
@ -89,11 +89,8 @@ addToRunTimeSelectionTable(searchableSurface, triSurfaceMesh, dict);
// return runTime.constant();
// }
//
// FatalErrorIn
// (
// "searchableSurfaces::findRawInstance"
// "(const Time&, const fileName&, const word&)"
// ) << "Cannot find file \"" << name << "\" in directory "
// FatalErrorInFunction
// << "Cannot find file \"" << name << "\" in directory "
// << runTime.constant()/dir
// << exit(FatalError);
//
@ -110,10 +107,8 @@ const Foam::fileName& Foam::triSurfaceMesh::checkFile
{
if (fName.empty())
{
FatalErrorIn
(
"triSurfaceMesh::checkFile(const fileName&, const fileName&)"
) << "Cannot find triSurfaceMesh starting from "
FatalErrorInFunction
<< "Cannot find triSurfaceMesh starting from "
<< objectName << exit(FatalError);
}
return fName;

4
src/meshTools/sets/cellSources/faceZoneToCell/faceZoneToCell.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
@ -100,7 +100,7 @@ void Foam::faceZoneToCell::combine(topoSet& set, const bool add) const
if (!hasMatched)
{
WarningIn("faceZoneToCell::combine(topoSet&, const bool)")
WarningInFunction
<< "Cannot find any faceZone named " << zoneName_ << endl
<< "Valid names are " << mesh_.faceZones().names() << endl;
}

16
src/meshTools/sets/cellSources/fieldToCell/fieldToCell.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
@ -196,11 +196,8 @@ void Foam::fieldToCell::applyToSet
if (!fieldObject.headerOk())
{
WarningIn
(
"fieldToCell::applyToSet(const topoSetSource::setAction"
", topoSet& set)"
) << "Cannot read field " << fieldName_
WarningInFunction
<< "Cannot read field " << fieldName_
<< " from time " << mesh().time().timeName() << endl;
}
else if (fieldObject.headerClassName() == "volScalarField")
@ -227,11 +224,8 @@ void Foam::fieldToCell::applyToSet
}
else
{
WarningIn
(
"fieldToCell::applyToSet(const topoSetSource::setAction"
", topoSet& set)"
) << "Cannot handle fields of type " << fieldObject.headerClassName()
WarningInFunction
<< "Cannot handle fields of type " << fieldObject.headerClassName()
<< endl;
}
}

9
src/meshTools/sets/cellSources/regionToCell/regionToCell.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
@ -131,11 +131,8 @@ Foam::boolList Foam::regionToCell::findRegions
if (keepProcI == -1)
{
FatalErrorIn
(
"outsideCellSelection::findRegions"
"(const bool, const regionSplit&)"
) << "Did not find " << insidePoints_[i]
FatalErrorInFunction
<< "Did not find " << insidePoints_[i]
<< " in mesh." << " Mesh bounds are " << mesh_.bounds()
<< exit(FatalError);
}

20
src/meshTools/sets/cellSources/shapeToCell/shapeToCell.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
@ -105,10 +105,8 @@ Foam::shapeToCell::shapeToCell
{
if (!cellModeller::lookup(type_) && (type_ != "splitHex"))
{
FatalErrorIn
(
"shapeToCell::shapeToCell(const polyMesh&, const word&)"
) << "Illegal cell type " << type_ << exit(FatalError);
FatalErrorInFunction
<< "Illegal cell type " << type_ << exit(FatalError);
}
}
@ -125,10 +123,8 @@ Foam::shapeToCell::shapeToCell
{
if (!cellModeller::lookup(type_) && (type_ != "splitHex"))
{
FatalErrorIn
(
"shapeToCell::shapeToCell(const polyMesh&, const dictionary&)"
) << "Illegal cell type " << type_ << exit(FatalError);
FatalErrorInFunction
<< "Illegal cell type " << type_ << exit(FatalError);
}
}
@ -145,10 +141,8 @@ Foam::shapeToCell::shapeToCell
{
if (!cellModeller::lookup(type_) && (type_ != "splitHex"))
{
FatalErrorIn
(
"shapeToCell::shapeToCell(const polyMesh&, Istream&)"
) << "Illegal cell type " << type_ << exit(FatalError);
FatalErrorInFunction
<< "Illegal cell type " << type_ << exit(FatalError);
}
}

14
src/meshTools/sets/cellSources/surfaceToCell/surfaceToCell.C
View File

@ -194,7 +194,7 @@ void Foam::surfaceToCell::combine(topoSet& set, const bool add) const
label cellI = queryMesh.findCell(outsidePoint, -1, false);
if (returnReduce(cellI, maxOp<label>()) == -1)
{
FatalErrorIn("surfaceToCell::combine(topoSet&, const bool)")
FatalErrorInFunction
<< "outsidePoint " << outsidePoint
<< " is not inside any cell"
<< exit(FatalError);
@ -332,10 +332,8 @@ void Foam::surfaceToCell::checkSettings() const
)
)
{
FatalErrorIn
(
"surfaceToCell:checkSettings()"
) << "Illegal include cell specification."
FatalErrorInFunction
<< "Illegal include cell specification."
<< " Result would be either all or no cells." << endl
<< "Please set one of includeCut, includeInside, includeOutside"
<< " to true, set nearDistance to a value > 0"
@ -345,10 +343,8 @@ void Foam::surfaceToCell::checkSettings() const
if (useSurfaceOrientation_ && includeCut_)
{
FatalErrorIn
(
"surfaceToCell:checkSettings()"
) << "Illegal include cell specification."
FatalErrorInFunction
<< "Illegal include cell specification."
<< " You cannot specify both 'useSurfaceOrientation'"
<< " and 'includeCut'"
<< " since 'includeCut' specifies a topological split"

6
src/meshTools/sets/cellSources/targetVolumeToCell/targetVolumeToCell.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2012-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -163,7 +163,7 @@ void Foam::targetVolumeToCell::combine(topoSet& set, const bool add) const
// Check that maxPoint indeed selects all cells
if (maxCells != nTotCells)
{
WarningIn("targetVolumeToCell::combine(topoSet&, const bool) const")
WarningInFunction
<< "Plane " << plane(points[maxPointI], n_)
<< " selects " << maxCells
<< " cells instead of all " << nTotCells
@ -241,7 +241,7 @@ void Foam::targetVolumeToCell::combine(topoSet& set, const bool add) const
}
else
{
WarningIn("targetVolumeToCell::combine(topoSet&, const bool) const")
WarningInFunction
<< "Did not converge onto plane. " << nl
<< "high plane:"
<< plane(high*n_, n_)

4
src/meshTools/sets/cellSources/zoneToCell/zoneToCell.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
@ -83,7 +83,7 @@ void Foam::zoneToCell::combine(topoSet& set, const bool add) const
if (!hasMatched)
{
WarningIn("zoneToCell::combine(topoSet&, const bool)")
WarningInFunction
<< "Cannot find any cellZone named " << zoneName_ << endl
<< "Valid names are " << mesh_.cellZones().names() << endl;
}

9
src/meshTools/sets/cellZoneSources/setToCellZone/setToCellZone.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
@ -105,11 +105,8 @@ void Foam::setToCellZone::applyToSet
{
if (!isA<cellZoneSet>(set))
{
WarningIn
(
"setToCellZone::applyToSet(const topoSetSource::setAction"
", topoSet"
) << "Operation only allowed on a cellZoneSet." << endl;
WarningInFunction
<< "Operation only allowed on a cellZoneSet." << endl;
}
else
{

9
src/meshTools/sets/faceSources/normalToFace/normalToFace.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
@ -62,11 +62,8 @@ void Foam::normalToFace::setNormal()
if (tol_ < -1 || tol_ > 1)
{
FatalErrorIn
(
"normalToFace::normalToFace(const polyMesh&, const vector&"
", const scalar)"
) << "tolerance not within range -1..1 : " << tol_
FatalErrorInFunction
<< "tolerance not within range -1..1 : " << tol_
<< exit(FatalError);
}
}

4
src/meshTools/sets/faceSources/patchToFace/patchToFace.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
@ -83,7 +83,7 @@ void Foam::patchToFace::combine(topoSet& set, const bool add) const
if (patchIDs.empty())
{
WarningIn("patchToFace::combine(topoSet&, const bool)")
WarningInFunction
<< "Cannot find any patch named " << patchName_ << endl
<< "Valid names are " << mesh_.boundaryMesh().names() << endl;
}

4
src/meshTools/sets/faceSources/zoneToFace/zoneToFace.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
@ -83,7 +83,7 @@ void Foam::zoneToFace::combine(topoSet& set, const bool add) const
if (!hasMatched)
{
WarningIn("zoneToFace::combine(topoSet&, const bool)")
WarningInFunction
<< "Cannot find any faceZone named " << zoneName_ << endl
<< "Valid names are " << mesh_.faceZones().names() << endl;
}

9
src/meshTools/sets/faceZoneSources/faceZoneToFaceZone/faceZoneToFaceZone.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
@ -105,11 +105,8 @@ void Foam::faceZoneToFaceZone::applyToSet
{
if (!isA<faceZoneSet>(set))
{
WarningIn
(
"faceZoneToFaceZone::applyToSet(const topoSetSource::setAction"
", topoSet"
) << "Operation only allowed on a faceZoneSet." << endl;
WarningInFunction
<< "Operation only allowed on a faceZoneSet." << endl;
}
else
{

10
src/meshTools/sets/faceZoneSources/searchableSurfaceToFaceZone/searchableSurfaceToFaceZone.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2012-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -101,12 +101,8 @@ void Foam::searchableSurfaceToFaceZone::applyToSet
{
if (!isA<faceZoneSet>(set))
{
WarningIn
(
"searchableSurfaceToFaceZone::applyToSet"
"(const topoSetSource::setAction"
", topoSet"
) << "Operation only allowed on a faceZoneSet." << endl;
WarningInFunction
<< "Operation only allowed on a faceZoneSet." << endl;
}
else
{

12
src/meshTools/sets/faceZoneSources/setAndNormalToFaceZone/setAndNormalToFaceZone.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2013-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -106,14 +106,8 @@ void Foam::setAndNormalToFaceZone::applyToSet
{
if (!isA<faceZoneSet>(set))
{
WarningIn
(
"setAndNormalToFaceZone::applyToSet"
"("
"const topoSetSource::setAction, "
"topoSet&"
")"
) << "Operation only allowed on a faceZoneSet." << endl;
WarningInFunction
<< "Operation only allowed on a faceZoneSet." << endl;
}
else
{

9
src/meshTools/sets/faceZoneSources/setToFaceZone/setToFaceZone.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
@ -106,11 +106,8 @@ void Foam::setToFaceZone::applyToSet
{
if (!isA<faceZoneSet>(set))
{
WarningIn
(
"setToFaceZone::applyToSet(const topoSetSource::setAction"
", topoSet"
) << "Operation only allowed on a faceZoneSet." << endl;
WarningInFunction
<< "Operation only allowed on a faceZoneSet." << endl;
}
else
{

16
src/meshTools/sets/faceZoneSources/setsToFaceZone/setsToFaceZone.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
@ -111,11 +111,8 @@ void Foam::setsToFaceZone::applyToSet
{
if (!isA<faceZoneSet>(set))
{
WarningIn
(
"setsToFaceZone::applyToSet(const topoSetSource::setAction"
", topoSet"
) << "Operation only allowed on a faceZoneSet." << endl;
WarningInFunction
<< "Operation only allowed on a faceZoneSet." << endl;
}
else
{
@ -160,11 +157,8 @@ void Foam::setsToFaceZone::applyToSet
}
else
{
WarningIn
(
"setsToFaceZone::applyToSet"
"(const topoSetSource::setAction, topoSet)"
) << "One of owner or neighbour of internal face "
WarningInFunction
<< "One of owner or neighbour of internal face "
<< faceI << " should be in cellSet "
<< cSet.name()
<< " to be able to determine orientation."

2
src/meshTools/sets/pointSources/surfaceToPoint/surfaceToPoint.C
View File

@ -108,7 +108,7 @@ void Foam::surfaceToPoint::checkSettings() const
{
if (nearDist_ < 0 && !includeInside_ && !includeOutside_)
{
FatalErrorIn("surfaceToPoint:checkSettings()")
FatalErrorInFunction
<< "Illegal point selection specification."
<< " Result would be either all or no points." << endl
<< "Please set one of includeInside or includeOutside"

4
src/meshTools/sets/pointSources/zoneToPoint/zoneToPoint.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
@ -83,7 +83,7 @@ void Foam::zoneToPoint::combine(topoSet& set, const bool add) const
if (!hasMatched)
{
WarningIn("zoneToPoint::combine(topoSet&, const bool)")
WarningInFunction
<< "Cannot find any pointZone named " << zoneName_ << endl
<< "Valid names are " << mesh_.pointZones().names() << endl;
}

9
src/meshTools/sets/pointZoneSources/setToPointZone/setToPointZone.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
@ -105,11 +105,8 @@ void Foam::setToPointZone::applyToSet
{
if (!isA<pointZoneSet>(set))
{
WarningIn
(
"setToPointZone::applyToSet(const topoSetSource::setAction"
", topoSet"
) << "Operation only allowed on a pointZoneSet." << endl;
WarningInFunction
<< "Operation only allowed on a pointZoneSet." << endl;
}
else
{

18
src/meshTools/sets/topoSetSource/topoSetSource.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
@ -82,11 +82,8 @@ Foam::autoPtr<Foam::topoSetSource> Foam::topoSetSource::New
if (cstrIter == wordConstructorTablePtr_->end())
{
FatalErrorIn
(
"topoSetSource::New(const word&, "
"const polyMesh&, const dictionary&)"
) << "Unknown topoSetSource type " << topoSetSourceType
FatalErrorInFunction
<< "Unknown topoSetSource type " << topoSetSourceType
<< endl << endl
<< "Valid topoSetSource types : " << endl
<< wordConstructorTablePtr_->sortedToc()
@ -109,11 +106,8 @@ Foam::autoPtr<Foam::topoSetSource> Foam::topoSetSource::New
if (cstrIter == istreamConstructorTablePtr_->end())
{
FatalErrorIn
(
"topoSetSource::New(const word&, "
"const polyMesh&, Istream&)"
) << "Unknown topoSetSource type " << topoSetSourceType
FatalErrorInFunction
<< "Unknown topoSetSource type " << topoSetSourceType
<< endl << endl
<< "Valid topoSetSource types : " << endl
<< istreamConstructorTablePtr_->sortedToc()
@ -132,7 +126,7 @@ Foam::Istream& Foam::topoSetSource::checkIs(Istream& is)
}
else
{
FatalErrorIn("cellToFace::cellToFace") << "Istream not good"
FatalErrorInFunction
<< exit(FatalError);
return is;

4
src/meshTools/sets/topoSets/faceSet.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
@ -133,7 +133,7 @@ void faceSet::sync(const polyMesh& mesh)
}
else if (found(faceI))
{
FatalErrorIn("faceSet::sync(const polyMesh&)")
FatalErrorInFunction
<< "Problem : syncing removed faces from set."
<< abort(FatalError);
}

8
src/meshTools/sets/topoSets/faceZoneSet.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
@ -206,7 +206,7 @@ void faceZoneSet::subset(const topoSet& set)
if (nConflict > 0)
{
WarningIn(" faceZoneSet::subset(const topoSet&)")
WarningInFunction
<< "subset : there are " << nConflict
<< " faces with different orientation in faceZonesSets "
<< name() << " and " << set.name() << endl;
@ -257,7 +257,7 @@ void faceZoneSet::addSet(const topoSet& set)
if (nConflict > 0)
{
WarningIn("faceZoneSet::addSet(const topoSet&)")
WarningInFunction
<< "addSet : there are " << nConflict
<< " faces with different orientation in faceZonesSets "
<< name() << " and " << set.name() << endl;
@ -309,7 +309,7 @@ void faceZoneSet::deleteSet(const topoSet& set)
if (nConflict > 0)
{
WarningIn("faceZoneSet::deleteSet(const topoSet&)")
WarningInFunction
<< "deleteSet : there are " << nConflict
<< " faces with different orientation in faceZonesSets "
<< name() << " and " << set.name() << endl;

29
src/meshTools/sets/topoSets/topoSet.C
View File

@ -56,11 +56,8 @@ Foam::autoPtr<Foam::topoSet> Foam::topoSet::New
if (cstrIter == wordConstructorTablePtr_->end())
{
FatalErrorIn
(
"topoSet::New(const word&, "
"const polyMesh&, const word&, readOption, writeOption)"
) << "Unknown set type " << setType
FatalErrorInFunction
<< "Unknown set type " << setType
<< endl << endl
<< "Valid set types : " << endl
<< wordConstructorTablePtr_->sortedToc()
@ -85,11 +82,8 @@ Foam::autoPtr<Foam::topoSet> Foam::topoSet::New
if (cstrIter == sizeConstructorTablePtr_->end())
{
FatalErrorIn
(
"topoSet::New(const word&, "
"const polyMesh&, const word&, const label, writeOption)"
) << "Unknown set type " << setType
FatalErrorInFunction
<< "Unknown set type " << setType
<< endl << endl
<< "Valid set types : " << endl
<< sizeConstructorTablePtr_->sortedToc()
@ -114,11 +108,8 @@ Foam::autoPtr<Foam::topoSet> Foam::topoSet::New
if (cstrIter == setConstructorTablePtr_->end())
{
FatalErrorIn
(
"topoSet::New(const word&, "
"const polyMesh&, const word&, const topoSet&, writeOption)"
) << "Unknown set type " << setType
FatalErrorInFunction
<< "Unknown set type " << setType
<< endl << endl
<< "Valid set types : " << endl
<< setConstructorTablePtr_->sortedToc()
@ -152,10 +143,8 @@ void Foam::topoSet::updateLabels(const labelList& map)
{
if ((iter.key() < 0) || (iter.key() > map.size()))
{
FatalErrorIn
(
"topoSet::updateLabels(const labelList&, labelHashSet)"
) << "Illegal content " << iter.key() << " of set:" << name()
FatalErrorInFunction
<< "Illegal content " << iter.key() << " of set:" << name()
<< " of type " << type() << endl
<< "Value should be between 0 and " << map.size()-1
<< abort(FatalError);
@ -197,7 +186,7 @@ void Foam::topoSet::check(const label maxLabel)
{
if ((iter.key() < 0) || (iter.key() > maxLabel))
{
FatalErrorIn("topoSet::check(const label)")
FatalErrorInFunction
<< "Illegal content " << iter.key() << " of set:" << name()
<< " of type " << type() << endl
<< "Value should be between 0 and " << maxLabel

50
src/meshTools/triSurface/booleanOps/booleanSurface/booleanSurface.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 @@ void Foam::booleanSurface::checkIncluded
if (!usesIncluded)
{
FatalErrorIn
(
"booleanSurface::checkIncluded(const intersectedSurface&"
", const labelList&, const label)"
) << "None of the faces reachable from face " << includedFace
FatalErrorInFunction
<< "None of the faces reachable from face " << includedFace
<< " connects to the intersection."
<< exit(FatalError);
}
@ -114,11 +111,8 @@ Foam::label Foam::booleanSurface::findEdge
return edgeLabels[edgeLabelI];
}
}
FatalErrorIn
(
"booleanSurface::findEdge(const edgeList&, const labelList&"
", const edge&)"
) << "Cannot find edge " << e << " in edges " << edgeLabels
FatalErrorInFunction
<< "Cannot find edge " << e << " in edges " << edgeLabels
<< abort(FatalError);
return -1;
@ -213,12 +207,8 @@ void Foam::booleanSurface::propagateEdgeSide
if (((eFaces.size() % 2) == 1) && (eFaces.size() != 1))
{
FatalErrorIn
(
"booleanSurface::propagateEdgeSide(const triSurface&,"
"const label, const label, const label, const label,"
" labelList&)"
) << "Don't know how to handle edges with odd number of faces"
FatalErrorInFunction
<< "Don't know how to handle edges with odd number of faces"
<< endl
<< "edge:" << edgeI << " vertices:" << surf.edges()[edgeI]
<< " coming from face:" << prevFaceI
@ -447,11 +437,8 @@ Foam::booleanSurface::booleanSurface
if (cutSurf1FaceI == -1)
{
FatalErrorIn
(
"booleanSurface(const triSurfaceSearch&"
", const label, const triSurfaceSearch&, const label)"
) << "Did not find face with label " << includeFace1
FatalErrorInFunction
<< "Did not find face with label " << includeFace1
<< " in intersectedSurface."
<< exit(FatalError);
}
@ -466,11 +453,8 @@ Foam::booleanSurface::booleanSurface
}
if (cutSurf2FaceI == -1)
{
FatalErrorIn
(
"booleanSurface(const triSurfaceSearch&"
", const label, const triSurfaceSearch&, const label)"
) << "Did not find face with label " << includeFace2
FatalErrorInFunction
<< "Did not find face with label " << includeFace2
<< " in intersectedSurface."
<< exit(FatalError);
}
@ -727,7 +711,7 @@ Foam::booleanSurface::booleanSurface
if (eFaces.size() == 1)
{
WarningIn("booleanSurface::booleanSurface")
WarningInFunction
<< "surf1 is open surface at edge " << edgeI
<< " verts:" << surf1.edges()[edgeI]
<< " connected to faces " << eFaces << endl;
@ -743,7 +727,7 @@ Foam::booleanSurface::booleanSurface
if (eFaces.size() == 1)
{
WarningIn("booleanSurface::booleanSurface")
WarningInFunction
<< "surf2 is open surface at edge " << edgeI
<< " verts:" << surf2.edges()[edgeI]
<< " connected to faces " << eFaces << endl;
@ -1001,12 +985,8 @@ Foam::booleanSurface::booleanSurface
{
if (side[faceI] == UNVISITED)
{
FatalErrorIn
(
"booleanSurface::booleanSurface"
"(const triSurfaceSearch&, const triSurfaceSearch&"
", const label booleanOp)"
) << "Face " << faceI << " has not been reached by walking from"
FatalErrorInFunction
<< "Face " << faceI << " has not been reached by walking from"
<< " nearest point " << minHit.rawPoint()
<< " nearest face " << minFaceI << exit(FatalError);
}

4
src/meshTools/triSurface/booleanOps/booleanSurface/booleanSurface.H
View File

@ -218,7 +218,7 @@ public:
{
if (!from1(faceI))
{
FatalErrorIn("booleanSurface::surf1Face(const label)")
FatalErrorInFunction
<< "face " << faceI << " not from surface 1"
<< abort(FatalError);
}
@ -229,7 +229,7 @@ public:
{
if (from1(faceI))
{
FatalErrorIn("booleanSurface::surf2Face(const label)")
FatalErrorInFunction
<< "face " << faceI << " not from surface 2"
<< abort(FatalError);
}

6
src/meshTools/triSurface/booleanOps/intersectedSurface/edgeSurface.H
View File

@ -170,10 +170,8 @@ public:
}
else
{
FatalErrorIn
(
"edgeSurface::parentEdge(const label edgeI) const"
) << "Trying to get parent (i.e. surface) edge for"
FatalErrorInFunction
<< "Trying to get parent (i.e. surface) edge for"
<< " intersection edge " << edgeI
<< abort(FatalError);
return -1;

48
src/meshTools/triSurface/booleanOps/intersectedSurface/intersectedSurface.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
@ -242,7 +242,7 @@ bool Foam::intersectedSurface::sameEdgeOrder
}
else
{
FatalErrorIn("intersectedSurface::sameEdgeOrder")
FatalErrorInFunction
<< "Triangle:" << fA << " and triangle:" << fB
<< " share a point but not an edge"
<< abort(FatalError);
@ -250,7 +250,7 @@ bool Foam::intersectedSurface::sameEdgeOrder
}
}
FatalErrorIn("intersectedSurface::sameEdgeOrder")
FatalErrorInFunction
<< "Triangle:" << fA << " and triangle:" << fB
<< " do not share an edge"
<< abort(FatalError);
@ -341,11 +341,8 @@ Foam::intersectedSurface::calcPointEdgeAddressing
// Check on dangling points.
if (iter().empty())
{
FatalErrorIn
(
"intersectedSurface::calcPointEdgeAddressing"
"(const edgeSurface&, const label)"
) << "Point:" << iter.key() << " used by too few edges:"
FatalErrorInFunction
<< "Point:" << iter.key() << " used by too few edges:"
<< iter() << abort(FatalError);
}
}
@ -411,12 +408,8 @@ Foam::label Foam::intersectedSurface::nextEdge
writeLocalOBJ(points, edges, connectedEdges, "faceEdges.obj");
}
FatalErrorIn
(
"intersectedSurface::nextEdge(const pointField&, const edgeList&"
", const vector&, Map<DynamicList<label> >, const label"
", const label)"
) << "Problem: prevVertI:" << prevVertI << " on edge " << prevEdgeI
FatalErrorInFunction
<< "Problem: prevVertI:" << prevVertI << " on edge " << prevEdgeI
<< " has less than 2 connected edges."
<< " connectedEdges:" << connectedEdges << abort(FatalError);
@ -471,7 +464,7 @@ Foam::label Foam::intersectedSurface::nextEdge
writeLocalOBJ(points, edges, connectedEdges, "faceEdges.obj");
}
FatalErrorIn("intersectedSurface::nextEdge")
FatalErrorInFunction
<< "Unnormalized normal e1:" << e1
<< " formed from cross product of e0:" << e0 << " n:" << n
<< abort(FatalError);
@ -539,13 +532,8 @@ Foam::label Foam::intersectedSurface::nextEdge
writeLocalOBJ(points, edges, connectedEdges, "faceEdges.obj");
}
FatalErrorIn
(
"intersectedSurface::nextEdge(const pointField&, const edgeList&"
", const Map<label>&, const vector&"
", const Map<DynamicList<label> >&"
", const label, const label"
) << "Trying to step from edge " << edges[prevEdgeI]
FatalErrorInFunction
<< "Trying to step from edge " << edges[prevEdgeI]
<< ", vertex " << prevVertI
<< " but cannot find 'unvisited' edges among candidates:"
<< connectedEdges
@ -687,12 +675,12 @@ void Foam::intersectedSurface::findNearestVisited
{
const labelList& fEdges = eSurf.faceEdges()[faceI];
SeriousErrorIn("intersectedSurface::findNearestVisited")
SeriousErrorInFunction
<< "Dumping face edges to faceEdges.obj" << endl;
writeLocalOBJ(eSurf.points(), eSurf.edges(), fEdges, "faceEdges.obj");
FatalErrorIn("intersectedSurface::findNearestVisited")
FatalErrorInFunction
<< "No fully visited edge found for pt " << pt
<< abort(FatalError);
}
@ -1069,12 +1057,12 @@ Foam::faceList Foam::intersectedSurface::splitFace
if (eSurf.isSurfaceEdge(edgeI) && stat != BOTH)
{
SeriousErrorIn("Foam::intersectedSurface::splitFace")
SeriousErrorInFunction
<< "Dumping face edges to faceEdges.obj" << endl;
writeLocalOBJ(points, edges, fEdges, "faceEdges.obj");
FatalErrorIn("intersectedSurface::splitFace")
FatalErrorInFunction
<< "Problem: edge " << edgeI << " vertices "
<< edges[edgeI] << " on face " << faceI
<< " has visited status " << stat << " from a "
@ -1261,10 +1249,8 @@ Foam::intersectedSurface::intersectedSurface
{
if (t[i] < 0 || t[i] >= eSurf.points().size())
{
FatalErrorIn
(
"intersectedSurface::intersectedSurface"
) << "Face triangulation of face " << faceI
FatalErrorInFunction
<< "Face triangulation of face " << faceI
<< " uses points outside range 0.."
<< eSurf.points().size()-1 << endl
<< "Triangulation:"
@ -1359,7 +1345,7 @@ Foam::intersectedSurface::intersectedSurface
}
else
{
FatalErrorIn("intersectedSurface::intersectedSurface")
FatalErrorInFunction
<< "Cannot find edge among candidates " << pEdges
<< " which uses points " << surfStartI
<< " and " << surfEndI

16
src/meshTools/triSurface/booleanOps/surfaceIntersection/edgeIntersections.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
@ -68,10 +68,8 @@ void Foam::edgeIntersections::checkEdges(const triSurface& surf)
if (eMag < minSize)
{
WarningIn
(
"Foam::edgeIntersections::checkEdges(const triSurface& surf)"
) << "Edge " << edgeI << " vertices " << e
WarningInFunction
<< "Edge " << edgeI << " vertices " << e
<< " coords:" << localPoints[e[0]] << ' '
<< localPoints[e[1]] << " is very small compared to bounding"
<< " box dimensions " << bb << endl
@ -81,10 +79,8 @@ void Foam::edgeIntersections::checkEdges(const triSurface& surf)
if (edgeFaces[edgeI].size() == 1)
{
WarningIn
(
"Foam::edgeIntersections::checkEdges(const triSurface& surf)"
) << "Edge " << edgeI << " vertices " << e
WarningInFunction
<< "Edge " << edgeI << " vertices " << e
<< " coords:" << localPoints[e[0]] << ' '
<< localPoints[e[1]] << " has only one face connected to it:"
<< edgeFaces[edgeI] << endl
@ -682,7 +678,7 @@ Foam::label Foam::edgeIntersections::removeDegenerates
if (edgesToTest.empty())
{
FatalErrorIn("perturb") << "oops" << abort(FatalError);
FatalErrorInFunction << "oops" << abort(FatalError);
}
// Re intersect moved edges.

15
src/meshTools/triSurface/booleanOps/surfaceIntersection/surfaceIntersection.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
@ -184,7 +184,7 @@ bool Foam::surfaceIntersection::excludeEdgeHit
// }
// }
//
// FatalErrorIn("surfaceIntersection::borderEdgeIntersection")
// FatalErrorInFunction
// << "Did not find intersection of plane " << pl
// << " with edges of face " << hitFaceI << " verts:" << f
// << abort(FatalError);
@ -239,13 +239,8 @@ void Foam::surfaceIntersection::storeIntersection
if (mag(prevHit - thisHit) < SMALL)
{
WarningIn
(
"Foam::surfaceIntersection::storeIntersection"
"(const bool isFirstSurf, const labelList& facesA,"
"const label faceB, DynamicList<edge>& allCutEdges,"
"DynamicList<point>& allCutPoints)"
) << "Encountered degenerate edge between face "
WarningInFunction
<< "Encountered degenerate edge between face "
<< twoFaces[0] << " on first surface"
<< " and face " << twoFaces[1] << " on second surface"
<< endl
@ -968,7 +963,7 @@ Foam::surfaceIntersection::surfaceIntersection
if (!usedPoints.found(pointI))
{
WarningIn("surfaceIntersection::surfaceIntersection")
WarningInFunction
<< "Problem: cut point:" << pointI
<< " coord:" << cutPoints_[pointI]
<< " not used by any edge" << endl;

9
src/meshTools/triSurface/booleanOps/surfaceIntersection/surfaceIntersectionFuncs.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
@ -104,11 +104,8 @@ Foam::label Foam::surfaceIntersection::getEdge
}
}
FatalErrorIn
(
"surfaceIntersection::getEdge(const triSurface&"
", const label, const label"
) << "Problem:: Cannot find edge with vertices " << faceEdge
FatalErrorInFunction
<< "Problem:: Cannot find edge with vertices " << faceEdge
<< " in face " << faceI
<< abort(FatalError);

10
src/meshTools/triSurface/orientedSurface/orientedSurface.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
@ -106,7 +106,7 @@ Foam::labelList Foam::orientedSurface::edgeToFace
{
if (flip[face1] == UNVISITED)
{
FatalErrorIn("orientedSurface::edgeToFace(..)") << "Problem"
FatalErrorInFunction
<< abort(FatalError);
}
else
@ -330,10 +330,8 @@ bool Foam::orientedSurface::flipSurface
{
if (flipState[faceI] == UNVISITED)
{
FatalErrorIn
(
"orientSurface(const point&, const label, const point&)"
) << "unvisited face " << faceI
FatalErrorInFunction
<< "unvisited face " << faceI
<< abort(FatalError);
}
else if (flipState[faceI] == FLIP)

16
src/meshTools/triSurface/surfaceFeatures/surfaceFeatures.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
@ -949,7 +949,7 @@ Foam::Map<Foam::label> Foam::surfaceFeatures::nearestSamples
if (!info.hit())
{
FatalErrorIn("surfaceFeatures::nearestSamples")
FatalErrorInFunction
<< "Problem for point "
<< surfPointI << " in tree " << ppTree.bb()
<< abort(FatalError);
@ -1484,19 +1484,15 @@ void Foam::surfaceFeatures::operator=(const surfaceFeatures& rhs)
// Check for assignment to self
if (this == &rhs)
{
FatalErrorIn
(
"Foam::surfaceFeatures::operator=(const Foam::surfaceFeatures&)"
) << "Attempted assignment to self"
FatalErrorInFunction
<< "Attempted assignment to self"
<< abort(FatalError);
}
if (&surf_ != &rhs.surface())
{
FatalErrorIn
(
"Foam::surfaceFeatures::operator=(const Foam::surfaceFeatures&)"
) << "Operating on different surfaces"
FatalErrorInFunction
<< "Operating on different surfaces"
<< abort(FatalError);
}

4
src/meshTools/triSurface/triSurfaceSearch/triSurfaceRegionSearch.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
@ -135,7 +135,7 @@ Foam::triSurfaceRegionSearch::treeByRegion() const
// if (nPoints != surface().points().size())
// {
// WarningIn("triSurfaceRegionSearch::treeByRegion() const")
// WarningInFunction
// << "Surface does not have compact point numbering. "
// << "Of " << surface().points().size()
// << " only " << nPoints

4
src/meshTools/triSurface/triSurfaceSearch/triSurfaceSearch.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
@ -209,7 +209,7 @@ Foam::triSurfaceSearch::tree() const
if (nPoints != surface().points().size())
{
WarningIn("triSurfaceSearch::tree() const")
WarningInFunction
<< "Surface does not have compact point numbering."
<< " Of " << surface().points().size()
<< " only " << nPoints

20
src/meshTools/triSurface/triSurfaceTools/pointToPointPlanarInterpolation.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2012-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -51,11 +51,8 @@ Foam::pointToPointPlanarInterpolation::calcCoordinateSystem
{
if (points.size() < 3)
{
FatalErrorIn
(
"pointToPointPlanarInterpolation::calcCoordinateSystem"
"(const pointField&)"
) << "Only " << points.size() << " provided." << nl
FatalErrorInFunction
<< "Only " << points.size() << " provided." << nl
<< "Need at least three non-colinear points"
<< " to be able to interpolate."
<< exit(FatalError);
@ -103,11 +100,8 @@ Foam::pointToPointPlanarInterpolation::calcCoordinateSystem
}
if (index2 == -1)
{
FatalErrorIn
(
"pointToPointPlanarInterpolation::calcCoordinateSystem"
"(const pointField&)"
) << "Cannot find points that make valid normal." << nl
FatalErrorInFunction
<< "Cannot find points that make valid normal." << nl
<< "Have so far points " << p0 << " and " << p1
<< "Need at least three points which are not in a line."
<< exit(FatalError);
@ -154,7 +148,7 @@ void Foam::pointToPointPlanarInterpolation::calcWeights
if (!fullMatch)
{
FatalErrorIn("pointToPointPlanarInterpolation::calcWeights(..)")
FatalErrorInFunction
<< "Did not find a corresponding sourcePoint for every face"
<< " centre" << exit(FatalError);
}
@ -390,7 +384,7 @@ bool Foam::pointToPointPlanarInterpolation::findTime
if (lo == -1)
{
//FatalErrorIn("findTime(..)")
//FatalErrorInFunction
// << "Cannot find starting sampling values for current time "
// << timeVal << nl
// << "Have sampling values for times "

9
src/meshTools/triSurface/triSurfaceTools/pointToPointPlanarInterpolationTemplates.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2012-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -35,11 +35,8 @@ Foam::tmp<Foam::Field<Type> > Foam::pointToPointPlanarInterpolation::interpolate
{
if (nPoints_ != sourceFld.size())
{
FatalErrorIn
(
"pointToPointPlanarInterpolation::interpolate"
"(const Field<Type>&) const"
) << "Number of source points = " << nPoints_
FatalErrorInFunction
<< "Number of source points = " << nPoints_
<< " number of values = " << sourceFld.size()
<< exit(FatalError);
}

59
src/meshTools/triSurface/triSurfaceTools/triSurfaceTools.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
@ -615,7 +615,7 @@ Foam::scalar Foam::triSurfaceTools::edgeCosAngle
}
else
{
FatalErrorIn("edgeCosAngle")
FatalErrorInFunction
<< "face " << faceI << " does not use vertex "
<< v1 << " of collapsed edge" << abort(FatalError);
}
@ -887,7 +887,7 @@ Foam::surfaceLocation Foam::triSurfaceTools::cutEdge
if (fp0 == -1)
{
FatalErrorIn("cutEdge(..)") << "excludePointI:" << excludePointI
FatalErrorInFunction
<< " localF:" << s.localFaces()[triI] << abort(FatalError);
}
@ -944,7 +944,7 @@ Foam::surfaceLocation Foam::triSurfaceTools::cutEdge
{
if (interI >= 2)
{
FatalErrorIn("cutEdge(..)")
FatalErrorInFunction
<< "problem : triangle has three intersections." << nl
<< "triangle:" << f.tri(points)
<< " d:" << d << abort(FatalError);
@ -963,7 +963,7 @@ Foam::surfaceLocation Foam::triSurfaceTools::cutEdge
{
if (interI >= 2)
{
FatalErrorIn("cutEdge(..)")
FatalErrorInFunction
<< "problem : triangle has three intersections." << nl
<< "triangle:" << f.tri(points)
<< " d:" << d << abort(FatalError);
@ -1210,7 +1210,7 @@ Foam::surfaceLocation Foam::triSurfaceTools::visitFaces
// If crossing an edge we expect next edge to be cut.
if (excludeEdgeI != -1 && !cutInfo.hit())
{
FatalErrorIn("triSurfaceTools::visitFaces(..)")
FatalErrorInFunction
<< "Triangle:" << triI
<< " excludeEdge:" << excludeEdgeI
<< " point:" << start.rawPoint()
@ -1469,12 +1469,8 @@ void Foam::triSurfaceTools::otherEdges
if (i0 == -1)
{
FatalErrorIn
(
"otherEdges"
"(const triSurface&, const label, const label,"
" label&, label&)"
) << "Edge " << surf.edges()[edgeI] << " not in face "
FatalErrorInFunction
<< "Edge " << surf.edges()[edgeI] << " not in face "
<< surf.localFaces()[faceI] << abort(FatalError);
}
@ -1515,12 +1511,8 @@ void Foam::triSurfaceTools::otherVertices
}
else
{
FatalErrorIn
(
"otherVertices"
"(const triSurface&, const label, const label,"
" label&, label&)"
) << "Vertex " << vertI << " not in face " << f << abort(FatalError);
FatalErrorInFunction
<< "Vertex " << vertI << " not in face " << f << abort(FatalError);
}
}
@ -1547,11 +1539,8 @@ Foam::label Foam::triSurfaceTools::oppositeEdge
}
}
FatalErrorIn
(
"oppositeEdge"
"(const triSurface&, const label, const label)"
) << "Cannot find vertex " << vertI << " in edges of face " << faceI
FatalErrorInFunction
<< "Cannot find vertex " << vertI << " in edges of face " << faceI
<< abort(FatalError);
return -1;
@ -1579,7 +1568,7 @@ Foam::label Foam::triSurfaceTools::oppositeVertex
}
}
FatalErrorIn("triSurfaceTools::oppositeVertex")
FatalErrorInFunction
<< "Cannot find vertex opposite edge " << edgeI << " vertices " << e
<< " in face " << faceI << " vertices " << f << abort(FatalError);
@ -1622,12 +1611,8 @@ Foam::label Foam::triSurfaceTools::getTriangle
{
if ((e0I == e1I) || (e0I == e2I) || (e1I == e2I))
{
FatalErrorIn
(
"getTriangle"
"(const triSurface&, const label, const label,"
" const label)"
) << "Duplicate edge labels : e0:" << e0I << " e1:" << e1I
FatalErrorInFunction
<< "Duplicate edge labels : e0:" << e0I << " e1:" << e1I
<< " e2:" << e2I
<< abort(FatalError);
}
@ -1693,7 +1678,7 @@ Foam::triSurface Foam::triSurfaceTools::collapseEdges
//
// if ((neighbours.size() != 2) && (neighbours.size() != 1))
// {
// FatalErrorIn("collapseEdges")
// FatalErrorInFunction
// << abort(FatalError);
// }
//
@ -1747,7 +1732,7 @@ Foam::triSurface Foam::triSurfaceTools::collapseEdges
if ((edgeI < 0) || (edgeI >= surf.nEdges()))
{
FatalErrorIn("collapseEdges")
FatalErrorInFunction
<< "Edge label outside valid range." << endl
<< "edge label:" << edgeI << endl
<< "total number of edges:" << surf.nEdges() << endl
@ -1777,7 +1762,7 @@ Foam::triSurface Foam::triSurfaceTools::collapseEdges
|| (pointMap[e.end()] != e.end())
)
{
FatalErrorIn("collapseEdges")
FatalErrorInFunction
<< "points already mapped. Double collapse." << endl
<< "edgeI:" << edgeI
<< " start:" << e.start()
@ -2224,7 +2209,7 @@ Foam::triSurfaceTools::sideType Foam::triSurfaceTools::surfaceSide
// if (mag(c) < 0.99)
// {
// FatalErrorIn("triSurfaceTools::surfaceSide")
// FatalErrorInFunction
// << "nearestPoint identified as being on triangle face "
// << "but vector from nearestPoint to sample is not "
// << "perpendicular to the normal." << nl
@ -2274,7 +2259,7 @@ Foam::triSurfaceTools::sideType Foam::triSurfaceTools::surfaceSide
// != edge(f[nearLabel], f[f.fcIndex(nearLabel)])
// )
// {
// FatalErrorIn("triSurfaceTools::surfaceSide")
// FatalErrorInFunction
// << "Edge:" << edgeI << " local vertices:" << e
// << " mesh vertices:" << meshEdge
// << " not at position " << nearLabel
@ -2335,7 +2320,7 @@ Foam::triSurfaceTools::sideType Foam::triSurfaceTools::surfaceSide
if (minEdgeI == -1)
{
FatalErrorIn("treeDataTriSurface::getSide")
FatalErrorInFunction
<< "Problem: did not find edge closer than " << minDistSqr
<< abort(FatalError);
}
@ -2565,7 +2550,7 @@ Foam::triSurface Foam::triSurfaceTools::delaunay2D(const List<vector2D>& pts)
if (err != 0)
{
FatalErrorIn("triSurfaceTools::delaunay2D(const List<vector2D>&)")
FatalErrorInFunction
<< "Failed dtris2 with vertices:" << pts.size()
<< abort(FatalError);
}

8
src/meshTools/twoDPointCorrector/twoDPointCorrector.C
View File

@ -102,7 +102,7 @@ void Foam::twoDPointCorrector::calcAddressing() const
if (mag(pn) < VSMALL)
{
FatalErrorIn("twoDPointCorrector::calcAddressing()")
FatalErrorInFunction
<< "Cannot determine normal vector from patches."
<< abort(FatalError);
}
@ -148,7 +148,7 @@ void Foam::twoDPointCorrector::calcAddressing() const
{
if (meshPoints.size() % 2 != 0)
{
WarningIn("twoDPointCorrector::calcAddressing()")
WarningInFunction
<< "the number of vertices in the geometry "
<< "is odd - this should not be the case for a 2-D case. "
<< "Please check the geometry."
@ -157,7 +157,7 @@ void Foam::twoDPointCorrector::calcAddressing() const
if (2*nNormalEdges != meshPoints.size())
{
WarningIn("twoDPointCorrector::calcAddressing()")
WarningInFunction
<< "The number of points in the mesh is "
<< "not equal to twice the number of edges normal to the plane "
<< "- this may be OK only for wedge geometries.\n"
@ -235,7 +235,7 @@ Foam::direction Foam::twoDPointCorrector::normalDir() const
}
else
{
FatalErrorIn("direction twoDPointCorrector::normalDir() const")
FatalErrorInFunction
<< "Plane normal not aligned with the coordinate system" << nl
<< " pn = " << pn
<< abort(FatalError);