Reference / Paper · 2024
Peak of Flight #618: Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2)
Apogee Components' Peak of Flight newsletter, issue 618 (2024-01-30).
- peak-of-flight
- apogee-components
- model-rocketry
Reference / Paper · 2024
Apogee Components' Peak of Flight newsletter, issue 618 (2024-01-30).
Apogee Components' Peak of Flight newsletter, issue 618 (2024-01-30).
Issue 618 / January 30th 2024 In This Issue: Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2) https://www.apogeerockets.com/Rocket-Kits/Skill-Level-2-Model-Rocket-Kits/Diamondback Issue 618 / January 30th, 2024 Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2) By John K. Bennett I n Part 1 of this article, we learned how to handle triangular, multi-sided, and other fin shapes based upon additive and subtractive geometry. In Part 2 we will generalize these techniques to allow us to estimate the flutter velocity of arbitrary fin shapes. Part 2 will make a lot more sense if Part 1 and Peak of Flight Issue #6151 (where I described the underlying calculations) are read first. Part 2 will involve some computer programming. Even if that is not your cup of tea, I hope that you will find useful information here. Analyzing Arbitrary Fin Shapes with Multi-Sided Polygon Triangulation Some fins designs may be sufficiently complex that their analysis is impractical using the methods we have discussed so far. Consider, for example, the fin design on the Apogee Peregrine2 rocket. This is a commercially available 4-inch rocket kit with an unusual fin design, as shown below: This fin design may not correspond to easily manipulated geometric elements like circles, triangles, rectangles, or ellipses. So, how do we calculate the area and centroid of fins like these? It turns out that we can generalize geometric decomposition to handle almost any fin design, from simple trapezoidal fins to the complex fin shown here. The basic idea follows the manual process we used for simple polygons: 1. Define the fin outline with a set of vertices. 2. Find a set of triangles within the fin that use these vertices. In Peak of Flight #4883,Tim Van Milligan demonstrated how complex curved fins such as these could be entered into RockSim by selecting vertices on a grid. These vertices are shown in the figure below. OpenRocket provides a similar mechanism for creating fins from a set of vertices. About this Newsletter 2 You can subscribe to recieve this e-zine FREE at the Apogee Components website www.ApogeeComponents.com, or by clicking the link here Newsletter Sign-Up 3. Calculate the area of each triangle from its vertices. The total fin area is the sum of the areas of the triangles. 4. Calculate Cx of each triangle. The Cx of the entire fin is the weighted average of the Cx’s of each triangle. Let’s take each of these steps one-by-one. Newsletter Staff Writer: John K. Bennett Editor: Tim Van Milligan Layout: Ryan Conway Issue 618 / January 30th, 2024 Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2) By John K. Bennett Obtaining the Vertices The vertices come straight from our simulator. For fins already defined by vertices, OpenRocket has an “Export CSV” button on its Freeform Fin Set Configuration page, as shown below. For trapezoidal fins, OpenRocket has a “Convert to Freeform” button on its Trapezoidal Fin Set Configuration page: which will produce a freeform page from which the vertices can be exported as above: 3 Issue 618 / January 30th, 2024 Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2) By John K. Bennett Creating the Triangles The exported fin vertices should define a closed polygon. The more vertices there are, the smoother any fin edge curve will be. For example, the Peregrine rocket fins define twenty-one vertices: RockSim does not make things quite this easy, but since OpenRocket can open a RockSim file to perform the export, you can use either simulator to design your fins. The vertex file exported by OpenRocket looks like this (for the four-vertex simple fin shown above): This text file has a header row that identifies the X and Y coordinate columns, as well as the unit system. Each row contains one vertex (with the x and y coordinates separated by a comma), and for some reason, an extra comma at the end of the row. 4 As we saw in Part 1, for small sets of vertices, it is possible to manually construct a set of triangles within the fin polygon. However, as the number of vertices grows, the manual process becomes tedious at best, and at some point, overwhelming. Fortunately, triangulation of polygons is a well-studied area of computational geometry. Much of that work revolves around the inherent complexity of the problem (how fast we can generate the triangles). As it turns out, modern computer graphics is based on creating and processing millions of triangles many times per second. One popular algorithm for polygon triangulation was created by Boris Delaunay in 19344. A desirable aspect of Delaunay’s approach is that it tries to minimize the number of triangles with very small angles, so called “sliver triangles.” However, the basic Delaunay algorithm treats the input vertices as just a set of vertices. This results in the algorithm generating extra triangles outside the fin boundary when it encounters a concave shape, as demonstrated in the image on the next page: Issue 618 / January 30th, 2024 Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2) By John K. Bennett To address this problem, the “constrained” Delaunay triangulation algorithm was developed. Constrained Delaunay triangulation assumes that the input vertices form a “planar straight-line graph”, or PSLG, that defines a closed boundary, and requires additional input in the form of non-crossing line segments built from the vertex set, all in one plane, that define that boundary. If we apply the constrained Delaunay triangulation algorithm5 to our set of vertices and segments, we get the following set of triangles: be found here8. There are also a wide selection of books and online resources for all things Python. Two of my two favorites among the many Python introductory books would be these9. We will initially use three Python software packages: numpy (a library for working with arrays), matplotlib (a library for creating graphs and charts), and triangle (the package that will perform the actual triangulation10). By using these packages, our (heavily commented) code to perform the triangulation is short (code-1 in the Appendix). If we run this code, we get the following output: It’s always a good idea to display the triangles that are produced as a check that everything went according to plan. If we are curious, we can see how many triangles were produced, and what the list of triangles looks like, by adding two lines (the last two lines shown below) to our code (code-2 in the Appendix). When we run the revised code, we get the following output (in addition to the plot above) (code-3 in the Appendix). This is the result that we want, but we are going to have to do a bit of computer programming to get there. The good news is that well-developed (and free) software packages exist to perform most of what we need to accomplish. Let’s work in Python, which has a rich set of software packages for scientific and engineering programming. You can download Python here6. A basic Python tutorial can be found here7. Help on installing Python packages can Each of the nineteen triangles is defined by three integers. These integers represent indices into the vertex array that we used as input to the triangulation process. For example, adding the (code-4 in the Appendix) will print the vertices of the first triangle (whose vertex indices are: [1, 0, 20]). Running this code prints (in addition to the previous output) the vertices of our first triangle (the one in the bottom left) (code-5 in the Appendix) 5 Issue 618 / January 30th, 2024 Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2) By John K. Bennett Calculating Fin Area and Cx Now that we have our triangles, we already know how to calculate fin area and Cx, given each triangle’s vertices. We just need to write the code to do this. Let’s add this code to what we already have (code-6 in the Appendix) We only need two triangles to characterize this fin, as demonstrated below: When we run this code, we get: (code-7 in the Appendix) Fin Area = 35.85 Fin Cx = 6.78 How cool is that? This program (Fin_Area_and_Cx.py) is available for download from GitHub11. It is worth noting that this program can analyze any fin set for which we can produce a set of vertices, from very simple trapezoidal fins to curved fins with holes. Let’s convince ourselves that this is true, starting with the original rocket/fin “worked example” in Peak of Flight #6151. The vertex file produced by that fin is: To compute Vf , we need to augment our program (using the same rocket and motor selections as the original PoF article). The entire program so far is shown below. Notice that we have imported another package, “math”, which we need to use square root and the constant pi. Also, in addition to computing Vf and Cx, we have added an inputs section, as well as ensuring that the program prints out the correct units for each result. (code-8 in the Appendix) When we run this code, we obtain the following output, confirming that we get the same answer as before: (code-9 in the Appendix) Note that printing of the intermediate calculations can be turned off by setting the constant “VERBOSE” to 0. The fin configuration that produced this file is shown below: Now, let’s go back and run this code on the Apogee Peregrine fin set. Do to this, we need to pick a motor. The motor mount tube of the Peregrine is 38mm, and 11 inches long. The Peregrine is intended for dual deployment, so we will be using a plugged motor. The highest total impulse 38mm motors that fit within the motor mount length are the Cesaroni I236-17A Blue Streak and the AeroTech I59WN-P. If we simulate a launch (using RockSim) with these motors, we get the following results: Issue 618 / January 30th, 2024 Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2) By John K. Bennett If we enter the highest velocity data (the I236BS) into our program (again turning off the “VERBOSE” switch in the code) and calculate Vf, we get: (code-10 in the Appendix) These data tell us that any 38mm H or I motor that fits within the motor mount dimensions will probably fly well in the Peregrine. If we are willing for the motor case to extend past the motor mount by up to an inch, these motors have the highest total impulse (RockSim launch simulation data is also shown): with a slow burn rate at the low end of the J total impulse range, e.g., the Cesaroni P38-5G Mellow (J94), which simulates as follows: (code-12 in the Appendix) The final program code that performs these calculations (Fin_Area_and_Cx_and_Input.py) can be downloaded from GitHub11. This downloadable version of the code can also optionally read a configuration file (e.g., “rocket. py”) that looks just like the input section of the code: (code-13 in the Appendix) This change allows us to create a separate file for each rocket/fin/launch site combination, without having to significantly edit the actual program text itself. We just need to name each file appropriately, and change “rocket” in the four lines of the program code shown below to be the chosen filename prefix. Alternatively, we could leave the program code untouched, and just change each configuration’s file name to “rocket.py” (only one at a time): (code-14 in the Appendix) If we enter the highest velocity data for these motors (the I435T) into our program and calculate Vf, we get: (code-11 in the Appendix) This is right on the edge of a safe flight, even on a cool day. The other motors are likely fine under most flight conditions, unless it’s a super-hot day. If we want to stretch to a J motor, we will need to carefully select one The program code must change slightly to support this optional input file, as shown below (this change has been incorporated in the downloadable version of the code11): (code-15 in the Appendix) Issue 618 / January 30th, 2024 Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2) By John K. Bennett End Notes It is possible to edit the triangle package input to include holes in the fins, e.g.: tr_input = dict(vertices=verts, segments=segs, holes=holes) This technique requires us to provide vertices and segments that define each hole, as well as a point within each hole. Completing this modification (more fully described in the Python triangle package documentation12) is left to the intrepid reader as an exercise. Before proceeding along these lines, it is probably wise to recall that holes in fins, from an aerodynamic perspective, may be a spectacularly bad idea. Finally, to reiterate what I said in both Part 1 and PoF #615, these methods only estimate the fin flutter velocity. The choice of input values (altitudes, temperatures, fin dimensions, and in particular, fin material shear modulus) will have a significant impact on the results. We will always strive to use the best data available, but it is important to remember that the final result is only an estimate. 1 https://www.apogeerockets.com/education/downloads/ Newsletter615.pdf 2 https://www.apogeerockets.com/Rocket-Kits/Skill-Level-3-ModelRocket-Kits/Peregrine https://www.apogeerockets.com/education/downloads/ Newsletter488_Large.pdf 3 4 https://www.mathnet.ru/links/a0aeb3483e137913db801557182e6e35/ im4937.pdf (in French) 5 L.P. Chew, SCG '87: Proceedings of the Third Annual Symposium on Computational Geometry, October 1987, Pages 215–222 6 https://www.python.org/downloads/ 7 https://www.w3schools.com/python/python_intro.asp 8 https://python.land/virtual-environments/installing-packages-withpip#Python_Install_Pip 9 https://www.amazon.com/gp/product/B071Z2Q6TQ and https://www.amazon.com/Python-Crash-Course-Eric-Matthes/ dp/1718502702 10 The Python triangle package is actually a Python “wrapper” around Jonathan Shewchuk’s two-dimensional mesh generator and Delaunay triangulator library, written in C (see https://www.cs.cmu.edu/~quake/ triangle.html). 11 https://github.com/jkb-git/Fin-Flutter-Velocity-Calculator 12 https://rufat.be/triangle/examples.html About the Author John Bennett is an engineering Professor Emeritus at the University of Colorado Boulder, and a TRA and NAR member in OregonRocketry. Using Brinley’s book as a guide, he built and flew many Zn/S and KN03/sugar rockets as a teenager. In retirement, he is now rediscovering his love of amateur rocketry, this time with better supervision. Issue 618 / January 30th, 2024 Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2) By John K. Bennett APPENDIX code-1 code-2 code-3 code-4 Issue 618 / January 30th, 2024 Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2) By John K. Bennett code-5 code-6 code-7 code-8 Issue 618 / January 30th, 2024 Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2) By John K. Bennett code-8 (continued) Issue 618 / January 30th, 2024 Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2) By John K. Bennett code-8 (continued) Issue 618 / January 30th, 2024 Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2) By John K. Bennett code-8 (continued) Issue 618 / January 30th, 2024 Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2) By John K. Bennett code-8 (continued) code-9 Issue 618 / January 30th, 2024 Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2) By John K. Bennett code-10 code-11 Issue 618 / January 30th, 2024 Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2) By John K. Bennett code-12 code-13 Issue 618 / January 30th, 2024 Calculating Fin Flutter Velocity for Complex Fin Shapes (Part 2) By John K. Bennett code-14 code-15