diff --git a/applications/utilities/parallelProcessing/decomposePar/decomposePar.C b/applications/utilities/parallelProcessing/decomposePar/decomposePar.C
index bc94782641e5dd91485a0b44d2b3df7ebc173f59..f9425cc506b90b14426e9532e3618ea96a0cd57e 100644
--- a/applications/utilities/parallelProcessing/decomposePar/decomposePar.C
+++ b/applications/utilities/parallelProcessing/decomposePar/decomposePar.C
@@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
- \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
+ \\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@@ -43,6 +43,9 @@ Usage
Decompose all regions in regionProperties. Does not check for
existence of processor*.
+ - \par -copyZero \n
+ Copy \a 0 directory to processor* rather than decompose the fields.
+
- \par -copyUniform \n
Copy any \a uniform directories too.
@@ -215,6 +218,11 @@ int main(int argc, char *argv[])
"decomposition method or as a volScalarField for post-processing."
);
argList::addBoolOption
+ (
+ "copyZero",
+ "Copy \a 0 directory to processor* rather than decompose the fields"
+ );
+ argList::addBoolOption
(
"copyUniform",
"copy any uniform/ directories too"
@@ -247,6 +255,7 @@ int main(int argc, char *argv[])
bool allRegions = args.optionFound("allRegions");
bool writeCellDist = args.optionFound("cellDist");
+ bool copyZero = args.optionFound("copyZero");
bool copyUniform = args.optionFound("copyUniform");
bool decomposeFieldsOnly = args.optionFound("fields");
bool decomposeSets = !args.optionFound("noSets");
@@ -476,668 +485,715 @@ 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
- forAll(times, timeI)
+ if (copyZero)
{
- runTime.setTime(times[timeI], timeI);
-
- Info<< "Time = " << runTime.timeName() << endl;
-
- // Search for list of objects for this time
- IOobjectList objects(mesh, runTime.timeName());
-
-
- // Construct the vol fields
- // ~~~~~~~~~~~~~~~~~~~~~~~~
- PtrList<volScalarField> volScalarFields;
- readFields(mesh, objects, volScalarFields);
- PtrList<volVectorField> volVectorFields;
- readFields(mesh, objects, volVectorFields);
- PtrList<volSphericalTensorField> volSphericalTensorFields;
- readFields(mesh, objects, volSphericalTensorFields);
- PtrList<volSymmTensorField> volSymmTensorFields;
- readFields(mesh, objects, volSymmTensorFields);
- PtrList<volTensorField> volTensorFields;
- readFields(mesh, objects, volTensorFields);
-
-
- // Construct the dimensioned fields
- // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- PtrList<DimensionedField<scalar, volMesh>> dimScalarFields;
- readFields(mesh, objects, dimScalarFields);
- PtrList<DimensionedField<vector, volMesh>> dimVectorFields;
- readFields(mesh, objects, dimVectorFields);
- PtrList<DimensionedField<sphericalTensor, volMesh>>
- dimSphericalTensorFields;
- readFields(mesh, objects, dimSphericalTensorFields);
- PtrList<DimensionedField<symmTensor, volMesh>> dimSymmTensorFields;
- readFields(mesh, objects, dimSymmTensorFields);
- PtrList<DimensionedField<tensor, volMesh>> dimTensorFields;
- readFields(mesh, objects, dimTensorFields);
-
-
- // Construct the surface fields
- // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- PtrList<surfaceScalarField> surfaceScalarFields;
- readFields(mesh, objects, surfaceScalarFields);
- PtrList<surfaceVectorField> surfaceVectorFields;
- readFields(mesh, objects, surfaceVectorFields);
- PtrList<surfaceSphericalTensorField> surfaceSphericalTensorFields;
- readFields(mesh, objects, surfaceSphericalTensorFields);
- PtrList<surfaceSymmTensorField> surfaceSymmTensorFields;
- readFields(mesh, objects, surfaceSymmTensorFields);
- PtrList<surfaceTensorField> surfaceTensorFields;
- readFields(mesh, objects, surfaceTensorFields);
-
-
- // Construct the point fields
- // ~~~~~~~~~~~~~~~~~~~~~~~~~~
- const pointMesh& pMesh = pointMesh::New(mesh);
-
- PtrList<pointScalarField> pointScalarFields;
- readFields(pMesh, objects, pointScalarFields);
- PtrList<pointVectorField> pointVectorFields;
- readFields(pMesh, objects, pointVectorFields);
- PtrList<pointSphericalTensorField> pointSphericalTensorFields;
- readFields(pMesh, objects, pointSphericalTensorFields);
- PtrList<pointSymmTensorField> pointSymmTensorFields;
- readFields(pMesh, objects, pointSymmTensorFields);
- PtrList<pointTensorField> pointTensorFields;
- readFields(pMesh, objects, pointTensorFields);
-
-
- // Construct the Lagrangian fields
- // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
- fileNameList cloudDirs
- (
- readDir(runTime.timePath()/cloud::prefix, fileName::DIRECTORY)
- );
-
- // Particles
- PtrList<Cloud<indexedParticle>> lagrangianPositions
- (
- cloudDirs.size()
- );
- // Particles per cell
- PtrList<List<SLList<indexedParticle*>*>> cellParticles
- (
- cloudDirs.size()
- );
-
- PtrList<PtrList<labelIOField>> lagrangianLabelFields
- (
- cloudDirs.size()
- );
- PtrList<PtrList<labelFieldCompactIOField>>
- lagrangianLabelFieldFields
- (
- cloudDirs.size()
- );
- PtrList<PtrList<scalarIOField>> lagrangianScalarFields
- (
- cloudDirs.size()
- );
- PtrList<PtrList<scalarFieldCompactIOField>>
- lagrangianScalarFieldFields
- (
- cloudDirs.size()
- );
- PtrList<PtrList<vectorIOField>> lagrangianVectorFields
- (
- cloudDirs.size()
- );
- PtrList<PtrList<vectorFieldCompactIOField>>
- lagrangianVectorFieldFields
- (
- cloudDirs.size()
- );
- PtrList<PtrList<sphericalTensorIOField>>
- lagrangianSphericalTensorFields
- (
- cloudDirs.size()
- );
- PtrList<PtrList<sphericalTensorFieldCompactIOField>>
- lagrangianSphericalTensorFieldFields(cloudDirs.size());
- PtrList<PtrList<symmTensorIOField>> lagrangianSymmTensorFields
- (
- cloudDirs.size()
- );
- PtrList<PtrList<symmTensorFieldCompactIOField>>
- lagrangianSymmTensorFieldFields
- (
- cloudDirs.size()
- );
- PtrList<PtrList<tensorIOField>> lagrangianTensorFields
- (
- cloudDirs.size()
- );
- PtrList<PtrList<tensorFieldCompactIOField>>
- lagrangianTensorFieldFields
- (
- cloudDirs.size()
- );
-
- label cloudI = 0;
-
- forAll(cloudDirs, i)
+ // Link the 0 directory into each of the processor directories
+ for (label proci = 0; proci < mesh.nProcs(); proci++)
{
- IOobjectList sprayObjs
+ Time processorDb
(
- mesh,
- runTime.timeName(),
- cloud::prefix/cloudDirs[i],
- IOobject::MUST_READ,
- IOobject::NO_WRITE,
- false
+ Time::controlDictName,
+ args.rootPath(),
+ args.caseName()/fileName(word("processor") + name(proci))
);
+ processorDb.setTime(runTime);
- IOobject* positionsPtr = sprayObjs.lookup(word("positions"));
-
- if (positionsPtr)
+ if (isDir(runTime.timePath()))
{
- // Read lagrangian particles
- // ~~~~~~~~~~~~~~~~~~~~~~~~~
-
- Info<< "Identified lagrangian data set: " << cloudDirs[i]
- << endl;
-
- lagrangianPositions.set
- (
- cloudI,
- new Cloud<indexedParticle>
- (
- mesh,
- cloudDirs[i],
- false
- )
- );
-
+ const fileName timePath = processorDb.timePath();
- // Sort particles per cell
- // ~~~~~~~~~~~~~~~~~~~~~~~
-
- cellParticles.set
- (
- cloudI,
- new List<SLList<indexedParticle*>*>
- (
- mesh.nCells(),
- static_cast<SLList<indexedParticle*>*>(nullptr)
- )
- );
+ Info<< "Processor " << proci
+ << ": linking " << runTime.timePath() << nl
+ << " to " << processorDb.timePath() << endl;
+ cp(runTime.timePath(), processorDb.timePath());
+ }
+ }
+ }
+ else
+ {
+ // Decompose the field files
+
+ // 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()
+ );
- label i = 0;
- forAllIter
+ // Loop over all times
+ forAll(times, timeI)
+ {
+ runTime.setTime(times[timeI], timeI);
+
+ Info<< "Time = " << runTime.timeName() << endl;
+
+ // Search for list of objects for this time
+ IOobjectList objects(mesh, runTime.timeName());
+
+
+ // Construct the vol fields
+ // ~~~~~~~~~~~~~~~~~~~~~~~~
+ PtrList<volScalarField> volScalarFields;
+ readFields(mesh, objects, volScalarFields);
+ PtrList<volVectorField> volVectorFields;
+ readFields(mesh, objects, volVectorFields);
+ PtrList<volSphericalTensorField> volSphericalTensorFields;
+ readFields(mesh, objects, volSphericalTensorFields);
+ PtrList<volSymmTensorField> volSymmTensorFields;
+ readFields(mesh, objects, volSymmTensorFields);
+ PtrList<volTensorField> volTensorFields;
+ readFields(mesh, objects, volTensorFields);
+
+
+ // Construct the dimensioned fields
+ // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ PtrList<DimensionedField<scalar, volMesh>> dimScalarFields;
+ readFields(mesh, objects, dimScalarFields);
+ PtrList<DimensionedField<vector, volMesh>> dimVectorFields;
+ readFields(mesh, objects, dimVectorFields);
+ PtrList<DimensionedField<sphericalTensor, volMesh>>
+ dimSphericalTensorFields;
+ readFields(mesh, objects, dimSphericalTensorFields);
+ PtrList<DimensionedField<symmTensor, volMesh>>
+ dimSymmTensorFields;
+ readFields(mesh, objects, dimSymmTensorFields);
+ PtrList<DimensionedField<tensor, volMesh>> dimTensorFields;
+ readFields(mesh, objects, dimTensorFields);
+
+
+ // Construct the surface fields
+ // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ PtrList<surfaceScalarField> surfaceScalarFields;
+ readFields(mesh, objects, surfaceScalarFields);
+ PtrList<surfaceVectorField> surfaceVectorFields;
+ readFields(mesh, objects, surfaceVectorFields);
+ PtrList<surfaceSphericalTensorField>
+ surfaceSphericalTensorFields;
+ readFields(mesh, objects, surfaceSphericalTensorFields);
+ PtrList<surfaceSymmTensorField> surfaceSymmTensorFields;
+ readFields(mesh, objects, surfaceSymmTensorFields);
+ PtrList<surfaceTensorField> surfaceTensorFields;
+ readFields(mesh, objects, surfaceTensorFields);
+
+
+ // Construct the point fields
+ // ~~~~~~~~~~~~~~~~~~~~~~~~~~
+ const pointMesh& pMesh = pointMesh::New(mesh);
+
+ PtrList<pointScalarField> pointScalarFields;
+ readFields(pMesh, objects, pointScalarFields);
+ PtrList<pointVectorField> pointVectorFields;
+ readFields(pMesh, objects, pointVectorFields);
+ PtrList<pointSphericalTensorField> pointSphericalTensorFields;
+ readFields(pMesh, objects, pointSphericalTensorFields);
+ PtrList<pointSymmTensorField> pointSymmTensorFields;
+ readFields(pMesh, objects, pointSymmTensorFields);
+ PtrList<pointTensorField> pointTensorFields;
+ readFields(pMesh, objects, pointTensorFields);
+
+
+ // Construct the Lagrangian fields
+ // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ fileNameList cloudDirs
+ (
+ readDir
(
- Cloud<indexedParticle>,
- lagrangianPositions[cloudI],
- iter
+ runTime.timePath()/cloud::prefix, fileName::DIRECTORY
)
- {
- iter().index() = i++;
-
- label celli = iter().cell();
-
- // Check
- if (celli < 0 || celli >= mesh.nCells())
- {
- FatalErrorInFunction
- << "Illegal cell number " << celli
- << " for particle with index " << iter().index()
- << " at position " << iter().position() << nl
- << "Cell number should be between 0 and "
- << mesh.nCells()-1 << nl
- << "On this mesh the particle should"
- << " be in cell "
- << mesh.findCell(iter().position())
- << exit(FatalError);
- }
+ );
- if (!cellParticles[cloudI][celli])
- {
- cellParticles[cloudI][celli] =
- new SLList<indexedParticle*>();
- }
+ // Particles
+ PtrList<Cloud<indexedParticle>> lagrangianPositions
+ (
+ cloudDirs.size()
+ );
+ // Particles per cell
+ PtrList<List<SLList<indexedParticle*>*>> cellParticles
+ (
+ cloudDirs.size()
+ );
- cellParticles[cloudI][celli]->append(&iter());
- }
+ PtrList<PtrList<labelIOField>> lagrangianLabelFields
+ (
+ cloudDirs.size()
+ );
+ PtrList<PtrList<labelFieldCompactIOField>>
+ lagrangianLabelFieldFields
+ (
+ cloudDirs.size()
+ );
+ PtrList<PtrList<scalarIOField>> lagrangianScalarFields
+ (
+ cloudDirs.size()
+ );
+ PtrList<PtrList<scalarFieldCompactIOField>>
+ lagrangianScalarFieldFields
+ (
+ cloudDirs.size()
+ );
+ PtrList<PtrList<vectorIOField>> lagrangianVectorFields
+ (
+ cloudDirs.size()
+ );
+ PtrList<PtrList<vectorFieldCompactIOField>>
+ lagrangianVectorFieldFields
+ (
+ cloudDirs.size()
+ );
+ PtrList<PtrList<sphericalTensorIOField>>
+ lagrangianSphericalTensorFields
+ (
+ cloudDirs.size()
+ );
+ PtrList<PtrList<sphericalTensorFieldCompactIOField>>
+ lagrangianSphericalTensorFieldFields(cloudDirs.size());
+ PtrList<PtrList<symmTensorIOField>> lagrangianSymmTensorFields
+ (
+ cloudDirs.size()
+ );
+ PtrList<PtrList<symmTensorFieldCompactIOField>>
+ lagrangianSymmTensorFieldFields
+ (
+ cloudDirs.size()
+ );
+ PtrList<PtrList<tensorIOField>> lagrangianTensorFields
+ (
+ cloudDirs.size()
+ );
+ PtrList<PtrList<tensorFieldCompactIOField>>
+ lagrangianTensorFieldFields
+ (
+ cloudDirs.size()
+ );
- // Read fields
- // ~~~~~~~~~~~
+ label cloudI = 0;
- IOobjectList lagrangianObjects
+ forAll(cloudDirs, i)
+ {
+ IOobjectList sprayObjs
(
mesh,
runTime.timeName(),
- cloud::prefix/cloudDirs[cloudI],
+ cloud::prefix/cloudDirs[i],
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
);
- lagrangianFieldDecomposer::readFields
+ IOobject* positionsPtr = sprayObjs.lookup
(
- cloudI,
- lagrangianObjects,
- lagrangianLabelFields
+ word("positions")
);
- lagrangianFieldDecomposer::readFieldFields
- (
- cloudI,
- lagrangianObjects,
- lagrangianLabelFieldFields
- );
+ if (positionsPtr)
+ {
+ // Read lagrangian particles
+ // ~~~~~~~~~~~~~~~~~~~~~~~~~
- lagrangianFieldDecomposer::readFields
- (
- cloudI,
- lagrangianObjects,
- lagrangianScalarFields
- );
+ Info<< "Identified lagrangian data set: "
+ << cloudDirs[i] << endl;
- lagrangianFieldDecomposer::readFieldFields
- (
- cloudI,
- lagrangianObjects,
- lagrangianScalarFieldFields
- );
+ lagrangianPositions.set
+ (
+ cloudI,
+ new Cloud<indexedParticle>
+ (
+ mesh,
+ cloudDirs[i],
+ false
+ )
+ );
- lagrangianFieldDecomposer::readFields
- (
- cloudI,
- lagrangianObjects,
- lagrangianVectorFields
- );
- lagrangianFieldDecomposer::readFieldFields
- (
- cloudI,
- lagrangianObjects,
- lagrangianVectorFieldFields
- );
+ // Sort particles per cell
+ // ~~~~~~~~~~~~~~~~~~~~~~~
- lagrangianFieldDecomposer::readFields
- (
- cloudI,
- lagrangianObjects,
- lagrangianSphericalTensorFields
- );
+ cellParticles.set
+ (
+ cloudI,
+ new List<SLList<indexedParticle*>*>
+ (
+ mesh.nCells(),
+ static_cast<SLList<indexedParticle*>*>(nullptr)
+ )
+ );
- lagrangianFieldDecomposer::readFieldFields
- (
- cloudI,
- lagrangianObjects,
- lagrangianSphericalTensorFieldFields
- );
+ label i = 0;
- lagrangianFieldDecomposer::readFields
- (
- cloudI,
- lagrangianObjects,
- lagrangianSymmTensorFields
- );
+ forAllIter
+ (
+ Cloud<indexedParticle>,
+ lagrangianPositions[cloudI],
+ iter
+ )
+ {
+ iter().index() = i++;
+
+ label celli = iter().cell();
+
+ // Check
+ if (celli < 0 || celli >= mesh.nCells())
+ {
+ FatalErrorInFunction
+ << "Illegal cell number " << celli
+ << " for particle with index "
+ << iter().index()
+ << " at position "
+ << iter().position() << nl
+ << "Cell number should be between 0 and "
+ << mesh.nCells()-1 << nl
+ << "On this mesh the particle should"
+ << " be in cell "
+ << mesh.findCell(iter().position())
+ << exit(FatalError);
+ }
+
+ if (!cellParticles[cloudI][celli])
+ {
+ cellParticles[cloudI][celli] =
+ new SLList<indexedParticle*>();
+ }
+
+ cellParticles[cloudI][celli]->append(&iter());
+ }
- lagrangianFieldDecomposer::readFieldFields
- (
- cloudI,
- lagrangianObjects,
- lagrangianSymmTensorFieldFields
- );
+ // Read fields
+ // ~~~~~~~~~~~
- lagrangianFieldDecomposer::readFields
- (
- cloudI,
- lagrangianObjects,
- lagrangianTensorFields
- );
+ IOobjectList lagrangianObjects
+ (
+ mesh,
+ runTime.timeName(),
+ cloud::prefix/cloudDirs[cloudI],
+ IOobject::MUST_READ,
+ IOobject::NO_WRITE,
+ false
+ );
- lagrangianFieldDecomposer::readFieldFields
- (
- cloudI,
- lagrangianObjects,
- lagrangianTensorFieldFields
- );
+ lagrangianFieldDecomposer::readFields
+ (
+ cloudI,
+ lagrangianObjects,
+ lagrangianLabelFields
+ );
- cloudI++;
- }
- }
+ lagrangianFieldDecomposer::readFieldFields
+ (
+ cloudI,
+ lagrangianObjects,
+ lagrangianLabelFieldFields
+ );
- lagrangianPositions.setSize(cloudI);
- cellParticles.setSize(cloudI);
- lagrangianLabelFields.setSize(cloudI);
- lagrangianLabelFieldFields.setSize(cloudI);
- lagrangianScalarFields.setSize(cloudI);
- lagrangianScalarFieldFields.setSize(cloudI);
- lagrangianVectorFields.setSize(cloudI);
- lagrangianVectorFieldFields.setSize(cloudI);
- lagrangianSphericalTensorFields.setSize(cloudI);
- lagrangianSphericalTensorFieldFields.setSize(cloudI);
- lagrangianSymmTensorFields.setSize(cloudI);
- lagrangianSymmTensorFieldFields.setSize(cloudI);
- lagrangianTensorFields.setSize(cloudI);
- lagrangianTensorFieldFields.setSize(cloudI);
-
- Info<< endl;
-
- // split the fields over processors
- for (label proci = 0; proci < mesh.nProcs(); proci++)
- {
- Info<< "Processor " << proci << ": field transfer" << endl;
+ lagrangianFieldDecomposer::readFields
+ (
+ cloudI,
+ lagrangianObjects,
+ lagrangianScalarFields
+ );
+ lagrangianFieldDecomposer::readFieldFields
+ (
+ cloudI,
+ lagrangianObjects,
+ lagrangianScalarFieldFields
+ );
- // open the database
- if (!processorDbList.set(proci))
- {
- processorDbList.set
- (
- proci,
- new Time
+ lagrangianFieldDecomposer::readFields
(
- Time::controlDictName,
- args.rootPath(),
- args.caseName()
- /fileName(word("processor") + name(proci))
- )
- );
- }
- Time& processorDb = processorDbList[proci];
+ cloudI,
+ lagrangianObjects,
+ lagrangianVectorFields
+ );
+ lagrangianFieldDecomposer::readFieldFields
+ (
+ cloudI,
+ lagrangianObjects,
+ lagrangianVectorFieldFields
+ );
- processorDb.setTime(runTime);
+ lagrangianFieldDecomposer::readFields
+ (
+ cloudI,
+ lagrangianObjects,
+ lagrangianSphericalTensorFields
+ );
- // read the mesh
- if (!procMeshList.set(proci))
- {
- procMeshList.set
- (
- proci,
- new fvMesh
+ lagrangianFieldDecomposer::readFieldFields
(
- IOobject
- (
- regionName,
- processorDb.timeName(),
- processorDb
- )
- )
- );
- }
- const fvMesh& procMesh = procMeshList[proci];
+ cloudI,
+ lagrangianObjects,
+ lagrangianSphericalTensorFieldFields
+ );
- const labelIOList& faceProcAddressing = procAddressing
- (
- procMeshList,
- proci,
- "faceProcAddressing",
- faceProcAddressingList
- );
+ lagrangianFieldDecomposer::readFields
+ (
+ cloudI,
+ lagrangianObjects,
+ lagrangianSymmTensorFields
+ );
- const labelIOList& cellProcAddressing = procAddressing
- (
- procMeshList,
- proci,
- "cellProcAddressing",
- cellProcAddressingList
- );
+ lagrangianFieldDecomposer::readFieldFields
+ (
+ cloudI,
+ lagrangianObjects,
+ lagrangianSymmTensorFieldFields
+ );
- const labelIOList& boundaryProcAddressing = procAddressing
- (
- procMeshList,
- proci,
- "boundaryProcAddressing",
- boundaryProcAddressingList
- );
+ lagrangianFieldDecomposer::readFields
+ (
+ cloudI,
+ lagrangianObjects,
+ lagrangianTensorFields
+ );
+ lagrangianFieldDecomposer::readFieldFields
+ (
+ cloudI,
+ lagrangianObjects,
+ lagrangianTensorFieldFields
+ );
+
+ cloudI++;
+ }
+ }
- // FV fields
+ lagrangianPositions.setSize(cloudI);
+ cellParticles.setSize(cloudI);
+ lagrangianLabelFields.setSize(cloudI);
+ lagrangianLabelFieldFields.setSize(cloudI);
+ lagrangianScalarFields.setSize(cloudI);
+ lagrangianScalarFieldFields.setSize(cloudI);
+ lagrangianVectorFields.setSize(cloudI);
+ lagrangianVectorFieldFields.setSize(cloudI);
+ lagrangianSphericalTensorFields.setSize(cloudI);
+ lagrangianSphericalTensorFieldFields.setSize(cloudI);
+ lagrangianSymmTensorFields.setSize(cloudI);
+ lagrangianSymmTensorFieldFields.setSize(cloudI);
+ lagrangianTensorFields.setSize(cloudI);
+ lagrangianTensorFieldFields.setSize(cloudI);
+
+ Info<< endl;
+
+ // split the fields over processors
+ for (label proci = 0; proci < mesh.nProcs(); proci++)
{
- if (!fieldDecomposerList.set(proci))
+ Info<< "Processor " << proci << ": field transfer" << endl;
+
+
+ // open the database
+ if (!processorDbList.set(proci))
{
- fieldDecomposerList.set
+ processorDbList.set
(
proci,
- new fvFieldDecomposer
+ new Time
(
- mesh,
- procMesh,
- faceProcAddressing,
- cellProcAddressing,
- boundaryProcAddressing
+ Time::controlDictName,
+ args.rootPath(),
+ args.caseName()
+ /fileName(word("processor") + name(proci))
)
);
}
- const fvFieldDecomposer& fieldDecomposer =
- fieldDecomposerList[proci];
-
- fieldDecomposer.decomposeFields(volScalarFields);
- fieldDecomposer.decomposeFields(volVectorFields);
- fieldDecomposer.decomposeFields(volSphericalTensorFields);
- fieldDecomposer.decomposeFields(volSymmTensorFields);
- fieldDecomposer.decomposeFields(volTensorFields);
-
- fieldDecomposer.decomposeFields(surfaceScalarFields);
- fieldDecomposer.decomposeFields(surfaceVectorFields);
- fieldDecomposer.decomposeFields
- (
- surfaceSphericalTensorFields
- );
- fieldDecomposer.decomposeFields(surfaceSymmTensorFields);
- fieldDecomposer.decomposeFields(surfaceTensorFields);
+ Time& processorDb = processorDbList[proci];
- if (times.size() == 1)
- {
- // Clear cached decomposer
- fieldDecomposerList.set(proci, nullptr);
- }
- }
- // Dimensioned fields
- {
- if (!dimFieldDecomposerList.set(proci))
+ processorDb.setTime(runTime);
+
+ // read the mesh
+ if (!procMeshList.set(proci))
{
- dimFieldDecomposerList.set
+ procMeshList.set
(
proci,
- new dimFieldDecomposer
+ new fvMesh
(
- mesh,
- procMesh,
- faceProcAddressing,
- cellProcAddressing
+ IOobject
+ (
+ regionName,
+ processorDb.timeName(),
+ processorDb
+ )
)
);
}
- const dimFieldDecomposer& dimDecomposer =
- dimFieldDecomposerList[proci];
+ const fvMesh& procMesh = procMeshList[proci];
- dimDecomposer.decomposeFields(dimScalarFields);
- dimDecomposer.decomposeFields(dimVectorFields);
- dimDecomposer.decomposeFields(dimSphericalTensorFields);
- dimDecomposer.decomposeFields(dimSymmTensorFields);
- dimDecomposer.decomposeFields(dimTensorFields);
-
- if (times.size() == 1)
- {
- dimFieldDecomposerList.set(proci, nullptr);
- }
- }
+ const labelIOList& faceProcAddressing = procAddressing
+ (
+ procMeshList,
+ proci,
+ "faceProcAddressing",
+ faceProcAddressingList
+ );
+ const labelIOList& cellProcAddressing = procAddressing
+ (
+ procMeshList,
+ proci,
+ "cellProcAddressing",
+ cellProcAddressingList
+ );
- // Point fields
- if
- (
- pointScalarFields.size()
- || pointVectorFields.size()
- || pointSphericalTensorFields.size()
- || pointSymmTensorFields.size()
- || pointTensorFields.size()
- )
- {
- const labelIOList& pointProcAddressing = procAddressing
+ const labelIOList& boundaryProcAddressing = procAddressing
(
procMeshList,
proci,
- "pointProcAddressing",
- pointProcAddressingList
+ "boundaryProcAddressing",
+ boundaryProcAddressingList
);
- const pointMesh& procPMesh = pointMesh::New(procMesh);
- if (!pointFieldDecomposerList.set(proci))
+ // FV fields
{
- pointFieldDecomposerList.set
- (
- proci,
- new pointFieldDecomposer
+ if (!fieldDecomposerList.set(proci))
+ {
+ fieldDecomposerList.set
(
- pMesh,
- procPMesh,
- pointProcAddressing,
- boundaryProcAddressing
- )
+ proci,
+ new fvFieldDecomposer
+ (
+ mesh,
+ procMesh,
+ faceProcAddressing,
+ cellProcAddressing,
+ boundaryProcAddressing
+ )
+ );
+ }
+ const fvFieldDecomposer& fieldDecomposer =
+ fieldDecomposerList[proci];
+
+ fieldDecomposer.decomposeFields(volScalarFields);
+ fieldDecomposer.decomposeFields(volVectorFields);
+ fieldDecomposer.decomposeFields
+ (
+ volSphericalTensorFields
);
- }
- const pointFieldDecomposer& pointDecomposer =
- pointFieldDecomposerList[proci];
+ fieldDecomposer.decomposeFields(volSymmTensorFields);
+ fieldDecomposer.decomposeFields(volTensorFields);
- pointDecomposer.decomposeFields(pointScalarFields);
- pointDecomposer.decomposeFields(pointVectorFields);
- pointDecomposer.decomposeFields(pointSphericalTensorFields);
- pointDecomposer.decomposeFields(pointSymmTensorFields);
- pointDecomposer.decomposeFields(pointTensorFields);
+ fieldDecomposer.decomposeFields(surfaceScalarFields);
+ fieldDecomposer.decomposeFields(surfaceVectorFields);
+ fieldDecomposer.decomposeFields
+ (
+ surfaceSphericalTensorFields
+ );
+ fieldDecomposer.decomposeFields
+ (
+ surfaceSymmTensorFields
+ );
+ fieldDecomposer.decomposeFields(surfaceTensorFields);
+ if (times.size() == 1)
+ {
+ // Clear cached decomposer
+ fieldDecomposerList.set(proci, nullptr);
+ }
+ }
- if (times.size() == 1)
+ // Dimensioned fields
{
- pointProcAddressingList.set(proci, nullptr);
- pointFieldDecomposerList.set(proci, nullptr);
+ if (!dimFieldDecomposerList.set(proci))
+ {
+ dimFieldDecomposerList.set
+ (
+ proci,
+ new dimFieldDecomposer
+ (
+ mesh,
+ procMesh,
+ faceProcAddressing,
+ cellProcAddressing
+ )
+ );
+ }
+ const dimFieldDecomposer& dimDecomposer =
+ dimFieldDecomposerList[proci];
+
+ dimDecomposer.decomposeFields(dimScalarFields);
+ dimDecomposer.decomposeFields(dimVectorFields);
+ dimDecomposer.decomposeFields(dimSphericalTensorFields);
+ dimDecomposer.decomposeFields(dimSymmTensorFields);
+ dimDecomposer.decomposeFields(dimTensorFields);
+
+ if (times.size() == 1)
+ {
+ dimFieldDecomposerList.set(proci, nullptr);
+ }
}
- }
- // If there is lagrangian data write it out
- forAll(lagrangianPositions, cloudI)
- {
- if (lagrangianPositions[cloudI].size())
+ // Point fields
+ if
+ (
+ pointScalarFields.size()
+ || pointVectorFields.size()
+ || pointSphericalTensorFields.size()
+ || pointSymmTensorFields.size()
+ || pointTensorFields.size()
+ )
{
- lagrangianFieldDecomposer fieldDecomposer
+ const labelIOList& pointProcAddressing = procAddressing
(
- mesh,
- procMesh,
- faceProcAddressing,
- cellProcAddressing,
- cloudDirs[cloudI],
- lagrangianPositions[cloudI],
- cellParticles[cloudI]
+ procMeshList,
+ proci,
+ "pointProcAddressing",
+ pointProcAddressingList
);
- // Lagrangian fields
+ const pointMesh& procPMesh = pointMesh::New(procMesh);
+
+ if (!pointFieldDecomposerList.set(proci))
{
- fieldDecomposer.decomposeFields
- (
- cloudDirs[cloudI],
- lagrangianLabelFields[cloudI]
- );
- fieldDecomposer.decomposeFieldFields
- (
- cloudDirs[cloudI],
- lagrangianLabelFieldFields[cloudI]
- );
- fieldDecomposer.decomposeFields
- (
- cloudDirs[cloudI],
- lagrangianScalarFields[cloudI]
- );
- fieldDecomposer.decomposeFieldFields
- (
- cloudDirs[cloudI],
- lagrangianScalarFieldFields[cloudI]
- );
- fieldDecomposer.decomposeFields
- (
- cloudDirs[cloudI],
- lagrangianVectorFields[cloudI]
- );
- fieldDecomposer.decomposeFieldFields
- (
- cloudDirs[cloudI],
- lagrangianVectorFieldFields[cloudI]
- );
- fieldDecomposer.decomposeFields
+ pointFieldDecomposerList.set
(
- cloudDirs[cloudI],
- lagrangianSphericalTensorFields[cloudI]
- );
- fieldDecomposer.decomposeFieldFields
- (
- cloudDirs[cloudI],
- lagrangianSphericalTensorFieldFields[cloudI]
- );
- fieldDecomposer.decomposeFields
- (
- cloudDirs[cloudI],
- lagrangianSymmTensorFields[cloudI]
- );
- fieldDecomposer.decomposeFieldFields
- (
- cloudDirs[cloudI],
- lagrangianSymmTensorFieldFields[cloudI]
+ proci,
+ new pointFieldDecomposer
+ (
+ pMesh,
+ procPMesh,
+ pointProcAddressing,
+ boundaryProcAddressing
+ )
);
- fieldDecomposer.decomposeFields
- (
- cloudDirs[cloudI],
- lagrangianTensorFields[cloudI]
- );
- fieldDecomposer.decomposeFieldFields
+ }
+ const pointFieldDecomposer& pointDecomposer =
+ pointFieldDecomposerList[proci];
+
+ pointDecomposer.decomposeFields(pointScalarFields);
+ pointDecomposer.decomposeFields(pointVectorFields);
+ pointDecomposer.decomposeFields
+ (
+ pointSphericalTensorFields
+ );
+ pointDecomposer.decomposeFields(pointSymmTensorFields);
+ pointDecomposer.decomposeFields(pointTensorFields);
+
+
+ if (times.size() == 1)
+ {
+ pointProcAddressingList.set(proci, nullptr);
+ pointFieldDecomposerList.set(proci, nullptr);
+ }
+ }
+
+
+ // If there is lagrangian data write it out
+ forAll(lagrangianPositions, cloudI)
+ {
+ if (lagrangianPositions[cloudI].size())
+ {
+ lagrangianFieldDecomposer fieldDecomposer
(
+ mesh,
+ procMesh,
+ faceProcAddressing,
+ cellProcAddressing,
cloudDirs[cloudI],
- lagrangianTensorFieldFields[cloudI]
+ lagrangianPositions[cloudI],
+ cellParticles[cloudI]
);
+
+ // Lagrangian fields
+ {
+ fieldDecomposer.decomposeFields
+ (
+ cloudDirs[cloudI],
+ lagrangianLabelFields[cloudI]
+ );
+ fieldDecomposer.decomposeFieldFields
+ (
+ cloudDirs[cloudI],
+ lagrangianLabelFieldFields[cloudI]
+ );
+ fieldDecomposer.decomposeFields
+ (
+ cloudDirs[cloudI],
+ lagrangianScalarFields[cloudI]
+ );
+ fieldDecomposer.decomposeFieldFields
+ (
+ cloudDirs[cloudI],
+ lagrangianScalarFieldFields[cloudI]
+ );
+ fieldDecomposer.decomposeFields
+ (
+ cloudDirs[cloudI],
+ lagrangianVectorFields[cloudI]
+ );
+ fieldDecomposer.decomposeFieldFields
+ (
+ cloudDirs[cloudI],
+ lagrangianVectorFieldFields[cloudI]
+ );
+ fieldDecomposer.decomposeFields
+ (
+ cloudDirs[cloudI],
+ lagrangianSphericalTensorFields[cloudI]
+ );
+ fieldDecomposer.decomposeFieldFields
+ (
+ cloudDirs[cloudI],
+ lagrangianSphericalTensorFieldFields[cloudI]
+ );
+ fieldDecomposer.decomposeFields
+ (
+ cloudDirs[cloudI],
+ lagrangianSymmTensorFields[cloudI]
+ );
+ fieldDecomposer.decomposeFieldFields
+ (
+ cloudDirs[cloudI],
+ lagrangianSymmTensorFieldFields[cloudI]
+ );
+ fieldDecomposer.decomposeFields
+ (
+ cloudDirs[cloudI],
+ lagrangianTensorFields[cloudI]
+ );
+ fieldDecomposer.decomposeFieldFields
+ (
+ cloudDirs[cloudI],
+ lagrangianTensorFieldFields[cloudI]
+ );
+ }
}
}
- }
- // Decompose the "uniform" directory in the time region
- // directory
- decomposeUniform(copyUniform, mesh, processorDb, regionDir);
+ // Decompose the "uniform" directory in the time region
+ // directory
+ decomposeUniform(copyUniform, mesh, processorDb, regionDir);
- // For the first region of a multi-region case additionally
- // decompose the "uniform" directory in the time directory
- if (regionNames.size() > 1 && regioni == 0)
- {
- decomposeUniform(copyUniform, mesh, processorDb);
- }
+ // For the first region of a multi-region case additionally
+ // decompose the "uniform" directory in the time directory
+ if (regionNames.size() > 1 && regioni == 0)
+ {
+ decomposeUniform(copyUniform, mesh, processorDb);
+ }
- // 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, nullptr);
- cellProcAddressingList.set(proci, nullptr);
- faceProcAddressingList.set(proci, nullptr);
- procMeshList.set(proci, nullptr);
- processorDbList.set(proci, nullptr);
+ // 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, nullptr);
+ cellProcAddressingList.set(proci, nullptr);
+ faceProcAddressingList.set(proci, nullptr);
+ procMeshList.set(proci, nullptr);
+ processorDbList.set(proci, nullptr);
+ }
}
}
}
diff --git a/src/OpenFOAM/db/Time/timeSelector.C b/src/OpenFOAM/db/Time/timeSelector.C
index ecffc55dc9839f7b5d3e32416c9b593d7d833dc8..7e47c12a9a8f291308da1856f2d3f9cd5beac7fa 100644
--- a/src/OpenFOAM/db/Time/timeSelector.C
+++ b/src/OpenFOAM/db/Time/timeSelector.C
@@ -135,8 +135,12 @@ void Foam::timeSelector::addOptions
argList::addBoolOption
(
"noZero",
- "exclude the '0/' dir from the times list, "
- "has precedence over the -withZero option"
+ string("exclude the '0/' dir from the times list")
+ + (
+ withZero
+ ? ", has precedence over the -withZero option"
+ : ""
+ )
);
argList::addBoolOption
(
diff --git a/tutorials/incompressible/simpleFoam/motorBike/Allclean b/tutorials/incompressible/simpleFoam/motorBike/Allclean
index 68a1d17d7b95d4325ac62967c787eb8a3e01709c..93a0975c85c7684f496b951d261c5952d3e58881 100755
--- a/tutorials/incompressible/simpleFoam/motorBike/Allclean
+++ b/tutorials/incompressible/simpleFoam/motorBike/Allclean
@@ -1,9 +1,10 @@
#!/bin/sh
+cd ${0%/*} || exit 1 # Run from this directory
# Source tutorial clean functions
. $WM_PROJECT_DIR/bin/tools/CleanFunctions
-# remove surface and features
+# Remove surface and features
rm -f constant/triSurface/motorBike.obj.gz > /dev/null 2>&1
rm -rf constant/extendedFeatureEdgeMesh > /dev/null 2>&1
rm -f constant/triSurface/motorBike.eMesh > /dev/null 2>&1
@@ -11,3 +12,5 @@ rm -f constant/triSurface/motorBike.eMesh > /dev/null 2>&1
rm -rf 0 > /dev/null 2>&1
cleanCase
+
+#------------------------------------------------------------------------------
diff --git a/tutorials/incompressible/simpleFoam/motorBike/Allrun b/tutorials/incompressible/simpleFoam/motorBike/Allrun
index 32e10a4eee61cd89b26616142eb13e4088c4c730..07069da13588b1272cc50ca8b31e70d1dfd719b6 100755
--- a/tutorials/incompressible/simpleFoam/motorBike/Allrun
+++ b/tutorials/incompressible/simpleFoam/motorBike/Allrun
@@ -4,21 +4,16 @@ cd ${0%/*} || exit 1 # Run from this directory
# Source tutorial run functions
. $WM_PROJECT_DIR/bin/tools/RunFunctions
-# copy motorbike surface from resources directory
+# Copy motorbike surface from resources directory
cp $FOAM_TUTORIALS/resources/geometry/motorBike.obj.gz constant/triSurface/
runApplication surfaceFeatureExtract
runApplication blockMesh
-runApplication decomposePar
-runParallel snappyHexMesh -overwrite
-
-#- For non-parallel running
-#cp -r 0.orig 0 > /dev/null 2>&1
+[ ! -d 0 ] && cp -r 0.orig 0
-#- For parallel running
-ls -d processor* | xargs -I {} rm -rf ./{}/0
-ls -d processor* | xargs -I {} cp -r 0.orig ./{}/0
+runApplication decomposePar -copyZero
+runParallel snappyHexMesh -overwrite
runParallel patchSummary
runParallel potentialFoam