diff --git a/docs/notebooks/SolidMotor_class_usage.ipynb b/docs/notebooks/SolidMotor_class_usage.ipynb
index ed43fd274..582efc2ab 100644
--- a/docs/notebooks/SolidMotor_class_usage.ipynb
+++ b/docs/notebooks/SolidMotor_class_usage.ipynb
@@ -76,6 +76,7 @@
"MOTOR = SolidMotor(\n",
" thrustSource=1500,\n",
" burnOut=5.3,\n",
+ " distanceNozzleMotorReference=0.40396,\n",
" reshapeThrustCurve=False,\n",
" grainNumber=6,\n",
" grainSeparation=6 / 1000,\n",
@@ -513,6 +514,7 @@
"MOTOR = SolidMotor(\n",
" thrustSource=r\"../../data/keron/thrustCurve.csv\",\n",
" burnOut=5.274,\n",
+ " distanceNozzleMotorReference=0.40396,\n",
" reshapeThrustCurve=False,\n",
" grainNumber=6,\n",
" grainSeparation=6 / 1000,\n",
@@ -900,6 +902,7 @@
"MOTOR = SolidMotor(\n",
" thrustSource=lambda x: 1 / (x + 1),\n",
" burnOut=5.274,\n",
+ " distanceNozzleMotorReference=0.40396,\n",
" reshapeThrustCurve=False,\n",
" grainNumber=6,\n",
" grainSeparation=6 / 1000,\n",
@@ -1277,6 +1280,7 @@
"MOTOR = SolidMotor(\n",
" thrustSource=r\"../../data/keron/thrustCurve.csv\",\n",
" burnOut=5.274,\n",
+ " distanceNozzleMotorReference=0.40396,\n",
" reshapeThrustCurve=[10, 6000],\n",
" grainNumber=6,\n",
" grainSeparation=6 / 1000,\n",
diff --git a/docs/notebooks/dispersion_analysis/dispersion_analysis.ipynb b/docs/notebooks/dispersion_analysis/dispersion_analysis.ipynb
index 1d2c3e229..c7f2c5430 100644
--- a/docs/notebooks/dispersion_analysis/dispersion_analysis.ipynb
+++ b/docs/notebooks/dispersion_analysis/dispersion_analysis.ipynb
@@ -1,1756 +1,1830 @@
{
- "nbformat": 4,
- "nbformat_minor": 2,
- "metadata": {
- "colab": {
- "name": "Valetudo_Monte_Carlo_Dispersion_Analysis.ipynb",
- "provenance": [],
- "collapsed_sections": [
- "au88RN0P-bVl",
- "-9u9RIaqpOQl",
- "tExJzLhDpOQp",
- "ifuJX7jYpORB",
- "mYD4EQ5spORE",
- "ajI4vr7QpORL",
- "9m19OV9upORS",
- "mQzQELcJpORX",
- "7MUVLAM-pORb",
- "4LpDYGpfpORf",
- "nKSzDWi7pORi",
- "BvMCGZYHpORn",
- "LhPQQlpHpORq",
- "5MvfiSQZvwPK"
- ],
- "toc_visible": true
- },
- "kernelspec": {
- "display_name": "Python 3",
- "language": "python",
- "name": "python3"
- }
- },
- "cells": [
- {
- "cell_type": "markdown",
- "source": [
- "# Monte Carlo Dispersion Analysis using RocketPy\n",
- "\n",
- "This is an advanced use of RocketPy. This notebook wraps RocketPy's methods to run a Monte Carlo analysis and predict probability distributions of the rocket's landing point, apogee and other relevant information.\n",
- "\n",
- "The main output is a map very similar to the one below.\n",
- "\n",
- "\n",
- "\n",
- "This jupyter notebook presents the Monte Carlo analysis performed for the flight of Valetudo, one of the most famous rockets made by Projeto Jupiter. Valetudo has a diameter of $80$ mm and height of $2.4$ m. It was built for the first time to be launched at Latin American Space Challenge (LASC) 2019. Indeed, Valetudo came to be launched in 2019 on August 10th by 5:56 pm (local time), propelled by a class K motor called 'Keron', a solid motor completely designed and built by Projeto Jupiter. The rocket crossed the sky and reached an $860$ m apogee, descending safely by the drogue parachute called \"Charmander\" and landing with an 18.5 m/s terminal velocity. \n",
- "\n",
- "We hope you enjoy the flight(s) in this notebook just like everyone in LASC19 did it in real-time!"
- ],
- "metadata": {
- "id": "V0OcBOvipOP8"
- }
- },
- {
- "cell_type": "markdown",
- "source": [
- "## Clone repository if using Google Colab\n",
- "\n",
- "If you are running this using Binder, or you are running locally with the necessary files, you do not need to run this.\n",
- "On the other hand, if you are running on Google Colab, make sure to run the cell below to clone the repository and download the necessary files."
- ],
- "metadata": {}
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "source": [
- "!git clone https://github.com/giovaniceotto/RocketPy.git\n",
- "import os\n",
- "\n",
- "os.chdir(\"RocketPy/docs/notebooks/dispersion_analysis\")"
- ],
- "outputs": [],
- "metadata": {}
- },
- {
- "cell_type": "markdown",
- "source": [
- "## Install and Load Necessary Libraries\n",
- "\n"
- ],
- "metadata": {
- "id": "Um2fvNlQpTAH"
- }
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "source": [
- "!pip install netCDF4\n",
- "!pip install rocketpy"
- ],
- "outputs": [],
- "metadata": {
- "id": "JJNfsYrwpXGJ",
- "colab": {
- "base_uri": "https://localhost:8080/"
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "V0OcBOvipOP8"
+ },
+ "source": [
+ "# Monte Carlo Dispersion Analysis using RocketPy\n",
+ "\n",
+ "This is an advanced use of RocketPy. This notebook wraps RocketPy's methods to run a Monte Carlo analysis and predict probability distributions of the rocket's landing point, apogee and other relevant information.\n",
+ "\n",
+ "The main output is a map very similar to the one below.\n",
+ "\n",
+ "\n",
+ "\n",
+ "This jupyter notebook presents the Monte Carlo analysis performed for the flight of Valetudo, one of the most famous rockets made by Projeto Jupiter. Valetudo has a diameter of $80$ mm and height of $2.4$ m. It was built for the first time to be launched at Latin American Space Challenge (LASC) 2019. Indeed, Valetudo came to be launched in 2019 on August 10th by 5:56 pm (local time), propelled by a class K motor called 'Keron', a solid motor completely designed and built by Projeto Jupiter. The rocket crossed the sky and reached an $860$ m apogee, descending safely by the drogue parachute called \"Charmander\" and landing with an 18.5 m/s terminal velocity. \n",
+ "\n",
+ "We hope you enjoy the flight(s) in this notebook just like everyone in LASC19 did it in real-time!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Clone repository if using Google Colab\n",
+ "\n",
+ "If you are running this using Binder, or you are running locally with the necessary files, you do not need to run this.\n",
+ "On the other hand, if you are running on Google Colab, make sure to run the cell below to clone the repository and download the necessary files."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "!git clone https://github.com/giovaniceotto/RocketPy.git\n",
+ "import os\n",
+ "\n",
+ "os.chdir(\"RocketPy/docs/notebooks/dispersion_analysis\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Um2fvNlQpTAH"
+ },
+ "source": [
+ "## Install and Load Necessary Libraries\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "JJNfsYrwpXGJ",
+ "outputId": "e2c4e1ef-4720-40ae-abd1-4d2a599bedd4",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "!pip install netCDF4\n",
+ "!pip install rocketpy"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "id": "rNY7u8fApOP_",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "from time import process_time, time\n",
+ "\n",
+ "from rocketpy import Environment, SolidMotor, Rocket, Flight, Function\n",
+ "\n",
+ "import numpy as np\n",
+ "from numpy.random import normal, choice\n",
+ "from IPython.display import display"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Next, we import matplotlib to produce awesome looking plots."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "id": "0uEmvBIt5Ltg",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "%config InlineBackend.figure_formats = ['svg']\n",
+ "import matplotlib as mpl\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "%matplotlib inline\n",
+ "mpl.rcParams[\"figure.figsize\"] = [8, 5]\n",
+ "mpl.rcParams[\"figure.dpi\"] = 120\n",
+ "mpl.rcParams[\"font.size\"] = 14\n",
+ "mpl.rcParams[\"legend.fontsize\"] = 14\n",
+ "mpl.rcParams[\"figure.titlesize\"] = 14"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "4ksmBqU7pOQC"
+ },
+ "source": [
+ "## Defining Analysis Parameters\n",
+ "\n",
+ "The analysis parameters are a collection of expected values (and their uncertainties, or standard deviation) that completely defines a rocket flight.\n",
+ "As an assumption, the parameters which define the flight can behave in 3 different ways:\n",
+ " - the parameter is a completely known and has a constant value (i.e. number of fins)\n",
+ " - the parameter can assume certain discrete values with uniform distribution (i.e. the member of an ensemble forecast, which might be any integer from 0 to 9)\n",
+ " - the parameter is best represented by a normal (gaussian) distribution with a defined expected value and standard deviation\n",
+ "\n",
+ "We implement this using a dictionary, where the key is the name of the parameter and the value is either a tuple or a list, depending on the behaviour of the parameter:\n",
+ " - if the parameter is know, its value is represented as a list with a single entry (i.e. `\"number_of_fins: [4]\"`)\n",
+ " - if the parameter can assume certain discrete values with uniform distribution, its values are represented by a list of possible choices (i.e. `\"member_of_ensemble_forecast: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\"`)\n",
+ " - if the parameter is best represented by a normal (gaussian) distribution, its value is a tuple with the expected value and its standard deviation (i.e. `\"rocket_mass\": (100, 2)`, where 100 kg is the expected mass, with uncertainty of plus or minus 2 kg)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "id": "fwoCdOgKpOQD",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "analysis_parameters = {\n",
+ " # Mass Details\n",
+ " \"rocketMass\": (\n",
+ " 8.257,\n",
+ " 0.001,\n",
+ " ), # Rocket's dry mass (kg) and its uncertainty (standard deviation)\n",
+ " # Propulsion Details - run help(SolidMotor) for more information\n",
+ " \"impulse\": (1415.15, 35.3), # Motor total impulse (N*s)\n",
+ " \"burnOut\": (5.274, 1), # Motor burn out time (s)\n",
+ " \"nozzleRadius\": (21.642 / 1000, 0.5 / 1000), # Motor's nozzle radius (m)\n",
+ " \"throatRadius\": (8 / 1000, 0.5 / 1000), # Motor's nozzle throat radius (m)\n",
+ " \"grainSeparation\": (\n",
+ " 6 / 1000,\n",
+ " 1 / 1000,\n",
+ " ), # Motor's grain separation (axial distance between two grains) (m)\n",
+ " \"grainDensity\": (1707, 50), # Motor's grain density (kg/m^3)\n",
+ " \"grainOuterRadius\": (21.4 / 1000, 0.375 / 1000), # Motor's grain outer radius (m)\n",
+ " \"grainInitialInnerRadius\": (\n",
+ " 9.65 / 1000,\n",
+ " 0.375 / 1000,\n",
+ " ), # Motor's grain inner radius (m)\n",
+ " \"grainInitialHeight\": (120 / 1000, 1 / 1000), # Motor's grain height (m)\n",
+ " # Aerodynamic Details - run help(Rocket) for more information\n",
+ " \"inertiaI\": (\n",
+ " 3.675,\n",
+ " 0.03675,\n",
+ " ), # Rocket's inertia moment perpendicular to its axis (kg*m^2)\n",
+ " \"inertiaZ\": (\n",
+ " 0.007,\n",
+ " 0.00007,\n",
+ " ), # Rocket's inertia moment relative to its axis (kg*m^2)\n",
+ " \"radius\": (40.45 / 1000, 0.001), # Rocket's radius (kg*m^2)\n",
+ " \"distanceRocketNozzle\": (\n",
+ " -1.024,\n",
+ " 0.001,\n",
+ " ), # Distance between rocket's center of dry mass and nozzle exit plane (m) (negative)\n",
+ " \"distanceNozzleMotorReference\": (0.39796, 0.001),\n",
+ " \"powerOffDrag\": (\n",
+ " 0.9081 / 1.05,\n",
+ " 0.033,\n",
+ " ), # Multiplier for rocket's drag curve. Usually has a mean value of 1 and a uncertainty of 5% to 10%\n",
+ " \"powerOnDrag\": (\n",
+ " 0.9081 / 1.05,\n",
+ " 0.033,\n",
+ " ), # Multiplier for rocket's drag curve. Usually has a mean value of 1 and a uncertainty of 5% to 10%\n",
+ " \"noseLength\": (0.274, 0.001), # Rocket's nose cone length (m)\n",
+ " \"noseDistanceToCM\": (\n",
+ " 1.134,\n",
+ " 0.001,\n",
+ " ), # Axial distance between rocket's center of dry mass and nearest point in its nose cone (m)\n",
+ " \"finSpan\": (0.077, 0.0005), # Fin span (m)\n",
+ " \"finRootChord\": (0.058, 0.0005), # Fin root chord (m)\n",
+ " \"finTipChord\": (0.018, 0.0005), # Fin tip chord (m)\n",
+ " \"finDistanceToCM\": (\n",
+ " -0.906,\n",
+ " 0.001,\n",
+ " ), # Axial distance between rocket's center of dry mass and nearest point in its fin (m)\n",
+ " # Launch and Environment Details - run help(Environment) and help(Flight) for more information\n",
+ " \"inclination\": (\n",
+ " 84.7,\n",
+ " 1,\n",
+ " ), # Launch rail inclination angle relative to the horizontal plane (degrees)\n",
+ " \"heading\": (53, 2), # Launch rail heading relative to north (degrees)\n",
+ " \"railLength\": (5.7, 0.0005), # Launch rail length (m)\n",
+ " \"ensembleMember\": list(range(10)), # Members of the ensemble forecast to be used\n",
+ " # Parachute Details - run help(Rocket) for more information\n",
+ " \"CdSDrogue\": (\n",
+ " 0.349 * 1.3,\n",
+ " 0.07,\n",
+ " ), # Drag coefficient times reference area for the drogue chute (m^2)\n",
+ " \"lag_rec\": (\n",
+ " 1,\n",
+ " 0.5,\n",
+ " ), # Time delay between parachute ejection signal is detected and parachute is inflated (s)\n",
+ " # Electronic Systems Details - run help(Rocket) for more information\n",
+ " \"lag_se\": (\n",
+ " 0.73,\n",
+ " 0.16,\n",
+ " ), # Time delay between sensor signal is received and ejection signal is fired (s)\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "EJCbP69TpOQG"
+ },
+ "source": [
+ "## Creating a Flight Settings Generator\n",
+ "\n",
+ "Now, we create a generator function which will yield all the necessary inputs for a single flight simulation. Each generated input will be randomly generated according to the `analysis_parameters` dicitionary set up above.\n",
+ "\n",
+ "This is just a helper function to make the code clearer."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "id": "5XCL9JaIpOQH",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def flight_settings(analysis_parameters, total_number):\n",
+ " i = 0\n",
+ " while i < total_number:\n",
+ " # Generate a flight setting\n",
+ " flight_setting = {}\n",
+ " for parameter_key, parameter_value in analysis_parameters.items():\n",
+ " if type(parameter_value) is tuple:\n",
+ " flight_setting[parameter_key] = normal(*parameter_value)\n",
+ " else:\n",
+ " flight_setting[parameter_key] = choice(parameter_value)\n",
+ "\n",
+ " # Skip if certain values are negative, which happens due to the normal curve but isnt realistic\n",
+ " if flight_setting[\"lag_rec\"] < 0 or flight_setting[\"lag_se\"] < 0:\n",
+ " continue\n",
+ "\n",
+ " # Update counter\n",
+ " i += 1\n",
+ " # Yield a flight setting\n",
+ " yield flight_setting"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "FtdRXCVHpOQO"
+ },
+ "source": [
+ "## Creating an Export Function\n",
+ "\n",
+ "Monte Carlo analyses usually contain data from thousands or tens of thousands of simulations. They can easily take hours to run. Therefore, it is very important to save our outputs to a file during the analysis. This way, if something happens, we do not lose our progress.\n",
+ "\n",
+ "These next functions take care of that. They export the simulation data to three different files:\n",
+ "- `dispersion_input_file`: A file where each line is a json converted dictionary of flight setting inputs to run a single trajectory simulation;\n",
+ "- `dispersion_output_file`: A file where each line is a json converted dictionary containing the main outputs of a single simulation, such as apogee altitute and maximum velocity;\n",
+ "- `dispersion_error_file`: A file to store the inputs of simulations which raised errors. This can help us debug these simulations later on."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "id": "1eC2p3jEpOQO",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def export_flight_data(flight_setting, flight_data, exec_time):\n",
+ " # Generate flight results\n",
+ " flight_result = {\n",
+ " \"outOfRailTime\": flight_data.outOfRailTime,\n",
+ " \"outOfRailVelocity\": flight_data.outOfRailVelocity,\n",
+ " \"apogeeTime\": flight_data.apogeeTime,\n",
+ " \"apogeeAltitude\": flight_data.apogee - Env.elevation,\n",
+ " \"apogeeX\": flight_data.apogeeX,\n",
+ " \"apogeeY\": flight_data.apogeeY,\n",
+ " \"impactTime\": flight_data.tFinal,\n",
+ " \"impactX\": flight_data.xImpact,\n",
+ " \"impactY\": flight_data.yImpact,\n",
+ " \"impactVelocity\": flight_data.impactVelocity,\n",
+ " \"initialStaticMargin\": flight_data.rocket.staticMargin(0),\n",
+ " \"outOfRailStaticMargin\": flight_data.rocket.staticMargin(\n",
+ " TestFlight.outOfRailTime\n",
+ " ),\n",
+ " \"finalStaticMargin\": flight_data.rocket.staticMargin(\n",
+ " TestFlight.rocket.motor.burnOutTime\n",
+ " ),\n",
+ " \"numberOfEvents\": len(flight_data.parachuteEvents),\n",
+ " \"executionTime\": exec_time,\n",
+ " }\n",
+ "\n",
+ " # Calculate maximum reached velocity\n",
+ " sol = np.array(flight_data.solution)\n",
+ " flight_data.vx = Function(\n",
+ " sol[:, [0, 4]], \"Time (s)\", \"Vx (m/s)\", \"linear\", extrapolation=\"natural\"\n",
+ " )\n",
+ " flight_data.vy = Function(\n",
+ " sol[:, [0, 5]], \"Time (s)\", \"Vy (m/s)\", \"linear\", extrapolation=\"natural\"\n",
+ " )\n",
+ " flight_data.vz = Function(\n",
+ " sol[:, [0, 6]], \"Time (s)\", \"Vz (m/s)\", \"linear\", extrapolation=\"natural\"\n",
+ " )\n",
+ " flight_data.v = (\n",
+ " flight_data.vx**2 + flight_data.vy**2 + flight_data.vz**2\n",
+ " ) ** 0.5\n",
+ " flight_data.maxVel = np.amax(flight_data.v.source[:, 1])\n",
+ " flight_result[\"maxVelocity\"] = flight_data.maxVel\n",
+ "\n",
+ " # Take care of parachute results\n",
+ " if len(flight_data.parachuteEvents) > 0:\n",
+ " flight_result[\"drogueTriggerTime\"] = flight_data.parachuteEvents[0][0]\n",
+ " flight_result[\"drogueInflatedTime\"] = (\n",
+ " flight_data.parachuteEvents[0][0] + flight_data.parachuteEvents[0][1].lag\n",
+ " )\n",
+ " flight_result[\"drogueInflatedVelocity\"] = flight_data.v(\n",
+ " flight_data.parachuteEvents[0][0] + flight_data.parachuteEvents[0][1].lag\n",
+ " )\n",
+ " else:\n",
+ " flight_result[\"drogueTriggerTime\"] = 0\n",
+ " flight_result[\"drogueInflatedTime\"] = 0\n",
+ " flight_result[\"drogueInflatedVelocity\"] = 0\n",
+ "\n",
+ " # Write flight setting and results to file\n",
+ " dispersion_input_file.write(str(flight_setting) + \"\\n\")\n",
+ " dispersion_output_file.write(str(flight_result) + \"\\n\")\n",
+ "\n",
+ "\n",
+ "def export_flight_error(flight_setting):\n",
+ " dispersion_error_file.write(str(flight_setting) + \"\\n\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "GX6pB4Y7pOQQ"
+ },
+ "source": [
+ "## Simulating Each Flight Setting\n",
+ "\n",
+ "Finally, we can start running some simulations!\n",
+ "\n",
+ "We start by defining the file name we want to use. Then, we specify how many simulations we would like to run by setting the `number_of_simulations` variable.\n",
+ "\n",
+ "It is good practice to run something in the order of 100 simulations first, to check for any possible errors in the code. Once we are confident that everything is working well, we increase the number of simulations to something in the range of 5000 to 50000.\n",
+ "\n",
+ "We will loop through all flight settings, creating the environment, rocket and motor classes with the data of the analysis parameters.\n",
+ "For the power off and on drag and thrust curve user should have in hands the .csv (or .eng for COTS motor's thrust curve).\n",
+ "\n",
+ "**Tip**: A better practice is opening the files in \"append\" mode, this way we can accumulate our simulations. To do this, just change the 'a' (write) argument of the `open` function in the third, fourth and fifth line of code to `a` (append)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 34
+ },
+ "id": "GILiaO30pOQS",
+ "outputId": "5a2ae15d-5c16-4ae0-f28b-165730d2419d",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Curent iteration: 019999 | Average Time per Iteration: 0.000289 s'"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Basic analysis info\n",
+ "filename = \"dispersion_analysis_outputs/valetudo_rocket_v0\"\n",
+ "number_of_simulations = 20000\n",
+ "\n",
+ "# Create data files for inputs, outputs and error logging\n",
+ "dispersion_error_file = open(str(filename) + \".disp_errors.txt\", \"w\")\n",
+ "dispersion_input_file = open(str(filename) + \".disp_inputs.txt\", \"w\")\n",
+ "dispersion_output_file = open(str(filename) + \".disp_outputs.txt\", \"w\")\n",
+ "\n",
+ "# Initialize counter and timer\n",
+ "i = 0\n",
+ "\n",
+ "initial_wall_time = time()\n",
+ "initial_cpu_time = process_time()\n",
+ "\n",
+ "# Define basic Environment object\n",
+ "Env = Environment(\n",
+ " railLength=5.7, date=(2019, 8, 10, 21), latitude=-23.363611, longitude=-48.011389\n",
+ ")\n",
+ "Env.setElevation(668)\n",
+ "Env.maxExpectedHeight = 1500\n",
+ "Env.setAtmosphericModel(\n",
+ " type=\"Ensemble\",\n",
+ " file=\"dispersion_analysis_inputs/LASC2019_reanalysis.nc\",\n",
+ " dictionary=\"ECMWF\",\n",
+ ")\n",
+ "\n",
+ "# Set up parachutes. This rocket, named Valetudo, only has a drogue chute.\n",
+ "def drogueTrigger(p, y):\n",
+ " # Check if rocket is going down, i.e. if it has passed the apogee\n",
+ " vertical_velocity = y[5]\n",
+ " # Return true to activate parachute once the vertical velocity is negative\n",
+ " return True if vertical_velocity < 0 else False\n",
+ "\n",
+ "\n",
+ "# Iterate over flight settings\n",
+ "out = display(\"Starting\", display_id=True)\n",
+ "for setting in flight_settings(analysis_parameters, number_of_simulations):\n",
+ " start_time = process_time()\n",
+ " i += 1\n",
+ "\n",
+ " # Update environment object\n",
+ " Env.selectEnsembleMember(setting[\"ensembleMember\"])\n",
+ " Env.railLength = setting[\"railLength\"]\n",
+ "\n",
+ " # Create motor\n",
+ " Keron = SolidMotor(\n",
+ " thrustSource=\"dispersion_analysis_inputs/thrustCurve.csv\",\n",
+ " burnOut=5.274,\n",
+ " reshapeThrustCurve=(setting[\"burnOut\"], setting[\"impulse\"]),\n",
+ " distanceNozzleMotorReference=setting[\"distanceNozzleMotorReference\"]\n",
+ " nozzleRadius=setting[\"nozzleRadius\"],\n",
+ " throatRadius=setting[\"throatRadius\"],\n",
+ " grainNumber=6,\n",
+ " grainSeparation=setting[\"grainSeparation\"],\n",
+ " grainDensity=setting[\"grainDensity\"],\n",
+ " grainOuterRadius=setting[\"grainOuterRadius\"],\n",
+ " grainInitialInnerRadius=setting[\"grainInitialInnerRadius\"],\n",
+ " grainInitialHeight=setting[\"grainInitialHeight\"],\n",
+ " interpolationMethod=\"linear\",\n",
+ " )\n",
+ "\n",
+ " # Create rocket\n",
+ " Valetudo = Rocket(\n",
+ " motor=Keron,\n",
+ " radius=setting[\"radius\"],\n",
+ " mass=setting[\"rocketMass\"],\n",
+ " inertiaI=setting[\"inertiaI\"],\n",
+ " inertiaZ=setting[\"inertiaZ\"],\n",
+ " distanceRocketNozzle=setting[\"distanceRocketNozzle\"],\n",
+ " powerOffDrag=\"dispersion_analysis_inputs/Cd_PowerOff.csv\",\n",
+ " powerOnDrag=\"dispersion_analysis_inputs/Cd_PowerOn.csv\",\n",
+ " )\n",
+ " Valetudo.setRailButtons([0.224, -0.93], 30)\n",
+ " # Edit rocket drag\n",
+ " Valetudo.powerOffDrag *= setting[\"powerOffDrag\"]\n",
+ " Valetudo.powerOnDrag *= setting[\"powerOnDrag\"]\n",
+ " # Add rocket nose, fins and tail\n",
+ " NoseCone = Valetudo.addNose(\n",
+ " length=setting[\"noseLength\"],\n",
+ " kind=\"vonKarman\",\n",
+ " distanceToCM=setting[\"noseDistanceToCM\"],\n",
+ " )\n",
+ " FinSet = Valetudo.addFins(\n",
+ " n=3,\n",
+ " rootChord=setting[\"finRootChord\"],\n",
+ " tipChord=setting[\"finTipChord\"],\n",
+ " span=setting[\"finSpan\"],\n",
+ " distanceToCM=setting[\"finDistanceToCM\"],\n",
+ " )\n",
+ " # Add parachute\n",
+ " Drogue = Valetudo.addParachute(\n",
+ " \"Drogue\",\n",
+ " CdS=setting[\"CdSDrogue\"],\n",
+ " trigger=drogueTrigger,\n",
+ " samplingRate=105,\n",
+ " lag=setting[\"lag_rec\"] + setting[\"lag_se\"],\n",
+ " noise=(0, 8.3, 0.5),\n",
+ " )\n",
+ "\n",
+ " # Run trajectory simulation\n",
+ " try:\n",
+ " TestFlight = Flight(\n",
+ " rocket=Valetudo,\n",
+ " environment=Env,\n",
+ " inclination=setting[\"inclination\"],\n",
+ " heading=setting[\"heading\"],\n",
+ " maxTime=600,\n",
+ " )\n",
+ " export_flight_data(setting, TestFlight, process_time() - start_time)\n",
+ " except Exception as E:\n",
+ " print(E)\n",
+ " export_flight_error(setting)\n",
+ "\n",
+ " # Register time\n",
+ " out.update(\n",
+ " f\"Current iteration: {i:06d} | Average Time per Iteration: {(process_time() - initial_cpu_time)/i:2.6f} s\"\n",
+ " )\n",
+ "\n",
+ "# Done\n",
+ "\n",
+ "## Print and save total time\n",
+ "final_string = f\"Completed {i} iterations successfully. Total CPU time: {process_time() - initial_cpu_time} s. Total wall time: {time() - initial_wall_time} s\"\n",
+ "out.update(final_string)\n",
+ "dispersion_input_file.write(final_string + \"\\n\")\n",
+ "dispersion_output_file.write(final_string + \"\\n\")\n",
+ "dispersion_error_file.write(final_string + \"\\n\")\n",
+ "\n",
+ "## Close files\n",
+ "dispersion_input_file.close()\n",
+ "dispersion_output_file.close()\n",
+ "dispersion_error_file.close()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Post-processing Monte Carlo Dispersion Results\n",
+ "\n",
+ "Now that we have finish running thousands of simulations, it is time to process the results and get some nice graphs out of them! "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "X8ewOccUpOQb"
+ },
+ "source": [
+ "### Importing Dispersion Analysis Saved Data\n",
+ "\n",
+ "We start by loading the file which stores the outputs."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "-7qgTJzRpOQb",
+ "outputId": "76d2cecd-a09f-429f-cca2-f4e03e39d49e",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Number of simulations: 20000\n"
+ ]
+ }
+ ],
+ "source": [
+ "filename = \"dispersion_analysis_outputs/valetudo_rocket_v0\"\n",
+ "\n",
+ "# Initialize variable to store all results\n",
+ "dispersion_general_results = []\n",
+ "\n",
+ "dispersion_results = {\n",
+ " \"outOfRailTime\": [],\n",
+ " \"outOfRailVelocity\": [],\n",
+ " \"apogeeTime\": [],\n",
+ " \"apogeeAltitude\": [],\n",
+ " \"apogeeX\": [],\n",
+ " \"apogeeY\": [],\n",
+ " \"impactTime\": [],\n",
+ " \"impactX\": [],\n",
+ " \"impactY\": [],\n",
+ " \"impactVelocity\": [],\n",
+ " \"initialStaticMargin\": [],\n",
+ " \"outOfRailStaticMargin\": [],\n",
+ " \"finalStaticMargin\": [],\n",
+ " \"numberOfEvents\": [],\n",
+ " \"maxVelocity\": [],\n",
+ " \"drogueTriggerTime\": [],\n",
+ " \"drogueInflatedTime\": [],\n",
+ " \"drogueInflatedVelocity\": [],\n",
+ " \"executionTime\": [],\n",
+ "}\n",
+ "\n",
+ "# Get all dispersion results\n",
+ "# Get file\n",
+ "dispersion_output_file = open(str(filename) + \".disp_outputs.txt\", \"r+\")\n",
+ "\n",
+ "# Read each line of the file and convert to dict\n",
+ "for line in dispersion_output_file:\n",
+ " # Skip comments lines\n",
+ " if line[0] != \"{\":\n",
+ " continue\n",
+ " # Eval results and store them\n",
+ " flight_result = eval(line)\n",
+ " dispersion_general_results.append(flight_result)\n",
+ " for parameter_key, parameter_value in flight_result.items():\n",
+ " dispersion_results[parameter_key].append(parameter_value)\n",
+ "\n",
+ "# Close data file\n",
+ "dispersion_output_file.close()\n",
+ "\n",
+ "# Print number of flights simulated\n",
+ "N = len(dispersion_general_results)\n",
+ "print(\"Number of simulations: \", N)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ioeUkzPipOQe"
+ },
+ "source": [
+ "## Dispersion Results\n",
+ "\n",
+ "Now, we plot the histogram for every single output. This shows how are outputs behave. Valuable statistical data can be calculated based on them."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "QDy8KaJ8pOQg"
+ },
+ "source": [
+ "### Out of Rail Time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 73,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 607
+ },
+ "id": "1JQSzd5cpOQh",
+ "outputId": "455abcdf-9dd7-4689-9523-50154c7fb302",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Out of Rail Time - Mean Value: 1.084 s\n",
+ "Out of Rail Time - Standard Deviation: 0.183 s\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": "\r\n\r\n\r\n\r\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "print(\n",
+ " f'Out of Rail Time - Mean Value: {np.mean(dispersion_results[\"outOfRailTime\"]):0.3f} s'\n",
+ ")\n",
+ "print(\n",
+ " f'Out of Rail Time - Standard Deviation: {np.std(dispersion_results[\"outOfRailTime\"]):0.3f} s'\n",
+ ")\n",
+ "\n",
+ "plt.figure()\n",
+ "plt.hist(dispersion_results[\"outOfRailTime\"], bins=int(N**0.5))\n",
+ "plt.title(\"Out of Rail Time\")\n",
+ "plt.xlabel(\"Time (s)\")\n",
+ "plt.ylabel(\"Number of Occurrences\")\n",
+ "plt.show()\n",
+ "\n",
+ "# You can also use Plotly instead of Matplotlib if you wish!\n",
+ "# import plotly.express as px\n",
+ "# fig1 = px.histogram(\n",
+ "# x=dispersion_results[\"outOfRailTime\"],\n",
+ "# title='Out of Rail Time',\n",
+ "# nbins=int(N**0.5)\n",
+ "# )\n",
+ "# fig1.update_layout(\n",
+ "# xaxis_title_text='Time (s)',\n",
+ "# yaxis_title_text='Number of occurences'\n",
+ "# )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "-9u9RIaqpOQl"
+ },
+ "source": [
+ "### Out of Rail Velocity"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 607
+ },
+ "id": "jE23vILMpOQm",
+ "outputId": "aa04f5a4-26f2-47e8-831a-41d3e76b616f",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Out of Rail Velocity - Mean Value: 23.081 m/s\n",
+ "Out of Rail Velocity - Standard Deviation: 3.116 m/s\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": "\r\n\r\n\r\n\r\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "print(\n",
+ " f'Out of Rail Velocity - Mean Value: {np.mean(dispersion_results[\"outOfRailVelocity\"]):0.3f} m/s'\n",
+ ")\n",
+ "print(\n",
+ " f'Out of Rail Velocity - Standard Deviation: {np.std(dispersion_results[\"outOfRailVelocity\"]):0.3f} m/s'\n",
+ ")\n",
+ "\n",
+ "plt.figure()\n",
+ "plt.hist(dispersion_results[\"outOfRailVelocity\"], bins=int(N**0.5))\n",
+ "plt.title(\"Out of Rail Velocity\")\n",
+ "plt.xlabel(\"Velocity (m/s)\")\n",
+ "plt.ylabel(\"Number of Occurrences\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "tExJzLhDpOQp"
+ },
+ "source": [
+ "### Apogee Time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 607
+ },
+ "id": "l8zjT_VjpOQq",
+ "outputId": "1c15fe12-afae-4035-f085-7d82e61d24d9",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Apogee Time - Mean Value: 14.305 s\n",
+ "Apogee Time - Standard Deviation: 0.344 s\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": "\r\n\r\n\r\n\r\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "print(\n",
+ " f'Apogee Time - Mean Value: {np.mean(dispersion_results[\"apogeeTime\"]):0.3f} s'\n",
+ ")\n",
+ "print(\n",
+ " f'Apogee Time - Standard Deviation: {np.std(dispersion_results[\"apogeeTime\"]):0.3f} s'\n",
+ ")\n",
+ "\n",
+ "plt.figure()\n",
+ "plt.hist(dispersion_results[\"apogeeTime\"], bins=int(N**0.5))\n",
+ "plt.title(\"Apogee Time\")\n",
+ "plt.xlabel(\"Time (s)\")\n",
+ "plt.ylabel(\"Number of Occurrences\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "erNB46vApOQt"
+ },
+ "source": [
+ "### Apogee Altitude"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 607
+ },
+ "id": "gWWMoOClpOQv",
+ "outputId": "88f2cf05-142c-4bb1-ce64-9879696107a7",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Apogee Altitude - Mean Value: 847.247 m\n",
+ "Apogee Altitude - Standard Deviation: 42.020 m\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": "\r\n\r\n\r\n\r\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "print(\n",
+ " f'Apogee Altitude - Mean Value: {np.mean(dispersion_results[\"apogeeAltitude\"]):0.3f} m'\n",
+ ")\n",
+ "print(\n",
+ " f'Apogee Altitude - Standard Deviation: {np.std(dispersion_results[\"apogeeAltitude\"]):0.3f} m'\n",
+ ")\n",
+ "\n",
+ "plt.figure()\n",
+ "plt.hist(dispersion_results[\"apogeeAltitude\"], bins=int(N**0.5))\n",
+ "plt.title(\"Apogee Altitude\")\n",
+ "plt.xlabel(\"Altitude (m)\")\n",
+ "plt.ylabel(\"Number of Occurrences\")\n",
+ "plt.show()\n",
+ "\n",
+ "# Real measured apogee for Valetudo = 860 m"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7bBvFJ5xpOQ1"
+ },
+ "source": [
+ "### Apogee X Position"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 607
+ },
+ "id": "nGdsF9VppOQ3",
+ "outputId": "b4f0a3aa-afa1-4942-91b8-8ad61d263244",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Apogee X Position - Mean Value: 108.492 m\n",
+ "Apogee X Position - Standard Deviation: 24.629 m\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": "\r\n\r\n\r\n\r\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "print(\n",
+ " f'Apogee X Position - Mean Value: {np.mean(dispersion_results[\"apogeeX\"]):0.3f} m'\n",
+ ")\n",
+ "print(\n",
+ " f'Apogee X Position - Standard Deviation: {np.std(dispersion_results[\"apogeeX\"]):0.3f} m'\n",
+ ")\n",
+ "\n",
+ "plt.figure()\n",
+ "plt.hist(dispersion_results[\"apogeeX\"], bins=int(N**0.5))\n",
+ "plt.title(\"Apogee X Position\")\n",
+ "plt.xlabel(\"Apogee X Position (m)\")\n",
+ "plt.ylabel(\"Number of Occurrences\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "-LtYxB0lpOQ8"
+ },
+ "source": [
+ "### Apogee Y Position"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 607
+ },
+ "id": "ocq6GmeNpOQ8",
+ "outputId": "f3a45339-c0a6-4819-bd03-60f7fe6df963",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Apogee Y Position - Mean Value: 107.614 m\n",
+ "Apogee Y Position - Standard Deviation: 19.732 m\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": "\r\n\r\n\r\n\r\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "print(\n",
+ " f'Apogee Y Position - Mean Value: {np.mean(dispersion_results[\"apogeeY\"]):0.3f} m'\n",
+ ")\n",
+ "print(\n",
+ " f'Apogee Y Position - Standard Deviation: {np.std(dispersion_results[\"apogeeY\"]):0.3f} m'\n",
+ ")\n",
+ "\n",
+ "plt.figure()\n",
+ "plt.hist(dispersion_results[\"apogeeY\"], bins=int(N**0.5))\n",
+ "plt.title(\"Apogee Y Position\")\n",
+ "plt.xlabel(\"Apogee Y Position (m)\")\n",
+ "plt.ylabel(\"Number of Occurrences\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ifuJX7jYpORB"
+ },
+ "source": [
+ "### Impact Time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 56,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 607
+ },
+ "id": "52j6t5-MpORB",
+ "outputId": "9cba31b1-c731-402f-b138-df5c72521408",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Impact Time - Mean Value: 62.911 s\n",
+ "Impact Time - Standard Deviation: 4.159 s\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": "\r\n\r\n\r\n\r\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "print(\n",
+ " f'Impact Time - Mean Value: {np.mean(dispersion_results[\"impactTime\"]):0.3f} s'\n",
+ ")\n",
+ "print(\n",
+ " f'Impact Time - Standard Deviation: {np.std(dispersion_results[\"impactTime\"]):0.3f} s'\n",
+ ")\n",
+ "\n",
+ "plt.figure()\n",
+ "plt.hist(dispersion_results[\"impactTime\"], bins=int(N**0.5))\n",
+ "plt.title(\"Impact Time\")\n",
+ "plt.xlabel(\"Time (s)\")\n",
+ "plt.ylabel(\"Number of Occurrences\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "mYD4EQ5spORE"
+ },
+ "source": [
+ "### Impact X Position"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 607
+ },
+ "id": "uzL8-1UGpORF",
+ "outputId": "5c74f8d1-b909-44cf-a5c9-2f1b5e9dda1d",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Impact X Position - Mean Value: 364.105 m\n",
+ "Impact X Position - Standard Deviation: 46.835 m\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": "\r\n\r\n\r\n\r\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "print(\n",
+ " f'Impact X Position - Mean Value: {np.mean(dispersion_results[\"impactX\"]):0.3f} m'\n",
+ ")\n",
+ "print(\n",
+ " f'Impact X Position - Standard Deviation: {np.std(dispersion_results[\"impactX\"]):0.3f} m'\n",
+ ")\n",
+ "\n",
+ "plt.figure()\n",
+ "plt.hist(dispersion_results[\"impactX\"], bins=int(N**0.5))\n",
+ "plt.title(\"Impact X Position\")\n",
+ "plt.xlabel(\"Impact X Position (m)\")\n",
+ "plt.ylabel(\"Number of Occurrences\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ajI4vr7QpORL"
+ },
+ "source": [
+ "### Impact Y Position"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 58,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 607
+ },
+ "id": "Q-ghmNVopORM",
+ "outputId": "cd0c81a8-a3fc-4710-cadf-a20cf0882bec",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Impact Y Position - Mean Value: 16.109 m\n",
+ "Impact Y Position - Standard Deviation: 36.402 m\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": "\r\n\r\n\r\n\r\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "print(\n",
+ " f'Impact Y Position - Mean Value: {np.mean(dispersion_results[\"impactY\"]):0.3f} m'\n",
+ ")\n",
+ "print(\n",
+ " f'Impact Y Position - Standard Deviation: {np.std(dispersion_results[\"impactY\"]):0.3f} m'\n",
+ ")\n",
+ "\n",
+ "plt.figure()\n",
+ "plt.hist(dispersion_results[\"impactY\"], bins=int(N**0.5))\n",
+ "plt.title(\"Impact Y Position\")\n",
+ "plt.xlabel(\"Impact Y Position (m)\")\n",
+ "plt.ylabel(\"Number of Occurrences\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "H7_H_eeXpORP"
+ },
+ "source": [
+ "### Impact Velocity"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 59,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 607
+ },
+ "id": "Ryx7KEEVpORP",
+ "outputId": "90cdcf97-affc-4f09-ed2a-9b854257a8a0",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Impact Velocity - Mean Value: -18.280 m/s\n",
+ "Impact Velocity - Standard Deviation: 1.503 m/s\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": "\r\n\r\n\r\n\r\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "print(\n",
+ " f'Impact Velocity - Mean Value: {np.mean(dispersion_results[\"impactVelocity\"]):0.3f} m/s'\n",
+ ")\n",
+ "print(\n",
+ " f'Impact Velocity - Standard Deviation: {np.std(dispersion_results[\"impactVelocity\"]):0.3f} m/s'\n",
+ ")\n",
+ "\n",
+ "plt.figure()\n",
+ "plt.hist(dispersion_results[\"impactVelocity\"], bins=int(N**0.5))\n",
+ "plt.title(\"Impact Velocity\")\n",
+ "# plt.grid()\n",
+ "plt.xlim(-35, 0)\n",
+ "plt.xlabel(\"Velocity (m/s)\")\n",
+ "plt.ylabel(\"Number of Occurrences\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "9m19OV9upORS"
+ },
+ "source": [
+ "### Static Margin"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 60,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 675
+ },
+ "id": "a2Tpo9hjpORT",
+ "outputId": "94129858-cd6b-4af6-8f88-66923455a566",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Initial Static Margin - Mean Value: 1.998 c\n",
+ "Initial Static Margin - Standard Deviation: 0.326 c\n",
+ "Out of Rail Static Margin - Mean Value: 2.178 c\n",
+ "Out of Rail Static Margin - Standard Deviation: 0.330 c\n",
+ "Final Static Margin - Mean Value: 3.026 c\n",
+ "Final Static Margin - Standard Deviation: 0.347 c\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": "\r\n\r\n\r\n\r\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "print(\n",
+ " f'Initial Static Margin - Mean Value: {np.mean(dispersion_results[\"initialStaticMargin\"]):0.3f} c'\n",
+ ")\n",
+ "print(\n",
+ " f'Initial Static Margin - Standard Deviation: {np.std(dispersion_results[\"initialStaticMargin\"]):0.3f} c'\n",
+ ")\n",
+ "\n",
+ "print(\n",
+ " f'Out of Rail Static Margin - Mean Value: {np.mean(dispersion_results[\"outOfRailStaticMargin\"]):0.3f} c'\n",
+ ")\n",
+ "print(\n",
+ " f'Out of Rail Static Margin - Standard Deviation: {np.std(dispersion_results[\"outOfRailStaticMargin\"]):0.3f} c'\n",
+ ")\n",
+ "\n",
+ "print(\n",
+ " f'Final Static Margin - Mean Value: {np.mean(dispersion_results[\"finalStaticMargin\"]):0.3f} c'\n",
+ ")\n",
+ "print(\n",
+ " f'Final Static Margin - Standard Deviation: {np.std(dispersion_results[\"finalStaticMargin\"]):0.3f} c'\n",
+ ")\n",
+ "\n",
+ "plt.figure()\n",
+ "plt.hist(dispersion_results[\"initialStaticMargin\"], label=\"Initial\", bins=int(N**0.5))\n",
+ "plt.hist(\n",
+ " dispersion_results[\"outOfRailStaticMargin\"], label=\"Out of Rail\", bins=int(N**0.5)\n",
+ ")\n",
+ "plt.hist(dispersion_results[\"finalStaticMargin\"], label=\"Final\", bins=int(N**0.5))\n",
+ "plt.legend()\n",
+ "plt.title(\"Static Margin\")\n",
+ "plt.xlabel(\"Static Margin (c)\")\n",
+ "plt.ylabel(\"Number of Occurrences\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "mQzQELcJpORX"
+ },
+ "source": [
+ "### Maximum Velocity"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 61,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 607
+ },
+ "id": "nOu1O8MXpORY",
+ "outputId": "7510aec8-7b73-4751-f033-8367cd0c9bdc",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Maximum Velocity - Mean Value: 124.881 m/s\n",
+ "Maximum Velocity - Standard Deviation: 5.655 m/s\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": "\r\n\r\n\r\n\r\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "print(\n",
+ " f'Maximum Velocity - Mean Value: {np.mean(dispersion_results[\"maxVelocity\"]):0.3f} m/s'\n",
+ ")\n",
+ "print(\n",
+ " f'Maximum Velocity - Standard Deviation: {np.std(dispersion_results[\"maxVelocity\"]):0.3f} m/s'\n",
+ ")\n",
+ "\n",
+ "plt.figure()\n",
+ "plt.hist(dispersion_results[\"maxVelocity\"], bins=int(N**0.5))\n",
+ "plt.title(\"Maximum Velocity\")\n",
+ "plt.xlabel(\"Velocity (m/s)\")\n",
+ "plt.ylabel(\"Number of Occurrences\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7MUVLAM-pORb"
+ },
+ "source": [
+ "### Number of Parachute Events\n",
+ "\n",
+ "This is usefull to check if the parachute was triggered in every flight."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 62,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 607
+ },
+ "id": "yhcWi2kCpORb",
+ "outputId": "dee54569-8213-46cc-e287-9fffd2b8e43c",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": "\r\n\r\n\r\n\r\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.figure()\n",
+ "plt.hist(dispersion_results[\"numberOfEvents\"])\n",
+ "plt.title(\"Parachute Events\")\n",
+ "plt.xlabel(\"Number of Parachute Events\")\n",
+ "plt.ylabel(\"Number of Occurrences\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "4LpDYGpfpORf"
+ },
+ "source": [
+ "### Drogue Parachute Trigger Time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 63,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 607
+ },
+ "id": "lvCksZG8pORf",
+ "outputId": "3efd19ed-11e9-41d1-8e66-04da384665ce",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Drogue Parachute Trigger Time - Mean Value: 13.338 s\n",
+ "Drogue Parachute Trigger Time - Standard Deviation: 0.347 s\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": "\r\n\r\n\r\n\r\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "print(\n",
+ " f'Drogue Parachute Trigger Time - Mean Value: {np.mean(dispersion_results[\"drogueTriggerTime\"]):0.3f} s'\n",
+ ")\n",
+ "print(\n",
+ " f'Drogue Parachute Trigger Time - Standard Deviation: {np.std(dispersion_results[\"drogueTriggerTime\"]):0.3f} s'\n",
+ ")\n",
+ "\n",
+ "plt.figure()\n",
+ "plt.hist(dispersion_results[\"drogueTriggerTime\"], bins=int(N**0.5))\n",
+ "plt.title(\"Drogue Parachute Trigger Time\")\n",
+ "plt.xlabel(\"Time (s)\")\n",
+ "plt.ylabel(\"Number of Occurrences\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "nKSzDWi7pORi"
+ },
+ "source": [
+ "### Drogue Parachute Fully Inflated Time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 64,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 607
+ },
+ "id": "KCYKVFYXpORj",
+ "outputId": "8ae49853-0f08-4bf6-9bd8-91a7c9a9448d",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Drogue Parachute Fully Inflated Time - Mean Value: 15.106 s\n",
+ "Drogue Parachute Fully Inflated Time - Standard Deviation: 0.608 s\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": "\r\n\r\n\r\n\r\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "print(\n",
+ " f'Drogue Parachute Fully Inflated Time - Mean Value: {np.mean(dispersion_results[\"drogueInflatedTime\"]):0.3f} s'\n",
+ ")\n",
+ "print(\n",
+ " f'Drogue Parachute Fully Inflated Time - Standard Deviation: {np.std(dispersion_results[\"drogueInflatedTime\"]):0.3f} s'\n",
+ ")\n",
+ "\n",
+ "plt.figure()\n",
+ "plt.hist(dispersion_results[\"drogueInflatedTime\"], bins=int(N**0.5))\n",
+ "plt.title(\"Drogue Parachute Fully Inflated Time\")\n",
+ "plt.xlabel(\"Time (s)\")\n",
+ "plt.ylabel(\"Number of Occurences\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "BvMCGZYHpORn"
+ },
+ "source": [
+ "### Drogue Parachute Fully Inflated Velocity"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 65,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 607
+ },
+ "id": "KxrpPUzqpORn",
+ "outputId": "9c102bdb-b805-4aa1-b3a2-1ac329c76976",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Drogue Parachute Fully Inflated Velocity - Mean Value: 13.936 m/s\n",
+ "Drogue Parachute Fully Inflated Velocity - Standard Deviation: 3.091 m/s\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": "\r\n\r\n\r\n\r\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "print(\n",
+ " f'Drogue Parachute Fully Inflated Velocity - Mean Value: {np.mean(dispersion_results[\"drogueInflatedVelocity\"]):0.3f} m/s'\n",
+ ")\n",
+ "print(\n",
+ " f'Drogue Parachute Fully Inflated Velocity - Standard Deviation: {np.std(dispersion_results[\"drogueInflatedVelocity\"]):0.3f} m/s'\n",
+ ")\n",
+ "\n",
+ "plt.figure()\n",
+ "plt.hist(dispersion_results[\"drogueInflatedVelocity\"], bins=int(N**0.5))\n",
+ "plt.title(\"Drogue Parachute Fully Inflated Velocity\")\n",
+ "plt.xlabel(\"Velocity m/s)\")\n",
+ "plt.ylabel(\"Number of Occurences\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "TlWXtnKMrlMI"
+ },
+ "source": [
+ "### Error Ellipses\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 69,
+ "metadata": {
+ "cellView": "both",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 837
+ },
+ "id": "DZRrk_bIr3iG",
+ "outputId": "b4a5a583-7f53-473a-bec2-2636cdf28a7c",
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": "\r\n\r\n\r\n