[snappyHexMesh] Meshing a very thin meatus with SnappyHexMesh

enginpower · December 12, 2016, 13:47

Hi all,
I'm trying to mesh a very thin meatus that connects two bigger boxes.
You can watch better the geometry in the attached images.
imm1.png

imm2.png

imm3.png

imm4.png

Attachment 52496
The thickness in the meatus is of about 18e-3 mm, that is 18e-6 m. To have a complete idea of the model, it is long 33mm and 20mm large, then the radius of the two boxes is 10mm (so 33x20x10mm). The meatus has a circular shape, with a radius of about 3mm and long 11mm.
What is the best solution to mesh it?
Actually I'm trying to do that with SnappyHexMesh, but the problem is that the meatus is not meshed like you can see in the following picture
imm6.png

This is my script I used in the SnappyHexMeshDict file:

Code:

/*--------------------------------*- C++ -*----------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  4.1                                   |
|   \\  /    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 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
{
    meatus.stl
    {
        type triSurfaceMesh;
        name meatus;
    }

    refinementBox
    {
        type searchableBox;
        min (0.006 -0.001 0.0099);
        max ( 0.014  0.00301 0.0206);
    }
};



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

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

    // Allow a certain level of imbalance during refining
    // (since balancing is quite expensive)
    // Expressed as fraction of perfect balance (= overall number of cells /
    // nProcs). 0=balance always.
    maxLoadUnbalance 0.10;


    // 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 "meatus.eMesh";
            level 4;
        }
    );



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

            // Optional specification of patch type (default is wall). No
            // constraint types (cyclic, symmetry) etc. are allowed.
            patchInfo
            {
                type wall;
                inGroups (meatusGroup);
            }
        }
    }

    // Resolve sharp angles
    resolveFeatureAngle 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 18));
        }
    }


    // 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.01 0.005 0.001);


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

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

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

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

    // Feature snapping

        //- Number of feature edge snapping iterations.
        //  Leave out altogether to disable.
        nFeatureSnapIter 10;

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

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

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



// Settings for the layer addition.
addLayersControls
{
    // Are the thickness parameters below relative to the undistorted
    // size of the refined cell outside layer (true) or absolute sizes (false).
    relativeSizes true;

    // Per final patch (so not geometry!) the layer information
    layers
    {
        "(lowerWall|meatus).*"
        {
            nSurfaceLayers 1;
        }
    }

    // Expansion factor for layer mesh
    expansionRatio 1.0;

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

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

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

    // At non-patched sides allow mesh to slip if extrusion direction makes
    // angle larger than slipFeatureAngle.
    slipFeatureAngle 30;

    // Maximum number of snapping relaxation iterations. Should stop
    // before upon reaching a correct mesh.
    nRelaxIter 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
    // 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

// Write flags
writeFlags
(
    scalarLevels
    layerSets
    layerFields     // write volScalarField for layer coverage
);


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


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

As you can read in the code, I created a refinement box around the meatus with a level of refinement of 18, but it seams not to be enough. What can I do to get all the meatus meshed?
Any other open software

to get better results for that?

Thanks a lot

DarylMusashi · December 22, 2016, 16:41

I know the commercial meshing software HEXPRESS/Hybrid by NUMECA, which is definitely a very good tool for meshing thin walls.

enginpower · December 27, 2016, 10:34

Thanks to reply.

But it is not open and free available, right?

DarylMusashi · December 28, 2016, 21:25

Thats correct, its a commercial software. Maybe you (or your superior) might think about asking for a demo license (support@numeca.be). HEXPRESS/Hybrid meshes can be definitely converted to openFOAM format at the end of the process.

enginpower · December 30, 2016, 09:58

My superior will expell me if I find a solution with a commercial software. It's part of a project to use only free and open solutions.

Thanks anyway, @DarylMusashi

I'm waiting a suggestions from others, if someone else wants to help.
As you can see Image1.jpg

Image2.jpg, I got some progresses, but I'd like to get the best solution, or to get the complete mesh of the shape without holes.

Thanks to all those who want to help me

chegdan · December 30, 2016, 20:30

The issue is that there needs to be at least 3 cells across the gap during castellation, snapping, and smoothing to actually create a surface. I would take my gap size (L_gap) and figure out the level or base mesh spacing (L_0) you need via

L_gap/3 = L_0/(2^n)

where n is the surface or volume refinement level you are applying. You can either fix n and adjust L_0 or fix L_0 and change n within a volume refinement region in your gap (or you could try a surface refinement if you split off the gap surfaces as separate STL surfaces). Good luck.

enginpower · January 2, 2017, 10:06

@chegdan,
thanks for your reply

If the meatus has a thin of 10e-6m, so I should have:

(10e-6)/3=L_0/(2^n)

Is the L_0 a global measure or the average size of the cell in the domain?
If the minimum size of the box domain is 10mm, I should have:
(10e-6)/3=(10e-3)/(2^n) ~=>n=14

That's ok, but how to get that.
Have a look to my snappyHexMesh file:

Code:

/*--------------------------------*- C++ -*----------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  4.1                                   |
|   \\  /    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 true;
snap            true;
addLayers       false;


// 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
{
    meatus.stl
    {
        type triSurfaceMesh;
        name meatus;
    }

    refinementCylinder
    {
        type searchableCylinder;
        point1 (0 0 0.0099);
        point2 (0 0 0.0206);
    radius 0.00301;
    }
};



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

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

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

    // Allow a certain level of imbalance during refining
    // (since balancing is quite expensive)
    // Expressed as fraction of perfect balance (= overall number of cells /
    // nProcs). 0=balance always.
    maxLoadUnbalance 0.10;


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



    // 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 "meatus.eMesh";
            level 2;
        }
    );



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

            // Optional specification of patch type (default is wall). No
            // constraint types (cyclic, symmetry) etc. are allowed.
            patchInfo
            {
                type wall;
                inGroups (meatusGroup);
            }
        }
    }

    // Resolve sharp angles
    resolveFeatureAngle 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
    {
        refinementCylinder
        {
            mode inside;
            levels ((1E15 14));
        gapLevel (6 14 14)        
        gapMode 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 (0 0.002 0.005);


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

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

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

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

    // Feature snapping

        //- Number of feature edge snapping iterations.
        //  Leave out altogether to disable.
        nFeatureSnapIter 8; //originale 8

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

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

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



// Settings for the layer addition.
addLayersControls
{
    // Are the thickness parameters below relative to the undistorted
    // size of the refined cell outside layer (true) or absolute sizes (false).
    relativeSizes true;

    // Per final patch (so not geometry!) the layer information
    layers
    {
        "(lowerWall|meatus).*"
        {
            nSurfaceLayers 1;
        }
    }

    // Expansion factor for layer mesh
    expansionRatio 1.0;

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

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

    // At non-patched sides allow mesh to slip if extrusion direction makes
    // angle larger than slipFeatureAngle.
    slipFeatureAngle 30;

    // Maximum number of snapping relaxation iterations. Should stop
    // before upon reaching a correct mesh.
    nRelaxIter 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
    // 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

// Write flags
writeFlags
(
    scalarLevels
    layerSets
    layerFields     // write volScalarField for layer coverage
);


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


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

As you can see, I used the refinementCylinder functionality set to level 14.
But this seems to not be enough.
Also I read this: http://www.openfoam.com/version-v3.0+/meshing.php
but some specifications are not clear.

For example:

HTML Code:

refinementRegions {     ref1     {         mode inside;         levels ((10000 0)); // Dummy base-level refinement         // If cells         // - are inside geometry ref1         // - have level 0..9                                                                                                                                                                // - and are in a gap < 4 cell sizes across         // refine them         gapLevel (4 0 10);         // Optional limiting of gap detection based on the         // local surface normal (of the nearest surface).         // The default is mixed, i.e.         // ignore the normal and detect gaps irrespective         // whether they are inside or outside of the geomtry.         // - options: inside, mixed, outside         gapMode inside;     } }      The specification is enabled by using the gapLevel keyword in a refinementRegion (in the refinementRegions section in the snappyHexMeshDict dictionary) and consists of three integers:       
the number of cells in the gap       minimum cell level at which to apply the detection and refinement, and       maximum cell level at which to apply the detection and refinement The minimum and maximum cell levels select the set of cells to operate on, the number of cells in the gap determines for this set of cells how large a gap is detected. Optionally the gapLevel can be overridden on a per-surface basis in the refinementSurfaces section. This will override all three settings but can never extend the set of cells, only limit it.

What does 'gapLevel' mean: the first value is 'the number of cell in the gap'? Is it what I want, or how? In my case, as discussed I have to put 3? And what about 'minimum cell level at which to apply the detection and refinement,'? How to set that value? I don't know how to calculate that. Please help me to calculate...

Moreover, another problem is how to set inlet and outlet surfaces? What I mean is that: after I got a mesh, how to set condition on inlet and outlet. I need to define those surface already in this phase? Right?

If you need I can also post the geometry

Thanks a lot

chegdan · January 2, 2017, 14:01

You probably do not want a level of 14 in your domain because each cell in that region that is level 14 will turn into 8^(n-1) = 8^(14-1) cells. L_0 is with respect to each cell and it works best if each cell is a cube as well. You can also make a custom block mesh dict that has already refined cells near the small part of your STL. Make sure the small cells are still cubes and do not have large aspect ratios. As far as making an inlet and outlet, you can make those 1) separate STLs or child surfaces of the same stl prior to meshing and set the surface refinement and names for each surface or 2) use tools like topoSet + create patch to make patches on existing meshes.

enginpower · January 4, 2017, 07:55

Actually I succeeded to get a complete mesh of my shape using this configuration:

Code:

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

castellatedMesh true;
snap            true;
addLayers       false;

geometry
{
    meatus.stl
    {
        type triSurfaceMesh;
        name meatus;
    }

    refinementCylinder
    {
        type searchableCylinder;
        point1 (0 0 0.0099);
        point2 (0 0 0.0206);
    radius 0.00301;
    }
};

castellatedMeshControls
{
    maxLocalCells 2700000; 

    maxGlobalCells 15000000;

    minRefinementCells 5;

    maxLoadUnbalance 0.10;

    nCellsBetweenLevels 2; //originale 1

    features
    (
        {
            file "meatus.eMesh";
            level 2;
        }
    );


    refinementSurfaces
    {
        meatus
        {
            level (2 4);

            
            patchInfo
            {
                type wall;
                inGroups (meatusGroup);
            }
        }
    }

    resolveFeatureAngle 30;

    refinementRegions
    {
        refinementCylinder
        {
            mode inside;
            levels ((1E15 9));
        gapLevel (6 6 6)          //aggiunto dopo
        gapMode inside;         //aggiunto dopo
        }
    }

    locationInMesh (0 0.002 0.005);
    allowFreeStandingZoneFaces false; 
}

snapControls
{
    nSmoothPatch 3;
    tolerance 2.0;

    nSolveIter 30;

    nRelaxIter 5;

    nFeatureSnapIter 8; //originale 8

    implicitFeatureSnap false;

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

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



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

    
    layers
    {
        "(lowerWall|meatus).*"
        {
            nSurfaceLayers 1;
        }
    }

    
    expansionRatio 1.0;

    
    finalLayerThickness 0.3;
    minThickness 0.00001;
    nGrow 0;

    
    featureAngle 60;

    slipFeatureAngle 30;

    
    nRelaxIter 3;

    
    nSmoothSurfaceNormals 1;

    
    nSmoothNormals 3;

    nSmoothThickness 10;

    maxFaceThicknessRatio 0.5;

    maxThicknessToMedialRatio 0.3;

    minMedianAxisAngle 90;

    nBufferCellsNoExtrude 0;
    nLayerIter 50;
}


meshQualityControls
{
    #include "meshQualityDict"


    
    nSmoothScale 4;
    
    errorReduction 0.75;
}

writeFlags
(
    scalarLevels
    layerSets
    layerFields     
);

mergeTolerance 1e-5;


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

Then I thought to create surfaces for the boundary conditions (this point is even not clear). Anyway I separated what in the simulation is the inlet surface, wall and outlet surface, using succefully this procedure. So I meshed in the same manner the whole part, but it needs such a big quantity of RAM that it is impossible to do on my machine. How is it possible? One stl file ok, three separated ones composing the same part, no??!

I've downgraded some refinement options (what I understood) in this manner:

Code:

/*--------------------------------*- C++ -*----------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  4.1                                   |
|   \\  /    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 true;
snap            true;
addLayers       false;


geometry
{
    inlet.stl
    {
        type triSurfaceMesh;
        name inlet;
    }

    outlet.stl
    {
        type triSurfaceMesh;
        name outlet;
    }

    wall.stl
    {
        type triSurfaceMesh;
        name wall;
    }

    refinementCylinder
    {
        type searchableCylinder;
        point1 (0 0 0.0099);
        point2 (0 0 0.0206);
    radius 0.00301;
    }
};


castellatedMeshControls
{

    maxLocalCells 2500000; 

    
    maxGlobalCells 14000000;

    minRefinementCells 10;  

    maxLoadUnbalance 0.10;

    nCellsBetweenLevels 2;

    features
    (
        {
            file "inlet.eMesh";
            level 0;
        }

    {
            file "outlet.eMesh";
            level 0;
        }

    {
            file "wall.eMesh";
            level 1;
        }
    );



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

            // Optional specification of patch type (default is wall). No
            // constraint types (cyclic, symmetry) etc. are allowed.
            patchInfo
            {
                type wall;
                inGroups (inletGroup);
            }
        }

    outlet
        {
            // Surface-wise min and max refinement level
            level (0 1);

            // Optional specification of patch type (default is wall). No
            // constraint types (cyclic, symmetry) etc. are allowed.
            patchInfo
            {
                type wall;
                inGroups (outletGroup);
            }
        }

    wall
        {
            // Surface-wise min and max refinement level
            level (0 1);

            // Optional specification of patch type (default is wall). No
            // constraint types (cyclic, symmetry) etc. are allowed.
            patchInfo
            {
                type wall;
                inGroups (wallGroup);
            }
        }
    }

    // Resolve sharp angles
    resolveFeatureAngle 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
    {
        refinementCylinder
        {
            mode inside;
            levels ((1E15 9));
        gapLevel (6 6 6)          //aggiunto dopo
        gapMode inside;         //aggiunto dopo
        }
    }


    // 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.002 0.005);


    // 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;  // originale true
}



// Settings for the snapping.
snapControls
{
    //- 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.
    tolerance 2.0;

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

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

    // Feature snapping

        //- Number of feature edge snapping iterations.
        //  Leave out altogether to disable.
        nFeatureSnapIter 8; //originale 8

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

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

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



// Settings for the layer addition.
addLayersControls
{
    // Are the thickness parameters below relative to the undistorted
    // size of the refined cell outside layer (true) or absolute sizes (false).
    relativeSizes true;

    // Per final patch (so not geometry!) the layer information
    layers
    {
        "(lowerWall|wall).*"
        {
            nSurfaceLayers 1;
        }
    }

    // Expansion factor for layer mesh
    expansionRatio 1.0;

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

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

    // At non-patched sides allow mesh to slip if extrusion direction makes
    // angle larger than slipFeatureAngle.
    slipFeatureAngle 30;

    // Maximum number of snapping relaxation iterations. Should stop
    // before upon reaching a correct mesh.
    nRelaxIter 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
    // 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

// Write flags
writeFlags
(
    scalarLevels
    layerSets
    layerFields     // write volScalarField for layer coverage
);


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


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

but even I have a problem with RAM quantity. How to get a coarse refinement all around all surfaces, that are inlet, outlet and globally walls, but to have a very fine one in the cylinder I created?
What I think is to downgrade the refinement everywhere but not in the cylinder. But I to do that??

So to sum up, it is not clear:

how to refine the mesh just in the cylinder as defined, to get a very fine mesh in the meatus and a coarser mesh in the remaining part, but gloabally obtaining a good quality mesh??
how to set up the surfaces where then I'll apply the boundary conditions in the simulation process? What is the workflow to use?
why, even if I set 14000000 as maxGlobalCells, that is approximately a need of 28GB (1Mcell=2GB), are 27GB of RAM + 18GB of swap not enough??

Actually it returns, in the end part, this:

Code:

Cells per refinement level:
    0    59818
    1    6392
    2    17356
    3    89432
    4    5886528
Balanced mesh in = 23.39 s
After balancing shell refinement iteration 3 : cells:6059526  faces:18293246  points:6174909
Cells per refinement level:
    0    59818
    1    6392
    2    17356
    3    89432
    4    5886528

Shell refinement iteration 4
----------------------------

Marked for refinement due to distance to explicit features : 0 cells.
Marked for refinement due to refinement shells             : 5929484 cells.
Determined cells to refine in = 1.54 s
Selected for internal refinement : 5938998 cells (out of 6059526)
Edge intersection testing:
    Number of edges             : 143337404
    Number of edges to retest   : 143128511
--------------------------------------------------------------------------
mpirun noticed that process rank 2 with PID 3513 on node enginepower exited on signal 9 (Killed).
--------------------------------------------------------------------------

for the command:

Code:

mpirun -np 6 snappyHexMesh -overwrite -parallel

Thanks again!

chegdan · January 4, 2017, 10:32

Read the last message just before your memory ran out:

Code:

Selected for internal refinement : 5938998 cells (out of 6059526)

That means that 5.9 million cells are about to be refined and become 5.9 M +7*5.9M cells ~= 41 M cells. This is only to level 5, and you have internal refinement up to 9 in some places so it will increase even more. Post your case and geometry and I will see what i can do.

enginpower · January 5, 2017, 05:18

Thanks a lot for your reply

Quote:

That means that 5.9 million cells are about to be refined and become 5.9 M +7*5.9M cells ~= 41 M cells

Could you explain me how do you get it? To me, it's not clear where 7 comes from

Quote:

This is only to level 5, and you have internal refinement up to 9 in some places so it will increase even more

Is it not the fourth, as said below? And where do you read 9?
An explanaition about this parameters will be very helpful in the understanding of OF.

Code:

Shell refinement iteration 4

I confirm that if I have only a stl file the required RAM reduces to an affordable capacity.
To do that I create a single stl file with different 'solid' sections. It is here

and so I changed the snappyHexMeshDict file in this manner:

Code:

/*--------------------------------*- C++ -*----------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  4.1                                   |
|   \\  /    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 true;
snap            true;
addLayers       false;


// 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
{
    assembly.stl
    {
        type triSurfaceMesh;
        name assembly;
    }

    refinementCylinder
    {
        type searchableCylinder;
        point1 (0 0 0.0099);
        point2 (0 0 0.0206);
    radius 0.00301;
    }
};



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

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

    // Allow a certain level of imbalance during refining
    // (since balancing is quite expensive)
    // Expressed as fraction of perfect balance (= overall number of cells /
    // nProcs). 0=balance always.
    maxLoadUnbalance 0.10;


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



    // 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 "assembly.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
    {
        inlet
        {
            // Surface-wise min and max refinement level
            level (0 1);

            // Optional specification of patch type (default is wall). No
            // constraint types (cyclic, symmetry) etc. are allowed.
            patchInfo
            {
                type wall;
                inGroups (inletGroup);
            }
        }

    outlet
        {
            // Surface-wise min and max refinement level
            level (0 1);

            // Optional specification of patch type (default is wall). No
            // constraint types (cyclic, symmetry) etc. are allowed.
            patchInfo
            {
                type wall;
                inGroups (outletGroup);
            }
        }

    wall
        {
            // Surface-wise min and max refinement level
            level (0 1);

            // Optional specification of patch type (default is wall). No
            // constraint types (cyclic, symmetry) etc. are allowed.
            patchInfo
            {
                type wall;
                inGroups (wallGroup);
            }
        }
    }

    // Resolve sharp angles
    resolveFeatureAngle 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
    {
        refinementCylinder
        {
            mode inside;
            levels ((1E15 9));
        gapLevel (6 6 6)          
        gapMode 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 (0 0.002 0.005);


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

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

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

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

    // Feature snapping

        //- Number of feature edge snapping iterations.
        //  Leave out altogether to disable.
        nFeatureSnapIter 8; //originale 8

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

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

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



// Settings for the layer addition.
addLayersControls
{
    // Are the thickness parameters below relative to the undistorted
    // size of the refined cell outside layer (true) or absolute sizes (false).
    relativeSizes true;

    // Per final patch (so not geometry!) the layer information
    layers
    {
        "(lowerWall|wall).*"
        {
            nSurfaceLayers 1;
        }
    }

    // Expansion factor for layer mesh
    expansionRatio 1.0;

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

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

    // At non-patched sides allow mesh to slip if extrusion direction makes
    // angle larger than slipFeatureAngle.
    slipFeatureAngle 30;

    // Maximum number of snapping relaxation iterations. Should stop
    // before upon reaching a correct mesh.
    nRelaxIter 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
    // 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

// Write flags
writeFlags
(
    scalarLevels
    layerSets
    layerFields     // write volScalarField for layer coverage
);


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


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

Quote:

Post your case and geometry

With this setting the problem is that locationMesh seems to fail. It creates a blocked mesh as defined in blockMeshDict, but I checked locationMesh should be inside. How is it possible?

This is my blockMeshDict:

Code:

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

convertToMeters 1;

vertices
(
    (-0.011 -0.001 -0.001) //0
    (0.011 -0.001 -0.001) //1
    (0.011 0.011 -0.001) //2
    (-0.011 0.011 -0.001) //3
    (-0.011 -0.001 0.0326) //4
    (0.011 -0.001 0.0326) //5
    (0.011 0.011 0.0326) //6
    (-0.011 0.011 0.0326) //7
);

blocks
(
    hex (0 1 2 3 4 5 6 7 ) (5 5 15) simpleGrading (1 1 1)
);

edges
(
);

boundary
(
    box
    {
        type patch;
        faces
        (
            (0 1 2 3)
        (0 1 5 4)
        (1 2 6 5)
        (2 6 7 3)
        (0 3 7 4)
        (4 5 6 7)
        );
    }
);

mergePatchPairs
(
);

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

I supposed that 'hex (0 1 2 3 4 5 6 7 ) (5 5 15)', that is 5 for x 5 for y 15 for z is to small, but let me do a trial.

I did, but nothing seems to change...

Another question is: how to get the log file from snappyHexMesh?
I tried this:

Code:

mpirun -np 6 snappyHexMesh -overwrite -parallel > log &

Let me know, what else you need.

It returns a log file, but it does seem to mesh

Thanks so much for your help

chegdan · January 5, 2017, 11:27

Quote:

Could you explain me how do you get it? To me, it's not clear where 7 comes from

When a cell is refined (isotropic refinement), 1 cell becomes a total of 8 cells. Standard SnappyHexMesh cannot do anisotropic volume refinement.

Quote:

This is only to level 5, and you have internal refinement up to 9 in some places so it will increase even more

In your list of current cells

Code:

Cells per refinement level:
    0    59818
    1    6392
    2    17356
    3    89432
    4    5886528

the largest number is 4 and it is currently refinement step so it will be 5.

Quote:

Is it not the fourth, as said below? And where do you read 9?

Your volumetric refinement level for the refinement region is set to 9, so not necessarily all 5.9 million will eventually reach level 9, but there will be some of those since the list of current refinements is only at 4...some of those 4 cells will become 9 cells down the road.

Code:

    refinementRegions
    {
        refinementCylinder
        {
            mode inside;
            levels ((1E15 9));
        gapLevel (6 6 6)          
        gapMode inside;      
        }
    }

Quote:

With this setting the problem is that locationMesh seems to fail. It creates a blocked mesh as defined in blockMeshDict, but I checked locationMesh should be inside. How is it possible?

No idea, i need the whole case so i can try meshing.

for writing logs in SHM i use

Code:

mpirun -np 6 snappyHexMesh -overwrite -parallel > snappyHexMesh.log 2>1&

enginpower · January 9, 2017, 08:05

Thanks, now it is clearer

I'll try to upload all the case.

Anyway, what I thought is that I created a surface for inlet, one for outlet and one for wall in the same file stl, folowing the same procedure described above, and maybe there are not connectected.

I don't get any error message using the sequence commands (blockMesh, surfaceFeatureExtract, decomposePar, mpirun -np 6 snappyHexMesh -overwrite -parallel, reconstructParMesh -constant)

So could be possible that the stl file is open somewhere? how to check this?
What I think to do, is to put also the complete stl file, that is to have assembly.stl (wall+inlet+outlet) and meatus.stl (the complete model, as exported by the CAD software). Will this create some problem?

LVDH · January 16, 2017, 04:52

You can check your stl files with surfaceCheck.
Also you should use kdiff or something to check your two snappyHexMeshDicts to be sure that you are not doing something very different now.

You should also check if the nodes from your walls and other surfaces match. This is possible in Paraview with the surface with edges display option.

enginpower · January 16, 2017, 07:31

Thanks for your reply

I did the check with surfaceCheck. That's the results:

Code:

Reading surface from "assembly.stl" ...

Statistics:
Triangles    : 1692
Vertices     : 848
Bounding Box : (-0.01 -1.03923e-35 0) (0.01 0.01 0.0325)

Region    Size
------    ----
wall    1516
inlet    78
outlet    98


Surface has no illegal triangles.

Triangle quality (equilateral=1, collapsed=0):
    0 .. 0.05  : 0.0070922
    0.05 .. 0.1  : 0
    0.1 .. 0.15  : 0.000591017
    0.15 .. 0.2  : 0
    0.2 .. 0.25  : 0
    0.25 .. 0.3  : 0
    0.3 .. 0.35  : 0
    0.35 .. 0.4  : 0
    0.4 .. 0.45  : 0.00295508
    0.45 .. 0.5  : 0.00295508
    0.5 .. 0.55  : 0.00118203
    0.55 .. 0.6  : 0.0035461
    0.6 .. 0.65  : 0.0177305
    0.65 .. 0.7  : 0.0236407
    0.7 .. 0.75  : 0.0206856
    0.75 .. 0.8  : 0.03487
    0.8 .. 0.85  : 0.0520095
    0.85 .. 0.9  : 0.119976
    0.9 .. 0.95  : 0.144799
    0.95 .. 1  : 0.567967

    min 7.8784e-05 for triangle 550
    max 1 for triangle 871

Edges:
    min 1.825e-05 for edge 759 points (-0.00298925 -1.03923e-35 0.01)(-0.0030075 4.28167e-19 0.01)
    max 0.00272475 for edge 2403 points (-0.00104529 0.00994522 0)(0.00106087 0.00821654 0)

Checking for points less than 1e-6 of bounding box ((0.02 0.01 0.0325) metre) apart.
Found 0 nearby points.

Surface is closed. All edges connected to two faces.

Number of unconnected parts : 1

Number of zones (connected area with consistent normal) : 1

Checking self-intersection.
Surface is self-intersecting at 157 locations.
Writing intersection points to "selfInterPoints.obj"


End

What I can see it is that there are not open surfaces but self-intersecting surfaces. How to eliminate the problem, if it is?

I'm sure the snappyHexMeshDict file is so not different. But actually I've not understood this:

Quote:

You should also check if the nodes from your walls and other surfaces match. This is possible in Paraview with the surface with edges display option.

Could you explain better this procedure?

What I get now is an almost complete mesh, but as you can see Image.jpg there are some missing 'lines of cells' exactly in the meatus zone, thus what I wronged and why?
Anyway checkMesh returns that it is all ok:

Code:

Create time

Create polyMesh for time = 0

Time = 0

Mesh stats
    points:           13596226
    faces:            33805200
    internal faces:   27997257
    cells:            10120663
    faces per cell:   6.106562
    boundary patches: 1
    point zones:      0
    face zones:       0
    cell zones:       0

Overall number of cells of each type:
    hexahedra:     9778252
    prisms:        0
    wedges:        0
    pyramids:      0
    tet wedges:    0
    tetrahedra:    0
    polyhedra:     342411
    Breakdown of polyhedra by number of faces:
        faces   number of cells
            6   51989
            9   226550
           12   59117
           15   4311
           18   444

Checking topology...
    Boundary definition OK.
    Cell to face addressing OK.
    Point usage OK.
    Upper triangular ordering OK.
    Face vertices OK.
    Number of regions: 1 (OK).

Checking patch topology for multiply connected surfaces...
                   Patch    Faces   Points                  Surface topology
                   model  5807943  5859080      ok (closed singly connected)

Checking geometry...
    Overall domain bounding box (-0.01000877 -9.794033e-06 -2.320972e-08) (0.01000877 0.01000942 0.03250005)
    Mesh has 3 geometric (non-empty/wedge) directions (1 1 1)
    Mesh has 3 solution (non-empty) directions (1 1 1)
    Boundary openness (2.691837e-14 -2.316395e-13 -2.837709e-16) OK.
    Max cell openness = 3.130751e-16 OK.
    Max aspect ratio = 2.510818 OK.
    Minimum face area = 1.890609e-11. Maximum face area = 2.144546e-07.  Face area magnitudes OK.
    Min volume = 1.451148e-16. Max volume = 5.18802e-11.  Total volume = 3.295963e-06.  Cell volumes OK.
    Mesh non-orthogonality Max: 49.1179 average: 6.667905
    Non-orthogonality check OK.
    Face pyramids OK.
    Max skewness = 1.464566 OK.
    Coupled point location match (average 0) OK.

Mesh OK.

End

Then there is another question. I'm following this tutorial
to get a complete case simulation. At time 39:00 he says to change the /constant/polyMesh/boundary file. He removes the parts not interesting generated by blockMesh (if I've well understood). The problem is that I got this:

Code:

/*--------------------------------*- C++ -*----------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  4.1                                   |
|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
|    \\/     M anipulation  |                                                 |
\*---------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       polyBoundaryMesh;
    location    "constant/polyMesh";
    object      boundary;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

1
(
    model
    {
        type            wall;
        inGroups        
2
(
modelGroup
wall
)
;
        nFaces          5807943;
        startFace       27997257;
    }
)

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

My question is: where is the inlet, outlet patches/surfaces? How to write or recognize them now? How to set the boundary file to have inlet, outlet and wall as boundaries to be set for the simulation? As you can read from the checkMesh result, there is only
Checking patch topology for multiply connected surfaces... Patch Faces Points Surface topology model 5807943 5859080 ok (closed singly connected)
Why does not it get the inlet, outlet and wall patches?

I attach here also the complete case so you can simulate by yourself. meatus.zip
So I hope now you can help me instructing above which parameters are to set or change, to get a complete good mesh ready to be simulated with OF.

Thanks so much to who wants to help

Waiting for a great help, I tried to import the mesh directly from Salome 7.1. After striving to get an aceptable mesh, not using prism because not recognised in unv mesh format, I exported it. The problem is that when I want to convert it to the OF mesh format, using

Code:

ideasUnvToFoam mesh.unv

I get this error message:

Code:

ideasUnvToFoam mesh.unv 
/*---------------------------------------------------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  4.1                                   |
|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
|    \\/     M anipulation  |                                                 |
\*---------------------------------------------------------------------------*/
Build  : 4.1
Exec   : ideasUnvToFoam mesh.unv
Date   : Jan 18 2017
Time   : 14:54:27
Host   : "engine-VirtualBox"
PID    : 5533
Case   : /home/engine/OpenFoam/meatusSalome
nProcs : 1
sigFpe : Enabling floating point exception trapping (FOAM_SIGFPE).
fileModificationChecking : Monitoring run-time modified files using timeStampMaster
allowSystemOperations : Allowing user-supplied system call operations

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Create time

