songtianlun/openfoam
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

STYLE: remove deprecated constraints format from tutorials

Browse Source
This commit is contained in:
Mark Olesen 2018-07-11 17:02:40 +02:00
parent 2b869824f2
commit b41d5ed523
21 changed files with 435 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
applications/test/hexRef8/block/system/decomposeParDict
View File

@ -17,22 +17,6 @@ FoamFile
numberOfSubdomains 2;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
//preservePatches (cyclic_half0 cyclic_half1);
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
//singleProcessorFaceSets ((f0 -1));
//- Use the volScalarField named here as a weight for each cell in the
// decomposition. For example, use a particle population field to decompose
// for a balanced number of particles in a lagrangian simulation.
@ -126,6 +110,38 @@ structuredCoeffs
method scotch;
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
patches
{
type preservePatches,
patches (cyclic_half0 cyclic_half1);
}
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
processors
{
type singleProcessorFaceSets;
sets ((f0 -1));
}
}
*/
//// Is the case distributed? Note: command-line argument -roots takes
//// precedence
//distributed yes;

52
applications/test/mapDistributePolyMesh/cavity/system/decomposeParDict
View File

@ -17,27 +17,6 @@ FoamFile
numberOfSubdomains 2;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
//preservePatches (cyclic_half0 cyclic_half1);
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
//singleProcessorFaceSets ((f0 -1));
//- Keep owner and neighbour of baffles on same processor (i.e. keep it
// detectable as a baffle). Baffles are two boundary face sharing the
// same points.
//preserveBaffles true;
//- Use the volScalarField named here as a weight for each cell in the
// decomposition. For example, use a particle population field to decompose
// for a balanced number of particles in a lagrangian simulation.
@ -130,6 +109,37 @@ structuredCoeffs
method scotch;
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
patches
{
type preservePatches,
patches (cyclic_half0 cyclic_half1);
}
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
processors
{
type singleProcessorFaceSets;
sets ((f0 -1));
}
}
*/
//// Is the case distributed? Note: command-line argument -roots takes
//// precedence
//distributed yes;

52
applications/test/mapDistributePolyMesh/cavity/system/decomposeParDict-2
View File

@ -17,27 +17,6 @@ FoamFile
numberOfSubdomains 2;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
//preservePatches (cyclic_half0 cyclic_half1);
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
//singleProcessorFaceSets ((f0 -1));
//- Keep owner and neighbour of baffles on same processor (i.e. keep it
// detectable as a baffle). Baffles are two boundary face sharing the
// same points.
//preserveBaffles true;
//- Use the volScalarField named here as a weight for each cell in the
// decomposition. For example, use a particle population field to decompose
// for a balanced number of particles in a lagrangian simulation.
@ -130,6 +109,37 @@ structuredCoeffs
method scotch;
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
patches
{
type preservePatches,
patches (cyclic_half0 cyclic_half1);
}
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
processors
{
type singleProcessorFaceSets;
sets ((f0 -1));
}
}
*/
//// Is the case distributed? Note: command-line argument -roots takes
//// precedence
//distributed yes;

52
applications/test/mapDistributePolyMesh/cavity/system/decomposeParDict-5
View File

@ -17,27 +17,6 @@ FoamFile
numberOfSubdomains 5;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
//preservePatches (cyclic_half0 cyclic_half1);
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
//singleProcessorFaceSets ((f0 -1));
//- Keep owner and neighbour of baffles on same processor (i.e. keep it
// detectable as a baffle). Baffles are two boundary face sharing the
// same points.
//preserveBaffles true;
//- Use the volScalarField named here as a weight for each cell in the
// decomposition. For example, use a particle population field to decompose
// for a balanced number of particles in a lagrangian simulation.
@ -130,6 +109,37 @@ structuredCoeffs
method scotch;
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
patches
{
type preservePatches,
patches (cyclic_half0 cyclic_half1);
}
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
processors
{
type singleProcessorFaceSets;
sets ((f0 -1));
}
}
*/
//// Is the case distributed? Note: command-line argument -roots takes
//// precedence
//distributed yes;

46
applications/test/patchRegion/cavity_pinched/system/decomposeParDict
View File

@ -17,22 +17,6 @@ FoamFile
numberOfSubdomains 2;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
//preservePatches (cyclic_half0 cyclic_half1);
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
//singleProcessorFaceSets ((f0 -1));
//- Use the volScalarField named here as a weight for each cell in the
// decomposition. For example, use a particle population field to decompose
// for a balanced number of particles in a lagrangian simulation.
@ -125,6 +109,36 @@ structuredCoeffs
method scotch;
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
patches
{
type preservePatches,
patches (cyclic_half0 cyclic_half1);
}
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
processors
{
type singleProcessorFaceSets;
sets ((f0 -1));
}
}
*/
//// Is the case distributed? Note: command-line argument -roots takes
//// precedence
//distributed yes;

