openfoam/applications/utilities/postProcessing/sampling/sample/sampleDict

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

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

// Surface output format. Choice of
//      null        : suppress output
//      ensight     : Ensight Gold format, one field per case file
//      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'.
//      boundaryData: written in a form that can be used with timeVaryingMapped
//                    boundary conditions (move to constant/boundaryData)
//      starcd      : Star-CD format (geometry in .cel/.vrt, data in .usr)
//      nastran     : Nastran (.nas) format
//
// Note:
// - other formats such as obj, stl, etc can also be written (by proxy)
//   but without any values!
// - boundaryData format: typical use:
//      - use a surfaces functionObject to sample a patch:
//            type            surfaces;
//            surfaceFormat   boundaryData;
//            fields          ( p );
//            surfaces
//            (
//                inlet
//                {
//                    type            patch;
//                    patches         (inpletPatch);
//                    interpolate     false;
//                }
//            );
//      - the boundaryData writer will write postProcessing/surfaces/inlet/
//      - move this to constant/boundaryData/inlet of the destination case
//      - use a timeVaryingMappedFixedValue bc to read&interpolate and use
//        as fixedValue.
// - boundaryData: 'interpolate false' writes face centres, 'interpolate true'
//   writes points. For 2D case the face centres might only be a single column
//   so cannot be used in timeVaryingMapped with standard mapping (since
//   uses triangulation to do interpolation).

surfaceFormat vtk;

// Optionally define extra controls for the output formats
formatOptions
{
    ensight
    {
        // ascii/binary format
        format  ascii;
        //collateTimes true;  // write single file containing multiple timesteps
                              // (only for static surfaces)
    }
    nastran
    {
        // From OpenFOAM field name to Nastran field name
        fields
        (
            (U      PLOAD4)
            (p      PLOAD2)
        );
        // Optional scale
        scale 1.0;
        // Optional format
        // short/long/free format
        // short: scalar field width 8. default.
        // long : scalar field width 16
        // free : comma separated, field width according to writePrecision
        //        setting
        format  short;      // short/long/free
    }
}

// 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.
//      pointMVC      : use point values only (Mean Value Coordinates)
//      cellPatchConstrained : like 'cell' but uses cell-centre except on
//                             boundary faces where it uses the boundary value.
//                             For use with e.g. patchCloudSet.
// 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
//
//      polyLine            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
//      polyLine, cloud: list of coordinates
//      patchCloud: list of coordinates and set of patches to look for nearest
//      patchSeed: random sampling on set of patches. Points slightly off
//                 face centre.
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;

        //- cavity
        start       (0.0001 0.0525 0.00501);
        end         (0.0999 0.0525 0.00501);
    }

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

    somePatchPoints
    {
        // Sample nearest points on selected patches. Looks only up to
        // maxDistance away. Any sampling point not found will get value
        // pTraits<Type>::max (usually VGREAT)
        // Use with interpolations:
        // - cell (cell value)
        // - cellPatchConstrained (boundary value)
        // - cellPoint (interpolated boundary value)
        type        patchCloud;
        axis        xyz;
        points      ((0.049 0.099 0.005)(0.051 0.054 0.005));
        maxDistance 0.1;    // maximum distance to search
        patches     (".*Wall.*");
    }

    patchSeed
    {
        type        patchSeed;
        axis        xyz;
        patches     (".*Wall.*");

        // Subset patch faces by:

        // 1. Number of points to seed. Divided amongst all processors
        //   according to fraction of patches they hold.
        maxPoints   100;

        // 2. Specified set of locations. This selects for every the specified
        //    point the nearest patch face. (in addition the number of points
        //    is also truncated by the maxPoints setting)
        //    The difference with patchCloud is that this selects patch
        //    face centres, not an arbitrary location on the face.
        points   ((0.049 0.099 0.005)(0.051 0.054 0.005));
    }

);


// 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
        // zone        zone1;

        //- Optional: do not triangulate (only for surfaceFormats that support
        //            polygons)
        //triangulate     false;
    }

    interpolatedPlane
    {
        type            plane;    // always triangulated

        // Make plane relative to the coordinateSystem (Cartesian)
        coordinateSystem
        {
            origin      (0.0501 0.0501 0.005);

            // Add a coordinate rotation
            // (required, so here one that doesn't change anything)
            coordinateRotation
            {
                type    axesRotation;
                e1      (1 0 0);
                e2      (0 1 0);
            }
        }
        basePoint       (0 0 0);
        normalVector    (0.1 0.1 1);
        interpolate     true;
    }

    walls_constant
    {
        type            patch;
        patches         ( ".*Wall.*" );
        // Optional: whether to leave as faces (=default) or triangulate
        // triangulate     false;
    }

    walls_interpolated
    {
        type            patch;
        patches         ( ".*Wall.*" );
        interpolate     true;
        // Optional: whether to leave as faces (=default) or triangulate
        // triangulate     false;
    }

    nearWalls_interpolated
    {
        // Sample cell values off patch. Does not need to be the near-wall
        // cell, can be arbitrarily far away.
        type            patchInternalField;
        patches         ( ".*Wall.*" );
        interpolate     true;


        // Optional: specify how to obtain sampling points from the patch
        //           face centres (default is 'normal')
        //
        //  //- Specify distance to offset in normal direction
        offsetMode  normal;
        distance    0.1;
        //
        //  //- Specify single uniform offset
        //  offsetMode  uniform;
        //  offset      (0 0 0.0001);
        //
        //  //- Specify offset per patch face
        //  offsetMode  nonuniform;
        //  offsets     ((0 0 0.0001) (0 0 0.0002));


        // 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

        // bounds       (1 1 1)(2 2 2); // Optional: limit extent

        // regularise      false;    // Optional: do not simplify
        // mergeTol        1e-10;    // Optional: fraction of mesh bounding box
                                     // to merge points (default=1e-6)
    }
    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

        // bounds       (1 1 1)(2 2 2); // Optional: limit extent

        // mergeTol        1e-10;    // Optional: fraction of mesh bounding box
                                     // to merge points (default=1e-6)
    }

    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

        // bounds       (1 1 1)(2 2 2); // Optional: limit extent

        // regularise      false;    // Optional: do not simplify
        // mergeTol        1e-10;    // Optional: fraction of mesh bounding box
                                     // to merge points (default=1e-6)
    }

    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;

        //cell            false;// optional: use isoSurface instead
                                // of isoSurfaceCell
        interpolate     false;
        regularise      false;  // Optional: do not simplify
        // bounds       (1 1 1)(2 2 2); // Optional: limit extent

        // mergeTol 1e-10;      // Optional: fraction of mesh bounding box
                                // to merge points (default=1e-6)
    }

    triSurfaceSampling
    {
        // Sampling on triSurface
        type        sampledTriSurfaceMesh;
        surface     integrationPlane.stl;
        source      boundaryFaces;  // What to sample: cells (nearest cell)
                                    // insideCells (only triangles inside cell)
                                    // boundaryFaces (nearest boundary face)
        interpolate true;
    }
);


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