Processing tag:164
Starting reading units at line 3.
l:1
units:"  SI: Meter (newton)"
unitType:2
Unit factors:
    Length scale       : 1
    Force scale        : 1
    Temperature scale  : 1
    Temperature offset : 273.15


Processing tag:2420
Skipping tag 2420 on line 9
Skipping section at line 9.

Processing tag:2411
Starting reading points at line 20.
terminate called after throwing an instance of 'std::out_of_range'
  what():  basic_string::substr: __pos (which is 25) > this->size() (which is 10)
Aborted (core dumped)

So it seems there is a problem in reading a different lenght string.

Why do I get this error? Actually I've not understood if it requires a 25 or 10 lenght size. Has the mesh.unv file numbers with too long precision?
This is the first part of my file:

Code:

    -1

   164

         1  SI: Meter (newton)         2

    1.0000000000000000E+0    1.0000000000000000E+0    1.0000000000000000E+0

    2.7314999999999998E+2

    -1

    -1

  2420

         1

SMESH_Mesh

         1         0         0

Global Cartesian Coordinate System

    1.0000000000000000E+0    0.0000000000000000E+0    0.0000000000000000E+0

    0.0000000000000000E+0    1.0000000000000000E+0    0.0000000000000000E+0

    0.0000000000000000E+0    0.0000000000000000E+0    1.0000000000000000E+0

    0.0000000000000000E+0    0.0000000000000000E+0    0.0000000000000000E+0

    -1

    -1

  2411

         1         1         1        11

  2.3915750000000000E-003  1.7933166429481991E-003  1.0000000000000000E-002

         2         1         1        11

  2.3915750000000000E-003  1.7933166429481991E-003  3.2500000000000001E-002

         3         1         1        11

  2.3915750000000000E-003  7.5876513300721826E-019  3.2500000000000001E-002

         4         1         1        11

  1.0000000000000000E-002  0.0000000000000000E+000  3.2500000000000001E-002

         5         1         1        11

  1.0000000000000000E-002  0.0000000000000000E+000  2.0500000000000001E-002

