|
[Sponsors] |
[snappyHexMesh] Layers don't fully surround surface |
|
LinkBack | Thread Tools | Search this Thread | Display Modes |
July 10, 2012, 15:44 |
Layers don't fully surround surface
|
#1 |
New Member
Eric
Join Date: Jan 2012
Posts: 18
Rep Power: 14 |
Hello all,
I am using SnappyHexMesh for the first time since the previous cases I have ran seem to give an inaccurate boundary layer and I was hoping to fix this with SHM. I am importing a .stl file which was exported from a SolidWorks CAD model. The problem I seem to be having is that the layers which I have defined do not fully surround the surface. I have attached pictures to show what I mean. Another problem is that there are small dimples that form on the surface which are undesirable. How can I smooth these bumps out? Lastly, it seems like SHM likes to refine the mesh a lot on the symmetry line of the aircraft which I am meshing. The image attached should show you what I mean. Is this ok? How do I correct this? Here is my SHMDict: Code:
castellatedMesh true; //create mesh snap true; //cuts mesh at surface interface addLayers true; //creates layers on surface // 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 { FullX48b.stl //must be stored in triSurfaceMesh { type triSurfaceMesh; //NEW NAME FOR PATCH name FullX48b; } //scales and cleans stl file (run before importing) // surfaceConvert constant/triSurface/X48b.stl constant/triSurface/X48big.stl -clean -scale 100 /* refinementBox //some volume not defined as fine region..yet. { type searchableBox; min (-1.0 -0.7 0.0); max ( 8.0 0.7 2.5); } */ }; // 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 6; // The minimum amount of cells required between refinement region the more you have the more space needed to reach refinement max to refiement min // Explicit feature edge refinement // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //If you have special features (sharp angles, trailing edges...) //You can isoilate these features with //surfaceFeatureExtract -including angle 150 -minElement 10 constant/triSuraface/name.obj // (any 2 line of cells that make an angle above 150 will be included in this //extractedfeatureset) (outside angle between cells) or feature that have less then 10 elements // Specifies a level for any cell intersected by its edges. // This is a featureEdgeMesh, read from constant/triSurface for now. features ( //{ //name.obj // file "name.eMesh"; // level 2; //refinement for all extracted surfaces in name.obj files and name.emesh file //} ); // 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 { //X48b //patch you want to refine FullX48b { // Surface-wise min and max refinement level //;level(min ref level, max ref level) //which is which is based on the the resolve feature angle below level (6 8); } } // Resolve sharp angles resolveFeatureAngle 30; //cells above angle use the max ref level, cells below use min // Region-wise refinement // ~~~~~~~~~~~~~~~~~~~~~~ // Specifies refinement level for cells in relation to a surface. One of // three modes // - distance. 'levels' specifies per distance to the surface the // wanted refinement level. The distances need to be specified in // descending order. // - inside. 'levels' is only one entry and only the level is used. All // cells inside the surface get refined up to the level. The surface // needs to be closed for this to be possible. // - outside. Same but cells outside. refinementRegions { /* refinementBox { mode inside; levels ((1E15 4)); //say 3 levels away from a surface /distance (1e-04 1e-03, 1e-02,1e-01) //distance away from surface corresponding to a refinement level (must be in order so OF knows which refinement level) the number of distance dictates how many levels of refinement at a given distance //levels (max min) aka anything inside the refinebox (in this case) must have level 4 refiment }*/ } // 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 0); //importnant only when you have multiple domains // point states what is the inner region of the mesh so just make sure it's within the domain and not on or in a surface // 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; //??????? someone find out } // 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 5; //tolerance*cellsize on surface = distance to look for closest cell distance relative to local cell size to look for adjacent cells //- Number of mesh displacement relaxation iterations. nSolveIter 0; //deforms entire mesh to make good quality iterations //- Maximum number of snapping relaxation iterations. Should stop // before upon reaching a correct mesh. nRelaxIter 5; //relaxing sharp intersection makes smooth //- 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; //this is iterations to snap solely on the extracted special features } // Settings for the layer addition. addLayersControls { //adds boundary layers to a given surface // Are the thickness parameters below relative to the undistorted // size of the refined cell outside layer (true) or absolute sizes (false). relativeSizes true; //relative to local cell size at surface //if this if false you would have to specify in meters the finallayerthickness, with it on we just use a factor of the local cell size // Per final patch (so not geometry!) the layer information layers { FullX48b_FullX48B //X48b { nSurfaceLayers 7; } } // Expansion factor for layer mesh expansionRatio 1.2; //cells are growing in height by a factor of 1.2 away from the surface //- 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. // is the thickness of the layer furthest away from the wall. // See relativeSizes parameter. finalLayerThickness 0.3; //0.3*(local cell size) is the final layer thickness //- 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.1; //not enforced but seeks to meet this //- 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; //sometimes cells don't extrude away from surface due to cells meeting at a sharp angle this forces the cells to grow a layer away from the surface // Advanced settings //- When not to extrude surface. 0 is flat surface, 90 is when two faces // make straight angle. featureAngle 179; //this is how OF knows whether to not extrude a layer (nGrow forces this layer to extrude and disregards feature angle //- Maximum number of snapping relaxation iterations. Should stop // before upon reaching a correct mesh. nRelaxIter 8; // 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 5; // 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 30; } // Generic mesh quality settings. At any undoable phase these determine // where to undo. meshQualityControls { //- Maximum non-orthogonality allowed. Set to 180 to disable. maxNonOrtho 65; //- Max skewness allowed. Set to <0 to disable. maxBoundarySkewness 20; maxInternalSkewness 4; //- Max concaveness allowed. Is angle (in degrees) below which concavity // is allowed. 0 is straight face, <0 would be convex face. // Set to 180 to disable. maxConcave 80; //- Minimum pyramid volume. Is absolute volume of cell pyramid. // Set to a sensible fraction of the smallest cell volume expected. // 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; //as 0 it will always show mesh before snapping, after snapping, and after // Merge tolerance. Is fraction of overall bounding box of initial mesh. // Note: the write tolerance needs to be higher than this. mergeTolerance 1e-6; surface.jpg LE.jpg TE.jpg |
|
July 17, 2012, 12:06 |
|
#2 |
New Member
Charlie
Join Date: Aug 2010
Posts: 14
Rep Power: 16 |
I have adjusted many settings and have now been able to get the layers to surround the surface and I have smoothed most of the bumps out of it as well. The only problem I am having now is that my y+ is at an average of 67 and a max of 179. I need to drastically lower these values (below 10 I believe is the criteria). Is there an easy solution to this or tips that anyone might have as to how to lower these values. Thanks!
|
|
July 17, 2012, 12:50 |
|
#3 |
New Member
Eric
Join Date: Jan 2012
Posts: 18
Rep Power: 14 |
Sorry, the above post was from me but I was accidentaly logged onto my colleague's account.
|
|
July 23, 2012, 08:03 |
|
#4 |
Member
|
Eric,
In my very limited experience, I noticed that getting values of y+ below 10 is not really possible using snappy. I would be really glad if someone has a solution for this but till date, I was not able to find one. There is a utility called refineWallLayer which can help you split cells at the wall but most often than not, I ran into some kind of weirdness in the mesh after doing the same. ( checked the mesh using checkMesh) Also, how did you solve your problem ? I am assuming you did some manipulation with featureAngle for layer construction Kalyan |
|
July 24, 2012, 06:27 |
|
#5 |
Member
ms
Join Date: Mar 2009
Location: West London
Posts: 48
Rep Power: 17 |
Hi Eric,
I'm also interested in your snappyHexMesh file; could you please post it? For your information I've posted a successful snappyHexMesh for a circular cylinder with domed ends at, http://www.cfd-online.com/Forums/ope...curvature.html but I'm having troubles with getting a layer to run around sharp edges. Best regards, Mark. |
|
July 25, 2012, 09:27 |
|
#6 |
New Member
Eric
Join Date: Jan 2012
Posts: 18
Rep Power: 14 |
I messed around with a lot of the settings which always would make part of my mesh better and then it would then cause a different problem with the mesh. So to be clear I didn't just change one item. I also introduced the featureEdges to my SHMdict. One parameter that helped to get my layers to fully surround was under the maxFaceThicknessRatio under advanced settings. I had this value too low and therefore would stop the layer growth where there were "highly warped cells."
This is my SHMdict Code:
/*--------------------------------*- C++ -*----------------------------------*\ | ========= | | | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | | \\ / O peration | Version: 2.1.0 | | \\ / 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; //create mesh snap true; //cuts mesh at surface interface addLayers true; //creates layers on surface // 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 { X48B.stl //must be stored in triSurfaceMesh { type triSurfaceMesh; //NEW NAME FOR PATCH name X48B; } //scales and cleans stl file (run before importing) // surfaceConvert constant/triSurface/X48b.stl constant/triSurface/X48big.stl -clean -scale 100 /* refinementBox //some volume not defined as fine region..yet. { type searchableBox; min (-1.0 -0.7 0.0); max ( 8.0 0.7 2.5); } */ }; // 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; // The minimum amount of cells required between refinement region the more you have the more space needed to reach refinement max to refiement min // Explicit feature edge refinement // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //If you have special features (sharp angles, trailing edges...) //You can isoilate these features with ///surfaceFeatureExtract -writeObj -includedAngle 150 constant/triSurface/X48B.stl X // (any 2 line of cells that make an angle above 150 will be included in this //extractedfeatureset) (outside angle between cells) or feature that have less then 10 elements // Specifies a level for any cell intersected by its edges. // This is a featureEdgeMesh, read from constant/triSurface for now. features ( { //name.obj file "X48B.eMesh"; level 9; //refinement for all extracted surfaces in name.obj files and name.emesh file } ); // 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 { //X48b //patch you want to refine X48B { // Surface-wise min and max refinement level //;level(min ref level, max ref level) //which is which is based on the the resolve feature angle below level (6 8); } } // Resolve sharp angles resolveFeatureAngle 30; //cells above angle use the max ref level, cells below use min // Region-wise refinement // ~~~~~~~~~~~~~~~~~~~~~~ // Specifies refinement level for cells in relation to a surface. One of // three modes // - distance. 'levels' specifies per distance to the surface the // wanted refinement level. The distances need to be specified in // descending order. // - inside. 'levels' is only one entry and only the level is used. All // cells inside the surface get refined up to the level. The surface // needs to be closed for this to be possible. // - outside. Same but cells outside. refinementRegions { /* refinementBox { mode inside; levels ((1E15 4)); //say 3 levels away from a surface /distance (1e-04 1e-03, 1e-02,1e-01) //distance away from surface corresponding to a refinement level (must be in order so OF knows which refinement level) the number of distance dictates how many levels of refinement at a given distance //levels (max min) aka anything inside the refinebox (in this case) must have level 4 refiment }*/ } // 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 0); //importnant only when you have multiple domains // point states what is the inner region of the mesh so just make sure it's within the domain and not on or in a surface // 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; //??????? someone find out } // 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 10; //tolerance*cellsize on surface = distance to look for closest cell distance relative to local cell size to look for adjacent cells //- Number of mesh displacement relaxation iterations. nSolveIter 15; //deforms entire mesh to make good quality iterations //- Maximum number of snapping relaxation iterations. Should stop // before upon reaching a correct mesh. nRelaxIter 5; //relaxing sharp intersection makes smooth //- 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; //this is iterations to snap solely on the extracted special features } // Settings for the layer addition. addLayersControls { //adds boundary layers to a given surface // Are the thickness parameters below relative to the undistorted // size of the refined cell outside layer (true) or absolute sizes (false). relativeSizes true; //relative to local cell size at surface //if this if false you would have to specify in meters the finallayerthickness, with it on we just use a factor of the local cell size // Per final patch (so not geometry!) the layer information layers { X48B_FullX48B //X48b { nSurfaceLayers 3; } } // Expansion factor for layer mesh expansionRatio 1.2; //cells are growing in height by a factor of 1.2 away from the surface //- 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. // is the thickness of the layer furthest away from the wall. // See relativeSizes parameter. finalLayerThickness 0.2; //0.3*(local cell size) is the final layer thickness //- 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.1; //not enforced but seeks to meet this //- 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; //sometimes cells don't extrude away from surface due to cells meeting at a sharp angle this forces the cells to grow a layer away from the surface // Advanced settings //- When not to extrude surface. 0 is flat surface, 90 is when two faces // make straight angle. featureAngle 60; //this is how OF k nows whether to not extrude a layer (nGrow forces this layer to extrude and disregards feature angle //- Maximum number of snapping relaxation iterations. Should stop // before upon reaching a correct mesh. nRelaxIter 8; // Number of smoothing iterations of surface normals nSmoothSurfaceNormals 30; // Number of smoothing iterations of interior mesh movement direction nSmoothNormals 30; // Smooth layer thickness over surface patches nSmoothThickness 30; // Stop layer growth on highly warped cells maxFaceThicknessRatio 0.7; // Reduce layer growth where ratio thickness to medial // distance is large maxThicknessToMedialRatio 1; // Angle used to pick up medial axis points // Note: changed(corrected) w.r.t 17x! 90 degrees corresponds to 130 in 17x. minMedianAxisAngle 90; // Create buffer region for new layer terminations nBufferCellsNoExtrude 0; // Overall max number of layer addition iterations. The mesher will exit // if it reaches this number of iterations; possibly with an illegal // mesh. nLayerIter 30; } // Generic mesh quality settings. At any undoable phase these determine // where to undo. meshQualityControls { //- Maximum non-orthogonality allowed. Set to 180 to disable. maxNonOrtho 65; //- Max skewness allowed. Set to <0 to disable. maxBoundarySkewness 20; maxInternalSkewness 4; //- Max concaveness allowed. Is angle (in degrees) below which concavity // is allowed. 0 is straight face, <0 would be convex face. // Set to 180 to disable. maxConcave 80; //- Minimum pyramid volume. Is absolute volume of cell pyramid. // Set to a sensible fraction of the smallest cell volume expected. // 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; //as 0 it will always show mesh before snapping, after snapping, and after // Merge tolerance. Is fraction of overall bounding box of initial mesh. // Note: the write tolerance needs to be higher than this. mergeTolerance 1e-6; // ************************************************************************* // I have reduced my y+ to an average of 5.2 with a max of 35 (there are still small areas that I haven't resolved). |
|
July 25, 2012, 13:49 |
|
#7 | |
Retired Super Moderator
Bruno Santos
Join Date: Mar 2009
Location: Lisbon, Portugal
Posts: 10,980
Blog Entries: 45
Rep Power: 128 |
Greetings to all!
For those on this thread that haven't seen this information, I've picked up on this post which should help you with questions about sHM: Quote:
@EVBUCF: I hope you'll be able to figure out what to configure next in your "snappyHexMeshDict" file Best regards, Bruno
__________________
|
||
July 26, 2012, 17:19 |
|
#8 |
New Member
Eric
Join Date: Jan 2012
Posts: 18
Rep Power: 14 |
Thanks for the link Bruno! It does clear up a lot of questions I had. It seems like my only problem is having high y+ near the nose of the aircraft I am modelling. I attached an image to show what I mean. It looks like the layers are partially formed but not quite. No matter what the featureAngle is I cannot seem to get the layers to continue over this region. Any ideas?
|
|
July 27, 2012, 16:05 |
|
#9 |
Retired Super Moderator
Bruno Santos
Join Date: Mar 2009
Location: Lisbon, Portugal
Posts: 10,980
Blog Entries: 45
Rep Power: 128 |
Hi Eric,
Try not to confuse snappyHexMesh You've boosted the mesh resolution at the roundest area, which makes snappy wary of doing layers in that super-refined zone. I would try to do the mesh in two independent passes:
Good luck! Bruno
__________________
Last edited by wyldckat; July 27, 2012 at 16:06. Reason: see "edit:" |
|
July 28, 2012, 05:20 |
Thanks
|
#10 |
Member
ms
Join Date: Mar 2009
Location: West London
Posts: 48
Rep Power: 17 |
Hi Eric. Thanks for posting your changed snappyHexMeshDict.
Hello again Bruno. Thanks for posting the link! Slowly but surely, snappy (and openFoam) is starting to work for me. |
|
July 30, 2012, 16:45 |
|
#11 |
New Member
Eric
Join Date: Jan 2012
Posts: 18
Rep Power: 14 |
Thanks for the feedback Bruno that was my problem! It was too refined in the nose region so it halted the layers from being formed there. Everything looks to be as smooth as I can get it but if I have any updates past this point I will update. Here is my final SHMdict:
Code:
/*--------------------------------*- C++ -*----------------------------------*\ | ========= | | | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | | \\ / O peration | Version: 2.1.0 | | \\ / 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; //create mesh snap true; //cuts mesh at surface interface addLayers true; //creates layers on surface // 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 { X48B.stl //must be stored in triSurfaceMesh { type triSurfaceMesh; //NEW NAME FOR PATCH name X48B; } //scales and cleans stl file (run before importing) // surfaceConvert constant/triSurface/X48b.stl constant/triSurface/X48big.stl -clean -scale 100 /* refinementBox //some volume not defined as fine region..yet. { type searchableBox; min (-1.0 -0.7 0.0); max ( 8.0 0.7 2.5); } */ }; // 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; // The minimum amount of cells required between refinement region the more you have the more space needed to reach refinement max to refiement min // Explicit feature edge refinement // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //If you have special features (sharp angles, trailing edges...) //You can isoilate these features with ///surfaceFeatureExtract -writeObj -includedAngle 150 constant/triSurface/X48B.stl X // (any 2 line of cells that make an angle above 150 will be included in this //extractedfeatureset) (outside angle between cells) or feature that have less then 10 elements // Specifies a level for any cell intersected by its edges. // This is a featureEdgeMesh, read from constant/triSurface for now. features ( /*{ //name.obj file "X48B.eMesh"; level 9; //refinement for all extracted surfaces in name.obj files and name.emesh file }*/ ); // 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 { //X48b //patch you want to refine X48B { // Surface-wise min and max refinement level //;level(min ref level, max ref level) //which is which is based on the the resolve feature angle below level (6 8); } } // Resolve sharp angles resolveFeatureAngle 105; //cells above angle use the max ref level, cells below use min // Region-wise refinement // ~~~~~~~~~~~~~~~~~~~~~~ // Specifies refinement level for cells in relation to a surface. One of // three modes // - distance. 'levels' specifies per distance to the surface the // wanted refinement level. The distances need to be specified in // descending order. // - inside. 'levels' is only one entry and only the level is used. All // cells inside the surface get refined up to the level. The surface // needs to be closed for this to be possible. // - outside. Same but cells outside. refinementRegions { /* refinementBox { mode inside; levels ((1E15 4)); //say 3 levels away from a surface /distance (1e-04 1e-03, 1e-02,1e-01) //distance away from surface corresponding to a refinement level (must be in order so OF knows which refinement level) the number of distance dictates how many levels of refinement at a given distance //levels (max min) aka anything inside the refinebox (in this case) must have level 4 refiment }*/ } // 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 0); //importnant only when you have multiple domains // point states what is the inner region of the mesh so just make sure it's within the domain and not on or in a surface // 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; //??????? someone find out } // 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 10; //tolerance*cellsize on surface = distance to look for closest cell distance relative to local cell size to look for adjacent cells //- Number of mesh displacement relaxation iterations. nSolveIter 300; //deforms entire mesh to make good quality iterations //- Maximum number of snapping relaxation iterations. Should stop // before upon reaching a correct mesh. nRelaxIter 5; //relaxing sharp intersection makes smooth //- 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; //this is iterations to snap solely on the extracted special features } // Settings for the layer addition. addLayersControls { //adds boundary layers to a given surface // Are the thickness parameters below relative to the undistorted // size of the refined cell outside layer (true) or absolute sizes (false). relativeSizes true; //relative to local cell size at surface //if this if false you would have to specify in meters the finallayerthickness, with it on we just use a factor of the local cell size // Per final patch (so not geometry!) the layer information layers { X48B_FullX48B //X48b { nSurfaceLayers 3; } } // Expansion factor for layer mesh expansionRatio 1.15; //cells are growing in height by a factor of 1.2 away from the surface //- 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. // is the thickness of the layer furthest away from the wall. // See relativeSizes parameter. finalLayerThickness 0.2; //0.3*(local cell size) is the final layer thickness //- 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.01; //not enforced but seeks to meet this //- 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; //sometimes cells don't extrude away from surface due to cells meeting at a sharp angle this forces the cells to grow a layer away from the surface // Advanced settings //- When not to extrude surface. 0 is flat surface, 90 is when two faces // make straight angle. featureAngle 180; //this is how OF k nows whether to not extrude a layer (nGrow forces this layer to extrude and disregards feature angle //- Maximum number of snapping relaxation iterations. Should stop // before upon reaching a correct mesh. nRelaxIter 5; // 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.3; // Reduce layer growth where ratio thickness to medial // distance is large maxThicknessToMedialRatio 0.5; // Angle used to pick up medial axis points // Note: changed(corrected) w.r.t 17x! 90 degrees corresponds to 130 in 17x. minMedianAxisAngle 80; // Create buffer region for new layer terminations nBufferCellsNoExtrude 0; // Overall max number of layer addition iterations. The mesher will exit // if it reaches this number of iterations; possibly with an illegal // mesh. nLayerIter 50; } // Generic mesh quality settings. At any undoable phase these determine // where to undo. meshQualityControls { //- Maximum non-orthogonality allowed. Set to 180 to disable. maxNonOrtho 65; //- Max skewness allowed. Set to <0 to disable. maxBoundarySkewness 20; maxInternalSkewness 4; //- Max concaveness allowed. Is angle (in degrees) below which concavity // is allowed. 0 is straight face, <0 would be convex face. // Set to 180 to disable. maxConcave 80; //- Minimum pyramid volume. Is absolute volume of cell pyramid. // Set to a sensible fraction of the smallest cell volume expected. // 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.05; //- minimum normalised cell determinant //- 1 = hex, <= 0 = folded or flattened illegal cell minDeterminant 0.001; //- minFaceWeight (0 -> 0.5) minFaceWeight 0.05; //- minVolRatio (0 -> 1) minVolRatio 0.01; //must be >0 for Fluent compatibility minTriangleTwist -1; // Advanced //- Number of error distribution iterations nSmoothScale 4; //- amount to scale back displacement at error points errorReduction 0.75; } // 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; //as 0 it will always show mesh before snapping, after snapping, and after // Merge tolerance. Is fraction of overall bounding box of initial mesh. // Note: the write tolerance needs to be higher than this. mergeTolerance 1e-6; // ************************************************************************* // |
|
July 30, 2012, 17:06 |
|
#12 |
Retired Super Moderator
Bruno Santos
Join Date: Mar 2009
Location: Lisbon, Portugal
Posts: 10,980
Blog Entries: 45
Rep Power: 128 |
Hi Eric,
A valuable advice when analyzing a section cut of a mesh in OpenFOAM: use "Extract Cells By Region" and the polyhedral option should be active as well! Example: http://www.cfd-online.com/Forums/ope...tml#post372605 Best regards, Bruno
__________________
|
|
August 17, 2012, 07:04 |
|
#13 |
Senior Member
Eloïse
Join Date: Jul 2012
Location: Trondheim, Norway
Posts: 113
Rep Power: 14 |
Hi Bruno,
Thanks for the nice tips! However, the link to the tutorial (which looks recent) seems to be dead. Could you update it? Thanks |
|
August 18, 2012, 05:42 |
|
#14 |
Retired Super Moderator
Bruno Santos
Join Date: Mar 2009
Location: Lisbon, Portugal
Posts: 10,980
Blog Entries: 45
Rep Power: 128 |
Hi Eloise,
I went a step beyond that and added a new page to the openfoamwiki.net: http://openfoamwiki.net/index.php/SnappyHexMesh There you'll find a link to a copy of that priceless presentation Best regards, Bruno
__________________
|
|
August 20, 2012, 04:31 |
|
#15 |
Senior Member
Eloïse
Join Date: Jul 2012
Location: Trondheim, Norway
Posts: 113
Rep Power: 14 |
Thanks Bruno, it is indeed a very good presentation.
|
|
Tags |
shm, snappyhexmesh |
Thread Tools | Search this Thread |
Display Modes | |
|
|
Similar Threads | ||||
Thread | Thread Starter | Forum | Replies | Last Post |
Add layers on the whole surface | Emanueledes | OpenFOAM | 10 | December 19, 2017 14:40 |
Remeshing 2d surface for layers | Grigoriy_Ermolaev | ANSA | 2 | July 19, 2016 07:50 |
Cluster ID's not contiguous in compute-nodes domain. ??? | Shogan | FLUENT | 1 | May 28, 2014 15:03 |
[snappyHexMesh] Effect of adding layers with sHM | Nucleophobe | OpenFOAM Meshing & Mesh Conversion | 4 | August 20, 2012 16:45 |
[Gmsh] boundaries with gmshToFoam | ouafa | OpenFOAM Meshing & Mesh Conversion | 7 | May 21, 2010 12:43 |