Generate Rotor-Stator Type Meshes in snappyHexMesh

Before we delve into detail on how to generate rotor-stator type meshes in snappyHexMesh, I would like to clarify what I mean by that. A rotor-stator setup basically describes a mesh, where a certain region rotates around a given axis and the rest of the domain stays in place. To accomodate such large rotational motions, a sliding interface (AMI/GGI) is to be used, which in turn requires the mesh to be split into two parts.

There is a tutorial in the official release, on how to generate rotor-stator type meshes in snappyHexMesh. This tutorial uses snappyHexMeshonly to generate the mesh in a single run. This method turns out ot be very memory intensive with the mesh increasing in size. Additionally that method is fairly time intensive, when iterating towards a high quality mesh, as the entire mesh has to be kept in memory. Optimizing the rotor part of the propeller mesh is hence even more time intensive, than it is anyway. The method presented in this tutorial helps to circuumvent those memory issues, by generating the rotating and stationary parts of the mesh individually and combining them later on.

You might not see this now, but the general geometry is assumed to be a box-like ship, with a rudder attached to it. The rudder has to rotate freely and is hence located in the cylindral zone. As a ship is not very straight forward to mesh at a high mesh quality (in a short period of time, at least), the ship is replaced by a box. Though not being very sophisticated, it serves the purpose of showing how to mesh such things well.

Before we start, the geometry of the rotor (in this case the rudder) should be inspected visually. Special attention must be paid to the edges, extracted from the STL. It is important that all relevant edges are extracted properly. A short overview of how to extract the edges from a STL file and force snappyHexMesh to snap cell edges to geometry feature edges can be found here.

Screenshot of the rudder geometry

Screenshot of the cylinder, used for the interface between the rotating and stationary part of the mesh.

Stator Part

The first step is to generate the stator part of the mesh, which is not going to rotate. For the sake of this tutorial, a block is used as a geometry, that has a cylinder underneath it, which serves as the stator part of the AMI/GGI mesh. This cylinder is empty and will remain so, while generating thestator part of the mesh.

Closeup view on the AMI/GGI interface (cylinder) and the ship-like body, the rudder will be attached to.

It does not matter what kind of geometry you choose, as long as there is a patch in there, that is suitable to be used with an AMI/GGI interface. The cylinder was created in paraview, triagulated and saved to disk as an ASCII STL. This geometry is then defined in the geometry subdict ofsnappyHexMesh. The relevant parts for this meshing case are the following:

• Position the locationInMesh as such, that the area around the the cylinder is meshed and any cells inside get removed
• Set up surfaceFeatureExtract to extract any edges of the cylinder STL file
• Use the edge snapping feature of snappyHexMesh, in conjunction with theconstant/extendedFeatureEdgeMesh/<your file name>.extendedFeatureEdgeMesh. It is important to create a symlink to <your file name>.eMeshas snappyHexMesh does not read *.extendedFeatureEdgeMesh files.
• For sake of simplicity, I like to use the overwrite option with snappyHexMesh
• It is important, that the cylindrically shaped stator patch has its edges aligned properly and is not crucket or something. Otherwise the rotation in the actual simulation will blow up fairly quickly.

Keep in mind, that using the overwrite option with snappyHexMesh will store the final mesh in constant/polyMesh and no time directories will be generated. Therefore before eventually rerunning blockMesh, the constant/polyMesh directory should be cleaned properly, with keeping the blockMeshDict.

The remaining steps are fairly straight forward. Execute blockMesh and snappyHexMesh, iterate to the mesh you desire and that’s it for this step. It is advisable to put up a script that executes all requried steps, including using sed to replace some patch names:

1. #!/bin/sh
2. cd ${0%/*} || exit 1
4. # Source tutorial run functions
5. . $WM_PROJECT_DIR/bin/tools/RunFunctions
7. runApplication blockMesh
8. runApplication surfaceFeatureExtract
9. runApplication snappyHexMesh -overwrite
11. sed -i "s/cylinder_ascii/STATOR1/g" constant/polyMesh/boundar

Rotor Part

Compared to the stator mesh, a little bit more effort should be spend on the rotor mesh. Not only the cylinder must remain as symmetrical as possible, the rudder geometry inside should be as nicely discretised as possible. Copy the rudder geometry to constant/triSurface/rudder.stl and either copy or symlink the cylinder to constant/triSurface/cylinder.stl. The blockMeshDict solely needs to consist of a single block, filled with cubic cells. The dimensions must be just as large as the cylinder.

View of the entire rotor mesh, containing the rudder and the outer boundary, which
represents the cylindrical interface for AMI/GGI

The geometry subdictionary of the snappyHexMeshDict must contain two STL based geometries: the cylinder and the rudder. Again, the surface features must be extracted and used for the meshing process. In order not to miss any steps, a script to execute each step may come in handy:

1. #!/bin/sh
2. cd ${0%/*} || exit 1
4. # Source tutorial run functions
5. . $WM_PROJECT_DIR/bin/tools/RunFunctions
7. runApplication blockMesh
8. runApplication surfaceFeatureExtract
9. runApplication snappyHexMesh -overwrite
11. sed -i "s/cylinder_ascii/ROTOR1/g" constant/polyMesh/boundary
12. sed -i "s/rudder_ascii/RUDDER/g" constant/polyMesh/boundary
13. sed -i "20,26d" constant/polyMesh/boundary
14. sed -i "s/^3$/2/g" constant/polyMesh/boundary

It is important to rename the patches to something meaningful as well as to delete the defaultFaces boundary, that does not contain any faces and adjust the length of the boundary list accordingly (to 2). Please not that this all hard coded and special attention needs to be paid, as soon as the mesh topology changes significantely. Especially in terms of number and names of the boundaries.

Combining both Meshes

Combining the two meshes is fairly straight forward. The first step is to copy the stator mesh and delete any obsolete files and dictionaries, such as snappyHexMeshDict, the surfaceFeatureExtractDict and constant/extendedFeatureEdgeMesh. This case now contains solely the stator part. Using mergeMesh, the rotor part is going to be meged into the stator mesh. Unfortunately this results in a single mesh zone, with internal faces, which is not going to work for the simulations. Using topoSet, the faces and cells are split into two different zones, to account for the rotor and stator parts of the mesh.

The main issue with regards to automization of the entire process is that the boundary file in the merged mesh must be extended, as the rotor and stator patches must get a type of cyclicAMI and this requires additional entries to be added. Using sed, this can be automated to some degree, though I haven’t found a way to include proper linebreaks in a sed replacement. Currently this leads to a long line with spaces to seperate the added lines. The script currently looks like the following:

1. #!/bin/sh
2. cd ${0%/*} || exit 1 # run from this directory
4. # Source tutorial run functions
5. . $WM_PROJECT_DIR/bin/tools/RunFunctions
7. # Perform the sed action on the boundary file
8. function fixBoundary {
9. echo "Fixing Patch $1"
10. l=`grep -n -E "$1$" constant/polyMesh/boundary | grep -o -E "^[0-9]*"`
11. echo $l
12. typeLine=$[$l + 2]
13. sed -i "${typeLine}s/wall/cyclicAMI/g" constant/polyMesh/boundary
14. sed -i "${typeLine}a \
15. inGroups 1(cyclicAMI); \
16. matchTolerance 1e-4; \
17. transform noOrdering; \
18. neighbourPatch $2;" constant/polyMesh/boundary
19. }
21. export rotor='../rudder'
22. export stator='../box'
24. rm -rf constant/polyMesh
25. rm log.*
26. cp -r $stator/constant/polyMesh constant/
27. cp -r $stator/constant/triSurface constant/
29. runApplication mergeMeshes -overwrite . $rotor
30. runApplication topoSet
32. fixBoundary "ROTOR1" "STATOR1"
33. fixBoundary "STATOR1" "ROTOR1"

As you can see, topoSet is used as well. Setting up the topoSetDict can be tricky, depending on how acustomed you are with that tool. The trick is to generate two different mesh zones, one for the rotating part and the other one for the static part. The faces of the cylindrical boundary, there should be two almost identical ones, for the rotor and stator boundary, respectively. The topoSetDict looks like the following:

1. /*--------------------------------*- C++ -*----------------------------------*\
2. | ========= | |
3. | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
4. | \\ / O peration | Version: 2.1.x |
5. | \\ / A nd | Web: www.OpenFOAM.org |
6. | \\/ M anipulation | |
7. \*---------------------------------------------------------------------------*/
8. FoamFile
9. {
10. version 2.0;
11. format ascii;
12. class dictionary;
13. object topoSetDict;
14. }
16. // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
18. actions
19. (
20. // Convert stator patch to a faceSet
21. {
22. name AMI;
23. type faceSet;
24. action new;
25. source patchToFace;
26. sourceInfo
27. {
28. name "STATOR1";
29. }
30. }
31. // Get all cells in the region representing the rotor
32. {
33. name rotor;
34. type cellSet;
35. action new;
36. source regionToCell;
37. sourceInfo
38. {
39. nErode 0;
40. insidePoints ((-2.0 -0.4 -0.5));
41. }
42. }
43. // Convert cellSet to zone
44. {
45. name rotor;
46. type cellZoneSet;
47. action new;
48. source setToCellZone;
49. sourceInfo
50. {
51. set rotor;
52. }
53. }
54. // Get all cells and then get a subset of them, using regionToFace
55. {
56. name rotorFace;
57. type faceSet;
58. action new;
59. source boxToFace;
60. sourceInfo
61. {
62. boxes ((-1e5 -1e5 -1e5) (1e5 1e5 1e5));
63. }
64. }
65. {
66. name rotorFace;
67. type faceSet;
68. action subset;
69. source regionToFace;
70. sourceInfo
71. {
72. set rotorFace;
73. nearPoint (-2.4 0 -1);
74. }
75. }
76. {
77. name rotorFace;
78. type faceZoneSet;
79. action new;
80. source setToFaceZone;
81. sourceInfo
82. {
83. faceSet rotorFace;
84. }
85. }
86. );
88. // ************************************************************************* //

Now it is only a matter of executing each individual meshing script one at a time and combing them in the end, as shown in this section.

Read more: http://www.sourceflux.de/blog/generate-rotor-stator-type-meshes-in-snappyhexmesh/