How to change that on Salome?

I looked around for a similar error in OF but I've not found anyone stuck with this problem.

enginpower · February 3, 2017, 10:41

I meshed the same geometry, but following all tricks and suggestions found here and all correlated videos.
Now I get this error:

Code:

[1] Adding particle for point:20577 coord:(0.002471089 0.00491784 0) feature:0 to track to:(0.001140569 0.005377354 0)
[1] Tracking 88503 particles over distance 0.08399262 to mark cells
[3] Remaining particles 0
Marked for refinement due to explicit features             : 261446 cells.
Determined cells to refine in = 25.97 s
Selected for feature refinement : 373925 cells (out of 4679259)
[1] getChangedFaces : Writing 3275417 changed faces to faceSet changedFaces
Edge intersection testing:
    Number of edges             : 23677778
    Number of edges to retest   : 12804405
[4] Writing refined but unbalanced "feature refinement iteration 1" mesh to time 2
[1] meshRefinement::dumpIntersections : Writing cellcentre-cellcentre intersections to file "/home/engine/OpenFoam/meato/processor1/2_edges.obj"
[5] 
[5] Dumped debug data in = 81 s
[5] meshRefinement::checkData() : Checking refinement structure.
[3] 
[2] Dumped debug data in = 81.46 s
[2] meshRefinement::checkData() : Checking refinement structure.
[5] meshRefinement::checkData() : Checking refinement levels.
[3] After refinement feature refinement iteration 1 : cells(local):996402  faces(local):3193894  points(local):1217357
[1] meshRefinement::checkData() : Found 0 duplicate pairs of faces.
[1] After refinement feature refinement iteration 1 : cells(local):1535142  faces(local):5033785  points(local):1989262
[4] meshRefinement::checkData() : Found 0 duplicate pairs of faces.
[4] After refinement feature refinement iteration 1 : cells(local):1163499  faces(local):3797344  points(local):1497336
[0] meshRefinement::checkData() : Found 0 duplicate pairs of faces.
Refined mesh in = 8.96 s
[0] After refinement feature refinement iteration 1 : cells(local):1300110  faces(local):4260361  points(local):1689067
[5] meshRefinement::checkData() : Found 0 duplicate pairs of faces.
[5] After refinement feature refinement iteration 1 : cells(local):996773  faces(local):3195478  points(local):1218306
[2] meshRefinement::checkData() : Found 0 duplicate pairs of faces.
[2] After refinement feature refinement iteration 1 : cells(local):1304808  faces(local):4276531  points(local):1695962
After refinement feature refinement iteration 1 : cells:7296734  faces:23677778  points:9221419
Cells per refinement level:
    0    3790484
    1    1414682
    2    2091568
