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

decomposePar changes

Browse Source 
* improved error checking for the -fields option
 * allow -lazy and -force combination
This commit is contained in:
Mark Olesen
2008-07-03 09:46:44 +02:00
parent 7d9f709ecc
commit e9a0d8147d
2 changed files with 103 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
applications/utilities/parallelProcessing/decomposePar/decomposePar.C
View File

@ -48,15 +48,15 @@ Usage
@param -force \n
Remove any existing @a processor subdirectories before decomposing the
geometry. Has precedence over the @a -lazy option.
geometry.
@param -lazy \n
Only decompose the geometry if the number of domains has changed
from a previous decomposition. Any existing @a processor subdirectories
are removed as necessary. This option can be used to avoid redundant
geometry decomposition (eg, in scripts), but should be used with caution
when the underlying (serial) geometry or the decomposition method etc
have been changed between decompositions.
Only decompose the geometry if the number of domains has changed from a
previous decomposition. No @a processor subdirectories will be removed
unless the @a -force option is also specified. This option can be used
to avoid redundant geometry decomposition (eg, in scripts), but should
be used with caution when the underlying (serial) geometry or the
decomposition method etc. have been changed between decompositions.
\*---------------------------------------------------------------------------*/
@ -110,83 +110,84 @@ int main(int argc, char *argv[])
++nProcs;
}
// Check for previously decomposed case first
// get requested numberOfSubdomains
label nDomains = 0;
{
IOdictionary decompDict
(
IOobject
(
"decomposeParDict",
runTime.time().system(),
runTime,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
);
decompDict.lookup("numberOfSubdomains") >> nDomains;
}
if (decomposeFieldsOnly)
{
if (!nProcs)
// Sanity check on previously decomposed case
if (nProcs != nDomains)
{
FatalErrorIn(args.executable())
<< "Specifying -fields requires a decomposed geometry!"
<< "Specified -fields, but the case was decomposed with "
<< nProcs << " domains"
<< nl
<< "instead of " << nDomains
<< " domains as specified in decomposeParDict"
<< nl
<< exit(FatalError);
}
}
else
else if (nProcs)
{
if (nProcs)
bool procDirsProblem = true;
if (lazyDecomposition && nProcs == nDomains)
{
bool hasProcDirs = true;
// we can reuse the decomposition
decomposeFieldsOnly = true;
procDirsProblem = false;
forceOverwrite = false;
if (forceOverwrite)
Info<< "Using existing processor directories" << nl;
}
if (forceOverwrite)
{
Info<< "Removing " << nProcs
<< " existing processor directories" << endl;
// remove existing processor dirs
// reverse order to avoid gaps if someone interrupts the process
for (label procI = nProcs-1; procI >= 0; --procI)
{
Info<< "Removing " << nProcs
<< " existing processor directories" << endl;
// remove existing processor dirs
for (label procI = nProcs-1; procI >= 0; --procI)
{
fileName procDir
(
runTime.path()/(word("processor") + name(procI))
);
rmDir(procDir);
}
hasProcDirs = false;
}
else if (lazyDecomposition)
{
// lazy decomposition
IOdictionary decompDict
fileName procDir
(
IOobject
(
"decomposeParDict",
runTime.time().system(),
runTime,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
runTime.path()/(word("processor") + name(procI))
);
label nDomains
(
readInt(decompDict.lookup("numberOfSubdomains"))
);
// avoid repeated decomposition
if (nDomains == nProcs)
{
decomposeFieldsOnly = true;
hasProcDirs = false;
Info<< "Using existing processor directories" << nl;
}
rmDir(procDir);
}
if (hasProcDirs)
{
FatalErrorIn(args.executable())
<< "Case is already decomposed with " << nProcs
<< " domains, use the -force option or manually" << nl
<< "remove processor directories before decomposing. e.g.,"
<< nl
<< " rm -rf " << runTime.path().c_str() << "/processor*"
<< nl
<< exit(FatalError);
}
procDirsProblem = false;
}
if (procDirsProblem)
{
FatalErrorIn(args.executable())
<< "Case is already decomposed with " << nProcs
<< " domains, use the -force option or manually" << nl
<< "remove processor directories before decomposing. e.g.,"
<< nl
<< " rm -rf " << runTime.path().c_str() << "/processor*"
<< nl
<< exit(FatalError);
}
}

70
applications/utilities/parallelProcessing/decomposePar/decomposeParDict
View File

@ -1,61 +1,61 @@
// Mesh decomposition control dictionary
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
/*-------------------------------*- C++ -*---------------------------------*\
| ========= |
| \\ / OpenFOAM |
| \\ / |
| \\ / The Open Source CFD Toolbox |
| \\/ http://www.OpenFOAM.org |
\*-------------------------------------------------------------------------*/
FoamFile
{
version 0.5;
format ascii;
root "ROOT";
case "CASE";
instance "system";
local "";
class dictionary;
object decompositionDict;
version 2.0;
format ascii;
class dictionary;
note "mesh decomposition control dictionary";
location "system";
object decomposeParDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
numberOfSubdomains 4;
numberOfSubdomains 4;
//preservePatches (inlet);
//preserveFaceZones (heater solid1 solid3);
// preservePatches (inlet);
// preserveFaceZones (heater solid1 solid3);
method simple;
//method hierarchical;
//method metis;
//method manual;
method simple;
// method hierarchical;
// method metis;
// method manual;
simpleCoeffs
{
n (2 2 1);
delta 0.001;
n (2 2 1);
delta 0.001;
}
hierarchicalCoeffs
{
n (2 2 1);
delta 0.001;
order xyz;
n (2 2 1);
delta 0.001;
order xyz;
}
metisCoeffs
{
//processorWeights
//(
// 1
// 1
// 1
// 1
//);
/*
processorWeights
(
1
1
1
1
);
*/
}
manualCoeffs
{
dataFile "decompositionData";
dataFile "decompositionData";
}
// ************************************************************************* //