rocketpy-team / rocketpy-hackathon-2022 Goto Github PK

Short Description:
Aeroelasticity problem is an important phenomena to care about when launching a rocket

Long Description:
Improve current Fin Flutter calculation, trying to add any new sophisticated method. You're free to propose any different source or approach, as long as you refer all your assumptions. This is not related with the the other flutter issue in this hackathon.

Useful links:
http://www.aerorocket.com/finsim.html; https://github.com/mid2SUPAERO/MastersRP-Akshay-GUPTA

Short Description:
Optimize the execution time of Environment Analysis Class

Long Description:
If we take a look at the data treatment functions available at Environment Analysis class of rocketPy, we are going to see that there are opportunities for saving some time. The basic problem now is that it takes too much time to run a simple dataset.

Short Description:
Fins are currently trapezoidal or elliptical on RocketPy, but real life is not that easy

Long Description:
We currently only accept trapezoidal and elliptical fins. Implement a model that allows for the use of parabolic fins or free geometry fins.

Useful links:
RocketPy/docs/technical/aerodynamics at develop · RocketPy-Team/RocketPy (github.com)

https://github.com/openrocket/openrocket/releases/download/Development_of_an_Open_Source_model_rocket_simulation-thesis-v20090520/Development_of_an_Open_Source_model_rocket_simulation-thesis-v20090520.pdf

Short Description:
It was a simple function when created,

Long Description:
Currently the Flight.calculateFinFlutterAnalysis method works only when a single set of fins is created, which may not be the reality of all cases. Can you try to solve this problem? You could also investigate if we could place the function at the utilities function or not

Short Description:
Reorganize the addFins functions into a class

Long Description:
There are currently two functions that add fins to the rocket: addTrapezoidalFins and addEllipticalFins. Both these functions have repeated code that could be avoided and better organized with a seperate Class for the fins. This issue ties in with issue #classAerodynamicSurfaces

Short Description:
Add terminateAtApogee parameter

Long Description:
If you want to make the simulation stop at apogee, you can use the terminateOnApogee parameter on the flight object. But what about when you want to stop the simulation at the moment the rocket leaves the rail? Add a similar parameter!

Currently, for RocketPy, the rocket is considered to be out of rail at the moment the uppermost rail button leaves the rail.

Useful links:
Try to find terminateAtApogee at the code

Short Description:
Add the option to save atmospheric data

Long Description:
Make it so there is a option to save the atmospheric model used in a simulation, so we can use the exact same set of data any time we want. This is especially useful for forecasts!

Short Description:
Minimizing drag would be an amazing addition to RocketPy

Long Description:
Given a desired static margin, how could rocketpy optimize aerodynamic surfaces to reduce overall drag force?

Short Description:
Allow flight without a launch rail

Long Description:
The current implementation expects that the rocket has rail buttons and the Environment a rail. Make this an optional feature. Suggestion: Disable wind in environment or give the rocket an initial velocity while testing so it can make a stable flight.

Short Description:
Calculate the mean of ensemble members and make it usable in simulations

Long Description:
Make it an option for the ensemble atmospheric model to use the mean of all the ensemble members for the simulation. Need to check documentation, mainly.

Useful links:
Selected Ensemble members issue #53 · Projeto-Jupiter/RocketPy (github.com)

Short Description:
Create a notebook that explains how to perform a multi stage rocket simulation with RocketPy

Long Description:
Create a Notebook that describes and explains how to perform a multi stage rocket simulation with RocketPy. If you search a little bit you're going to find that someone already created such simulation, but it was not given as an example notebook though.

Useful links:
RocketPy-Team#45 (comment)

Short Description:
Implement ground level check for rocket impact

Long Description:
Since the Earth is not flat, we can implement some functions that allow us to more accurately determine the impact coordinates by searching the point where the rocket crosses the ground. Good candidates for this job are SRTM data.

Short Description:
Create a notebook for the Rocket class

Long Description:
Create a Rocket Usage notebook for the Rocket class. This notebook should explain how to use the class and what are some of its parameters and methods. See other class usage notebooks for example