[3] Wanted distribution:6(0 0 0 996402 0 0)
[5] Wanted distribution:6(0 0 0 0 0 996773)
[1] Wanted resulting decomposition:
[1]     0    1215136
[1]     1    1215393
[1]     2    1216454
[1]     3    1217207
[1]     4    1217588
[1]     5    1214956
[1] 
[4] Wanted resulting decomposition:
[4]     0    1215136
[4]     1    1215393
[4]     2    1216454
[4]     3    1217207
[4]     4    1217588
[4]     5    1214956
[4] 
[0] Wanted resulting decomposition:
[0]     0    1215136
[0]     1    1215393
[0]     2    1216454
[0]     3    1217207
[0]     4    1217588
[0]     5    1214956
[0] 
[3] Wanted resulting decomposition:
[3]     0    1215136
[3]     1    1215393
[3]     2    1216454
[3]     3    1217207
[3]     4    1217588
[3]     5    1214956
[3] 
[5] Wanted resulting decomposition:
[5]     0    1215136
[5]     1    1215393
[5]     2    1216454
[5]     3    1217207
[5]     4    1217588
[5]     5    1214956
[2] Wanted resulting decomposition:
[2]     0    1215136
[2]     1    1215393
[2]     2    1216454
[2]     3    1217207
[2]     4    1217588
[2]     5    1214956
[2] 
[5] 
[5] #0  Foam::error::printStack(Foam::Ostream&) at ??:?
[5] #1  Foam::sigSegv::sigHandler(int) at ??:?
[5] #2  ? in "/lib/x86_64-linux-gnu/libc.so.6"
[5] #3  Foam::polyMeshAdder::insertVertices(Foam::HashTable<Foam::List<int>, Foam::edge, Foam::Hash<Foam::edge> > const&, Foam::Map<int> const&, Foam::List<int> const&, Foam::face const&, Foam::DynamicList<int, 0u, 2u, 1u>&, Foam::face&) at ??:?
[5] #4  Foam::polyMeshAdder::mergePrimitives(Foam::polyMesh const&, Foam::polyMesh const&, Foam::faceCoupleInfo const&, int, Foam::List<int> const&, Foam::List<int> const&, Foam::Field<Foam::Vector<double> >&, Foam::List<int>&, Foam::List<int>&, Foam::List<Foam::face>&, Foam::List<int>&, Foam::List<int>&, int&, Foam::List<int>&, int&, Foam::List<int>&, Foam::List<int>&, Foam::List<int>&) at ??:?
[5] #5  Foam::polyMeshAdder::add(Foam::polyMesh&, Foam::polyMesh const&, Foam::faceCoupleInfo const&, bool) at ??:?
[5] #6  Foam::fvMeshAdder::add(Foam::fvMesh&, Foam::fvMesh const&, Foam::faceCoupleInfo const&, bool) at ??:?
[5] #7  Foam::fvMeshDistribute::distribute(Foam::List<int> const&) at ??:?
[5] #8  Foam::meshRefinement::balance(bool, bool, Foam::Field<double> const&, Foam::decompositionMethod&, Foam::fvMeshDistribute&) at ??:?
[5] #9  Foam::meshRefinement::refineAndBalance(Foam::string const&, Foam::decompositionMethod&, Foam::fvMeshDistribute&, Foam::List<int> const&, double) at ??:?
[5] #10  Foam::snappyRefineDriver::featureEdgeRefine(Foam::refinementParameters const&, int, int) at ??:?
[5] #11  Foam::snappyRefineDriver::doRefine(Foam::dictionary const&, Foam::refinementParameters const&, Foam::snapParameters const&, bool, Foam::dictionary const&) at ??:?
[5] #12  ? at ??:?
[5] #13  __libc_start_main in "/lib/x86_64-linux-gnu/libc.so.6"
[5] #14  ? at ??:?
[engine-VirtualBox:02729] *** Process received signal ***
[engine-VirtualBox:02729] Signal: Segmentation fault (11)
[engine-VirtualBox:02729] Signal code:  (-6)
[engine-VirtualBox:02729] Failing at address: 0x3e800000aa9
[engine-VirtualBox:02729] [ 0] /lib/x86_64-linux-gnu/libc.so.6(+0x354b0)[0x7f4395d8c4b0]
[engine-VirtualBox:02729] [ 1] /lib/x86_64-linux-gnu/libc.so.6(gsignal+0x38)[0x7f4395d8c428]
[engine-VirtualBox:02729] [ 2] /lib/x86_64-linux-gnu/libc.so.6(+0x354b0)[0x7f4395d8c4b0]
[engine-VirtualBox:02729] [ 3] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libdynamicMesh.so(_ZN4Foam13polyMeshAdder14insertVerticesERKNS_9HashTableINS_4ListIiEENS_4edgeENS_4HashIS4_EEEERKNS_3MapIiEERKS3_RKNS_4faceERNS_11DynamicListIiLj0ELj2ELj1EEERSG_+0x10f)[0x7f4397e6cb0f]
[engine-VirtualBox:02729] [ 4] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libdynamicMesh.so(_ZN4Foam13polyMeshAdder15mergePrimitivesERKNS_8polyMeshES3_RKNS_14faceCoupleInfoEiRKNS_4ListIiEESA_RNS_5FieldINS_6VectorIdEEEERS8_SG_RNS7_INS_4faceEEESG_SG_RiSG_SK_SG_SG_SG_+0xed2)[0x7f4397e71c92]
[engine-VirtualBox:02729] [ 5] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libdynamicMesh.so(_ZN4Foam13polyMeshAdder3addERNS_8polyMeshERKS1_RKNS_14faceCoupleInfoEb+0x2fc)[0x7f4397e7559c]
[engine-VirtualBox:02729] [ 6] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libdynamicMesh.so(_ZN4Foam11fvMeshAdder3addERNS_6fvMeshERKS1_RKNS_14faceCoupleInfoEb+0x53)[0x7f4397d91363]
[engine-VirtualBox:02729] [ 7] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libdynamicMesh.so(_ZN4Foam16fvMeshDistribute10distributeERKNS_4ListIiEE+0x286f)[0x7f4397df6eef]
[engine-VirtualBox:02729] [ 8] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libsnappyHexMesh.so(_ZN4Foam14meshRefinement7balanceEbbRKNS_5FieldIdEERNS_19decompositionMethodERNS_16fvMeshDistributeE+0x3c6)[0x7f43977d2e46]
[engine-VirtualBox:02729] [ 9] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libsnappyHexMesh.so(_ZN4Foam14meshRefinement16refineAndBalanceERKNS_6stringERNS_19decompositionMethodERNS_16fvMeshDistributeERKNS_4ListIiEEd+0x632)[0x7f439783f0a2]
[engine-VirtualBox:02729] [10] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libsnappyHexMesh.so(_ZN4Foam18snappyRefineDriver17featureEdgeRefineERKNS_20refinementParametersEii+0xabb)[0x7f4397795f2b]
[engine-VirtualBox:02729] [11] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libsnappyHexMesh.so(_ZN4Foam18snappyRefineDriver8doRefineERKNS_10dictionaryERKNS_20refinementParametersERKNS_14snapParametersEbS3_+0xcb)[0x7f439779d32b]
[engine-VirtualBox:02729] [12] snappyHexMesh[0x416660]
[engine-VirtualBox:02729] [13] /lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0)[0x7f4395d77830]
[engine-VirtualBox:02729] [14] snappyHexMesh[0x4175c9]
[engine-VirtualBox:02729] *** End of error message ***
[3] #0  Foam::error::printStack(Foam::Ostream&) at ??:?
[3] #1  Foam::sigSegv::sigHandler(int) at ??:?
[3] #2  ? in "/lib/x86_64-linux-gnu/libc.so.6"
[3] #3  Foam::polyMeshAdder::insertVertices(Foam::HashTable<Foam::List<int>, Foam::edge, Foam::Hash<Foam::edge> > const&, Foam::Map<int> const&, Foam::List<int> const&, Foam::face const&, Foam::DynamicList<int, 0u, 2u, 1u>&, Foam::face&) at ??:?
[3] #4  Foam::polyMeshAdder::mergePrimitives(Foam::polyMesh const&, Foam::polyMesh const&, Foam::faceCoupleInfo const&, int, Foam::List<int> const&, Foam::List<int> const&, Foam::Field<Foam::Vector<double> >&, Foam::List<int>&, Foam::List<int>&, Foam::List<Foam::face>&, Foam::List<int>&, Foam::List<int>&, int&, Foam::List<int>&, int&, Foam::List<int>&, Foam::List<int>&, Foam::List<int>&) at ??:?
[3] #5  Foam::polyMeshAdder::add(Foam::polyMesh&, Foam::polyMesh const&, Foam::faceCoupleInfo const&, bool) at ??:?
[3] #6  Foam::fvMeshAdder::add(Foam::fvMesh&, Foam::fvMesh const&, Foam::faceCoupleInfo const&, bool) at ??:?
[3] #7  Foam::fvMeshDistribute::distribute(Foam::List<int> const&)[4] #0  Foam::error::printStack(Foam::Ostream&) at ??:?
[3] #8  Foam::meshRefinement::balance(bool, bool, Foam::Field<double> const&, Foam::decompositionMethod&, Foam::fvMeshDistribute&) at ??:?
[4] #1  Foam::sigSegv::sigHandler(int) at ??:?
[3] #9  Foam::meshRefinement::refineAndBalance(Foam::string const&, Foam::decompositionMethod&, Foam::fvMeshDistribute&, Foam::List<int> const&, double) at ??:?
[4] #2  ? in "/lib/x86_64-linux-gnu/libc.so.6"
[4] #3  Foam::polyMeshAdder::insertVertices(Foam::HashTable<Foam::List<int>, Foam::edge, Foam::Hash<Foam::edge> > const&, Foam::Map<int> const&, Foam::List<int> const&, Foam::face const&, Foam::DynamicList<int, 0u, 2u, 1u>&, Foam::face&) at ??:?
[3] #10  Foam::snappyRefineDriver::featureEdgeRefine(Foam::refinementParameters const&, int, int) at ??:?
[4] #4  Foam::polyMeshAdder::mergePrimitives(Foam::polyMesh const&, Foam::polyMesh const&, Foam::faceCoupleInfo const&, int, Foam::List<int> const&, Foam::List<int> const&, Foam::Field<Foam::Vector<double> >&, Foam::List<int>&, Foam::List<int>&, Foam::List<Foam::face>&, Foam::List<int>&, Foam::List<int>&, int&, Foam::List<int>&, int&, Foam::List<int>&, Foam::List<int>&, Foam::List<int>&) at ??:?
[3] #11  Foam::snappyRefineDriver::doRefine(Foam::dictionary const&, Foam::refinementParameters const&, Foam::snapParameters const&, bool, Foam::dictionary const&) at ??:?
[4] #5  Foam::polyMeshAdder::add(Foam::polyMesh&, Foam::polyMesh const&, Foam::faceCoupleInfo const&, bool) at ??:?
[3] #12   at ??:?
[4] #6  Foam::fvMeshAdder::add(Foam::fvMesh&, Foam::fvMesh const&, Foam::faceCoupleInfo const&, bool) at ??:?
[4] #7  Foam::fvMeshDistribute::distribute(Foam::List<int> const&)? at ??:?
[4] #8  Foam::meshRefinement::balance(bool, bool, Foam::Field<double> const&, Foam::decompositionMethod&, Foam::fvMeshDistribute&) at ??:?
[3] #13  __libc_start_main at ??:?
[4] #9  Foam::meshRefinement::refineAndBalance(Foam::string const&, Foam::decompositionMethod&, Foam::fvMeshDistribute&, Foam::List<int> const&, double) in "/lib/x86_64-linux-gnu/libc.so.6"
[3] #14  ? at ??:?
[4] #10  Foam::snappyRefineDriver::featureEdgeRefine(Foam::refinementParameters const&, int, int) at ??:?
[engine-VirtualBox:02727] *** Process received signal ***
[engine-VirtualBox:02727] Signal: Segmentation fault (11)
[engine-VirtualBox:02727] Signal code:  (-6)
[engine-VirtualBox:02727] Failing at address: 0x3e800000aa7
[engine-VirtualBox:02727] [ 0] /lib/x86_64-linux-gnu/libc.so.6(+0x354b0)[0x7faeb8cdf4b0]
[engine-VirtualBox:02727] [ 1] /lib/x86_64-linux-gnu/libc.so.6(gsignal+0x38)[0x7faeb8cdf428]
[engine-VirtualBox:02727] [ 2] /lib/x86_64-linux-gnu/libc.so.6(+0x354b0)[0x7faeb8cdf4b0]
[engine-VirtualBox:02727] [ 3] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libdynamicMesh.so(_ZN4Foam13polyMeshAdder14insertVerticesERKNS_9HashTableINS_4ListIiEENS_4edgeENS_4HashIS4_EEEERKNS_3MapIiEERKS3_RKNS_4faceERNS_11DynamicListIiLj0ELj2ELj1EEERSG_+0x10f)[0x7faebadbfb0f]
[engine-VirtualBox:02727] [ 4] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libdynamicMesh.so(_ZN4Foam13polyMeshAdder15mergePrimitivesERKNS_8polyMeshES3_RKNS_14faceCoupleInfoEiRKNS_4ListIiEESA_RNS_5FieldINS_6VectorIdEEEERS8_SG_RNS7_INS_4faceEEESG_SG_RiSG_SK_SG_SG_SG_+0xed2)[0x7faebadc4c92]
[engine-VirtualBox:02727] [ 5] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libdynamicMesh.so(_ZN4Foam13polyMeshAdder3addERNS_8polyMeshERKS1_RKNS_14faceCoupleInfoEb+0x2fc)[0x7faebadc859c]
[engine-VirtualBox:02727] [ 6] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libdynamicMesh.so(_ZN4Foam11fvMeshAdder3addERNS_6fvMeshERKS1_RKNS_14faceCoupleInfoEb+0x53)[0x7faebace4363]
[engine-VirtualBox:02727] [ 7] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libdynamicMesh.so(_ZN4Foam16fvMeshDistribute10distributeERKNS_4ListIiEE+0x286f)[0x7faebad49eef]
[engine-VirtualBox:02727] [ 8] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libsnappyHexMesh.so(_ZN4Foam14meshRefinement7balanceEbbRKNS_5FieldIdEERNS_19decompositionMethodERNS_16fvMeshDistributeE+0x3c6)[0x7faeba725e46]
[engine-VirtualBox:02727] [ 9] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libsnappyHexMesh.so(_ZN4Foam14meshRefinement16refineAndBalanceERKNS_6stringERNS_19decompositionMethodERNS_16fvMeshDistributeERKNS_4ListIiEEd+0x632)[0x7faeba7920a2]
[engine-VirtualBox:02727] [10] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libsnappyHexMesh.so(_ZN4Foam18snappyRefineDriver17featureEdgeRefineERKNS_20refinementParametersEii+0xabb)[0x7faeba6e8f2b]
[engine-VirtualBox:02727] [11] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libsnappyHexMesh.so(_ZN4Foam18snappyRefineDriver8doRefineERKNS_10dictionaryERKNS_20refinementParametersERKNS_14snapParametersEbS3_+0xcb)[0x7faeba6f032b]
[engine-VirtualBox:02727] [12] snappyHexMesh[0x416660]
[engine-VirtualBox:02727] [13] /lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0)[0x7faeb8cca830]
[engine-VirtualBox:02727] [14] snappyHexMesh[0x4175c9]
[engine-VirtualBox:02727] *** End of error message ***
[0] #0  Foam::error::printStack(Foam::Ostream&) at ??:?
[4] #11  Foam::snappyRefineDriver::doRefine(Foam::dictionary const&, Foam::refinementParameters const&, Foam::snapParameters const&, bool, Foam::dictionary const&) at ??:?
[4] #12   at ??:?
[0] #1  Foam::sigSegv::sigHandler(int)? at ??:?
[0] #2  ? at ??:?
[4] #13  __libc_start_main in "/lib/x86_64-linux-gnu/libc.so.6"
[0] #3  Foam::polyMeshAdder::insertVertices(Foam::HashTable<Foam::List<int>, Foam::edge, Foam::Hash<Foam::edge> > const&, Foam::Map<int> const&, Foam::List<int> const&, Foam::face const&, Foam::DynamicList<int, 0u, 2u, 1u>&, Foam::face&)[2] #0  Foam::error::printStack(Foam::Ostream&) in "/lib/x86_64-linux-gnu/libc.so.6"
[4] #14   at ??:?
[2] #1  Foam::sigSegv::sigHandler(int)? at ??:?
[0] #4  Foam::polyMeshAdder::mergePrimitives(Foam::polyMesh const&, Foam::polyMesh const&, Foam::faceCoupleInfo const&, int, Foam::List<int> const&, Foam::List<int> const&, Foam::Field<Foam::Vector<double> >&, Foam::List<int>&, Foam::List<int>&, Foam::List<Foam::face>&, Foam::List<int>&, Foam::List<int>&, int&, Foam::List<int>&, int&, Foam::List<int>&, Foam::List<int>&, Foam::List<int>&) at ??:?
[2] #2  ? at ??:?
[engine-VirtualBox:02728] *** Process received signal ***
[engine-VirtualBox:02728] Signal: Segmentation fault (11)
[engine-VirtualBox:02728] Signal code:  (-6)
[engine-VirtualBox:02728] Failing at address: 0x3e800000aa8
[engine-VirtualBox:02728] [ 0] /lib/x86_64-linux-gnu/libc.so.6(+0x354b0)[0x7f342d8214b0]
[engine-VirtualBox:02728] [ 1] /lib/x86_64-linux-gnu/libc.so.6(gsignal+0x38)[0x7f342d821428]
[engine-VirtualBox:02728] [ 2] /lib/x86_64-linux-gnu/libc.so.6(+0x354b0)[0x7f342d8214b0]
[engine-VirtualBox:02728] [ 3] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libdynamicMesh.so(_ZN4Foam13polyMeshAdder14insertVerticesERKNS_9HashTableINS_4ListIiEENS_4edgeENS_4HashIS4_EEEERKNS_3MapIiEERKS3_RKNS_4faceERNS_11DynamicListIiLj0ELj2ELj1EEERSG_+0x10f)[0x7f342f901b0f]
[engine-VirtualBox:02728] [ 4] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libdynamicMesh.so(_ZN4Foam13polyMeshAdder15mergePrimitivesERKNS_8polyMeshES3_RKNS_14faceCoupleInfoEiRKNS_4ListIiEESA_RNS_5FieldINS_6VectorIdEEEERS8_SG_RNS7_INS_4faceEEESG_SG_RiSG_SK_SG_SG_SG_+0xed2)[0x7f342f906c92]
[engine-VirtualBox:02728] [ 5] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libdynamicMesh.so(_ZN4Foam13polyMeshAdder3addERNS_8polyMeshERKS1_RKNS_14faceCoupleInfoEb+0x2fc)[0x7f342f90a59c]
[engine-VirtualBox:02728] [ 6] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libdynamicMesh.so(_ZN4Foam11fvMeshAdder3addERNS_6fvMeshERKS1_RKNS_14faceCoupleInfoEb+0x53)[0x7f342f826363]
[engine-VirtualBox:02728] [ 7] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libdynamicMesh.so(_ZN4Foam16fvMeshDistribute10distributeERKNS_4ListIiEE+0x286f)[0x7f342f88beef]
[engine-VirtualBox:02728] [ 8] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libsnappyHexMesh.so(_ZN4Foam14meshRefinement7balanceEbbRKNS_5FieldIdEERNS_19decompositionMethodERNS_16fvMeshDistributeE+0x3c6)[0x7f342f267e46]
[engine-VirtualBox:02728] [ 9] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libsnappyHexMesh.so(_ZN4Foam14meshRefinement16refineAndBalanceERKNS_6stringERNS_19decompositionMethodERNS_16fvMeshDistributeERKNS_4ListIiEEd+0x632)[0x7f342f2d40a2]
[engine-VirtualBox:02728] [10] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libsnappyHexMesh.so(_ZN4Foam18snappyRefineDriver17featureEdgeRefineERKNS_20refinementParametersEii+0xabb)[0x7f342f22af2b]
[engine-VirtualBox:02728] [11] /opt/openfoam4/platforms/linux64GccDPInt32Opt/lib/libsnappyHexMesh.so(_ZN4Foam18snappyRefineDriver8doRefineERKNS_10dictionaryERKNS_20refinementParametersERKNS_14snapParametersEbS3_+0xcb)[0x7f342f23232b]
[engine-VirtualBox:02728] [12] snappyHexMesh[0x416660]
[engine-VirtualBox:02728] [13] /lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0)[0x7f342d80c830]
[engine-VirtualBox:02728] [14] snappyHexMesh[0x4175c9]
[engine-VirtualBox:02728] *** End of error message ***
 at ??:?
