[staustrahltriebwerk]

Hey Guys, i know you must be tired of this sort of question, but i havent found a similar case in this forum.

I am trying to create a mesh of a wall with several drillholes in it. The wall including the holes is a stl file, created with AutoCAD.
When i run snappy, it refines the mesh but doesnt snap the cells to the stl surface, as you can see at the attached files. I tried to vary the refinement options (maybe too much cells), but that doesnt take effect.
I am sure to look at the mesh at time "2". The Mesh of the bounding box is nearly cubic.

Here are my blockMeshDict and snappyHexMeshDict:

/*---------------------------------------------------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  1.0                                   |
|   \\  /    A nd           | Web:      http://www.openfoam.org               |
|    \\/     M anipulation  |                                                 |
\*---------------------------------------------------------------------------*/

FoamFile
{
    version         2.0;
    format          ascii;

    root            "";
    case            "";
    instance        "";
    local           "";

    class           dictionary;
    object          blockMeshDict;
}

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


convertToMeters 1;

vertices        
(
    (-10 0 0)
    (12.057 0 0)
    (12.057  72.8598 0)
    (-10 72.8598 0)
    (-10 0 6.6)
    (12.057 0 6.6)
    (12.057 72.8598 6.6)
    (-10 72.8598 6.6)
);

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

edges           
(
);

boundary
(
    inlet
    {
        type patch;
        faces
        (
            (0 4 7 3)
        );
    }
    outlet
    {
        type patch;
        faces
        (
            (1 2 6 5)
        );
    }
    walls
    {
        type wall;
        faces
        (
            (0 1 5 4)
        (0 3 2 1)
        (2 3 7 6)
            (4 5 6 7)
        );
    }

);

mergePatchPairs 
(
);


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

/*---------------------------------------------------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  1.0                                   |
|   \\  /    A nd           | Web:      http://www.openfoam.org               |
|    \\/     M anipulation  |                                                 |
\*---------------------------------------------------------------------------*/

FoamFile
{
    version         2.0;
    format          ascii;

    root            "/home/penfold/mattijs/foam/mattijs2.1/run/icoFoam";
    case            "test2";
    instance        "system";
    local           "";

    class           dictionary;
    object          autoHexMeshDict;
}

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

// Which of the steps to run
castellatedMesh true;  // true;
snap            true;   // true;
addLayers       true;   // 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
{
    test2.stl
    {
        type triSurfaceMesh;
        name stlSurface;
    }

    refinementBox
    {
        type searchableBox;
        min (0 0 0);
        max (0.5 0.5 0.5);
    }
};



// Settings for the castellatedMesh generation.
castellatedMeshControls
{

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

    // While refining maximum number of cells per processor. This is basically
    // the number of cells that fit on a processor. If you choose this too small
    // it will do just more refinement iterations to obtain a similar mesh.
    maxLocalCells 1000000;

    // Overall cell limit (approximately). Refinement will stop immediately
    // upon reaching this number so a refinement level might not complete.
    // Note that this is the number of cells before removing the part which
    // is not 'visible' from the keepPoint. The final number of cells might
    // actually be a lot less.
    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 2;   // 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 "someLine.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
    {
        stlSurface
        {
            // Surface-wise min and max refinement level
            level (3 5);  // 5 6
        }
    }

    // Resolve sharp angles
    resolveFeatureAngle 15;   // 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
    {
        stlSurface
        {
        mode distance;
        levels ((0.1 5)(0.2 3)(1 2));
            mode inside;   // inside;
            levels ((1.0e+15 5));  //1E15 4
        }
    };


    // 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 (-5 0 3.3); 


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

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

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

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

    //- Highly experimental and wip: number of feature edge snapping
    //  iterations. Leave out altogether to disable.
    //  Do not use here since mesh resolution too low and baffles present
    //nFeatureSnapIter 10;
}



