add axial_accelaration and test.

Author: hogatata

rocketpy/simulation/flight.py

@@ -1,21 +1,20 @@
 # pylint: disable=too-many-lines
+import json
 import math
 import warnings
 from copy import deepcopy
 from functools import cached_property
 
 import numpy as np
+import simplekml
 from scipy.integrate import BDF, DOP853, LSODA, RK23, RK45, OdeSolver, Radau
 
-from rocketpy.simulation.flight_data_exporter import FlightDataExporter
-
 from ..mathutils.function import Function, funcify_method
 from ..mathutils.vector_matrix import Matrix, Vector
 from ..plots.flight_plots import _FlightPlots
 from ..prints.flight_prints import _FlightPrints
 from ..tools import (
     calculate_cubic_hermite_coefficients,
-    deprecated,
     euler313_to_quaternions,
     find_closest,
     find_root_linear_interpolation,
@@ -1130,7 +1129,6 @@ def __init_solution_monitors(self):
         self.out_of_rail_time_index = 0
         self.out_of_rail_state = np.array([0])
         self.apogee_state = np.array([0])
-        self.apogee = 0
         self.apogee_time = 0
         self.x_impact = 0
         self.y_impact = 0
@@ -2470,6 +2468,15 @@ def max_acceleration(self):
         """Maximum acceleration reached by the rocket."""
         max_acceleration_time_index = np.argmax(self.acceleration[:, 1])
         return self.acceleration[max_acceleration_time_index, 1]
+    
+    @cached_property
+    def axial_acceleration(self):
+        """Axial acceleration magnitude as a function of time."""
+        return (
+            self.ax * self.attitude_vector_x
+            + self.ay * self.attitude_vector_y
+            + self.az * self.attitude_vector_z
+        )
 
     @funcify_method("Time (s)", "Horizontal Speed (m/s)")
     def horizontal_speed(self):
@@ -3266,72 +3273,270 @@ def calculate_stall_wind_velocity(self, stall_angle):  # TODO: move to utilities
             + f" of attack exceeds {stall_angle:.3f}°: {w_v:.3f} m/s"
         )
 