[0] #5  Foam::polyMeshAdder::add(Foam::polyMesh&, Foam::polyMesh const&, Foam::faceCoupleInfo const&, bool) in "/lib/x86_64-linux-gnu/libc.so.6"
[2] #3  Foam::polyMeshAdder::insertVertices(Foam::HashTable<Foam::List<int>, Foam::edge, Foam::Hash<Foam::edge> > const&, Foam::Map<int> const&, Foam::List<int> const&, Foam::face const&, Foam::DynamicList<int, 0u, 2u, 1u>&, Foam::face&) at ??:?
[0] #6  Foam::fvMeshAdder::add(Foam::fvMesh&, Foam::fvMesh const&, Foam::faceCoupleInfo const&, bool) at ??:?
[2] #4  Foam::polyMeshAdder::mergePrimitives(Foam::polyMesh const&, Foam::polyMesh const&, Foam::faceCoupleInfo const&, int, Foam::List<int> const&, Foam::List<int> const&, Foam::Field<Foam::Vector<double> >&, Foam::List<int>&, Foam::List<int>&, Foam::List<Foam::face>&, Foam::List<int>&, Foam::List<int>&, int&, Foam::List<int>&, int&, Foam::List<int>&, Foam::List<int>&, Foam::List<int>&) at ??:?
[2] #5  Foam::polyMeshAdder::add(Foam::polyMesh&, Foam::polyMesh const&, Foam::faceCoupleInfo const&, bool) at ??:?
[2] #6  Foam::fvMeshAdder::add(Foam::fvMesh&, Foam::fvMesh const&, Foam::faceCoupleInfo const&, bool) at ??:?
[2] #7  Foam::fvMeshDistribute::distribute(Foam::List<int> const&) at ??:?
[2] #8  Foam::meshRefinement::balance(bool, bool, Foam::Field<double> const&, Foam::decompositionMethod&, Foam::fvMeshDistribute&)--------------------------------------------------------------------------
mpirun noticed that process rank 3 with PID 2727 on node engine-VirtualBox exited on signal 11 (Segmentation fault).

