| /*--------------------------------*- C++ -*----------------------------------*\ | |
| ========= | | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | |
| \\ / O peration | Website: https://openfoam.org | |
| \\ / A nd | Version: dev | |
| \\/ M anipulation | | |
| \*---------------------------------------------------------------------------*/ | |
| FoamFile | |
| { | |
| format ascii; | |
| class dictionary; | |
| location "system"; | |
| object decomposeParDict; | |
| } | |
| // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // | |
| numberOfSubdomains 2; | |
| // Optional decomposition constraints | |
| /* | |
| constraints | |
| { | |
| preserveBaffles | |
| { | |
| //- 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 | |
| type preserveBaffles; | |
| } | |
| preserveFaceZones | |
| { | |
| //- Keep owner and neighbour on same processor for faces in zones | |
| type preserveFaceZones; | |
| zones (".*"); | |
| } | |
| preservePatches | |
| { | |
| //- Keep owner and neighbour on same processor for faces in patches. Can | |
| // be used to prevent a cyclic patch from being decomposed into | |
| // multiple processor cyclics. | |
| type preservePatches; | |
| patches (".*"); | |
| } | |
| singleProcessorFaceZones | |
| { | |
| //- Keep all of faceZone 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). If processor index is set to -1, the decomposition | |
| // method chooses the processor to which the face set is decomposed. | |
| // This is likely to create a better balance than if the processor | |
| // index is explicitly specified. | |
| type singleProcessorFaceZones; | |
| singleProcessorFaceZones ((f1 -1)); | |
| } | |
| refinementHistory | |
| { | |
| //- Decompose cells such that all cell originating from single cell | |
| // end up on same processor | |
| type refinementHistory; | |
| } | |
| } | |
| */ | |
| //- 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. | |
| // weightField dsmcRhoNMean; | |
| method scotch; | |
| // method hierarchical; | |
| // method simple; | |
| // method metis; | |
| // method manual; | |
| // method multiLevel; | |
| // method structured; // does 2D decomposition of structured mesh | |
| multiLevel | |
| { | |
| // Decomposition methods to apply in turn. This is like hierarchical but | |
| // fully general - every method can be used at every level. | |
| level0 | |
| { | |
| numberOfSubdomains 64; | |
| // method simple; | |
| // simple | |
| // { | |
| // n (2 1 1); | |
| // delta 0.001; | |
| // } | |
| method scotch; | |
| } | |
| level1 | |
| { | |
| numberOfSubdomains 4; | |
| method scotch; | |
| } | |
| } | |
| simple | |
| { | |
| // Number of processor blocks in each coordinate direction | |
| n (2 1 1); | |
| // Coefficient of the slight rotation of the mesh to bias the decomposition | |
| // to be deterministic in the case that the initial block mesh is coordinate | |
| // aligned | |
| delta 0.001; | |
| } | |
| hierarchical | |
| { | |
| // Number of processor blocks in each coordinate direction | |
| n (1 2 1); | |
| // Coordinate order of the hierarchical decomposition | |
| order xyz; | |
| // Coefficient of the slight rotation of the mesh to bias the decomposition | |
| // to be deterministic in the case that the initial block mesh is coordinate | |
| // aligned | |
| delta 0.001; | |
| } | |
| metis | |
| { | |
| /* | |
| processorWeights | |
| ( | |
| 1 | |
| 1 | |
| 1 | |
| 1 | |
| ); | |
| */ | |
| } | |
| scotch | |
| { | |
| /* | |
| processorWeights | |
| ( | |
| 1 | |
| 1 | |
| 1 | |
| 1 | |
| ); | |
| writeGraph true; | |
| strategy "b"; | |
| */ | |
| } | |
| manual | |
| { | |
| dataFile "decompositionData"; | |
| } | |
| structured | |
| { | |
| // 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; | |
| } | |
| // Is the case distributed? Note: command-line argument -roots takes | |
| // precedence | |
| // distributed yes; | |
| // Per slave (so nProcs-1 entries) the directory above the case. | |
| /* | |
| roots | |
| ( | |
| "/tmp" | |
| "/tmp" | |
| ); | |
| */ | |
| // ************************************************************************* // | |