// Settings for the layer addition.
addLayersControls
{
    relativeSizes true;  //true;   // v 1.6
    // Per final patch (so not geometry!) the layer information
    layers
    {
        //minZ
        //{
        //    nSurfaceLayers 3;
        //}
        stlSurface_patch0   // a_surface_name
        {
            nSurfaceLayers 5;
        }
    }

    // Expansion factor for layer mesh
    expansionRatio 1.4;   // 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.
    //finalLayerRatio FINALLAYERRATIO;   // 0.3; 
    finalLayerThickness 0.6;   // 0.3;    // v 1.6

    //- 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.001;   // 0.1;

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


    // Advanced settings

    //- When not to extrude surface. 0 is flat surface, 90 is when two faces
    //  make straight angle.
    featureAngle 179;   // 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
    minMedianAxisAngle 130;

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

    // Overall max number of layer addition iterations   // v 1.6
    nLayerIter 50;   // v 1.6
}



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

    //- Max skewness allowed. Set to <0 to disable.
    maxBoundarySkewness 20;
    maxInternalSkewness 4;

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

    //- Minimum pyramid volume. Is absolute volume of cell pyramid.
    //  Set to very negative number (e.g. -1E30) to disable.
    minVol 1e-13;

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

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

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

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

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

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

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


    // Advanced

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


// Advanced

// Flags for optional output
// 0 : only write final meshes
// 1 : write intermediate meshes
// 2 : write volScalarField with cellLevel for postprocessing
// 4 : write current intersections as .obj files
debug 0;


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


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

Any ideas?

[wyldckat]

Greetings Thomas and welcome to the forum!

The only thing that I can find to be potentially wrong is the "locationInMesh", which is a value too round and likely to get placed on top of a face or vertex of a cell.

I suggest the following:

1. Create a smaller case, based on this geometry, with a single connecting cylinder.
2. Prepare the case for mesh generation. In a similar way to the tutorial "mesh/snappyHexMesh/flange".
3. Test if it works.
   If it does, run Allclean and pack your case inside a zip or tar.gz file and attach to your next post. If too big, share online in some site like Dropbox.

This way it is easier to diagnose what's wrong, since we'll be able to test this ourselves.

Best regards,
Bruno

[SirWombat]

Your SHM-Dict looks good, but surfaces not beeing snapped is a bug in OF 2.0.x Change to the new OpenFOAM (2.1.x) and it will (most certainly) work!

Watch your overall cell count. You have quite a large domain there and a lot of refinement.

G. Jan

[staustrahltriebwerk]

I solved the problem i think.
I added an additional stlsurface refinement region and lowered the refinement levels at higher distance to the stlsurface. Now i get a nice mesh.

The only thing that I can find to be potentially wrong is the "locationInMesh", which is a value too round and likely to get placed on top of a face or vertex of a cell.

That isnt allowed, too? I thought the locationInMesh need just to be a location anywhere in the mesh. I will change that.

Create a smaller case, based on this geometry, with a single connecting cylinder

That isnt appropiate for my case. In a further step the wall should move in y-direction, then just one hole will not be enough. I simulated this yesterday, but i got problems with the boundaries at the upper and lower wall. I must think about this.

Your SHM-Dict looks good, but surfaces not beeing snapped is a bug in OF 2.0.x Change to the new OpenFOAM (2.1.x) and it will (most certainly) work!

Watch your overall cell count. You have quite a large domain there and a lot of refinement.

I already run Version 2.1.1.
The cell count is very high, indeed. It took some time to generate the mesh

Now it works, thanks to both of you

[Turbulence]

Hi everyone,
I am studying free round jet flow in detail. PFA the computational domain.
My inlet is very small compared to rest of the domain. snappyHexMesh is not meshing the inlet pipe. I had tried a lot of things but of no use.
I am starting from the begining. So Any suggestions guys?
Thanks in advance
Turbulence.

[staustrahltriebwerk]

Have you tried to define a refinementBox around your inletpipe?

[Turbulence]

Hi staustrahltriebwerk
I had tried the refinement box thing. If my locationInMesh is in inlet pipe, then only inlet pipe remains after meshing. If my locationInMesh is in the big cylinder ,then only big cylinder remains. This is what happened in my previous runs. Any idea why?
Thanks
Turbulence.

[staustrahltriebwerk]

seems as if the pipe and the cylinder arent connected to each other. Which program do you use for stl generation?

[Turbulence]

Hi
I had used solidworks. For the background mesh I had used two separate boxes for bounding mesh. That may be the problem.
Fresh Story:
Now, I had set all the parameters false except castellatedMesh and proceeded with meshing. I made my background mesh very fine so as to make sure that it intersects my inlet pipe. PFA the images i had attached.
rough diagram of my blockMesh: http://www.cfd-online.com/Forums/att...-photo0221.jpg

The coloured object is my original geometry, and the wireframe is the mesh generated.As you can see in screenshot 3 instead of whole face only a small portion is getting meshed.
Any ideas?

Thank You Turbulence

[Turbulence]

Does my background mesh has anything to do with this problem?
Tried many things..still stuck with this issue.

[wyldckat]