It's not clear where is the problem and which error is there

Thanks for help!

enginpower · February 16, 2017, 10:20

No one can help me on my problem?!?
Thanks

LVDH · February 16, 2017, 10:34

Quote:

Originally Posted by enginpower

The thickness in the meatus is of about 18e-3 mm, that is 18e-6 m. To have a complete idea of the model, it is long 33mm and 20mm large, then the radius of the two boxes is 10mm (so 33x20x10mm). The meatus has a circular shape, with a radius of about 3mm and long 11mm.

SnappyHexMesh only works well with boxes as a basis. Maybe my math is wrong but if you want to fit about ten cells in the thickness of this meatus with it being 11mm high you get an enormous amount of cells. About 2mm³ volume of the meatus with about 8e-9mm³ cells results into about 250e6 cells. I am wrong?

piu58 · February 16, 2017, 14:54

A few thoughts at your problem:
- Such problematic cases should be meshed manually (may be with the help of a special meshing program) and not given to some kind of meshing automate
- The problem is radial symmetric. Therefore it is easy to transform it in 2D. I recommend first experiment with a 2D model. May be you need 3d later, but you gain a lot of information from 2d which helps you later.

enginpower · February 20, 2017, 07:36

Quote:

Originally Posted by LVDH

SnappyHexMesh only works well with boxes as a basis. Maybe my math is wrong but if you want to fit about ten cells in the thickness of this meatus with it being 11mm high you get an enormous amount of cells. About 2mm³ volume of the meatus with about 8e-9mm³ cells results into about 250e6 cells. I am wrong?

