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,reconsturctPar: added -allRegions option

Browse Source
This commit is contained in:
mattijs
2012-09-26 12:08:43 +01:00
parent e29c0b1266
commit da17674f0f
9 changed files with 1399 additions and 1287 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
applications/utilities/parallelProcessing/decomposePar/Make/options
View File

@ -3,7 +3,8 @@ EXE_INC = \
-I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \ -I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \ -I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/lagrangian/basic/lnInclude \ -I$(LIB_SRC)/lagrangian/basic/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude -I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/regionModels/regionModel/lnInclude
EXE_LIBS = \ EXE_LIBS = \
-lfiniteVolume \ -lfiniteVolume \
@ -11,4 +12,5 @@ EXE_LIBS = \
-lgenericPatchFields \ -lgenericPatchFields \
-ldecompositionMethods -L$(FOAM_LIBBIN)/dummy -lmetisDecomp -lscotchDecomp \ -ldecompositionMethods -L$(FOAM_LIBBIN)/dummy -lmetisDecomp -lscotchDecomp \
-llagrangian \ -llagrangian \
-lmeshTools -lmeshTools \
-lregionModels

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

File diff suppressed because it is too large Load Diff

6
applications/utilities/parallelProcessing/reconstructPar/Make/options
View File

@ -1,11 +1,13 @@
EXE_INC = \ EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \ -I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/lagrangian/basic/lnInclude \ -I$(LIB_SRC)/lagrangian/basic/lnInclude \
-I$(LIB_SRC)/parallel/reconstruct/reconstruct/lnInclude -I$(LIB_SRC)/parallel/reconstruct/reconstruct/lnInclude \
-I$(LIB_SRC)/regionModels/regionModel/lnInclude
EXE_LIBS = \ EXE_LIBS = \
-lfiniteVolume \ -lfiniteVolume \
-lgenericPatchFields \ -lgenericPatchFields \
-llagrangian \ -llagrangian \
-lmeshTools \ -lmeshTools \
-lreconstruct -lreconstruct \
-lregionModels

819
applications/utilities/parallelProcessing/reconstructPar/reconstructPar.C
View File