6
tutorials/heatTransfer/chtMultiRegionFoam/externalCoupledHeater/system/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
// method hierarchical;
// method simple;
@ -27,9 +24,8 @@ method scotch;
coeffs
{
n (2 2 1);
//delta 0.001; // default=0.001
//order xyz; // default=xzy
dataFile "decompositionData";
}
// ************************************************************************* //

16
tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/system/decomposeParDict
View File

@ -16,11 +16,7 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
// method hierarchical;
// method simple;
// method manual;
@ -44,4 +40,16 @@ coeffs
n (2 2 1);
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

17
tutorials/heatTransfer/chtMultiRegionFoam/snappyMultiRegionHeater/system/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
regions
@ -26,7 +23,7 @@ regions
heater
{
numberOfSubdomains 1;
method simple;
method simple;
coeffs
{
@ -40,4 +37,16 @@ coeffs
n (2 2 1);
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

14
tutorials/heatTransfer/chtMultiRegionSimpleFoam/externalCoupledHeater/system/decomposeParDict
View File

@ -16,10 +16,18 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

15
tutorials/heatTransfer/chtMultiRegionSimpleFoam/multiRegionHeaterRadiation/system/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
// method hierarchical;
// method simple;
@ -37,4 +34,16 @@ scotchCoeffs
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

16
tutorials/lagrangian/reactingParcelFoam/filter/system/decomposeParDict
View File

@ -18,15 +18,19 @@ numberOfSubdomains 4;
method scotch;
preserveFaceZones
(
cycLeft
cycRight
);
coeffs
{
n (2 2 1);
}
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (cycLeft cycRight);
}
}
// ************************************************************************* //

71
tutorials/mesh/parallel/cavity/system/decomposeParDict
View File

@ -17,27 +17,6 @@ FoamFile
numberOfSubdomains 2;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
//preservePatches (cyclic_half0 cyclic_half1);
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
//singleProcessorFaceSets ((f0 -1));
//- Keep owner and neighbour of baffles on same processor (i.e. keep it
// detectable as a baffle). Baffles are two boundary face sharing the
// same points.
//preserveBaffles true;
//- Use the volScalarField named here as a weight for each cell in the
// decomposition. For example, use a particle population field to decompose
// for a balanced number of particles in a lagrangian simulation.
@ -79,15 +58,12 @@ multiLevelCoeffs
simpleCoeffs
{
n (2 1 1);
delta 0.001;
n (2 1 1);
}
hierarchicalCoeffs
{
n (1 2 1);
delta 0.001;
order xyz;
n (1 2 1);
}
metisCoeffs
@ -131,6 +107,49 @@ structuredCoeffs
method scotch;
}
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
zones
{
type preserveFaceZones;
zones (heater solid1 solid3);
enabled false;
}
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
patches
{
type preservePatches;
patches (cyclic_half0 cyclic_half1);
enabled false;
}
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
processors
{
type singleProcessorFaceSets;
sets ((f0 -1));
enabled false;
}
//- Keep owner and neighbour of baffles on same processor
// (i.e. keep it detectable as a baffle).
// Baffles are two boundary face sharing the same points.
baffles
{
type preserveBaffles;
enabled false;
}
}
//// Is the case distributed? Note: command-line argument -roots takes
//// precedence
//distributed yes;

77
tutorials/mesh/parallel/cavity/system/decomposeParDict-5
View File

@ -17,27 +17,6 @@ FoamFile
numberOfSubdomains 5;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
//preservePatches (cyclic_half0 cyclic_half1);
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
//singleProcessorFaceSets ((f0 -1));
//- Keep owner and neighbour of baffles on same processor (i.e. keep it
// detectable as a baffle). Baffles are two boundary face sharing the
// same points.
//preserveBaffles true;
//- Use the volScalarField named here as a weight for each cell in the
// decomposition. For example, use a particle population field to decompose
// for a balanced number of particles in a lagrangian simulation.
@ -79,15 +58,12 @@ multiLevelCoeffs
simpleCoeffs
{
n (2 1 1);
delta 0.001;
n (2 1 1);
}
hierarchicalCoeffs
{
n (1 2 1);
delta 0.001;
order xyz;
n (1 2 1);
}
metisCoeffs
@ -123,14 +99,57 @@ manualCoeffs
structuredCoeffs
{
// Method to use on the 2D subset
method scotch;
// Patches to do 2D decomposition on. Structured mesh only; cells have
// to be in 'columns' on top of patches.
patches (movingWall);
// Method to use on the 2D subset
method scotch;
}
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
zones
{
type preserveFaceZones;
zones (heater solid1 solid3);
enabled false;
}
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
patches
{
type preservePatches;
patches (cyclic_half0 cyclic_half1);
enabled false;
}
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
processors
{
type singleProcessorFaceSets;
sets ((f0 -1));
enabled false;
}
//- Keep owner and neighbour of baffles on same processor
// (i.e. keep it detectable as a baffle).
// Baffles are two boundary face sharing the same points.
baffles
{
type preserveBaffles;
enabled false;
}
}
//// Is the case distributed? Note: command-line argument -roots takes
//// precedence
//distributed yes;