You're almost right. Because if I choose to divide the meatus thin in 4 cells, and not 10, I need almost 20e6 cells, and it is more affordable, so I'd have a total of 30e6 cells.

The problem is: why I get some mesh, but there are some holes inside, as one column of cells in the meatus? That's my issue

About symmetry, it is already a cut of a symmetry part. @piu58, do you suggest me to create a simulation just of the symmetry plane, so the front plane of my model? Could you provide an help on how to set all conditions in this new configuration?

Thanks anyway

February 16, 2017, 14:54		#19
piu58 Senior Member Uwe Pilz Join Date: Feb 2017 Location: Leipzig, Germany Posts: 744 Rep Power: 15	A few thoughts at your problem: - Such problematic cases should be meshed manually (may be with the help of a special meshing program) and not given to some kind of meshing automate - The problem is radial symmetric. Therefore it is easy to transform it in 2D. I recommend first experiment with a 2D model. May be you need 3d later, but you gain a lot of information from 2d which helps you later. __________________ Uwe Pilz -- Die der Hauptbewegung überlagerte Schwankungsbewegung ist in ihren Einzelheiten so hoffnungslos kompliziert, daß ihre theoretische Berechnung aussichtslos erscheint. (Hermann Schlichting, 1950)

Similar Threads
Thread	Thread Starter	Forum	Replies	Last Post
[ANSYS Meshing] Very thin plate (0.1mm) ICEM CFD bad meshing	msormania	ANSYS Meshing & Geometry	1	April 30, 2012 08:45
thin extrusion meshing	guillaume	Siemens	3	November 4, 2008 09:53
thin extrusion meshing	guillaume	Phoenics	0	October 27, 2008 19:39
thin extrusion meshing	guillaume	Fidelity CFD	0	October 27, 2008 19:39
thin extrusion meshing	guillaume	Main CFD Forum	0	October 27, 2008 19:36