Short Description:
Calculate the bending moment no the rail buttons and present that information

Long Description:
Currently there are evaluations for Normal and Shear Forces on Rail Buttons,
It's lacking only bending moments calculations.
Include their calculations in the code!!

Useful links:
Rail Buttons Force and Moments Calculation · Issue #27 · Projeto-Jupiter/RocketPy (github.com)

Short Description:
Add drag calculation to any aerodynamic surfaces

Long Description:
Currently, the drag coefficients for the rocket must be set as an input in the powerOn and powerOff parameters. Make RocketPy calculate the drag coefficient without the need of an external software

Useful Links:
RocketPy-Team#112; https://dspace.mit.edu/handle/1721.1/1701

Short Description:
Integrating control methods and RocketPy

Long Description:
Add a method to the Rocket class that allows the user to define a continuous or discrete-time closed-loop control function to be simulated during flight.

Short Description:
Always trying to be flexible, now RocketPy should support any aerodynamic surface.

Long Description:
Currently, the Rocket class only allows aerodynamic forces to be computed on predetermined surfaces: fins, nosecone or tail. Implement an option to insert a custom aerodynamic surface, where the user can freely provide what the lift, drag or aerodynamic moment will be on that surface during flight. For instance, the user could be trying to implement a body with non null lift coefficient.

Short Description:
Add the ability to calculate average wind heading profile on the Environment Analysis class

Long Description:
Currently there's a problem when analysing wind heading. It's related to bearing compass range limits (0° - 360º), which creates a tricky phenomena when we try to interpolate values when 2 adjacent points crosses the 0º/360º limit. See the conversation on PR 197 to get familiar with, and then try to propose a method that handle with creation of average wind heading profile

Useful links:
RocketPy-Team#197

Short Description:
Consolidate dispersion simulations in an easier approach

Long Description:
Everything regarding the dispersion analysis is all in a notebook. Add Dispersion to the code via a Class Dispersion. The final result must be an easy-to-use simulation.

Short Description:
Make it possible to simulate a rocket that at some point in the flight loses one of its fins.

Long Description:
Make it possible to simulate a rocket that at some point in the flight loses one of its fins.

Short Description:
Implement the Prandtl factor on the Tail and Nosecone

Long Description:
Currently we have calculation of Lift Coefficient derivative in function of Mach Number through the beta parameter - see def beta in the code – only for fins. This provides a more realistic solution when the Mach number approaches 1. This dependency comes from the Prandtl factor which corrects subsonic force coefficients for compressible flow.

Implement the use of the Prandtl factor in some way in the Tail and Nosecone lift coefficient derivative calculation.

Useful Links:
https://github.com/Projeto-Jupiter/RocketPy/issues/133
https://github.com/openrocket/openrocket/releases/download/Development_of_an_Open_Source_model_rocket_simulation-thesis-v20090520/Development_of_an_Open_Source_model_rocket_simulation-thesis-v20090520.pdf

Short Description:
Remodelling an important and currently time-consumption function

Long Description:
Using the property decorator, we could create a managed attribute for each post process variable and really calculate them only when they are called, independently.

Useful links:
What if we rearrange postProcess method? · Issue #164 · Projeto-Jupiter/RocketPy (github.com)

Short Description:
Add the possibility to select which input parameters the users want to vary and which parameters they want to see as outputs of Monte Carlo simulations

Long Description:
The most used example of Monte Carlo simulations using RocketPy is the example notebook. However, the time has shown to us that usually users only modify values on the simulation, not the code structure itself. This addition would allow us to reach more dispersion simulations.

Short Description:
Propose a new model to describe the variation in the position of the engine's center of mass during flight.

Long Description:
Currently, for solid motors, the position of the center of mass is assumed to be fixed. However, to correctly simulate a hybrid motor, it is necessary to calculate the initial position of the center of mass of the loaded motor and how it varies during flight. propose a mathematical model that allows calculating the variation of the center of mass within a hybrid (or liquid) motor taking into account the variation of the mass of the solid fuel and the liquid oxidant

