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

6
src/parallel/decompose/decompose/fvFieldDecomposerDecomposeFields.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
@ -149,7 +149,7 @@ Foam::fvFieldDecomposer::decomposeField
}
else
{
FatalErrorIn("fvFieldDecomposer::decomposeField()")
FatalErrorInFunction
<< "Unknown type." << abort(FatalError);
}
}
@ -307,7 +307,7 @@ Foam::fvFieldDecomposer::decomposeField
}
else
{
FatalErrorIn("fvFieldDecomposer::decomposeField()")
FatalErrorInFunction
<< "Unknown type." << abort(FatalError);
}
}

42
src/parallel/decompose/decompositionMethods/decompositionMethod/decompositionMethod.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
@ -66,11 +66,8 @@ Foam::autoPtr<Foam::decompositionMethod> Foam::decompositionMethod::New
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn
(
"decompositionMethod::New"
"(const dictionary& decompositionDict)"
) << "Unknown decompositionMethod "
FatalErrorInFunction
<< "Unknown decompositionMethod "
<< methodType << nl << nl
<< "Valid decompositionMethods are : " << endl
<< dictionaryConstructorTablePtr_->sortedToc()
@ -768,17 +765,8 @@ Foam::labelList Foam::decompositionMethod::decompose
if (nWeights > 0 && cellWeights.size() != mesh.nCells())
{
FatalErrorIn
(
"decompositionMethod::decompose\n"
"(\n"
" const polyMesh&,\n"
" const scalarField&,\n"
" const boolList&,\n"
" const PtrList<labelList>&,\n"
" const labelList&,\n"
" const List<labelPair>&\n"
) << "Number of weights " << cellWeights.size()
FatalErrorInFunction
<< "Number of weights " << cellWeights.size()
<< " differs from number of cells " << mesh.nCells()
<< exit(FatalError);
}
@ -938,18 +926,8 @@ Foam::labelList Foam::decompositionMethod::decompose
}
else if (blockedFace[f0] != blockedFace[f1])
{
FatalErrorIn
(
"labelList decompose\n"
"(\n"
" const polyMesh&,\n"
" const scalarField&,\n"
" const boolList&,\n"
" const PtrList<labelList>&,\n"
" const labelList&,\n"
" const List<labelPair>&\n"
")"
) << "On explicit connection between faces " << f0
FatalErrorInFunction
<< "On explicit connection between faces " << f0
<< " and " << f1
<< " the two blockedFace status are not equal : "
<< blockedFace[f0] << " and " << blockedFace[f1]
@ -1093,7 +1071,7 @@ Foam::labelList Foam::decompositionMethod::decompose
label nbrProc = nbrDecomp[bFaceI];
if (ownProc != nbrProc)
{
FatalErrorIn("decompositionMethod::decompose()")
FatalErrorInFunction
<< "patch:" << pp.name()
<< " face:" << faceI
<< " at:" << mesh.faceCentres()[faceI]
@ -1145,7 +1123,7 @@ void Foam::decompositionMethod::setConstraints
if (patchI == -1)
{
FatalErrorIn("decompositionMethod::decompose(const polyMesh&)")
FatalErrorInFunction
<< "Unknown preservePatch " << pNames[i]
<< endl << "Valid patches are " << patches.names()
<< exit(FatalError);
@ -1179,7 +1157,7 @@ void Foam::decompositionMethod::setConstraints
if (zoneI == -1)
{
FatalErrorIn("decompositionMethod::decompose(const polyMesh&)")
FatalErrorInFunction
<< "Unknown preserveFaceZone " << zNames[i]
<< endl << "Valid faceZones are " << fZones.names()
<< exit(FatalError);

9
src/parallel/decompose/decompositionMethods/geomDecomp/geomDecomp.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
@ -43,11 +43,8 @@ Foam::geomDecomp::geomDecomp
if (nProcessors_ != n_.x()*n_.y()*n_.z())
{
FatalErrorIn
(
"geomDecomp::geomDecomp"
"(const dictionary& decompositionDict)"
) << "Wrong number of processor divisions in geomDecomp:" << nl
FatalErrorInFunction
<< "Wrong number of processor divisions in geomDecomp:" << nl
<< "Number of domains : " << nProcessors_ << nl
<< "Wanted decomposition : " << n_
<< exit(FatalError);

14
src/parallel/decompose/decompositionMethods/hierarchGeomDecomp/hierarchGeomDecomp.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -50,10 +50,8 @@ void Foam::hierarchGeomDecomp::setDecompOrder()
if (order.size() != 3)
{
FatalIOErrorIn
FatalIOErrorInFunction
(
"hierarchGeomDecomp::hierarchGeomDecomp"
"(const dictionary& decompositionDict)",
decompositionDict_
) << "number of characters in order (" << order << ") != 3"
<< exit(FatalIOError);
@ -75,10 +73,8 @@ void Foam::hierarchGeomDecomp::setDecompOrder()
}
else
{
FatalIOErrorIn
FatalIOErrorInFunction
(
"hierarchGeomDecomp::hierarchGeomDecomp"
"(const dictionary& decompositionDict)",
decompositionDict_
) << "Illegal decomposition order " << order << endl
<< "It should only contain x, y or z" << exit(FatalError);
@ -229,7 +225,7 @@ void Foam::hierarchGeomDecomp::findBinary
if (returnReduce(hasNotChanged, andOp<bool>()))
{
WarningIn("hierarchGeomDecomp::findBinary(..)")
WarningInFunction
<< "unable to find desired decomposition split, making do!"
<< endl;
break;
@ -309,7 +305,7 @@ void Foam::hierarchGeomDecomp::findBinary
if (returnReduce(hasNotChanged, andOp<bool>()))
{
WarningIn("hierarchGeomDecomp::findBinary(..)")
WarningInFunction
<< "unable to find desired deomposition split, making do!"
<< endl;
break;

14
src/parallel/decompose/decompositionMethods/manualDecomp/manualDecomp.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
@ -85,10 +85,8 @@ Foam::labelList Foam::manualDecomp::decompose
if (finalDecomp.size() != points.size())
{
FatalErrorIn
(
"manualDecomp::decompose(const pointField&, const scalarField&)"
) << "Size of decomposition list does not correspond "
FatalErrorInFunction
<< "Size of decomposition list does not correspond "
<< "to the number of points. Size: "
<< finalDecomp.size() << " Number of points: "
<< points.size()
@ -99,10 +97,8 @@ Foam::labelList Foam::manualDecomp::decompose
if (min(finalDecomp) < 0 || max(finalDecomp) > nProcessors_ - 1)
{
FatalErrorIn
(
"manualDecomp::decompose(const pointField&, const scalarField&)"
) << "According to the decomposition, cells assigned to "
FatalErrorInFunction
<< "According to the decomposition, cells assigned to "
<< "impossible processor numbers. Min processor = "
<< min(finalDecomp) << " Max processor = " << max(finalDecomp)
<< ".\n" << "Manual decomposition data read from file "

4
src/parallel/decompose/decompositionMethods/multiLevelDecomp/multiLevelDecomp.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
@ -351,7 +351,7 @@ Foam::multiLevelDecomp::multiLevelDecomp(const dictionary& decompositionDict)
if (n != nDomains())
{
FatalErrorIn("multiLevelDecomp::multiLevelDecomp(const dictionary&)")
FatalErrorInFunction
<< "Top level decomposition specifies " << nDomains()
<< " domains which is not equal to the product of"
<< " all sub domains " << n

2
src/parallel/decompose/decompositionMethods/structuredDecomp/structuredDecomp.C
View File

@ -149,7 +149,7 @@ Foam::labelList Foam::structuredDecomp::decompose
{
if (!haveWarned)
{
WarningIn("structuredDecomp::decompose(..)")
WarningInFunction
<< "Did not visit some cells, e.g. cell " << cellI
<< " at " << mesh.cellCentres()[cellI] << endl
<< "Assigning these cells to domain 0." << endl;

44
src/parallel/decompose/metisDecomp/metisDecomp.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
@ -88,21 +88,15 @@ Foam::label Foam::metisDecomp::decompose
{
if (minWeights <= 0)
{
WarningIn
(
"metisDecomp::decompose"
"(const pointField&, const scalarField&)"
) << "Illegal minimum weight " << minWeights
WarningInFunction
<< "Illegal minimum weight " << minWeights
<< endl;
}
if (cWeights.size() != numCells)
{
FatalErrorIn
(
"metisDecomp::decompose"
"(const pointField&, const scalarField&)"
) << "Number of cell weights " << cWeights.size()
FatalErrorInFunction
<< "Number of cell weights " << cWeights.size()
<< " does not equal number of cells " << numCells
<< exit(FatalError);
}
@ -126,7 +120,7 @@ Foam::label Foam::metisDecomp::decompose
{
if (method != "recursive" && method != "k-way")
{
FatalErrorIn("metisDecomp::decompose()")
FatalErrorInFunction
<< "Method " << method << " in metisCoeffs in dictionary : "
<< decompositionDict_.name()
<< " should be 'recursive' or 'k-way'"
@ -141,7 +135,7 @@ Foam::label Foam::metisDecomp::decompose
{
if (options.size() != METIS_NOPTIONS)
{
FatalErrorIn("metisDecomp::decompose()")
FatalErrorInFunction
<< "Number of options in metisCoeffs in dictionary : "
<< decompositionDict_.name()
<< " should be " << METIS_NOPTIONS
@ -158,7 +152,7 @@ Foam::label Foam::metisDecomp::decompose
if (processorWeights.size() != nProcessors_)
{
FatalErrorIn("metisDecomp::decompose(const pointField&)")
FatalErrorInFunction
<< "Number of processor weights "
<< processorWeights.size()
<< " does not equal number of domains " << nProcessors_
@ -185,7 +179,7 @@ Foam::label Foam::metisDecomp::decompose
//
// if (cellWeights.size() != xadj.size()-1)
// {
// FatalErrorIn("metisDecomp::decompose(const pointField&)")
// FatalErrorInFunction
// << "Number of cell weights " << cellWeights.size()
// << " does not equal number of cells " << xadj.size()-1
// << exit(FatalError);
@ -265,10 +259,8 @@ Foam::labelList Foam::metisDecomp::decompose
{
if (points.size() != mesh.nCells())
{
FatalErrorIn
(
"metisDecomp::decompose(const pointField&,const scalarField&)"
) << "Can use this decomposition method only for the whole mesh"
FatalErrorInFunction
<< "Can use this decomposition method only for the whole mesh"
<< endl
<< "and supply one coordinate (cellCentre) for every cell." << endl
<< "The number of coordinates " << points.size() << endl
@ -304,11 +296,8 @@ Foam::labelList Foam::metisDecomp::decompose
{
if (agglom.size() != mesh.nCells())
{
FatalErrorIn
(
"metisDecomp::decompose"
"(const labelList&, const pointField&, const scalarField&)"
) << "Size of cell-to-coarse map " << agglom.size()
FatalErrorInFunction
<< "Size of cell-to-coarse map " << agglom.size()
<< " differs from number of cells in mesh " << mesh.nCells()
<< exit(FatalError);
}
@ -346,11 +335,8 @@ Foam::labelList Foam::metisDecomp::decompose
{
if (cellCentres.size() != globalCellCells.size())
{
FatalErrorIn
(
"metisDecomp::decompose"
"(const pointField&, const labelListList&, const scalarField&)"
) << "Inconsistent number of cells (" << globalCellCells.size()
FatalErrorInFunction
<< "Inconsistent number of cells (" << globalCellCells.size()
<< ") and number of cell centres (" << cellCentres.size()
<< ")." << exit(FatalError);
}

41
src/parallel/decompose/ptscotchDecomp/ptscotchDecomp.C
View File

@ -152,7 +152,7 @@ void Foam::ptscotchDecomp::check(const int retVal, const char* str)
{
if (retVal)
{
FatalErrorIn("ptscotchDecomp::decompose(..)")
FatalErrorInFunction
<< "Call to scotch routine " << str << " failed."
<< exit(FatalError);
}
@ -238,7 +238,7 @@ void Foam::ptscotchDecomp::check(const int retVal, const char* str)
//
// if (prevXadj.size() != nSendCells[Pstream::myProcNo()-1])
// {
// FatalErrorIn("ptscotchDecomp::decompose(..)")
// FatalErrorInFunction
// << "Expected from processor " << Pstream::myProcNo()-1
// << " connectivity for " << nSendCells[Pstream::myProcNo()-1]
// << " nCells but only received " << prevXadj.size()
@ -315,7 +315,7 @@ void Foam::ptscotchDecomp::check(const int retVal, const char* str)
//
// if (nextFinalDecomp.size() != nSendCells[Pstream::myProcNo()])
// {
// FatalErrorIn("parMetisDecomp::decompose(..)")
// FatalErrorInFunction
// << "Expected from processor " << Pstream::myProcNo()+1
// << " decomposition for " << nSendCells[Pstream::myProcNo()]
// << " nCells but only received " << nextFinalDecomp.size()
@ -489,19 +489,15 @@ Foam::label Foam::ptscotchDecomp::decompose
{
if (minWeights <= 0)
{
WarningIn
(
"ptscotchDecomp::decompose(..)"
) << "Illegal minimum weight " << minWeights
WarningInFunction
<< "Illegal minimum weight " << minWeights
<< endl;
}
if (cWeights.size() != xadjSize-1)
{
FatalErrorIn
(
"ptscotchDecomp::decompose(..)"
) << "Number of cell weights " << cWeights.size()
FatalErrorInFunction
<< "Number of cell weights " << cWeights.size()
<< " does not equal number of cells " << xadjSize-1
<< exit(FatalError);
}
@ -519,10 +515,8 @@ Foam::label Foam::ptscotchDecomp::decompose
// rangeScale tipping the subsequent sum over the integer limit.
rangeScale = 0.9*scalar(labelMax - 1)/velotabSum;
WarningIn
(
"ptscotchDecomp::decompose(...)"
) << "Sum of weights has overflowed integer: " << velotabSum
WarningInFunction
<< "Sum of weights has overflowed integer: " << velotabSum
<< ", compressing weight scale by a factor of " << rangeScale
<< endl;
}
@ -737,10 +731,7 @@ Foam::labelList Foam::ptscotchDecomp::decompose
{
if (points.size() != mesh.nCells())
{
FatalErrorIn
(
"ptscotchDecomp::decompose(const pointField&, const scalarField&)"
)
FatalErrorInFunction
<< "Can use this decomposition method only for the whole mesh"
<< endl
<< "and supply one coordinate (cellCentre) for every cell." << endl
@ -796,10 +787,8 @@ Foam::labelList Foam::ptscotchDecomp::decompose
{
if (agglom.size() != mesh.nCells())
{
FatalErrorIn
(
"ptscotchDecomp::decompose(const labelList&, const pointField&)"
) << "Size of cell-to-coarse map " << agglom.size()
FatalErrorInFunction
<< "Size of cell-to-coarse map " << agglom.size()
<< " differs from number of cells in mesh " << mesh.nCells()
<< exit(FatalError);
}
@ -850,10 +839,8 @@ Foam::labelList Foam::ptscotchDecomp::decompose
{
if (cellCentres.size() != globalCellCells.size())
{
FatalErrorIn
(
"ptscotchDecomp::decompose(const pointField&, const labelListList&)"
) << "Inconsistent number of cells (" << globalCellCells.size()
FatalErrorInFunction
<< "Inconsistent number of cells (" << globalCellCells.size()
<< ") and number of cell centres (" << cellCentres.size()
<< ")." << exit(FatalError);
}

42
src/parallel/decompose/scotchDecomp/scotchDecomp.C
View File

@ -163,7 +163,7 @@ void Foam::scotchDecomp::check(const int retVal, const char* str)
{
if (retVal)
{
FatalErrorIn("scotchDecomp::decompose(..)")
FatalErrorInFunction
<< "Call to scotch routine " << str << " failed."
<< exit(FatalError);
}
@ -382,19 +382,15 @@ Foam::label Foam::scotchDecomp::decomposeOneProc
{
if (minWeights <= 0)
{
WarningIn
(
"scotchDecomp::decompose(...)"
) << "Illegal minimum weight " << minWeights
WarningInFunction
<< "Illegal minimum weight " << minWeights
<< endl;
}
if (cWeights.size() != xadj.size()-1)
{
FatalErrorIn
(
"scotchDecomp::decompose(...)"
) << "Number of cell weights " << cWeights.size()
FatalErrorInFunction
<< "Number of cell weights " << cWeights.size()
<< " does not equal number of cells " << xadj.size()-1
<< exit(FatalError);
}
@ -409,10 +405,8 @@ Foam::label Foam::scotchDecomp::decomposeOneProc
// rangeScale tipping the subsequent sum over the integer limit.
rangeScale = 0.9*scalar(labelMax - 1)/velotabSum;
WarningIn
(
"scotchDecomp::decompose(...)"
) << "Sum of weights has overflowed integer: " << velotabSum
WarningInFunction
<< "Sum of weights has overflowed integer: " << velotabSum
<< ", compressing weight scale by a factor of " << rangeScale
<< endl;
}
@ -601,11 +595,8 @@ Foam::labelList Foam::scotchDecomp::decompose
{
if (points.size() != mesh.nCells())
{
FatalErrorIn
(
"scotchDecomp::decompose(const polyMesh&, const pointField&"
", const scalarField&)"
) << "Can use this decomposition method only for the whole mesh"
FatalErrorInFunction
<< "Can use this decomposition method only for the whole mesh"
<< endl
<< "and supply one coordinate (cellCentre) for every cell." << endl
<< "The number of coordinates " << points.size() << endl
@ -655,12 +646,8 @@ Foam::labelList Foam::scotchDecomp::decompose
{
if (agglom.size() != mesh.nCells())
{
FatalErrorIn
(
"scotchDecomp::decompose"
"(const polyMesh&, const labelList&, const pointField&"
", const scalarField&)"
) << "Size of cell-to-coarse map " << agglom.size()
FatalErrorInFunction
<< "Size of cell-to-coarse map " << agglom.size()
<< " differs from number of cells in mesh " << mesh.nCells()
<< exit(FatalError);
}
@ -708,11 +695,8 @@ Foam::labelList Foam::scotchDecomp::decompose
{
if (cellCentres.size() != globalCellCells.size())
{
FatalErrorIn
(
"scotchDecomp::decompose"
"(const labelListList&, const pointField&, const scalarField&)"
) << "Inconsistent number of cells (" << globalCellCells.size()
FatalErrorInFunction
<< "Inconsistent number of cells (" << globalCellCells.size()
<< ") and number of cell centres (" << cellCentres.size()
<< ")." << exit(FatalError);
}

29
src/parallel/distributed/distributedTriSurfaceMesh/distributedTriSurfaceMesh.C
View File

@ -833,22 +833,16 @@ Foam::distributedTriSurfaceMesh::independentlyDistributedBbs
if (!decomposer_().parallelAware())
{
FatalErrorIn
(
"distributedTriSurfaceMesh::independentlyDistributedBbs"
"(const triSurface&)"
) << "The decomposition method " << decomposer_().typeName
FatalErrorInFunction
<< "The decomposition method " << decomposer_().typeName
<< " does not decompose in parallel."
<< " Please choose one that does." << exit(FatalError);
}
if (!isA<geomDecomp>(decomposer_()))
{
FatalErrorIn
(
"distributedTriSurfaceMesh::independentlyDistributedBbs"
"(const triSurface&)"
) << "The decomposition method " << decomposer_().typeName
FatalErrorInFunction
<< "The decomposition method " << decomposer_().typeName
<< " is not a geometric decomposition method." << endl
<< "Only geometric decomposition methods are currently"
<< " supported."
@ -1381,8 +1375,7 @@ Foam::distributedTriSurfaceMesh::distributedTriSurfaceMesh(const IOobject& io)
)
)
{
FatalErrorIn("Foam::distributedTriSurfaceMesh::read()")
<< " distributedTriSurfaceMesh is being constructed\n"
FatalErrorInFunction
<< " using 'timeStampMaster' or 'inotifyMaster.'\n"
<< " Modify the entry fileModificationChecking\n"
<< " in the etc/controlDict.\n"
@ -1465,8 +1458,7 @@ Foam::distributedTriSurfaceMesh::distributedTriSurfaceMesh
)
)
{
FatalErrorIn("Foam::distributedTriSurfaceMesh::read()")
<< " distributedTriSurfaceMesh is being constructed\n"
FatalErrorInFunction
<< " using 'timeStampMaster' or 'inotifyMaster.'\n"
<< " Modify the entry fileModificationChecking\n"
<< " in the etc/controlDict.\n"
@ -2004,11 +1996,8 @@ void Foam::distributedTriSurfaceMesh::getVolumeType
List<volumeType>& volType
) const
{
FatalErrorIn
(
"distributedTriSurfaceMesh::getVolumeType"
"(const pointField&, List<volumeType>&) const"
) << "Volume type not supported for distributed surfaces."
FatalErrorInFunction
<< "Volume type not supported for distributed surfaces."
<< exit(FatalError);
}
@ -2090,7 +2079,7 @@ void Foam::distributedTriSurfaceMesh::distribute
break;
default:
FatalErrorIn("distributedTriSurfaceMesh::distribute(..)")
FatalErrorInFunction
<< "Unsupported distribution type." << exit(FatalError);
break;
}

15
src/parallel/reconstruct/reconstruct/fvFieldReconstructor.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,17 +53,8 @@ Foam::fvFieldReconstructor::fvFieldReconstructor
|| boundaryProcAddressing[procI].size() != procMesh.boundary().size()
)
{
FatalErrorIn
(
"fvFieldReconstructor::fvFieldReconstructor\n"
"(\n"
" fvMesh&,\n"
" const PtrList<fvMesh>&,\n"
" const PtrList<labelIOList>&,\n"
" const PtrList<labelIOList>&,\n"
" const PtrList<labelIOList>&\n"
")"
) << "Size of maps does not correspond to size of mesh"
FatalErrorInFunction
<< "Size of maps does not correspond to size of mesh"
<< " for processor " << procI << endl
<< "faceProcAddressing : " << faceProcAddressing[procI].size()
<< " nFaces : " << procMesh.nFaces() << endl

13
src/parallel/reconstruct/reconstruct/fvFieldReconstructorReconstructFields.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
@ -190,15 +190,8 @@ Foam::fvFieldReconstructor::reconstructFvVolumeField
// Check
if (cp[faceI] <= 0)
{
FatalErrorIn
(
"fvFieldReconstructor::reconstructFvVolumeField\n"
"(\n"
" const IOobject&,\n"
" const PtrList<GeometricField<Type,"
" fvPatchField, volMesh> >&\n"
") const\n"
) << "Processor " << procI
FatalErrorInFunction
<< "Processor " << procI
<< " patch "
<< procField.mesh().boundary()[patchI].name()
<< " face " << faceI

15
src/parallel/reconstruct/reconstruct/pointFieldReconstructor.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,17 +83,8 @@ Foam::pointFieldReconstructor::pointFieldReconstructor
if (procPatchAddr.size() && min(procPatchAddr) < 0)
{
FatalErrorIn
(
"pointFieldReconstructor::pointFieldReconstructor"
"(\n"
" const pointMesh& mesh,\n"
" const PtrList<pointMesh>& procMeshes,\n"
" const PtrList<labelIOList>& pointProcAddressing,\n"
" const PtrList<labelIOList>& "
"boundaryProcAddressing\n"
")"
) << "Incomplete patch point addressing"
FatalErrorInFunction
<< "Incomplete patch point addressing"
<< abort(FatalError);
}
}

4
src/parallel/reconstruct/reconstruct/processorMeshes.C
View File

@ -177,7 +177,7 @@ Foam::fvMesh::readUpdateState Foam::processorMeshes::readUpdate()
}
else if (stat != procStat)
{
FatalErrorIn("processorMeshes::readUpdate()")
FatalErrorInFunction
<< "Processor " << procI
<< " has a different polyMesh at time "
<< databases_[procI].timeName()
@ -241,7 +241,7 @@ void Foam::processorMeshes::reconstructPoints(fvMesh& mesh)
if (pointProcAddressingI.size() != procPoints.size())
{
FatalErrorIn("processorMeshes")
FatalErrorInFunction
<< "problem :"
<< " pointProcAddressingI:" << pointProcAddressingI.size()
<< " procPoints:" << procPoints.size()