December 22, 2016, 16:41		#2
DarylMusashi Senior Member Holger Dietrich Join Date: Apr 2011 Location: Germany Posts: 174 Rep Power: 15	I know the commercial meshing software HEXPRESS/Hybrid by NUMECA, which is definitely a very good tool for meshing thin walls.

December 27, 2016, 10:34		#3
enginpower Member power Join Date: Jun 2014 Posts: 86 Rep Power: 12	Thanks to reply. But it is not open and free available, right?

December 28, 2016, 21:25		#4
DarylMusashi Senior Member Holger Dietrich Join Date: Apr 2011 Location: Germany Posts: 174 Rep Power: 15	Thats correct, its a commercial software. Maybe you (or your superior) might think about asking for a demo license (support@numeca.be). HEXPRESS/Hybrid meshes can be definitely converted to openFOAM format at the end of the process.

December 30, 2016, 09:58		#5
enginpower Member power Join Date: Jun 2014 Posts: 86 Rep Power: 12	My superior will expell me if I find a solution with a commercial software. It's part of a project to use only free and open solutions. Thanks anyway, @DarylMusashi I'm waiting a suggestions from others, if someone else wants to help. As you can see Image1.jpg Image2.jpg, I got some progresses, but I'd like to get the best solution, or to get the complete mesh of the shape without holes. Thanks to all those who want to help me

December 30, 2016, 20:30		#6
chegdan Senior Member Daniel P. Combest Join Date: Mar 2009 Location: St. Louis, USA Posts: 621 Rep Power: 0	The issue is that there needs to be at least 3 cells across the gap during castellation, snapping, and smoothing to actually create a surface. I would take my gap size (L_gap) and figure out the level or base mesh spacing (L_0) you need via L_gap/3 = L_0/(2^n) where n is the surface or volume refinement level you are applying. You can either fix n and adjust L_0 or fix L_0 and change n within a volume refinement region in your gap (or you could try a surface refinement if you split off the gap surfaces as separate STL surfaces). Good luck. arvindpj and student666 like this.

January 2, 2017, 14:01		#8
chegdan Senior Member Daniel P. Combest Join Date: Mar 2009 Location: St. Louis, USA Posts: 621 Rep Power: 0	You probably do not want a level of 14 in your domain because each cell in that region that is level 14 will turn into 8^(n-1) = 8^(14-1) cells. L_0 is with respect to each cell and it works best if each cell is a cube as well. You can also make a custom block mesh dict that has already refined cells near the small part of your STL. Make sure the small cells are still cubes and do not have large aspect ratios. As far as making an inlet and outlet, you can make those 1) separate STLs or child surfaces of the same stl prior to meshing and set the surface refinement and names for each surface or 2) use tools like topoSet + create patch to make patches on existing meshes.

January 4, 2017, 10:32		#10
chegdan Senior Member Daniel P. Combest Join Date: Mar 2009 Location: St. Louis, USA Posts: 621 Rep Power: 0	Read the last message just before your memory ran out: Code: Selected for internal refinement : 5938998 cells (out of 6059526) That means that 5.9 million cells are about to be refined and become 5.9 M +75.9M cells ~= 41 M cells. This is only to level 5, and you have internal refinement up to 9 in some places so it will increase even more. Post your case and geometry and I will see what i can do. Last edited by chegdan; January 4, 2017 at 10:50. Reason: grammar*

January 9, 2017, 08:05		#13
enginpower Member power Join Date: Jun 2014 Posts: 86 Rep Power: 12	Thanks, now it is clearer I'll try to upload all the case. Anyway, what I thought is that I created a surface for inlet, one for outlet and one for wall in the same file stl, folowing the same procedure described above, and maybe there are not connectected. I don't get any error message using the sequence commands (blockMesh, surfaceFeatureExtract, decomposePar, mpirun -np 6 snappyHexMesh -overwrite -parallel, reconstructParMesh -constant) So could be possible that the stl file is open somewhere? how to check this? What I think to do, is to put also the complete stl file, that is to have assembly.stl (wall+inlet+outlet) and meatus.stl (the complete model, as exported by the CAD software). Will this create some problem? Last edited by enginpower; January 10, 2017 at 07:27.

January 16, 2017, 04:52		#14
LVDH Member Andre Z Join Date: Dec 2009 Posts: 75 Rep Power: 17	You can check your stl files with surfaceCheck. Also you should use kdiff or something to check your two snappyHexMeshDicts to be sure that you are not doing something very different now. You should also check if the nodes from your walls and other surfaces match. This is possible in Paraview with the surface with edges display option. __________________ www.MantiumCAE.com

February 16, 2017, 10:20		#17
enginpower Member power Join Date: Jun 2014 Posts: 86 Rep Power: 12	No one can help me on my problem?!? Thanks