sampleDict

/*--------------------------------*- C++ -*----------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  1.6                                   |
|   \\  /    A nd           | Web:      http://www.OpenFOAM.org               |
|    \\/     M anipulation  |                                                 |
\*---------------------------------------------------------------------------*/

FoamFile
{
    version         2.0;
    format          ascii;
    class           dictionary;
    location        system;
    object          sampleDict;
}

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

// Set output format : choice of
//      xmgr
//      jplot
//      gnuplot
//      raw
//      vtk
setFormat raw;

// Surface output format. Choice of
//      null        : suppress output
//      foamFile    : separate points, faces and values file
//      dx          : DX scalar or vector format
//      vtk         : VTK ascii format
//      raw         : x y z value format for use with e.g. gnuplot 'splot'.
//
// Note:
// other formats such as obj, stl, etc can also be written (by proxy)
// but without any values!
surfaceFormat vtk;

// interpolationScheme. choice of
//      cell          : use cell-centre value only; constant over cells (default)
//      cellPoint     : use cell-centre and vertex values
//      cellPointFace : use cell-centre, vertex and face values.
// 1] vertex values determined from neighbouring cell-centre values
// 2] face values determined using the current face interpolation scheme
//    for the field (linear, gamma, etc.)
interpolationScheme cellPoint;

// Fields to sample.
fields
(
    p
    U
);


// Set sampling definition: choice of
//      uniform             evenly distributed points on line
//      face                one point per face intersection
//      midPoint            one point per cell, inbetween two face intersections
//      midPointAndFace     combination of face and midPoint
//
//      curve               specified points, not nessecary on line, uses
//                          tracking
//      cloud               specified points, uses findCell
//      triSurfaceMeshPointSet  points of triSurface
//
// axis: how to write point coordinate. Choice of
// - x/y/z: x/y/z coordinate only
// - xyz: three columns
//  (probably does not make sense for anything but raw)
// - distance: distance from start of sampling line (if uses line) or
//             distance from first specified sampling point
//
// type specific:
//      uniform, face, midPoint, midPointAndFace : start and end coordinate
//      uniform: extra number of sampling points
//      curve, cloud: list of coordinates
sets
(
    lineX1
    {
        type        uniform;
        axis        distance;

        //- cavity. Slightly perturbed so not to align with face or edge.
        start       (0.0201 0.05101 0.00501);
        end         (0.0601 0.05101 0.00501);
        nPoints     10;
    }

    lineX2
    {
        type        face;
        axis        x;

        //- flangeHex
        //start       (0 20  -20);
        //end         (0 20   10);

        //- nablaCavity
        //start       (-1 0.05 0.005);
        //end         ( 1 0.05 0.005);

        //- cavity
        start       (0.001 0.5101  0.00501);
        end         (2.01 0.5101  0.00501);
        nPoints     10;
    }

    somePoints
    {
        type    cloud;
        axis    xyz;
        points  ((0.049 0.049 0.00501)(0.051 0.049 0.00501));
    }

);


// Surface sampling definition
//
// 1] patches are not triangulated by default
// 2] planes are always triangulated
// 3] iso-surfaces are always triangulated
surfaces
(
    constantPlane
    {
        type            plane;    // always triangulated
        basePoint       (0.0501 0.0501 0.005);
        normalVector    (0.1 0.1 1);

        //- Optional: restrict to a particular zone
        // zoneName        zone1;
    }

    interpolatedPlane
    {
        type            plane;    // always triangulated
        // make plane relative to the coordinateSystem (Cartesian)
        coordinateSystem
        {
            origin      (0.0501 0.0501 0.005);
        }
        basePoint       (0 0 0);
        normalVector    (0.1 0.1 1);
        interpolate     true;
    }

    movingWall_constant
    {
        type            patch;
        patchName       movingWall;
        // Optional: whether to leave as faces (=default) or triangulate
        // triangulate     false;
    }

    movingWall_interpolated
    {
        type            patch;
        patchName       movingWall;
        interpolate     true;
        // Optional: whether to leave as faces (=default) or triangulate
        // triangulate     false;
    }

    interpolatedIso
    {
        // Iso surface for interpolated values only
        type            isoSurface;    // always triangulated
        isoField        rho;
        isoValue        0.5;
        interpolate     true;

        //zone            ABC;          // Optional: zone only
        //exposedPatchName fixedWalls;  // Optional: zone only

        // regularise      false;    // Optional: do not simplify
    }
    constantIso
    {
        // Iso surface for constant values.
        // Triangles guaranteed not to cross cells.
        type            isoSurfaceCell;    // always triangulated
        isoField        rho;
        isoValue        0.5;
        interpolate     false;
        regularise      false;              // do not simplify
    }

    triangleCut
    {
        // Cutingplane using iso surface
        type            cuttingPlane;
        planeType       pointAndNormal;
        pointAndNormalDict
        {
            basePoint       (0.4 0 0.4);
            normalVector    (1 0.2 0.2);
        }
        interpolate     true;

        //zone            ABC;          // Optional: zone only
        //exposedPatchName fixedWalls;  // Optional: zone only

        // regularise      false;    // Optional: do not simplify
    }

    distance
    {
        // Isosurface from signed/unsigned distance to surface
        type            distanceSurface;
        signed          true;

        // Definition of surface
        surfaceType     triSurfaceMesh;
        surfaceName     integrationPlane.stl;
        // Distance to surface
        distance        0.0;

        interpolate     false;
    }

    triSurfaceSampling
    {
        // Sampling on triSurface
        type        sampledTriSurfaceMesh;
        surface     integrationPlane.stl;
        interpolate true;
    }
);


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