-    @deprecated(
-        reason="Moved to FlightDataExporter.export_pressures()",
-        version="v1.12.0",
-        alternative="rocketpy.simulation.flight_data_exporter.FlightDataExporter.export_pressures",
-    )
-    def export_pressures(self, file_name, time_step):
-        """
-        .. deprecated:: 1.11
-           Use :class:`rocketpy.simulation.flight_data_exporter.FlightDataExporter`
-           and call ``.export_pressures(...)``.
+    def export_pressures(self, file_name, time_step):  # TODO: move out
+        """Exports the pressure experienced by the rocket during the flight to
+        an external file, the '.csv' format is recommended, as the columns will
+        be separated by commas. It can handle flights with or without
+        parachutes, although it is not possible to get a noisy pressure signal
+        if no parachute is added.
+
+        If a parachute is added, the file will contain 3 columns: time in
+        seconds, clean pressure in Pascals and noisy pressure in Pascals.
+        For flights without parachutes, the third column will be discarded
+
+        This function was created especially for the 'Projeto Jupiter'
+        Electronics Subsystems team and aims to help in configuring
+        micro-controllers.
+
+        Parameters
+        ----------
+        file_name : string
+            The final file name,
+        time_step : float
+            Time step desired for the final file
+
+        Return
+        ------
+        None
         """
-        return FlightDataExporter(self).export_pressures(file_name, time_step)
+        time_points = np.arange(0, self.t_final, time_step)
+        # pylint: disable=W1514, E1121
+        with open(file_name, "w") as file:
+            if len(self.rocket.parachutes) == 0:
+                print("No parachutes in the rocket, saving static pressure.")
+                for t in time_points:
+                    file.write(f"{t:f}, {self.pressure.get_value_opt(t):.5f}\n")
+            else:
+                for parachute in self.rocket.parachutes:
+                    for t in time_points:
+                        p_cl = parachute.clean_pressure_signal_function.get_value_opt(t)
+                        p_ns = parachute.noisy_pressure_signal_function.get_value_opt(t)
+                        file.write(f"{t:f}, {p_cl:.5f}, {p_ns:.5f}\n")
+                    # We need to save only 1 parachute data
+                    break
 
-    @deprecated(
-        reason="Moved to FlightDataExporter.export_data()",
-        version="v1.12.0",
-        alternative="rocketpy.simulation.flight_data_exporter.FlightDataExporter.export_data",
-    )
     def export_data(self, file_name, *variables, time_step=None):
+        """Exports flight data to a comma separated value file (.csv).
+
+        Data is exported in columns, with the first column representing time
+        steps. The first line of the file is a header line, specifying the
+        meaning of each column and its units.
+
+        Parameters
+        ----------
+        file_name : string
+            The file name or path of the exported file. Example: flight_data.csv
+            Do not use forbidden characters, such as / in Linux/Unix and
+            `<, >, :, ", /, \\, | ?, *` in Windows.
+        variables : strings, optional
+            Names of the data variables which shall be exported. Must be Flight
+            class attributes which are instances of the Function class. Usage
+            example: test_flight.export_data('test.csv', 'z', 'angle_of_attack',
+            'mach_number').
+        time_step : float, optional
+            Time step desired for the data. If None, all integration time steps
+            will be exported. Otherwise, linear interpolation is carried out to
+            calculate values at the desired time steps. Example: 0.001.
         """
-        .. deprecated:: 1.11
-           Use :class:`rocketpy.simulation.flight_data_exporter.FlightDataExporter`
-           and call ``.export_data(...)``.
-        """
-        return FlightDataExporter(self).export_data(
-            file_name, *variables, time_step=time_step
+        # TODO: we should move this method to outside of class.
+
+        # Fast evaluation for the most basic scenario
+        if time_step is None and len(variables) == 0:
+            np.savetxt(
+                file_name,
+                self.solution,
+                fmt="%.6f",
+                delimiter=",",
+                header=""
+                "Time (s),"
+                "X (m),"
+                "Y (m),"
+                "Z (m),"
+                "E0,"
+                "E1,"
+                "E2,"
+                "E3,"
+                "W1 (rad/s),"
+                "W2 (rad/s),"
+                "W3 (rad/s)",
+            )
+            return
+
+        # Not so fast evaluation for general case
+        if variables is None:
+            variables = [
+                "x",
+                "y",
+                "z",
+                "vx",
+                "vy",
+                "vz",
+                "e0",
+                "e1",
+                "e2",
+                "e3",
+                "w1",
+                "w2",
+                "w3",
+            ]
+
+        if time_step is None:
+            time_points = self.time
+        else:
+            time_points = np.arange(self.t_initial, self.t_final, time_step)
+
+        exported_matrix = [time_points]
+        exported_header = "Time (s)"
+
+        # Loop through variables, get points and names (for the header)
+        for variable in variables:
+            if variable in self.__dict__:
+                variable_function = self.__dict__[variable]
+            # Deal with decorated Flight methods
+            else:
+                try:
+                    obj = getattr(self.__class__, variable)
+                    variable_function = obj.__get__(self, self.__class__)
+                except AttributeError as exc:
+                    raise AttributeError(
+                        f"Variable '{variable}' not found in Flight class"
+                    ) from exc
+            variable_points = variable_function(time_points)
+            exported_matrix += [variable_points]
+            exported_header += f", {variable_function.__outputs__[0]}"
+
+        exported_matrix = np.array(exported_matrix).T  # Fix matrix orientation
+
+        np.savetxt(
+            file_name,
+            exported_matrix,
+            fmt="%.6f",
+            delimiter=",",
+            header=exported_header,
+            encoding="utf-8",
         )
 
-    @deprecated(
-        reason="Moved to FlightDataExporter.export_sensor_data()",
-        version="v1.12.0",
-        alternative="rocketpy.simulation.flight_data_exporter.FlightDataExporter.export_sensor_data",
-    )
     def export_sensor_data(self, file_name, sensor=None):
+        """Exports sensors data to a file. The file format can be either .csv or
+        .json.
+
+        Parameters
+        ----------
+        file_name : str
+            The file name or path of the exported file. Example: flight_data.csv
+            Do not use forbidden characters, such as / in Linux/Unix and
+            `<, >, :, ", /, \\, | ?, *` in Windows.
+        sensor : Sensor, string, optional
+            The sensor to export data from. Can be given as a Sensor object or
+            as a string with the sensor name. If None, all sensors data will be
+            exported. Default is None.
         """
-        .. deprecated:: 1.11
-           Use :class:`rocketpy.simulation.flight_data_exporter.FlightDataExporter`
-           and call ``.export_sensor_data(...)``.
-        """
-        return FlightDataExporter(self).export_sensor_data(file_name, sensor=sensor)
+        if sensor is None:
+            data_dict = {}
+            for used_sensor, measured_data in self.sensor_data.items():
+                data_dict[used_sensor.name] = measured_data
+        else:
+            # export data of only that sensor
+            data_dict = {}
+
+            if not isinstance(sensor, str):
+                data_dict[sensor.name] = self.sensor_data[sensor]
+            else:  # sensor is a string
+                matching_sensors = [s for s in self.sensor_data if s.name == sensor]
+
+                if len(matching_sensors) > 1:
+                    data_dict[sensor] = []
+                    for s in matching_sensors:
+                        data_dict[s.name].append(self.sensor_data[s])
+                elif len(matching_sensors) == 1:
+                    data_dict[sensor] = self.sensor_data[matching_sensors[0]]
+                else:
+                    raise ValueError("Sensor not found in the Flight.sensor_data.")
 
-    @deprecated(
-        reason="Moved to FlightDataExporter.export_kml()",
-        version="v1.12.0",
-        alternative="rocketpy.simulation.flight_data_exporter.FlightDataExporter.export_kml",
-    )
-    def export_kml(
+        with open(file_name, "w") as file:
+            json.dump(data_dict, file)
+        print("Sensor data exported to: ", file_name)
+
+    def export_kml(  # TODO: should be moved out of this class.
         self,
         file_name="trajectory.kml",
         time_step=None,
         extrude=True,
         color="641400F0",
         altitude_mode="absolute",
     ):
+        """Exports flight data to a .kml file, which can be opened with Google
+        Earth to display the rocket's trajectory.
+
+        Parameters
+        ----------
+        file_name : string
+            The file name or path of the exported file. Example: flight_data.csv
+        time_step : float, optional
+            Time step desired for the data. If None, all integration time steps
+            will be exported. Otherwise, linear interpolation is carried out to
+            calculate values at the desired time steps. Example: 0.001.
+        extrude: bool, optional
+            To be used if you want to project the path over ground by using an
+            extruded polygon. In case False only the linestring containing the
+            flight path will be created. Default is True.
+        color : str, optional
+            Color of your trajectory path, need to be used in specific kml
+            format. Refer to http://www.zonums.com/gmaps/kml_color/ for more
+            info.
+        altitude_mode: str
+            Select elevation values format to be used on the kml file. Use
+            'relativetoground' if you want use Above Ground Level elevation, or
+            'absolute' if you want to parse elevation using Above Sea Level.
+            Default is 'relativetoground'. Only works properly if the ground
+            level is flat. Change to 'absolute' if the terrain is to irregular
+            or contains mountains.
         """
-        .. deprecated:: 1.11
-           Use :class:`rocketpy.simulation.flight_data_exporter.FlightDataExporter`
-           and call ``.export_kml(...)``.
-        """
-        return FlightDataExporter(self).export_kml(
-            file_name=file_name,
-            time_step=time_step,
-            extrude=extrude,
-            color=color,
-            altitude_mode=altitude_mode,
-        )
+        # Define time points vector
+        if time_step is None:
+            time_points = self.time
+        else:
+            time_points = np.arange(self.t_initial, self.t_final + time_step, time_step)
+        # Open kml file with simplekml library
+        kml = simplekml.Kml(open=1)
+        trajectory = kml.newlinestring(name="Rocket Trajectory - Powered by RocketPy")
+
+        if altitude_mode == "relativetoground":
+            # In this mode the elevation data will be the Above Ground Level
+            # elevation. Only works properly if the ground level is similar to
+            # a plane, i.e. it might not work well if the terrain has mountains
+            coords = [
+                (
+                    self.longitude.get_value_opt(t),
+                    self.latitude.get_value_opt(t),
+                    self.altitude.get_value_opt(t),
+                )
+                for t in time_points
+            ]
+            trajectory.coords = coords
+            trajectory.altitudemode = simplekml.AltitudeMode.relativetoground
+        else:  # altitude_mode == 'absolute'
+            # In this case the elevation data will be the Above Sea Level elevation
+            # Ensure you use the correct value on self.env.elevation, otherwise
+            # the trajectory path can be offset from ground
+            coords = [
+                (
+                    self.longitude.get_value_opt(t),
+                    self.latitude.get_value_opt(t),
+                    self.z.get_value_opt(t),
+                )
+                for t in time_points
+            ]
+            trajectory.coords = coords
+            trajectory.altitudemode = simplekml.AltitudeMode.absolute
+        # Modify style of trajectory linestring
+        trajectory.style.linestyle.color = color
+        trajectory.style.polystyle.color = color
+        if extrude:
+            trajectory.extrude = 1
+        # Save the KML
+        kml.save(file_name)
+        print("File ", file_name, " saved with success!")
 
     def info(self):
         """Prints out a summary of the data available about the Flight."""