openfoam/tutorials/mesh/cvMesh/simpleShapes/system/cvMeshDict

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

FoamFile
{
    version         2.0;
    format          ascii;
    class           dictionary;
    object          cvMeshDict;
}

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


/*

Control dictionary for cvMesh - polyhedral mesh generator.

cvMesh phases:
1. fill volume with initial points (initialPoints subdictionary). An option
   is to reread from previous set of points.

2. internal point motion (motionControl subdictionary)

3. every once in a while add point duplets/triplets to conform to
   surfaces and features (surfaceConformation subdictionary)

4. back to 2

5. construct polyMesh.
    - filter (polyMeshFiltering subdictionary)
    - check (meshQualityControls subdictionary) and undo filtering


See also cvControls.H in the conformalVoronoiMesh library

*/


// Important:
// ----------
// Any scalar with a name <name>Coeff specifies a value that will be implemented
// as a faction of the local target cell size
// Any scalar with a name <name>Size specifies an absolute size.


// Geometry. Definition of all surfaces. All surfaces are of class
// searchableSurface.
// Surfaces need to be (almost) closed - use closedTriSurfaceMesh
// if they are not topologically closed. Surfaces need to be oriented so
// the space to be meshed is always on the inside of all surfaces. Use e.g.
// surfaceOrient.
geometry
{
    // Internal shape
    coneAndSphere_clean_orient.obj
    {
        name coneAndSphere;
        type triSurfaceMesh;
    }

    // Outside of domain
    domain_clean_orient.stl
    {
        name domain;
        type triSurfaceMesh;
    }

}


// Controls for conforming to the surfaces.
surfaceConformation
{
    // A point inside surfaces that is inside mesh.
    locationInMesh (0 -0.5 0);

    // How far apart are point-duplets generated. Balance this between
    // - very low distance: little chance of interference from other
    //   surfaces
    // - largish distance: less non-orthogonality in final cell
    //   (circumcentre far away from centroid)
    pointPairDistanceCoeff      0.1;

    // Mixed feature edges - both inside and outside edges. Recreated
    // by inserting triplets of points to recreate a single edge. Done for
    // all edges emanating from point. triplets of points get inserted
    // mixedFeaturePointPPDistanceCoeff distance away from feature point.
    mixedFeaturePointPPDistanceCoeff    5.0;

    // Distance to a feature point within which surface and edge
    // conformation points are excluded - fraction of the local target
    // cell size
    featurePointExclusionDistanceCoeff  0.4;

    // Distance to an existing feature edge conformation location
    // within which other edge conformation location are excluded -
    // fraction of the local target cell size
    featureEdgeExclusionDistanceCoeff   0.2;

    // Optimisation: do not check for surface intersection (of dual edges)
    // for points near to surface.
    surfaceSearchDistanceCoeff  2.5;

    // Maximum allowable protrusion through the surface before
    // conformation points are added - fraction of the local target
    // cell size. These small protusions are (hopefully) done by mesh filtering
    // instead.
    maxSurfaceProtrusionCoeff   0.1;

    // If feature edge with large angle (so more than 125 degrees) introduce
    // additional points to create two half angled cells (= mitering).
    maxQuadAngle 125;

    // Frequency to redo surface conformation (expensive).
    surfaceConformationRebuildFrequency 10;

    // Initial and intermediate controls
    coarseConformationControls
    {
        // Initial conformation
        initial
        {
            // We've got a point poking through the surface. Don't do any
            // surface conformation if near feature edge (since feature edge
            // conformation should have priority)

            // distance to search for near feature edges
            edgeSearchDistCoeff         1.1;

            // Proximity to a feature edge where a surface hit is
            //  not created, only the edge conformation is created
            // - fraction of the local target cell size. Coarse
            // conformation, initial protrusion tests.
            surfacePtReplaceDistCoeff   0.5;
        }

        // Same for iterations
        iteration
        {
            edgeSearchDistCoeff         1.25;
            surfacePtReplaceDistCoeff   0.7;
        }

        // Stop either at maxIterations or if the number of surface pokes
        // is very small (iterationToInitialHitRatioLimit * initial number)
        // Note: perhaps iterationToInitialHitRatioLimit should be absolute
        // count?
        maxIterations 15;

        iterationToInitialHitRatioLimit 0.001;
    }

    // Final (at endTime) controls
    fineConformationControls
    {
        initial
        {
            edgeSearchDistCoeff         1.1;
            surfacePtReplaceDistCoeff   0.5;
        }

        iteration
        {
            edgeSearchDistCoeff         1.25;
            surfacePtReplaceDistCoeff   0.7;
        }

        maxIterations 15;

        iterationToInitialHitRatioLimit 0.001;
    }

    // Geometry to mesh to
    geometryToConformTo
    {
        coneAndSphere
        {
            featureMethod extendedFeatureEdgeMesh;
            extendedFeatureEdgeMesh "coneAndSphere_clean_orient.extendedFeatureEdgeMesh";
        }

        domain
        {
            featureMethod extendedFeatureEdgeMesh;
            extendedFeatureEdgeMesh "domain_clean_orient.extendedFeatureEdgeMesh";
        }
    }

    additionalFeatures {}
}


