[Wolfram]

Hi,

I am trying to mesh a pretty simple propeller. Here you can see the geometry already snapped.
Screenshot 2022-09-18 155759.jpg


Everything looks fine unless the layers.

The layer creation always collapses when a reasonable value for "minTetQuality" in the meshQualityDict is applied. It collapses even for 1e-30 for example.

All layers are created, when "minTetQuality" is set to "-1", but with this mesh "mapFields" and so on does not work and an error message like "no base point for face ..." occurs.

Here you can see the collapsed layers:
Screenshot 2022-09-18 155912.jpg


I am playing for days now with all parameters before asking you for any advice.

Here are my current sHM settings.

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

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

// Which of the steps to run
castellatedMesh true;
snap            true;
addLayers       true;


// Geometry. Definition of all surfaces. All surfaces are of class
// searchableSurface.
// Surfaces are used
// - to specify refinement for any mesh cell intersecting it
// - to specify refinement for any mesh cell inside/outside/near
// - to 'snap' the mesh boundary to the surface
geometry
{
    AMI.stl
    {
        type	    triSurfaceMesh;
        name	    AMI;
    }

    regions.stl
    {
        type        triSurfaceMesh;
        name regionss;
        regions
        {
            inlet           { name inlet; }
            outlet          { name outlet; }
            wall            { name wall; }
            propeller_1     { name propeller_1; }
            propeller_2     { name propeller_2; }
            obstacle        { name obstacle; }
        }
    }
}


// Settings for the castellatedMesh generation.
castellatedMeshControls
{

    // Refinement parameters
    // ~~~~~~~~~~~~~~~~~~~~~

    // If local number of cells is >= maxLocalCells on any processor
    // switches from from refinement followed by balancing
    // (current method) to (weighted) balancing before refinement.
    maxLocalCells 10000000;

    // 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.
    maxGlobalCells 200000000;

    // 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)
    minRefinementCells 0;

    // Number of buffer layers between different levels.
    // 1 means normal 2:1 refinement restriction, larger means slower
    // refinement.
    nCellsBetweenLevels 3;



    // Explicit feature edge refinement
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    // Specifies a level for any cell intersected by its edges.
    // This is a featureEdgeMesh, read from constant/triSurface for now.
    features
    (
        {
            file "AMI.eMesh";
            level 0;
        }
        {
            file "propeller_1.eMesh";
            level 0;
        }
        {
            file "inlet.eMesh";
            level 0;
        }
        {
            file "outlet.eMesh";
            level 0;
        }
        {
            file "obstacle.eMesh";
            level 0;
        }
    );



    // Surface based refinement
    // ~~~~~~~~~~~~~~~~~~~~~~~~

    // Specifies two levels for every surface. The first is the minimum level,
    // every cell intersecting a surface gets refined up to the minimum level.
    // The second level is the maximum level. Cells that 'see' multiple
    // intersections where the intersections make an
    // angle > resolveFeatureAngle get refined up to the maximum level.

    refinementSurfaces
    {
                          /* part from Holzmann
                          AMI
                          {
                              level       (3 5);
                              faceZone    rotatingZone;
                              cellZone    rotatingZone;
                              cellZoneInside  inside;
                          }*/
        AMI
        {
            level       (2 3);

            // How to handle faceZones
            //  a. no faceZone. No keyword 'faceZone' or 'faceZoneNaming'
            //  b. single user-specified faceZone:
            //      faceZone myZone;
            //  c. faceZones according to the surface/region:
            //      faceZoneNaming region;

            // c. faceZones according to the surface/region
            faceZone AMI1; //name of the faceZone ... the name of the boundary is set under geometry above
            faceType baffle;
            cellZone    cellMRFzone;
            cellZoneInside  inside;
        }


        regionss
        {
            level       (0 0);
            //patchInfo   { type wall; }
            inGroups    (regionss);

            // Override per-patch information
            regions //this is not the name of any own file. This "regions" is part of the synthax
            {
                inlet
                {
                    level (1 2);
                    patchInfo { type patch; }
                }

                outlet
                {
                    level (1 2);
                    patchInfo { type patch; }
                }

                wall
                {
                    level (1 2);
                    patchInfo { type wall; }
                }
                obstacle
                {
                    level (3 3);
                    patchInfo { type wall; }
                }

                propeller_1
                {
                    level (5 5); //(6 7)
                    patchInfo { type wall; }
                }
                propeller_2
                {
                    level (5 5); //(6 7)
                    patchInfo { type wall; }
                }


            }
        }



    }

    // Resolve sharp angles
    resolveFeatureAngle 5; //30


    // Region-wise refinement
    // ~~~~~~~~~~~~~~~~~~~~~~

    // Specifies refinement level for cells in relation to a surface. One of
    // three modes
    // - distance. 'levels' specifies per distance to the surface the
    //   wanted refinement level. The distances need to be specified in
    //   descending order.
    // - inside. 'levels' is only one entry and only the level is used. All
    //   cells inside the surface get refined up to the level. The surface
    //   needs to be closed for this to be possible.
    // - outside. Same but cells outside.

    refinementRegions
    {
        //refinementBox
        //{
        //    mode inside;
        //    levels ((1E15 4));
        //}

        AMI
        {
            levels ((3 3));
            mode inside;
        }
    }


    // Mesh selection
    // ~~~~~~~~~~~~~~

    // After refinement patches get added for all refinementSurfaces and
    // all cells intersecting the surfaces get put into these patches. The
    // section reachable from the locationInMesh is kept.
    // NOTE: This point should never be on a face, always inside a cell, even
    // after refinement.
    locationInMesh (1e-5 -1e-2 -0.025);


    // Whether any faceZones (as specified in the refinementSurfaces)
    // are only on the boundary of corresponding cellZones or also allow
    // free-standing zone faces. Not used if there are no faceZones.
    allowFreeStandingZoneFaces true;
}



