OpenFOAM-12/etc/caseDicts/annotated/decomposeParDict

/*--------------------------------*- C++ -*----------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     | Website:  https://openfoam.org
    \\  /    A nd           | Version:  12
     \\/     M anipulation  |
\*---------------------------------------------------------------------------*/
FoamFile
{
    format      ascii;
    class       dictionary;
    note        "mesh decomposition control dictionary";
    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 (".*");
   }

   singleProcessorFaceSets
   {
       //- 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). 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    singleProcessorFaceSets;
       singleProcessorFaceSets ((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

multiLevelCoeffs
{
    // 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;
        // simpleCoeffs
        // {
        //     n           (2 1 1);
        //     delta       0.001;
        // }
        method scotch;
    }
    level1
    {
        numberOfSubdomains  4;
        method scotch;
    }
}


simpleCoeffs
{
    // 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;
}

hierarchicalCoeffs
{
    // 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;
}

metisCoeffs
{
    /*
    processorWeights
    (
        1
        1
        1
        1
    );
    */
}

scotchCoeffs
{
    /*
    processorWeights
    (
       1
       1
       1
       1
    );
    writeGraph  true;
    strategy "b";
    */
}

manualCoeffs
{
    dataFile    "decompositionData";
}

structuredCoeffs
{
    // 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"
);
*/

// ************************************************************************* //