// Controls for seeding initial points and general control of the target
// cell size (used everywhere)
initialPoints
{
    // Do not place point closer than minimumSurfaceDistanceCoeff
    // to the surface. Is fraction of local target cell size (see below)
    minimumSurfaceDistanceCoeff 0.55;

    initialPointsMethod             autoDensity;
    // initialPointsMethod          uniformGrid;
    // initialPointsMethod          bodyCentredCubic;
    // initialPointsMethod          pointFile;

    // Take boundbox of all geometry. Samples with this box. If too much
    // samples (due to target cell size) in box split box.
    autoDensityCoeffs
    {
        // Initial number of refinement levels. Needs to be enough to pick
        // up features due to size ratio. If not enough it will take longer
        // to determine point seeding.
        minLevels 4;
        // Split box if ratio of min to max cell size larger than maxSizeRatio
        maxSizeRatio 5.0;
        // Per box sample 3x3x3 internally
        sampleResolution 3;
        // Additionally per face of the box sample 3
        surfaceSampleResolution 3;
    }

    uniformGridCoeffs
    {
        // Absolute cell size.
        initialCellSize         0.0015;
        randomiseInitialGrid    yes;
        randomPerturbationCoeff 0.02;
    }

    bodyCentredCubicCoeffs
    {
        initialCellSize         0.0015;
        randomiseInitialGrid    no;
        randomPerturbationCoeff 0.1;
    }

    pointFileCoeffs
    {
        // Reads points from file. Still rejects points that are too
        // close to the surface (minimumSurfaceDistanceCoeff) or on the
        // wrong side of the surfaces.
        pointFile              "constant/internalDelaunayVertices";
    }
}


// Control size of voronoi cells i.e. distance between points. This
// determines the target cell size which is used everywhere.
// It determines the cell size given a location. It then uses all
// the rules
// - defaultCellSize
// - cellSizeControlGeometry
// to determine target cell size. Rule with highest priority wins. If same
// priority smallest cell size wins.
motionControl
{
    // Absolute cell size of back ground mesh. This is the maximum cell size.
    defaultCellSize     0.1;

    // Assign a priority to all requests for cell sizes, the highest overrules.
    defaultPriority     0;

    cellSizeControlGeometry
    {
    }

    // Underrelaxation for point motion. Simulated annealing: starts off at 1
    // and lowers to 0 (at simulation endTime) to converge points.
    // adaptiveLinear is preferred choice.
    // Points move by e.g. 10% of tet size.
    relaxationModel     adaptiveLinear; //rampHoldFall

    adaptiveLinearCoeffs
    {
        relaxationStart 1.0;
        relaxationEnd   0.0;
    }

    // Output lots and lots of .obj files
    objOutput                   no;

    // Timing and memory usage.
    timeChecks                  yes;

    // Number of rays in plane parallel to nearest surface. Used to detect
    // next closest surfaces. Used to work out alignment (three vectors)
    // to surface.
    // Note that only the initial points (from the seeding) calculate this
    // information so if these are not fine enough the alignment will
    // not be correct. (any points added during the running will lookup
    // this information from the nearest initial point since it is
    // expensive)
    alignmentSearchSpokes       36;

    // For each delaunay edge (between two vertices, becomes
    // the Voronoi face normal) snap to the alignment direction if within
    // alignmentAcceptanceAngle. Slightly > 45 is a good choice - prevents
    // flipping.
    alignmentAcceptanceAngle    48;

    // How often to rebuild the alignment info (expensive)
    sizeAndAlignmentRebuildFrequency 20;

    // When to insert points. Not advisable change to
    // these settings.
    pointInsertionCriteria
    {
        // If edge larger than 1.75 target cell size
        // (so tets too large/stretched) insert point
        cellCentreDistCoeff     1.75;
        // Do not insert point if voronoi face (on edge) very small.
        faceAreaRatioCoeff      0.0025;
        // Insert point only if edge closely aligned to local alignment
        // direction.
        acceptanceAngle         21.5;
    }

    // Opposite: remove point if mesh too compressed. Do not change these
    // settings.
    pointRemovalCriteria
    {
        cellCentreDistCoeff  0.65;
    }

    // How to determine the point motion. All edges got some direction.
    // Sum all edge contributions to determine point motion. Weigh by
    // face area so motion is preferentially determined by large faces
    // (or more importantly ignore contribution from small faces).
    // Do not change these settings.
    faceAreaWeightModel piecewiseLinearRamp;

    piecewiseLinearRampCoeffs
    {
        lowerAreaFraction       0.5;
        upperAreaFraction       1.0;
    }
}


