/*--------------------------------*- C++ -*----------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  v2206                                 |
|   \\  /    A nd           | Website:  www.openfoam.com                      |
|    \\/     M anipulation  |                                                 |
\*---------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       dictionary;
    object      topoSetDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

// Information about topoSetSource types

cellSet_doc
{
    //- Select all external (boundary) faces.
    {
        source boundaryToCell;
    }


    //- Cells with cell centre within multiple boxes or single box
    {
        source  boxToCell;

        boxes   ((0 0 0) (1 1 1) (10 10 10)(11 11 11));
        // or
        box     (0 0 0) (1 1 1);
        // or
        min     (0 0 0);
        max     (1 1 1);
    }


    //- Copy elements from one or more other cellSets
    {
        source  cellToCell;
        sets    (c1 c2);
        // or
        set     c1;
    }


    //- Cells with centres within cylinder or cylinder annulus
    {
        source  cylinderToCell;
        point1  (0.2 0.2 -10); // beg point on cylinder axis
        point2  (0.2 0.2 0);   // end point on cylinder axis
        radius  5.0;
        // optional
        innerRadius 1.0;
    }

    //- Select based on faceSet
    {
        source  faceToCell;
        sets    (f0 f1);
        // or
        set     f0;             // Name of faceSet

        //- selection option (mandatory)
        option any;             // cell with any face in faceSet
        // option all;          // cell with all faces in faceSet
        // option neighbour;    // cell with neighbour in faceSet
        // option owner;        // cell with owner in faceSet
    }


    //- Cells on master or slave side of faceZone
    {
        source  faceZoneToCell;
        zones   (".*Zone");     // Names of faceZones, word or regex
        // or
        zone    ".*Zone";       // Name of faceZone, word or regex

        option  master;         // master/slave
    }


    //- values of field within certain range
    {
        source  fieldToCell;
        field   U;      // Note: uses mag(U) since volVectorField
        min     0.1;
        max     0.5;
    }


    //- Select by explicitly providing cell labels
    {
        source  labelToCell;
        value   (12 13 56);   // labels of cells
    }


    //- Select based on number of neighbouring cells
    {
        source  nbrToCell;
        neighbours  4;   // min neighbours
    }


    //- Cells with cellCentre nearest to coordinates
    {
        source  nearestToCell;
        points  ((0 0 0) (1 1 1)(2 2 2));
    }


    //- Select cells associated with patch
    {
        source  patchToCell;
        patches ("patch.*");
        // or
        patch   somePatch;
    }


    //- Select based on pointSet
    {
        source  pointToCell;
        sets    (p0 p1);
        // or
        sets    p0;

        option any;         // cell with any point in pointSet
        //option edge;      // cell with an edge with both points in pointSet
    }


    //- Mesh region (non-face connected part of (subset of)mesh)
    {
        source  regionToCell;
        insidePoints ((1 2 3)); // points inside region to select
        set     c0;             // optional name of cellSet giving mesh subset
        nErode  0;              // optional number of layers to erode selection
    }


    //- Cells with cell centre within box
    // Is skewed, rotated box. Given as origin and three spanning vectors.
    {
        source  rotatedBoxToCell;
        origin  (0.2 0.2 -10);
        i       (0.2 0.2 0);
        j       (-0.2 0.2 0);
        k       (10 10 10);
    }


    //- Select cells with centres within a (closed!) searchableSurface
    {
        source       searchableSurfaceToCell;
        surfaceType  triSurfaceMesh;  // Type of surface
        surfaceName  blob.obj;        // Name for surface object
    }


    //- Select based on cellShape
    {
        source  shapeToCell;
        shape   hex;     // hex/wedge/prism/pyr/tet/tetWedge/splitHex
    }


    //- Cells with centre within sphere
    {
        source  sphereToCell;
        origin  (0.2 0.2 -10);
        radius  5.0;

        // optional
        innerRadius 1.0;
    }


    //- Select based on surface
    {
        source  surfaceToCell;

        file            "geometry.stl";
        outsidePoints   ((-99 -99 -59));    // definition of outside
        includeCut      false;              // cells cut by surface
        includeInside   false;              // cells not on outside of surf
        includeOutside  false;              // cells on outside of surf
        nearDistance    -1;                 // cells with centre near surf
                                            // (set to -1 if not used)
        curvature       0.9;                // cells within nearDistance
                                            // and near surf curvature
                                            // (set to -100 if not used)
        // optional
        useSurfaceOrientation false;  // use closed surface inside/outside
                                      // test (ignores includeCut,
                                      // outsidePoints)
    }


    //- Cells underneath plane such that volume is reached.
    // E.g. for use in setFields to set the level given a wanted volume.
    {
        source  targetVolumeToCell;
        volume  2e-05;
        normal  (0 1 0);          // usually in direction of gravity
        // optional
        set     c0;               // restrict to named cellSet
    }


    //- Cells in cell zone
    {
        source  zoneToCell;
        zones   (".*Zone");     // Names of cellZones, word or regex
        // or
        zone    ".*Zone";       // Name of cellZone, word or regex
    }

    //- Cells attached to the outside of the input cellSet
    {
        source      haloToCell;
        steps       3;          // Number of grow/shrink steps to use
    }
}


faceSet_doc
{
    //- All boundary faces
    {
        source  boundaryToFace;
    }


    //- Faces with face centre within box ('box') or multiple boxes ('boxes')
    {
        source  boxToFace;

        boxes   ((0 0 0) (1 1 1) (10 10 10)(11 11 11));
        // or
        box     (0 0 0) (1 1 1);
        // or
        min     (0 0 0);
        max     (1 1 1);
    }


    //- Select based on cellSet
    {
        source  cellToFace;
        sets    (c0 c1);
        // or
        set     c0;             // Name of cellSet

        option  all;            // All faces of cells
        //option  both;         // Only faces with owner+neighbour in cellSet
    }


    //- Faces with centres within cylinder or cylinder annulus
    {
        source  cylinderToFace;
        point1  (0.2 0.2 -10); // beg point on cylinder axis
        point2  (0.2 0.2 0);   // end point on cylinder axis
        radius  5.0;
        // optional
        innerRadius 1.0;
    }


    //- Copy elements from faceSet
    {
        source  faceToFace;
        set     f1;
    }


    //- Select by explicitly providing face labels
    {
        source  labelToFace;
        value   (12 13 56);     // labels of faces
    }


    //- Faces with normal to within certain angle aligned with vector.
    {
        source  normalToFace;
        normal  (0 0 1);        // Vector
        cos     0.01;           // Tolerance (max cos of angle)
    }


    //- All faces of patch
    {
        source  patchToFace;
        patches ("patch.*");
        // or
        patch   somePatch;
    }


    //- Select based on pointSet
    {
        source  pointToFace;
        sets    (p0 p1);
        // or
        set     p0;             // Name of pointSet

        option  any;           // Faces using any point in pointSet
        //option  all          // Faces with all points in pointSet
        //option  edge         // Faces with two consecutive points in pointSet
    }


    //- Walk on faces in faceSet, starting from face nearest given position
    {
        source  regionToFace;
        set     f0;
        nearPoint (0.1 0.1 0.005);
    }


    //- Select faces with centres within a (closed!) searchableSurface
    //  (if surface is not closed a warning will be given and surface will
    //   be ignored)
    {
        source       searchableSurfaceToFace;
        surfaceType  triSurfaceMesh;  // Type of surface
        surfaceName  blob.obj;        // Name for surface object
    }


    //- Faces with centre within sphere
    {
        source  sphereToFace;
        origin  (0.2 0.2 -10);
        radius  5.0;
        // optional
        innerRadius 1.0;
    }


    //- Faces to close connection between points in different 'zones'
    {
        source  holeToFace;
        points
        (
            ((0.2 0.2 -10) (1.3 0.4 -0.1))  // points for zone 0
            ((10 10 10))                    // points for zone 1
        );

        // optional blocked faces (all uncoupled boundary faces are always
        // blocked)
        faceSet blockedFaces;

        // optional subset of cells to operate in (default is all cells)
        cellSet candidateCells;

        // optional erosion of resulting set. This does some local optimisations
        // to minimise the set of faces
        erode true;
    }


    //- All faces of faceZone
    {
        source  zoneToFace;

        zones   (".*Zone");     // Names of faceZones, word or regex
        // or
        zone    ".*Zone";       // Name of faceZone, word or regex
    }
}


pointSet_doc
{
    //- Points within multiple boxes or single box
    {
        source  boxToPoint;

        boxes   ((0 0 0) (1 1 1) (10 10 10)(11 11 11));
        // or
        box     (0 0 0) (1 1 1);
        // or
        min     (0 0 0);
        max     (1 1 1);
    }


    //- Points associated with cellSet
    {
        source  cellToPoint;
        sets    (c1 c2);
        // or
        set     c1;

        option  all;         // all points of cell
    }


    //- Points within cylinder or cylinder annulus
    {
        source  cylinderToPoint;
        point1  (0.2 0.2 -10); // beg point on cylinder axis
        point2  (0.2 0.2 0);   // end point on cylinder axis
        radius  5.0;
        // optional
        innerRadius 1.0;
    }


    //- Points associated with faceSet
    {
        source  faceToPoint;
        sets    (f1 f2);
        // or
        set     f1;

        option  all;         // all points of face
    }


    //- Select by explicitly providing point labels
    {
        source  labelToPoint;
        value   (12 13 56);   // labels of points
    }


    //- Points nearest to coordinates
    {
        source  nearestToPoint;
        points  ((0 0 0) (1 1 1));
    }


    //- Copy elements from pointSet
    {
        source  pointToPoint;
        sets    (p1 p2);
        // or
        set     p1;
    }


    //- Cell centres within a searchableSurface
    {
        source       searchableSurfaceToCell;
        surfaceType  triSurfaceMesh;  // Type of surface
        surfaceName  blob.obj;        // Name for surface object
    }


    //- Points centre within sphere
    {
        source  sphereToPoint;
        origin  (0.2 0.2 -10);
        radius  5.0;
        // optional
        innerRadius 1.0;
    }


    //- Select based on surface
    {
        source  searchableSurfaceToPoint;
        file    "geometry.stl";
        nearDistance    0.1;    // points near to surface
        includeInside   false;  // points on inside of surface
                                // (requires closed surface with consistent
                                //  normals)
        includeOutside  false;  //   ,,    outside  ,,
    }


    //- Points from pointZone
    {
        source  zoneToPoint;
        zones   (".*Zone");     // Names of pointZones, word or regex
        // or
        zone    ".*Zone";       // Name of pointZone, word or regex
    }
}


// cellZoneSet
// ~~~~~~~~~~~
// Manipulates a cellZone (as well as a cellSet)
// Takes any cellSet source. The difference with a cellSet is
// - reads the cells from the cellZone, not the cellSet
// - write to the cellZone as well as the cellSet

cellZoneSet_doc
{
    // For backwards compatibility:

    //- Select based on cellSet
    {
        source  setToCellZone;
        set     c0;           // name of cellSet
    }
}


// faceZoneSet
// ~~~~~~~~~~~
// Manipulates a faceZone (as well as a faceSet).
// It can only be used with special sources.

faceZoneSet_doc
{
    //- Select from another faceZone
    {
        source  faceZoneToFaceZone;
        zone    z1;             // Zone name, no regex
    }


    //- Select based on surface. Orientation from normals on surface
    {
        source       searchableSurfaceToFaceZone;
        surfaceType  sphere;          // Type of surface
        surfaceName  blob.obj;        // Name for surface object

        // Parameters for surface
        origin  (0.05 0.05 0.005);
        radius  0.025;
    }


    //- Select based on faceSet, using supplied normal to determine orientation
    {
        source  setAndNormalToFaceZone;
        faceSet f0;        // name of faceSet
        normal  (1 0 0);   // normal orientation
    }


    //- Select based on faceSet without orientation
    {
        source  setToFaceZone;
        faceSet f0;       // name of faceSet
    }


    //- Select based on faceSet, using cellSet to determine orientation
    {
        source  setsToFaceZone;
        faceSet f0;       // name of faceSet
        cellSet c0;       // name of cellSet of slave side
        flip    false;    // optional: flip the faceZone (so now the cellSet
                          //           is the master side)
    }
}


// pointZoneSet
// ~~~~~~~~~~~~
// Manipulates a pointZone (as well as a pointSet)
// Takes any pointSet source. The difference with a pointSet is
// - reads the cells from the pointZone, not the pointSet
// - write to the pointZone as well as the pointSet

pointZoneSet_doc
{
    // For backwards compatibility
    //- Select based on pointSet
    {
        source  setToPointZone;
        set     p0;           // name of pointSet
    }
}


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