Short Description:
Create notebook simulating deployable payload flight

Long Description:
Deployable payload are not so rare in most rocket and launch vehicle flights. It's about time for us to discover whether rocketPy can handle with this kind of flight or not.

Useful links:
RocketPy-Team#45 (comment)

Short Description:
A new class to be used right after the Flight class

Long Description:
There are many different type of analysis that can be made using RocketPy, such as the apoggeByMass function or outOfRailVelocityByMass. Other type of this kind of optimizations are also possible, as you can see in the getting started notebook. Create a class that can fit these analysis into the code.

Useful links:
Getting started notebook at the rocketpy's main page

Short Description:
Create a notebook os script describing the simulation of a 2D flight

Long Description:
The rocket can only varying in to directions (x and z). This is important for some cases and proof of concepts during the design phases. Tip: What happens if you simulate a flight in an environment without wind?

Short Description:
Modifying equations of motion in the currently code can be difficult, let's try a new approach then

Long Description:
Utilize some symbolic manipulation method (e.g.: sympy) and implement the equations of motion, that already exist, in this new system. Perform the integration with the numerical integrator leave the equations ready in the symbolic manipulation system.

Useful links:
https://www.sympy.org/en/index.html

Short Description:
Create Aerodynamic Surfaces Class

Long Description:
Reorganize all the aerodynamic surfaces (Tail, Nosecone and Fins) into a single class so it can better handle aerodynamic information. You can base your code on the Fin discussion on PR RocketPy-Team#206 comments

Useful links:
https://github.com/Projeto-Jupiter/RocketPy/pull/206

Short Description:
Implement a simple drawing to better illustrate all the input parameters

Long Description:
Especially with regards to position inputs, sometimes it is hard for new users to understand what values to input in each function. Try to create a drawing (or any better ideia) to help iusers. This should be attached, somehow, to the documentation page of rocketpy

Useful links:
https://docs.rocketpy.org/en/latest/?badge=latest

Short Description:
Fix broken links and images in the rocketpy documentation page

Long Description:
The current start page of our documentation, which is pretty much the ReadMe, contains broken links and images. Navigate to https://docs.rocketpy.org/en/latest/ and scroll down until Supporting RocketPy and Contributing or Authors and Contributors. You will notice broken links and images, as shown below. This is also an opportunity to start working with documentations, creative ideas or implementation may receive some extra points.

Useful links:
Docs: Broken links and images · Issue #204 · Projeto-Jupiter/RocketPy (github.com)

Short Description:
Implement a more realistic earth model

Long Description:
A model that considers the flat earth is currently used. Implement code modifications so that the simulations consider the real shape of the Earth. Analyze reference ellipsoid models and gravity models

Useful links:
Ellipsoid model: https://en.wikipedia.org/wiki/Earth_ellipsoid

Gravitational model: https://en.wikipedia.org/wiki/Earth_Gravitational_Model

Short Description:
Add magnetic field to the environment class

Long Description:
Add a way to receive magnetic field to the environment class. This is especially useful for IMU comparisons!

Short Description:
Add airfoil information to Rocket.allInfo() method

Long Description:
Not so long ago, we had RocketPy-Team#140 solving bugs regarding airfoil implementation.
It's true that now rocketpy is dealing very well with these non-flat fins, however some plots and maybe some airfoil information could be implemented in the rocket.py file to show to the user.

Some of them could be:

Simple plot of airfoil data the user inputted by addFins() method
Derivative of Lift coefficient by angle of attack
But of course feel free to add any other information you consider important!

Useful links:
https://github.com/Projeto-Jupiter/RocketPy/issues/144

Short Description:
What do we need to run faster?

Long Description:
Implement improvements that help RocketPy running flight (or dispersion analysis) simulations faster, possibly allowing the computer to run multiple simulations in parallel mode

Short Description:
Use the environment analysis as an environment in the simulation

Long Description:
Create a way to get an Environment object from a Environment Analysis results

Short Description:
Implement the apogeeByMass function that is found in the notebooks, in the code