// After simulation, when converting to polyMesh, filter out small faces/edges.
// Do not change. See cvControls.H
polyMeshFiltering
{
    // Upper limit on the size of faces to be filtered.
    // fraction of the local target cell size
    filterSizeCoeff                         0.2;

    // Upper limit on how close two dual vertices can be before
    // being merged, fraction of the local target cell size
    mergeClosenessCoeff                     1e-9;

    // To not filter: set maxNonOrtho to 1 (so check fails) and then
    // set continueFilteringOnBadInitialPolyMesh to false.
    continueFilteringOnBadInitialPolyMesh   true;

    // When a face is "bad", what fraction should the filterSizeCoeff be
    // reduced by.  Recursive, so for a filterCount value of fC, the
    // filterSizeCoeff is reduced by pow(filterErrorReductionCoeff, fC)
    filterErrorReductionCoeff               0.5;

    // Maximum number of filterCount applications before a face
    // is not attempted to be filtered
    filterCountSkipThreshold                4;

    // Maximum number of permissible iterations of the face collapse
    // algorithm.  The value to choose will be related the maximum number
    // of points on a face that is to be collapsed and how many faces
    // around it need to be collapsed.
    maxCollapseIterations                   25;

    // Maximum number of times an to allow an equal faceSet to be
    // returned from the face quality assessment before stopping iterations
    // to break an infinitie loop.
    maxConsecutiveEqualFaceSets             5;
    // Remove little steps (almost perp to surface) by collapsing face.
    surfaceStepFaceAngle                    80;
    // Do not collapse face to edge if should become edges
    edgeCollapseGuardFraction               0.3;
    // Only collapse face to point if high aspect ratio
    maxCollapseFaceToPointSideLengthCoeff   0.35;
}


// Generic mesh quality settings. At any undoable phase these determine
// where to undo. Same as in snappyHexMeshDict
meshQualityControls
{
    //- Maximum non-orthogonality allowed. Set to 180 to disable.
    maxNonOrtho 65;

    //- Max skewness allowed. Set to <0 to disable.
    maxBoundarySkewness 50;
    maxInternalSkewness 10;

    //- Max concaveness allowed. Is angle (in degrees) below which concavity
    //  is allowed. 0 is straight face, <0 would be convex face.
    //  Set to 180 to disable.
    maxConcave 80;

    //- Minimum pyramid volume. Is absolute volume of cell pyramid.
    //  Set to a sensible fraction of the smallest cell volume expected.
    //  Set to very negative number (e.g. -1E30) to disable.
    minVol -1E30;

    //- Minimum quality of the tet formed by the
    //  variable base point minimum decomposition triangles and
    //  the cell centre (so not face-centre decomposition).
    //  This has to be a positive number for tracking
    //  to work. Set to very negative number (e.g. -1E30) to
    //  disable.
    //     <0 = inside out tet,
    //      0 = flat tet
    //      1 = regular tet
    minTetQuality 1e-30;

    //- Minimum absolute face area. Set to <0 to disable.
    minArea -1;

    //- Minimum face twist. Set to <-1 to disable. dot product of face normal
    //- and face centre triangles normal
    minTwist 0.001;

    //- minimum normalised cell determinant
    //- 1 = hex, <= 0 = folded or flattened illegal cell
    minDeterminant 0.001;

    //- minFaceWeight (0 -> 0.5)
    minFaceWeight 0.02;

    //- minVolRatio (0 -> 1)
    minVolRatio 0.01;

    //must be >0 for Fluent compatibility
    minTriangleTwist -1;
}


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