rocketpy 1.3.0__tar.gz → 1.4.0__tar.gz

{rocketpy-1.3.0/rocketpy.egg-info → rocketpy-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rocketpy
-Version: 1.3.0
+Version: 1.4.0
 Summary: Advanced 6-DOF trajectory simulation for High-Power Rocketry.
 Author-email: Giovani Hidalgo Ceotto <ghceotto@gmail.com>
 Project-URL: homepage, https://rocketpy.org/
@@ -9,9 +9,16 @@ Project-URL: repository, https://github.com/RocketPy-Team/RocketPy
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: numpy>=1.13
+Requires-Dist: scipy>=1.0
+Requires-Dist: matplotlib>=3.0
+Requires-Dist: netCDF4>=1.6.4
+Requires-Dist: requests
+Requires-Dist: pytz
+Requires-Dist: simplekml
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-coverage; extra == "tests"

{rocketpy-1.3.0 → rocketpy-1.4.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "rocketpy"
-version = "1.3.0"
+version = "1.4.0"
 description="Advanced 6-DOF trajectory simulation for High-Power Rocketry."
 dynamic = ["dependencies"]
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 authors = [
   {name = "Giovani Hidalgo Ceotto", email = "ghceotto@gmail.com"}
 ]
@@ -20,11 +20,11 @@ documentation = "https://docs.rocketpy.org/"
 repository = "https://github.com/RocketPy-Team/RocketPy"
 
 [build-system]
-requires = ["setuptools"]
+requires = ["setuptools>=42", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools]
-py-modules = ['rocketpy']
+packages = { find = { where = ["."], include = ["rocketpy*"] } }
 
 [tool.setuptools.dynamic]
 dependencies = { file = ["requirements.txt"] }

rocketpy-1.4.0/requirements.txt

@@ -0,0 +1,7 @@
+numpy>=1.13
+scipy>=1.0
+matplotlib>=3.0
+netCDF4>=1.6.4
+requests
+pytz
+simplekml

rocketpy-1.4.0/rocketpy/__init__.py

@@ -0,0 +1,51 @@
+from .control import _Controller
+from .environment import Environment, EnvironmentAnalysis
+from .mathutils import (
+    Function,
+    PiecewiseFunction,
+    funcify_method,
+    reset_funcified_methods,
+)
+from .motors import (
+    CylindricalTank,
+    EmptyMotor,
+    Fluid,
+    GenericMotor,
+    HybridMotor,
+    LevelBasedTank,
+    LiquidMotor,
+    MassBasedTank,
+    MassFlowRateBasedTank,
+    Motor,
+    SolidMotor,
+    SphericalTank,
+    Tank,
+    TankGeometry,
+    UllageBasedTank,
+)
+from .plots.compare import Compare, CompareFlights
+from .rocket import (
+    AeroSurface,
+    AirBrakes,
+    Components,
+    EllipticalFins,
+    Fins,
+    NoseCone,
+    Parachute,
+    RailButtons,
+    Rocket,
+    Tail,
+    TrapezoidalFins,
+)
+from .simulation import Flight, MonteCarlo
+from .stochastic import (
+    StochasticEllipticalFins,
+    StochasticEnvironment,
+    StochasticFlight,
+    StochasticNoseCone,
+    StochasticParachute,
+    StochasticRocket,
+    StochasticSolidMotor,
+    StochasticTail,
+    StochasticTrapezoidalFins,
+)

rocketpy-1.4.0/rocketpy/_encoders.py

@@ -0,0 +1,43 @@
+"""Defines a custom JSON encoder for RocketPy objects."""
+
+import json
+import types
+
+import numpy as np
+
+from rocketpy.mathutils.function import Function
+
+
+class RocketPyEncoder(json.JSONEncoder):
+    """NOTE: This is still under construction, please don't use it yet."""
+
+    def default(self, o):
+        if isinstance(
+            o,
+            (
+                np.int_,
+                np.intc,
+                np.intp,
+                np.int8,
+                np.int16,
+                np.int32,
+                np.int64,
+                np.uint8,
+                np.uint16,
+                np.uint32,
+                np.uint64,
+            ),
+        ):
+            return int(o)
+        elif isinstance(o, (np.float16, np.float32, np.float64)):
+            return float(o)
+        elif isinstance(o, np.ndarray):
+            return o.tolist()
+        elif hasattr(o, "to_dict"):
+            return o.to_dict()
+        # elif isinstance(o, Function):
+        #     return o.__dict__()
+        elif isinstance(o, (Function, types.FunctionType)):
+            return repr(o)
+        else:
+            return json.JSONEncoder.default(self, o)

rocketpy-1.4.0/rocketpy/control/__init__.py

@@ -0,0 +1 @@
+from .controller import _Controller

rocketpy-1.4.0/rocketpy/control/controller.py

@@ -0,0 +1,132 @@
+from ..prints.controller_prints import _ControllerPrints
+
+
+class _Controller:
+    """A class for storing and running controllers on a rocket. Controllers
+    have a controller function that is called at a specified sampling rate
+    during the simulation. The controller function can access and modify
+    the objects that are passed to it. The controller function also stores the
+    variables of interest in the objects that are passed to it."""
+
+    def __init__(
+        self,
+        interactive_objects,
+        controller_function,
+        sampling_rate,
+        initial_observed_variables=None,
+        name="Controller",
+    ):
+        """Initialize the class with the controller function and the objects to
+        be observed.
+
+        Parameters
+        ----------
+        interactive_objects : list or object
+            A collection of objects that the controller function can access and
+            potentially modify. This can be either a list of objects or a single
+            object. The objects listed here are provided to the controller function
+            as the last argument, maintaining the order specified in this list if
+            it's a list. The controller function gains the ability to interact with
+            and make adjustments to these objects during its execution.
+        controller_function : function, callable
+            An user-defined function responsible for controlling the simulation.
+            This function is expected to take the following arguments, in order:
+
+            1. `time` (float): The current simulation time in seconds.
+            2. `sampling_rate` (float): The rate at which the controller
+               function is called, measured in Hertz (Hz).
+            3. `state` (list): The state vector of the simulation, structured as
+               `[x, y, z, vx, vy, vz, e0, e1, e2, e3, wx, wy, wz]`.
+            4. `state_history` (list): A record of the rocket's state at each
+               step throughout the simulation. The state_history is organized as
+               a list of lists, with each sublist containing a state vector. The
+               last item in the list always corresponds to the previous state
+               vector, providing a chronological sequence of the rocket's
+               evolving states.
+            5. `observed_variables` (list): A list containing the variables that
+               the controller function returns. The return of each controller
+               function call is appended to the observed_variables list. The
+               initial value in the first step of the simulation of this list is
+               provided by the `initial_observed_variables` argument.
+            6. `interactive_objects` (list): A list containing the objects that
+               the controller function can interact with. The objects are
+               listed in the same order as they are provided in the
+               `interactive_objects`.
+
+            This function will be called during the simulation at the specified
+            sampling rate. The function should evaluate and change the interactive
+            objects as needed. The function return statement can be used to save
+            relevant information in the `observed_variables` list.
+
+            .. note:: The function will be called according to the sampling rate
+            specified.
+        sampling_rate : float
+            The sampling rate of the controller function in Hertz (Hz). This
+            means that the controller function will be called every
+            `1/sampling_rate` seconds.
+        initial_observed_variables : list, optional
+            A list of the initial values of the variables that the controller
+            function returns. This list is used to initialize the
+            `observed_variables` argument of the controller function. The
+            default value is None, which initializes the list as an empty list.
+        name : str
+            The name of the controller. This will be used for printing and
+            plotting.
+
+        Returns
+        -------
+        None
+        """
+        self.interactive_objects = interactive_objects
+        self.controller_function = controller_function
+        self.sampling_rate = sampling_rate
+        self.name = name
+        self.prints = _ControllerPrints(self)
+
+        if initial_observed_variables is not None:
+            self.observed_variables = [initial_observed_variables]
+        else:
+            self.observed_variables = []
+
+    def __call__(self, time, state_vector, state_history):
+        """Call the controller function. This is used by the simulation class.
+
+        Parameters
+        ----------
+        time : float
+            The time of the simulation in seconds.
+        state_vector : list
+            The state vector of the simulation, which is defined as:
+
+            `[x, y, z, vx, vy, vz, e0, e1, e2, e3, wx, wy, wz]`.
+        state_history : list
+            A list containing the state history of the simulation. The state
+            history is a list of every state vector of every step of the
+            simulation. The state history is a list of lists, where each
+            sublist is a state vector and is ordered from oldest to newest.
+
+        Returns
+        -------
+        None
+        """
+        observed_variables = self.controller_function(
+            time,
+            self.sampling_rate,
+            state_vector,
+            state_history,
+            self.observed_variables,
+            self.interactive_objects,
+        )
+        if observed_variables is not None:
+            self.observed_variables.append(observed_variables)
+
+    def __str__(self):
+        return f"Controller '{self.name}' with sampling rate {self.sampling_rate} Hz."
+
+    def info(self):
+        """Prints out summarized information about the controller."""
+        self.prints.all()
+
+    def all_info(self):
+        """Prints out all information about the controller."""
+        self.info()

rocketpy-1.4.0/rocketpy/environment/__init__.py

@@ -0,0 +1,2 @@
+from .environment import Environment
+from .environment_analysis import EnvironmentAnalysis