changed dictionary

applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C

@@ -34,9 +34,6 @@ Description
 #include "Time.H"
 #include "fvMesh.H"
 #include "autoHexMeshDriver.H"
-#include "pointMesh.H"
-#include "motionSmoother.H"
-#include "mapDistributePolyMesh.H"
 
 using namespace Foam;
 
@@ -52,6 +49,18 @@ int main(int argc, char *argv[])
     Info<< "Read mesh in = "
         << runTime.cpuTimeIncrement() << " s" << endl;
 
+    // Read decomposePar dictionary
+    IOdictionary decomposeDict
+    (
+        IOobject
+        (
+            "decomposeParDict",
+            runTime.system(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        )
+    );
 
     // Read meshing dictionary
     IOdictionary meshDict
@@ -66,24 +75,46 @@ int main(int argc, char *argv[])
        )
     );
 
-    // Read decomposePar dictionary
-    IOdictionary decomposeDict
+    // refinement parameters
+    const dictionary& refineDict = meshDict.subDict("refineDict");
+
+    // snap-to-surface parameters
+    const dictionary& snapDict = meshDict.subDict("snapDict");
+
+    // mesh motion and mesh quality parameters
+    const dictionary& motionDict = meshDict.subDict("motionDict");
+
+    // layer addition parameters
+    const dictionary& layerDict = meshDict.subDict("layerDict");
+
+
+    // Main meshing driver. Read surfaces. Determine initial intersections.
+    autoHexMeshDriver meshEngine
     (
-        IOobject
-        (
-            "decomposeParDict",
-            runTime.system(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::NO_WRITE
-        )
+        mesh,
+        meshDict,       // global control parameters
+        refineDict,     // refinement parameters
+        decomposeDict
     );
 
-    // Main meshing driver. Read surfaces. Determine intersections.
-    autoHexMeshDriver meshEngine(mesh, meshDict, decomposeDict);
+    Switch wantRefine(meshDict.lookup("doRefine"));
+    Switch wantSnap(meshDict.lookup("doSnap"));
+    Switch wantLayers(meshDict.lookup("doLayers"));
 
-    // Do all: refine, snap, add layers
-    meshEngine.doMesh();
+    if (wantRefine)
+    {
+        meshEngine.doRefine(refineDict, wantSnap);
+    }
+
+    if (wantSnap)
+    {
+        meshEngine.doSnap(snapDict, motionDict);
+    }
+
+    if (wantLayers)
+    {
+        meshEngine.doLayers(layerDict, motionDict);
+    }
 
     Info<< "Finished meshing in = "
         << runTime.elapsedCpuTime() << " s." << endl;

applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict

@@ -0,0 +1,314 @@
+/*---------------------------------------------------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  1.0                                   |
+|   \\  /    A nd           | Web:      http://www.openfoam.org               |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+
+FoamFile
+{
+    version         2.0;
+    format          ascii;
+
+    root            "/home/penfold/mattijs/foam/mattijs2.1/run/icoFoam";
+    case            "cavity";
+    instance        "system";
+    local           "";
+
+    class           dictionary;
+    object          autoHexMeshDict;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Which phases to run.
+doRefine true;
+doSnap   true;
+doLayers true; // includes autoMergeFaces
+
+
+// Whether to dump intermediate meshes and print lots
+// 1 : write mesh
+// 2 : write volScalarField with cellLevel for postprocessing
+// 4 : write current intersections as .obj files
+debug 0;
+
+refineDict
+{
+    // Which part to keep.
+    // NOTE: This point should never be on a face, always inside a cell, even
+    // after refinement.
+    keepPoints ((3 0.28 0.43));
+
+    // Whether to remove/split cells likely to give problems when snapping
+    handleSnapProblems on;
+
+    // Merge tolerance. Is fraction of overall bounding box of initial mesh
+    mergeTolerance 1E-6;
+
+    // While refining maximum number of cells per processor. This is basically
+    // the number of cells that fit on a processor. If you choose this too small
+    // it will do just more refinement iterations to obtain a similar mesh.
+    procCellLimit 1000000;
+
+
+    // Overall cell limit (approximately). Refinement will stop immediately
+    // upon reaching this number so a refinement level might not complete.
+    // Note that this is the number of cells before removing the part which
+    // is not 'visible' from the keepPoint. The final number of cells might actually
+    // be a lot less.
+    cellLimit 2000000;
+
+
+    // The surface refinement loop might spend lots of iterations refining just a
+    // few cells. This setting will cause refinement to stop if <= minimumRefine
+    // are selected for refinement. Note: it will at least do one iteration
+    // (unless the number of cells to refine is 0)
+    minimumRefine 0;
+
+
+
+
+    // Number of buffer layers between different levels.
+    // 1 means normal 2:1 refinement restriction, larger means slower
+    // refinement.
+    nBufferLayers 1;
+
+
+    // Feature Edge Refinement
+    // ~~~~~~~~~~~~~~~~~~~~~~~
+
+    // External feature file. Read from constant/triSurface for now.
+    // Limitations:
+    // - either start or edge of any feature line has to be inside domain
+    //   and be visible from keepPoint on starting mesh.
+    // - refining cells containing features is separate phase before refining
+    //   based on surface.
+    // - no load balancing, no check for cellLimit is done while doing this.
+    features
+    (
+    //    {
+    //        file "someLine.eMesh";
+    //        level 2;
+    //    }
+    );
+
+
+    // Internal Mesh Refinement
+    // ~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Specifies the areas where the refinement has to be a certain level.
+    // These surfaces have to be closed. Refinement is either inside
+    // (refineInside = true) or outside. (note:insideness or outsideness
+    // is with respect to far away)
+    // Note:that even using these the transition can never be faster than
+    // nBufferLayers!
+    // Note:the refinement level can never be higher than any of the surfaces
+    // they overlap with. See below for the surface refinement level specification.
+    refinementShells
+    (
+        {
+            //type triSurfaceMesh;
+            //name cube1x1x1.stl;
+            type searchableBox;
+            name box1x1x1;
+            min (2.5 -0.5 -0.5);
+            max (3.5 0.5 0.5);
+
+            level 4;
+            refineInside true;
+        }
+    );
+
+
+    // Surface based refinement
+    // ~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Curvature. Cosine of angle between two neighbouring surface intersections.
+    // Only used if cell level > minLevel and < maxLevel.
+    curvature 0.5;
+
+
+    // Overall the refinement is according to the following rules:
+    // - if the cell-cell vector intersects a surface any cell that
+    //   is less refined than the minRefinementLevel of the surface gets refined.
+    // - else if the refinement level of the cell is between the
+    //   minRefinementLevel and maxRefinementLevel the cell gets refined if
+    //      - the normal of neighbouring surface intersections differ by more
+    //        than above curvature
+    //      - or if neighbouring surface intersections are on different surfaces or
+    //        different surface regions.
+
+
+    // surfaces
+    surfaces
+    (
+        {
+            name    sphere;
+            file    "sphere.stl";
+
+            // Surface wide refinement level
+            minRefinementLevel 1;
+            maxRefinementLevel 1;
+
+            // Layers
+            surfaceLayers 1;
+
+            // Region specific refinement level
+            regions
+            (
+                {
+                    name firstSolid;
+                    minRefinementLevel 3;
+                    maxRefinementLevel 3;
+                    surfaceLayers 2;
+                }
+                {
+                    name secondSolid;
+                    minRefinementLevel 1;
+                    maxRefinementLevel 1;
+                    surfaceLayers 1;
+                }
+            );
+        }
+    );
+}
+
+// For snapping
+snapDict
+{
+    //- Number of patch smoothing iterations before finding correspondence
+    //  to surface
+    nSmoothPatch 3;
+
+    //- Relative distance for points to be attracted by surface feature point
+    //  or edge. True distance is this factor times local
+    //  maximum edge length.
+    snapTol 4.0;
+
+    //- Whether to move internal mesh as well as boundary
+    smoothMesh true;
+
+    //- Number of mesh displacement smoothing iterations.
+    nSmoothDispl 30;
+
+    //- Maximum number of snapping relaxation iterations. Should stop
+    //  before upon reaching a correct mesh.
+    nSnap 5;
+}
+
+
+// For cell layers
+layerDict
+{
+    //- When not to extrude surface. 0 is flat surface, 90 is when two faces
+    //  make straight angle.
+    featureAngle 60;
+
+    //- Maximum number of snapping relaxation iterations. Should stop
+    //  before upon reaching a correct mesh.
+    nSnap 5;
+
+
+    //- Minimum thickness of cell layer. If for any reason layer cannot be
+    //  above minThickness do not add layer if thickness below minThickNess.
+    //  Relative to undistorted cell size
+    minThickness 0.25;
+
+    //- If points get not extruded do nGrow layers of connected faces that are
+    //  not grown. Is used to not do layers at all close to features.
+    nGrow 1;
+
+    // Expansion factor for layer mesh
+    expansionRatio 1.3;	
+
+    // Ratio of cell size in final added cell layer to cell size 
+    // outside layer 
+    finalLayerRatio 0.3;
+
+    // Number of smoothing iterations of surface normals 
+    nSmoothSurfaceNormals 1;
+
+    // Number of smoothing iterations of interior mesh movement direction  
+    nSmoothNormals 3;
+
+    // Smooth layer thickness over surface patches
+    nSmoothThickness 10;
+
+    // Stop layer growth on highly warped cells 
+    maxFaceThicknessRatio 0.5;
+
+    // Reduce layer growth where ratio thickness to medial 
+    // distance is large 
+    maxThicknessToMedialRatio 0.3;
+
+    // Angle used to pick up medial axis points
+    minMedianAxisAngle 130;
+
+    // Create buffer region for new layer terminations
+    nBufferCellsNoExtrude 0;
+
+    thickness 0.5;
+    nSmoothDispl 4;
+}
+
+
+// For mesh motion
+motionDict
+{
+    //
+    // Mesh Quality Parameters. Decide when mesh is good enough to stop
+    // smoothing.
+    //
+
+    //- Maximum non-orthogonality allowed. Set to 180 to disable.
+    maxNonOrtho 65;
+
+    //- Max skewness allowed. Set to <0 to disable.
+    maxBoundarySkewness 20;
+    maxInternalSkewness 4;
+
+    //- 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 projected area v.s. actual area. Set to -1 to disable.
+    minFlatness 0.5;
+
+    //- Minimum pyramid volume. Is absolute volume of cell pyramid.
+    //  Set to very negative number (e.g. -1E30) to disable.
+    minVol 1e-13;
+
+    //- Minimum 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.05;
+
+    //- minimum normalised cell determinant
+    //- 1 = hex, <= 0 = folded or flattened illegal cell
+    minDeterminant 0.001;
+
+    //- minFaceWeight (0 -> 0.5) 
+    minFaceWeight 0.05;
+
+    //- minVolRatio (0 -> 1)
+    minVolRatio 0.01;
+
+
+    //must be >0 for Fluent compatibility
+    minTriangleTwist -1;
+
+    // Advanced
+
+    //- Number of error distribution iterations
+    nSmoothScale 4;
+    //- amount to scale back displacement at error points
+    errorReduction 0.75;
+}
+
+
+// ************************************************************************* //