Advanced 6-DOF trajectory simulation for High-Power Rocketry.
RocketPy is a trajectory simulation for High-Power Rocketry built by Projeto Jupiter. The code is written as a Python library and allows for a complete 6 degrees of freedom simulation of a rocket's flight trajectory, including high fidelity variable mass effects as well as descent under parachutes. Weather conditions, such as wind profile, can be imported from sophisticated datasets, allowing for realistic scenarios. Furthermore, the implementation facilitates complex simulations, such as multi-stage rockets, design and trajectory optimization and dispersion analysis.
Nonlinear 6 degrees of freedom simulations
- Rigorous treatment of mass variation effects
- Solved using LSODA with adjustable error tolerances
- Highly optimized to run fast
Accurate weather modeling
- International Standard Atmosphere (1976)
- Custom atmospheric profiles
- Soundings (Wyoming, NOAARuc)
- Weather forecasts and reanalysis
- Weather ensembles
- Barrowman equations for lift coefficients (optional)
- Drag coefficients can be easily imported from other sources (e.g. CFD simulations)
Parachutes with external trigger functions
- Test the exact code that will fly
- Sensor data can be augmented with noise
Solid motors models
- Burn rate and mass variation properties from thrust curve
- CSV and ENG file support
Monte Carlo simulations
- Dispersion analysis
- Global sensitivity analysis
Flexible and modular
- Straightforward engineering analysis (e.g. apogee and lifting off speed as a function of mass)
- Non-standard flights (e.g. parachute drop test from helicopter)
- Multi-stage rockets
- Custom continuous and discrete control laws
- Create new classes (e.g. other types of motors)
Check out documentation details using the links below:
Join Our Community!
RocketPy is growing fast! Many unviersity groups and rocket hobbyist have already started using it. The number of stars and forks for this repository is skyrocketing. And this is all thanks to a great community of users, engineers, developers, marketing specialists, and everyone interested in helping.
If you want to be a part of this and make RocketPy your own, join our Discord server today!
Then, you can read the Getting Started section to get your own copy!
These instructions will get you a copy of RocketPy up and running on your local machine.
The following is needed in order to run RocketPy:
- Python >= 3.0
- Numpy >= 1.0
- Scipy >= 1.0
- Matplotlib >= 3.0
- netCDF4 >= 1.4 (optional, requires Cython)
All of these packages, with the exception of netCDF4, should be automatically installed when RocketPy is installed using either pip or conda.
However, in case the user wants to install these packages manually, they can do so by following the instructions bellow:
The first 4 prerequisites come with Anaconda, but Scipy might need updating. The nedCDF4 package can be installed if there is interest in importing weather data from netCDF files. To update Scipy and install netCDF4 using Conda, the following code is used:
$ conda install "scipy>=1.0" $ conda install -c anaconda "netcdf4>=1.4"
Alternatively, if you only have Python 3.X installed, the packages needed can be installed using pip:
$ pip install "numpy>=1.0" $ pip install "scipy>=1.0" $ pip install "matplotlib>=3.0" $ pip install "netCDF4>=1.4" $ pip install "requests"
Although Jupyter Notebooks are by no means required to run RocketPy, they are strongly recommend. They already come with Anaconda builds, but can also be installed separately using pip:
$ pip install jupyter
To get a copy of RocketPy using pip, just run:
$ pip install rocketpyalpha
Alternatively, the package can also be installed using conda:
$ conda install -c conda-forge rocketpy
If you want to downloaded it from source, you may do so either by:
- Downloading it from RocketPy's GitHub page
- Unzip the folder and you are ready to go
- Or cloning it to a desired directory using git:
$ git clone https://github.com/giovaniceotto/RocketPy.git
The RockeyPy library can then be installed by running:
$ python setup.py install
You can find RocketPy's documentation at Read the Docs.
Running Your First Simulation
In order to run your first rocket trajectory simulation using RocketPy, you can start a Jupyter Notebook and navigate to the nbks folder. Open Getting Started - Examples.ipynb and you are ready to go.
Otherwise, you may want to create your own script or your own notebook using RocketPy. To do this, let's see how to use RocketPy's four main classes:
- Environment - Keeps data related to weather.
- SolidMotor - Keeps data related to solid motors. Hybrid motor support is coming in the next weeks.
- Rocket - Keeps data related to a rocket.
- Flight - Runs the simulation and keeps the results.
A typical workflow starts with importing these classes from RocketPy:
from rocketpy import Environment, Rocket, SolidMotor, Flight
Then create an Environment object. To learn more about it, you can use:
A sample code is:
Env = Environment( railLength=5.2, latitude=32.990254, longitude=-106.974998, elevation=1400, date=(2020, 3, 4, 12) # Tomorrow's date in year, month, day, hour UTC format ) Env.setAtmosphericModel(type='Forecast', file='GFS')
This can be followed up by starting a Solid Motor object. To get help on it, just use:
A sample Motor object can be created by the following code:
Pro75M1670 = SolidMotor( thrustSource="../data/motors/Cesaroni_M1670.eng", burnOut=3.9, grainNumber=5, grainSeparation=5/1000, grainDensity=1815, grainOuterRadius=33/1000, grainInitialInnerRadius=15/1000, grainInitialHeight=120/1000, nozzleRadius=33/1000, throatRadius=11/1000, interpolationMethod='linear' )
With a Solid Motor defined, you are ready to create your Rocket object. As you may have guessed, to get help on it, use:
A sample code to create a Rocket is:
Calisto = Rocket( motor=Pro75M1670, radius=127/2000, mass=19.197-2.956, inertiaI=6.60, inertiaZ=0.0351, distanceRocketNozzle=-1.255, distanceRocketPropellant=-0.85704, powerOffDrag='../data/calisto/powerOffDragCurve.csv', powerOnDrag='../data/calisto/powerOnDragCurve.csv' ) Calisto.setRailButtons([0.2, -0.5]) NoseCone = Calisto.addNose(length=0.55829, kind="vonKarman", distanceToCM=0.71971) FinSet = Calisto.addFins(4, span=0.100, rootChord=0.120, tipChord=0.040, distanceToCM=-1.04956) Tail = Calisto.addTail(topRadius=0.0635, bottomRadius=0.0435, length=0.060, distanceToCM=-1.194656)
You may want to add parachutes to your rocket as well:
def drogueTrigger(p, y): return True if y < 0 else False def mainTrigger(p, y): return True if y < 0 and y < 800 else False Main = Calisto.addParachute('Main', CdS=10.0, trigger=mainTrigger, samplingRate=105, lag=1.5, noise=(0, 8.3, 0.5)) Drogue = Calisto.addParachute('Drogue', CdS=1.0, trigger=drogueTrigger, samplingRate=105, lag=1.5, noise=(0, 8.3, 0.5))
Finally, you can create a Flight object to simulate your trajectory. To get help on the Flight class, use:
To actually create a Flight object, use:
TestFlight = Flight(rocket=Calisto, environment=Env, inclination=85, heading=0)
Once the TestFlight object is created, your simulation is done! Use the following code to get a summary of the results:
To seel all available results, use:
Please read CONTRIBUTING.md for details on our code of conduct, and the process for submitting pull requests to us. - Still working on this!
- Creator: Giovani Hidalgo Ceotto
See the list of contributors who are actively working on RocketPy.
This project is licensed under the MIT License - see the LICENSE.md file for details
Want to know which bugs have been fixed and new features of each version? Check out the release notes.
Release history Release notifications | RSS feed
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
|Filename, size||File type||Python version||Upload date||Hashes|
|Filename, size rocketpy-0.9.8-py3-none-any.whl (83.1 kB)||File type Wheel||Python version py3||Upload date||Hashes View|
|Filename, size rocketpy-0.9.8.tar.gz (85.1 kB)||File type Source||Python version None||Upload date||Hashes View|