MNT: Allow for encoding customization of MonteCarlo.

DEV: fix CHANGELOG

MNT: reposition barometric height as env json output.

MNT: Allow for encoding customization of MonteCarlo.

Author: phmbressan

CHANGELOG.md

@@ -41,6 +41,7 @@ Attention: The newest changes should be on top -->
 - ENH: Expansion of Encoders Implementation for Full Flights. [#679](https://github.com/RocketPy-Team/RocketPy/pull/679)
 
 
+
 ### Changed
 
 - MNT: move piecewise functions to separate file [#746](https://github.com/RocketPy-Team/RocketPy/pull/746)

docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example.inputs.txt

@@ -1,20 +1,21 @@
 """Defines a custom JSON encoder for RocketPy objects."""
 
-import base64
 import json
 from datetime import datetime
 from importlib import import_module
 
-import dill
 import numpy as np
 
+from rocketpy.mathutils.function import Function
+
 
 class RocketPyEncoder(json.JSONEncoder):
     """Custom JSON encoder for RocketPy objects. It defines how to encode
     different types of objects to a JSON supported format."""
 
     def __init__(self, *args, **kwargs):
         self.include_outputs = kwargs.pop("include_outputs", False)
+        self.include_function_data = kwargs.pop("include_function_data", True)
         super().__init__(*args, **kwargs)
 
     def default(self, o):
@@ -43,6 +44,13 @@ def default(self, o):
             return [o.year, o.month, o.day, o.hour]
         elif hasattr(o, "__iter__") and not isinstance(o, str):
             return list(o)
+        elif isinstance(o, Function):
+            if not self.include_function_data:
+                return str(o)
+            else:
+                encoding = o.to_dict(self.include_outputs)
+                encoding["signature"] = get_class_signature(o)
+                return encoding
         elif hasattr(o, "to_dict"):
             encoding = o.to_dict(self.include_outputs)
             encoding = remove_circular_references(encoding)
@@ -155,39 +163,3 @@ def remove_circular_references(obj_dict):
     obj_dict.pop("plots", None)
 
     return obj_dict
-
-
-def to_hex_encode(obj, encoder=base64.b85encode):
-    """Converts an object to hex representation using dill.
-
-    Parameters
-    ----------
-    obj : object
-        Object to be converted to hex.
-    encoder : callable, optional
-        Function to encode the bytes. Default is base64.b85encode.
-
-    Returns
-    -------
-    bytes
-        Object converted to bytes.
-    """
-    return encoder(dill.dumps(obj)).hex()
-
-
-def from_hex_decode(obj_bytes, decoder=base64.b85decode):
-    """Converts an object from hex representation using dill.
-
-    Parameters
-    ----------
-    obj_bytes : str
-        Hex string to be converted to object.
-    decoder : callable, optional
-        Function to decode the bytes. Default is base64.b85decode.
-
-    Returns
-    -------
-    object
-        Object converted from bytes.
-    """
-    return dill.loads(decoder(bytes.fromhex(obj_bytes)))

docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example.kml

@@ -2766,7 +2766,6 @@ def to_dict(self, include_outputs=False):
             "max_expected_height": self.max_expected_height,
             "atmospheric_model_type": self.atmospheric_model_type,
             "pressure": self.pressure,
-            "barometric_height": self.barometric_height,
             "temperature": self.temperature,
             "wind_velocity_x": self.wind_velocity_x,
             "wind_velocity_y": self.wind_velocity_y,
@@ -2777,6 +2776,7 @@ def to_dict(self, include_outputs=False):
 
         if include_outputs:
             env_dict["density"] = self.density
+            env_dict["barometric_height"] = self.barometric_height
             env_dict["speed_of_sound"] = self.speed_of_sound
             env_dict["dynamic_viscosity"] = self.dynamic_viscosity
 
@@ -2808,7 +2808,6 @@ def from_dict(cls, data):  # pylint: disable=too-many-statements
             )
         else:
             env.__set_pressure_function(data["pressure"])
-            env.__set_barometric_height_function(data["barometric_height"])
             env.__set_temperature_function(data["temperature"])
             env.__set_wind_velocity_x_function(data["wind_velocity_x"])
             env.__set_wind_velocity_y_function(data["wind_velocity_y"])
@@ -2818,7 +2817,7 @@ def from_dict(cls, data):  # pylint: disable=too-many-statements
             env.elevation = data["elevation"]
             env.max_expected_height = data["max_expected_height"]
 
-            if atmospheric_model in ["windy", "forecast", "reanalysis", "ensemble"]:
+            if atmospheric_model in ("windy", "forecast", "reanalysis", "ensemble"):
                 env.atmospheric_model_init_date = data["atmospheric_model_init_date"]
                 env.atmospheric_model_end_date = data["atmospheric_model_end_date"]
                 env.atmospheric_model_interval = data["atmospheric_model_interval"]
@@ -2838,6 +2837,7 @@ def from_dict(cls, data):  # pylint: disable=too-many-statements
                 env.wind_speed_ensemble = data["wind_speed_ensemble"]
                 env.num_ensemble_members = data["num_ensemble_members"]
 
+            env.__reset_barometric_height_function()
             env.calculate_density_profile()
             env.calculate_speed_of_sound_profile()
             env.calculate_dynamic_viscosity()

docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example.outputs.txt

@@ -22,9 +22,9 @@
     RBFInterpolator,
 )
 