14
tutorials/mesh/parallel/filter/system/decomposeParDict
View File

@ -18,11 +18,15 @@ numberOfSubdomains 3;
method scotch;
preserveFaceZones
(
cycLeft
cycRight
);
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (cycLeft cycRight);
}
}
// ************************************************************************* //

74
tutorials/mesh/snappyHexMesh/addLayersToFaceZone/system/decomposeParDict
View File

@ -17,27 +17,6 @@ FoamFile
numberOfSubdomains 2;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
//preservePatches (cyclic_half0 cyclic_half1);
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
//singleProcessorFaceSets ((f0 -1));
//- Keep owner and neighbour of baffles on same processor (i.e. keep it
// detectable as a baffle). Baffles are two boundary face sharing the
// same points.
//preserveBaffles true;
//- Use the volScalarField named here as a weight for each cell in the
// decomposition. For example, use a particle population field to decompose
// for a balanced number of particles in a lagrangian simulation.
@ -79,14 +58,11 @@ multiLevelCoeffs
simpleCoeffs
{
n (2 1 1);
delta 0.001;
}
hierarchicalCoeffs
{
n (1 2 1);
delta 0.001;
order xyz;
}
metisCoeffs
@ -122,14 +98,58 @@ manualCoeffs
structuredCoeffs
{
// Method to use on the 2D subset
method scotch;
// Patches to do 2D decomposition on. Structured mesh only; cells have
// to be in 'columns' on top of patches.
patches (movingWall);
// Method to use on the 2D subset
method scotch;
}
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
zones
{
type preserveFaceZones;
zones (heater solid1 solid3);
enabled false;
}
//- Keep owner and neighbour on same processor for faces in patches:
// (makes sense only for cyclic patches)
patches
{
type preservePatches;
patches (cyclic_half0 cyclic_half1);
enabled false;
}
//- Keep all of faceSet on a single processor. This puts all cells
// connected with a point, edge or face on the same processor.
// (just having face connected cells might not guarantee a balanced
// decomposition)
// The processor can be -1 (the decompositionMethod chooses the processor
// for a good load balance) or explicitly provided (upsets balance).
singleProcessorFaceSets
{
type singleProcessorFaceSets;
sets ((f0 -1));
enabled false;
}
//- Keep owner and neighbour of baffles on same processor
// (i.e. keep it detectable as a baffle).
// Baffles are two boundary face sharing the same points.
baffles
{
type preserveBaffles;
enabled false;
}
}
//// Is the case distributed? Note: command-line argument -roots takes
//// precedence
//distributed yes;

15
tutorials/preProcessing/createZeroDirectory/snappyMultiRegionHeater/system/bottomAir/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
// method hierarchical;
// method simple;
@ -45,4 +42,16 @@ scotchCoeffs
//strategy "b";
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

15
tutorials/preProcessing/createZeroDirectory/snappyMultiRegionHeater/system/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
// method scotch;
method hierarchical;
// method simple;
@ -45,4 +42,16 @@ scotchCoeffs
//strategy "b";
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones;
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

15
tutorials/preProcessing/createZeroDirectory/snappyMultiRegionHeater/system/heater/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
// method hierarchical;
// method simple;
@ -45,4 +42,16 @@ scotchCoeffs
//strategy "b";
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

15
tutorials/preProcessing/createZeroDirectory/snappyMultiRegionHeater/system/leftSolid/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
// method hierarchical;
// method simple;
@ -45,4 +42,16 @@ scotchCoeffs
//strategy "b";
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

15
tutorials/preProcessing/createZeroDirectory/snappyMultiRegionHeater/system/rightSolid/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
// method hierarchical;
// method simple;
@ -45,4 +42,16 @@ scotchCoeffs
//strategy "b";
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //

15
tutorials/preProcessing/createZeroDirectory/snappyMultiRegionHeater/system/topAir/decomposeParDict
View File

@ -16,9 +16,6 @@ FoamFile
numberOfSubdomains 4;
//- Keep owner and neighbour on same processor for faces in zones:
// preserveFaceZones (heater solid1 solid3);
method scotch;
// method hierarchical;
// method simple;
@ -45,4 +42,16 @@ scotchCoeffs
//strategy "b";
}
/*
constraints
{
//- Keep owner and neighbour on same processor for faces in zones:
faces
{
type preserveFaceZones,
zones (heater solid1 solid3);
}
}
*/
// ************************************************************************* //