Greetings Turbulence,

I'm not 100% certain I understand the problem here, but my deduction is this:

1. You're trying to mesh 2 cylinders, one really big one and another very small. The two are interconnected.
2. You have a base mesh that is customized to provide the best base mesh possible for your geometries. This is a very good and advisable idea!
3. The low resolution (2 cells!) in one of the directions for the small cylinder might be a bad idea. Additionally, this specific local box seems to be very tight to the small cylinder.
4. I can't see if the small cylinder is open on the side of the big cylinder. In other words, snappyHexMesh usually assumes that walls are to be preserved, so if there isn't a hole connecting the two cylinders, it's only natural that it won't work as you intend.

If you could share the case or share with a more basic STL file (in case the original STL contains sensitive data), it would be easier for us to give it a try!

Best regards,
Bruno

[Turbulence]

Hi Bruno

Thanks for replying. I just realized that the small cyclinder is not open to the big one. I will make this correction and run this case again , will get back to you. Please do let me know if there are any more suggestions before I run this case.


Thank You
Turbulence

[Turbulence]

Hi Bruno

I ran the case with only castellated mesh set as true. The big cylinder is meshed, and small one is totally disappeared!
Questions:
1.Should my background mesh be finer? Should I make sure that the back ground mesh cuts the inlet pipe(small cylinder) ?

2. Even If I make that background mesh finer, (its taking lot time to run bolckmesh) I am just able to cut the small cylinder at 2 points. Then the resulting inlet pipe turns to be a rectange/square. How can I make sure that the small circular inlet remains circular?

Thank You
Turbulence.

[wyldckat]

Hi Turbulence,

Create a refinement box for the castellation phase around this cylinder.
And on blockMesh, extend a bit more the box around this cylinder, by 1 or 2 mm if possible.

Best regards,
Bruno

[Turbulence]

Hi Bruno
I took your advise but the error couldn't be rectified. There must be something wrong with my snappyHexMeshDict. PFA the essential files required to run the case. Kindly look in this problem.

Thank you,
Turbulence.

[wyldckat]

Hi Turbulence,

I'm sorry to say, but this base mesh is really lousy Given the geometries at hand, you should create cylinders with blockMesh for the base mesh. Or at least, use cube-like cells, not parallelepipedic ones
Otherwise, even if you do generate a mesh with snappyHexMesh, it won't be very good.

I didn't even try running sHM because I don't have enough RAM on my machine 2.5 million cells for the base mesh is a lot and I'm expecting this to shoot up to 10 million during sHM.

I advise you to use these two tools:

• SwiftBlock
• SwiftSnap

They are for using with Blender and they should make your life really a lot easier!


The other hypothesis is to look here in the forum for:

cylinder blockMesh

Additionally, you should use a refinement cylinder instead of a refinement box...

Best regards,
Bruno

[Turbulence]

Hi Bruno

Thanks for the reply.My prof expects me to mesh learn meshing a solid geometry generated by solid works/catia(the geometry is pretty complex) using snappyhexmesh. So I don't have lot of options here.
I will try to use cylindrical background mesh as suggested by you. Will get back to you.

Thank a Lot
Turbulence.

[wyldckat]

Hi Turbulence,

I think I didn't explain properly: SwiftBlock and SwiftSwak are helper tools for setting up "blockMeshDict" and "snappyHexMeshDict". They themselves are not meshers!

But still, before these existed, people have to set the dictionaries manually. So search the forum and you should find a lot of pearls of wisdom!

Good luck!
Bruno

[Turbulence]

Thanks Bruno
I have managed to mesh the geometry 'satisfactory'LY
Still a problem is nagging me.
After running the snappyhexmesh, a unwanted surfaces is formed inside my inlet pipe.
(image1 patch d). Image 2(patch e) is the face of big cylinder in contact with my inlet pipe. The whole point of simulating a round jet is defeated here .

This unwanted surface is not lost even after running the snap , add layers part.
I am attaching the necessary code. I think it has something to do with my stl surface, but I cant find the mistake. Please look into it.

Thanks a lot for your help
Turbulence

[wyldckat]

Hi Turbulence,

I won't be able to look at this anytime soon... maybe this weekend. But in the meantime, I've picked up on this post:

Originally Posted by elvis

there is a brilliant tutorial (download and untar it "tar -xzf ") I believe it will guide you throught most of your SHM questions

The full link to where the tutorial is: http://www.openfoamworkshop.org/2012...enedeVilliers/

Best regards,
Bruno