From 4ecbf3f6473109640379da2703301c6551659885 Mon Sep 17 00:00:00 2001 From: danielandresrestrebadaleal-dev Date: Sat, 4 Apr 2026 18:08:12 -0500 Subject: [PATCH 1/8] Creado con Colab --- Jupyter_tutorial_ARC.ipynb | 802 +++++++++++++++++++++++++++++++++++++ 1 file changed, 802 insertions(+) create mode 100644 Jupyter_tutorial_ARC.ipynb diff --git a/Jupyter_tutorial_ARC.ipynb b/Jupyter_tutorial_ARC.ipynb new file mode 100644 index 0000000..6b5ff40 --- /dev/null +++ b/Jupyter_tutorial_ARC.ipynb @@ -0,0 +1,802 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZJ2210Cdwwal" + }, + "source": [ + "# Analyzing orbital perturbations of TESS orbit\n", + "\n", + " The goal of this tutorial is to simulate the orbit of the Transiting Exoplanet Survey Satellite (TESS) under the effect of different perturbing forces (solar radiation, gravitational forces, etc.). The simulation will be performed for approximately 8.5 years. Therefore, we aim to understand how we can minimize computational processing time by compromising some degree of accuracy in our simulation. This is achieved by ignoring the effect of each perturbing force and computing the evolution of the fractional error of the position and velocity of TESS over time. The JPL Horizons database is utilized to obtain our reference values for the position and velocity of TESS for the timespan of the simulation. By understanding which perturbing forces can be dismissed while maintaining a low fractional error, we can generalize the results of this simulation to others which have a similar orbit and thus save computational time.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "sLFju77hwW6w" + }, + "outputs": [], + "source": [ + "#Install necessary packages for Google Colab. Note: hapsira is the modern version of poliastro to handle Python 3.12\n", + "!pip install hapsira \"astropy<7.0\" jplephem" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fqRzoMKXwu_r" + }, + "source": [ + "# Code Imports\n", + "This code utilizes several Python libraries for different functionalities:\n", + "1. poliastro: defines celestial bodies and physical constants, calculates the evolution of the orbit using Cowell Propagator, and introduces the effects of solar radiation and other forces\n", + "\n", + "2. astropy: imports the JPL horizons database and handles coordinate system conversions to accurately compare the simulation results\n", + "\n", + "3. numpy: performs math computations\n", + "\n", + "4. matplotlib: plots evolution of fractional error for position and velocity over time in an organized graph with axes labels and legend\n", + "\n", + "5. gc: clean up data\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "NI5Hi5Tj7kF9" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import astropy.units as u\n", + "from astropy.time import Time\n", + "from astropy.coordinates import solar_system_ephemeris\n", + "from hapsira.bodies import Earth, Moon, Sun, Jupiter, Venus\n", + "from hapsira.twobody import Orbit\n", + "from hapsira.twobody.propagation import CowellPropagator\n", + "from hapsira.core.perturbations import third_body, radiation_pressure\n", + "from hapsira.core.propagation import func_twobody\n", + "from hapsira.ephem import build_ephem_interpolant, Ephem\n", + "from hapsira.constants import rho0_earth, H0_earth\n", + "import time\n", + "import gc\n", + "from astropy.coordinates import (\n", + " CartesianRepresentation, CartesianDifferential, SkyCoord, ICRS, GCRS\n", + ")\n", + "\n", + "# ---------------------- Simulation Configuration ----------------------\n", + "# Total simulation duration in days.\n", + "SIMULATION_DURATION_DAYS = 3050" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "34eJzUCH-WOg" + }, + "source": [ + "# Environment Initialization\n", + "\n", + "Ths function defines the starting time of the simulation as June 1st, 2018. It then creates an evenly-spaced position vector for each celestial body with its current position every 1 hour from the beginning to the end of the simulation. This is more effective than looking for the exact position of each celestial body for each small step in the simulation since it would significantly increase the computational time." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "4EjAFUmaAaGw" + }, + "outputs": [], + "source": [ + "def initialize_environment():\n", + " \"\"\"\n", + " Set up the solar system ephemeris and build ephemeris interpolants.\n", + " \"\"\"\n", + " # Choose ephemeris data source (JPL in this case)\n", + " solar_system_ephemeris.set(\"jpl\")\n", + "\n", + " # 1. Define simulation epoch as a pure Time object\n", + " simulation_start_epoch = Time(\"2018-06-01T00:00:00\", scale=\"utc\", format=\"isot\")\n", + "\n", + " # 2. Calculate the exact end Time object by adding the days directly to the Time object (NO .jd!)\n", + " simulation_end_epoch = simulation_start_epoch + SIMULATION_DURATION_DAYS * u.day\n", + "\n", + " # Generate an array of epochs at 1-hour intervals for the interpolation\n", + " time_span_delta = simulation_end_epoch - simulation_start_epoch\n", + " num_steps = int(time_span_delta.to(u.hr).value) # Calculate number of steps to ensure including the end epoch\n", + " epochs_for_interpolant = simulation_start_epoch + np.arange(num_steps + 1) * u.hr\n", + "\n", + " # 3. Build ephemeris interpolants, specifying Earth as the attractor\n", + " moon_ephem_interp = build_ephem_interpolant(\n", + " Moon, epochs_for_interpolant, attractor=Earth\n", + " )\n", + " sun_ephem_interp = build_ephem_interpolant(\n", + " Sun, epochs_for_interpolant, attractor=Earth\n", + " )\n", + " jupiter_ephem_interp = build_ephem_interpolant(\n", + " Jupiter, epochs_for_interpolant, attractor=Earth\n", + " )\n", + " venus_ephem_interp = build_ephem_interpolant(\n", + " Venus, epochs_for_interpolant, attractor=Earth\n", + " )\n", + "\n", + " # Clean up memory\n", + " gc.collect()\n", + "\n", + " return simulation_start_epoch, moon_ephem_interp, sun_ephem_interp, jupiter_ephem_interp, venus_ephem_interp" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xPL8KK8kAhek" + }, + "source": [ + "# Setting up physical constants\n", + "\n", + "This function mainly computes the required physical constants to perform the orbital simulations and converts them to the correct units" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "bzZ33Af7BMOW" + }, + "outputs": [], + "source": [ + "# ---------------------- Physical Constants ----------------------\n", + "def define_physical_constants():\n", + " \"\"\"\n", + " Retrieve and compute key physical constants required for the simulation.\n", + "\n", + " Returns:\n", + " dict: A dictionary containing various physical parameters.\n", + " \"\"\"\n", + " earth_radius_km = Earth.R.to(u.km).value\n", + " gravitational_param = Earth.k.to(u.km**3 / u.s**2).value\n", + "\n", + " # Atmospheric drag coefficient (negligible for TESS orbit, hence set as a constant)\n", + " drag_coefficient = 2.2\n", + "\n", + " # Area-to-mass ratio, converting from square meters/kg to square km/kg\n", + " area_to_mass = ((3) * (u.m**2) / (350 * u.kg)).to_value(u.km**2 / u.kg)\n", + "\n", + " # Atmospheric density at Earth's surface and scale height\n", + " surface_density = rho0_earth.to(u.kg / u.km**3).value\n", + " scale_height = H0_earth.to(u.km).value\n", + "\n", + " # Radiation pressure coefficient and solar flux-to-speed constant ratio\n", + " radiation_coefficient = 1.3\n", + " solar_flux_over_c = (3.828e20) / 299792.458\n", + "\n", + " return {\n", + " \"earth_radius\": earth_radius_km,\n", + " \"grav_param\": gravitational_param,\n", + " \"drag_coefficient\": drag_coefficient,\n", + " \"area_to_mass\": area_to_mass,\n", + " \"surface_density\": surface_density,\n", + " \"scale_height\": scale_height,\n", + " \"radiation_coefficient\": radiation_coefficient,\n", + " \"solar_flux_over_c\": solar_flux_over_c,\n", + " }" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bMhDPYC3BUr9" + }, + "source": [ + "# Computing Acceleration Vector\n", + "\n", + "This function creates a 3D vector representing the acceleration in the x, y, and z directions for our spacecraft. It then checks whether it is desired to calculate the effect of a perturbing force by checking the force_flags dictionary. If it is listed as \"True,\" it calls the corresponding function from poliastro (e.g. \"third_body\" for celestial bodies) to add the acceleration produced by such force. In this way, we can bypass the effect of a force to analyze how accurate the simulation can still be. The function returns an acceleration vector is the addition of all the accelerations produced by the desired perturbing forces" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "_iUBJbRcD4l0" + }, + "outputs": [], + "source": [ + "# ---------------------- Perturbation Acceleration Functions ----------------------\n", + "def compute_perturbation_acceleration(t0, state, grav_param, constants, sun_interp, moon_interp,\n", + " jupiter_interp, venus_interp, force_flags):\n", + " \"\"\"\n", + " Computes the total perturbation acceleration due to third-body effects and radiation pressure.\n", + "\n", + " Args:\n", + " t0 (float): Initial time.\n", + " state (ndarray): Current state vector of the spacecraft.\n", + " grav_param (float): Gravitational parameter of the primary body.\n", + " constants (dict): Physical constants (e.g., Earth radius, radiation coefficients).\n", + " sun_interp: Ephemeris interpolant for the Sun.\n", + " moon_interp: Ephemeris interpolant for the Moon.\n", + " jupiter_interp: Ephemeris interpolant for Jupiter.\n", + " venus_interp: Ephemeris interpolant for Venus.\n", + " force_flags (dict): Dictionary indicating which forces to include in the simulation.\n", + "\n", + " Returns:\n", + " ndarray: Combined acceleration vector due to all selected perturbation forces.\n", + " \"\"\"\n", + " total_acceleration = np.zeros(3)\n", + "\n", + " # Moon's third-body effect\n", + " if force_flags.get(\"Moon\", True):\n", + " total_acceleration += third_body(t0, state, grav_param,\n", + " k_third=Moon.k.to(u.km**3/u.s**2).value,\n", + " perturbation_body=moon_interp)\n", + " # Sun's third-body effect (using sun_interp as the star body)\n", + " if force_flags.get(\"Sun\", True):\n", + " total_acceleration += third_body(t0, state, grav_param,\n", + " k_third=Sun.k.to(u.km**3/u.s**2).value,\n", + " perturbation_body=sun_interp)\n", + " # Jupiter's third-body effect\n", + " if force_flags.get(\"Jupiter\", True):\n", + " total_acceleration += third_body(t0, state, grav_param,\n", + " k_third=Jupiter.k.to(u.km**3/u.s**2).value,\n", + " perturbation_body=jupiter_interp)\n", + " # Venus's third-body effect\n", + " if force_flags.get(\"Venus\", True):\n", + " total_acceleration += third_body(t0, state, grav_param,\n", + " k_third=Venus.k.to(u.km**3/u.s**2).value,\n", + " perturbation_body=venus_interp)\n", + " # Solar radiation pressure effect\n", + " if force_flags.get(\"Radiation\", True):\n", + " total_acceleration += radiation_pressure(\n", + " t0, state, grav_param,\n", + " constants[\"earth_radius\"],\n", + " constants[\"radiation_coefficient\"],\n", + " constants[\"area_to_mass\"],\n", + " constants[\"solar_flux_over_c\"],\n", + " sun_interp\n", + " )\n", + " return total_acceleration" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gQVWwLQnD--r" + }, + "source": [ + "# Computing the derivative of the state vector\n", + "\n", + "In order to use the Cowell Propagator from poliastro, this function computes how fast the position and velocity of the spacecraft is changing at a specific point in time. It calculates the velocity and acceleration vector based on a 2-body Keplerian motion model between the Earth and the spacecraft. Then, it adds all the third-body effects to this vector to obtain a final vector describing how both the position and velocity are changing through time at that instant." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "WA3qxCw4KLXE" + }, + "outputs": [], + "source": [ + "def perturbation_derivatives(t0, state, grav_param, constants, sun_interp, moon_interp,\n", + " jupiter_interp, venus_interp, force_flags):\n", + " \"\"\"\n", + " Computes the time derivatives of the state vector including both Keplerian and perturbation accelerations.\n", + "\n", + " Args:\n", + " t0 (float): Initial time.\n", + " state (ndarray): Current state vector.\n", + " grav_param (float): Gravitational parameter for the primary body.\n", + " constants (dict): Dictionary of physical constants.\n", + " sun_interp, moon_interp, jupiter_interp, venus_interp: Ephemeris interpolants.\n", + " force_flags (dict): Flags indicating which perturbing forces are active.\n", + "\n", + " Returns:\n", + " ndarray: Time derivative of the state vector.\n", + " \"\"\"\n", + " # Two-body (Keplerian) derivative\n", + " keplerian_deriv = func_twobody(t0, state, grav_param)\n", + "\n", + " # Compute total perturbation acceleration.\n", + " accel_perturb = compute_perturbation_acceleration(\n", + " t0, state, grav_param, constants, sun_interp, moon_interp, jupiter_interp, venus_interp, force_flags\n", + " )\n", + "\n", + " # Append the perturbation acceleration (affecting velocity components) to the Keplerian derivative.\n", + " return keplerian_deriv + np.array([0, 0, 0, accel_perturb[0], accel_perturb[1], accel_perturb[2]])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eiUzvvn5KQDl" + }, + "source": [ + "# Initializing the orbit\n", + "\n", + "This function defines the Orbit object needed to start the simulation. To do so, it extracts the the state vector of TESS at the starting time of our simulation from the JPL Horizons database. It performs some necessary unit conversions and translates the vector from ICRS (Sun-centered) to GCRS (Earth-centered) coordinate system, as poliastro uses GCRS as default for orbit propagations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "_AaJQNupKg2Y" + }, + "outputs": [], + "source": [ + "# ---------------------- Orbit Initialization ----------------------\n", + "def initialize_orbit(simulation_epoch):\n", + " \"\"\"\n", + " Create the initial orbit state from spacecraft ephemeris data (using TESS as reference).\n", + " The state vector is transformed from the ICRS frame to the GCRS frame.\n", + "\n", + " Args:\n", + " simulation_epoch (Time): The epoch of the simulation start.\n", + "\n", + " Returns:\n", + " Orbit: The initial Orbit object.\n", + " \"\"\"\n", + " # Retrieve TESS ephemeris data from Horizons system.\n", + " tess_ephem = Ephem.from_horizons(\"TESS\", epochs=simulation_epoch)\n", + "\n", + " # Get position and velocity vectors in km and km/s respectively.\n", + " position_icrf = np.array(tess_ephem.rv()[0].to(u.km).value).reshape(-1)\n", + " velocity_icrf = np.array(tess_ephem.rv()[1].to(u.km / u.s).value).reshape(-1)\n", + "\n", + " # Create initial orbit in ICRF frame from position and velocity.\n", + " orbit_icrf = Orbit.from_vectors(Earth, position_icrf * u.km, velocity_icrf * (u.km / u.s), epoch=simulation_epoch)\n", + "\n", + " # Extract ICRF vectors\n", + " r_icrf, v_icrf = orbit_icrf.rv()\n", + "\n", + " # Transform state vector from ICRS/ICRF to the GCRS frame.\n", + " cart_representation = CartesianRepresentation(*r_icrf)\n", + " cart_differentials = CartesianDifferential(*v_icrf)\n", + " icrs_coord = SkyCoord(cart_representation.with_differentials(cart_differentials),\n", + " frame=ICRS, obstime=simulation_epoch)\n", + " gcrs_coord = icrs_coord.transform_to(GCRS(obstime=simulation_epoch))\n", + "\n", + " # Retrieve transformed position and velocity components.\n", + " r_gcrs = gcrs_coord.data.represent_as(CartesianRepresentation).xyz\n", + " v_gcrs = gcrs_coord.data.differentials[\"s\"].d_xyz\n", + "\n", + " # Clean up temporary variables.\n", + " del cart_representation, cart_differentials, icrs_coord, gcrs_coord\n", + " gc.collect()\n", + "\n", + " return Orbit.from_vectors(Earth, r_gcrs, v_gcrs, epoch=simulation_epoch)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PRC-BO0IMUfx" + }, + "source": [ + "# Orbit propagation\n", + "\n", + "This function simply propagates the starting orbit using poliastro's Cowell Propagator over the specified time interval. It returns the final orbit object after the simulation, from which we can extract the state vector. In principle, this function is called for each time step during the simulation to obtain a continuous evolution of the position and velocity of the spacecraft" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "vmGWMSUdMXER" + }, + "outputs": [], + "source": [ + "# ---------------------- Orbit Propagation & Data Processing ----------------------\n", + "def propagate_orbit(orbit_obj, time_interval, perturbation_function):\n", + " \"\"\"\n", + " Propagate the orbit over a specified time interval using the Cowell propagator.\n", + "\n", + " Args:\n", + " orbit_obj (Orbit): The initial Orbit object.\n", + " time_interval (Quantity): Duration over which to propagate.\n", + " perturbation_function (function): Function to compute perturbations.\n", + "\n", + " Returns:\n", + " Orbit: Final orbit after propagation.\n", + " \"\"\"\n", + " propagated_orbit = orbit_obj.propagate(\n", + " time_interval, method=CowellPropagator(rtol=3e-14, f=perturbation_function)\n", + " )\n", + " gc.collect()\n", + " return propagated_orbit" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uSBQa23XNQiR" + }, + "source": [ + "# Creating evenly-spaced time intervals\n", + "\n", + "This function creates epoch objects which are evenly spaced. The number of intervals is user-defined and can affect the how precise our simulation is. A good value should be chosen so that we can have enough precision while still running the program in a reasonable amount of time. Thus, 100 intervals were chosen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "yTf9vpShNREu" + }, + "outputs": [], + "source": [ + "def create_simulation_epochs(start_epoch, end_epoch, num_intervals):\n", + " \"\"\"\n", + " Generate an array of epochs spanning from the start to the end epoch.\n", + " \"\"\"\n", + " # Safely convert the TimeDelta into raw seconds\n", + " total_seconds = (end_epoch - start_epoch).to(u.s).value\n", + "\n", + " # Generate the checkpoints and add them back to the start time\n", + " epochs = start_epoch + np.linspace(0, total_seconds, num_intervals + 1) * u.s\n", + "\n", + " gc.collect()\n", + " return epochs" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NX7MXI5aOFr6" + }, + "source": [ + "# Extracting data for error analysis\n", + "\n", + "This function calls the Cowell Propagator for each time interval to obtain the Orbit object for each time step. Then, it extracts the position and velocity vector from each object. These values are converted from GCRS to the ICRS coordinate system for comparison with the JPL Horizons database" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "JcRYLKiZOEcQ" + }, + "outputs": [], + "source": [ + "def simulate_spacecraft_trajectory(orbit_obj, perturbation_function, epoch_array):\n", + " \"\"\"\n", + " Propagate the spacecraft orbit for each epoch in the provided array and convert the results\n", + " to ICRS frame state vectors.\n", + "\n", + " Args:\n", + " orbit_obj (Orbit): Initial orbit.\n", + " perturbation_function (function): Function to compute perturbation accelerations.\n", + " epoch_array (Quantity): Array of epochs at which to propagate the orbit.\n", + "\n", + " Returns:\n", + " tuple: (r_state, v_state) state arrays in the ICRS frame.\n", + " \"\"\"\n", + " start_time = time.perf_counter()\n", + " propagated_orbits = [\n", + " orbit_obj.propagate(ep, method=CowellPropagator(rtol=3e-14, f=perturbation_function))\n", + " for ep in epoch_array\n", + " ]\n", + " end_time = time.perf_counter()\n", + " print(\"Propagation time: {:.3f} seconds\".format(end_time - start_time))\n", + "\n", + " positions, velocities, epochs_list = [], [], []\n", + " for orbit_instance in propagated_orbits:\n", + " positions.append(orbit_instance.r)\n", + " velocities.append(orbit_instance.v)\n", + " epochs_list.append(orbit_instance.epoch)\n", + "\n", + " # Convert lists to numpy arrays\n", + " pos_array = np.array(positions)\n", + " vel_array = np.array(velocities)\n", + " epochs_array = Time(epochs_list)\n", + "\n", + " # Convert coordinates from GCRS to ICRS for output and analysis.\n", + " conversion_start = time.perf_counter()\n", + " sky_coordinates = SkyCoord(\n", + " CartesianRepresentation(\n", + " pos_array[:, 0] * u.km,\n", + " pos_array[:, 1] * u.km,\n", + " pos_array[:, 2] * u.km,\n", + " differentials=CartesianDifferential(\n", + " vel_array[:, 0] * (u.km / u.s),\n", + " vel_array[:, 1] * (u.km / u.s),\n", + " vel_array[:, 2] * (u.km / u.s)\n", + " )\n", + " ),\n", + " frame=GCRS,\n", + " obstime=epochs_array\n", + " )\n", + " icrs_coordinates = sky_coordinates.transform_to(ICRS)\n", + " r_state = icrs_coordinates.cartesian.xyz.T.value\n", + " v_state = icrs_coordinates.cartesian.differentials[\"s\"].d_xyz.T.value\n", + "\n", + " # Clean up and free memory.\n", + " del positions, velocities, pos_array, vel_array, epochs_list, epochs_array, sky_coordinates, icrs_coordinates\n", + " gc.collect()\n", + "\n", + " conversion_end = time.perf_counter()\n", + " print(\"Coordinate conversion time: {:.3f} seconds\".format(conversion_end - conversion_start))\n", + " return r_state, v_state" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WDbOY6Y8PP0E" + }, + "source": [ + "# Retrieving TESS data from JPL Horizons\n", + "\n", + "At each time step, this function retrieves the position and velocity vectors from JPL Horizons for TESS" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "bmRkh3r_PQae" + }, + "outputs": [], + "source": [ + "def retrieve_actual_spacecraft_data(epoch_array, num_intervals):\n", + " \"\"\"\n", + " Obtain reference spacecraft data from Horizons (using TESS as reference) for error comparison.\n", + "\n", + " Args:\n", + " epoch_array (Quantity): Array of simulation epochs.\n", + " num_intervals (int): Number of intervals (subdivisions used during simulation).\n", + "\n", + " Returns:\n", + " tuple: (r_actual, v_actual) state arrays from reference data.\n", + " \"\"\"\n", + " tess_ephem_list = [Ephem.from_horizons(\"TESS\", epochs=ep) for ep in epoch_array]\n", + " actual_positions = np.array([ephem.rv()[0].to(u.km).value for ephem in tess_ephem_list])\n", + " actual_velocities = np.array([ephem.rv()[1].to(u.km / u.s).value for ephem in tess_ephem_list])\n", + "\n", + " # Ensure that the arrays have the expected dimensions.\n", + " r_actual = actual_positions.reshape(num_intervals + 1, 3)\n", + " v_actual = actual_velocities.reshape(num_intervals + 1, 3)\n", + " del tess_ephem_list\n", + " gc.collect()\n", + " return r_actual, v_actual" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8vTnimfdPo_m" + }, + "source": [ + "# Computing and plotting fractional error over time\n", + "\n", + "These functions calculate and plot the fractional error as a function of time for the duration of the simulation. The fractional error for the position and velocity vectors are computed as the difference between the Euclidean norm between the simulation vector and JPL Horizons vector dividided by the JPL Horizons vector. This is done for each time step using vectorized operations with the help of numpy. The results are plotted in two different figures: one for the position and one for the velocity vector" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "FlquX_O1PpeE" + }, + "outputs": [], + "source": [ + "# ---------------------- Error Analysis ----------------------\n", + "def calculate_fractional_errors(simulated_positions, reference_positions, simulated_velocities, reference_velocities):\n", + " \"\"\"\n", + " Calculate the fractional errors between simulated and reference position and velocity vectors.\n", + "\n", + " Args:\n", + " simulated_positions (ndarray): Simulated positions.\n", + " reference_positions (ndarray): Reference positions.\n", + " simulated_velocities (ndarray): Simulated velocities.\n", + " reference_velocities (ndarray): Reference velocities.\n", + "\n", + " Returns:\n", + " tuple: Fractional errors for positions and velocities.\n", + " \"\"\"\n", + " # Position error calculations\n", + " position_error_norm = np.linalg.norm(simulated_positions - reference_positions, axis=1)\n", + " reference_position_norm = np.linalg.norm(reference_positions, axis=1)\n", + " fractional_error_position = position_error_norm / reference_position_norm\n", + "\n", + " # Velocity error calculations\n", + " velocity_error_norm = np.linalg.norm(simulated_velocities - reference_velocities, axis=1)\n", + " reference_velocity_norm = np.linalg.norm(reference_velocities, axis=1)\n", + " fractional_error_velocity = velocity_error_norm / reference_velocity_norm\n", + "\n", + " return fractional_error_position, fractional_error_velocity\n", + "\n", + "# ---------------------- Plotting Functions ----------------------\n", + "def plot_fractional_errors(time_years, position_errors_dict, velocity_errors_dict):\n", + " \"\"\"\n", + " Plot and save the fractional error comparisons for positions and velocities.\n", + "\n", + " Args:\n", + " time_years (ndarray): Time axis in years.\n", + " position_errors_dict (dict): Dictionary of position error arrays keyed by simulation case label.\n", + " velocity_errors_dict (dict): Dictionary of velocity error arrays keyed by simulation case label.\n", + " \"\"\"\n", + " # Plot position fractional errors.\n", + " fig_pos, ax_pos = plt.subplots(figsize=(10, 6))\n", + " for label, error_array in position_errors_dict.items():\n", + " ax_pos.plot(time_years, error_array, 'o-', label=label)\n", + " ax_pos.set_title('Fractional Error in Position Magnitude')\n", + " ax_pos.set_xlabel('Time Since Start (years)')\n", + " ax_pos.set_ylabel('Fractional Error')\n", + " ax_pos.legend()\n", + " fig_pos.savefig(\"position_magnitude_error.png\", dpi=130)\n", + "\n", + " # Plot velocity fractional errors.\n", + " fig_vel, ax_vel = plt.subplots(figsize=(10, 6))\n", + " for label, error_array in velocity_errors_dict.items():\n", + " ax_vel.plot(time_years, error_array, 'o-', label=label)\n", + " ax_vel.set_title('Fractional Error in Velocity Magnitude')\n", + " ax_vel.set_xlabel('Time Since Start (years)')\n", + " ax_vel.set_ylabel('Fractional Error')\n", + " ax_vel.legend()\n", + " fig_vel.savefig(\"velocity_magnitude_error.png\", dpi=130)\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-_FqFJ3-RMho" + }, + "source": [ + "# Main program function\n", + "\n", + "This is the main function of the program that handles all other functions. Its main purpose is to update the force_flags dictionary each time with a new force turned \"off\" and plot the results for that corresponding case" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "DyzoIjwGRM_F", + "collapsed": true + }, + "outputs": [], + "source": [ + "# ---------------------- Main Simulation Routine ----------------------\n", + "def main_simulation():\n", + " # Initialize simulation environment and physical constants.\n", + " sim_epoch, moon_interp, sun_interp, jupiter_interp, venus_interp = initialize_environment()\n", + " physical_constants = define_physical_constants()\n", + "\n", + " # Initialize the spacecraft orbit using reference (TESS) data.\n", + " initial_orbit = initialize_orbit(sim_epoch)\n", + "\n", + " # Define the number of intervals for simulation sampling.\n", + " NUM_INTERVALS = 100\n", + "\n", + " # Propagate orbit without any modifications to define final simulation end epoch.\n", + " final_orbit = propagate_orbit(\n", + " initial_orbit,\n", + " SIMULATION_DURATION_DAYS * u.day,\n", + " lambda t0, state, k: perturbation_derivatives(\n", + " t0, state, k, physical_constants, sun_interp, moon_interp, jupiter_interp,\n", + " venus_interp, {\"Moon\": True, \"Sun\": True, \"Jupiter\": True, \"Venus\": True, \"Radiation\": True}\n", + " )\n", + " )\n", + "\n", + " # Generate an array of epochs between the start and final orbit epochs.\n", + " simulation_epochs = create_simulation_epochs(initial_orbit.epoch, final_orbit.epoch, NUM_INTERVALS)\n", + "\n", + " # Retrieve reference spacecraft data for error analysis.\n", + " reference_positions, reference_velocities = retrieve_actual_spacecraft_data(simulation_epochs, NUM_INTERVALS)\n", + "\n", + " # Define base force flags and simulation cases (each turning off one perturbation).\n", + " base_force_flags = {\n", + " \"Moon\": True, \"Sun\": True, \"Jupiter\": True, \"Venus\": True, \"Radiation\": True\n", + " }\n", + " simulation_cases = {\n", + " \"Without Moon\": {**base_force_flags, \"Moon\": False},\n", + " \"Without Sun\": {**base_force_flags, \"Sun\": False},\n", + " \"Without Jupiter\": {**base_force_flags, \"Jupiter\": False},\n", + " \"Without Venus\": {**base_force_flags, \"Venus\": False},\n", + " \"Without Radiation\": {**base_force_flags, \"Radiation\": False},\n", + " \"All Forces\": base_force_flags.copy()\n", + " }\n", + "\n", + " # Dictionaries to hold the fractional errors for each simulation case.\n", + " pos_errors_dict = {}\n", + " vel_errors_dict = {}\n", + " # Convert epochs difference to years for x-axis plotting.\n", + " time_axis_years = (simulation_epochs - simulation_epochs[0]).sec / (3600 * 24 * 365.25)\n", + "\n", + " # Execute simulation for each force configuration.\n", + " for case_label, force_config in simulation_cases.items():\n", + " # Define the perturbation function using current force configuration.\n", + " perturbation_function = lambda t0, state, k, flags=force_config: perturbation_derivatives(\n", + " t0, state, k, physical_constants, sun_interp, moon_interp, jupiter_interp, venus_interp, flags\n", + " )\n", + " simulated_positions, simulated_velocities = simulate_spacecraft_trajectory(initial_orbit, perturbation_function, simulation_epochs)\n", + "\n", + " # Compute fractional errors between simulation and reference data.\n", + " frac_err_pos, frac_err_vel = calculate_fractional_errors(simulated_positions, reference_positions,\n", + " simulated_velocities, reference_velocities)\n", + " pos_errors_dict[case_label] = frac_err_pos\n", + " vel_errors_dict[case_label] = frac_err_vel\n", + "\n", + " # Plot and save error comparisons.\n", + " plot_fractional_errors(time_axis_years, pos_errors_dict, vel_errors_dict)\n", + " gc.collect()\n", + "\n", + "# Execute the simulation only if this script is run directly.\n", + "if __name__ == \"__main__\":\n", + " main_simulation()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D3x_mHN-Q6wr" + }, + "source": [ + "The following figures are obtained from this code:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "g1xBm_YEQkQ5" + }, + "source": [ + "![velocity_magnitude_error (1).png](data:image/png;base64,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)![position_magnitude_error (1) (1).png](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tQ0tBVlpRG3S" + }, + "source": [ + "#" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Results and Conclusions\n", + "\n", + "Both graphs show the need to include the third-body effects from the Moon and the Sun to obtain accurate simulations. The fractional error for the magnitude of both the position and the velocity spikes at a very early stage of the simulation when the gravitational forces from these bodies is ignored. The solar radiation force becomes more relevant at around 6 years after the beginning of the simulation, where it starts to clearly diverge from the \"All forces\" case. In contrast, removing the influence of secondary celestial bodies, such as Jupiter and Venus, on the orbit of the simulated spacecraft shows no clear sign of loss of accuracy. Based on these results, it can be concluded that when simulating the orbit of a spacecraft on High-Earth Orbit (HEO), such as TESS, it is crucial to include the gravitational effects of primary celestial bodies like the Moon and the Sun while the influence from planets like Jupiter and Venus can be removed, saving computational time while not compromising a significant loss of accuracy\n", + "\n" + ], + "metadata": { + "id": "rTMJYPxyqxQB" + } + } + ], + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyMUbF1AMZ3NdtaQOd740GBx", + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From 74e766bcfd22e6dc5e4283c2c50c2678c1232cf4 Mon Sep 17 00:00:00 2001 From: danielandresrestrebadaleal-dev Date: Sun, 5 Apr 2026 15:28:35 -0500 Subject: [PATCH 2/8] Creado con Colab --- Jupyter_tutorial_ARC.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Jupyter_tutorial_ARC.ipynb b/Jupyter_tutorial_ARC.ipynb index 6b5ff40..e482f89 100644 --- a/Jupyter_tutorial_ARC.ipynb +++ b/Jupyter_tutorial_ARC.ipynb @@ -206,7 +206,7 @@ "source": [ "# Computing Acceleration Vector\n", "\n", - "This function creates a 3D vector representing the acceleration in the x, y, and z directions for our spacecraft. It then checks whether it is desired to calculate the effect of a perturbing force by checking the force_flags dictionary. If it is listed as \"True,\" it calls the corresponding function from poliastro (e.g. \"third_body\" for celestial bodies) to add the acceleration produced by such force. In this way, we can bypass the effect of a force to analyze how accurate the simulation can still be. The function returns an acceleration vector is the addition of all the accelerations produced by the desired perturbing forces" + "This function creates a 3D vector representing the acceleration in the x, y, and z directions for our spacecraft. It then checks whether it is desired to calculate the effect of a perturbing force by checking the force_flags dictionary. If it is listed as \"True,\" it calls the corresponding function from poliastro (e.g. \"third_body\" for celestial bodies) to add the acceleration produced by such force. In this way, we can bypass the effect of a force to analyze how accurate the simulation can still be. The function returns an acceleration vector as the addition of all the accelerations produced by the desired perturbing forces" ] }, { @@ -786,7 +786,7 @@ "metadata": { "colab": { "provenance": [], - "authorship_tag": "ABX9TyMUbF1AMZ3NdtaQOd740GBx", + "authorship_tag": "ABX9TyMsVwy+oufGfJ1JcOW2+zMX", "include_colab_link": true }, "kernelspec": { From f5eb8796fcb9749a453cb1e1991096466715357d Mon Sep 17 00:00:00 2001 From: danielandresrestrebadaleal-dev Date: Sun, 5 Apr 2026 15:30:00 -0500 Subject: [PATCH 3/8] Creado con Colab --- GEO_orbital_simulation.ipynb | 611 +++++++++++++++++++++++++++++++++++ 1 file changed, 611 insertions(+) create mode 100644 GEO_orbital_simulation.ipynb diff --git a/GEO_orbital_simulation.ipynb b/GEO_orbital_simulation.ipynb new file mode 100644 index 0000000..fd1cce9 --- /dev/null +++ b/GEO_orbital_simulation.ipynb @@ -0,0 +1,611 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyPdwXNaWs4HiY7aS0cvdNWP", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Intro & Goal of this program\n", + "\n", + "This program simulates the orbital profile of a payload carried by a two-stage rocket from a LEO orbit to insertion in a GEO orbit. To achieve this, the spacecraft performs a classic Hohmann transfer maneuver. The code implements realistic perturbing forces, such as the gravitational influence of the Moon, the Sun, J-type forces, etc. The goal of this program is to determine what is the associated delta-V cost and fuel mass needed to insert a payload in a GEO orbit, given specific launch parameters such as launch latitude, initial LEO altitude, etc." + ], + "metadata": { + "id": "EfZO5Rd4jXec" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "BjpU7NeZhLM-" + }, + "outputs": [], + "source": [ + "#Install necessary packages for Google Colab. Note: hapsira is the modern version of poliastro to handle Python 3.12\n", + "!pip install hapsira \"astropy<7.0\"" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Code Imports\n", + "This code utilizes several Python libraries for different functionalities:\n", + "\n", + "1. poliastro: defines celestial bodies and physical constants, calculates the evolution of the orbit using Cowell Propagator, and introduces the effects of solar radiation and other forces\n", + "\n", + "2. astropy: handling time objects, astronomical units, etc." + ], + "metadata": { + "id": "_sNzUodbmjgF" + } + }, + { + "cell_type": "code", + "source": [ + "from astropy import units as u\n", + "from hapsira.twobody import Orbit\n", + "from hapsira.core.perturbations import (\n", + " J2_perturbation, J3_perturbation, third_body,\n", + " radiation_pressure, atmospheric_drag_exponential\n", + ")\n", + "from hapsira.ephem import build_ephem_interpolant, Ephem\n", + "from hapsira.bodies import Earth, Moon, Sun\n", + "from hapsira.maneuver import Maneuver\n", + "from hapsira.constants import rho0_earth, H0_earth\n", + "\n", + "import numpy as np\n", + "from astropy.time import Time\n", + "from astropy.coordinates import CartesianRepresentation, CartesianDifferential, SkyCoord, ICRS, GCRS\n", + "from astropy.coordinates import solar_system_ephemeris\n", + "from hapsira.twobody.propagation import CowellPropagator\n", + "from hapsira.core.propagation import func_twobody" + ], + "metadata": { + "id": "pChUe3tU9j3G" + }, + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Interpolating values\n", + "\n", + "Because this program is meant to run multiple times with different launch parameters, we provide a list of apporixmate delta-V losses during takeoff to reach a specific LEO altitude. Interpolation is then used if any delta-V values is needed that is in between any of the provided LEO altitudes. This saves us the trouble of having to make complex calculations for the delta-V losses due to gravity and atmospheric drag for a specific altitude, although more sophisticated models can include this to increase accuracy" + ], + "metadata": { + "id": "_rNn-mNi92Dz" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "# ===============================================================\n", + "# Simulation and Interpolation Configuration\n", + "# ===============================================================\n", + "# Example interpolation data for gravitational and atmospheric losses based on LEO altitudes\n", + "LEO_ALTITUDES_KM = [200, 300, 400, 500, 600, 700, 800]\n", + "DELTA_V_GRAV_KMS = [1520, 1540, 1560, 1580, 1600, 1620, 1640] # in km/s (example values)\n", + "DELTA_V_ATM_KMS = [320, 280, 250, 230, 210, 190, 170] # in km/s (example values)\n" + ], + "metadata": { + "id": "eOVI25ac_Guv" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Physical Constants and Ephemeris Setup\n", + "\n", + "Because we will be computing drag, solar radiation, and other types of forces, we define a few constants with the necessary units for future calculations. We also set a starting epoch and initialize two vectors containing the positions of the Sun and the Moon from the starting time until one day later for every half an hour. This is more computationally efficient than calculating the exact position of the celestial bodies for every time step of the simulation." + ], + "metadata": { + "id": "M4UynXSc_KbF" + } + }, + { + "cell_type": "code", + "source": [ + "# ===============================================================\n", + "# Global Constants and Ephemeris Setup\n", + "# ===============================================================\n", + "# Earth-related constants\n", + "EARTH_RADIUS_KM = Earth.R.to(u.km).value\n", + "EARTH_K = Earth.k.to(u.km**3 / u.s**2).value\n", + "DRAG_COEFFICIENT = 2.2 # dimensionless\n", + "\n", + "# Atmospheric model constants (Earth)\n", + "SCALE_HEIGHT_KM = H0_earth.to(u.km).value\n", + "SEA_LEVEL_DENSITY = rho0_earth.to(u.kg / u.km**3).value\n", + "GLOBAL_AREA_TO_MASS = 0 # Placeholder value; updated later in calculation\n", + "\n", + "#Solar radiation constants\n", + "rad_coeff = 1.3\n", + "Wdivc_s = 3.828e20/299792.458\n", + "\n", + "# Define time epoch and set solar system ephemerides\n", + "EPOCH = Time(2451543.597, format=\"jd\", scale=\"tdb\")\n", + "solar_system_ephemeris.set(\"de432s\")\n", + "\n", + "# Build ephemeris interpolants for Moon and Sun (half-hour resolution over one day)\n", + "start_time = EPOCH\n", + "end_time = EPOCH + 1 * u.day\n", + "time_step = 0.5 * u.hr\n", + "\n", + "# Calculate the number of points needed to include both start and end times at the given step.\n", + "# For 1 day (24h) and 0.5h step: (24/0.5) + 1 = 48 + 1 = 49 points.\n", + "num_points = int(round((end_time - start_time).to(u.hr).value / time_step.to(u.hr).value)) + 1\n", + "times = start_time + np.arange(num_points) * time_step\n", + "\n", + "moon_ephem = build_ephem_interpolant(\n", + " Moon,\n", + " times, # Changed to positional argument\n", + " attractor=Earth # Explicitly set attractor\n", + ")\n", + "sun_ephem = build_ephem_interpolant(\n", + " Sun,\n", + " times, # Changed to positional argument\n", + " attractor=Earth # Explicitly set attractor\n", + ")\n" + ], + "metadata": { + "id": "KMyHUYvR_Ktu" + }, + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Initializing the LEO orbit\n", + "\n", + "Here, we initialize the Orbit object that defines our starting LEO orbit. The altitude and the inclination are user-defined, while all other parameters are set to 0." + ], + "metadata": { + "id": "vJHHI11HA-Hm" + } + }, + { + "cell_type": "code", + "source": [ + "def create_leo_orbit(leo_altitude_km, inclination_deg):\n", + " \"\"\"\n", + " Create a circular LEO orbit given altitude and inclination.\n", + "\n", + " Parameters:\n", + " leo_altitude_km (float): Altitude above the Earth’s surface in km.\n", + " inclination_deg (float): Orbit inclination in degrees.\n", + "\n", + " Returns:\n", + " Orbit: A poliastro Orbit object created from classical orbital elements.\n", + " \"\"\"\n", + " semi_major_axis = (leo_altitude_km + 6378) * u.km\n", + " eccentricity = 0.0 * u.one\n", + " inclination = inclination_deg * u.deg\n", + " raan = 0 * u.deg\n", + " arg_periapsis = 0 * u.deg\n", + " true_anomaly = 0 * u.deg\n", + "\n", + " return Orbit.from_classical(Earth, semi_major_axis, eccentricity,\n", + " inclination, raan, arg_periapsis, true_anomaly)" + ], + "metadata": { + "id": "HDeyr9oXA-wS" + }, + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Computing acceleration vector\n", + "\n", + "This function simply computes the accelerations caused by each force on the spacecraft at a specific time. To do this, we use poliastro's built-in functions for each force, the physical constants we defined earlier, and the arrays containing the position of the celestial bodies, as appropiate. It then adds up all the accelerations to get a final acceleration vector and returns this value." + ], + "metadata": { + "id": "ntzKSHj5BY_c" + } + }, + { + "cell_type": "code", + "source": [ + "# ===============================================================\n", + "# Perturbation and Propagation Functions\n", + "# ===============================================================\n", + "def perturbing_acceleration(t0, state, gravitational_parameter, J2, J3, radius,\n", + " drag_coeff, area_to_mass, scale_height, density0, Wdivc_s, rad_coeff, third_body_ephem):\n", + " \"\"\"\n", + " Compute total perturbing acceleration including J2, J3, atmospheric drag,\n", + " and third-body gravitational effects.\n", + " \"\"\"\n", + " accel_J2 = J2_perturbation(t0, state, gravitational_parameter, J2, radius)\n", + " accel_drag = atmospheric_drag_exponential(t0, state, gravitational_parameter, radius,\n", + " drag_coeff, area_to_mass, scale_height, density0)\n", + " accel_moon = third_body(t0, state, gravitational_parameter,\n", + " k_third=Moon.k.to(u.km**3 / u.s**2).value,\n", + " perturbation_body=moon_ephem)\n", + " accel_sun = third_body(t0, state, gravitational_parameter,\n", + " k_third=Sun.k.to(u.km**3 / u.s**2).value,\n", + " perturbation_body=third_body_ephem)\n", + " accel_J3 = J3_perturbation(t0, state, gravitational_parameter, J3, radius)\n", + " accel_rad = radiation_pressure(t0, state, gravitational_parameter, radius, rad_coeff, area_to_mass, Wdivc_s, third_body_ephem)\n", + "\n", + " return accel_J2 + accel_drag + accel_moon + accel_sun + accel_J3" + ], + "metadata": { + "id": "fbSfX8CKBZUV" + }, + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Computing the derivative of the state vector\n", + "\n", + "This function computes the 2-body Keplerian effect on the spacecraft and adds the total acceleration vector from the other forces to obtain the derivative of the state vector at a specific time. This derivative is a vector containing the velocity and acceleration of the spacecraft in the x, y and z directions. It is used as an indicator of how the position and velocity of the object is chnaging at that point in time." + ], + "metadata": { + "id": "KOiVl6oODUso" + } + }, + { + "cell_type": "code", + "source": [ + "def total_dynamics(t0, state, gravitational_parameter):\n", + " \"\"\"\n", + " Compute the total time derivative of the state vector (Keplerian dynamics\n", + " plus perturbations).\n", + " \"\"\"\n", + " du_kep = func_twobody(t0, state, gravitational_parameter)\n", + " ax, ay, az = perturbing_acceleration(\n", + " t0, state, gravitational_parameter,\n", + " Earth.J2.value, Earth.J3.value,\n", + " EARTH_RADIUS_KM, DRAG_COEFFICIENT, GLOBAL_AREA_TO_MASS,\n", + " SCALE_HEIGHT_KM, SEA_LEVEL_DENSITY, Wdivc_s, rad_coeff, sun_ephem\n", + " )\n", + " perturbation = np.array([0, 0, 0, ax, ay, az])\n", + " return du_kep + perturbation" + ], + "metadata": { + "id": "r7ISbywRDVLt" + }, + "execution_count": 13, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Optimizing the rocket's mass\n", + "\n", + "In this simulation, it is assumed that the two-stage rocket provides all the delta-V needed to go from Earth to a GTO orbit, where the payload leaves and circularizes into a GEO orbit. This function looks at the most efficient way to split this delta-V between the two stages of the rocket to minimize its mass.\n", + "\n", + "Based on typical applications and previous literature, we assume the delta-V provided by stage 1 is between 25% to 40% of the total. We test each of the 16 possible scenarios (e.g. going 1% up each time from 25% to 40%) to see which configuration is the most efficient. To do this, we calculate the mass of each stage and add them all up to get the total initial mass. The mass of each stage is calculated using the following equation:\n", + "The modified Tsiolkovsky rocket equation accounting for structural mass fraction ($\\epsilon$) is:\n", + "\n", + "$$M_{stage} = \\frac{M_{stages} \\left( e^{\\frac{\\Delta V}{V_e}} - 1 \\right)}{1 - \\epsilon e^{\\frac{\\Delta V}{V_e}}}$$\n", + "\n", + "This is a modified version of Tsiolkovsky rocket equation that accounts for structural mass fraction $\\epsilon$. $V_e$ is the exhaust velocity of such stage. Δ $V$ is the delta-V for that stage. ${M_{stages}}$ represents sum of the masses of each stage that comes after the current stage.\n", + "\n", + "The derivation of this equation can be found on this website: https://space.geometrian.com/calcs/opt-multi-stage.php" + ], + "metadata": { + "id": "YV1wTXoPFAr_" + } + }, + { + "cell_type": "code", + "source": [ + "def optimize_rocket_mass(exhaust_vel1, exhaust_vel2, satellite_mass, mag_deltaV, deltaV_takeoff):\n", + " \"\"\"\n", + " Optimize the distribution of delta-V between stage 1 and stage 2 to minimize\n", + " the total rocket mass. The function computes stage masses over a range of splits.\n", + "\n", + " Parameters:\n", + " exhaust_vel1 (float): Exhaust velocity for the first stage.\n", + " exhaust_vel2 (float): Exhaust velocity for the second stage.\n", + " satellite_mass (float): Dry mass of the satellite.\n", + " mag_deltaV (float): Magnitude of the computed delta-V from orbit propagation (km/s).\n", + " deltaV_takeoff (float): Delta-V required for take-off (km/s).\n", + "\n", + " Returns:\n", + " tuple: Contains stage1_mass_loss, stage2_mass_loss, wet_stage2_mass,\n", + " deltaV_stage1, deltaV_stage2 corresponding to the optimal split.\n", + " \"\"\"\n", + " total_required_dv = (mag_deltaV * 1000.0) + deltaV_takeoff\n", + " start_fraction = 0.25\n", + "\n", + " # Generate candidate splits for stage 1 delta-V allocation (16 candidates)\n", + " deltaV_stage1_candidates = [start_fraction * total_required_dv + i * 0.01 * total_required_dv for i in range(16)]\n", + " deltaV_stage2_candidates = [total_required_dv - dv1 for dv1 in deltaV_stage1_candidates]\n", + "\n", + " stage1_mass_losses = [None] * 16\n", + " stage2_mass_losses = [None] * 16\n", + " total_rocket_masses = [None] * 16\n", + "\n", + " # Compute mass requirements for each candidate split using the rocket equation with\n", + " # additional mass fractions (0.06 for stage 1, 0.04 for stage 2)\n", + " for i in range(16):\n", + " stage2_mass_losses[i] = (satellite_mass *\n", + " (np.e**(deltaV_stage2_candidates[i] / exhaust_vel2) - 1.0)\n", + " / (1.0 - (np.e**(deltaV_stage2_candidates[i] / exhaust_vel2) * 0.04))\n", + " )\n", + " stage1_mass_losses[i] = ((satellite_mass + stage2_mass_losses[i]) *\n", + " (np.e**(deltaV_stage1_candidates[i] / exhaust_vel1) - 1.0)\n", + " / (1.0 - (np.e**(deltaV_stage1_candidates[i] / exhaust_vel1) * 0.06))\n", + " )\n", + " total_rocket_masses[i] = stage1_mass_losses[i] + stage2_mass_losses[i] + satellite_mass\n", + "\n", + " # Find candidate index with the minimum total rocket mass\n", + " optimal_index = np.argmin(total_rocket_masses)\n", + "\n", + " return (\n", + " stage1_mass_losses[optimal_index] * 0.06,\n", + " stage2_mass_losses[optimal_index] * 0.04,\n", + " stage2_mass_losses[optimal_index],\n", + " deltaV_stage1_candidates[optimal_index],\n", + " deltaV_stage2_candidates[optimal_index]\n", + " )\n" + ], + "metadata": { + "id": "9Y1lW1ZPFBEU" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Propagating the orbit anc calculating delta-V and fuel mass\n", + "\n", + "This function performs all the necessary maneuvers to insert the satellite into GEO at the desired inclination. It begins by computing the velocity of the spacecraft at LEO based on its altitude using the Vis-Viva equation:\n", + "\n", + "$$v = \\sqrt{\\mu \\left( \\frac{2}{r} - \\frac{1}{a} \\right)}$$\n", + "\n", + "where $\\mu$ is Newton's gravitational constant times mass of the Earth, $r$ is the distance from the earth, and $a$ is the semi-major axis of the orbit (1 for circular orbits).\n", + "\n", + "This same equation is used to compute the expected velocity of the spacecraft in a GTO orbit at the same distance $r$ from the Earth. The delta-V for insertion into GTO us simply the difference between these two velocities. Trigonometry is used to apply the burn in a direction where the inclination is unchanged. The orbit is then propagated by half of the period of the current GTO orbit\n", + "\n", + "Next, the code performs a combined plane change maneuver where both the inclination and the altitude of the orbit are changed to insert the payload into GEO with a desired inclination. We use the law of cosines to find the magnitude of this delta-V and the law of sines to find how this delta-V should be split between the x, y and z components. The maneuver is performed and the fuel mass for this insertion is calculated using Tsiolkovsky rocket equation.\n", + "\n" + ], + "metadata": { + "id": "mJC9RKZgNbfj" + } + }, + { + "cell_type": "code", + "source": [ + "def propagate_and_compute_transfer_dv(leo_orbit, exhaust_vel1, exhaust_vel2, exhaust_vel_prop,\n", + " satellite_mass, deltaV_takeoff, inc_change_percent):\n", + " \"\"\"\n", + " Propagate the orbit from LEO to a transfer orbit and compute the transfer delta-V\n", + " components along with required propellant loss.\n", + "\n", + " Parameters:\n", + " leo_orbit (Orbit): Initial LEO orbit.\n", + " exhaust_vel1 (float): Exhaust velocity for the first stage.\n", + " exhaust_vel2 (float): Exhaust velocity for the second stage.\n", + " exhaust_vel_prop (float): Propulsive exhaust velocity.\n", + " satellite_mass (float): Satellite mass.\n", + " deltaV_takeoff (float): Delta-V required for take-off.\n", + " inc_change_percent (float): Percentage factor for inclination change.\n", + "\n", + " Returns:\n", + " tuple: (magnitude_deltaV, magnitude_plane_change_deltaV, total_propellant_loss)\n", + " \"\"\"\n", + " # Compute LEO orbital parameters\n", + " leo_semi_major_km = leo_orbit.a.to(u.km).value\n", + " leo_velocity_kms = np.sqrt((Earth.k.value / 1000.0) / leo_semi_major_km) / 1000.0\n", + "\n", + " # Define GTO parameters from LEO altitude\n", + " gto_semi_major_km = (42164.0 + leo_semi_major_km) / 2.0\n", + " gto_perigee_velocity = np.sqrt((Earth.k.value/1000.0) * ((2.0/leo_semi_major_km) - (1.0/gto_semi_major_km))) / 1000.0\n", + " transfer_deltaV = gto_perigee_velocity - leo_velocity_kms\n", + "\n", + " # Delta-V components (projected along orbital plane components)\n", + " dv_components = [\n", + " 0,\n", + " transfer_deltaV * np.cos(np.deg2rad(leo_orbit.inc.value)),\n", + " transfer_deltaV * np.sin(np.deg2rad(leo_orbit.inc.value))\n", + " ]\n", + " dv_vector = np.array(dv_components) * u.km / u.s\n", + "\n", + " # Apply first maneuver to raise orbit from LEO to GTO\n", + " impulse_maneuver = Maneuver.impulse(dv_vector)\n", + " gto_orbit = leo_orbit.apply_maneuver(impulse_maneuver)\n", + "\n", + " # Compute magnitude of applied delta-V (in km/s)\n", + " mag_deltaV = np.linalg.norm(dv_vector.to(u.km/u.s).value)\n", + "\n", + " # Optimize rocket mass based on stages using an external function below\n", + " stage_results = optimize_rocket_mass(exhaust_vel1, exhaust_vel2, satellite_mass,\n", + " mag_deltaV, deltaV_takeoff)\n", + " stage1_mass_loss, stage2_mass_loss, wet_stage2_mass, deltaV_stage1, deltaV_stage2 = stage_results\n", + "\n", + " # Compute updated area-to-mass ratio for drag calculations\n", + " local_area_to_mass = ((((np.pi) * (1.85**2)) * (u.m**2)) /\n", + " ((satellite_mass + stage2_mass_loss) * u.kg)\n", + " ).to(u.km**2 / u.kg).value\n", + "\n", + " # Propagate the orbit until apogee (half period propagation)\n", + " time_to_apogee = (gto_orbit.period.value / 2.0) * u.s\n", + " propagated_orbit = gto_orbit.propagate(time_to_apogee, method=CowellPropagator(f=total_dynamics))\n", + "\n", + " # Calculate velocity for GEO based on norm of propagated position vector\n", + " norm_radius = np.linalg.norm(propagated_orbit.r.value)\n", + " geo_velocity = np.sqrt(Earth.k.value / 1000.0 * ((2.0/norm_radius) - (1.0/42164.0))) / 1000.0\n", + "\n", + " # Cancel x-component of velocity due to perturbations with a second burn\n", + " dv_cancel = np.array([-propagated_orbit.v.value[0], 0, 0]) * (u.m / u.s)\n", + " impulse_cancel = Maneuver.impulse(dv_cancel)\n", + " propagated_orbit_corrected = propagated_orbit.apply_maneuver(impulse_cancel)\n", + "\n", + " # Compute delta-V for second burn (aiming to circularize GEO orbit)\n", + " mag_deltaV_plane = np.sqrt(np.linalg.norm(propagated_orbit_corrected.v.value)**2 +\n", + " geo_velocity**2 -\n", + " 2 * geo_velocity *\n", + " np.linalg.norm(propagated_orbit_corrected.v.value) *\n", + " np.cos(propagated_orbit_corrected.inc.value *\n", + " (inc_change_percent/100)))\n", + "\n", + " # Determine flight path angle based on circularization maneuver requirements\n", + " flight_path_angle_deg = (180 - np.degrees(np.arcsin((geo_velocity *\n", + " np.sin(propagated_orbit_corrected.inc.value * (inc_change_percent/100)) /\n", + " mag_deltaV_plane))))\n", + "\n", + " # Calculate the components of the delta-V vector using different approaches based on inclination\n", + " if leo_orbit.inc.value >= 59 and inc_change_percent == 100:\n", + " vector1_magnitude = np.abs(mag_deltaV_plane * np.cos(np.radians(flight_path_angle_deg - 90)))\n", + " else:\n", + " vector1_magnitude = np.abs(mag_deltaV_plane * np.cos(np.radians(flight_path_angle_deg)))\n", + "\n", + " angle_vector1 = np.arctan2(propagated_orbit_corrected.v.value[2],\n", + " propagated_orbit_corrected.v.value[1])\n", + " vector1 = [0, vector1_magnitude * np.cos(angle_vector1),\n", + " vector1_magnitude * np.sin(angle_vector1)]\n", + "\n", + " if leo_orbit.inc.value >= 59 and inc_change_percent == 100:\n", + " vector2_magnitude = np.abs(mag_deltaV_plane * np.sin(np.radians(flight_path_angle_deg - 90)))\n", + " else:\n", + " vector2_magnitude = np.abs(mag_deltaV_plane * np.sin(np.radians(flight_path_angle_deg)))\n", + "\n", + " # Calculate perpendicular vector to vector1 in the orbital plane\n", + " vector1_perp = [0, propagated_orbit_corrected.v.value[2], -propagated_orbit_corrected.v.value[1]]\n", + " angle_vector2 = np.arctan2(vector1_perp[2], vector1_perp[1])\n", + " vector2 = [0, vector2_magnitude * np.cos(angle_vector2),\n", + " vector2_magnitude * np.sin(angle_vector2)]\n", + "\n", + " # Combine vectors to produce the required GEO plane-change maneuver\n", + " if leo_orbit.inc.value >= 59 and inc_change_percent == 100:\n", + " combined_dv_vector = [0, -(vector1[2] + vector2[2]),\n", + " vector1[1] + vector2[1]]\n", + " else:\n", + " combined_dv_vector = [0, -(vector1[1] + vector2[1]),\n", + " -(vector1[2] + vector2[2])]\n", + "\n", + " impulse_plane_change = Maneuver.impulse(np.array(combined_dv_vector) * (u.km/u.s))\n", + " geo_orbit = propagated_orbit_corrected.apply_maneuver(impulse_plane_change)\n", + "\n", + " # Total combined delta-V for plane change maneuver (including cancellation burn)\n", + " combined_plane_dv = mag_deltaV_plane + np.abs(propagated_orbit.v.value[0])\n", + "\n", + " # Propellant loss calculations using the rocket equation (staged)\n", + " loss_stage3 = satellite_mass - (satellite_mass / np.e**((mag_deltaV_plane * 1000.0) / exhaust_vel_prop))\n", + " loss_stage2 = (satellite_mass + stage2_mass_loss) * (np.e**((mag_deltaV * 1000.0) / (348.0 * 9.8)) - 1.0)\n", + " loss_stage1 = (satellite_mass + stage2_mass_loss + loss_stage2) * (np.e**((deltaV_stage2 - (mag_deltaV * 1000.0)) / (348.0 * 9.8)) - 1.0)\n", + " loss_initial = (satellite_mass + wet_stage2_mass + stage1_mass_loss) * (np.e**(deltaV_stage1 / (300.0 * 9.8)) - 1.0)\n", + " total_propellant_loss = loss_initial + loss_stage1 + loss_stage2 + loss_stage3\n", + "\n", + " return mag_deltaV, combined_plane_dv, total_propellant_loss" + ], + "metadata": { + "id": "T8OKwYHTNb11" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Simulating the orbit\n", + "\n", + "This function utilizes all the functions described above to obtain the total fuel mass and delta-V for all maneuevers. It also computes an approximate of the delta-V required to insert the rocket into LEO orbit, accounting for drag, gravity, earth's boost, etc." + ], + "metadata": { + "id": "lYtITy71UGlW" + } + }, + { + "cell_type": "code", + "source": [ + "# ===============================================================\n", + "# Simulation Functions\n", + "# ===============================================================\n", + "def simulate_orbit(sim_params):\n", + " \"\"\"\n", + " Perform a single orbit simulation.\n", + "\n", + " Parameters:\n", + " sim_params (tuple): Contains the following parameters:\n", + " - inclination_deg: LEO orbital inclination in degrees.\n", + " - leo_altitude_km: LEO altitude above Earth surface (km).\n", + " - exhaust_vel_stage1: Exhaust velocity for stage 1.\n", + " - exhaust_vel_stage2: Exhaust velocity for stage 2.\n", + " - exhaust_vel_propulsive: Propulsive exhaust velocity.\n", + " - satellite_mass: Dry mass of satellite.\n", + " - inclination_change_percent: Percent value for inclination change.\n", + "\n", + " Returns:\n", + " tuple: (inclination_deg, inclination_change_percent, leo_altitude_km,\n", + " exhaust_vel_stage1, exhaust_vel_stage2, exhaust_vel_propulsive,\n", + " satellite_mass, f_total, total_deltaV)\n", + " \"\"\"\n", + " # Unpack simulation parameters\n", + " (inclination_deg, leo_altitude_km,\n", + " exhaust_vel_stage1, exhaust_vel_stage2, exhaust_vel_propulsive,\n", + " satellite_mass, inc_change_percent) = sim_params\n", + "\n", + " # Create an initial LEO orbit object using given altitude and inclination\n", + " leo_orbit = create_leo_orbit(leo_altitude_km, inclination_deg)\n", + "\n", + " # Compute delta-V components from orbital mechanics and perturbations\n", + " transfer_dv = np.sqrt(Earth.k.value / (6378000 + (leo_altitude_km * 1000)))\n", + " potential_dv = (np.sqrt(Earth.k.value / 6378000) *\n", + " np.sqrt(2 - (6378000 / (6378000 + (leo_altitude_km * 1000)))) -\n", + " np.sqrt(Earth.k.value / (6378000 + (leo_altitude_km * 1000))))\n", + " grav_loss_dv = np.interp(leo_altitude_km, LEO_ALTITUDES_KM, DELTA_V_GRAV_KMS)\n", + " atm_loss_dv = np.interp(leo_altitude_km, LEO_ALTITUDES_KM, DELTA_V_ATM_KMS)\n", + " earth_boost_dv = (7.2921159e-5) * Earth.R.to(u.m).value * np.cos(leo_orbit.inc.to(u.rad).value)\n", + "\n", + " # Total take-off delta-V is the sum of various components minus the boost provided by Earth's rotation\n", + " deltaV_takeoff = transfer_dv + grav_loss_dv + potential_dv + atm_loss_dv - earth_boost_dv\n", + "\n", + " # Compute additional delta-V contributions by propagating the orbit and other calculations.\n", + " mag_deltaV, mag_deltaV_plane, total_propulsive_loss = propagate_and_compute_transfer_dv(\n", + " leo_orbit, exhaust_vel_stage1, exhaust_vel_stage2, exhaust_vel_propulsive,\n", + " satellite_mass, deltaV_takeoff, inc_change_percent\n", + " )\n", + "\n", + " total_deltaV = deltaV_takeoff + mag_deltaV * 1000 + mag_deltaV_plane * 1000\n", + "\n", + " # Return complete simulation results\n", + " return (inclination_deg, inc_change_percent, leo_altitude_km,\n", + " exhaust_vel_stage1, exhaust_vel_stage2, exhaust_vel_propulsive,\n", + " satellite_mass, total_propulsive_loss, total_deltaV)" + ], + "metadata": { + "id": "Ldu_y1EJUGCD" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From aa019765cd6e85ae8bfccaee320fcfcc59a88a56 Mon Sep 17 00:00:00 2001 From: danielandresrestrebadaleal-dev Date: Sun, 5 Apr 2026 15:31:55 -0500 Subject: [PATCH 4/8] Creado con Colab --- TESS_Simulation.ipynb | 802 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 802 insertions(+) create mode 100644 TESS_Simulation.ipynb diff --git a/TESS_Simulation.ipynb b/TESS_Simulation.ipynb new file mode 100644 index 0000000..e1f0912 --- /dev/null +++ b/TESS_Simulation.ipynb @@ -0,0 +1,802 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZJ2210Cdwwal" + }, + "source": [ + "# Analyzing orbital perturbations of TESS orbit\n", + "\n", + " The goal of this tutorial is to simulate the orbit of the Transiting Exoplanet Survey Satellite (TESS) under the effect of different perturbing forces (solar radiation, gravitational forces, etc.). The simulation will be performed for approximately 8.5 years. Therefore, we aim to understand how we can minimize computational processing time by compromising some degree of accuracy in our simulation. This is achieved by ignoring the effect of each perturbing force and computing the evolution of the fractional error of the position and velocity of TESS over time. The JPL Horizons database is utilized to obtain our reference values for the position and velocity of TESS for the timespan of the simulation. By understanding which perturbing forces can be dismissed while maintaining a low fractional error, we can generalize the results of this simulation to others which have a similar orbit and thus save computational time.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true, + "id": "sLFju77hwW6w" + }, + "outputs": [], + "source": [ + "#Install necessary packages for Google Colab. Note: hapsira is the modern version of poliastro to handle Python 3.12\n", + "!pip install hapsira \"astropy<7.0\" jplephem" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fqRzoMKXwu_r" + }, + "source": [ + "# Code Imports\n", + "This code utilizes several Python libraries for different functionalities:\n", + "1. poliastro: defines celestial bodies and physical constants, calculates the evolution of the orbit using Cowell Propagator, and introduces the effects of solar radiation and other forces\n", + "\n", + "2. astropy: imports the JPL horizons database and handles coordinate system conversions to accurately compare the simulation results\n", + "\n", + "3. numpy: performs math computations\n", + "\n", + "4. matplotlib: plots evolution of fractional error for position and velocity over time in an organized graph with axes labels and legend\n", + "\n", + "5. gc: clean up data\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "NI5Hi5Tj7kF9" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import astropy.units as u\n", + "from astropy.time import Time\n", + "from astropy.coordinates import solar_system_ephemeris\n", + "from hapsira.bodies import Earth, Moon, Sun, Jupiter, Venus\n", + "from hapsira.twobody import Orbit\n", + "from hapsira.twobody.propagation import CowellPropagator\n", + "from hapsira.core.perturbations import third_body, radiation_pressure\n", + "from hapsira.core.propagation import func_twobody\n", + "from hapsira.ephem import build_ephem_interpolant, Ephem\n", + "from hapsira.constants import rho0_earth, H0_earth\n", + "import time\n", + "import gc\n", + "from astropy.coordinates import (\n", + " CartesianRepresentation, CartesianDifferential, SkyCoord, ICRS, GCRS\n", + ")\n", + "\n", + "# ---------------------- Simulation Configuration ----------------------\n", + "# Total simulation duration in days.\n", + "SIMULATION_DURATION_DAYS = 3050" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "34eJzUCH-WOg" + }, + "source": [ + "# Environment Initialization\n", + "\n", + "Ths function defines the starting time of the simulation as June 1st, 2018. It then creates an evenly-spaced position vector for each celestial body with its current position every 1 hour from the beginning to the end of the simulation. This is more effective than looking for the exact position of each celestial body for each small step in the simulation since it would significantly increase the computational time." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "4EjAFUmaAaGw" + }, + "outputs": [], + "source": [ + "def initialize_environment():\n", + " \"\"\"\n", + " Set up the solar system ephemeris and build ephemeris interpolants.\n", + " \"\"\"\n", + " # Choose ephemeris data source (JPL in this case)\n", + " solar_system_ephemeris.set(\"jpl\")\n", + "\n", + " # 1. Define simulation epoch as a pure Time object\n", + " simulation_start_epoch = Time(\"2018-06-01T00:00:00\", scale=\"utc\", format=\"isot\")\n", + "\n", + " # 2. Calculate the exact end Time object by adding the days directly to the Time object (NO .jd!)\n", + " simulation_end_epoch = simulation_start_epoch + SIMULATION_DURATION_DAYS * u.day\n", + "\n", + " # Generate an array of epochs at 1-hour intervals for the interpolation\n", + " time_span_delta = simulation_end_epoch - simulation_start_epoch\n", + " num_steps = int(time_span_delta.to(u.hr).value) # Calculate number of steps to ensure including the end epoch\n", + " epochs_for_interpolant = simulation_start_epoch + np.arange(num_steps + 1) * u.hr\n", + "\n", + " # 3. Build ephemeris interpolants, specifying Earth as the attractor\n", + " moon_ephem_interp = build_ephem_interpolant(\n", + " Moon, epochs_for_interpolant, attractor=Earth\n", + " )\n", + " sun_ephem_interp = build_ephem_interpolant(\n", + " Sun, epochs_for_interpolant, attractor=Earth\n", + " )\n", + " jupiter_ephem_interp = build_ephem_interpolant(\n", + " Jupiter, epochs_for_interpolant, attractor=Earth\n", + " )\n", + " venus_ephem_interp = build_ephem_interpolant(\n", + " Venus, epochs_for_interpolant, attractor=Earth\n", + " )\n", + "\n", + " # Clean up memory\n", + " gc.collect()\n", + "\n", + " return simulation_start_epoch, moon_ephem_interp, sun_ephem_interp, jupiter_ephem_interp, venus_ephem_interp" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xPL8KK8kAhek" + }, + "source": [ + "# Setting up physical constants\n", + "\n", + "This function mainly computes the required physical constants to perform the orbital simulations and converts them to the correct units" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "bzZ33Af7BMOW" + }, + "outputs": [], + "source": [ + "# ---------------------- Physical Constants ----------------------\n", + "def define_physical_constants():\n", + " \"\"\"\n", + " Retrieve and compute key physical constants required for the simulation.\n", + "\n", + " Returns:\n", + " dict: A dictionary containing various physical parameters.\n", + " \"\"\"\n", + " earth_radius_km = Earth.R.to(u.km).value\n", + " gravitational_param = Earth.k.to(u.km**3 / u.s**2).value\n", + "\n", + " # Atmospheric drag coefficient (negligible for TESS orbit, hence set as a constant)\n", + " drag_coefficient = 2.2\n", + "\n", + " # Area-to-mass ratio, converting from square meters/kg to square km/kg\n", + " area_to_mass = ((3) * (u.m**2) / (350 * u.kg)).to_value(u.km**2 / u.kg)\n", + "\n", + " # Atmospheric density at Earth's surface and scale height\n", + " surface_density = rho0_earth.to(u.kg / u.km**3).value\n", + " scale_height = H0_earth.to(u.km).value\n", + "\n", + " # Radiation pressure coefficient and solar flux-to-speed constant ratio\n", + " radiation_coefficient = 1.3\n", + " solar_flux_over_c = (3.828e20) / 299792.458\n", + "\n", + " return {\n", + " \"earth_radius\": earth_radius_km,\n", + " \"grav_param\": gravitational_param,\n", + " \"drag_coefficient\": drag_coefficient,\n", + " \"area_to_mass\": area_to_mass,\n", + " \"surface_density\": surface_density,\n", + " \"scale_height\": scale_height,\n", + " \"radiation_coefficient\": radiation_coefficient,\n", + " \"solar_flux_over_c\": solar_flux_over_c,\n", + " }" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bMhDPYC3BUr9" + }, + "source": [ + "# Computing Acceleration Vector\n", + "\n", + "This function creates a 3D vector representing the acceleration in the x, y, and z directions for our spacecraft. It then checks whether it is desired to calculate the effect of a perturbing force by checking the force_flags dictionary. If it is listed as \"True,\" it calls the corresponding function from poliastro (e.g. \"third_body\" for celestial bodies) to add the acceleration produced by such force. In this way, we can bypass the effect of a force to analyze how accurate the simulation can still be. The function returns an acceleration vector is the addition of all the accelerations produced by the desired perturbing forces" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "_iUBJbRcD4l0" + }, + "outputs": [], + "source": [ + "# ---------------------- Perturbation Acceleration Functions ----------------------\n", + "def compute_perturbation_acceleration(t0, state, grav_param, constants, sun_interp, moon_interp,\n", + " jupiter_interp, venus_interp, force_flags):\n", + " \"\"\"\n", + " Computes the total perturbation acceleration due to third-body effects and radiation pressure.\n", + "\n", + " Args:\n", + " t0 (float): Initial time.\n", + " state (ndarray): Current state vector of the spacecraft.\n", + " grav_param (float): Gravitational parameter of the primary body.\n", + " constants (dict): Physical constants (e.g., Earth radius, radiation coefficients).\n", + " sun_interp: Ephemeris interpolant for the Sun.\n", + " moon_interp: Ephemeris interpolant for the Moon.\n", + " jupiter_interp: Ephemeris interpolant for Jupiter.\n", + " venus_interp: Ephemeris interpolant for Venus.\n", + " force_flags (dict): Dictionary indicating which forces to include in the simulation.\n", + "\n", + " Returns:\n", + " ndarray: Combined acceleration vector due to all selected perturbation forces.\n", + " \"\"\"\n", + " total_acceleration = np.zeros(3)\n", + "\n", + " # Moon's third-body effect\n", + " if force_flags.get(\"Moon\", True):\n", + " total_acceleration += third_body(t0, state, grav_param,\n", + " k_third=Moon.k.to(u.km**3/u.s**2).value,\n", + " perturbation_body=moon_interp)\n", + " # Sun's third-body effect (using sun_interp as the star body)\n", + " if force_flags.get(\"Sun\", True):\n", + " total_acceleration += third_body(t0, state, grav_param,\n", + " k_third=Sun.k.to(u.km**3/u.s**2).value,\n", + " perturbation_body=sun_interp)\n", + " # Jupiter's third-body effect\n", + " if force_flags.get(\"Jupiter\", True):\n", + " total_acceleration += third_body(t0, state, grav_param,\n", + " k_third=Jupiter.k.to(u.km**3/u.s**2).value,\n", + " perturbation_body=jupiter_interp)\n", + " # Venus's third-body effect\n", + " if force_flags.get(\"Venus\", True):\n", + " total_acceleration += third_body(t0, state, grav_param,\n", + " k_third=Venus.k.to(u.km**3/u.s**2).value,\n", + " perturbation_body=venus_interp)\n", + " # Solar radiation pressure effect\n", + " if force_flags.get(\"Radiation\", True):\n", + " total_acceleration += radiation_pressure(\n", + " t0, state, grav_param,\n", + " constants[\"earth_radius\"],\n", + " constants[\"radiation_coefficient\"],\n", + " constants[\"area_to_mass\"],\n", + " constants[\"solar_flux_over_c\"],\n", + " sun_interp\n", + " )\n", + " return total_acceleration" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gQVWwLQnD--r" + }, + "source": [ + "# Computing the derivative of the state vector\n", + "\n", + "In order to use the Cowell Propagator from poliastro, this function computes how fast the position and velocity of the spacecraft is changing at a specific point in time. It calculates the velocity and acceleration vector based on a 2-body Keplerian motion model between the Earth and the spacecraft. Then, it adds all the third-body effects to this vector to obtain a final vector describing how both the position and velocity are changing through time at that instant." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "WA3qxCw4KLXE" + }, + "outputs": [], + "source": [ + "def perturbation_derivatives(t0, state, grav_param, constants, sun_interp, moon_interp,\n", + " jupiter_interp, venus_interp, force_flags):\n", + " \"\"\"\n", + " Computes the time derivatives of the state vector including both Keplerian and perturbation accelerations.\n", + "\n", + " Args:\n", + " t0 (float): Initial time.\n", + " state (ndarray): Current state vector.\n", + " grav_param (float): Gravitational parameter for the primary body.\n", + " constants (dict): Dictionary of physical constants.\n", + " sun_interp, moon_interp, jupiter_interp, venus_interp: Ephemeris interpolants.\n", + " force_flags (dict): Flags indicating which perturbing forces are active.\n", + "\n", + " Returns:\n", + " ndarray: Time derivative of the state vector.\n", + " \"\"\"\n", + " # Two-body (Keplerian) derivative\n", + " keplerian_deriv = func_twobody(t0, state, grav_param)\n", + "\n", + " # Compute total perturbation acceleration.\n", + " accel_perturb = compute_perturbation_acceleration(\n", + " t0, state, grav_param, constants, sun_interp, moon_interp, jupiter_interp, venus_interp, force_flags\n", + " )\n", + "\n", + " # Append the perturbation acceleration (affecting velocity components) to the Keplerian derivative.\n", + " return keplerian_deriv + np.array([0, 0, 0, accel_perturb[0], accel_perturb[1], accel_perturb[2]])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eiUzvvn5KQDl" + }, + "source": [ + "# Initializing the orbit\n", + "\n", + "This function defines the Orbit object needed to start the simulation. To do so, it extracts the the state vector of TESS at the starting time of our simulation from the JPL Horizons database. It performs some necessary unit conversions and translates the vector from ICRS (Sun-centered) to GCRS (Earth-centered) coordinate system, as poliastro uses GCRS as default for orbit propagations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "_AaJQNupKg2Y" + }, + "outputs": [], + "source": [ + "# ---------------------- Orbit Initialization ----------------------\n", + "def initialize_orbit(simulation_epoch):\n", + " \"\"\"\n", + " Create the initial orbit state from spacecraft ephemeris data (using TESS as reference).\n", + " The state vector is transformed from the ICRS frame to the GCRS frame.\n", + "\n", + " Args:\n", + " simulation_epoch (Time): The epoch of the simulation start.\n", + "\n", + " Returns:\n", + " Orbit: The initial Orbit object.\n", + " \"\"\"\n", + " # Retrieve TESS ephemeris data from Horizons system.\n", + " tess_ephem = Ephem.from_horizons(\"TESS\", epochs=simulation_epoch)\n", + "\n", + " # Get position and velocity vectors in km and km/s respectively.\n", + " position_icrf = np.array(tess_ephem.rv()[0].to(u.km).value).reshape(-1)\n", + " velocity_icrf = np.array(tess_ephem.rv()[1].to(u.km / u.s).value).reshape(-1)\n", + "\n", + " # Create initial orbit in ICRF frame from position and velocity.\n", + " orbit_icrf = Orbit.from_vectors(Earth, position_icrf * u.km, velocity_icrf * (u.km / u.s), epoch=simulation_epoch)\n", + "\n", + " # Extract ICRF vectors\n", + " r_icrf, v_icrf = orbit_icrf.rv()\n", + "\n", + " # Transform state vector from ICRS/ICRF to the GCRS frame.\n", + " cart_representation = CartesianRepresentation(*r_icrf)\n", + " cart_differentials = CartesianDifferential(*v_icrf)\n", + " icrs_coord = SkyCoord(cart_representation.with_differentials(cart_differentials),\n", + " frame=ICRS, obstime=simulation_epoch)\n", + " gcrs_coord = icrs_coord.transform_to(GCRS(obstime=simulation_epoch))\n", + "\n", + " # Retrieve transformed position and velocity components.\n", + " r_gcrs = gcrs_coord.data.represent_as(CartesianRepresentation).xyz\n", + " v_gcrs = gcrs_coord.data.differentials[\"s\"].d_xyz\n", + "\n", + " # Clean up temporary variables.\n", + " del cart_representation, cart_differentials, icrs_coord, gcrs_coord\n", + " gc.collect()\n", + "\n", + " return Orbit.from_vectors(Earth, r_gcrs, v_gcrs, epoch=simulation_epoch)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PRC-BO0IMUfx" + }, + "source": [ + "# Orbit propagation\n", + "\n", + "This function simply propagates the starting orbit using poliastro's Cowell Propagator over the specified time interval. It returns the final orbit object after the simulation, from which we can extract the state vector. In principle, this function is called for each time step during the simulation to obtain a continuous evolution of the position and velocity of the spacecraft" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "vmGWMSUdMXER" + }, + "outputs": [], + "source": [ + "# ---------------------- Orbit Propagation & Data Processing ----------------------\n", + "def propagate_orbit(orbit_obj, time_interval, perturbation_function):\n", + " \"\"\"\n", + " Propagate the orbit over a specified time interval using the Cowell propagator.\n", + "\n", + " Args:\n", + " orbit_obj (Orbit): The initial Orbit object.\n", + " time_interval (Quantity): Duration over which to propagate.\n", + " perturbation_function (function): Function to compute perturbations.\n", + "\n", + " Returns:\n", + " Orbit: Final orbit after propagation.\n", + " \"\"\"\n", + " propagated_orbit = orbit_obj.propagate(\n", + " time_interval, method=CowellPropagator(rtol=3e-14, f=perturbation_function)\n", + " )\n", + " gc.collect()\n", + " return propagated_orbit" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uSBQa23XNQiR" + }, + "source": [ + "# Creating evenly-spaced time intervals\n", + "\n", + "This function creates epoch objects which are evenly spaced. The number of intervals is user-defined and can affect the how precise our simulation is. A good value should be chosen so that we can have enough precision while still running the program in a reasonable amount of time. Thus, 100 intervals were chosen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "yTf9vpShNREu" + }, + "outputs": [], + "source": [ + "def create_simulation_epochs(start_epoch, end_epoch, num_intervals):\n", + " \"\"\"\n", + " Generate an array of epochs spanning from the start to the end epoch.\n", + " \"\"\"\n", + " # Safely convert the TimeDelta into raw seconds\n", + " total_seconds = (end_epoch - start_epoch).to(u.s).value\n", + "\n", + " # Generate the checkpoints and add them back to the start time\n", + " epochs = start_epoch + np.linspace(0, total_seconds, num_intervals + 1) * u.s\n", + "\n", + " gc.collect()\n", + " return epochs" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NX7MXI5aOFr6" + }, + "source": [ + "# Extracting data for error analysis\n", + "\n", + "This function calls the Cowell Propagator for each time interval to obtain the Orbit object for each time step. Then, it extracts the position and velocity vector from each object. These values are converted from GCRS to the ICRS coordinate system for comparison with the JPL Horizons database" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "JcRYLKiZOEcQ" + }, + "outputs": [], + "source": [ + "def simulate_spacecraft_trajectory(orbit_obj, perturbation_function, epoch_array):\n", + " \"\"\"\n", + " Propagate the spacecraft orbit for each epoch in the provided array and convert the results\n", + " to ICRS frame state vectors.\n", + "\n", + " Args:\n", + " orbit_obj (Orbit): Initial orbit.\n", + " perturbation_function (function): Function to compute perturbation accelerations.\n", + " epoch_array (Quantity): Array of epochs at which to propagate the orbit.\n", + "\n", + " Returns:\n", + " tuple: (r_state, v_state) state arrays in the ICRS frame.\n", + " \"\"\"\n", + " start_time = time.perf_counter()\n", + " propagated_orbits = [\n", + " orbit_obj.propagate(ep, method=CowellPropagator(rtol=3e-14, f=perturbation_function))\n", + " for ep in epoch_array\n", + " ]\n", + " end_time = time.perf_counter()\n", + " print(\"Propagation time: {:.3f} seconds\".format(end_time - start_time))\n", + "\n", + " positions, velocities, epochs_list = [], [], []\n", + " for orbit_instance in propagated_orbits:\n", + " positions.append(orbit_instance.r)\n", + " velocities.append(orbit_instance.v)\n", + " epochs_list.append(orbit_instance.epoch)\n", + "\n", + " # Convert lists to numpy arrays\n", + " pos_array = np.array(positions)\n", + " vel_array = np.array(velocities)\n", + " epochs_array = Time(epochs_list)\n", + "\n", + " # Convert coordinates from GCRS to ICRS for output and analysis.\n", + " conversion_start = time.perf_counter()\n", + " sky_coordinates = SkyCoord(\n", + " CartesianRepresentation(\n", + " pos_array[:, 0] * u.km,\n", + " pos_array[:, 1] * u.km,\n", + " pos_array[:, 2] * u.km,\n", + " differentials=CartesianDifferential(\n", + " vel_array[:, 0] * (u.km / u.s),\n", + " vel_array[:, 1] * (u.km / u.s),\n", + " vel_array[:, 2] * (u.km / u.s)\n", + " )\n", + " ),\n", + " frame=GCRS,\n", + " obstime=epochs_array\n", + " )\n", + " icrs_coordinates = sky_coordinates.transform_to(ICRS)\n", + " r_state = icrs_coordinates.cartesian.xyz.T.value\n", + " v_state = icrs_coordinates.cartesian.differentials[\"s\"].d_xyz.T.value\n", + "\n", + " # Clean up and free memory.\n", + " del positions, velocities, pos_array, vel_array, epochs_list, epochs_array, sky_coordinates, icrs_coordinates\n", + " gc.collect()\n", + "\n", + " conversion_end = time.perf_counter()\n", + " print(\"Coordinate conversion time: {:.3f} seconds\".format(conversion_end - conversion_start))\n", + " return r_state, v_state" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WDbOY6Y8PP0E" + }, + "source": [ + "# Retrieving TESS data from JPL Horizons\n", + "\n", + "At each time step, this function retrieves the position and velocity vectors from JPL Horizons for TESS" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "bmRkh3r_PQae" + }, + "outputs": [], + "source": [ + "def retrieve_actual_spacecraft_data(epoch_array, num_intervals):\n", + " \"\"\"\n", + " Obtain reference spacecraft data from Horizons (using TESS as reference) for error comparison.\n", + "\n", + " Args:\n", + " epoch_array (Quantity): Array of simulation epochs.\n", + " num_intervals (int): Number of intervals (subdivisions used during simulation).\n", + "\n", + " Returns:\n", + " tuple: (r_actual, v_actual) state arrays from reference data.\n", + " \"\"\"\n", + " tess_ephem_list = [Ephem.from_horizons(\"TESS\", epochs=ep) for ep in epoch_array]\n", + " actual_positions = np.array([ephem.rv()[0].to(u.km).value for ephem in tess_ephem_list])\n", + " actual_velocities = np.array([ephem.rv()[1].to(u.km / u.s).value for ephem in tess_ephem_list])\n", + "\n", + " # Ensure that the arrays have the expected dimensions.\n", + " r_actual = actual_positions.reshape(num_intervals + 1, 3)\n", + " v_actual = actual_velocities.reshape(num_intervals + 1, 3)\n", + " del tess_ephem_list\n", + " gc.collect()\n", + " return r_actual, v_actual" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8vTnimfdPo_m" + }, + "source": [ + "# Computing and plotting fractional error over time\n", + "\n", + "These functions calculate and plot the fractional error as a function of time for the duration of the simulation. The fractional error for the position and velocity vectors are computed as the difference between the Euclidean norm between the simulation vector and JPL Horizons vector dividided by the JPL Horizons vector. This is done for each time step using vectorized operations with the help of numpy. The results are plotted in two different figures: one for the position and one for the velocity vector" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "FlquX_O1PpeE" + }, + "outputs": [], + "source": [ + "# ---------------------- Error Analysis ----------------------\n", + "def calculate_fractional_errors(simulated_positions, reference_positions, simulated_velocities, reference_velocities):\n", + " \"\"\"\n", + " Calculate the fractional errors between simulated and reference position and velocity vectors.\n", + "\n", + " Args:\n", + " simulated_positions (ndarray): Simulated positions.\n", + " reference_positions (ndarray): Reference positions.\n", + " simulated_velocities (ndarray): Simulated velocities.\n", + " reference_velocities (ndarray): Reference velocities.\n", + "\n", + " Returns:\n", + " tuple: Fractional errors for positions and velocities.\n", + " \"\"\"\n", + " # Position error calculations\n", + " position_error_norm = np.linalg.norm(simulated_positions - reference_positions, axis=1)\n", + " reference_position_norm = np.linalg.norm(reference_positions, axis=1)\n", + " fractional_error_position = position_error_norm / reference_position_norm\n", + "\n", + " # Velocity error calculations\n", + " velocity_error_norm = np.linalg.norm(simulated_velocities - reference_velocities, axis=1)\n", + " reference_velocity_norm = np.linalg.norm(reference_velocities, axis=1)\n", + " fractional_error_velocity = velocity_error_norm / reference_velocity_norm\n", + "\n", + " return fractional_error_position, fractional_error_velocity\n", + "\n", + "# ---------------------- Plotting Functions ----------------------\n", + "def plot_fractional_errors(time_years, position_errors_dict, velocity_errors_dict):\n", + " \"\"\"\n", + " Plot and save the fractional error comparisons for positions and velocities.\n", + "\n", + " Args:\n", + " time_years (ndarray): Time axis in years.\n", + " position_errors_dict (dict): Dictionary of position error arrays keyed by simulation case label.\n", + " velocity_errors_dict (dict): Dictionary of velocity error arrays keyed by simulation case label.\n", + " \"\"\"\n", + " # Plot position fractional errors.\n", + " fig_pos, ax_pos = plt.subplots(figsize=(10, 6))\n", + " for label, error_array in position_errors_dict.items():\n", + " ax_pos.plot(time_years, error_array, 'o-', label=label)\n", + " ax_pos.set_title('Fractional Error in Position Magnitude')\n", + " ax_pos.set_xlabel('Time Since Start (years)')\n", + " ax_pos.set_ylabel('Fractional Error')\n", + " ax_pos.legend()\n", + " fig_pos.savefig(\"position_magnitude_error.png\", dpi=130)\n", + "\n", + " # Plot velocity fractional errors.\n", + " fig_vel, ax_vel = plt.subplots(figsize=(10, 6))\n", + " for label, error_array in velocity_errors_dict.items():\n", + " ax_vel.plot(time_years, error_array, 'o-', label=label)\n", + " ax_vel.set_title('Fractional Error in Velocity Magnitude')\n", + " ax_vel.set_xlabel('Time Since Start (years)')\n", + " ax_vel.set_ylabel('Fractional Error')\n", + " ax_vel.legend()\n", + " fig_vel.savefig(\"velocity_magnitude_error.png\", dpi=130)\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-_FqFJ3-RMho" + }, + "source": [ + "# Main program function\n", + "\n", + "This is the main function of the program that handles all other functions. Its main purpose is to update the force_flags dictionary each time with a new force turned \"off\" and plot the results for that corresponding case" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "DyzoIjwGRM_F", + "collapsed": true + }, + "outputs": [], + "source": [ + "# ---------------------- Main Simulation Routine ----------------------\n", + "def main_simulation():\n", + " # Initialize simulation environment and physical constants.\n", + " sim_epoch, moon_interp, sun_interp, jupiter_interp, venus_interp = initialize_environment()\n", + " physical_constants = define_physical_constants()\n", + "\n", + " # Initialize the spacecraft orbit using reference (TESS) data.\n", + " initial_orbit = initialize_orbit(sim_epoch)\n", + "\n", + " # Define the number of intervals for simulation sampling.\n", + " NUM_INTERVALS = 100\n", + "\n", + " # Propagate orbit without any modifications to define final simulation end epoch.\n", + " final_orbit = propagate_orbit(\n", + " initial_orbit,\n", + " SIMULATION_DURATION_DAYS * u.day,\n", + " lambda t0, state, k: perturbation_derivatives(\n", + " t0, state, k, physical_constants, sun_interp, moon_interp, jupiter_interp,\n", + " venus_interp, {\"Moon\": True, \"Sun\": True, \"Jupiter\": True, \"Venus\": True, \"Radiation\": True}\n", + " )\n", + " )\n", + "\n", + " # Generate an array of epochs between the start and final orbit epochs.\n", + " simulation_epochs = create_simulation_epochs(initial_orbit.epoch, final_orbit.epoch, NUM_INTERVALS)\n", + "\n", + " # Retrieve reference spacecraft data for error analysis.\n", + " reference_positions, reference_velocities = retrieve_actual_spacecraft_data(simulation_epochs, NUM_INTERVALS)\n", + "\n", + " # Define base force flags and simulation cases (each turning off one perturbation).\n", + " base_force_flags = {\n", + " \"Moon\": True, \"Sun\": True, \"Jupiter\": True, \"Venus\": True, \"Radiation\": True\n", + " }\n", + " simulation_cases = {\n", + " \"Without Moon\": {**base_force_flags, \"Moon\": False},\n", + " \"Without Sun\": {**base_force_flags, \"Sun\": False},\n", + " \"Without Jupiter\": {**base_force_flags, \"Jupiter\": False},\n", + " \"Without Venus\": {**base_force_flags, \"Venus\": False},\n", + " \"Without Radiation\": {**base_force_flags, \"Radiation\": False},\n", + " \"All Forces\": base_force_flags.copy()\n", + " }\n", + "\n", + " # Dictionaries to hold the fractional errors for each simulation case.\n", + " pos_errors_dict = {}\n", + " vel_errors_dict = {}\n", + " # Convert epochs difference to years for x-axis plotting.\n", + " time_axis_years = (simulation_epochs - simulation_epochs[0]).sec / (3600 * 24 * 365.25)\n", + "\n", + " # Execute simulation for each force configuration.\n", + " for case_label, force_config in simulation_cases.items():\n", + " # Define the perturbation function using current force configuration.\n", + " perturbation_function = lambda t0, state, k, flags=force_config: perturbation_derivatives(\n", + " t0, state, k, physical_constants, sun_interp, moon_interp, jupiter_interp, venus_interp, flags\n", + " )\n", + " simulated_positions, simulated_velocities = simulate_spacecraft_trajectory(initial_orbit, perturbation_function, simulation_epochs)\n", + "\n", + " # Compute fractional errors between simulation and reference data.\n", + " frac_err_pos, frac_err_vel = calculate_fractional_errors(simulated_positions, reference_positions,\n", + " simulated_velocities, reference_velocities)\n", + " pos_errors_dict[case_label] = frac_err_pos\n", + " vel_errors_dict[case_label] = frac_err_vel\n", + "\n", + " # Plot and save error comparisons.\n", + " plot_fractional_errors(time_axis_years, pos_errors_dict, vel_errors_dict)\n", + " gc.collect()\n", + "\n", + "# Execute the simulation only if this script is run directly.\n", + "if __name__ == \"__main__\":\n", + " main_simulation()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D3x_mHN-Q6wr" + }, + "source": [ + "The following figures are obtained from this code:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "g1xBm_YEQkQ5" + }, + "source": [ + "![velocity_magnitude_error (1).png](data:image/png;base64,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)![position_magnitude_error (1) (1).png](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tQ0tBVlpRG3S" + }, + "source": [ + "#" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Results and Conclusions\n", + "\n", + "Both graphs show the need to include the third-body effects from the Moon and the Sun to obtain accurate simulations. The fractional error for the magnitude of both the position and the velocity spikes at a very early stage of the simulation when the gravitational forces from these bodies is ignored. The solar radiation force becomes more relevant at around 6 years after the beginning of the simulation, where it starts to clearly diverge from the \"All forces\" case. In contrast, removing the influence of secondary celestial bodies, such as Jupiter and Venus, on the orbit of the simulated spacecraft shows no clear sign of loss of accuracy. Based on these results, it can be concluded that when simulating the orbit of a spacecraft on High-Earth Orbit (HEO), such as TESS, it is crucial to include the gravitational effects of primary celestial bodies like the Moon and the Sun while the influence from planets like Jupiter and Venus can be removed, saving computational time while not compromising a significant loss of accuracy\n", + "\n" + ], + "metadata": { + "id": "rTMJYPxyqxQB" + } + } + ], + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyMUbF1AMZ3NdtaQOd740GBx", + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From 90a70f979d931105c680c380d2e311f6cf96b3ce Mon Sep 17 00:00:00 2001 From: danielandresrestrebadaleal-dev Date: Sun, 5 Apr 2026 15:36:57 -0500 Subject: [PATCH 5/8] Creado con Colab --- GEO_orbital_simulation.ipynb | 88 ++++++++++++++++++++++++++++++------ 1 file changed, 73 insertions(+), 15 deletions(-) diff --git a/GEO_orbital_simulation.ipynb b/GEO_orbital_simulation.ipynb index fd1cce9..86a7cb5 100644 --- a/GEO_orbital_simulation.ipynb +++ b/GEO_orbital_simulation.ipynb @@ -4,7 +4,7 @@ "metadata": { "colab": { "provenance": [], - "authorship_tag": "ABX9TyPdwXNaWs4HiY7aS0cvdNWP", + "authorship_tag": "ABX9TyNehg1/9TgLhaE6psc6cCCX", "include_colab_link": true }, "kernelspec": { @@ -39,11 +39,69 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": { - "id": "BjpU7NeZhLM-" + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "BjpU7NeZhLM-", + "outputId": "5bdfe54d-e654-45a9-d2f2-987df4745667" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: hapsira in /usr/local/lib/python3.12/dist-packages (0.18.0)\n", + "Requirement already satisfied: astropy<7.0 in /usr/local/lib/python3.12/dist-packages (6.1.7)\n", + "Requirement already satisfied: astroquery in /usr/local/lib/python3.12/dist-packages (from hapsira) (0.4.11)\n", + "Requirement already satisfied: jplephem in /usr/local/lib/python3.12/dist-packages (from hapsira) (2.24)\n", + "Requirement already satisfied: matplotlib<3.8 in /usr/local/lib/python3.12/dist-packages (from hapsira) (3.7.5)\n", + "Requirement already satisfied: numba in /usr/local/lib/python3.12/dist-packages (from hapsira) (0.60.0)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (from hapsira) (1.26.4)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.12/dist-packages (from hapsira) (2.2.2)\n", + "Requirement already satisfied: plotly in /usr/local/lib/python3.12/dist-packages (from hapsira) (5.24.1)\n", + "Requirement already satisfied: pyerfa in /usr/local/lib/python3.12/dist-packages (from hapsira) (2.0.1.5)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.12/dist-packages (from hapsira) (1.16.3)\n", + "Requirement already satisfied: astropy-iers-data>=0.2024.10.28.0.34.7 in /usr/local/lib/python3.12/dist-packages (from astropy<7.0) (0.2026.3.30.0.54.34)\n", + "Requirement already satisfied: PyYAML>=3.13 in /usr/local/lib/python3.12/dist-packages (from astropy<7.0) (6.0.3)\n", + "Requirement already satisfied: packaging>=19.0 in /usr/local/lib/python3.12/dist-packages (from astropy<7.0) (26.0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (1.3.3)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (4.62.1)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (1.5.0)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (11.3.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (3.3.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (2.9.0.post0)\n", + "Requirement already satisfied: requests>=2.19 in /usr/local/lib/python3.12/dist-packages (from astroquery->hapsira) (2.32.4)\n", + "Requirement already satisfied: beautifulsoup4>=4.8 in /usr/local/lib/python3.12/dist-packages (from astroquery->hapsira) (4.13.5)\n", + "Requirement already satisfied: html5lib>=0.999 in /usr/local/lib/python3.12/dist-packages (from astroquery->hapsira) (1.1)\n", + "Requirement already satisfied: keyring>=15.0 in /usr/local/lib/python3.12/dist-packages (from astroquery->hapsira) (25.7.0)\n", + "Requirement already satisfied: pyvo>=1.5 in /usr/local/lib/python3.12/dist-packages (from astroquery->hapsira) (1.8.1)\n", + "Requirement already satisfied: llvmlite<0.44,>=0.43.0dev0 in /usr/local/lib/python3.12/dist-packages (from numba->hapsira) (0.43.0)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.12/dist-packages (from pandas->hapsira) (2025.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/dist-packages (from pandas->hapsira) (2025.3)\n", + "Requirement already satisfied: tenacity>=6.2.0 in /usr/local/lib/python3.12/dist-packages (from plotly->hapsira) (9.1.4)\n", + "Requirement already satisfied: soupsieve>1.2 in /usr/local/lib/python3.12/dist-packages (from beautifulsoup4>=4.8->astroquery->hapsira) (2.8.3)\n", + "Requirement already satisfied: typing-extensions>=4.0.0 in /usr/local/lib/python3.12/dist-packages (from beautifulsoup4>=4.8->astroquery->hapsira) (4.15.0)\n", + "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.12/dist-packages (from html5lib>=0.999->astroquery->hapsira) (1.17.0)\n", + "Requirement already satisfied: webencodings in /usr/local/lib/python3.12/dist-packages (from html5lib>=0.999->astroquery->hapsira) (0.5.1)\n", + "Requirement already satisfied: SecretStorage>=3.2 in /usr/local/lib/python3.12/dist-packages (from keyring>=15.0->astroquery->hapsira) (3.5.0)\n", + "Requirement already satisfied: jeepney>=0.4.2 in /usr/local/lib/python3.12/dist-packages (from keyring>=15.0->astroquery->hapsira) (0.9.0)\n", + "Requirement already satisfied: jaraco.classes in /usr/local/lib/python3.12/dist-packages (from keyring>=15.0->astroquery->hapsira) (3.4.0)\n", + "Requirement already satisfied: jaraco.functools in /usr/local/lib/python3.12/dist-packages (from keyring>=15.0->astroquery->hapsira) (4.4.0)\n", + "Requirement already satisfied: jaraco.context in /usr/local/lib/python3.12/dist-packages (from keyring>=15.0->astroquery->hapsira) (6.1.2)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests>=2.19->astroquery->hapsira) (3.4.6)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests>=2.19->astroquery->hapsira) (3.11)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/dist-packages (from requests>=2.19->astroquery->hapsira) (2.5.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.12/dist-packages (from requests>=2.19->astroquery->hapsira) (2026.2.25)\n", + "Requirement already satisfied: cryptography>=2.0 in /usr/local/lib/python3.12/dist-packages (from SecretStorage>=3.2->keyring>=15.0->astroquery->hapsira) (43.0.3)\n", + "Requirement already satisfied: more-itertools in /usr/local/lib/python3.12/dist-packages (from jaraco.classes->keyring>=15.0->astroquery->hapsira) (10.8.0)\n", + "Requirement already satisfied: cffi>=1.12 in /usr/local/lib/python3.12/dist-packages (from cryptography>=2.0->SecretStorage>=3.2->keyring>=15.0->astroquery->hapsira) (2.0.0)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.12/dist-packages (from cffi>=1.12->cryptography>=2.0->SecretStorage>=3.2->keyring>=15.0->astroquery->hapsira) (3.0)\n" + ] + } + ], "source": [ "#Install necessary packages for Google Colab. Note: hapsira is the modern version of poliastro to handle Python 3.12\n", "!pip install hapsira \"astropy<7.0\"" @@ -87,7 +145,7 @@ "metadata": { "id": "pChUe3tU9j3G" }, - "execution_count": 1, + "execution_count": 15, "outputs": [] }, { @@ -110,13 +168,13 @@ "# ===============================================================\n", "# Example interpolation data for gravitational and atmospheric losses based on LEO altitudes\n", "LEO_ALTITUDES_KM = [200, 300, 400, 500, 600, 700, 800]\n", - "DELTA_V_GRAV_KMS = [1520, 1540, 1560, 1580, 1600, 1620, 1640] # in km/s (example values)\n", - "DELTA_V_ATM_KMS = [320, 280, 250, 230, 210, 190, 170] # in km/s (example values)\n" + "DELTA_V_GRAV_KMS = [1520, 1540, 1560, 1580, 1600, 1620, 1640] # in m/s (example values)\n", + "DELTA_V_ATM_KMS = [320, 280, 250, 230, 210, 190, 170] # in m/s (example values)\n" ], "metadata": { "id": "eOVI25ac_Guv" }, - "execution_count": 2, + "execution_count": 16, "outputs": [] }, { @@ -178,7 +236,7 @@ "metadata": { "id": "KMyHUYvR_Ktu" }, - "execution_count": 10, + "execution_count": 17, "outputs": [] }, { @@ -219,7 +277,7 @@ "metadata": { "id": "HDeyr9oXA-wS" }, - "execution_count": 11, + "execution_count": 18, "outputs": [] }, { @@ -262,7 +320,7 @@ "metadata": { "id": "fbSfX8CKBZUV" }, - "execution_count": 12, + "execution_count": 19, "outputs": [] }, { @@ -297,7 +355,7 @@ "metadata": { "id": "r7ISbywRDVLt" }, - "execution_count": 13, + "execution_count": 20, "outputs": [] }, { @@ -377,7 +435,7 @@ "metadata": { "id": "9Y1lW1ZPFBEU" }, - "execution_count": null, + "execution_count": 21, "outputs": [] }, { @@ -529,7 +587,7 @@ "metadata": { "id": "T8OKwYHTNb11" }, - "execution_count": null, + "execution_count": 22, "outputs": [] }, { @@ -604,7 +662,7 @@ "metadata": { "id": "Ldu_y1EJUGCD" }, - "execution_count": null, + "execution_count": 23, "outputs": [] } ] From b48eba961d95bb0e9ecf659b193726f4b4ee12bb Mon Sep 17 00:00:00 2001 From: danielandresrestrebadaleal-dev Date: Sat, 11 Apr 2026 14:42:51 -0500 Subject: [PATCH 6/8] Creado con Colab --- corner_code.ipynb | 412 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 412 insertions(+) create mode 100644 corner_code.ipynb diff --git a/corner_code.ipynb b/corner_code.ipynb new file mode 100644 index 0000000..39deac7 --- /dev/null +++ b/corner_code.ipynb @@ -0,0 +1,412 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyOyce1zrA8v+gN1Idly4kTw", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Project Overview\n", + "\n", + "This code analyzes how different launch parameters (like launch latitude, exhaust velocity, etc.) affect the required delta-V and propellant mass to insert a payload in a geosynchronous orbit with a desired inclination. It creates a corner plots to understand the dependency of the delta-V and fuel mass on these launch variables" + ], + "metadata": { + "id": "zCNyd43A3Y-6" + } + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "FCGMNdHQ2wJz", + "outputId": "29feecb3-81ac-4383-a3c2-ee5f37606227" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: hapsira in /usr/local/lib/python3.12/dist-packages (0.18.0)\n", + "Requirement already satisfied: astropy<7.0 in /usr/local/lib/python3.12/dist-packages (6.1.7)\n", + "Collecting corner\n", + " Downloading corner-2.2.3-py3-none-any.whl.metadata (2.2 kB)\n", + "Requirement already satisfied: astroquery in /usr/local/lib/python3.12/dist-packages (from hapsira) (0.4.11)\n", + "Requirement already satisfied: jplephem in /usr/local/lib/python3.12/dist-packages (from hapsira) (2.24)\n", + "Requirement already satisfied: matplotlib<3.8 in /usr/local/lib/python3.12/dist-packages (from hapsira) (3.7.5)\n", + "Requirement already satisfied: numba in /usr/local/lib/python3.12/dist-packages (from hapsira) (0.60.0)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (from hapsira) (1.26.4)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.12/dist-packages (from hapsira) (2.2.2)\n", + "Requirement already satisfied: plotly in /usr/local/lib/python3.12/dist-packages (from hapsira) (5.24.1)\n", + "Requirement already satisfied: pyerfa in /usr/local/lib/python3.12/dist-packages (from hapsira) (2.0.1.5)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.12/dist-packages (from hapsira) (1.16.3)\n", + "Requirement already satisfied: astropy-iers-data>=0.2024.10.28.0.34.7 in /usr/local/lib/python3.12/dist-packages (from astropy<7.0) (0.2026.3.30.0.54.34)\n", + "Requirement already satisfied: PyYAML>=3.13 in /usr/local/lib/python3.12/dist-packages (from astropy<7.0) (6.0.3)\n", + "Requirement already satisfied: packaging>=19.0 in /usr/local/lib/python3.12/dist-packages (from astropy<7.0) (26.0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (1.3.3)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (4.62.1)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (1.5.0)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (11.3.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (3.3.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (2.9.0.post0)\n", + "Requirement already satisfied: requests>=2.19 in /usr/local/lib/python3.12/dist-packages (from astroquery->hapsira) (2.32.4)\n", + "Requirement already satisfied: beautifulsoup4>=4.8 in /usr/local/lib/python3.12/dist-packages (from astroquery->hapsira) (4.13.5)\n", + "Requirement already satisfied: html5lib>=0.999 in /usr/local/lib/python3.12/dist-packages (from astroquery->hapsira) (1.1)\n", + "Requirement already satisfied: keyring>=15.0 in /usr/local/lib/python3.12/dist-packages (from astroquery->hapsira) (25.7.0)\n", + "Requirement already satisfied: pyvo>=1.5 in /usr/local/lib/python3.12/dist-packages (from astroquery->hapsira) (1.8.1)\n", + "Requirement already satisfied: llvmlite<0.44,>=0.43.0dev0 in /usr/local/lib/python3.12/dist-packages (from numba->hapsira) (0.43.0)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.12/dist-packages (from pandas->hapsira) (2025.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/dist-packages (from pandas->hapsira) (2025.3)\n", + "Requirement already satisfied: tenacity>=6.2.0 in /usr/local/lib/python3.12/dist-packages (from plotly->hapsira) (9.1.4)\n", + "Requirement already satisfied: soupsieve>1.2 in /usr/local/lib/python3.12/dist-packages (from beautifulsoup4>=4.8->astroquery->hapsira) (2.8.3)\n", + "Requirement already satisfied: typing-extensions>=4.0.0 in /usr/local/lib/python3.12/dist-packages (from beautifulsoup4>=4.8->astroquery->hapsira) (4.15.0)\n", + "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.12/dist-packages (from html5lib>=0.999->astroquery->hapsira) (1.17.0)\n", + "Requirement already satisfied: webencodings in /usr/local/lib/python3.12/dist-packages (from html5lib>=0.999->astroquery->hapsira) (0.5.1)\n", + "Requirement already satisfied: SecretStorage>=3.2 in /usr/local/lib/python3.12/dist-packages (from keyring>=15.0->astroquery->hapsira) (3.5.0)\n", + "Requirement already satisfied: jeepney>=0.4.2 in /usr/local/lib/python3.12/dist-packages (from keyring>=15.0->astroquery->hapsira) (0.9.0)\n", + "Requirement already satisfied: jaraco.classes in /usr/local/lib/python3.12/dist-packages (from keyring>=15.0->astroquery->hapsira) (3.4.0)\n", + "Requirement already satisfied: jaraco.functools in /usr/local/lib/python3.12/dist-packages (from keyring>=15.0->astroquery->hapsira) (4.4.0)\n", + "Requirement already satisfied: jaraco.context in /usr/local/lib/python3.12/dist-packages (from keyring>=15.0->astroquery->hapsira) (6.1.2)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests>=2.19->astroquery->hapsira) (3.4.6)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests>=2.19->astroquery->hapsira) (3.11)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/dist-packages (from requests>=2.19->astroquery->hapsira) (2.5.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.12/dist-packages (from requests>=2.19->astroquery->hapsira) (2026.2.25)\n", + "Requirement already satisfied: cryptography>=2.0 in /usr/local/lib/python3.12/dist-packages (from SecretStorage>=3.2->keyring>=15.0->astroquery->hapsira) (43.0.3)\n", + "Requirement already satisfied: more-itertools in /usr/local/lib/python3.12/dist-packages (from jaraco.classes->keyring>=15.0->astroquery->hapsira) (10.8.0)\n", + "Requirement already satisfied: cffi>=1.12 in /usr/local/lib/python3.12/dist-packages (from cryptography>=2.0->SecretStorage>=3.2->keyring>=15.0->astroquery->hapsira) (2.0.0)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.12/dist-packages (from cffi>=1.12->cryptography>=2.0->SecretStorage>=3.2->keyring>=15.0->astroquery->hapsira) (3.0)\n", + "Downloading corner-2.2.3-py3-none-any.whl (15 kB)\n", + "Installing collected packages: corner\n", + "Successfully installed corner-2.2.3\n" + ] + } + ], + "source": [ + "#Install necessary packages for Google Colab. Note: hapsira is the modern version of poliastro to handle Python 3.12\n", + "!pip install hapsira \"astropy<7.0\" corner" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Code Imports\n", + "This code utilizes several Python libraries for different functionalities:\n", + "\n", + "1. poliastro & astropy: for orbital state representation\n", + "\n", + "2. multiprocessing: to handle multiple orbital simulations simultaneously to reduce computational time\n", + "\n", + "3. corner & matplotlib: to plot results\n", + "\n", + "4. random: to randomize some launch parameters\n", + "\n", + "5. time: to keep track of the computational time\n", + "\n", + "6. numpy: to make complex vector calculations\n", + "\n", + "7. simulate_orbit: function that simulates the insertion of a payload into GEO orbit and computes the total delta-V and propellant mass needed given specific launch parameters (from GEO_orbital_simulation tutorial)" + ], + "metadata": { + "id": "WmVwZAuv4Iba" + } + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import time\n", + "import random\n", + "from itertools import product\n", + "import multiprocessing as mp\n", + "import matplotlib as mpl\n", + "from matplotlib import pyplot as plt\n", + "import corner\n", + "\n", + "from astropy import units as u\n", + "from hapsira.bodies import Earth\n", + "from hapsira.twobody import Orbit\n", + "from astropy.coordinates import CartesianRepresentation\n", + "\n", + "# Import the simulation function from the simulation module.\n", + "# Ensure that the function 'simulate' is available in the 'simulation.py' module in your environment.\n", + "from simulation import simulate_orbit" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 297 + }, + "collapsed": true, + "id": "RCxEH_aK4Onk", + "outputId": "c4b28a23-3a99-4f1f-dfc5-44b19f835a9f" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "error", + "ename": "TypeError", + "evalue": "build_ephem_interpolant() got an unexpected keyword argument 'rtol'", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_840/4123592895.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;31m# Import the simulation function from the simulation module.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 16\u001b[0m \u001b[0;31m# Ensure that the function 'simulate' is available in the 'simulation.py' module in your environment.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0msimulation\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0msimulate_orbit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/content/simulation.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 126\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 127\u001b[0m \u001b[0;31m# Build ephemeris interpolants for Moon and Sun (half-hour resolution over one day)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 128\u001b[0;31m moon_ephem = build_ephem_interpolant(\n\u001b[0m\u001b[1;32m 129\u001b[0m \u001b[0mMoon\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 130\u001b[0m \u001b[0;36m0.5\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mu\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: build_ephem_interpolant() got an unexpected keyword argument 'rtol'" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Defining launch parameters\n", + "\n", + "All the launch parameters that will be analyzed are initialized here. Discrete values are chosen for all quantities and are randomized within a range except the final inclination and exhaust velocities of the two stages of the rocket." + ], + "metadata": { + "id": "SJ0Gu2JM7r9d" + } + }, + { + "cell_type": "code", + "source": [ + "# ===============================================================\n", + "# Define Parameter Lists for Simulation\n", + "# ===============================================================\n", + "# Fixed list of inclination values (in degrees)\n", + "inclination_values = [5, 13, 26, 34, 46, 62]\n", + "\n", + "# Fixed list of stage 1 exhaust velocities (in m/s)\n", + "exhaust_velocity_stage1 = [2800, 2925, 3050, 3175, 3300]\n", + "\n", + "# Fixed list of stage 2 exhaust velocities (in m/s)\n", + "exhaust_velocity_stage2 = [4200, 4300, 4400, 4500, 4600]\n", + "\n", + "# Generate randomized list for payload exhaust velocity (propulsive exhaust) in m/s\n", + "payload_exhaust_lin = np.linspace(20000, 30000, 5)\n", + "payload_exhaust_values = [\n", + " np.clip(val + np.random.uniform(-1000, 1000), 20000, 30000)\n", + " for val in payload_exhaust_lin\n", + "]\n", + "\n", + "# Generate randomized list for LEO altitude values (in km)\n", + "leo_altitude_lin = np.linspace(200, 800, 10)\n", + "leo_altitude_values = [\n", + " np.clip(val + np.random.uniform(-10, 10), 200, 800)\n", + " for val in leo_altitude_lin\n", + "]\n", + "\n", + "# Generate randomized list for payload mass values (in kg)\n", + "payload_mass_lin = np.linspace(200, 300, 5)\n", + "payload_mass_values = [\n", + " np.clip(val + np.random.uniform(-10, 10), 200, 300)\n", + " for val in payload_mass_lin\n", + "]\n", + "\n", + "# Generate randomized list for inclination change percentage (in %)\n", + "inclination_change_lin = np.linspace(0, 100, 10)\n", + "inclination_change_values = [\n", + " np.clip(val + np.random.uniform(-5, 5), 0, 100)\n", + " for val in inclination_change_lin\n", + "]" + ], + "metadata": { + "id": "XAR7Ntb97sca" + }, + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Main code\n", + "\n", + "Here, we combine all the launch parameters into a tuple and pass them over to the simulation_orbit() function. The multiprocessing tool is utilized to run multiple simulations with different parameters at the same time to run the code faster. Lastly, we create a corner plot using the corner function and adjust font size, dpi of the picture, and other variabes to create a polished figure with the help of matplotlib" + ], + "metadata": { + "id": "158lPIJX8QTI" + } + }, + { + "cell_type": "code", + "source": [ + "# ===============================================================\n", + "# Main Entry Point for Simulation and Plotting\n", + "# ===============================================================\n", + "if __name__ == '__main__':\n", + " # Mark start time of simulation\n", + " start_time = time.perf_counter()\n", + "\n", + " # Create a list of all possible parameter combinations as tuples:\n", + " # (inclination, LEO altitude, stage 1 exhaust, stage 2 exhaust, payload exhaust, payload mass, inclination change)\n", + " parameter_combinations = list(product(\n", + " inclination_values,\n", + " leo_altitude_values,\n", + " exhaust_velocity_stage1,\n", + " exhaust_velocity_stage2,\n", + " payload_exhaust_values,\n", + " payload_mass_values,\n", + " inclination_change_values\n", + " ))\n", + "\n", + " # Use a multiprocessing pool to parallelize the simulation.\n", + " with mp.Pool(processes=mp.cpu_count()) as pool:\n", + " simulation_results = pool.map(simulate_orbit, parameter_combinations)\n", + "\n", + " # Convert the results to a NumPy array for further processing/plotting.\n", + " results_array = np.array(simulation_results)\n", + "\n", + " # Set global font size for plotting with matplotlib\n", + " mpl.rcParams.update({'font.size': 115})\n", + "\n", + " # Define axis labels for the corner plot\n", + " plot_labels = [\n", + " \"Initial Inclination (deg)\",\n", + " \"Inclination Change (%)\",\n", + " \"LEO Altitude (km)\",\n", + " \"Stage 1 EV (m/s)\",\n", + " \"Stage 2 EV (m/s)\",\n", + " \"Payload EV (m/s)\",\n", + " \"Payload Mass (kg)\",\n", + " \"Propellant Mass (kg)\",\n", + " \"Total ΔV (m/s)\"\n", + " ]\n", + "\n", + " # Generate the corner plot with the simulation results\n", + " corner_fig = corner.corner(\n", + " results_array,\n", + " labels=plot_labels,\n", + " label_kwargs={\"fontsize\": 120},\n", + " show_titles=True,\n", + " title_fmt=\".2f\",\n", + " bins=60,\n", + " smooth=1.0,\n", + " fill_contours=True,\n", + " plot_contours=True,\n", + " max_n_ticks=4,\n", + " hist2d_kwargs={\n", + " 'plot_datapoints': True,\n", + " 'alpha': 0.15,\n", + " 'plot_density': False\n", + " },\n", + " scatter_kwargs={\n", + " 'alpha': 0.05,\n", + " 's': 3\n", + " }\n", + " )\n", + "\n", + " # Set figure size and layout adjustments, then save and display the plot.\n", + " corner_fig.set_size_inches(220, 220)\n", + " corner_fig.tight_layout()\n", + " plt.savefig(\"Corner.pdf\", dpi=130, bbox_inches='tight')\n", + "\n", + " # Mark end time and output the duration of the simulation\n", + " end_time = time.perf_counter()\n", + " print(\"Total simulation and plotting time: \", end_time - start_time, \"seconds\")\n", + " plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 211 + }, + "id": "L0pRoWks8Qrc", + "outputId": "04a06cd8-d282-4f7b-cbd4-8cf3c23c34c2" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "name 'simulate_orbit' is not defined", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_840/2661663276.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 20\u001b[0m \u001b[0;31m# Use a multiprocessing pool to parallelize the simulation.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mmp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mPool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprocesses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcpu_count\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mpool\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 22\u001b[0;31m \u001b[0msimulation_results\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpool\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msimulate_orbit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparameter_combinations\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 23\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[0;31m# Convert the results to a NumPy array for further processing/plotting.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'simulate_orbit' is not defined" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Given the size of this figure, the code below is used to download the figure from a google colab folder and transfer it to your google drive account for visualization with the name of \"Corner_Simulation_Plot.pdf.\" Please run the code below to download the figure\n" + ], + "metadata": { + "id": "rkm5DPtP9Ugu" + } + }, + { + "cell_type": "code", + "source": [ + "from google.colab import drive\n", + "import shutil\n", + "\n", + "# 1. This will prompt you to log in and connect your Google Drive\n", + "drive.mount('/content/drive')\n", + "\n", + "# 2. This copies your massive PDF from Colab's temporary memory straight into your Drive\n", + "shutil.copy(\"Corner.pdf\", \"/content/drive/MyDrive/Corner_Simulation_Plot.pdf\")\n", + "\n", + "print(\"Transfer complete! Check your Google Drive.\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_yhcydSmDJ8Q", + "outputId": "69f0d6f6-febc-4dc7-e188-2950d1b97d6a" + }, + "execution_count": 16, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n", + "Transfer complete! Check your Google Drive.\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Results and Conclusions\n", + "\n", + "As shown in the corner plot above, the three main factors to consider to otpimize the payload mass are the launch site latitude, the exhaust velocity of the stage 2 of the rocket, and the mass of the payload. Similarly, the percent change in final inclination and initial launch site latitude are the factors that most heavily influence the total required delta-V. These results highlight the need for a strategic design of the payload to reduce the fuel mass, as well as selecting high-performance engines, especially for the stage 2 of the rocket. Additionally, the initial and final inclinations of the orbit must be close in value if minimizing the delta-V is a priority." + ], + "metadata": { + "id": "v7KAZ3SkAgGl" + } + } + ] +} \ No newline at end of file From 3fc616fdce2e87a2303a3141fdbf1662bbd04976 Mon Sep 17 00:00:00 2001 From: danielandresrestrebadaleal-dev Date: Sat, 11 Apr 2026 14:44:08 -0500 Subject: [PATCH 7/8] Creado con Colab --- corner_code.ipynb | 135 +++++----------------------------------------- 1 file changed, 12 insertions(+), 123 deletions(-) diff --git a/corner_code.ipynb b/corner_code.ipynb index 39deac7..904117f 100644 --- a/corner_code.ipynb +++ b/corner_code.ipynb @@ -39,75 +39,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, "collapsed": true, - "id": "FCGMNdHQ2wJz", - "outputId": "29feecb3-81ac-4383-a3c2-ee5f37606227" + "id": "FCGMNdHQ2wJz" }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Requirement already satisfied: hapsira in /usr/local/lib/python3.12/dist-packages (0.18.0)\n", - "Requirement already satisfied: astropy<7.0 in /usr/local/lib/python3.12/dist-packages (6.1.7)\n", - "Collecting corner\n", - " Downloading corner-2.2.3-py3-none-any.whl.metadata (2.2 kB)\n", - "Requirement already satisfied: astroquery in /usr/local/lib/python3.12/dist-packages (from hapsira) (0.4.11)\n", - "Requirement already satisfied: jplephem in /usr/local/lib/python3.12/dist-packages (from hapsira) (2.24)\n", - "Requirement already satisfied: matplotlib<3.8 in /usr/local/lib/python3.12/dist-packages (from hapsira) (3.7.5)\n", - "Requirement already satisfied: numba in /usr/local/lib/python3.12/dist-packages (from hapsira) (0.60.0)\n", - "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (from hapsira) (1.26.4)\n", - "Requirement already satisfied: pandas in /usr/local/lib/python3.12/dist-packages (from hapsira) (2.2.2)\n", - "Requirement already satisfied: plotly in /usr/local/lib/python3.12/dist-packages (from hapsira) (5.24.1)\n", - "Requirement already satisfied: pyerfa in /usr/local/lib/python3.12/dist-packages (from hapsira) (2.0.1.5)\n", - "Requirement already satisfied: scipy in /usr/local/lib/python3.12/dist-packages (from hapsira) (1.16.3)\n", - "Requirement already satisfied: astropy-iers-data>=0.2024.10.28.0.34.7 in /usr/local/lib/python3.12/dist-packages (from astropy<7.0) (0.2026.3.30.0.54.34)\n", - "Requirement already satisfied: PyYAML>=3.13 in /usr/local/lib/python3.12/dist-packages (from astropy<7.0) (6.0.3)\n", - "Requirement already satisfied: packaging>=19.0 in /usr/local/lib/python3.12/dist-packages (from astropy<7.0) (26.0)\n", - "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (1.3.3)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (0.12.1)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (4.62.1)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (1.5.0)\n", - "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (11.3.0)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (3.3.2)\n", - "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.12/dist-packages (from matplotlib<3.8->hapsira) (2.9.0.post0)\n", - "Requirement already satisfied: requests>=2.19 in /usr/local/lib/python3.12/dist-packages (from astroquery->hapsira) (2.32.4)\n", - "Requirement already satisfied: beautifulsoup4>=4.8 in /usr/local/lib/python3.12/dist-packages (from astroquery->hapsira) (4.13.5)\n", - "Requirement already satisfied: html5lib>=0.999 in /usr/local/lib/python3.12/dist-packages (from astroquery->hapsira) (1.1)\n", - "Requirement already satisfied: keyring>=15.0 in /usr/local/lib/python3.12/dist-packages (from astroquery->hapsira) (25.7.0)\n", - "Requirement already satisfied: pyvo>=1.5 in /usr/local/lib/python3.12/dist-packages (from astroquery->hapsira) (1.8.1)\n", - "Requirement already satisfied: llvmlite<0.44,>=0.43.0dev0 in /usr/local/lib/python3.12/dist-packages (from numba->hapsira) (0.43.0)\n", - "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.12/dist-packages (from pandas->hapsira) (2025.2)\n", - "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/dist-packages (from pandas->hapsira) (2025.3)\n", - "Requirement already satisfied: tenacity>=6.2.0 in /usr/local/lib/python3.12/dist-packages (from plotly->hapsira) (9.1.4)\n", - "Requirement already satisfied: soupsieve>1.2 in /usr/local/lib/python3.12/dist-packages (from beautifulsoup4>=4.8->astroquery->hapsira) (2.8.3)\n", - "Requirement already satisfied: typing-extensions>=4.0.0 in /usr/local/lib/python3.12/dist-packages (from beautifulsoup4>=4.8->astroquery->hapsira) (4.15.0)\n", - "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.12/dist-packages (from html5lib>=0.999->astroquery->hapsira) (1.17.0)\n", - "Requirement already satisfied: webencodings in /usr/local/lib/python3.12/dist-packages (from html5lib>=0.999->astroquery->hapsira) (0.5.1)\n", - "Requirement already satisfied: SecretStorage>=3.2 in /usr/local/lib/python3.12/dist-packages (from keyring>=15.0->astroquery->hapsira) (3.5.0)\n", - "Requirement already satisfied: jeepney>=0.4.2 in /usr/local/lib/python3.12/dist-packages (from keyring>=15.0->astroquery->hapsira) (0.9.0)\n", - "Requirement already satisfied: jaraco.classes in /usr/local/lib/python3.12/dist-packages (from keyring>=15.0->astroquery->hapsira) (3.4.0)\n", - "Requirement already satisfied: jaraco.functools in /usr/local/lib/python3.12/dist-packages (from keyring>=15.0->astroquery->hapsira) (4.4.0)\n", - "Requirement already satisfied: jaraco.context in /usr/local/lib/python3.12/dist-packages (from keyring>=15.0->astroquery->hapsira) (6.1.2)\n", - "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests>=2.19->astroquery->hapsira) (3.4.6)\n", - "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests>=2.19->astroquery->hapsira) (3.11)\n", - "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/dist-packages (from requests>=2.19->astroquery->hapsira) (2.5.0)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.12/dist-packages (from requests>=2.19->astroquery->hapsira) (2026.2.25)\n", - "Requirement already satisfied: cryptography>=2.0 in /usr/local/lib/python3.12/dist-packages (from SecretStorage>=3.2->keyring>=15.0->astroquery->hapsira) (43.0.3)\n", - "Requirement already satisfied: more-itertools in /usr/local/lib/python3.12/dist-packages (from jaraco.classes->keyring>=15.0->astroquery->hapsira) (10.8.0)\n", - "Requirement already satisfied: cffi>=1.12 in /usr/local/lib/python3.12/dist-packages (from cryptography>=2.0->SecretStorage>=3.2->keyring>=15.0->astroquery->hapsira) (2.0.0)\n", - "Requirement already satisfied: pycparser in /usr/local/lib/python3.12/dist-packages (from cffi>=1.12->cryptography>=2.0->SecretStorage>=3.2->keyring>=15.0->astroquery->hapsira) (3.0)\n", - "Downloading corner-2.2.3-py3-none-any.whl (15 kB)\n", - "Installing collected packages: corner\n", - "Successfully installed corner-2.2.3\n" - ] - } - ], + "outputs": [], "source": [ "#Install necessary packages for Google Colab. Note: hapsira is the modern version of poliastro to handle Python 3.12\n", "!pip install hapsira \"astropy<7.0\" corner" @@ -159,29 +96,11 @@ "from simulation import simulate_orbit" ], "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 297 - }, "collapsed": true, - "id": "RCxEH_aK4Onk", - "outputId": "c4b28a23-3a99-4f1f-dfc5-44b19f835a9f" + "id": "RCxEH_aK4Onk" }, - "execution_count": 6, - "outputs": [ - { - "output_type": "error", - "ename": "TypeError", - "evalue": "build_ephem_interpolant() got an unexpected keyword argument 'rtol'", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_840/4123592895.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;31m# Import the simulation function from the simulation module.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 16\u001b[0m \u001b[0;31m# Ensure that the function 'simulate' is available in the 'simulation.py' module in your environment.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0msimulation\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0msimulate_orbit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/content/simulation.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 126\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 127\u001b[0m \u001b[0;31m# Build ephemeris interpolants for Moon and Sun (half-hour resolution over one day)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 128\u001b[0;31m moon_ephem = build_ephem_interpolant(\n\u001b[0m\u001b[1;32m 129\u001b[0m \u001b[0mMoon\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 130\u001b[0m \u001b[0;36m0.5\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mu\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mTypeError\u001b[0m: build_ephem_interpolant() got an unexpected keyword argument 'rtol'" - ] - } - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", @@ -333,27 +252,10 @@ " plt.show()" ], "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 211 - }, - "id": "L0pRoWks8Qrc", - "outputId": "04a06cd8-d282-4f7b-cbd4-8cf3c23c34c2" + "id": "L0pRoWks8Qrc" }, - "execution_count": 8, - "outputs": [ - { - "output_type": "error", - "ename": "NameError", - "evalue": "name 'simulate_orbit' is not defined", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_840/2661663276.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 20\u001b[0m \u001b[0;31m# Use a multiprocessing pool to parallelize the simulation.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mmp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mPool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprocesses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcpu_count\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mpool\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 22\u001b[0;31m \u001b[0msimulation_results\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpool\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msimulate_orbit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparameter_combinations\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 23\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[0;31m# Convert the results to a NumPy array for further processing/plotting.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'simulate_orbit' is not defined" - ] - } - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", @@ -379,23 +281,10 @@ "print(\"Transfer complete! Check your Google Drive.\")" ], "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "_yhcydSmDJ8Q", - "outputId": "69f0d6f6-febc-4dc7-e188-2950d1b97d6a" + "id": "_yhcydSmDJ8Q" }, - "execution_count": 16, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mounted at /content/drive\n", - "Transfer complete! Check your Google Drive.\n" - ] - } - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", From e2e09a2d338554ff76b56bbfca56101253459d18 Mon Sep 17 00:00:00 2001 From: danielandresrestrebadaleal-dev Date: Sat, 11 Apr 2026 14:53:04 -0500 Subject: [PATCH 8/8] Creado con Colab --- corner_code.ipynb | 24 ++---------------------- 1 file changed, 2 insertions(+), 22 deletions(-) diff --git a/corner_code.ipynb b/corner_code.ipynb index 904117f..fc6031d 100644 --- a/corner_code.ipynb +++ b/corner_code.ipynb @@ -4,7 +4,7 @@ "metadata": { "colab": { "provenance": [], - "authorship_tag": "ABX9TyOyce1zrA8v+gN1Idly4kTw", + "authorship_tag": "ABX9TyNHjjBoncuSIBPpLueRZOte", "include_colab_link": true }, "kernelspec": { @@ -260,32 +260,12 @@ { "cell_type": "markdown", "source": [ - "Given the size of this figure, the code below is used to download the figure from a google colab folder and transfer it to your google drive account for visualization with the name of \"Corner_Simulation_Plot.pdf.\" Please run the code below to download the figure\n" + "Given the size of this figure, google colab crashes out when it tries to display this picture. Thus, a link is provided with direct access to this figure. Click here to view a PDF version of the corner plot: https://drive.google.com/drive/folders/1mz0qIrBFHchnG6LQ4o484kGEIt2xbMU1?usp=sharing" ], "metadata": { "id": "rkm5DPtP9Ugu" } }, - { - "cell_type": "code", - "source": [ - "from google.colab import drive\n", - "import shutil\n", - "\n", - "# 1. This will prompt you to log in and connect your Google Drive\n", - "drive.mount('/content/drive')\n", - "\n", - "# 2. This copies your massive PDF from Colab's temporary memory straight into your Drive\n", - "shutil.copy(\"Corner.pdf\", \"/content/drive/MyDrive/Corner_Simulation_Plot.pdf\")\n", - "\n", - "print(\"Transfer complete! Check your Google Drive.\")" - ], - "metadata": { - "id": "_yhcydSmDJ8Q" - }, - "execution_count": null, - "outputs": [] - }, { "cell_type": "markdown", "source": [