-from ..plots.plot_helpers import show_or_save_plot
+from rocketpy.tools import from_hex_decode, to_hex_encode
 
-from rocketpy._encoders import from_hex_decode, to_hex_encode
+from ..plots.plot_helpers import show_or_save_plot
 
 # Numpy 1.x compatibility,
 # TODO: remove these lines when all dependencies support numpy>=2.0.0

docs/notebooks/monte_carlo_analysis/monte_carlo_class_usage.ipynb

@@ -2,7 +2,7 @@
 
 import numpy as np
 
-from rocketpy._encoders import from_hex_decode, to_hex_encode
+from rocketpy.tools import from_hex_decode, to_hex_encode
 
 from ..mathutils.function import Function
 from ..prints.parachute_prints import _ParachutePrints

rocketpy/_encoders.py

@@ -173,7 +173,7 @@ def __init__(
 
     # pylint: disable=consider-using-with
     def simulate(
-        self, number_of_simulations, append=False
+        self, number_of_simulations, append=False, **kwargs
     ):  # pylint: disable=too-many-statements
         """
         Runs the Monte Carlo simulation and saves all data.
@@ -185,6 +185,17 @@ def simulate(
         append : bool, optional
             If True, the results will be appended to the existing files. If
             False, the files will be overwritten. Default is False.
+        kwargs : dict
+            Custom arguments for simulation export of the ``inputs`` file. Options
+            are:
+
+                * ``include_outputs``: whether to also include outputs data of the
+                  simulation. Default is ``False``.
+
+                * ``include_function_data``: whether to include ``rocketpy.Function``
+                  results into the export. Default is ``True``.
+
+            See ``rocketpy._encoders.RocketPyEncoder`` for more information.
 
         Returns
         -------
@@ -204,6 +215,7 @@ def simulate(
         overwritten. Make sure to save the files with the results before
         running the simulation again with `append=False`.
         """
+        self._export_config = kwargs
         # Create data files for inputs, outputs and error logging
         open_mode = "a" if append else "w"
         input_file = open(self._input_file, open_mode, encoding="utf-8")
@@ -224,11 +236,21 @@ def simulate(
                 self.__run_single_simulation(input_file, output_file)
         except KeyboardInterrupt:
             print("Keyboard Interrupt, files saved.")
-            error_file.write(json.dumps(self._inputs_dict, cls=RocketPyEncoder) + "\n")
+            error_file.write(
+                json.dumps(
+                    self._inputs_dict, cls=RocketPyEncoder, **self._export_config
+                )
+                + "\n"
+            )
             self.__close_files(input_file, output_file, error_file)
         except Exception as error:
             print(f"Error on iteration {self.__iteration_count}: {error}")
-            error_file.write(json.dumps(self._inputs_dict, cls=RocketPyEncoder) + "\n")
+            error_file.write(
+                json.dumps(
+                    self._inputs_dict, cls=RocketPyEncoder, **self._export_config
+                )
+                + "\n"
+            )
             self.__close_files(input_file, output_file, error_file)
             raise error
         finally:
@@ -393,8 +415,12 @@ def __export_flight_data(
                     ) from e
             results = results | additional_exports
 
-        input_file.write(json.dumps(inputs_dict, cls=RocketPyEncoder) + "\n")
-        output_file.write(json.dumps(results, cls=RocketPyEncoder) + "\n")
+        input_file.write(
+            json.dumps(inputs_dict, cls=RocketPyEncoder, **self._export_config) + "\n"
+        )
+        output_file.write(
+            json.dumps(results, cls=RocketPyEncoder, **self._export_config) + "\n"
+        )
 
     def __check_export_list(self, export_list):
         """