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

ENH: decomposePar: cache decomposeers if running with multiple times.

Browse Source
This commit is contained in:
mattijs
2012-04-16 12:37:01 +01:00
parent c8af778231
commit 96f8104ae5
1 changed files with 227 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -322,6 +322,23 @@ int main(int argc, char *argv[])
} }
// Caches
// ~~~~~~
// Cached processor meshes and maps. These are only preserved if running
// with multiple times.
PtrList<Time> processorDbList(mesh.nProcs());
PtrList<fvMesh> procMeshList(mesh.nProcs());
PtrList<labelIOList> faceProcAddressingList(mesh.nProcs());
PtrList<labelIOList> cellProcAddressingList(mesh.nProcs());
PtrList<labelIOList> boundaryProcAddressingList(mesh.nProcs());
PtrList<fvFieldDecomposer> fieldDecomposerList(mesh.nProcs());
PtrList<dimFieldDecomposer> dimFieldDecomposerList(mesh.nProcs());
PtrList<labelIOList> pointProcAddressingList(mesh.nProcs());
PtrList<pointFieldDecomposer> pointFieldDecomposerList(mesh.nProcs());
// Loop over all times // Loop over all times
forAll(times, timeI) forAll(times, timeI)
{ {
@ -674,13 +691,24 @@ int main(int argc, char *argv[])
{ {
Info<< "Processor " << procI << ": field transfer" << endl; Info<< "Processor " << procI << ": field transfer" << endl;
// open the database // open the database
Time processorDb if (!processorDbList.set(procI))
( {
Time::controlDictName, processorDbList.set
args.rootPath(), (
args.caseName()/fileName(word("processor") + name(procI)) procI,
); new Time
(
Time::controlDictName,
args.rootPath(),
args.caseName()
/fileName(word("processor") + name(procI))
)
);
}
Time& processorDb = processorDbList[procI];
processorDb.setTime(runTime); processorDb.setTime(runTime);
@ -695,65 +723,113 @@ int main(int argc, char *argv[])
} }
// read the mesh // read the mesh
fvMesh procMesh if (!procMeshList.set(procI))
( {
IOobject procMeshList.set
( (
regionName, procI,
processorDb.timeName(), new fvMesh
processorDb (
) IOobject
); (
regionName,
processorDb.timeName(),
processorDb
)
)
);
}
const fvMesh& procMesh = procMeshList[procI];
labelIOList faceProcAddressing
(
IOobject
(
"faceProcAddressing",
procMesh.facesInstance(),
procMesh.meshSubDir,
procMesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
);
labelIOList cellProcAddressing if (!faceProcAddressingList.set(procI))
( {
IOobject faceProcAddressingList.set
( (
"cellProcAddressing", procI,
procMesh.facesInstance(), new labelIOList
procMesh.meshSubDir, (
procMesh, IOobject
IOobject::MUST_READ, (
IOobject::NO_WRITE "faceProcAddressing",
) procMesh.facesInstance(),
); procMesh.meshSubDir,
procMesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
)
);
}
const labelIOList& faceProcAddressing =
faceProcAddressingList[procI];
labelIOList boundaryProcAddressing
( if (!cellProcAddressingList.set(procI))
IOobject {
cellProcAddressingList.set
( (
"boundaryProcAddressing", procI,
procMesh.facesInstance(), new labelIOList
procMesh.meshSubDir, (
procMesh, IOobject
IOobject::MUST_READ, (
IOobject::NO_WRITE "cellProcAddressing",
) procMesh.facesInstance(),
); procMesh.meshSubDir,
procMesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
)
);
}
const labelIOList& cellProcAddressing =
cellProcAddressingList[procI];
if (!boundaryProcAddressingList.set(procI))
{
boundaryProcAddressingList.set
(
procI,
new labelIOList
(
IOobject
(
"boundaryProcAddressing",
procMesh.facesInstance(),
procMesh.meshSubDir,
procMesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
)
);
}
const labelIOList& boundaryProcAddressing =
boundaryProcAddressingList[procI];
// FV fields // FV fields
{ {
fvFieldDecomposer fieldDecomposer if (!fieldDecomposerList.set(procI))
( {
mesh, fieldDecomposerList.set
procMesh, (
faceProcAddressing, procI,
cellProcAddressing, new fvFieldDecomposer
boundaryProcAddressing (
); mesh,
procMesh,
faceProcAddressing,
cellProcAddressing,
boundaryProcAddressing
)
);
}
const fvFieldDecomposer& fieldDecomposer =
fieldDecomposerList[procI];
fieldDecomposer.decomposeFields(volScalarFields); fieldDecomposer.decomposeFields(volScalarFields);
fieldDecomposer.decomposeFields(volVectorFields); fieldDecomposer.decomposeFields(volVectorFields);
@ -766,23 +842,43 @@ int main(int argc, char *argv[])
fieldDecomposer.decomposeFields(surfaceSphericalTensorFields); fieldDecomposer.decomposeFields(surfaceSphericalTensorFields);
fieldDecomposer.decomposeFields(surfaceSymmTensorFields); fieldDecomposer.decomposeFields(surfaceSymmTensorFields);
fieldDecomposer.decomposeFields(surfaceTensorFields); fieldDecomposer.decomposeFields(surfaceTensorFields);
if (times.size() == 1)
{
// Clear cached decomposer
fieldDecomposerList.set(procI, NULL);
}
} }
// Dimensioned fields // Dimensioned fields
{ {
dimFieldDecomposer fieldDecomposer if (!dimFieldDecomposerList.set(procI))
( {
mesh, dimFieldDecomposerList.set
procMesh, (
faceProcAddressing, procI,
cellProcAddressing new dimFieldDecomposer
); (
mesh,
procMesh,
faceProcAddressing,
cellProcAddressing
)
);
}
const dimFieldDecomposer& dimDecomposer =
dimFieldDecomposerList[procI];
fieldDecomposer.decomposeFields(dimScalarFields); dimDecomposer.decomposeFields(dimScalarFields);
fieldDecomposer.decomposeFields(dimVectorFields); dimDecomposer.decomposeFields(dimVectorFields);
fieldDecomposer.decomposeFields(dimSphericalTensorFields); dimDecomposer.decomposeFields(dimSphericalTensorFields);
fieldDecomposer.decomposeFields(dimSymmTensorFields); dimDecomposer.decomposeFields(dimSymmTensorFields);
fieldDecomposer.decomposeFields(dimTensorFields); dimDecomposer.decomposeFields(dimTensorFields);
if (times.size() == 1)
{
dimFieldDecomposerList.set(procI, NULL);
}
} }
@ -796,34 +892,59 @@ int main(int argc, char *argv[])
|| pointTensorFields.size() || pointTensorFields.size()
) )
{ {
labelIOList pointProcAddressing if (!pointProcAddressingList.set(procI))
( {
IOobject pointProcAddressingList.set
( (
"pointProcAddressing", procI,
procMesh.facesInstance(), new labelIOList
procMesh.meshSubDir, (
procMesh, IOobject
IOobject::MUST_READ, (
IOobject::NO_WRITE "pointProcAddressing",
) procMesh.facesInstance(),
); procMesh.meshSubDir,
procMesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
)
);
}
const labelIOList& pointProcAddressing =
pointProcAddressingList[procI];
pointMesh procPMesh(procMesh); const pointMesh& procPMesh = pointMesh::New(procMesh);
pointFieldDecomposer fieldDecomposer if (!pointFieldDecomposerList.set(procI))
( {
pMesh, pointFieldDecomposerList.set
procPMesh, (
pointProcAddressing, procI,
boundaryProcAddressing new pointFieldDecomposer
); (
pMesh,
procPMesh,
pointProcAddressing,
boundaryProcAddressing
)
);
}
const pointFieldDecomposer& pointDecomposer =
pointFieldDecomposerList[procI];
fieldDecomposer.decomposeFields(pointScalarFields); pointDecomposer.decomposeFields(pointScalarFields);
fieldDecomposer.decomposeFields(pointVectorFields); pointDecomposer.decomposeFields(pointVectorFields);
fieldDecomposer.decomposeFields(pointSphericalTensorFields); pointDecomposer.decomposeFields(pointSphericalTensorFields);
fieldDecomposer.decomposeFields(pointSymmTensorFields); pointDecomposer.decomposeFields(pointSymmTensorFields);
fieldDecomposer.decomposeFields(pointTensorFields); pointDecomposer.decomposeFields(pointTensorFields);
if (times.size() == 1)
{
pointProcAddressingList.set(procI, NULL);
pointFieldDecomposerList.set(procI, NULL);
}
} }
@ -938,6 +1059,20 @@ int main(int argc, char *argv[])
chDir(currentDir); chDir(currentDir);
} }
} }
// We have cached all the constant mesh data for the current
// processor. This is only important if running with multiple
// times, otherwise it is just extra storage.
if (times.size() == 1)
{
boundaryProcAddressingList.set(procI, NULL);
cellProcAddressingList.set(procI, NULL);
faceProcAddressingList.set(procI, NULL);
procMeshList.set(procI, NULL);
processorDbList.set(procI, NULL);
}
} }
} }