decomposeParDict in OpenFOAM 4.x,来源：github

/*--------------------------------*- C++ -*----------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  4.x                                   |
|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
|    \\/     M anipulation  |                                                 |
\*---------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       dictionary;
    note        "mesh decomposition control dictionary";
    object      decomposeParDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

numberOfSubdomains  2; // specifies the number of processor (or cores) you want to use to solve your case.


// 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
//        //  (only makes sense for cyclic patches. Not suitable for e.g.
//        //   cyclicAMI since these are not coupled on the patch level. Use
//        //   singleProcessorFaceSets for those)
//        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)
//        // The processor can be -1 (the decompositionMethod chooses the
//        // processor for a good load balance) or explicitly provided (upsets
//        // balance)
//        type    singleProcessorFaceSets;
//        singleProcessorFaceSets ((f1 -1));
//    }
//    refinementHistory
//    {
//        //- Decompose cells such that all cell originating from single cell
//        //  end up on same processor
//        type    refinementHistory;
//    }
//}


// Deprecated form of specifying decomposition constraints:
//- 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. Not suitable for e.g. cyclicAMI
//   since these are not coupled on the patch level. Use
//   singleProcessorFaceSets for those)
//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.
// 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;
    }
}

// Desired output
// delta is the cell skew factor. It's default value is 0.001.
simpleCoeffs
{
    n           (2 1 1);
    delta       0.001;
}

hierarchicalCoeffs
{
    n           (1 2 1);
    delta       0.001;
    order       xyz;
}

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

singleProcessorFaceSets 设置，来源:OpenFOAM API Guide

同上

constraints
    {
        procs
        {
            type    singleProcessorFaceSets;
            sets
            (
                (faceSet1   0)
                (faceSet5   12)
                (faceSet25 510)
            );
        }
    }