CFD Online Discussion Forums

CFD Online Discussion Forums (https://www.cfd-online.com/Forums/)
-   OpenFOAM Meshing & Mesh Conversion (https://www.cfd-online.com/Forums/openfoam-meshing/)
-   -   [snappyHexMesh] Boundary layers across rotorDisk cellZone (https://www.cfd-online.com/Forums/openfoam-meshing/220610-boundary-layers-across-rotordisk-cellzone.html)

vLhomme September 13, 2019 09:24

Boundary layers across rotorDisk cellZone
 
Hello foamers !

I'm currently struggling with the implementation of a propeller and would be glad if you would have some knowledge to share with me.

I'm trying to modelize a ducted propeller with the rotorDisk source class. This requires a cellZone to be implemented on. I then tried to mesh this geometry and create this cellZone of 1 cell height with snappyHexMesh.

I managed to create a mesh with a cell zone by adding in the refinementSurfaces dictionnary :

Code:

rotatingZone
        {
            level      (7 7);
            faceZone    rotatingZone;
            cellZone    rotatingZone;
            cellZoneInside  inside;
        }

This mesh is of fairly good quality with a high definition of the boundary layer every where on the duct except where the cellZone is applied (see picture at https://www.dropbox.com/s/x0k7ou3h2f...oblem.JPG?dl=0 https://www.dropbox.com/s/x0k7ou3h2f...oblem.JPG?dl=0)!

How can I tell snappyHexMesh that it should take into account this cellZone while generating boundary layers and create same boundary layers in the cellZone ?

Many thanks in advance and happy foaming !!

PS : here is my snappy hex mesh dict :


Code:

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

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

// Which of the steps to run
castellatedMesh false;
snap false;
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
{
  fixed.stl
  {
      type triSurfaceMesh;
      name fixed;
      regions
      {
          slipWall  { name slipWall; }
          outlet    { name outlet; }
          inlet    { name inlet; }
          TorusDuct { name TorusDuct; }
          TorusLips { name TorusLips; }
          TorusSide { name TorusSide; }
          CBDuct    { name CBDuct; }
          CBLips    { name CBLips; }
      }
  }/*
  rotatingZone.stl
  {
      type triSurfaceMesh;
      name rotatingZone;
  }*/
  rotatingZone
  {
                type                searchableCylinder;
                point1              (0 0 -0.00625);
                point2                                (0 0 -0.0125);
                radius              0.5;
  }
  Rotor7
  {
      type                searchableCylinder;
      point1              (0 0 0.13);
      point2                                (0 0 -0.38);
      radius              0.5;
      }
  Rotor5
    {
      type                      searchableCylinder;
      point1              (0 0 0.5);
      point2        (0 0 -1);
      radius                    0.9;
    }
  Rotor4
    {
      type                searchableCone;
      point1          (0 0 1);
      radius1        1.6;
      innerRadius1    0;
      point2          (0 0 -5);
      radius2            4.8;
      innerRadius2    0;
    }
  Rotor3
    {
      type                  searchableCone;
      point1          (0 0 2);
      radius1        1.6;
      innerRadius1    0;
      point2          (0 0 -10);
      radius2              4.8;
      innerRadius2    0;
    }
  Rotor2
    {
      type                  searchableCone;
      point1          (0 0 5);
      radius1        2;
      innerRadius1    0;
      point2          (0 0 -25);
      radius2              10;
      innerRadius2    0;
    }
};



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

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

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



    // 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 "fixed.eMesh";
            level 1;
        }
        {
            file "exit.eMesh";
            level 8;
        }
    );



    // 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
    {
        fixed
        {
            // Surface-wise min and max refinement level
            level (0 0);

            regions
            {
                slipWall        { level (0 0); patchInfo { type wall; }}
                outlet          { level (0 0); patchInfo { type patch; }}
                inlet          { level (0 0); patchInfo { type patch; }}
                TorusDuct      { level (7 7); patchInfo { type wall; }}
                TorusLips      { level (7 7); patchInfo { type wall; }}
                TorusSide      { level (7 7); patchInfo { type wall; }}
                CBDuct          { level (7 7); patchInfo { type wall; }}
                CBLips          { level (7 7); patchInfo { type wall; }}
            }
        }
        rotatingZone
        {
            level      (7 7);
            faceZone    rotatingZone;
            cellZone    rotatingZone;
            cellZoneInside  inside;
        }
    }

    // Resolve sharp angles
    resolveFeatureAngle 15;


    // 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
    {
      fixed            { mode inside; levels ((1e-5 1));}
      rotatingZone      { mode inside; levels ((1e-5 5));}
      Rotor3            { mode inside; levels ((3 3));}
      Rotor7            { mode inside; levels ((7 7));}
      Rotor5            { mode inside; levels ((5 5));}
      Rotor4            { mode inside; levels ((4 4));}
      Rotor2            { mode inside; levels ((2 2));}
    }


    // 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 (0. 0. -10.01);


    // 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 false;
}



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

    //- 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.0;

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

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

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

        //- Detect (geometric only) features by sampling the surface
        //  (default=false).
        implicitFeatureSnap true;

        //- Use castellatedMeshControls::features (default = true)
        explicitFeatureSnap false;

        //- Detect points on multiple surfaces (only for explicitFeatureSnap)
        multiRegionFeatureSnap false;
}



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

    // Per final patch (so not geometry!) the layer information
    layers
    {
        TorusDuct        { nSurfaceLayers 15; }
        TorusLips        { nSurfaceLayers 15; }
        TorusSide        { nSurfaceLayers 15; }
        CBDuct                { nSurfaceLayers 15; }
        CBLips                { nSurfaceLayers 15; }
    }

    // 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.
    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.00001;

    // 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 17x! (didn't do anything in 17x)
    nGrow 0;

    // Advanced settings

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

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

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

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

    // 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 50;
}



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

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


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

Please informe me if I do not provide enough information.

vLhomme September 13, 2019 11:21

Image of the problem
 
1 Attachment(s)
https://www.cfd-online.com/Forums/at...1&d=1568387910


All times are GMT -4. The time now is 16:36.