@ -25,7 +25,7 @@ Application
reconstructPar reconstructPar
Description Description
Reconstructs a mesh and fields of a case that is decomposed for parallel Reconstructs fields of a case that is decomposed for parallel
execution of OpenFOAM. execution of OpenFOAM.
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
@ -36,6 +36,7 @@ Description
#include "fvCFD.H" #include "fvCFD.H"
#include "IOobjectList.H" #include "IOobjectList.H"
#include "processorMeshes.H" #include "processorMeshes.H"
#include "regionProperties.H"
#include "fvFieldReconstructor.H" #include "fvFieldReconstructor.H"
#include "pointFieldReconstructor.H" #include "pointFieldReconstructor.H"
#include "reconstructLagrangian.H" #include "reconstructLagrangian.H"
@ -44,11 +45,21 @@ Description
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
argList::addNote
(
"Reconstruct fields of a parallel case"
);
// enable -constant ... if someone really wants it // enable -constant ... if someone really wants it
// enable -zeroTime to prevent accidentally trashing the initial fields // enable -zeroTime to prevent accidentally trashing the initial fields
timeSelector::addOptions(true, true); timeSelector::addOptions(true, true);
argList::noParallel(); argList::noParallel();
# include "addRegionOption.H" # include "addRegionOption.H"
argList::addBoolOption
(
"allRegions",
"operate on all regions in regionProperties"
);
argList::addOption argList::addOption
( (
"fields", "fields",
@ -101,7 +112,8 @@ int main(int argc, char *argv[])
} }
const bool newTimes = args.optionFound("newTimes"); const bool newTimes = args.optionFound("newTimes");
const bool allRegions = args.optionFound("allRegions");
// determine the processor count directly // determine the processor count directly
@ -159,414 +171,487 @@ int main(int argc, char *argv[])
} }
# include "createNamedMesh.H"
word regionDir = word::null;
if (regionName != fvMesh::defaultRegion)
{
regionDir = regionName;
}
// Set all times on processor meshes equal to reconstructed mesh // Set all times on processor meshes equal to reconstructed mesh
forAll(databases, procI) forAll(databases, procI)
{ {
databases[procI].setTime(runTime.timeName(), runTime.timeIndex()); databases[procI].setTime(runTime.timeName(), runTime.timeIndex());
} }
// Read all meshes and addressing to reconstructed mesh
processorMeshes procMeshes(databases, regionName);
wordList regionNames;
// check face addressing for meshes that have been decomposed wordList regionDirs;
// with a very old foam version if (allRegions)
# include "checkFaceAddressingComp.H"
// Loop over all times
forAll(timeDirs, timeI)
{ {
if (newTimes) Info<< "Reconstructing for all regions in regionProperties" << nl
<< endl;
regionProperties rp(runTime);
forAllConstIter(HashTable<wordList>, rp, iter)
{ {
// Compare on timeName, not value const wordList& regions = iter();
bool foundTime = false; forAll(regions, i)
forAll(masterTimeDirs, i)
{ {
if (masterTimeDirs[i].name() == timeDirs[timeI].name()) if (findIndex(regionNames, regions[i]) == -1)
{ {
foundTime = true; regionNames.append(regions[i]);
break;
} }
} }
if (foundTime) }
regionDirs = regionNames;
}
else
{
word regionName;
if (args.optionReadIfPresent("region", regionName))
{
regionNames = wordList(1, regionName);
regionDirs = regionNames;
}
else
{
regionNames = wordList(1, fvMesh::defaultRegion);
regionDirs = wordList(1, word::null);
}
}
forAll(regionNames, regionI)
{
const word& regionName = regionNames[regionI];
const word& regionDir = regionDirs[regionI];
Info<< "\n\nReconstructing fields for mesh " << regionName << nl
<< endl;
fvMesh mesh
(
IOobject
(
regionName,
runTime.timeName(),
runTime,
Foam::IOobject::MUST_READ
)
);
// Read all meshes and addressing to reconstructed mesh
processorMeshes procMeshes(databases, regionName);
// check face addressing for meshes that have been decomposed
// with a very old foam version
# include "checkFaceAddressingComp.H"
// Loop over all times
forAll(timeDirs, timeI)
{
if (newTimes)
{ {
Info<< "Skipping time " << timeDirs[timeI].name() // Compare on timeName, not value
<< endl << endl; bool foundTime = false;
continue; forAll(masterTimeDirs, i)
} {
} if (masterTimeDirs[i].name() == timeDirs[timeI].name())
{
foundTime = true;
// Set time for global database break;
runTime.setTime(timeDirs[timeI], timeI); }
}
Info<< "Time = " << runTime.timeName() << endl << endl; if (foundTime)
{
// Set time for all databases Info<< "Skipping time " << timeDirs[timeI].name()
forAll(databases, procI) << endl << endl;
{ continue;
databases[procI].setTime(timeDirs[timeI], timeI); }
}
// Check if any new meshes need to be read.
fvMesh::readUpdateState meshStat = mesh.readUpdate();
fvMesh::readUpdateState procStat = procMeshes.readUpdate();
if (procStat == fvMesh::POINTS_MOVED)
{
// Reconstruct the points for moving mesh cases and write them out
procMeshes.reconstructPoints(mesh);
}
else if (meshStat != procStat)
{
WarningIn(args.executable())
<< "readUpdate for the reconstructed mesh:" << meshStat << nl
<< "readUpdate for the processor meshes :" << procStat << nl
<< "These should be equal or your addressing"
<< " might be incorrect."
<< " Please check your time directories for any "
<< "mesh directories." << endl;
}
// Get list of objects from processor0 database
IOobjectList objects(procMeshes.meshes()[0], databases[0].timeName());
{
// If there are any FV fields, reconstruct them
Info<< "Reconstructing FV fields" << nl << endl;
fvFieldReconstructor fvReconstructor
(
mesh,
procMeshes.meshes(),
procMeshes.faceProcAddressing(),
procMeshes.cellProcAddressing(),
procMeshes.boundaryProcAddressing()
);
fvReconstructor.reconstructFvVolumeInternalFields<scalar>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeInternalFields<vector>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeInternalFields<sphericalTensor>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeInternalFields<symmTensor>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeInternalFields<tensor>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeFields<scalar>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeFields<vector>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeFields<sphericalTensor>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeFields<symmTensor>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeFields<tensor>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvSurfaceFields<scalar>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvSurfaceFields<vector>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvSurfaceFields<sphericalTensor>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvSurfaceFields<symmTensor>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvSurfaceFields<tensor>
(
objects,
selectedFields
);
if (fvReconstructor.nReconstructed() == 0)
{
Info<< "No FV fields" << nl << endl;
}
}
{
Info<< "Reconstructing point fields" << nl << endl;
const pointMesh& pMesh = pointMesh::New(mesh);
PtrList<pointMesh> pMeshes(procMeshes.meshes().size());
forAll(pMeshes, procI)
{
pMeshes.set(procI, new pointMesh(procMeshes.meshes()[procI]));
} }
pointFieldReconstructor pointReconstructor
(
pMesh,
pMeshes,
procMeshes.pointProcAddressing(),
procMeshes.boundaryProcAddressing()
);
pointReconstructor.reconstructFields<scalar> // Set time for global database
( runTime.setTime(timeDirs[timeI], timeI);
objects,
selectedFields
);
pointReconstructor.reconstructFields<vector>
(
objects,
selectedFields
);
pointReconstructor.reconstructFields<sphericalTensor>
(
objects,
selectedFields
);
pointReconstructor.reconstructFields<symmTensor>
(
objects,
selectedFields
);
pointReconstructor.reconstructFields<tensor>
(
objects,
selectedFields
);
if (pointReconstructor.nReconstructed() == 0) Info<< "Time = " << runTime.timeName() << endl << endl;
{
Info<< "No point fields" << nl << endl;
}
}
// If there are any clouds, reconstruct them.
// The problem is that a cloud of size zero will not get written so
// in pass 1 we determine the cloud names and per cloud name the
// fields. Note that the fields are stored as IOobjectList from
// the first processor that has them. They are in pass2 only used
// for name and type (scalar, vector etc).
if (!noLagrangian)
{
HashTable<IOobjectList> cloudObjects;
// Set time for all databases
forAll(databases, procI) forAll(databases, procI)
{ {
fileNameList cloudDirs databases[procI].setTime(timeDirs[timeI], timeI);
}
// Check if any new meshes need to be read.
fvMesh::readUpdateState meshStat = mesh.readUpdate();
fvMesh::readUpdateState procStat = procMeshes.readUpdate();
if (procStat == fvMesh::POINTS_MOVED)
{
// Reconstruct the points for moving mesh cases and write
// them out
procMeshes.reconstructPoints(mesh);
}
else if (meshStat != procStat)
{
WarningIn(args.executable())
<< "readUpdate for the reconstructed mesh:"
<< meshStat << nl
<< "readUpdate for the processor meshes :"
<< procStat << nl
<< "These should be equal or your addressing"
<< " might be incorrect."
<< " Please check your time directories for any "
<< "mesh directories." << endl;
}
// Get list of objects from processor0 database
IOobjectList objects
(
procMeshes.meshes()[0],
databases[0].timeName()
);
{
// If there are any FV fields, reconstruct them
Info<< "Reconstructing FV fields" << nl << endl;
fvFieldReconstructor fvReconstructor
( (
readDir mesh,
( procMeshes.meshes(),
databases[procI].timePath() / regionDir / cloud::prefix, procMeshes.faceProcAddressing(),
fileName::DIRECTORY procMeshes.cellProcAddressing(),
) procMeshes.boundaryProcAddressing()
); );
forAll(cloudDirs, i) fvReconstructor.reconstructFvVolumeInternalFields<scalar>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeInternalFields<vector>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeInternalFields
<sphericalTensor>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeInternalFields<symmTensor>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeInternalFields<tensor>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeFields<scalar>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeFields<vector>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeFields<sphericalTensor>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeFields<symmTensor>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvVolumeFields<tensor>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvSurfaceFields<scalar>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvSurfaceFields<vector>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvSurfaceFields<sphericalTensor>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvSurfaceFields<symmTensor>
(
objects,
selectedFields
);
fvReconstructor.reconstructFvSurfaceFields<tensor>
(
objects,
selectedFields
);
if (fvReconstructor.nReconstructed() == 0)
{ {
// Check if we already have cloud objects for this cloudname Info<< "No FV fields" << nl << endl;
HashTable<IOobjectList>::const_iterator iter = }
cloudObjects.find(cloudDirs[i]); }
if (iter == cloudObjects.end()) {
{ Info<< "Reconstructing point fields" << nl << endl;
// Do local scan for valid cloud objects
IOobjectList sprayObjs const pointMesh& pMesh = pointMesh::New(mesh);
PtrList<pointMesh> pMeshes(procMeshes.meshes().size());
forAll(pMeshes, procI)
{
pMeshes.set
(
procI,
new pointMesh(procMeshes.meshes()[procI])
);
}
pointFieldReconstructor pointReconstructor
(
pMesh,
pMeshes,
procMeshes.pointProcAddressing(),
procMeshes.boundaryProcAddressing()
);
pointReconstructor.reconstructFields<scalar>
(
objects,
selectedFields
);
pointReconstructor.reconstructFields<vector>
(
objects,
selectedFields
);
pointReconstructor.reconstructFields<sphericalTensor>
(
objects,
selectedFields
);
pointReconstructor.reconstructFields<symmTensor>
(
objects,
selectedFields
);
pointReconstructor.reconstructFields<tensor>
(
objects,
selectedFields
);
if (pointReconstructor.nReconstructed() == 0)
{
Info<< "No point fields" << nl << endl;
}
}
// If there are any clouds, reconstruct them.
// The problem is that a cloud of size zero will not get written so
// in pass 1 we determine the cloud names and per cloud name the
// fields. Note that the fields are stored as IOobjectList from
// the first processor that has them. They are in pass2 only used
// for name and type (scalar, vector etc).
if (!noLagrangian)
{
HashTable<IOobjectList> cloudObjects;
forAll(databases, procI)
{
fileNameList cloudDirs
(
readDir
( (
procMeshes.meshes()[procI], databases[procI].timePath()
databases[procI].timeName(), / regionDir
cloud::prefix/cloudDirs[i] / cloud::prefix,
); fileName::DIRECTORY
)
);
IOobject* positionsPtr = sprayObjs.lookup("positions"); forAll(cloudDirs, i)
{
// Check if we already have cloud objects for this
// cloudname
HashTable<IOobjectList>::const_iterator iter =
cloudObjects.find(cloudDirs[i]);
if (positionsPtr) if (iter == cloudObjects.end())
{ {
cloudObjects.insert(cloudDirs[i], sprayObjs); // Do local scan for valid cloud objects
IOobjectList sprayObjs
(
procMeshes.meshes()[procI],
databases[procI].timeName(),
cloud::prefix/cloudDirs[i]
);
IOobject* positionsPtr = sprayObjs.lookup
(
"positions"
);
if (positionsPtr)
{
cloudObjects.insert(cloudDirs[i], sprayObjs);
}
} }
} }
} }
}
if (cloudObjects.size()) if (cloudObjects.size())
{
// Pass2: reconstruct the cloud
forAllConstIter(HashTable<IOobjectList>, cloudObjects, iter)
{ {
const word cloudName = string::validate<word>(iter.key()); // Pass2: reconstruct the cloud
forAllConstIter(HashTable<IOobjectList>, cloudObjects, iter)
{
const word cloudName = string::validate<word>
(
iter.key()
);
// Objects (on arbitrary processor) // Objects (on arbitrary processor)
const IOobjectList& sprayObjs = iter(); const IOobjectList& sprayObjs = iter();
Info<< "Reconstructing lagrangian fields for cloud " Info<< "Reconstructing lagrangian fields for cloud "
<< cloudName << nl << endl; << cloudName << nl << endl;
reconstructLagrangianPositions reconstructLagrangianPositions
( (
mesh, mesh,
cloudName, cloudName,
procMeshes.meshes(), procMeshes.meshes(),
procMeshes.faceProcAddressing(), procMeshes.faceProcAddressing(),
procMeshes.cellProcAddressing() procMeshes.cellProcAddressing()
); );
reconstructLagrangianFields<label> reconstructLagrangianFields<label>
( (
cloudName, cloudName,
mesh, mesh,
procMeshes.meshes(), procMeshes.meshes(),
sprayObjs, sprayObjs,
selectedLagrangianFields selectedLagrangianFields
); );
reconstructLagrangianFieldFields<label> reconstructLagrangianFieldFields<label>
( (
cloudName, cloudName,
mesh, mesh,
procMeshes.meshes(), procMeshes.meshes(),
sprayObjs, sprayObjs,
selectedLagrangianFields selectedLagrangianFields
); );
reconstructLagrangianFields<scalar> reconstructLagrangianFields<scalar>
( (
cloudName, cloudName,
mesh, mesh,
procMeshes.meshes(), procMeshes.meshes(),
sprayObjs, sprayObjs,
selectedLagrangianFields selectedLagrangianFields
); );
reconstructLagrangianFieldFields<scalar> reconstructLagrangianFieldFields<scalar>
( (
cloudName, cloudName,
mesh, mesh,
procMeshes.meshes(), procMeshes.meshes(),
sprayObjs, sprayObjs,
selectedLagrangianFields selectedLagrangianFields
); );
reconstructLagrangianFields<vector> reconstructLagrangianFields<vector>
( (
cloudName, cloudName,
mesh, mesh,
procMeshes.meshes(), procMeshes.meshes(),
sprayObjs, sprayObjs,
selectedLagrangianFields selectedLagrangianFields
); );
reconstructLagrangianFieldFields<vector> reconstructLagrangianFieldFields<vector>
( (
cloudName, cloudName,
mesh, mesh,
procMeshes.meshes(), procMeshes.meshes(),
sprayObjs, sprayObjs,
selectedLagrangianFields selectedLagrangianFields
); );
reconstructLagrangianFields<sphericalTensor> reconstructLagrangianFields<sphericalTensor>
( (
cloudName, cloudName,
mesh, mesh,
procMeshes.meshes(), procMeshes.meshes(),
sprayObjs, sprayObjs,
selectedLagrangianFields selectedLagrangianFields
); );
reconstructLagrangianFieldFields<sphericalTensor> reconstructLagrangianFieldFields<sphericalTensor>
( (
cloudName, cloudName,
mesh, mesh,
procMeshes.meshes(), procMeshes.meshes(),
sprayObjs, sprayObjs,
selectedLagrangianFields selectedLagrangianFields
); );
reconstructLagrangianFields<symmTensor> reconstructLagrangianFields<symmTensor>
( (
cloudName, cloudName,
mesh, mesh,
procMeshes.meshes(), procMeshes.meshes(),
sprayObjs, sprayObjs,
selectedLagrangianFields selectedLagrangianFields
); );
reconstructLagrangianFieldFields<symmTensor> reconstructLagrangianFieldFields<symmTensor>
( (
cloudName, cloudName,
mesh, mesh,
procMeshes.meshes(), procMeshes.meshes(),
sprayObjs, sprayObjs,
selectedLagrangianFields selectedLagrangianFields
); );
reconstructLagrangianFields<tensor> reconstructLagrangianFields<tensor>
( (
cloudName, cloudName,
mesh, mesh,
procMeshes.meshes(), procMeshes.meshes(),
sprayObjs, sprayObjs,
selectedLagrangianFields selectedLagrangianFields
); );
reconstructLagrangianFieldFields<tensor> reconstructLagrangianFieldFields<tensor>
( (
cloudName, cloudName,
mesh, mesh,
procMeshes.meshes(), procMeshes.meshes(),
sprayObjs, sprayObjs,
selectedLagrangianFields selectedLagrangianFields
); );
}
}
else
{
Info<< "No lagrangian fields" << nl << endl;
} }
} }
else
{
Info<< "No lagrangian fields" << nl << endl;
}
} }
}
// If there are any "uniform" directories copy them from // If there are any "uniform" directories copy them from
// the master processor // the master processor
forAll(timeDirs, timeI)
{
fileName uniformDir0 = databases[0].timePath()/"uniform"; fileName uniformDir0 = databases[0].timePath()/"uniform";
if (isDir(uniformDir0)) if (isDir(uniformDir0))
{ {

15
tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/Allrun
View File

@ -31,27 +31,18 @@ done
#runApplication `getApplication` #runApplication `getApplication`
# Decompose # Decompose
for i in bottomAir topAir heater leftSolid rightSolid runApplication decomposePar -allRegions
do
decomposePar -region $i > log.decomposePar.$i 2>&1
done
# Run # Run
runParallel `getApplication` 4 runParallel `getApplication` 4
# Reconstruct # Reconstruct
for i in bottomAir topAir heater leftSolid rightSolid runApplication reconstructPar -allRegions
do
reconstructPar -region $i > log.reconstructPar.$i2 >&1
done
echo echo
echo "creating files for paraview post-processing" echo "creating files for paraview post-processing"
echo echo
for i in bottomAir topAir heater leftSolid rightSolid paraFoam -touchAll
do
paraFoam -touch -region $i
done
# ----------------------------------------------------------------- end-of-file # ----------------------------------------------------------------- end-of-file

10
tutorials/heatTransfer/chtMultiRegionFoam/multiRegionLiquidHeater/Allrun
View File

@ -31,19 +31,13 @@ done
#runApplication chtMultiRegionFoam #runApplication chtMultiRegionFoam
# Decompose # Decompose
for i in bottomWater topAir heater leftSolid rightSolid runApplication decomposePar -allRegions
do
decomposePar -region $i > log.decomposePar.$i 2>&1
done
# Run # Run
runParallel `getApplication` 4 runParallel `getApplication` 4
# Reconstruct # Reconstruct
for i in bottomWater topAir heater leftSolid rightSolid runApplication reconstructPar -allRegions
do
reconstructPar -region $i > log.reconstructPar.$i 2>&1
done
echo echo

15
tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/Allrun
View File

@ -36,27 +36,18 @@ runApplication `getApplication`
## Decompose ## Decompose
#for i in bottomAir topAir heater leftSolid rightSolid #runApplication decomposePar -allRegions
#do
# decomposePar -region $i > log.decomposePar.$i 2>&1
#done
# #
## Run ## Run
#runParallel `getApplication` 4 #runParallel `getApplication` 4
# #
## Reconstruct ## Reconstruct
#for i in bottomAir topAir heater leftSolid rightSolid #runApplication reconstructPar -allRegions
#do
# reconstructPar -region $i > log.reconstructPar.$i 2>&1
#done
echo echo
echo "creating files for paraview post-processing" echo "creating files for paraview post-processing"
echo echo
for i in bottomAir topAir heater leftSolid rightSolid paraFoam -touchAll
do
paraFoam -touch -region $i
done
# ----------------------------------------------------------------- end-of-file # ----------------------------------------------------------------- end-of-file

10
tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeater/Allrun
View File

@ -31,19 +31,13 @@ done
runApplication `getApplication` runApplication `getApplication`
## Decompose ## Decompose
#for i in bottomAir topAir heater leftSolid rightSolid #runApplication decomposePar -allRegions
#do
# decomposePar -region $i > log.decomposePar.$i 2>&1
#done
# #
## Run ## Run
#runParallel `getApplication` 4 #runParallel `getApplication` 4
# #
## Reconstruct ## Reconstruct
#for i in bottomAir topAir heater leftSolid rightSolid #runApplication reconstructPar -allRegions
#do
# reconstructPar -region $i > log.reconstructPar.$i 2>&1
#done
echo echo

10
tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/Allrun
View File

@ -44,10 +44,7 @@ runApplication `getApplication`
## Run in parallel ## Run in parallel
## Decompose ## Decompose
#for i in bottomAir topAir heater leftSolid rightSolid #runApplication decomposePar -allRegions
#do
# decomposePar -region $i > log.decomposePar.$i 2>&1
#done
# #
#for i in bottomAir topAir #for i in bottomAir topAir
#do #do
@ -63,10 +60,7 @@ runApplication `getApplication`
#runParallel `getApplication` 4 #runParallel `getApplication` 4
# #
## Reconstruct ## Reconstruct
#for i in bottomAir topAir heater leftSolid rightSolid #runApplication reconstructPar -allRegions
#do
# reconstructPar -region $i > log.reconstructPar.$i 2>&1
#done
echo echo