// Settings for the snapping.
snapControls
{
    //- Number of patch smoothing iterations before finding correspondence
    //  to surface
    nSmoothPatch 5;

    //- Relative distance for points to be attracted by surface feature point
    //  or edge. True distance is this factor times local
    //  maximum edge length.
    tolerance 3;

    //- Number of mesh displacement relaxation iterations.
    nSolveIter 100;

    //- Maximum number of snapping relaxation iterations. Should stop
    //  before upon reaching a correct mesh.
    nRelaxIter 20;

    //- Highly experimental and wip: number of feature edge snapping
    //  iterations. Leave out altogether to disable.
    //  Of limited use in this case since faceZone faces not handled.
    nFeatureSnapIter 30; //(5)

    implicitFeatureSnap false;
    explicitFeatureSnap true;

    //- Detect features between multiple surfaces
    //  (only for explicitFeatureSnap, default = false)
    multiRegionFeatureSnap true;
}



// Settings for the layer addition.
addLayersControls
{
    relativeSizes false;

    // Per final patch (so not geometry!) the layer information
    layers
    {
        propeller_1
        {
            nSurfaceLayers 10;
            thickness 0.0005;
            expansionRatio 1.2;
        }
        propeller_2
        {
            nSurfaceLayers 10;
            thickness 0.0005;
            expansionRatio 1.2;
        }
        wall
        {
            nSurfaceLayers 10;
            thickness 0.003;
            expansionRatio 1.2;
        }
        obstacle
        {
            nSurfaceLayers 10;
            thickness 0.003;
            expansionRatio 1.2;
        }
    }

    thickness 0.001;

    // Expansion factor for layer mesh
    expansionRatio 1.2;

      // Wanted thickness of final added cell layer. If multiple layers
      // is the thickness of the layer furthest away from the wall.
      // Relative to undistorted size of cell outside layer.
      // See relativeSizes parameter.
    //finalLayerThickness 0.5;

      // Minimum thickness of cell layer. If for any reason layer
      // cannot be above minThickness do not add layer.
      // Relative to undistorted size of cell outside layer.
    minThickness 0.0000001;

    // If points get not extruded do nGrow layers of connected faces that are
    // also not grown. This helps convergence of the layer addition process
    // close to features.
    // Note: changed(corrected) w.r.t 1.7.x! (didn't do anything in 1.7.x)
    nGrow 0;

    // Advanced settings

    // When not to extrude surface. 0 is flat surface, 90 is when two faces
    // are perpendicular
    featureAngle 180;

    //slipFeatureAngle 10;

    // Maximum number of snapping relaxation iterations. Should stop
    // before upon reaching a correct mesh.
    nRelaxIter 10; //5
    //nRelaxedIter 2; //gab es vorher nicht

    // Number of smoothing iterations of surface normals
    nSmoothSurfaceNormals 20; //10

    // Number of smoothing iterations of interior mesh movement direction
    nSmoothNormals 5;

    // Smooth layer thickness over surface patches
    nSmoothThickness 2;

    // Stop layer growth on highly warped cells
    maxFaceThicknessRatio 0.5;

    // Reduce layer growth where ratio thickness to medial
    // distance is large
    maxThicknessToMedialRatio 1; //0

    // Angle used to pick up medial axis points
    // Note: changed(corrected) w.r.t 1.7.x! 90 degrees corresponds to 130
    // in 1.7.x.
    minMedialAxisAngle 80;

    // Create buffer region for new layer terminations
    nBufferCellsNoExtrude 0;

    // Overall max number of layer addition iterations. The mesher will exit
    // if it reaches this number of iterations; possibly with an illegal
    // mesh.
    nLayerIter 100;

    //nSmoothDisplacement 10; //gab es vorher nicht

    // Max number of iterations after which relaxed meshQuality controls
    // get used. Up to nRelaxIter it uses the settings in meshQualityControls,
    // after nRelaxIter it uses the values in meshQualityControls::relaxed.
    nRelaxedIter 20;
}



// Generic mesh quality settings. At any undoable phase these determine
// where to undo.
meshQualityControls
{
    #include "meshQualityDict"

    relaxed
    {
      maxNonOrtho 180;
      minTetQuality -1;

    }

    // Advanced

    //- Number of error distribution iterations
    nSmoothScale 4;
    //- Amount to scale back displacement at error points
    errorReduction 0.75;
}


// Advanced

// Merge tolerance. Is fraction of overall bounding box of initial mesh.
// Note: the write tolerance needs to be higher than this.
mergeTolerance 1e-8;


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