Long Description:
Add, in a efficient way, the apogeeByMass function straight to the source code of RocketPy. This function can be found in the getting_started.ipynb notebooks. We suggest start investigating whether this could become a part of utilities.py class

Useful links:
https://github.com/Projeto-Jupiter/RocketPy/blob/5c65decb5caadc28a8c02deb4d2e8c14c3d3d3a4/docs/notebooks/getting_started.ipynb

Short Description:
Fins will not always be ideally placed on the rocket

Long Description:
Modify RocketPy so fins can be implemented not necessarily regularly spaced.

Useful links:
https://en.wikipedia.org/wiki/Dihedral_(aeronautics); https://openrocket.info/documentation.html; https://ntrs.nasa.gov/citations/20010047838

Short Description:
Use real rocket data to validate (or not) rocketpy's roll moment simulation

Long Description:
RocketPy already accept roll moment calculation when the fins are positioned with a cant angle. However, we have never had the chance to compare simulated results against actual trajectory flight data.

Useful links:
Here we performed a comparison of some rockets: https://github.com/RocketPy-Team/RocketPaper

Short Description:
Make the rocket inertia products an input for the simulation

Long Description:
Make the rocket inertia products an input for the simulation, analyzing whether it will bring significant differences or not

Short Description:
Add different boattail shapes

Long Description:
Currently RocketPy only considers for its simulation conical tails. Implement other tail shapes, much like the Nosecone.

The implementation would require two thing that would need to be researched:

1. The formula for the lift coefficient derivative for that tail shape
2. The formula for the center of pressure for that tail shape

Short Description:
Create a notebook for the Flight class

Long Description:
Create a Flight Usage notebook for the Flight class. This notebook should explain how to use the class and what are some of its parameters and methods. See other class usage notebooks for example, we suggest to start by the environment class usage.

Short Description:
Implementation of neural networks to control the 6 degrees of freedom of the rocket during flight.

Long Description:
Implementation of neural networks to control the 6 degrees of freedom of the rocket during flight.

Short Description:
Dispersion analysis can take a while to run, sometimes we need to schedule multiple simulations and go to sleep. Ensure everything is ready once the user wakes up.

Long Description:
Build a notebook that makes it easy to simulate multiple flights in sequence, specially for multiple dispersion analysis scenarios. Be sure to comment on it accordingly.

Short Description:
Air brakes are used to increase drag when the rocket is about to overcome the target apogee

Long Description:
Air breakers are used to drastically increase drag when the rocket is about to overcome the target apogee. Bring to RocketPy whatever is needed that simulation

Short Description:
Deduce the equations of motion and implement the code for when the rocket is attached to the rail with only one rail button

Long Description:
When there is only one rail button sliding on the launch rail, the rocket can only move in one plane, with 3 degrees of freedom. Deduce the equations of motion and write their code.

Useful links:
https://drive.google.com/file/d/1HFDmLuQ65gRiR_I-2Ocy67TkZbSvGeOF/view?usp=sharing

Short Description:
Currently RocketPy uses Barrowman's equation to determine the lift coefficient of each aerodynamic surface. Bring any new and more sophisticated method to RocketPy.

Long Description:
Implement a method alternative to Barrowman's equation so RocketPy can calculate lift coefficients for the different aerodynamics surfaces. We recomend https://en.wikipedia.org/wiki/Vortex_lattice_method.

Short Description:
Create a notebook for the Function class

Long Description:
There's a rumor that the Function class is actually the most critical and important function available at RocketPy. Being true or not, the fact is that people would be impressed if they get to know a bit more about Function, what if we show to the world using an example notebook?

Short Description:
Add precipitation to the simulation

Long Description:
Currently RocketPy does not know if it is raining or not. Try to implement features that solve this problem.

Short Description:
Add ability to simulate IMU (inertial measurement unit) inside the rocket.

Long Description:
It would be really useful to compare different attitude estimation algorithms. Useful to GNC (guidance, navigation, and control).

Useful links:
RocketPy-Team#198