From e403872109dcbd1851555808817c4b86e51c31b1 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 1 Apr 2024 18:51:21 +0200 Subject: [PATCH 01/77] ENH: sensors class --- rocketpy/sensors/__init__.py | 1 + rocketpy/sensors/sensors.py | 233 +++++++++++++++++++++++++++++++++++ 2 files changed, 234 insertions(+) create mode 100644 rocketpy/sensors/__init__.py create mode 100644 rocketpy/sensors/sensors.py diff --git a/rocketpy/sensors/__init__.py b/rocketpy/sensors/__init__.py new file mode 100644 index 000000000..413a784a8 --- /dev/null +++ b/rocketpy/sensors/__init__.py @@ -0,0 +1 @@ +from .sensors import Sensors diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py new file mode 100644 index 000000000..8ba08317b --- /dev/null +++ b/rocketpy/sensors/sensors.py @@ -0,0 +1,233 @@ +from abc import ABC, abstractmethod +from rocketpy.mathutils.vector_matrix import Matrix, Vector +import numpy as np + + +class Sensors(ABC): + """ + Abstract class for sensors + """ + + def __init__( + self, + sampling_rate, + orientation=(0, 0, 0), + measurement_range=np.inf, + resolution=0, + noise_density=0, + random_walk=0, + constant_bias=0, + operating_temperature=25, + temperature_bias=0, + temperature_scale_factor=0, + cross_axis_sensitivity=0, + name="Sensor", + ): + """ + Initialize the accelerometer sensor + + Parameters + ---------- + sampling_rate : float + Sample rate of the sensor + orientation : tuple, list, optional + Orientation of the sensor in the rocket. The orientation can be + given as: + - A list of length 3, where the elements are the Euler angles for + the rotation roll (φ), pitch (θ) and yaw (ψ) in radians. The + standard rotation sequence is z-y-x (3-2-1) is used, meaning the + sensor is first rotated by ψ around the z axis, then by θ around + the new y axis and finally by φ around the new x axis. + - A list of lists (matrix) of shape 3x3, representing the rotation + matrix from the sensor frame to the rocket frame. The sensor frame + of reference is defined as to have z axis along the sensor's normal + vector pointing upwards, x and y axes perpendicular to the z axis + and each other. + The rocket frame of reference is defined as to have z axis + along the rocket's axis of symmetry pointing upwards, x and y axes + perpendicular to the z axis and each other. Default is (0, 0, 0), + meaning the sensor is aligned with the rocket's axis of symmetry. + measurement_range : float, tuple, optional + The measurement range of the sensor in the sensor units. If a float, + the same range is applied both for positive and negative values. If + a tuple, the first value is the positive range and the second value + is the negative range. Default is np.inf. + resolution : float, optional + The resolution of the sensor in sensor units/LSB. Default is 0, + meaning no quantization is applied. + noise_density : float, optional + The noise density of the sensor in sensor units/√Hz. Sometimes + called "white noise drift", "angular random walk" for gyroscopes, + "velocity random walk" for the accelerometers or + "(rate) noise density". Default is 0, meaning no noise is applied. + random_walk : float, optional + The random walk of the sensor in sensor units/√Hz. Sometimes called + "bias (in)stability" or "bias drift"". Default is 0, meaning no + random walk is applied. + constant_bias : float, optional + The constant bias of the sensor in sensor units. Default is 0, + meaning no constant bias is applied. + operating_temperature : float, optional + The operating temperature of the sensor in degrees Celsius. At 25°C, + the temperature bias and scale factor are 0. Default is 25. + temperature_bias : float, optional + The temperature bias of the sensor in sensor units/°C. Default is 0, + meaning no temperature bias is applied. + temperature_scale_factor : float, optional + The temperature scale factor of the sensor in %/°C. Default is 0, + meaning no temperature scale factor is applied. + cross_axis_sensitivity : float, optional + Skewness of the sensor's axes in percentage. Default is 0, meaning + no cross-axis sensitivity is applied. + name : str, optional + The name of the sensor. Default is "Sensor". + + Returns + ------- + None + """ + self.sampling_rate = sampling_rate + self.orientation = orientation + self.resolution = resolution + self.noise_density = noise_density * Vector([1, 1, 1]) + self.random_walk = random_walk * Vector([1, 1, 1]) + self.constant_bias = constant_bias * Vector([1, 1, 1]) + self.operating_temperature = operating_temperature + self.temperature_bias = temperature_bias * Vector([1, 1, 1]) + self.temperature_scale_factor = temperature_scale_factor * Vector([1, 1, 1]) + self.cross_axis_sensitivity = cross_axis_sensitivity + self.name = name + self._random_walk_drift = Vector([0, 0, 0]) + self.measurement = None + self.measured_values = [] # change to data + + # handle measurement range + if isinstance(measurement_range, (tuple, list)): + if len(measurement_range) != 2: + raise ValueError("Invalid measurement range format") + self.measurement_range = measurement_range + elif isinstance(measurement_range, (int, float)): + self.measurement_range = (-measurement_range, measurement_range) + else: + raise ValueError("Invalid measurement range format") + + # rotation matrix and normal vector + if any(isinstance(row, (tuple, list)) for row in orientation): # matrix + self.rotation_matrix = Matrix(orientation) + elif len(orientation) == 3: # euler angles + self.rotation_matrix = Matrix.transformation_euler_angles(*orientation) + else: + raise ValueError("Invalid orientation format") + self.normal_vector = Vector( + [ + self.rotation_matrix[0][2], + self.rotation_matrix[1][2], + self.rotation_matrix[2][2], + ] + ).unit_vector + + # cross axis sensitivity matrix + _cross_axis_matrix = 0.01 * Matrix( + [ + [100, self.cross_axis_sensitivity, self.cross_axis_sensitivity], + [self.cross_axis_sensitivity, 100, self.cross_axis_sensitivity], + [self.cross_axis_sensitivity, self.cross_axis_sensitivity, 100], + ] + ) + + # compute total rotation matrix given cross axis sensitivity + self._total_rotation_matrix = self.rotation_matrix @ _cross_axis_matrix + + def __repr__(self): + return f"{self.type} sensor, orientation: {self.orientation}" + + def __call__(self, *args, **kwds): + return self.measure(*args, **kwds) + + @abstractmethod + def measure(self, *args, **kwargs): + pass + + @abstractmethod + def export_measured_values(self): + pass + + def quantize(self, value): + """ + Quantize the sensor measurement + + Parameters + ---------- + value : float + The value to quantize + + Returns + ------- + float + The quantized value + """ + x = min(max(value.x, self.measurement_range[0]), self.measurement_range[1]) + y = min(max(value.y, self.measurement_range[0]), self.measurement_range[1]) + z = min(max(value.z, self.measurement_range[0]), self.measurement_range[1]) + if self.resolution != 0: + x = round(x / self.resolution) * self.resolution + y = round(y / self.resolution) * self.resolution + z = round(z / self.resolution) * self.resolution + return Vector([x, y, z]) + + def apply_noise(self, value): + """ + Add noise to the sensor measurement + + Parameters + ---------- + value : float + The value to add noise to + + Returns + ------- + float + The value with added noise + """ + # white noise + white_noise = ( + np.random.normal(0, 1) * self.noise_density * self.sampling_rate**0.5 + ) + + # random walk + self._random_walk_drift = ( + self._random_walk_drift + + np.random.normal(0, 1) * self.random_walk / self.sampling_rate**0.5 + ) + + # add noise + value += white_noise + self._random_walk_drift + self.constant_bias + + return value + + def apply_temperature_drift(self, value): + """ + Apply temperature drift to the sensor measurement + + Parameters + ---------- + value : float + The value to apply temperature drift to + + Returns + ------- + float + The value with applied temperature drift + """ + # temperature drift + value += (self.operating_temperature - 25) * self.temperature_bias + # temperature scale factor + scale_factor = ( + Vector([1, 1, 1]) + + (self.operating_temperature - 25) / 100 * self.temperature_scale_factor + ) + value.x *= scale_factor.x + value.y *= scale_factor.y + value.z *= scale_factor.z + + return value From 6cd3598fd8827523f472c0921123cdc418ad3011 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 1 Apr 2024 19:09:52 +0200 Subject: [PATCH 02/77] ENH: add accelerometer and gyroscope classes --- rocketpy/__init__.py | 1 + rocketpy/sensors/__init__.py | 2 + rocketpy/sensors/accelerometer.py | 184 ++++++++++++++++++++++++++ rocketpy/sensors/gyroscope.py | 212 ++++++++++++++++++++++++++++++ 4 files changed, 399 insertions(+) create mode 100644 rocketpy/sensors/accelerometer.py create mode 100644 rocketpy/sensors/gyroscope.py diff --git a/rocketpy/__init__.py b/rocketpy/__init__.py index 10404b619..fe55dda41 100644 --- a/rocketpy/__init__.py +++ b/rocketpy/__init__.py @@ -37,4 +37,5 @@ Tail, TrapezoidalFins, ) +from .sensors import Accelerometer, Gyroscope, Sensors from .simulation import Flight diff --git a/rocketpy/sensors/__init__.py b/rocketpy/sensors/__init__.py index 413a784a8..044deec43 100644 --- a/rocketpy/sensors/__init__.py +++ b/rocketpy/sensors/__init__.py @@ -1 +1,3 @@ from .sensors import Sensors +from .gyroscope import Gyroscope +from .accelerometer import Accelerometer diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py new file mode 100644 index 000000000..1774fde76 --- /dev/null +++ b/rocketpy/sensors/accelerometer.py @@ -0,0 +1,184 @@ +import numpy as np +from ..mathutils.vector_matrix import Matrix, Vector +from ..sensors.sensors import Sensors +from ..prints.sensors_prints import _AccelerometerPrints + + +class Accelerometer(Sensors): + """ + Class for the accelerometer sensor + """ + + def __init__( + self, + sampling_rate, + orientation=(0, 0, 0), + measurement_range=np.inf, + resolution=0, + noise_density=0, + random_walk=0, + constant_bias=0, + operating_temperature=25, + temperature_bias=0, + temperature_scale_factor=0, + cross_axis_sensitivity=0, + consider_gravity=False, + name="Accelerometer", + ): + """ + Initialize the accelerometer sensor + + Parameters + ---------- + sampling_rate : float + Sample rate of the sensor + orientation : tuple, list, optional + Orientation of the sensor in the rocket. The orientation can be + given as: + - A list of length 3, where the elements are the Euler angles for + the rotation roll (φ), pitch (θ) and yaw (ψ) in radians. The + standard rotation sequence is z-y-x (3-2-1) is used, meaning the + sensor is first rotated by ψ around the z axis, then by θ around + the new y axis and finally by φ around the new x axis. + - A list of lists (matrix) of shape 3x3, representing the rotation + matrix from the sensor frame to the rocket frame. The sensor frame + of reference is defined as to have z axis along the sensor's normal + vector pointing upwards, x and y axes perpendicular to the z axis + and each other. + The rocket frame of reference is defined as to have z axis + along the rocket's axis of symmetry pointing upwards, x and y axes + perpendicular to the z axis and each other. A rotation around the x + axis configures a pitch, around the y axis a yaw and around z axis a + roll. Default is (0, 0, 0), meaning the sensor is aligned with all + of the rocket's axis. + measurement_range : float, tuple, optional + The measurement range of the sensor in the m/s^2. If a float, the + same range is applied both for positive and negative values. If a + tuple, the first value is the positive range and the second value is + the negative range. Default is np.inf. + resolution : float, optional + The resolution of the sensor in m/s^2/LSB. Default is 0, meaning no + quantization is applied. + noise_density : float, optional + The noise density of the sensor in m/s^2/√Hz. Sometimes called + "white noise drift", "angular random walk" for gyroscopes, "velocity + random walk" for the accelerometers or "(rate) noise density". + Default is 0, meaning no noise is applied. + random_walk : float, optional + The random walk of the sensor in m/s^2/√Hz. Sometimes called "bias + (in)stability" or "bias drift"". Default is 0, meaning no random + walk is applied. + constant_bias : float, optional + The constant bias of the sensor in m/s^2. Default is 0, meaning no + constant bias is applied. + operating_temperature : float, optional + The operating temperature of the sensor in degrees Celsius. At 25°C, + the temperature bias and scale factor are 0. Default is 25. + temperature_bias : float, optional + The temperature bias of the sensor in m/s^2/°C. Default is 0, + meaning no temperature bias is applied. + temperature_scale_factor : float, optional + The temperature scale factor of the sensor in %/°C. Default is 0, + meaning no temperature scale factor is applied. + cross_axis_sensitivity : float, optional + Skewness of the sensor's axes in percentage. Default is 0, meaning + no cross-axis sensitivity is applied. + consider_gravity : bool, optional + If True, the sensor will consider the effect of gravity on the + acceleration. Default is False. + name : str, optional + The name of the sensor. Default is "Accelerometer". + + Returns + ------- + None + """ + self.type = "Accelerometer" + self.consider_gravity = consider_gravity + self.prints = _AccelerometerPrints(self) + super().__init__( + sampling_rate, + orientation, + measurement_range=measurement_range, + resolution=resolution, + noise_density=noise_density, + random_walk=random_walk, + constant_bias=constant_bias, + operating_temperature=operating_temperature, + temperature_bias=temperature_bias, + temperature_scale_factor=temperature_scale_factor, + cross_axis_sensitivity=cross_axis_sensitivity, + name=name, + ) + + def measure(self, t, u, u_dot, relative_position, gravity, *args): + """ + Measure the acceleration of the rocket + """ + # Linear acceleration of rocket cdm in inertial frame + gravity = ( + Vector([0, 0, -gravity]) if self.consider_gravity else Vector([0, 0, 0]) + ) + a_I = Vector(u_dot[3:6]) + gravity + + # Vector from rocket cdm to sensor in rocket frame + r = relative_position + + # Angular velocity and accel of rocket + omega = Vector(u[10:13]) + omega_dot = Vector(u_dot[10:13]) + + # Measured acceleration at sensor position in inertial frame + A = ( + a_I + + Vector.cross(omega_dot, r) + + Vector.cross(omega, Vector.cross(omega, r)) + ) + # Transform to sensor frame + inertial_to_sensor = self._total_rotation_matrix @ Matrix.transformation( + u[6:10] + ) + A = inertial_to_sensor @ A + + # Apply noise + bias and quatize + A = self.apply_noise(A) + A = self.apply_temperature_drift(A) + A = self.quantize(A) + + self.measurement = tuple([*A]) + self.measured_values.append((t, *A)) + + def export_measured_values(self, filename, format="csv"): + """ + Export the measured values to a file + + Parameters + ---------- + filename : str + Name of the file to export the values to + format : str + Format of the file to export the values to. Options are "csv" and + "json". Default is "csv". + + Returns + ------- + None + """ + if format == "csv": + with open(filename, "w") as f: + f.write("t,ax,ay,az\n") + for t, ax, ay, az in self.measured_values: + f.write(f"{t},{ax},{ay},{az}\n") + elif format == "json": + import json + + data = {"t": [], "ax": [], "ay": [], "az": []} + for t, ax, ay, az in self.measured_values: + data["t"].append(t) + data["ax"].append(ax) + data["ay"].append(ay) + data["az"].append(az) + with open(filename, "w") as f: + json.dump(data, f) + else: + raise ValueError("Invalid format") diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py new file mode 100644 index 000000000..21543e99c --- /dev/null +++ b/rocketpy/sensors/gyroscope.py @@ -0,0 +1,212 @@ +import numpy as np +from ..mathutils.vector_matrix import Matrix, Vector +from ..sensors.sensors import Sensors +from ..prints.sensors_prints import _GyroscopePrints + + +class Gyroscope(Sensors): + """ + Class for the gyroscope sensor + """ + + def __init__( + self, + sampling_rate, + orientation=(0, 0, 0), + measurement_range=np.inf, + resolution=0, + noise_density=0, + random_walk=0, + constant_bias=0, + operating_temperature=25, + temperature_bias=0, + temperature_scale_factor=0, + cross_axis_sensitivity=0, + acceleration_sensitivity=0, + name="Gyroscope", + ): + """ + Initialize the gyroscope sensor + + Parameters + ---------- + sampling_rate : float + Sample rate of the sensor + orientation : tuple, list, optional + Orientation of the sensor in the rocket. The orientation can be + given as: + - A list of length 3, where the elements are the Euler angles for + the rotation roll (φ), pitch (θ) and yaw (ψ) in radians. The + standard rotation sequence is z-y-x (3-2-1) is used, meaning the + sensor is first rotated by ψ around the z axis, then by θ around + the new y axis and finally by φ around the new x axis. + - A list of lists (matrix) of shape 3x3, representing the rotation + matrix from the sensor frame to the rocket frame. The sensor frame + of reference is defined as to have z axis along the sensor's normal + vector pointing upwards, x and y axes perpendicular to the z axis + and each other. + The rocket frame of reference is defined as to have z axis + along the rocket's axis of symmetry pointing upwards, x and y axes + perpendicular to the z axis and each other. Default is (0, 0, 0), + meaning the sensor is aligned with the rocket's axis of symmetry. + measurement_range : float, tuple, optional + The measurement range of the sensor in the rad/s. If a float, the + same range is applied both for positive and negative values. If a + tuple, the first value is the positive range and the second value is + the negative range. Default is np.inf. + resolution : float, optional + The resolution of the sensor in rad/s/LSB. Default is 0, meaning no + quantization is applied. + noise_density : float, optional + The noise density of the sensor in rad/s/√Hz. Sometimes called + "white noise drift", "angular random walk" for gyroscopes, "velocity + random walk" for the accelerometers or "(rate) noise density". + Default is 0, meaning no noise is applied. + random_walk : float, optional + The random walk of the sensor in rad/s/√Hz. Sometimes called "bias + (in)stability" or "bias drift"". Default is 0, meaning no random + walk is applied. + constant_bias : float, optional + The constant bias of the sensor in rad/s. Default is 0, meaning no + constant bias is applied. + operating_temperature : float, optional + The operating temperature of the sensor in degrees Celsius. At 25°C, + the temperature bias and scale factor are 0. Default is 25. + temperature_sensitivity : float, optional + The temperature bias of the sensor in rad/s/°C. Default is 0, + meaning no temperature bias is applied. + temperature_scale_factor : float, optional + The temperature scale factor of the sensor in %/°C. Default is 0, + meaning no temperature scale factor is applied. + cross_axis_sensitivity : float, optional + Skewness of the sensor's axes in percentage. Default is 0, meaning + no cross-axis sensitivity is applied. + acceleration_sensitivity : float, optional + Sensitivity of the sensor to linear acceleration in rad/s/g. Default + is 0, meaning no sensitivity to linear acceleration is applied. + + Returns + ------- + None + """ + self.type = "Gyroscope" + self.acceleration_sensitivity = acceleration_sensitivity + self.prints = _GyroscopePrints(self) + super().__init__( + sampling_rate, + orientation, + measurement_range=measurement_range, + resolution=resolution, + noise_density=noise_density, + random_walk=random_walk, + constant_bias=constant_bias, + operating_temperature=operating_temperature, + temperature_bias=temperature_bias, + temperature_scale_factor=temperature_scale_factor, + cross_axis_sensitivity=cross_axis_sensitivity, + name=name, + ) + + def measure(self, t, u, u_dot, relative_position, *args): + """ + Measure the angular velocity of the rocket + """ + # Angular velocity of the rocket in the rocket frame + omega = Vector(u[10:13]) + + # Transform to sensor frame + inertial_to_sensor = self._total_rotation_matrix @ Matrix.transformation( + u[6:10] + ) + W = inertial_to_sensor @ omega + + # Apply noise + bias + # Apply noise + bias and quatize + W = self.apply_noise(W) + W = self.apply_temperature_drift(W) + + # Apply acceleration sensitivity + if self.acceleration_sensitivity != 0 and self.acceleration_sensitivity != None: + W += self.apply_acceleration_sensitivity( + omega, u_dot, relative_position, inertial_to_sensor + ) + + W = self.quantize(W) + + self.measurement = tuple([*W]) + self.measured_values.append((t, *W)) + + def apply_acceleration_sensitivity( + self, omega, u_dot, relative_position, rotation_matrix + ): + """ + Apply acceleration sensitivity to the sensor measurement + + Parameters + ---------- + omega : Vector + The angular velocity to apply acceleration sensitivity to + cache : tuple + The cache of the rocket state + relative_position : Vector + The vector from the rocket's center of mass to the sensor in the + rocket frame + rotation_matrix : Matrix + The rotation matrix from the inertial frame to the sensor frame + + Returns + ------- + Vector + The angular velocity with applied acceleration sensitivity + """ + # Linear acceleration of rocket cdm in inertial frame + a_I = Vector(u_dot[3:6]) + + # Angular velocity and accel of rocket + omega_dot = Vector(u_dot[10:13]) + + # Acceleration felt in sensor + A = ( + a_I + + Vector.cross(omega_dot, relative_position) + + Vector.cross(omega, Vector.cross(omega, relative_position)) + ) + # Transform to sensor frame + A = rotation_matrix @ A + + return self.acceleration_sensitivity * A + + def export_measured_values(self, filename, format="csv"): + """ + Export the measured values to a file + + Parameters + ---------- + filename : str + Name of the file to export the values to + format : str + Format of the file to export the values to. Options are "csv" and + "json". Default is "csv". + + Returns + ------- + None + """ + if format == "csv": + with open(filename, "w") as f: + f.write("t,wx,wy,wz\n") + for t, wx, wy, wz in self.measured_values: + f.write(f"{t},{wx},{wy},{wz}\n") + elif format == "json": + import json + + data = {"t": [], "wx": [], "wy": [], "wz": []} + for t, wx, wy, wz in self.measured_values: + data["t"].append(t) + data["wx"].append(wx) + data["wy"].append(wy) + data["wz"].append(wz) + with open(filename, "w") as f: + json.dump(data, f) + else: + raise ValueError("Invalid format") From 3b817771ed458f1eedb9c8ad5a3fc115d39ef16d Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 1 Apr 2024 19:12:04 +0200 Subject: [PATCH 03/77] ENH: euler to quaternions tool function --- rocketpy/mathutils/vector_matrix.py | 28 +++++++++++++++++++++-- rocketpy/tools.py | 35 ++++++++++++++++++++++++++++- 2 files changed, 60 insertions(+), 3 deletions(-) diff --git a/rocketpy/mathutils/vector_matrix.py b/rocketpy/mathutils/vector_matrix.py index 50d827659..8263da2bf 100644 --- a/rocketpy/mathutils/vector_matrix.py +++ b/rocketpy/mathutils/vector_matrix.py @@ -1,7 +1,7 @@ from cmath import isclose from itertools import product -from rocketpy.tools import cached_property +from rocketpy.tools import cached_property, euler_to_quaternions class Vector: @@ -153,7 +153,10 @@ def __len__(self): @cached_property def unit_vector(self): """R3 vector with the same direction of self, but normalized.""" - return self / abs(self) + try: + return self / abs(self) + except ZeroDivisionError: + return self @cached_property def cross_matrix(self): @@ -984,6 +987,27 @@ def transformation(quaternion): ] ) + @staticmethod + def transformation_euler_angles(roll, pitch, yaw): + """Returns the transformation Matrix from frame B to frame A, where B + is rotated by the Euler angles roll, pitch and yaw with respect to A. + + Parameters + ---------- + roll : float + The roll angle in radians. + pitch : float + The pitch angle in radians. + yaw : float + The yaw angle in radians. + + Returns + ------- + Matrix + The transformation matrix from frame B to frame A. + """ + return Matrix.transformation(euler_to_quaternions(roll, pitch, yaw)) + if __name__ == "__main__": import doctest diff --git a/rocketpy/tools.py b/rocketpy/tools.py index 1ce588636..5666fdbdf 100644 --- a/rocketpy/tools.py +++ b/rocketpy/tools.py @@ -40,7 +40,7 @@ def __get__(self, instance, owner=None): def tuple_handler(value): """Transforms the input value into a tuple that - represents a range. If the input is an input or float, + represents a range. If the input is an int or float, the output is a tuple from zero to the input value. If the input is a tuple or list, the output is a tuple with the same range. @@ -472,6 +472,39 @@ def quaternions_to_nutation(e1, e2): return (180 / np.pi) * 2 * np.arcsin(-((e1**2 + e2**2) ** 0.5)) +def euler_to_quaternions(roll, pitch, yaw): + """Calculates the quaternions from the Euler angles in 3-2-1 sequence. + + Parameters + ---------- + roll : float + Euler angle due to roll (psi) in degrees + pitch : float + Euler angle due to pitch (theta) in degrees + yaw : float + Euler angle due to yaw (phi) in degrees + + Returns + ------- + tuple + Tuple containing the Euler parameters e0, e1, e2, e3 + """ + psi = np.radians(roll) + theta = np.radians(pitch) + phi = np.radians(yaw) + cr = np.cos(phi / 2) + sr = np.sin(phi / 2) + cp = np.cos(theta / 2) + sp = np.sin(theta / 2) + cy = np.cos(psi / 2) + sy = np.sin(psi / 2) + e0 = cr * cp * cy + sr * sp * sy + e1 = sr * cp * cy - cr * sp * sy + e2 = cr * sp * cy + sr * cp * sy + e3 = cr * cp * sy - sr * sp * cy + return e0, e1, e2, e3 + + if __name__ == "__main__": import doctest From 4c8aa136c4c379672d650c75b639a9ead61cee70 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 1 Apr 2024 19:54:28 +0200 Subject: [PATCH 04/77] ENH: add sensors to other classes --- rocketpy/control/controller.py | 52 ++++++++++++++++++- rocketpy/rocket/components.py | 19 ++++++- rocketpy/rocket/rocket.py | 37 +++++++++++--- rocketpy/simulation/flight.py | 91 ++++++++++++++++++++++++++++------ 4 files changed, 173 insertions(+), 26 deletions(-) diff --git a/rocketpy/control/controller.py b/rocketpy/control/controller.py index 81fc8b332..497161c22 100644 --- a/rocketpy/control/controller.py +++ b/rocketpy/control/controller.py @@ -1,3 +1,4 @@ +from inspect import signature from ..prints.controller_prints import _ControllerPrints @@ -52,6 +53,10 @@ def __init__( the controller function can interact with. The objects are listed in the same order as they are provided in the `interactive_objects`. + 7. `sensors` (list): A list of sensors that are attached to the + rocket. The most recent measurements of the sensors are provided + with the ``sensor.measurement`` attribute. The sensors are + listed in the same order as they are added to the rocket This function will be called during the simulation at the specified sampling rate. The function should evaluate and change the interactive @@ -78,7 +83,7 @@ def __init__( None """ self.interactive_objects = interactive_objects - self.controller_function = controller_function + self.controller_function = self.__init_controller_function(controller_function) self.sampling_rate = sampling_rate self.name = name self.prints = _ControllerPrints(self) @@ -88,7 +93,44 @@ def __init__( else: self.observed_variables = [] - def __call__(self, time, state_vector, state_history): + def __init_controller_function(self, controller_function): + """Checks number of arguments of the controller function and initializes + it with the correct number of arguments. This is a workaround to allow + the controller function to receive sensors without breaking changes""" + sig = signature(controller_function) + if len(sig.parameters) == 6: + + def new_controller_function( + time, + sampling_rate, + state_vector, + state_history, + observed_variables, + interactive_objects, + sensors, + ): + return controller_function( + time, + sampling_rate, + state_vector, + state_history, + observed_variables, + interactive_objects, + ) + + elif len(sig.parameters) == 7: + new_controller_function = controller_function + else: + raise ValueError( + "The controller function must have 6 or 7 arguments. " + "The arguments must be in the following order: " + "(time, sampling_rate, state_vector, state_history, " + "observed_variables, interactive_objects, sensors)." + "Sensors argument is optional." + ) + return new_controller_function + + def __call__(self, time, state_vector, state_history, sensors): """Call the controller function. This is used by the simulation class. Parameters @@ -104,6 +146,11 @@ def __call__(self, time, state_vector, state_history): 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. + sensors : list + A list of sensors that are attached to the rocket. The most recent + measurements of the sensors are provided with the + ``sensor.measurement`` attribute. The sensors are listed in the same + order as they are added to the rocket. Returns ------- @@ -116,6 +163,7 @@ def __call__(self, time, state_vector, state_history): state_history, self.observed_variables, self.interactive_objects, + sensors, ) if observed_variables is not None: self.observed_variables.append(observed_variables) diff --git a/rocketpy/rocket/components.py b/rocketpy/rocket/components.py index 1d1d33e56..4a033507c 100644 --- a/rocketpy/rocket/components.py +++ b/rocketpy/rocket/components.py @@ -23,6 +23,11 @@ def __init__(self): self.component_tuple = namedtuple("component_tuple", "component position") self._components = [] + # List of components and their positions to avoid extra for loops in + # simulation time + self._component_list = [] + self._position_list = [] + def __repr__(self): """Return a string representation of the Components instance.""" components_str = "\n".join( @@ -61,6 +66,8 @@ def add(self, component, position): ------- None """ + self._component_list.append(component) + self._position_list.append(position) self._components.append(self.component_tuple(component, position)) def get_by_type(self, component_type): @@ -103,6 +110,16 @@ def get_tuple_by_type(self, component_type): ] return component_type_list + def get_components(self): + """Return a list of all the components in the list of components. + + Returns + ------- + list + A list of all the components in the list of components. + """ + return self._component_list + def get_positions(self): """Return a list of all the positions of the components in the list of components. @@ -113,7 +130,7 @@ def get_positions(self): A list of all the positions of the components in the list of components. """ - return [c.position for c in self._components] + return self._position_list def remove(self, component): """Remove a component from the list of components. If more than one diff --git a/rocketpy/rocket/rocket.py b/rocketpy/rocket/rocket.py index aaf585091..cfc0ad3eb 100644 --- a/rocketpy/rocket/rocket.py +++ b/rocketpy/rocket/rocket.py @@ -4,6 +4,7 @@ from rocketpy.control.controller import _Controller from rocketpy.mathutils.function import Function +from rocketpy.mathutils.vector_matrix import Vector from rocketpy.motors.motor import EmptyMotor from rocketpy.plots.rocket_plots import _RocketPlots from rocketpy.prints.rocket_prints import _RocketPrints @@ -282,16 +283,11 @@ def __init__( self.thrust_eccentricity_y = 0 self.thrust_eccentricity_x = 0 - # Parachute, Aerodynamic and Rail buttons data initialization + # Parachute, Aerodynamic, Buttons, Controllers, Sensors data initialization self.parachutes = [] - - # Controllers data initialization self._controllers = [] - - # AirBrakes data initialization self.air_brakes = [] - - # Aerodynamic data initialization + self.sensors = Components() self.aerodynamic_surfaces = Components() self.rail_buttons = Components() @@ -1170,6 +1166,29 @@ def add_parachute( self.parachutes.append(parachute) return self.parachutes[-1] + def add_sensor(self, sensor, position, x_position=0, y_position=0): + """Adds a sensor to the rocket. + + Parameters + ---------- + sensor : Sensor + Sensor to be added to the rocket. + position : int, float, tuple + Position, in meters, of the sensor's coordinate system origin + relative to the user defined rocket coordinate system. + x_position : int, float, optional + Distance in meters by which the CM is to be translated in the x + direction relative to geometrical center line. Default is 0. + y_position : int, float, optional + Distance in meters by which the CM is to be translated in the y + direction relative to geometrical center line. Default is 0. + + Returns + ------- + None + """ + self.sensors.add(sensor, Vector([x_position, y_position, position])) + def add_air_brakes( self, drag_coefficient_curve, @@ -1238,6 +1257,10 @@ def add_air_brakes( the controller function can interact with. The objects are listed in the same order as they are provided in the `interactive_objects` + 7. `sensors` (list): A list of sensors that are attached to the + rocket. The most recent measurements of the sensors are provided + with the ``sensor.measurement`` attribute. The sensors are + listed in the same order as they are added to the rocket This function will be called during the simulation at the specified sampling rate. The function should evaluate and change the observed diff --git a/rocketpy/simulation/flight.py b/rocketpy/simulation/flight.py index 77632d2f2..dc922dba2 100644 --- a/rocketpy/simulation/flight.py +++ b/rocketpy/simulation/flight.py @@ -57,6 +57,8 @@ class Flight: Name of the flight. Flight._controllers : list List of controllers to be used during simulation. + Flight._component_sensors : list + List of sensors to be used during simulation. Flight.max_time : int, float Maximum simulation time allowed. Refers to physical time being simulated, not time taken to run simulation. @@ -594,6 +596,8 @@ def __init__( raise ValueError("Rail length must be a positive value.") self.parachutes = self.rocket.parachutes[:] self._controllers = self.rocket._controllers[:] + self._component_sensors = self.rocket.sensors + self._sensors_list = self.rocket.sensors.get_components() self.inclination = inclination self.heading = heading self.max_time = max_time @@ -662,17 +666,20 @@ def __init__( # Initialize phase time nodes phase.TimeNodes = TimeNodes() # Add first time node to permanent list - phase.TimeNodes.add_node(phase.t, [], []) + phase.TimeNodes.add_node(phase.t, [], [], []) # Add non-overshootable parachute time nodes if self.time_overshoot is False: phase.TimeNodes.add_parachutes( self.parachutes, phase.t, phase.time_bound ) + phase.TimeNodes.add_sensors( + self._component_sensors, phase.t, phase.time_bound + ) phase.TimeNodes.add_controllers( self._controllers, phase.t, phase.time_bound ) # Add lst time node to permanent list - phase.TimeNodes.add_node(phase.time_bound, [], []) + phase.TimeNodes.add_node(phase.time_bound, [], [], []) # Sort time nodes phase.TimeNodes.sort() # Merge equal time nodes @@ -702,8 +709,28 @@ def __init__( for callback in node.callbacks: callback(self) + for sensor, position in node._component_sensors: + relative_position = position - self.rocket._csys * Vector( + [0, 0, self.rocket.center_of_dry_mass_position] + ) + u_dot = phase.derivative( + self.t, self.y_sol + ) # calling udot for each sensor. Not optimal + sensor.measure( + self.t, + self.y_sol, + u_dot, + relative_position, + self.env.gravity(self.solution[-1][3]), + ) + for controller in node._controllers: - controller(self.t, self.y_sol, self.solution) + controller( + self.t, + self.y_sol, + self.solution, + self._sensors_list, + ) for parachute in node.parachutes: # Calculate and save pressure signal @@ -718,7 +745,9 @@ def __init__( self.env.barometric_height(pressure + noise) - self.env.elevation ) - if parachute.triggerfunc(pressure + noise, hAGL, self.y_sol): + if parachute.triggerfunc( + pressure + noise, hAGL, self.y_sol, self._sensors_list + ): # print('\nEVENT DETECTED') # print('Parachute Triggered') # print('Name: ', parachute.name, ' | Lag: ', parachute.lag) @@ -750,7 +779,7 @@ def __init__( ) # Prepare to leave loops and start new flight phase phase.TimeNodes.flush_after(node_index) - phase.TimeNodes.add_node(self.t, [], []) + phase.TimeNodes.add_node(self.t, [], [], []) phase.solver.status = "finished" # Save parachute event self.parachute_events.append([self.t, parachute]) @@ -868,7 +897,7 @@ def __init__( ) # Prepare to leave loops and start new flight phase phase.TimeNodes.flush_after(node_index) - phase.TimeNodes.add_node(self.t, [], []) + phase.TimeNodes.add_node(self.t, [], [], []) phase.solver.status = "finished" # Check for apogee event @@ -902,7 +931,7 @@ def __init__( self.FlightPhases.add_phase(self.t) # Prepare to leave loops and start new flight phase phase.TimeNodes.flush_after(node_index) - phase.TimeNodes.add_node(self.t, [], []) + phase.TimeNodes.add_node(self.t, [], [], []) phase.solver.status = "finished" # Check for impact event if self.y_sol[2] < self.env.elevation: @@ -965,7 +994,7 @@ def __init__( self.FlightPhases.add_phase(self.t) # Prepare to leave loops and start new flight phase phase.TimeNodes.flush_after(node_index) - phase.TimeNodes.add_node(self.t, [], []) + phase.TimeNodes.add_node(self.t, [], [], []) phase.solver.status = "finished" # List and feed overshootable time nodes @@ -977,7 +1006,7 @@ def __init__( self.parachutes, self.solution[-2][0], self.t ) # Add last time node (always skipped) - overshootable_nodes.add_node(self.t, [], []) + overshootable_nodes.add_node(self.t, [], [], []) if len(overshootable_nodes) > 1: # Sort overshootable time nodes overshootable_nodes.sort() @@ -1026,7 +1055,10 @@ def __init__( ) if parachute.triggerfunc( - pressure + noise, hAGL, overshootable_node.y + pressure + noise, + hAGL, + overshootable_node.y, + self._sensors_list, ): # print('\nEVENT DETECTED') # print('Parachute Triggered') @@ -1069,7 +1101,7 @@ def __init__( overshootable_index ) phase.TimeNodes.flush_after(node_index) - phase.TimeNodes.add_node(self.t, [], []) + phase.TimeNodes.add_node(self.t, [], [], []) phase.solver.status = "finished" # Save parachute event self.parachute_events.append( @@ -1943,6 +1975,8 @@ def u_dot_parachute(self, t, u, post_processing=False): ay = Dy / (mp + ma) az = (Dz - 9.8 * mp) / (mp + ma) + u_dot = [vx, vy, vz, ax, ay, az, 0, 0, 0, 0, 0, 0, 0] + if post_processing: # Dynamics variables self.R1_list.append([t, Dx]) @@ -3566,6 +3600,8 @@ def __init__(self, t, derivative=None, callbacks=None, clear=True): self.derivative = derivative self.callbacks = callbacks[:] if callbacks is not None else [] self.clear = clear + self.time_bound = None + self.TimeNodes = None def __repr__(self): if self.derivative is None: @@ -3594,8 +3630,8 @@ def __repr__(self): def add(self, time_node): self.list.append(time_node) - def add_node(self, t, parachutes, callbacks): - self.list.append(self.TimeNode(t, parachutes, callbacks)) + def add_node(self, t, parachutes, controllers, sensors): + self.list.append(self.TimeNode(t, parachutes, controllers, sensors)) def add_parachutes(self, parachutes, t_init, t_end): # Iterate over parachutes @@ -3603,7 +3639,7 @@ def add_parachutes(self, parachutes, t_init, t_end): # Calculate start of sampling time nodes pcDt = 1 / parachute.sampling_rate parachute_node_list = [ - self.TimeNode(i * pcDt, [parachute], []) + self.TimeNode(i * pcDt, [parachute], [], []) for i in range( math.ceil(t_init / pcDt), math.floor(t_end / pcDt) + 1 ) @@ -3616,7 +3652,7 @@ def add_controllers(self, controllers, t_init, t_end): # Calculate start of sampling time nodes controller_time_step = 1 / controller.sampling_rate controller_node_list = [ - self.TimeNode(i * controller_time_step, [], [controller]) + self.TimeNode(i * controller_time_step, [], [controller], []) for i in range( math.ceil(t_init / controller_time_step), math.floor(t_end / controller_time_step) + 1, @@ -3624,6 +3660,22 @@ def add_controllers(self, controllers, t_init, t_end): ] self.list += controller_node_list + def add_sensors(self, sensors, t_init, t_end): + # Iterate over sensors + for sensor_component_tuple in sensors: + # Calculate start of sampling time nodes + sensor_time_step = 1 / sensor_component_tuple.component.sampling_rate + sensor_node_list = [ + self.TimeNode( + i * sensor_time_step, [], [], [sensor_component_tuple] + ) + for i in range( + math.ceil(t_init / sensor_time_step), + math.floor(t_end / sensor_time_step) + 1, + ) + ] + self.list += sensor_node_list + def sort(self): self.list.sort(key=(lambda node: node.t)) @@ -3637,6 +3689,8 @@ def merge(self): if abs(node.t - self.tmp_list[-1].t) < 1e-7: self.tmp_list[-1].parachutes += node.parachutes self.tmp_list[-1].callbacks += node.callbacks + self.tmp_list[-1]._component_sensors += node._component_sensors + self.tmp_list[-1]._controllers += node._controllers # Add new node to tmp list if there is none with the same time else: self.tmp_list.append(node) @@ -3647,11 +3701,12 @@ def flush_after(self, index): del self.list[index + 1 :] class TimeNode: - def __init__(self, t, parachutes, controllers): + def __init__(self, t, parachutes, controllers, sensors): self.t = t self.parachutes = parachutes self.callbacks = [] self._controllers = controllers + self._component_sensors = sensors def __repr__(self): return ( @@ -3659,5 +3714,9 @@ def __repr__(self): + str(self.t) + " | Parachutes: " + str(len(self.parachutes)) + + " | Controllers: " + + str(len(self._controllers)) + + " | Sensors: " + + str(len(self._sensors_list)) + "}" ) From 09e0d751a8dc1f6dccbce19ebe03f33ee4b03784 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 1 Apr 2024 19:56:39 +0200 Subject: [PATCH 05/77] ENH: prints and sensors draw --- rocketpy/plots/rocket_plots.py | 329 +++++++++++++++++------------- rocketpy/prints/sensors_prints.py | 99 +++++++++ rocketpy/rocket/rocket.py | 8 +- 3 files changed, 294 insertions(+), 142 deletions(-) create mode 100644 rocketpy/prints/sensors_prints.py diff --git a/rocketpy/plots/rocket_plots.py b/rocketpy/plots/rocket_plots.py index 7074704e6..50b24e0e9 100644 --- a/rocketpy/plots/rocket_plots.py +++ b/rocketpy/plots/rocket_plots.py @@ -3,6 +3,7 @@ import matplotlib.pyplot as plt import numpy as np +from rocketpy.mathutils.vector_matrix import Vector from rocketpy.motors import EmptyMotor, HybridMotor, LiquidMotor, SolidMotor from rocketpy.rocket.aero_surface import Fins, NoseCone, Tail @@ -168,7 +169,7 @@ def thrust_to_weight(self): return None - def draw(self, vis_args=None): + def draw(self, vis_args=None, plane="xz"): """Draws the rocket in a matplotlib figure. Parameters @@ -188,8 +189,10 @@ def draw(self, vis_args=None): } A full list of color names can be found at: https://matplotlib.org/stable/gallery/color/named_colors + plane : str, optional + Plane in which the rocket will be drawn. Default is 'xz'. Other + options is 'yz'. Used only for sensors representation. """ - # TODO: we need to modularize this function, it is too big if vis_args is None: vis_args = { "background": "#EEEEEE", @@ -202,20 +205,34 @@ def draw(self, vis_args=None): "line_width": 1.0, } - # Create the figure and axis - _, ax = plt.subplots(figsize=(8, 6), facecolor="#EEEEEE") + fig, ax = plt.subplots(figsize=(8, 6), facecolor=vis_args["background"]) ax.set_aspect("equal") - ax.set_facecolor(vis_args["background"]) ax.grid(True, linestyle="--", linewidth=0.5) csys = self.rocket._csys reverse = csys == 1 self.rocket.aerodynamic_surfaces.sort_by_position(reverse=reverse) + drawn_surfaces = self._draw_aerodynamic_surfaces(ax, vis_args) + last_radius, last_x = self._draw_tubes(ax, drawn_surfaces, vis_args) + self._draw_motor(last_radius, last_x, ax, vis_args) + self._draw_rail_buttons(ax, vis_args) + self._draw_center_of_mass_and_pressure(ax) + self._draw_sensor(ax, self.rocket.sensors, plane, vis_args) + + plt.title("Rocket Representation") + plt.xlim() + plt.ylim([-self.rocket.radius * 4, self.rocket.radius * 6]) + plt.xlabel("Position (m)") + plt.ylabel("Radius (m)") + plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left") + plt.tight_layout() + plt.show() + + def _draw_aerodynamic_surfaces(self, ax, vis_args): # List of drawn surfaces with the position of points of interest # and the radius of the rocket at that point drawn_surfaces = [] - # Idea is to get the shape of each aerodynamic surface in their own # coordinate system and then plot them in the rocket coordinate system # using the position of each surface @@ -225,113 +242,98 @@ def draw(self, vis_args=None): for surface, position in self.rocket.aerodynamic_surfaces: if isinstance(surface, NoseCone): - x_nosecone = -csys * surface.shape_vec[0] + position - y_nosecone = surface.shape_vec[1] + self._draw_nose_cone(ax, surface, position, drawn_surfaces, vis_args) + elif isinstance(surface, Tail): + self._draw_tail(ax, surface, position, drawn_surfaces, vis_args) + elif isinstance(surface, Fins): + self._draw_fins(ax, surface, position, drawn_surfaces, vis_args) + return drawn_surfaces - ax.plot( - x_nosecone, - y_nosecone, - color=vis_args["nose"], - linewidth=vis_args["line_width"], - ) - ax.plot( - x_nosecone, - -y_nosecone, - color=vis_args["nose"], - linewidth=vis_args["line_width"], - ) - # close the nosecone - ax.plot( - [x_nosecone[-1], x_nosecone[-1]], - [y_nosecone[-1], -y_nosecone[-1]], - color=vis_args["nose"], - linewidth=vis_args["line_width"], - ) + def _draw_nose_cone(self, ax, surface, position, drawn_surfaces, vis_args): + x_nosecone = -self.rocket._csys * surface.shape_vec[0] + position + y_nosecone = surface.shape_vec[1] + ax.plot( + x_nosecone, + y_nosecone, + color=vis_args["nose"], + linewidth=vis_args["line_width"], + ) + ax.plot( + x_nosecone, + -y_nosecone, + color=vis_args["nose"], + linewidth=vis_args["line_width"], + ) + # close the nosecone + ax.plot( + [x_nosecone[-1], x_nosecone[-1]], + [y_nosecone[-1], -y_nosecone[-1]], + color=vis_args["nose"], + linewidth=vis_args["line_width"], + ) + # Add the nosecone to the list of drawn surfaces + drawn_surfaces.append( + (surface, x_nosecone[-1], surface.rocket_radius, x_nosecone[-1]) + ) - # Add the nosecone to the list of drawn surfaces - drawn_surfaces.append( - (surface, x_nosecone[-1], surface.rocket_radius, x_nosecone[-1]) - ) + def _draw_tail(self, ax, surface, position, drawn_surfaces, vis_args): + x_tail = -self.rocket._csys * surface.shape_vec[0] + position + y_tail = surface.shape_vec[1] + ax.plot( + x_tail, y_tail, color=vis_args["tail"], linewidth=vis_args["line_width"] + ) + ax.plot( + x_tail, -y_tail, color=vis_args["tail"], linewidth=vis_args["line_width"] + ) + # close above and below the tail + ax.plot( + [x_tail[-1], x_tail[-1]], + [y_tail[-1], -y_tail[-1]], + color=vis_args["tail"], + linewidth=vis_args["line_width"], + ) + ax.plot( + [x_tail[0], x_tail[0]], + [y_tail[0], -y_tail[0]], + color=vis_args["tail"], + linewidth=vis_args["line_width"], + ) + # Add the tail to the list of drawn surfaces + drawn_surfaces.append((surface, position, surface.bottom_radius, x_tail[-1])) - elif isinstance(surface, Tail): - x_tail = -csys * surface.shape_vec[0] + position - y_tail = surface.shape_vec[1] + def _draw_fins(self, ax, surface, position, drawn_surfaces, vis_args): + num_fins = surface.n + x_fin = -self.rocket._csys * surface.shape_vec[0] + position + y_fin = surface.shape_vec[1] + surface.rocket_radius + rotation_angles = [2 * np.pi * i / num_fins for i in range(num_fins)] - ax.plot( - x_tail, - y_tail, - color=vis_args["tail"], - linewidth=vis_args["line_width"], - ) - ax.plot( - x_tail, - -y_tail, - color=vis_args["tail"], - linewidth=vis_args["line_width"], - ) - # close above and below the tail - ax.plot( - [x_tail[-1], x_tail[-1]], - [y_tail[-1], -y_tail[-1]], - color=vis_args["tail"], - linewidth=vis_args["line_width"], - ) - ax.plot( - [x_tail[0], x_tail[0]], - [y_tail[0], -y_tail[0]], - color=vis_args["tail"], - linewidth=vis_args["line_width"], - ) + for angle in rotation_angles: + x_rotated, y_rotated = self._rotate_points(x_fin, y_fin, angle) + ax.plot( + x_rotated, + y_rotated, + color=vis_args["fins"], + linewidth=vis_args["line_width"], + ) - # Add the tail to the list of drawn surfaces - drawn_surfaces.append( - (surface, position, surface.bottom_radius, x_tail[-1]) - ) + drawn_surfaces.append((surface, position, surface.rocket_radius, x_rotated[-1])) - # Draw fins - elif isinstance(surface, Fins): - num_fins = surface.n - x_fin = -csys * surface.shape_vec[0] + position - y_fin = surface.shape_vec[1] + surface.rocket_radius - - # Calculate the rotation angles for the other two fins (symmetrically) - rotation_angles = [2 * np.pi * i / num_fins for i in range(num_fins)] - - # Apply rotation transformations to get points for the other fins in 2D space - for angle in rotation_angles: - # Create a rotation matrix for the current angle around the x-axis - rotation_matrix = np.array([[1, 0], [0, np.cos(angle)]]) - - # Apply the rotation to the original fin points - rotated_points_2d = np.dot( - rotation_matrix, np.vstack((x_fin, y_fin)) - ) - - # Extract x and y coordinates of the rotated points - x_rotated, y_rotated = rotated_points_2d - - # Project points above the XY plane back into the XY plane (set z-coordinate to 0) - x_rotated = np.where( - rotated_points_2d[1] > 0, rotated_points_2d[0], x_rotated - ) - y_rotated = np.where( - rotated_points_2d[1] > 0, rotated_points_2d[1], y_rotated - ) - - # Plot the fins - ax.plot( - x_rotated, - y_rotated, - color=vis_args["fins"], - linewidth=vis_args["line_width"], - ) - - # Add the fin to the list of drawn surfaces - drawn_surfaces.append( - (surface, position, surface.rocket_radius, x_rotated[-1]) - ) + def _rotate_points(self, x_fin, y_fin, angle): + # Create a rotation matrix for the current angle around the x-axis + rotation_matrix = np.array([[1, 0], [0, np.cos(angle)]]) + + # Apply the rotation to the original fin points + rotated_points_2d = np.dot(rotation_matrix, np.vstack((x_fin, y_fin))) + + # Extract x and y coordinates of the rotated points + x_rotated, y_rotated = rotated_points_2d - # Draw tubes + # Project points above the XY plane back into the XY plane (set z-coordinate to 0) + x_rotated = np.where(rotated_points_2d[1] > 0, rotated_points_2d[0], x_rotated) + y_rotated = np.where(rotated_points_2d[1] > 0, rotated_points_2d[1], y_rotated) + return x_rotated, y_rotated + + def _draw_tubes(self, ax, drawn_surfaces, vis_args): for i, d_surface in enumerate(drawn_surfaces): # Draw the tubes, from the end of the first surface to the beginning # of the next surface, with the radius of the rocket at that point @@ -368,18 +370,39 @@ def draw(self, vis_args=None): color=vis_args["body"], linewidth=vis_args["line_width"], ) + return radius, last_x - # Draw motor + def _draw_motor(self, last_radius, last_x, ax, vis_args): total_csys = self.rocket._csys * self.rocket.motor._csys nozzle_position = ( self.rocket.motor_position + self.rocket.motor.nozzle_position * total_csys ) - # List of motor patches + # Get motor patches translated to the correct position + motor_patches = self._generate_motor_patches(total_csys, ax, vis_args) + + # Draw patches + if not isinstance(self.rocket.motor, EmptyMotor): + # Add nozzle last so it is in front of the other patches + nozzle = self.rocket.motor.plots._generate_nozzle( + translate=(nozzle_position, 0), csys=self.rocket._csys + ) + motor_patches += [nozzle] + + outline = self.rocket.motor.plots._generate_motor_region( + list_of_patches=motor_patches + ) + # add outline first so it is behind the other patches + ax.add_patch(outline) + for patch in motor_patches: + ax.add_patch(patch) + + self._draw_nozzle_tube(last_radius, last_x, nozzle_position, ax, vis_args) + + def _generate_motor_patches(self, total_csys, ax, vis_args): motor_patches = [] - # Get motor patches translated to the correct position - if isinstance(self.rocket.motor, (SolidMotor)): + if isinstance(self.rocket.motor, SolidMotor): grains_cm_position = ( self.rocket.motor_position + self.rocket.motor.grains_center_of_mass_position * total_csys @@ -452,27 +475,16 @@ def draw(self, vis_args=None): ) motor_patches += [tank] - # add nozzle last so it is in front of the other patches - if not isinstance(self.rocket.motor, EmptyMotor): - nozzle = self.rocket.motor.plots._generate_nozzle( - translate=(nozzle_position, 0), csys=self.rocket._csys - ) - motor_patches += [nozzle] - outline = self.rocket.motor.plots._generate_motor_region( - list_of_patches=motor_patches - ) - # add outline first so it is behind the other patches - ax.add_patch(outline) - for patch in motor_patches: - ax.add_patch(patch) + return motor_patches + def _draw_nozzle_tube(self, last_radius, last_x, nozzle_position, ax, vis_args): # Check if nozzle is beyond the last surface, if so draw a tube # to it, with the radius of the last surface if self.rocket._csys == 1: if nozzle_position < last_x: x_tube = [last_x, nozzle_position] - y_tube = [radius, radius] - y_tube_negated = [-radius, -radius] + y_tube = [last_radius, last_radius] + y_tube_negated = [-last_radius, -last_radius] ax.plot( x_tube, @@ -489,8 +501,8 @@ def draw(self, vis_args=None): else: # if self.rocket._csys == -1: if nozzle_position > last_x: x_tube = [last_x, nozzle_position] - y_tube = [radius, radius] - y_tube_negated = [-radius, -radius] + y_tube = [last_radius, last_radius] + y_tube_negated = [-last_radius, -last_radius] ax.plot( x_tube, @@ -505,11 +517,11 @@ def draw(self, vis_args=None): linewidth=vis_args["line_width"], ) - # Draw rail buttons + def _draw_rail_buttons(self, ax, vis_args): try: buttons, pos = self.rocket.rail_buttons[0] lower = pos - upper = pos + buttons.buttons_distance * csys + upper = pos + buttons.buttons_distance * self.rocket._csys ax.scatter( lower, -self.rocket.radius, marker="s", color=vis_args["buttons"], s=15 ) @@ -519,6 +531,7 @@ def draw(self, vis_args=None): except IndexError: pass + def _draw_center_of_mass_and_pressure(self, ax): # Draw center of mass and center of pressure cm = self.rocket.center_of_mass(0) ax.scatter(cm, 0, color="#1565c0", label="Center of Mass", s=10) @@ -528,17 +541,55 @@ def draw(self, vis_args=None): cp, 0, label="Static Center of Pressure", color="red", s=10, zorder=10 ) - # Set plot attributes - plt.title("Rocket Representation") - plt.xlim() - plt.ylim([-self.rocket.radius * 4, self.rocket.radius * 6]) - plt.xlabel("Position (m)") - plt.ylabel("Radius (m)") - plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left") - plt.tight_layout() - plt.show() + def _draw_sensor(self, ax, sensors, plane, vis_args): + """Draw the sensor as a small thick line at the position of the sensor, + with a vector pointing in the direction normal of the sensor. Get the + normal vector from the sensor orientation matrix.""" + colors = plt.rcParams["axes.prop_cycle"].by_key()["color"] + for i, sensor_pos in enumerate(sensors): + sensor = sensor_pos[0] + pos = sensor_pos[1] + if plane == "xz": + # z position of the sensor is the x position in the plot + x_pos = pos[2] + normal_x = sensor.normal_vector.z + # x position of the sensor is the y position in the plot + y_pos = pos[0] + normal_y = sensor.normal_vector.x + elif plane == "yz": + # z position of the sensor is the x position in the plot + x_pos = pos[2] + normal_x = sensor.normal_vector.z + # y position of the sensor is the y position in the plot + y_pos = pos[1] + normal_y = sensor.normal_vector.y + else: + raise ValueError("Plane must be 'xz' or 'yz'.") - return None + # line length is 1/10 of the rocket radius + line_length = self.rocket.radius / 2.5 + + ax.plot( + [x_pos, x_pos], + [y_pos + line_length, y_pos - line_length], + linewidth=2, + color=colors[(i + 1) % len(colors)], + zorder=10, + label=sensor.name, + ) + ax.quiver( + x_pos, + y_pos, + normal_x, + normal_y, + color=colors[(i + 1) % len(colors)], + scale_units="xy", + angles="xy", + minshaft=2, + headwidth=2, + headlength=4, + zorder=10, + ) def all(self): """Prints out all graphs available about the Rocket. It simply calls diff --git a/rocketpy/prints/sensors_prints.py b/rocketpy/prints/sensors_prints.py new file mode 100644 index 000000000..d41227de7 --- /dev/null +++ b/rocketpy/prints/sensors_prints.py @@ -0,0 +1,99 @@ +from abc import ABC, abstractmethod + + +UNITS = { + "Gyroscope": "rad/s", + "Accelerometer": "m/s^2", + "Magnetometer": "T", + "PressureSensor": "Pa", + "TemperatureSensor": "K", +} + + +class _SensorsPrints(ABC): + def __init__(self, sensor): + self.sensor = sensor + self.units = UNITS[sensor.type] + + def _print_aligned(self, label, value): + """Prints a label and a value aligned vertically.""" + print(f"{label:<26} {value}") + + def identity(self): + """Prints the identity of the sensor.""" + print("Identification of the Sensor:\n") + self._print_aligned("Name:", self.sensor.name) + self._print_aligned("Type:", self.sensor.type) + + def orientation(self): + """Prints the orientation of the sensor.""" + print("\nOrientation of the Sensor:\n") + self._print_aligned("Orientation:", self.sensor.orientation) + self._print_aligned("Normal Vector:", self.sensor.normal_vector) + print("Rotation Matrix:") + for row in self.sensor.rotation_matrix: + value = " ".join(f"{val:.2f}" for val in row) + value = [float(val) for val in value.split()] + self._print_aligned("", value) + + def quantization(self): + """Prints the quantization of the sensor.""" + print("\nQuantization of the Sensor:\n") + self._print_aligned( + "Measurement Range:", + f"{self.sensor.measurement_range[0]} to {self.sensor.measurement_range[1]} ({self.units})", + ) + self._print_aligned("Resolution:", f"{self.sensor.resolution} {self.units}/LSB") + + def noise(self): + """Prints the noise of the sensor.""" + print("\nNoise of the Sensor:\n") + self._print_aligned( + "Noise Density:", f"{self.sensor.noise_density} {self.units}/√Hz" + ) + self._print_aligned( + "Random Walk:", f"{self.sensor.random_walk} {self.units}/√Hz" + ) + self._print_aligned( + "Constant Bias:", f"{self.sensor.constant_bias} {self.units}" + ) + self._print_aligned( + "Operating Temperature:", f"{self.sensor.operating_temperature} °C" + ) + self._print_aligned( + "Temperature Bias:", f"{self.sensor.temperature_bias} {self.units}/°C" + ) + self._print_aligned( + "Temperature Scale Factor:", f"{self.sensor.temperature_scale_factor} %/°C" + ) + self._print_aligned( + "Cross Axis Sensitivity:", f"{self.sensor.cross_axis_sensitivity} %" + ) + if self.sensor.type == "Gyroscope": + self._print_aligned( + "Acceleration Sensitivity:", + f"{self.sensor.acceleration_sensitivity} rad/s/g", + ) + + def all(self): + """Prints all information of the sensor.""" + self.identity() + self.orientation() + self.quantization() + self.noise() + + +class _AccelerometerPrints(_SensorsPrints): + """Class that contains all accelerometer prints.""" + + def __init__(self, accelerometer): + """Initialize the class.""" + super().__init__(accelerometer) + + +class _GyroscopePrints(_SensorsPrints): + """Class that contains all gyroscope prints.""" + + def __init__(self, gyroscope): + """Initialize the class.""" + super().__init__(gyroscope) diff --git a/rocketpy/rocket/rocket.py b/rocketpy/rocket/rocket.py index cfc0ad3eb..9c179557e 100644 --- a/rocketpy/rocket/rocket.py +++ b/rocketpy/rocket/rocket.py @@ -1454,7 +1454,7 @@ def add_thrust_eccentricity(self, x, y): self.thrust_eccentricity_x = y return self - def draw(self, vis_args=None): + def draw(self, vis_args=None, plane="xz"): """Draws the rocket in a matplotlib figure. Parameters @@ -1474,9 +1474,11 @@ def draw(self, vis_args=None): } A full list of color names can be found at: https://matplotlib.org/stable/gallery/color/named_colors + plane : str, optional + Plane in which the rocket will be drawn. Default is 'xz'. Other + options is 'yz'. Used only for sensors representation. """ - self.plots.draw(vis_args) - return None + self.plots.draw(vis_args, plane) def info(self): """Prints out a summary of the data and graphs available about From 38866f4e712f3b9f9136100fc335c6862abc9a6a Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 1 Apr 2024 19:58:23 +0200 Subject: [PATCH 06/77] ENH: add sensors to parachutes --- rocketpy/rocket/parachute.py | 22 +++++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) diff --git a/rocketpy/rocket/parachute.py b/rocketpy/rocket/parachute.py index 31f9252ed..4c5e5d7f3 100644 --- a/rocketpy/rocket/parachute.py +++ b/rocketpy/rocket/parachute.py @@ -1,4 +1,5 @@ import numpy as np +from inspect import signature from ..mathutils.function import Function from ..prints.parachute_prints import _ParachutePrints @@ -31,6 +32,11 @@ class Parachute: `[x, y, z, vx, vy, vz, e0, e1, e2, e3, wx, wy, wz]`. + 4. A list of sensors that are attached to the rocket. The most recent + measurements of the sensors are provided with the + ``sensor.measurement`` attribute. The sensors are listed in the same + order as they are added to the rocket. + The function should return True if the parachute ejection system should be triggered and False otherwise. @@ -177,12 +183,22 @@ def __evaluate_trigger_function(self, trigger): """This is used to set the triggerfunc attribute that will be used to interact with the Flight class. """ + # The parachute is deployed by a custom function if callable(trigger): - self.triggerfunc = trigger + # work around for having added sensors to parachute triggers + # to avoid breaking changes + triggerfunc = trigger + sig = signature(triggerfunc) + if len(sig.parameters) == 3: + + def triggerfunc(p, h, y, sensors): + return trigger(p, h, y) + + self.triggerfunc = triggerfunc elif isinstance(trigger, (int, float)): # The parachute is deployed at a given height - def triggerfunc(p, h, y): + def triggerfunc(p, h, y, sensors): # p = pressure considering parachute noise signal # h = height above ground level considering parachute noise signal # y = [x, y, z, vx, vy, vz, e0, e1, e2, e3, w1, w2, w3] @@ -192,7 +208,7 @@ def triggerfunc(p, h, y): elif trigger.lower() == "apogee": # The parachute is deployed at apogee - def triggerfunc(p, h, y): + def triggerfunc(p, h, y, sensors): # p = pressure considering parachute noise signal # h = height above ground level considering parachute noise signal # y = [x, y, z, vx, vy, vz, e0, e1, e2, e3, w1, w2, w3] From b386e388f05ad466564d336ad28f46401ddb67bb Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 1 Apr 2024 19:59:10 +0200 Subject: [PATCH 07/77] TST: add sensors fixtures --- tests/conftest.py | 1 + tests/fixtures/flight/flight_fixtures.py | 30 +++++++++ tests/fixtures/rockets/rocket_fixtures.py | 27 ++++++++ tests/fixtures/sensors/__init__.py | 0 tests/fixtures/sensors/sensors_fixtures.py | 78 ++++++++++++++++++++++ 5 files changed, 136 insertions(+) create mode 100644 tests/fixtures/sensors/__init__.py create mode 100644 tests/fixtures/sensors/sensors_fixtures.py diff --git a/tests/conftest.py b/tests/conftest.py index 4766b570a..e8eda67ce 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -13,6 +13,7 @@ "tests.fixtures.rockets.rocket_fixtures", "tests.fixtures.surfaces.surface_fixtures", "tests.fixtures.units.numerical_fixtures", + "tests.fixtures.sensors.sensors_fixtures", ] diff --git a/tests/fixtures/flight/flight_fixtures.py b/tests/fixtures/flight/flight_fixtures.py index c8f73d52c..9976ddac2 100644 --- a/tests/fixtures/flight/flight_fixtures.py +++ b/tests/fixtures/flight/flight_fixtures.py @@ -158,3 +158,33 @@ def flight_calisto_air_brakes(calisto_air_brakes_clamp_on, example_plain_env): time_overshoot=False, terminate_on_apogee=True, ) + + +@pytest.fixture +def flight_calisto_accel_gyro(calisto_accel_gyro, example_plain_env): + """A rocketpy.Flight object of the Calisto rocket. This uses the calisto + with an ideal accelerometer and a gyroscope. The environment is the simplest + possible, with no parameters set. + + Parameters + ---------- + calisto_accel_gyro : rocketpy.Rocket + An object of the Rocket class. + example_plain_env : rocketpy.Environment + An object of the Environment class. + + Returns + ------- + rocketpy.Flight + A rocketpy.Flight object of the Calisto rocket in a more complex + condition. + """ + return Flight( + rocket=calisto_accel_gyro, + environment=example_plain_env, + rail_length=5.2, + inclination=85, + heading=0, + time_overshoot=False, + terminate_on_apogee=True, + ) diff --git a/tests/fixtures/rockets/rocket_fixtures.py b/tests/fixtures/rockets/rocket_fixtures.py index 3a1c82988..c461a78f4 100644 --- a/tests/fixtures/rockets/rocket_fixtures.py +++ b/tests/fixtures/rockets/rocket_fixtures.py @@ -243,6 +243,33 @@ def calisto_air_brakes_clamp_off(calisto_robust, controller_function): return calisto +@pytest.fixture +def calisto_accel_gyro(calisto_robust, ideal_accelerometer, ideal_gyroscope): + """Create an object class of the Rocket class to be used in the tests. This + is the same Calisto rocket that was defined in the calisto fixture, but with + an ideal accelerometer and a gyroscope added at the center of dry mass. + Meaning the readings will be the same as the values saved on a Flight object. + + Parameters + ---------- + calisto : rocketpy.Rocket + An object of the Rocket class. This is a pytest fixture. + accelerometer : rocketpy.Accelerometer + An object of the Accelerometer class. This is a pytest fixture. + gyroscope : rocketpy.Gyroscope + An object of the Gyroscope class. This is a pytest fixture. + + Returns + ------- + rocketpy.Rocket + An object of the Rocket class + """ + calisto = calisto_robust + calisto.add_sensor(ideal_accelerometer, -0.10482544178314143) + calisto.add_sensor(ideal_gyroscope, -0.10482544178314143) + return calisto + + @pytest.fixture # old name: dimensionless_rocket def dimensionless_calisto(kg, m, dimensionless_cesaroni_m1670): """The dimensionless version of the Calisto rocket. This is the same rocket diff --git a/tests/fixtures/sensors/__init__.py b/tests/fixtures/sensors/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/fixtures/sensors/sensors_fixtures.py b/tests/fixtures/sensors/sensors_fixtures.py new file mode 100644 index 000000000..d334a0a46 --- /dev/null +++ b/tests/fixtures/sensors/sensors_fixtures.py @@ -0,0 +1,78 @@ +import pytest +from rocketpy import Accelerometer, Gyroscope + + +@pytest.fixture +def noisy_rotated_accelerometer(): + """Returns an accelerometer with all parameters set to non-default values, + i.e. with noise and rotation.""" + # mpu6050 values + return Accelerometer( + sampling_rate=100, + orientation=(60, 60, 60), + noise_density=0.05, + random_walk=0.02, + constant_bias=0.5, + operating_temperature=25, + temperature_bias=0.02, + temperature_scale_factor=0.02, + cross_axis_sensitivity=0.5, + consider_gravity=True, + name="Accelerometer", + ) + + +@pytest.fixture +def noisy_rotated_gyroscope(): + """Returns a gyroscope with all parameters set to non-default values, + i.e. with noise and rotation.""" + # mpu6050 values + return Gyroscope( + sampling_rate=100, + orientation=(-60, -60, -60), + noise_density=0.05, + random_walk=0.02, + constant_bias=0.5, + operating_temperature=25, + temperature_bias=0.02, + temperature_scale_factor=0.02, + cross_axis_sensitivity=0.5, + acceleration_sensitivity=0.0017, + name="Gyroscope", + ) + + +@pytest.fixture +def quantized_accelerometer(): + """Returns an accelerometer with all parameters set to non-default values, + i.e. with noise and rotation.""" + return Accelerometer( + sampling_rate=100, + measurement_range=2, + resolution=0.4882, + ) + + +@pytest.fixture +def quantized_gyroscope(): + """Returns a gyroscope with all parameters set to non-default values, + i.e. with noise and rotation.""" + return Gyroscope( + sampling_rate=100, + measurement_range=15, + resolution=0.4882, + ) + + +@pytest.fixture +def ideal_accelerometer(): + return Accelerometer( + sampling_rate=100, + ) + + +@pytest.fixture +def ideal_gyroscope(): + return Gyroscope( + sampling_rate=100, + ) From 6ff2dde621df293231c67801faf2d7000a278714 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 1 Apr 2024 19:59:22 +0200 Subject: [PATCH 08/77] TST: add sensors tests --- tests/test_sensors.py | 63 ++++++ tests/unit/test_sensors.py | 398 +++++++++++++++++++++++++++++++++++++ 2 files changed, 461 insertions(+) create mode 100644 tests/test_sensors.py create mode 100644 tests/unit/test_sensors.py diff --git a/tests/test_sensors.py b/tests/test_sensors.py new file mode 100644 index 000000000..666e5f8e3 --- /dev/null +++ b/tests/test_sensors.py @@ -0,0 +1,63 @@ +import numpy as np + +from rocketpy.mathutils.vector_matrix import Vector +from rocketpy.rocket.components import Components +from rocketpy.sensors.accelerometer import Accelerometer +from rocketpy.sensors.gyroscope import Gyroscope + + +def test_sensor_on_rocket(calisto_accel_gyro): + """Test the sensor on the rocket. + + Parameters + ---------- + calisto_accel_gyro : Rocket + Pytest fixture for the calisto rocket with an accelerometer and a gyroscope. + """ + sensors = calisto_accel_gyro.sensors + assert isinstance(sensors, Components) + assert isinstance(sensors[0].component, Accelerometer) + assert isinstance(sensors[1].position, Vector) + assert isinstance(sensors[1].component, Gyroscope) + assert isinstance(sensors[1].position, Vector) + + +def test_ideal_accelerometer(flight_calisto_accel_gyro): + """Test the ideal accelerometer. + + Parameters + ---------- + flight_calisto_accel_gyro : Flight + Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. + """ + accelerometer = flight_calisto_accel_gyro.rocket.sensors[0].component + time, ax, ay, az = zip(*accelerometer.measured_values) + ax = np.array(ax) + ay = np.array(ay) + az = np.array(az) + a = np.sqrt(ax**2 + ay**2 + az**2) + sim_accel = flight_calisto_accel_gyro.acceleration(time) + + # tolerance is bounded to numerical errors in the transformation matrixes + assert np.allclose(a, sim_accel, atol=1e-2) + + +def test_ideal_gyroscope(flight_calisto_accel_gyro): + """Test the ideal gyroscope. + + Parameters + ---------- + flight_calisto_accel_gyro : Flight + Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. + """ + gyroscope = flight_calisto_accel_gyro.rocket.sensors[1].component + time, wx, wy, wz = zip(*gyroscope.measured_values) + wx = np.array(wx) + wy = np.array(wy) + wz = np.array(wz) + w = np.sqrt(wx**2 + wy**2 + wz**2) + flight_wx = np.array(flight_calisto_accel_gyro.w1(time)) + flight_wy = np.array(flight_calisto_accel_gyro.w2(time)) + flight_wz = np.array(flight_calisto_accel_gyro.w3(time)) + sim_w = np.sqrt(flight_wx**2 + flight_wy**2 + flight_wz**2) + assert np.allclose(w, sim_w, atol=1e-8) diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensors.py new file mode 100644 index 000000000..c7ee8175b --- /dev/null +++ b/tests/unit/test_sensors.py @@ -0,0 +1,398 @@ +import json +import os +import numpy as np +from pytest import approx +from rocketpy.mathutils.vector_matrix import Matrix, Vector +from rocketpy.tools import euler_to_quaternions + +# calisto standard simulation no wind solution index 200 +SOLUTION = [ + 3.338513236767685, + 0.02856482783411794, + 50.919436628139216, + 1898.9056294848442, + 0.021620542063162787, + 30.468683793837055, + 284.19140267225384, + -0.0076008223256743114, + 0.0004430927976100488, + 0.05330950836930627, + 0.9985245671704497, + 0.0026388673982115224, + 0.00010697759229808481, + 19.72526891699468, +] +UDOT = [ + 0.021620542063162787, + 30.468683793837055, + 284.19140267225384, + 0.0009380154986373648, + 1.4853035773069556, + 4.377014845613867, + -9.848086239924413, + 0.5257087555505318, + -0.0030529818895471124, + -0.07503444684343626, + 0.028008532884449017, + -0.052789015849051935, + 2.276425320359305, +] + + +def test_accelerometer_prints(noisy_rotated_accelerometer, quantized_accelerometer): + """Test the print methods of the Accelerometer class. Checks if all + attributes are printed correctly. + """ + noisy_rotated_accelerometer.prints.all() + quantized_accelerometer.prints.all() + assert True + + +def test_gyroscope_prints(noisy_rotated_gyroscope, quantized_gyroscope): + """Test the print methods of the Gyroscope class. Checks if all + attributes are printed correctly. + """ + noisy_rotated_gyroscope.prints.all() + quantized_gyroscope.prints.all() + assert True + + +def test_rotation_matrix(noisy_rotated_accelerometer): + """Test the rotation_matrix property of the Accelerometer class. Checks if + the rotation matrix is correctly calculated. + """ + expected_matrix = np.array( + [ + [0.2500000, -0.0580127, 0.9665064], + [0.4330127, 0.8995190, -0.0580127], + [-0.8660254, 0.4330127, 0.2500000], + ] + ) + rotation_matrix = np.array(noisy_rotated_accelerometer.rotation_matrix.components) + assert np.allclose(expected_matrix, rotation_matrix, atol=1e-8) + + +def test_ideal_accelerometer_measure(ideal_accelerometer): + """Test the measure method of the Accelerometer class. Checks if saved + measurement is (ax,ay,az) and if measured_values is [(t, (ax,ay,az)), ...] + """ + t = SOLUTION[0] + u = SOLUTION[1:] + + relative_position = Vector([0, 0, 0]) + gravity = 9.81 + a_I = Vector(UDOT[3:6]) + omega = Vector(u[10:13]) + omega_dot = Vector(UDOT[10:13]) + accel = ( + a_I + + Vector.cross(omega_dot, relative_position) + + Vector.cross(omega, Vector.cross(omega, relative_position)) + ) + ax, ay, az = Matrix.transformation(u[6:10]) @ accel + ideal_accelerometer.measure(t, u, UDOT, relative_position, gravity) + + # check last measurement + assert len(ideal_accelerometer.measurement) == 3 + assert all(isinstance(i, float) for i in ideal_accelerometer.measurement) + assert ideal_accelerometer.measurement == approx([ax, ay, az], abs=1e-10) + + # check measured values + assert len(ideal_accelerometer.measured_values) == 1 + ideal_accelerometer.measure(t, u, UDOT, relative_position, gravity) + assert len(ideal_accelerometer.measured_values) == 2 + + assert all(isinstance(i, tuple) for i in ideal_accelerometer.measured_values) + assert ideal_accelerometer.measured_values[0][0] == t + assert ideal_accelerometer.measured_values[0][1:] == approx([ax, ay, az], abs=1e-10) + + +def test_ideal_gyroscope_measure(ideal_gyroscope): + """Test the measure method of the Gyroscope class. Checks if saved + measurement is (wx,wy,wz) and if measured_values is [(t, (wx,wy,wz)), ...] + """ + t = SOLUTION[0] + u = SOLUTION[1:] + relative_position = Vector( + [np.random.randint(-1, 1), np.random.randint(-1, 1), np.random.randint(-1, 1)] + ) + + rot = Matrix.transformation(u[6:10]) + ax, ay, az = rot @ Vector(u[10:13]) + + ideal_gyroscope.measure(t, u, UDOT, relative_position) + + # check last measurement + assert len(ideal_gyroscope.measurement) == 3 + assert all(isinstance(i, float) for i in ideal_gyroscope.measurement) + assert ideal_gyroscope.measurement == approx([ax, ay, az], abs=1e-10) + + # check measured values + assert len(ideal_gyroscope.measured_values) == 1 + ideal_gyroscope.measure(t, u, UDOT, relative_position) + assert len(ideal_gyroscope.measured_values) == 2 + + assert all(isinstance(i, tuple) for i in ideal_gyroscope.measured_values) + assert ideal_gyroscope.measured_values[0][0] == t + assert ideal_gyroscope.measured_values[0][1:] == approx([ax, ay, az], abs=1e-10) + + +def test_noisy_rotated_accelerometer(noisy_rotated_accelerometer): + """Test the measure method of the Accelerometer class. Checks if saved + measurement is (ax,ay,az) and if measured_values is [(t, (ax,ay,az)), ...] + """ + t = SOLUTION[0] + u = SOLUTION[1:] + + # calculate acceleration at sensor position in inertial frame + relative_position = Vector([0.4, 0.4, 1]) + gravity = 9.81 + a_I = Vector(UDOT[3:6]) + Vector([0, 0, -gravity]) + omega = Vector(u[10:13]) + omega_dot = Vector(UDOT[10:13]) + accel = ( + a_I + + Vector.cross(omega_dot, relative_position) + + Vector.cross(omega, Vector.cross(omega, relative_position)) + ) + + # calculate total rotation matrix + cross_axis_sensitivity = Matrix( + [ + [1, 0.005, 0.005], + [0.005, 1, 0.005], + [0.005, 0.005, 1], + ] + ) + sensor_rotation = Matrix.transformation(euler_to_quaternions(60, 60, 60)) + total_rotation = sensor_rotation @ cross_axis_sensitivity + rocket_rotation = Matrix.transformation(u[6:10]) + # expected measurement without noise + ax, ay, az = total_rotation @ (rocket_rotation @ accel) + # expected measurement with constant bias + ax += 0.5 + ay += 0.5 + az += 0.5 + + # check last measurement considering noise error bounds + noisy_rotated_accelerometer.measure(t, u, UDOT, relative_position, gravity) + assert noisy_rotated_accelerometer.measurement == approx([ax, ay, az], rel=0.5) + + +def test_noisy_rotated_gyroscope(noisy_rotated_gyroscope): + """Test the measure method of the Gyroscope class. Checks if saved + measurement is (wx,wy,wz) and if measured_values is [(t, (wx,wy,wz)), ...] + """ + t = SOLUTION[0] + u = SOLUTION[1:] + # calculate acceleration at sensor position in inertial frame + relative_position = Vector([0.4, 0.4, 1]) + gravity = 9.81 + omega = Vector(u[10:13]) + # calculate total rotation matrix + cross_axis_sensitivity = Matrix( + [ + [1, 0.005, 0.005], + [0.005, 1, 0.005], + [0.005, 0.005, 1], + ] + ) + sensor_rotation = Matrix.transformation(euler_to_quaternions(-60, -60, -60)) + total_rotation = sensor_rotation @ cross_axis_sensitivity + rocket_rotation = Matrix.transformation(u[6:10]) + # expected measurement without noise + wx, wy, wz = total_rotation @ (rocket_rotation @ omega) + # expected measurement with constant bias + wx += 0.5 + wy += 0.5 + wz += 0.5 + + # check last measurement considering noise error bounds + noisy_rotated_gyroscope.measure(t, u, UDOT, relative_position, gravity) + assert noisy_rotated_gyroscope.measurement == approx([wx, wy, wz], rel=0.5) + + +def test_quatization_accelerometer(quantized_accelerometer): + """Test the measure method of the Accelerometer class. Checks if saved + measurement is (ax,ay,az) and if measured_values is [(t, (ax,ay,az)), ...] + """ + t = SOLUTION[0] + u = SOLUTION[1:] + # calculate acceleration at sensor position in inertial frame + relative_position = Vector([0, 0, 0]) + gravity = 9.81 + a_I = Vector(UDOT[3:6]) + omega = Vector(u[10:13]) + omega_dot = Vector(UDOT[10:13]) + accel = ( + a_I + + Vector.cross(omega_dot, relative_position) + + Vector.cross(omega, Vector.cross(omega, relative_position)) + ) + + # calculate total rotation matrix + rocket_rotation = Matrix.transformation(u[6:10]) + # expected measurement without noise + ax, ay, az = rocket_rotation @ accel + # expected measurement with quantization + az = 2 # saturated + ax = round(ax / 0.4882) * 0.4882 + ay = round(ay / 0.4882) * 0.4882 + az = round(az / 0.4882) * 0.4882 + + # check last measurement considering noise error bounds + quantized_accelerometer.measure(t, u, UDOT, relative_position, gravity) + assert quantized_accelerometer.measurement == approx([ax, ay, az], abs=1e-10) + + +def test_quatization_gyroscope(quantized_gyroscope): + """Test the measure method of the Gyroscope class. Checks if saved + measurement is (wx,wy,wz) and if measured_values is [(t, (wx,wy,wz)), ...] + """ + t = SOLUTION[0] + u = SOLUTION[1:] + # calculate acceleration at sensor position in inertial frame + relative_position = Vector([0.4, 0.4, 1]) + gravity = 9.81 + omega = Vector(u[10:13]) + # calculate total rotation matrix + rocket_rotation = Matrix.transformation(u[6:10]) + # expected measurement without noise + wx, wy, wz = rocket_rotation @ omega + # expected measurement with quantization + wz = 15 # saturated + wx = round(wx / 0.4882) * 0.4882 + wy = round(wy / 0.4882) * 0.4882 + wz = round(wz / 0.4882) * 0.4882 + + # check last measurement considering noise error bounds + quantized_gyroscope.measure(t, u, UDOT, relative_position, gravity) + assert quantized_gyroscope.measurement == approx([wx, wy, wz], abs=1e-10) + + +def test_export_accel_data_csv(ideal_accelerometer): + """Test the export_data method of accelerometer. Checks if the data is + exported correctly. + + Parameters + ---------- + flight_calisto_accel_gyro : Flight + Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. + """ + t = SOLUTION[0] + u = SOLUTION[1:] + relative_position = Vector([0, 0, 0]) + gravity = 9.81 + ideal_accelerometer.measure(t, u, UDOT, relative_position, gravity) + ideal_accelerometer.measure(t, u, UDOT, relative_position, gravity) + + file_name = "sensors.csv" + + ideal_accelerometer.export_measured_values(file_name, format="csv") + + with open(file_name, "r") as file: + contents = file.read() + + expected_data = "t,ax,ay,az\n" + for t, ax, ay, az in ideal_accelerometer.measured_values: + expected_data += f"{t},{ax},{ay},{az}\n" + + assert contents == expected_data + os.remove(file_name) + + +def test_export_accel_data_json(ideal_accelerometer): + """Test the export_data method of the accelerometer. Checks if the data is + exported correctly. + + Parameters + ---------- + flight_calisto_accel_gyro : Flight + Pytest fixture for the flight of the calisto rocket with an ideal + accelerometer and a gyroscope. + """ + t = SOLUTION[0] + u = SOLUTION[1:] + relative_position = Vector([0, 0, 0]) + gravity = 9.81 + ideal_accelerometer.measure(t, u, UDOT, relative_position, gravity) + ideal_accelerometer.measure(t, u, UDOT, relative_position, gravity) + + file_name = "sensors.json" + + ideal_accelerometer.export_measured_values(file_name, format="json") + + contents = json.load(open(file_name, "r")) + + expected_data = {"t": [], "ax": [], "ay": [], "az": []} + for t, ax, ay, az in ideal_accelerometer.measured_values: + expected_data["t"].append(t) + expected_data["ax"].append(ax) + expected_data["ay"].append(ay) + expected_data["az"].append(az) + + assert contents == expected_data + os.remove(file_name) + + +def test_export_gyro_data_csv(ideal_gyroscope): + """Test the export_data method of the gyroscope. Checks if the data is + exported correctly. + + Parameters + ---------- + flight_calisto_accel_gyro : Flight + Pytest fixture for the flight of the calisto rocket with an ideal + accelerometer and a gyroscope. + """ + t = SOLUTION[0] + u = SOLUTION[1:] + relative_position = Vector([0, 0, 0]) + ideal_gyroscope.measure(t, u, UDOT, relative_position) + ideal_gyroscope.measure(t, u, UDOT, relative_position) + + file_name = "sensors.csv" + + ideal_gyroscope.export_measured_values(file_name, format="csv") + + with open(file_name, "r") as file: + contents = file.read() + + expected_data = "t,wx,wy,wz\n" + for t, wx, wy, wz in ideal_gyroscope.measured_values: + expected_data += f"{t},{wx},{wy},{wz}\n" + + assert contents == expected_data + os.remove(file_name) + + +def test_export_gyro_data_json(ideal_gyroscope): + """Test the export_data method of the gyroscope. Checks if the data is + exported correctly. + + Parameters + ---------- + flight_calisto_accel_gyro : Flight + Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. + """ + t = SOLUTION[0] + u = SOLUTION[1:] + relative_position = Vector([0, 0, 0]) + ideal_gyroscope.measure(t, u, UDOT, relative_position) + ideal_gyroscope.measure(t, u, UDOT, relative_position) + + file_name = "sensors.json" + + ideal_gyroscope.export_measured_values(file_name, format="json") + + contents = json.load(open(file_name, "r")) + + expected_data = {"t": [], "wx": [], "wy": [], "wz": []} + for t, wx, wy, wz in ideal_gyroscope.measured_values: + expected_data["t"].append(t) + expected_data["wx"].append(wx) + expected_data["wy"].append(wy) + expected_data["wz"].append(wz) + + assert contents == expected_data + os.remove(file_name) From 5ae01b9f5db9e17a8a9f0ac38ee33cc2e793dab6 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 1 Apr 2024 20:15:56 +0200 Subject: [PATCH 09/77] DEV: sensors testing notebook --- docs/notebooks/sensors_testing.ipynb | 690 +++++++++++++++++++++++++++ 1 file changed, 690 insertions(+) create mode 100644 docs/notebooks/sensors_testing.ipynb diff --git a/docs/notebooks/sensors_testing.ipynb b/docs/notebooks/sensors_testing.ipynb new file mode 100644 index 000000000..76a0815a9 --- /dev/null +++ b/docs/notebooks/sensors_testing.ipynb @@ -0,0 +1,690 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "nvAT8wcRNVEk" + }, + "source": [ + "# -----------\n", + "\n", + "notebook to test sensors... should not be merged" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "XGK9M8ecNVEp" + }, + "outputs": [], + "source": [ + "from rocketpy import Environment, SolidMotor, Rocket, Flight" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "uRa566HoNVE9" + }, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "5kl-Je8dNVFI" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Gravity Details\n", + "\n", + "Acceleration of gravity at surface level: 9.7913 m/s²\n", + "Acceleration of gravity at 10.000 km (ASL): 9.7649 m/s²\n", + "\n", + "\n", + "Launch Site Details\n", + "\n", + "Launch Site Latitude: 32.99025°\n", + "Launch Site Longitude: -106.97500°\n", + "Reference Datum: SIRGAS2000\n", + "Launch Site UTM coordinates: 315468.64 W 3651938.65 N\n", + "Launch Site UTM zone: 13S\n", + "Launch Site Surface Elevation: 1400.0 m\n", + "\n", + "\n", + "Atmospheric Model Details\n", + "\n", + "Atmospheric Model Type: custom_atmosphere\n", + "custom_atmosphere Maximum Height: 10.000 km\n", + "\n", + "\n", + "Surface Atmospheric Conditions\n", + "\n", + "Surface Wind Speed: 4.69 m/s\n", + "Surface Wind Direction: 219.81°\n", + "Surface Wind Heading: 39.81°\n", + "Surface Pressure: 856.02 hPa\n", + "Surface Temperature: 279.07 K\n", + "Surface Air Density: 1.069 kg/m³\n", + "Surface Speed of Sound: 334.55 m/s\n", + "\n", + "\n", + "Earth Model Details\n", + "\n", + "Earth Radius at Launch site: 6371.83 km\n", + "Semi-major Axis: 6378.14 km\n", + "Semi-minor Axis: 6356.75 km\n", + "Flattening: 0.0034\n", + "\n", + "\n", + "Atmospheric Model Plots\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "env = Environment(latitude=32.990254, longitude=-106.974998, elevation=1400)\n", + "env.set_atmospheric_model(\n", + " type=\"custom_atmosphere\", wind_u=[(0, 3), (10000, 3)], wind_v=[(0, 5), (10000, -5)]\n", + ")\n", + "env.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "Vx1dZObwNVFX" + }, + "outputs": [], + "source": [ + "Pro75M1670 = SolidMotor(\n", + " thrust_source=\"../../data/motors/Cesaroni_M1670.eng\",\n", + " dry_mass=1.815,\n", + " dry_inertia=(0.125, 0.125, 0.002),\n", + " nozzle_radius=33 / 1000,\n", + " grain_number=5,\n", + " grain_density=1815,\n", + " grain_outer_radius=33 / 1000,\n", + " grain_initial_inner_radius=15 / 1000,\n", + " grain_initial_height=120 / 1000,\n", + " grain_separation=5 / 1000,\n", + " grains_center_of_mass_position=0.397,\n", + " center_of_dry_mass_position=0.317,\n", + " nozzle_position=0,\n", + " burn_time=3.9,\n", + " throat_radius=11 / 1000,\n", + " coordinate_system_orientation=\"nozzle_to_combustion_chamber\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "D1fyK8u_NVFh" + }, + "outputs": [], + "source": [ + "calisto = Rocket(\n", + " radius=127 / 2000,\n", + " mass=14.426,\n", + " inertia=(6.321, 6.321, 0.034),\n", + " power_off_drag=\"../../data/calisto/powerOffDragCurve.csv\",\n", + " power_on_drag=\"../../data/calisto/powerOnDragCurve.csv\",\n", + " center_of_mass_without_motor=0,\n", + " coordinate_system_orientation=\"tail_to_nose\",\n", + ")\n", + "\n", + "rail_buttons = calisto.set_rail_buttons(\n", + " upper_button_position=0.0818,\n", + " lower_button_position=-0.618,\n", + " angular_position=45,\n", + ")\n", + "\n", + "calisto.add_motor(Pro75M1670, position=-1.255)\n", + "\n", + "nose_cone = calisto.add_nose(length=0.55829, kind=\"vonKarman\", position=1.278)\n", + "\n", + "fin_set = calisto.add_trapezoidal_fins(\n", + " n=4,\n", + " root_chord=0.120,\n", + " tip_chord=0.060,\n", + " span=0.110,\n", + " position=-1.04956,\n", + " cant_angle=0.5,\n", + " airfoil=(\"../../data/calisto/NACA0012-radians.csv\", \"radians\"),\n", + ")\n", + "\n", + "tail = calisto.add_tail(\n", + " top_radius=0.0635, bottom_radius=0.0435, length=0.060, position=-1.194656\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from rocketpy import Accelerometer, Gyroscope\n", + "accel_noisy_nosecone = Accelerometer(sampling_rate=100,\n", + " consider_gravity=False,\n", + " orientation=(60,60,60),\n", + " measurement_range=70,\n", + " resolution=0.4882,\n", + " noise_density=0.05,\n", + " random_walk=0.02,\n", + " constant_bias=1 ,\n", + " operating_temperature=25,\n", + " temperature_bias=0.02,\n", + " temperature_scale_factor=0.02,\n", + " cross_axis_sensitivity=0.02,\n", + " name='Accelerometer in Nosecone'\n", + " )\n", + "accel_clean_cdm = Accelerometer(sampling_rate=100,\n", + " consider_gravity=False,\n", + " orientation=[[0.25, -0.0581, 0.9665],\n", + " [0.433, 0.8995, -0.0581],\n", + " [-0.8661, 0.433, 0.25]\n", + " ],\n", + " name='Accelerometer in CDM'\n", + " )\n", + "calisto.add_sensor(accel_noisy_nosecone, 1.278)\n", + "calisto.add_sensor(accel_clean_cdm, -0.10482544178314143)#, 127/2000)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Identification of the Sensor:\n", + "\n", + "Name: Accelerometer in Nosecone\n", + "Type: Accelerometer\n", + "\n", + "Orientation of the Sensor:\n", + "\n", + "Orientation: (60, 60, 60)\n", + "Normal Vector: (0.9665063509461097, -0.05801270189221941, 0.2500000000000002)\n", + "Rotation Matrix:\n", + " [0.25, -0.06, 0.97]\n", + " [0.43, 0.9, -0.06]\n", + " [-0.87, 0.43, 0.25]\n", + "\n", + "Quantization of the Sensor:\n", + "\n", + "Measurement Range: -70 to 70 (m/s^2)\n", + "Resolution: 0.4882 m/s^2/LSB\n", + "\n", + "Noise of the Sensor:\n", + "\n", + "Noise Density: (0.05, 0.05, 0.05) m/s^2/√Hz\n", + "Random Walk: (0.02, 0.02, 0.02) m/s^2/√Hz\n", + "Constant Bias: (1, 1, 1) m/s^2\n", + "Operating Temperature: 25 °C\n", + "Temperature Bias: (0.02, 0.02, 0.02) m/s^2/°C\n", + "Temperature Scale Factor: (0.02, 0.02, 0.02) %/°C\n", + "Cross Axis Sensitivity: 0.02 %\n", + "Identification of the Sensor:\n", + "\n", + "Name: Accelerometer in CDM\n", + "Type: Accelerometer\n", + "\n", + "Orientation of the Sensor:\n", + "\n", + "Orientation: [[0.25, -0.0581, 0.9665], [0.433, 0.8995, -0.0581], [-0.8661, 0.433, 0.25]]\n", + "Normal Vector: (0.9665010341566599, -0.05810006216709978, 0.25000026750042936)\n", + "Rotation Matrix:\n", + " [0.25, -0.06, 0.97]\n", + " [0.43, 0.9, -0.06]\n", + " [-0.87, 0.43, 0.25]\n", + "\n", + "Quantization of the Sensor:\n", + "\n", + "Measurement Range: -inf to inf (m/s^2)\n", + "Resolution: 0 m/s^2/LSB\n", + "\n", + "Noise of the Sensor:\n", + "\n", + "Noise Density: (0, 0, 0) m/s^2/√Hz\n", + "Random Walk: (0, 0, 0) m/s^2/√Hz\n", + "Constant Bias: (0, 0, 0) m/s^2\n", + "Operating Temperature: 25 °C\n", + "Temperature Bias: (0, 0, 0) m/s^2/°C\n", + "Temperature Scale Factor: (0, 0, 0) %/°C\n", + "Cross Axis Sensitivity: 0 %\n" + ] + } + ], + "source": [ + "accel_noisy_nosecone.prints.all()\n", + "accel_clean_cdm.prints.all() # should have the same rotation matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "gyro_clean = Gyroscope(sampling_rate=100)\n", + "gyro_noisy = Gyroscope(sampling_rate=100, \n", + " orientation=(180, 0, 0),\n", + " acceleration_sensitivity=0.02,\n", + " measurement_range=70,\n", + " resolution=0.4882,\n", + " noise_density=0.05,\n", + " random_walk=0.02,\n", + " constant_bias=1 ,\n", + " operating_temperature=25,\n", + " temperature_bias=0.02,\n", + " temperature_scale_factor=0.02,\n", + " cross_axis_sensitivity=0.02,\n", + " )\n", + "calisto.add_sensor(gyro_clean, -0.10482544178314143+0.5, 127/2000)\n", + "calisto.add_sensor(gyro_noisy, 1.278-0.4, 127/2000-127/4000)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "calisto.draw(plane=\"xz\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "calisto.draw(plane=\"yz\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def controller_function(\n", + " time, sampling_rate, state, state_history, observed_variables, air_brakes, sensors\n", + "):\n", + " # state = [x, y, z, vx, vy, vz, e0, e1, e2, e3, wx, wy, wz]\n", + " altitude_ASL = state[2]\n", + " altitude_AGL = altitude_ASL - env.elevation\n", + " vx, vy, vz = state[3], state[4], state[5]\n", + "\n", + " # Get winds in x and y directions\n", + " wind_x, wind_y = env.wind_velocity_x(altitude_ASL), env.wind_velocity_y(\n", + " altitude_ASL\n", + " )\n", + "\n", + " # Calculate Mach number\n", + " free_stream_speed = ((wind_x - vx) ** 2 + (wind_y - vy) ** 2 + (vz) ** 2) ** 0.5\n", + " mach_number = free_stream_speed / env.speed_of_sound(altitude_ASL)\n", + "\n", + " # Get previous state from state_history\n", + " previous_state = state_history[-1]\n", + " previous_vz = previous_state[5]\n", + "\n", + " # If we wanted to we could get the returned values from observed_variables:\n", + " # returned_time, deployment_level, drag_coefficient = observed_variables[-1]\n", + "\n", + "\n", + " # Check if the rocket has reached burnout\n", + " accelerometer = sensors[0]\n", + " if accelerometer.measurement[2] > 0:\n", + " return None\n", + "\n", + " # If below 1500 meters above ground level, air_brakes are not deployed\n", + " if altitude_AGL < 1500:\n", + " air_brakes.deployment_level = 0\n", + "\n", + " # Else calculate the deployment level\n", + " else:\n", + " # Controller logic\n", + " new_deployment_level = (\n", + " air_brakes.deployment_level + 0.1 * vz + 0.01 * previous_vz**2\n", + " )\n", + "\n", + " # Limiting the speed of the air_brakes to 0.2 per second\n", + " # Since this function is called every 1/sampling_rate seconds\n", + " # the max change in deployment level per call is 0.2/sampling_rate\n", + " max_change = 0.2 / sampling_rate\n", + " lower_bound = air_brakes.deployment_level - max_change\n", + " upper_bound = air_brakes.deployment_level + max_change\n", + " new_deployment_level = min(max(new_deployment_level, lower_bound), upper_bound)\n", + "\n", + " air_brakes.deployment_level = new_deployment_level\n", + "\n", + " # Return variables of interest to be saved in the observed_variables list\n", + " return (\n", + " time,\n", + " air_brakes.deployment_level,\n", + " air_brakes.drag_coefficient(air_brakes.deployment_level, mach_number),\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "air_brakes = calisto.add_air_brakes(\n", + " drag_coefficient_curve=\"../../data/calisto/air_brakes_cd.csv\",\n", + " controller_function=controller_function,\n", + " sampling_rate=10,\n", + " reference_area=None,\n", + " clamp=True,\n", + " initial_observed_variables=[0, 0, 0],\n", + " override_rocket_drag=False,\n", + " name=\"AirBrakes\",\n", + " controller_name=\"AirBrakes Controller\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# air_brakes.all_info()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "v__Ud2p2NVFx" + }, + "outputs": [], + "source": [ + "test_flight = Flight(\n", + " rocket=calisto,\n", + " environment=env,\n", + " rail_length=5.2,\n", + " inclination=85,\n", + " heading=0,\n", + " time_overshoot=False,\n", + " terminate_on_apogee=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "test_flight.altitude()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGdCAYAAAA44ojeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABQ7ElEQVR4nO3dd3yUZb7//9c9k2TSE0K6JHSkV6XYEVyKsqis7bC76LEdheWrrD/3sGtF96Db9Ohi20VZdxXLUbEjiAJSFVhABakBghBaSO8z1++PSQaSDJCEDDPMvJ+PxzwymbvMZ24Y7jfXfV3XbRljDCIiIiIBxObvAkREREQaUkARERGRgKOAIiIiIgFHAUVEREQCjgKKiIiIBBwFFBEREQk4CigiIiIScBRQREREJOCE+buAlnC5XOzbt4+4uDgsy/J3OSIiItIExhiKi4vJzMzEZjt5G8lZGVD27dtHVlaWv8sQERGRFsjNzaVdu3YnXeesDChxcXGA+wPGx8f7uRoRERFpiqKiIrKysjzn8ZM5KwNK3WWd+Ph4BRQREZGzTFO6Z6iTrIiIiAQcBRQREREJOAooIiIiEnDOyj4oIiKByhhDTU0NTqfT36WInHF2u52wsLBWmQJEAUVEpJVUVVWxf/9+ysrK/F2KiN9ER0eTkZFBRETEae1HAUVEpBW4XC5ycnKw2+1kZmYSERGhiSQlpBhjqKqq4tChQ+Tk5NC1a9dTTsZ2MgooIiKtoKqqCpfLRVZWFtHR0f4uR8QvoqKiCA8PZ/fu3VRVVREZGdnifamTrIhIKzqd/zGKBIPW+g7omyQiIiIBRwFFRERaTYcOHXj66af9XYbPLF68GMuyKCgo8HcpQU8BRUQkxN18881YlsUTTzxR7/V58+Y1u6PvN998wx133NGa5Xk1atQo7HY733zzjc/fK9icLSFSAUVERIiMjOTJJ5/k6NGjp7WflJQUn3cS3rNnDytWrGDKlCm8/PLLPn0vX6iqqvJ3Ca3C159DAUVaxuWEVc/DvvX+rkREWsHIkSNJT09n5syZJ13vnXfeoVevXjgcDjp06MCf//znesuP/9+5MYZHHnmE7OxsHA4HmZmZTJ06FYAZM2bQu3fvRvvv378/Dz744ElreOWVV7jqqqu46667mDt3LuXl5fWWFxQUcOedd5KWlkZkZCS9e/fmo48+8ixfvnw5l112GdHR0bRp04ZRo0Z5gpnL5WLmzJl07NiRqKgo+vXrx//93/+dtJ5ly5Zx8cUXExUVRVZWFlOnTqW0tLTeMXnsscf45S9/SXx8vKeFqSnH8vHHH+eXv/wlsbGxtG/fng8++IBDhw4xfvx4YmNj6du3L2vWrGlyPZdddhm7d+/m3nvvxbKsei1kLf0cPmPOQoWFhQYwhYWF/i4ldK191ZiH490PETHl5eVm06ZNpry83POay+UypZXVZ/zhcrmaVfukSZPM+PHjzbvvvmsiIyNNbm6uMcaY9957zxx/mlizZo2x2WxmxowZZsuWLeaVV14xUVFR5pVXXvGs0759e/PUU08ZY4x5++23TXx8vPnkk0/M7t27zerVq81LL71kjDEmNzfX2Gw28/XXX3u2XbdunbEsy+zYseOEtbpcLtO+fXvz0UcfGWOMGTRokHn11Vc9y51Opxk6dKjp1auXWbBggdmxY4f58MMPzSeffGKMMebf//63cTgc5q677jLr16833333nXn22WfNoUOHjDHGPP7446Z79+5m/vz5ZseOHeaVV14xDofDLF682BhjzJdffmkAc/ToUWOMMdu3bzcxMTHmqaeeMlu3bjXLly83AwYMMDfffHO9YxIfH2/+9Kc/me3bt5vt27c3+VgmJSWZF154wWzdutXcddddJj4+3owePdq89dZbZsuWLebqq682PXr08PyZn6qeI0eOmHbt2pkZM2aY/fv3m/3795/W5/DG23ehTnPO35Yxxvg2ArW+oqIiEhISKCwsJD4+3t/lhKZPfwOrX3A/f6TQv7WIBICKigpycnLo2LGjZ+6Hsqoaej702RmvZdOMUURHNH2aq5tvvpmCggLmzZvHsGHD6NmzJ7Nnz2bevHlcc8011J0mJk6cyKFDh1iwYIFn2/vvv5+PP/6Y77//HnD/L/uee+7hnnvu4S9/+Qsvvvgi3333HeHh4Y3ed+zYsXTo0IHnnnsOgKlTp/Ltt9/y5ZdfnrDWhQsXMnHiRPbt20dYWBhPP/008+bNY/HixQAsWLCAMWPGsHnzZrp169Zo+//4j/9gz549LFu2rNGyyspKkpKS+Pzzzxk2bJjn9dtuu42ysjJef/11Fi9ezPDhwzl69CiJiYncdttt2O12XnzxRc/6y5Yt49JLL6W0tJTIyEg6dOjAgAEDeO+99zzrNPVYXnzxxfzzn/8EIC8vj4yMDB588EFmzJgBwKpVqxg2bBj79+8nPT29yfXU/Rkd/xlb8jm88fZdqNOc87cu8YiIiMeTTz7JP/7xDzZv3txo2ebNm7nwwgvrvXbhhReybds2r/ceuu666ygvL6dTp07cfvvtvPfee9TU1HiW33777cydO5eKigqqqqp4/fXX+c///M+T1vfyyy9zww03EBbmDmA33XQTy5cvZ8eOHQCsX7+edu3aeQ0ndctHjBjhddn27dspKyvjiiuuIDY21vN49dVXPftvaMOGDcyZM6fe+qNGjfLMLFznvPPOq7ddU49l3759Pc/T0tIA6NOnT6PXDh482Kx6Wutz+JJmkhUR8ZGocDubZozyy/u21CWXXMKoUaOYPn06N99882nVkZWVxZYtW/j8889ZuHAhd999N3/84x9ZsmQJ4eHhjBs3DofDwXvvvUdERATV1dX87Gc/O+H+8vPzee+996iurub555/3vO50Onn55Zf5/e9/T1RU1ElrOtnykpISAD7++GPOOeecesscDscJt7nzzjs9fWuOl52d7XkeExNz0rpO5PiWp7r+It5ec7lczaqnIV9/jpZQQBER8RHLspp1qSVQPPHEE/Tv359zzz233us9evRg+fLl9V5bvnw53bp1w273HoqioqIYN24c48aNY/LkyXTv3p1vv/2WgQMHEhYWxqRJk3jllVeIiIjgxhtvPGmAeO2112jXrh3z5s2r9/qCBQv485//zIwZM+jbty979+5l69atXltR+vbty6JFi3j00UcbLevZsycOh4M9e/Zw6aWXnrCO4w0cOJBNmzbRpUuXJq1fpyXHsrXqiYiIaNTi1dLP4Utn3zdHRER8qk+fPkycOJFnnnmm3uu//vWvOf/883nssce44YYbWLlyJX/96189fUgamjNnDk6nkyFDhhAdHc2//vUvoqKiaN++vWed2267jR49egA0OmE3NHv2bH72s581Gv2TlZXF9OnTmT9/PldeeSWXXHIJEyZM4C9/+QtdunThhx9+wLIsRo8ezfTp0+nTpw933303//Vf/0VERARffvkl1113HcnJydx3333ce++9uFwuLrroIgoLC1m+fDnx8fFMmjSpUU2/+c1vGDp0KFOmTOG2224jJiaGTZs2sXDhQv7617+e8LM091g2VVPq6dChA0uXLuXGG2/E4XCQnJzc4s/hS+qDIiIijcyYMcNz2aDOwIEDeeutt3jjjTfo3bs3Dz30EDNmzDjhpaDExET+9re/ceGFF9K3b18+//xzPvzwQ9q2betZp2vXrlxwwQV0796dIUOGnLCetWvXsmHDBiZMmNBoWUJCAiNGjGD27NmAe/ju+eefz0033UTPnj25//77PS0G3bp1Y8GCBWzYsIHBgwczbNgw3n//fU+flscee4wHH3yQmTNn0qNHD0aPHs3HH39Mx44dvdbVt29flixZwtatW7n44osZMGAADz30EJmZmSc+uC04lk3VlHpmzJjBrl276Ny5MykpKaf1OXxJo3ikZTSKR6Sek41ckBMzxtC1a1fuvvtupk2b5u9ypBW01igeXeIRERG/OHToEG+88QZ5eXnccsst/i5HAowCioiI+EVqairJycm89NJLtGnTxt/lSIBRQBEREb84C3sYyBmkTrIiIiIScBRQREREJOAooIiIiEjAUUARERGRgKOAIiIiIgFHAUVEREQCjgKKiIg0iWVZjW7UF6o6dOjA008/7e8ygpoCioiIkJeXx69+9Ss6deqEw+EgKyuLcePGsWjRIn+XdkJz587FbrczefJkf5dy1nnkkUfo37+/v8s4KQUUEZEQt2vXLgYNGsQXX3zBH//4R7799lvmz5/P8OHDA/rkP3v2bO6//37mzp1LRUWFv8tplqqqKn+X0Cp8+TkUUEREQtzdd9+NZVl8/fXXTJgwgW7dutGrVy+mTZvGqlWrTrhdbm4u119/PYmJiSQlJTF+/Hh27drlWf7NN99wxRVXkJycTEJCApdeeinr1q2rtw/Lsvj73//ONddcQ3R0NF27duWDDz44Zc05OTmsWLGC//7v/6Zbt268++67jdZ5+eWX6dWrFw6Hg4yMDKZMmeJZVlBQwJ133klaWhqRkZH07t2bjz76yLN82bJlXHzxxURFRZGVlcXUqVMpLS09YT0FBQXcdtttpKSkEB8fz+WXX86GDRs8y+taLP7+97/Xu4nenj17GD9+PLGxscTHx3P99ddz4MCBRtu9/PLLZGdnExsby913343T6eQPf/gD6enppKam8vvf/77J9cyZM4dHH32UDRs2YFkWlmUxZ86c0/ocvqCAIiLiK8ZAVemZfzRjCvn8/Hzmz5/P5MmTiYmJabQ8MTHR63bV1dWMGjWKuLg4vvrqK5YvX05sbCyjR4/2/K+6uLiYSZMmsWzZMlatWkXXrl0ZO3YsxcXF9fb16KOPcv3117Nx40bGjh3LxIkTyc/PP2ndr7zyCldeeSUJCQn8/Oc/Z/bs2fWWP//880yePJk77riDb7/9lg8++IAuXboA4HK5GDNmDMuXL+df//oXmzZt4oknnsButwOwY8cORo8ezYQJE9i4cSNvvvkmy5YtqxdwGrruuus4ePAgn376KWvXrmXgwIGMGDGi3ufYvn0777zzDu+++y7r16/H5XIxfvx48vPzWbJkCQsXLmTnzp3ccMMN9fa9Y8cOPv30U+bPn8/cuXOZPXs2V155JXv37mXJkiU8+eSTPPDAA6xevbpJ9dxwww38+te/plevXuzfv5/9+/d73rMln8NnzFmosLDQAKawsNDfpYSuT+435uF490NETHl5udm0aZMpLy8/9mJlybHvyZl8VJY0ue7Vq1cbwLz77runXBcw7733njHGmH/+85/m3HPPNS6X69jHraw0UVFR5rPPPvO6vdPpNHFxcebDDz+st88HHnjA83tJSYkBzKeffnrCOpxOp8nKyjLz5s0zxhhz6NAhExERYXbu3OlZJzMz0/zud7/zuv1nn31mbDab2bJli9flt956q7njjjvqvfbVV18Zm83m+fNt3769eeqppzzL4uPjTUVFRb1tOnfubF588UVjjDEPP/ywCQ8PNwcPHvQsX7BggbHb7WbPnj2e177//nsDmK+//tqzXXR0tCkqKvKsM2rUKNOhQwfjdDo9r5177rlm5syZzaqnX79+jT5jSz5HQ16/C7Wac/7WzQJFREKYaeEN+zZs2MD27duJi4ur93pFRQU7duwA4MCBAzzwwAMsXryYgwcP4nQ6KSsrY8+ePfW26du3r+d5TEwM8fHxHDx48ITvvXDhQkpLSxk7diwAycnJXHHFFbz88ss89thjHDx4kH379jFixAiv269fv5527drRrVu3E362jRs38tprr3leM8bgcrnIycmhR48ejdYvKSmhbdu29V4vLy/3HAuA9u3bk5KS4vl98+bNZGVlkZWV5XmtZ8+eJCYmsnnzZs4//3zAPWLo+OOclpaG3W7HZrPVe63umDW1Hm+fuyWfw1cUUEREfCU8Gn67zz/v20Rdu3bFsix++OGHZr1FSUkJgwYNqncSr1N38po0aRJHjhzhf//3f2nfvj0Oh4Nhw4Y16lgZHh5e73fLsnC5XCd879mzZ5Ofn09UVJTnNZfLxcaNG3n00Ufrve7NqZaXlJRw5513MnXq1EbLsrOzva6fkZHB4sWLGy07/hKZt0toTeHt+JzsmDW1noZ8/TmaSwFFRMRXLAsizsw/5i2VlJTEqFGjmDVrFlOnTm108ikoKPB6Uhs4cCBvvvkmqampxMfHe9338uXLee655zwtHbm5uRw+fPi06j1y5Ajvv/8+b7zxBr169fK87nQ6ueiii1iwYAGjR4+mQ4cOLFq0iOHDhzfaR9++fdm7dy9bt2712ooycOBANm3a5OmzcioDBw4kLy+PsLAwOnTo0OTP0qNHD3Jzc8nNzfW0omzatImCggJ69uzZ5P20pJ6IiAicTmeztzuT1ElWRCTEzZo1C6fTyeDBg3nnnXfYtm0bmzdv5plnnmHYsGFet5k4cSLJycmMHz+er776ipycHBYvXszUqVPZu3cv4G6d+ec//8nmzZtZvXo1EydOPGXrxan885//pG3btlx//fX07t3b8+jXrx9jx471dJZ95JFH+POf/8wzzzzDtm3bWLduHc8++ywAl156KZdccgkTJkxg4cKF5OTkeDqhAvzmN79hxYoVTJkyhfXr17Nt2zbef//9E3aSHTlyJMOGDePqq69mwYIF7Nq1ixUrVvC73/2ONWvWnPCzjBw5kj59+jBx4kTWrVvH119/zS9/+UsuvfRSzjvvvBYfo6bU06FDB3Jycli/fj2HDx+msrKyxZ/DVxRQRERCXKdOnVi3bh3Dhw/n17/+Nb179+aKK65g0aJFPP/88163iY6OZunSpWRnZ3PttdfSo0cPbr31VioqKjwtKrNnz+bo0aMMHDiQX/ziF0ydOpXU1NTTqvXll1/mmmuuwbKsRssmTJjABx98wOHDh5k0aRJPP/00zz33HL169eKqq65i27ZtnnXfeecdzj//fG666SZ69uzJ/fff72lR6Nu3L0uWLGHr1q1cfPHFDBgwgIceeojMzEyvNVmWxSeffMIll1zCLbfcQrdu3bjxxhvZvXs3aWlpJ/wslmXx/vvv06ZNGy655BJGjhxJp06dePPNN0/rGDWlngkTJjB69GiGDx9OSkoKc+fObfHn8BXLtLSHlB8VFRWRkJBAYWHhCZsWxcc+/Q2sfsH9/JFC/9YiEgAqKirIycnx+dwQIoHuZN+F5py/1YIiIiIiAUcBRURERAKOAoqIiIgEHAUUERERCTgKKCIiIhJwFFBERFrRWTgwUqRVtdZ3QAFFRKQV1E09XlZW5udKRPyr7jvQcDr+5tJU9yIircBut5OYmOi5YVt0dLTXycREgpUxhrKyMg4ePEhiYiJ2u/209qeAIiLSStLT0wFOeidekWCXmJjo+S6cDgUUEZFWYlkWGRkZpKamUl1d7e9yRM648PDw0245qaOAIiLSyux2e6v9Iy0SqtRJVkRERAKOAoqIiIgEHAUUERERCTgKKCIiIhJwFFBEREQk4CigiIiISMBRQBEREZGAo4AiIiIiAUcBRURERAKOAoqIiIgEHAUUERERCTgKKCIiIhJwmh1Qli5dyrhx48jMzMSyLObNm1dv+c0334xlWfUeo0ePrrdOfn4+EydOJD4+nsTERG699VZKSkpO64OIiIhI8Gh2QCktLaVfv37MmjXrhOuMHj2a/fv3ex5z586tt3zixIl8//33LFy4kI8++oilS5dyxx13NL96ERERCUphzd1gzJgxjBkz5qTrOBwO0tPTvS7bvHkz8+fP55tvvuG8884D4Nlnn2Xs2LH86U9/IjMzs7kliYiISJDxSR+UxYsXk5qayrnnnstdd93FkSNHPMtWrlxJYmKiJ5wAjBw5EpvNxurVq31RjoiIiJxlmt2CciqjR4/m2muvpWPHjuzYsYPf/va3jBkzhpUrV2K328nLyyM1NbV+EWFhJCUlkZeX53WflZWVVFZWen4vKipq7bJFREQkgLR6QLnxxhs9z/v06UPfvn3p3LkzixcvZsSIES3a58yZM3n00Udbq0QREREJcD4fZtypUyeSk5PZvn07AOnp6Rw8eLDeOjU1NeTn55+w38r06dMpLCz0PHJzc31dtoiIiPiRzwPK3r17OXLkCBkZGQAMGzaMgoIC1q5d61nniy++wOVyMWTIEK/7cDgcxMfH13uIiIhI8Gr2JZ6SkhJPawhATk4O69evJykpiaSkJB599FEmTJhAeno6O3bs4P7776dLly6MGjUKgB49ejB69Ghuv/12XnjhBaqrq5kyZQo33nijRvCIiIgI0IIWlDVr1jBgwAAGDBgAwLRp0xgwYAAPPfQQdrudjRs38tOf/pRu3bpx6623MmjQIL766iscDodnH6+99hrdu3dnxIgRjB07losuuoiXXnqp9T6VnAGWvwsQEZEg1uwWlMsuuwxjzAmXf/bZZ6fcR1JSEq+//npz31oCyon/DoiIiJwu3YtHREREAo4CioiIiAQcBRQREREJOAooIiIiEnAUUERERCTgKKCIiIhIwFFAERERkYCjgCIiIiIBRwFFREREAo4CioiIiAQcBRQREREJOAooIiIiEnAUUERERCTgKKCIiIhIwFFAERERkYCjgCIiIiIBRwFFREREAo4CioiIiAQcBRQREREJOAooIiIiEnAUUERERCTgKKCIiIhIwFFAERERkYCjgCIiIiIBRwFFREREAo4CirSQ5e8CREQkiCmgSAsZfxcgIiJBTAFFREREAo4CioiIiAQcBRQREREJOAooIiIiEnAUUERERCTgKKBIC2mYsYiI+I4CirSQhhmLiIjvKKCIiIhIwFFAERERkYCjgCIiIiIBRwFFREREAo4CioiIiAQcBRRpIQ0zFhER31FAkRbSMGMREfEdBRQREREJOAooIiIiEnAUUERERCTgKKCIiIhIwFFAkRbSKB4REfEdBRRpIY3iERER31FAERERkYCjgCIiIiIBRwFFREREAo4CioiIiAQcBRQREREJOAoo0kIaZiwiIr6jgCItpGHGIiLiOwooIiIiEnAUUERERCTgKKCIiIhIwFFAERERkYCjgCIiIiIBRwFFWkjDjEVExHcUUKSFNMxYRER8RwFFREREAo4CioiIiAQcBRQREREJOAooIiIiEnAUUERERCTgKKBIC2mYsYiI+I4CirSQhhmLiIjvKKCIiIhIwFFAERERkYCjgCIiIiIBp9kBZenSpYwbN47MzEwsy2LevHn1lhtjeOihh8jIyCAqKoqRI0eybdu2euvk5+czceJE4uPjSUxM5NZbb6WkpOS0PoiIiIgEj2YHlNLSUvr168esWbO8Lv/DH/7AM888wwsvvMDq1auJiYlh1KhRVFRUeNaZOHEi33//PQsXLuSjjz5i6dKl3HHHHS3/FOIHGsUjIiK+E9bcDcaMGcOYMWO8LjPG8PTTT/PAAw8wfvx4AF599VXS0tKYN28eN954I5s3b2b+/Pl88803nHfeeQA8++yzjB07lj/96U9kZmaexscRERGRYNCqfVBycnLIy8tj5MiRntcSEhIYMmQIK1euBGDlypUkJiZ6wgnAyJEjsdlsrF692ut+KysrKSoqqvcQf9MwYxER8Z1WDSh5eXkApKWl1Xs9LS3NsywvL4/U1NR6y8PCwkhKSvKs09DMmTNJSEjwPLKyslqzbO8qi+Hfr0FZvu/fS0REROo5K0bxTJ8+ncLCQs8jNzfX92/6wVR4/274v//0/XuJiIhIPa0aUNLT0wE4cOBAvdcPHDjgWZaens7BgwfrLa+pqSE/P9+zTkMOh4P4+Ph6D5/7/l33z51f+v69REREpJ5WDSgdO3YkPT2dRYsWeV4rKipi9erVDBs2DIBhw4ZRUFDA2rVrPet88cUXuFwuhgwZ0prliIiIyFmq2aN4SkpK2L59u+f3nJwc1q9fT1JSEtnZ2dxzzz08/vjjdO3alY4dO/Lggw+SmZnJ1VdfDUCPHj0YPXo0t99+Oy+88ALV1dVMmTKFG2+8USN4zioaZiwiIr7T7ICyZs0ahg8f7vl92rRpAEyaNIk5c+Zw//33U1payh133EFBQQEXXXQR8+fPJzIy0rPNa6+9xpQpUxgxYgQ2m40JEybwzDPPtMLHOcsU5MKSJ2D3CsgeBhdMhdTu/q5KRETE7yxjzFk3XrSoqIiEhAQKCwt91x/lkYTjnhe2/v6//T94fwrUlB97zbLDsMkw4mGwNzs7nlmf/gZWv+B+7ovjIyIiQac55++zYhSPX1n21t2fMbDsaXjnVnc4aX8h/PSvcO6VYJyw4hl48+fgrGnd9xURETmLKKCcSljkqddpKmcNfHIffP6w+/ehk2HSRzDwF3DT63D9qxAWBVs/dV/6ERERCVEKKN4cf9UrLKJ19nlkB/zrWvjm74AFo/4HRv8P2I77I+g5Hq6uvcfRsqchP6d13ltEROQsE+AdHfyk+rh+IXZHy/ZR+CPM/w3k7wJXNRz6wf16WBRM+Bv0GOd9u94T4N//gh1fwFd/hvF/bdn7i4iInMXUguJN5XH3+rGHN3/7XcvgpUth84dw4NvacGJB11HwX8tOHE7qXHK/++d370B5QfPf/4zQMGMREfEdtaB4U1l87LmzqunbGQOrnocFD7g7vKb1geG/dV8mSusNcd5nym0keyik9oSDm2DjWzDkjubVLyIicpZTC4o3Fce1oNRUNG2b6gp49w74bLo7nPS5Hm5dAN3HQpeRTQ8nAJYFg252P1//r6Zvd0addaPTRUTkLKKA4k3lcfN61FSeev3SI/DqePj2LbCFwZg/wLUvQUR0y2vocx3YwmH/BjiwqeX7EREROQspoHhz/BwkNRX1R/U0lL8TZo+E3FXgSICfvwtD7nS3gpyO6CToNsr9fMPrp7cvERGRs4wCijfGVf93Z7X39Q5vg1fGukNKQrb7kk6nS1uvjv7/4f654U1N3CYiIiFFAcWrBi0m3vqhHPwB5lwJxfshpTvc9nnr30enyxUQ3RZKD7qHHde979ybYM5V7nv4+I1G8YiIiO8ooHjTsAWlYT+UA5vc4aTkgHt0zs0fQ1xa69cRFuHuiwKw6jnYuwZeGQ1bPoFdX8Fr17lbcURERIKMAoo3jQLKcS0oxsB7d0LZYUjvC5M+hJhk39Uy+A6wR8DOL+HvI6D8KGQOdD+qSmDRo75775PSKB4REfEdBRRvGvVBOW4ulNzVkLfRfY+en7/r7szqS207w+gnjt208NwrYdIHcPXzgOWeDO7gD76tQURE5AzTRG3eNBy1c3wLytcvuX/2uQ5iU85MPeff6p591lUD8Znu11K7w7ljYcvH7rlSfvL4malFRETkDFALijcnusRTnAeb3nc/H3z7ma0pNvVYOKkzYKL758a3wOVqvI2IiMhZSgHFmxN1kl37D3crRtYQyOh35utqqMsV7rlXSg7Aj2v9XY2IiEirUUDxptElnkr3XChrXnb/PjhA7o0TFgFdRrifb/nkDL+5hhmLiIjvKKB45SWgbP4QSvIgJhV6/NQ/ZXlz7hj3zy2f+rcOERGRVqSA4o23Pijf/N39fNDN7paLQNFlJFg2OLQZCvacwTfWMGMREfEdBRRvGgaUfetg93L3UN/zbvFPTScSnQTtBrufb1vo31pERERaiQKKNw0Dypo57p89rmo8kiYQdL3C/fP4gLJ3Daz4q3vkkYiIyFlGAcWbhp1kKwvdP88/w0OLm6rrT9w/c5a4+8vs+ze8PAoW/M59M8NqL/cSEhERCWAKKN40bEEBSOkBHS4687U0RXofiE2H6jL3pahFM9zDoQHyd8C3b/u3PhERkWZSQPHGW0AZfDtYATq01rKOXeb58P+573xsC3N36AVY/5ov3tQH+xQREXFTQPGmYUBxxEPfG/xTS1MNqu28WzeSZ8Av4NL/BizYsxIK9/qtNBERkeZSQPGqQR+Ugb8ER6x/SmmqdoOg1zXu59HJcNl/Q3wGZA91v7bpg1Z+Qw0zFhER39HNAr2p6yTb9SfuWWM7DfdvPU117d+h/0RI6Q5x6e7Xel7tbkHZNA+G3e3P6kRERJpMLSje1F3iiYhx9+2wnyU5zh7mrjcx69hrPWtnvc1dDYU/+qcuERGRZlJA8aYuoFhBcHjiMyGr9jLP5ta+zCMiIuIbQXAG9gHPPChBMlKlrm/K9/P8WoaIiEhTKaB4E0wtKHDcZZ5V8M7t8Np1MP+3pzmBW5CENxERCUhBcgZuZcEWUOIzj802++1bsG0BrJoFG9/wb10iIiInECRn4FYWbAEF4KfPQu+fQefLITbN/dppzY2iYcYiIuI7QXQGbk21J99AnTm2JeLS4Wez4RfvuYciA1QW+7cmERGRE1BA8cbTghJEAeV4dZPOVZb4tw4REZETUEDxJhgv8RwvIs79s0otKCIiEpiC9Ax8muqGGQdrQGmVFpQgbV0SEZGAEKRn4NPkuVlgkJ6EI2oDSpUu8YiISGBSQPEm6FtQai/xqJOsiIgEqCA9A5+mYO+D4gkop9OComHGIiLiO2fJXfDOrPKqaqKAFTvz+fDdjf4up9WlVvzIvUBVWSERLdyHyxilWxER8RkFFC+27C+kP7DlQAlzf8z1dzmtLoNC7o0EqkoorawhxtH8vwZbDxTTvfVLExERARRQvKp2ui/xtI2N5L7B3fxcTeuLqCmBFRBhOdlfWERMalKz91FQVu2DykRERNwUULxxOQFoGxfFTy/v6udifMDlhBXupwUFR2nfgoAStCOcREQkIKgbgRemtpOsZQvSw2OzU4EDgMqSAv/WIiIi4kWQnoFPjyegBOtU90C5LRqA6rIiP1ciIiLSmAKKF8YzD4rdv4X4UKUtCoCqFgcUDTMWERHfUUDxxhXkl3iAKnsMAM4KTdYmIiKBJ3jPwKfh2CWe4D08dQHFpYAiIiIBKHjPwKcjBPqgOMMUUEREJHApoHhR1wclmC/xOMPdAcWqamlACd7wJiIi/he8Z+DTEQKXeFy1dzS2dEdjEREJQMF7Bj4ddTcLDOIWFFMbUGzVpS3dQ+sVIyIi0kDwnoFPg6kdxWML4hYUq/aOxvZqtaCIiEjgCd4z8GmpbR0I4hYUW21ACasp83MlIiIijQXvGfh01F3iCeIWFFuUO6BEOFt6iUdERMR3gvcMfBosgn+YcVhkPAARrpa2oATvsREREf9TQPHCCoGp7sOj3Z1kHa5yP1ciIiLSmAKKN3UBJYhbCSKiEgCIVEAREZEApIDixbFLPMF7eCJj3AElmnJcrpYMGdYwYxER8Z3gPQOfjtpOsiaI+6BExro7ycZQQXm108/ViIiI1KeA4oXlGWYcvH1Q6lpQYqigtLLaz9WIiIjUp4DiVe29eIK3AcUzUZvNMpSXarI2EREJLAooXlghMA8K4dG4ajsBl5cUtGAHQZzeRETE74L4DNxydcOMg7mTLJZFOZEAVJYV+bkYERGR+oL4DNxydaN4gnkeFIAKKwqAKgUUEREJMAooXoXGENoKWzQA1eUtCSihcYxERMQ/FFC88FziCeJRPABVdndAcZYV+7kSERGR+hRQvDh2iSe4O4JW1wWUSo3iERGRwKKA4sWxe/EE9+GpCYsBwFWhFhQREQksrX4GfuSRR7Asq96je/funuUVFRVMnjyZtm3bEhsby4QJEzhw4EBrl3GaQmAUD+AMdwcUU9WSFpTgbl0SERH/8skZuFevXuzfv9/zWLZsmWfZvffey4cffsjbb7/NkiVL2LdvH9dee60vymgxzzwotuAOKK7agGJVqgVFREQCS5hPdhoWRnp6eqPXCwsLmT17Nq+//jqXX345AK+88go9evRg1apVDB061BflNJtnqvsgvwJWF1BsNWV+rkRERKQ+n5yBt23bRmZmJp06dWLixIns2bMHgLVr11JdXc3IkSM963bv3p3s7GxWrlx5wv1VVlZSVFRU7+FLnrsZ24L7MoYrPBaA8JrSFmytYcYiIuI7rR5QhgwZwpw5c5g/fz7PP/88OTk5XHzxxRQXF5OXl0dERASJiYn1tklLSyMvL++E+5w5cyYJCQmeR1ZWVmuXXV8ozCQLuCLcLShhakEREZEA0+qXeMaMGeN53rdvX4YMGUL79u156623iIqKatE+p0+fzrRp0zy/FxUV+TSkeC7xBHlAIcLdghLhbEkLioiIiO/4/AycmJhIt27d2L59O+np6VRVVVFQUFBvnQMHDnjts1LH4XAQHx9f7+FLnks8oRJQXOV+LkRERKQ+n5+BS0pK2LFjBxkZGQwaNIjw8HAWLVrkWb5lyxb27NnDsGHDfF1Kk3nmQQnyUTyWo64FpSWXeIK7f46IiPhXq1/iue+++xg3bhzt27dn3759PPzww9jtdm666SYSEhK49dZbmTZtGklJScTHx/OrX/2KYcOGBcwIHjh2iccK8plkY+MTAQhrUSdZERER32n1gLJ3715uuukmjhw5QkpKChdddBGrVq0iJSUFgKeeegqbzcaECROorKxk1KhRPPfcc61dxmk5NtV9cLegpCa3BSDSlGOMCfpAJiIiZ49WDyhvvPHGSZdHRkYya9YsZs2a1dpv3WpCZar7iGh3X54YKqhyunCENefmiBpmLCIivhPcZ+AWCpVOshFRCQDEUE5FldPP1YiIiBwT3GfgFqq70GHZmtOicPYJj44DwG4ZKst1R2MREQkcCiheHGtB8XMhPmbVTnUPUFXW3IAS5AdHRET8SgHFi2MTtQV3Cwo2G6VEAlBdXujnYkRERI5RQPGi7m7GVpDPgwJQhnt23+py397fSEREpDmC/wzcAsfmQQn+w1NuuQOKs6LYz5WIiIgcE/xn4BYIlYnaACpttQGl2Z1kNcxYRER8RwHFC1uo9EEBKm3RALgq1YIiIiKBQwHFi2N9UEKhBaU2oOgSj4iIBBAFFK9CYyZZAGftUOOqsuZ2kg3+8CYiIv4T/GfgFqi7xGMLgYBij3Tf0bi8VMOMRUQkcAT/GbgFPJ1kQ2CYMRHugEKlZpIVEZHAEQJn4Oaz1d3NOCQCSu1099WlzdxQo3hERMR3QuAM3BKhc4nHcrhbUOw1zQsoITACW0RE/Cj4z8At4BlmHAItKLbaPihhNWXN2s6oAUVERHwo+M/ALeDpgxICI1XskfEARDibF1BERER8SQHFC5tnHpTgn6gtLMrdB6XZAUXXeERExIcUUE7CFgIBJSLaHVAiTTMDii7xiIiIDymgeOEZxRMCrQQR0QkARJpyP1ciIiJyjAKKFzbPPCjBH1CiY90BJdpUYJrR89Wy1IQiIiK+o4DixbG7GQf/JZ7oOHdAiaGcssqaJm+nUTwiIuJLCihehNJMspEx7lE8YZaLkrLmTtYmIiLiG8F/Bm6BULoXj1U7kyxAaXFBMzYM/stfIiLiP8F/Bm4BK4Q6yWKzUUYkAGXNCSi6xCMiIj6kgOLFsU6ywd8HBaDMigagsqTAv4WIiIjUUkBpwBjj6YNiC4E+KAAVthgAqkoLm75RCDQuiYiI/4TGGbgZjDl+FE9oHJ5KuzugVJcVNH0jDeMREREfCo0zcDMYjr/EExqHpzrMfcNAV3mRnysRERFxC40zcDO4jPHMJBsqLSg14e6A4qxo+iWeUOg/LCIi/hMaZ+BmcF/icbPsoXF4XHVDjSuKm7yNMUooIiLiO6FxBm4Gl8uFzQqtUTwuh3uyNqtKl3hERCQwKKA0cPz9aKwQGapiOdwtKPaqkmZs5KNiREREUEBpxBin57ktRFpQbFHu+/GEVTf9Eo8mahMREV9SQGnA5TquBSVERvHYI92XeMJrmnMvHiUUERHxndA4AzeDy3WsBcWyhcZ1jPAYdwtKpLPpl3g0ikdERHxJAaUB43J5nofCzQIBImISAYh0lTV5G83TJiIivhQaZ+BmMMe3oIRIQImMbQNAtGnOJR41oYiIiO+Exhm4GVzHNQ2ESifZqLhEAGIop9rpOvnKdZRPRETEhxRQGjruEk+odJKNjnO3oMRRRkl5ddM20iUeERHxodA4AzeD6/iAEiKXeMLqhhlbLkpKmjHUWERExEdC4wzcDMfPg0KIBBQiYnDW/lUoLc5v0iaWpSYUERHxnRA5Azfd8TPJhkxAsSzKiAKgoqRpNwzUKB4REfGlEDkDN93xo3hCabKPMlsMAJUlR/1ciYiIiAJKI8Z1fAtK6ASUSrs7oFSVNa0FJZSOjYiInHkKKA24avugOE1onYCr7LEAOJsaUHSJR0REfEgBpYG6FhRXiB2a6jB3C4qzosjPlYiIiCigNGbcw4xNiM1E5oyIA8CUN/USjw+LERGRkKeA0kDdzQJDLaC4wt0BhcqmzYNi6RqPiIj4kAJKQ7XjZ10h1gnURMYDYKvSRG0iIuJ/CigNuEL0Eg8OdwtKWHXTAkrIHR8RETmjFFAaqJsHJdQ6yVq1LSgRzhI/VyIiIqKA0pgrNFtQLIc7oDicZX6uRERERAGlEVdtH5RQCyi2KHdAiVQLioiIBAAFlAZMbQuKK8QCSli0+47GUa5SP1ciIiKigNKI8XSSDa1Dk5DYFoBIV1n9GyaegIYZi4iIL4XWWbgJTIj2QWmT5A4osZRRVFHj52pERCTUKaA0FKLDjCOiEwGItSoor6g65fqhdnxEROTMUkBpwIRoQKkbZgxQ2dQbBoqIiPiIAkoDxzrJhtihCXNQSTgAlaUKKCIi4l8hdhY+NU8LSohNdQ9QSjQA1aVH/VyJiIiEOgWUBkK1kyxApT0GgAMHD55yXY3iERERX1JAaShE+6AAVEYmA1Ce/6OfKxERkVCngNKA8cwkG3qHpjwyHYDdOVv9XImIiIS60DsLn8KxmwWGXgtKRXQGAKmuw6dcNxRbmERE5MxRQGnAVdsHhRDsJNuuQxcAEmsO+bkSEREJdQooDVQ73S0ooXiJJ7JtewCSXYeodrr8XI2IiISy0DsLn4Kzptr9JARbUKJTsgHItPIpKKv2czUiIhLKFFAacFa7p3mvsSL8XMmZZ0/MAiDVKuBoUfFJ19UwYxER8SUFlAZc1ZXun7ZwP1fiB9FtqcQdzIoP7fFzMSIiEsoUUBpw1rhbUJxWmJ8r8QPL4og9BYDdOzXUWERE/MevAWXWrFl06NCByMhIhgwZwtdff+3Pcnh33V7eXr0TgGpCMKCAJ6CUHT55C4qGGYuIiC/5LaC8+eabTJs2jYcffph169bRr18/Ro0axcEmTLPuKy4D4dQAcKgsNPtYhLVpB0BU2X4/VyIiIqHMbwHlL3/5C7fffju33HILPXv25IUXXiA6OpqXX37ZXyXRrk0U4ZY7oNgjQq+TLIAjyT2SJ6oiz8+ViIhIKPPLdYyqqirWrl3L9OnTPa/ZbDZGjhzJypUrG61fWVlJZWWl5/eioiKf1DWoZj1Dw/8OwMAOaT55j0BX14KSUHXAz5WIiEgo80sLyuHDh3E6naSl1Q8BaWlp5OU1/p/7zJkzSUhI8DyysrJ8Uld40bF+FzFtz/HJewS6qGR3C0pb5yHPfYm80TBjERHxpbNiFM/06dMpLCz0PHJzc33zRtnD4Mo/w/hZMPy3vnmPABef1gGAdI7w79wCv9YiIiKhyy+XeJKTk7Hb7Rw4UP8ywoEDB0hPT2+0vsPhwOFw+L6w1O7uRwhztHW3oCRapfzuzdV8+v+N9rqeRvGIiIgv+aUFJSIigkGDBrFo0SLPay6Xi0WLFjFs2DB/lCR1IhMoNlEAZNuP+LkYERE5kwrLquk4/WNmfrrZ36X47xLPtGnT+Nvf/sY//vEPNm/ezF133UVpaSm33HKLv0qSWuVtewHQt/pbP1ciIiKtrbLGidNlqHa6qKypvUGuMRhj6DdjAcbAi0t2Ulzh33uy+W02shtuuIFDhw7x0EMPkZeXR//+/Zk/f36jjrNy5lV3vBzy19CtZDV7j5bRrk20v0sSEZHTdLS0iqXbDvH/3lh/ynVjKeM/n1/I2/eO9X1hJ+DX6VKnTJnClClT/FmCeFHVcTis/QMX2L6n/5ML2fbEeH+XJCISUlwuw1trcjm/YxKdU2Kbvb3TZfjjZ1vYcaiEwR2S6J+dyHUvNJ7Go04CJZxv28IQ22YG236gt5XD65U3ASEaUCQwdeg5hEMmgRSrkPNsW6iodhIZbq+3joYZi4i0LpfL8D+fbKZvViKrdh7h9dXuqS92PXElALO+3E5BWRXFFTVMHt6FrKRofiwo538/38qNg7N5/98/sq+wgoWb6g9Aafi7gyp6WrvpZ9tBP9sO+lo76WxrPHv4gOjDPvqkTaOAIo1YNjvh3UbCtne41LaR3UfKODc9zt9liYicVVwug81m4XQZalwuHGHu/+gZY6iscREZbuebXflMf/dbfn1FN+56bZ3X/Xy8cT+TX6+/7I1v6k+38daavY22s3BxjnWYc61czrX20s2WSzfrR7paewm3nI3WL4vvRHTXS8hrM4jPijtx3YihLf3orUIBRbxK7Du2NqCs5/53NvL+5AvrLdcwYxEJVgVlVew9Wk7vcxIaLSurquGD9fu4sEsyWUnu/nk1Thdf78qn9zkJFJVXs2L7Ed7f8CPLtx/hDxP6cv87GwH4/TW9yUiI5D/nrAHgkm4pLN16COCE4QRoFE6OF00FGdYRsqxDZFkHya73OECMVel1u5rIttRkDGCrvRupPS4kvfswomPaApAOTDr1YfI5BRTxrvPlOI1FD1suh3O3YcwFWJZCiYicfSprnNz39kaGdEzi0m4pfLRxP+F2i8u7p7J06yEmDGpHXGQ4izYf4Ie8Yv742RYA3p98If2yEuvta8CMhVTWuAC4tFsKF3Ruy+ebD/DNrqNe37sunAD87r3v6i2rCycNRVNBslVICgXun1Zh7e/un8eWFRF9ggBSx9gjqEnqikntgZXSg/CMXpDWi7CELMIsi74n3dq/FFDEu+gkClMGkXR4DSPs61i2/Uou7pri76pEJEgYY3ji0x/olBLDDednt2gfX/5wkFvmfAPAW3cOY/GWgxRX1PDPVbsZ1qktTmP4Oiffs/6HG/bV2/7xj91zfTzy4Sav+x8/a/lJ33/J1kMsOUHIaMhb6EixCkluQehoqMREUhB5DvEZXVhTmMCg/v1JyOwGbTpgtelIuP3sPNWfnVXLGZHQ/6fw+RpG2tbx4LzvWPz/Dfd3SSJyBrlchooaJ9ER3k8VxhiqnQbLApcxnj4Wx6uscVJR5eKJ+ZuZ+7W738TIHqnccmFHXly6E4Cf9EwnxhFGeZWTXUdKmfrGv0mNc7DtYAkFZdXcfEEH5qzYBcDPh2bzr1V7Gr3P9S/WH6GycqdvJ5q04SKOMtpYxbSlqNVDRzkOKh1t+bEmnvbZ7cm3EjnoiqcqMoW4thkcJpHhg3pDTCqxjljqxvlc3vof1W8UUOSE7N2vhM8fYqhtE0eO+Lc3t4i0zM5DJdhtFu3bxtR7ffvBEhxhNk8/iiMllRwuqeLc9Di+31fIj0fL+cNnW9hXUM57d1/IZ9/n0S8rkQi7jfLqGuw2G19tPcSrq3ZTVXvJ4607h1HjdJFfVsXY3hm89vUeHpz3XaOaPt98kM83H/T8PuCxhY3W2X2kzPO8LpwAXsPJiYRRQwKlJFoltKGYOKucCKpxUEOEVU0ENURQXfuowWFV1y53PyKsuuc1OKgi3iolsXZ/8ZRhs5o3mrHMODhs4glLyCAsPpWjJJLZLpu45HMgJhViax8xqUQ5YokCEmu3jQVa1s509lJAkRNL7kJhdAcSynZxiW0j2w6MpmuaezSPhhmL+JfTZfh/b/ybtbuP8tQN/RnaqS1lVTU8+ekPJEZHMHl4Fw6XVHL5n5cAcE5iFHNuOZ/iyhru/tc68ooqAOiUHEPb2IgT9qEAGPX00ibVVL8V498t/GQGOy7CqSGCGsJwEk4N4VYNDqpJoJQEq5REStw/rRISKaFN7c+6MJJolRBvlbewhqYrMZGUhyfSJi0LYlKwYlOxxaZS4Ugmqk0GZY62lIcnEZaQTmxcIm2qaoiLDAcg1efVnd0UUOSkEvr/FFY8wxX2NazOyfcEFBFpXXmFFTzx6WYmXdCBAdltTrn+W2ty+Wije+6KG19aRa/MeL7fV+RZ/r+LttVb/8eCcq54qnHQ2Hm4lJ2HS0+z+saiqSDFKiCVAlKsAlKsQlKto6RQ6H7dKiDJKiaCasJxEoaTMGqI8DL89XRVhsXhiEuGyAQIi4SwCIzdwYItR6kijCrCqTRh9GmfRp/2qRDmcD/sDs/6hEW6t49qA1FtmPttMbtKw/nvq/oS62UAQZTnOLgfderCiZyaAoqcXPcrYcUzDLetZ07hsX/ENMxYxK24otpz0nG6DGVVNRggvva1yhonLpe7j0ZdPwtHmI2cI6Xc9o81dGgbzc7DpZ5LGvPW72PNAyOJdYQRZrO4/sWVpMZFckGXtjz0/vcnrOP4cNIyhjYUk2YVkGYdJdU6Smpth047Lgzu733dd9+OizCc7tYOq4Y2FNOmtvUi2So84fDWlqg2duzhEdjCIiAyEaLaYKLa8PG2cgpNDP3P7USvzh0gOqk2QCRBdBLrj1hsKbBzw5COjfZpAY4tB6murGFC38xm13RTMHX2CFAKKHJy7c6nLCyRhJoCNq78FEb19HdFIn713Y+FtI2NID4ynJtf+Zpvdh3l5gs6cEXPNF5autMzquPOSzpxabcUbn91DaVV7laB7ulx/JBXjCPM5hmqmuOl9eK8xz9v9Nr87/O81pNIMZ2tfbS1ikiwSomiEhc2DBau2kBR9xwghgraWMUkUUyKVUiadbS2peNoq7deVFiRtf0t0mv7V9T9TIO4dIhJdrdM2MI5VO7kcJmhxzlJYA8HWzjYI9hfUsOR0upGc5JYQL/8MsqqnCecSLJ/MvQ/SX2XnauLLIFMAUVOzmYn/5zLid79LpeYNVQ7XYTb/XYTbBGf+GrbIQ6XVHLNgHZ8uGEfv35rA+d1aMPl3VOZdEEHz9/5XYdLuerZZY22n7NiV72OnAAvLt3pGaVS54e8YgBPOGkOB1V0sX6kp203Pa3d9LDtoYv1I8nW6bac1OeKaouJTceekEFlVArztlXTKTWR/lkJ2C2LH/KKWLv7KCN6ZZKaEENYWJg7TEQn4YpMwhmVRFhsMlXRKURGN57o7ERSah8NZSRGkJHofZu6Dr4SnBRQ5JQyh1wDu9/lcvMNLy7ezpQR3fxdkkirWbH9ML+Y/TUA2UnR/Gquu3Pnih1HWLHjCPO/y2PN7hN3IG0+QzvrMH2snfS17aSztY9Eq4RYKjBADXZc2LAw2Gv7ZqRaBbS1ik+8y/h27haJ6CQIjwYMFVXVbMsrol2bSNpEhQMGjIGIaM8lEE9LRmx67c8092WUWg7ghgZv1bP24Y2t9lG3rcjpUECRU7J1GUGFCSfLdoiPP/9cAaWBimonxkBUROM5IM40l8tQXFFDQnTzO+IZYygqb9m2TVVWVUNJZQ0psQ4qql3YbRYRYfVb5IwxFJZX167vxG6z+PTb/fzvom08N3EQA9snep1vo87BogqSYiIIq231MMawfPsR7n1rPb+6vAvDz03FEWZjzopdPLd4R71tJzzf+G6vJwsn8ZTS3dpDglWKA3fNTmyeSyvu5zYSKKW7LZee1i762HJoY5U07YA1FNUG0vuwJ6ITxQnd6dVvCCR3A0fju91GAn1a9i4iAUEBRU4tIoYfYs6nf9kKRtm/YUNugb8rOqMqa5ys2pnPkI5Jje7qvPtIKZf+cTHxkWE8dnVvth0o4ap+GdQ4Tb1r5hXVTv69p4AhHZPYcqCYiDBbi26hXlRRzYbcAi7onIzddqyj8qZ9RWzeX8S89T/y1bbDvHzzeWzILaRvuwT6ZSWSHOv+/+y+gnL2F1ZQXuVk44/uega1TwLgN+9s5K01e/lwykVU1DjJToqmqLya+d/lcfslnTyf/cstB6lxGq7omQZAVY2Lvy/bSafkWPIKy+mWHofNsujbLsEzwdf2gyUUVVRz7XMr6n2eWEcYT93Qn4HZiWzJK+bHgnI+3Lj/hFOA3/S3VQDM+o+BjO2T7rn9Qm5+GR9s2Mfm/UWekS1TR3RlSMckHv7ge7YfdAcCdydT7x1NHVQRTxnh1ODERjVh1GCnqvZnMoV0s+2ll7WbXrYc+lg5tLcd9LqvU6kydrZb7ekx8BL2OjrTNi2T6NhEKmpc5OWXkBprZ09+JeERYXROS3TPkRGf6Q4olhVy82FIaLKMMWfdhBZFRUUkJCRQWFhIfHy8v8sJCc51/8L+wWQ2udrzUMYL3GdeYejBt9wLHyn0b3GtpMbp4v53NvLuuh/JSIhkZI80Hv1pL57+fCvPfLEdgHtHdmPlzsN0S4vjkXG96PTbT064v0nD2pMaH8nYPhkM/9PiRst3/s9YbLUh42hpFROeX8GR0ioKy6u59aKOPHBlDyzLYvP+IpZsPUTPjHh++bL7UkRmQiQf/uoi2sY6KKmsoffDn530sz05oQ83nJ9Nh//+uNGyXwxtz4zxveg4/cSfpU6cI4ziyppTrncmpMU7uKhLCmVVNXz6nfcOpCfjoIoLbd8xyraGobZNZFmHmj3xFkB59DnkVMSQlpRAUkwExuXCZVzYcZFXUEZJRRVZqUlEntMH0nrxTVU2j66y+J/rB9G3XWKz30/kbNac87cCijRNWT7OP3TGjouLKp/mT1krzrqAsiG3gFlfbmf62B50TI5ptPydtXv59dsbznhdybERHC6pOuPv6z+GCGpwYVGDHbwMWbdw0dfayXD7enpZu7DVTgy41tWNd5wXc4Ckk75DWwpJsNyjY6qxU23CqCGMBKuEPlYOI+1rucy2gVirokFlFpY9HFxOMPVHtDixUxSdze6wDmT3voCkzudDRj93Xw4RaZLmnL91iUeaJjqJ/OTzSTm8mlG2bwi0iWSNMewrrOAvC7byzrq9ANxwXhYPjevJnBW7mL0sh/xSdwhYsOkAAE9c24dnv9jOeR3a8P76fSfcN4AdJ92tXNpahRSaGI4QT6mJpKOVx3D7ekba1tLDlsunzvP53tWBfzhHUXzc9EwWLjI5QqJVygHThsPEU3diPhZO3Cfuuk6SDTmoIopKKoiggggantjjKQUM3a1c8kgi38RRQnSDdUq41LYRg0WyVUi+iaeIaA6ZBPJMEvFWGW0opr11gHOsw/xokomxKtjkak8pkRSZGIqIxmBhx8Ug2xYqcNDV2ksUlRw2CRQQS4GJpYBYDpt4oqjiEvtGsq2DnGdtpZst19Phs8REstukccC0Ic8kkW0dIMxy0dvKaRQeAEbY/8394W8yu2YMj9X83HMMwqnhPNsWLrVt4DLbBrrbck/651nnsC0Ze8+raNN/HKT3w4pJhrpJt1wucFUzb+0uurWNpGeHDNqERXDqKdREpDWoBUWazLnyBeyf/YavXefyA534pe1T9wI/taAYY5izYhcd2sbw9a58nm/Q4bE5LFwMtLbR1fYjTmzkmSTyTTyZ1mFG2tZxhX0NSS3o2Pi5cwD9bDux4ao3CqPChLPDuCeHSrBKiaCGZAqxWQansThEInkmCQtDNJV0tf1Yb78VJpyjxFFgYqjAwQDbdq/vv98ksd8kUUU4Q22bm12/P7kiYinPHk5Ml4vcs3queBby6/8Z73BlsN2cw4W27+oFGoOFccTjdLkIw4WrphK7qaHSimSTsx0H2g5m9M9ug8yBxwKJiPicLvGIbxTuhad64TIWH7mG8lN77YiHVgwo1U4XLy3dyaXdUth9pIy/fbWTuy7rzKhe6QDsOVLG7z/ZxGffH2j2vjtbP3KZbT1trWIOmkT2mhSqCeMi27dcZV9FhpV/0u1djgRMfDtslQW4Sg5hd1VxyMRTnjGEdl36YavIh0NbMAc3YZU3HvlRY4VRasWR4GrNIastk2dLI99qQ3bbWGJtlbiKD2Ar9dLhMzYNV5h70m6ruhRn6VHC8N4HpSbjPFb+WEU87nuipIWVEuk6NgnZuvCBRHS+mH/uO4epN17FOW2iofgAHPqBpSu+whTkclGXFOyZ/SCtJ7Qb7J5i/HiVJRT8eRCJVY37nJiYFFydRmC6jCSs64hGl14qqmqIDLdTUeNq1NlZRM4MBRTxmfynLyKp4FsqTDiRlntYZUsDSmF5Nf0eXQDAq/852NMBtKWiqeAq+0ousn1HFJXsNSnsNmnEUMFP7GvoZ9t58h044iF7qLv/QXEelB5yn+Q6XgLdr4L2F4K99qqoMeCscv/P3ot1i9+j5Lv5lB3axWFHe/7jpknYsge7Z8isqYKt8+HoLvj3v6Dd+e4ZNTsPh/S+7v0W/QiHt8ORbRCdDMX7oNsYiM9wT/VdfhQqCqC8AHK/BkccZA1215PaE2oqoKoUDv0AFUXu5xUF7vfKHOC91aCq1D2rZ8lB95wYxoCtwaUmY9z7Lt4PzhpIOAec1RCVCMAPeUX8Y8Uupo7oSnxkOE99tIYOKfF8f7iGX13elczEqMbv21zOGig5AO9Pdh/PrMHQZSSk92tcr4gEFAUU8ZmapX8h7ItH6794koBSWllDUUU1t7+6hpiIMF78xSCe+PQHPv0uzzPXRXNkcpibwr5guG09UVSSa1LZZdJItEoYaVvntd9CHSd2DqVeQEl0FinWUQ7nbsdmqnEm96D9Jf9BeLefQHhks2sSEZGmUSdZ8Zmwnj+FhgHlOMYYFm46QH5pFQaY/u639Zb3n7Gw0TYxlFNde0dRgFSO8ouwhUywLyWVAvaZtmw35xBJFUNtm+sNBe3M/nr7qk7sRGXP6ygPT6TswA7iyveSFB8HWUOw97qG9Jhkz7pNn4RbRETONAUUaZ7kLmw1WXSz6o+SMMbwzKLtPPX51ibtJpwarrSt4rawT+ht2wXAAZPIURNHF+tHwqxj9yrJtg6RzbGJu3JiB9LxJ3dhYlNxHtmJvWA3hDmwOl9OeNYQwi2L5k+BJiIigUQBRZptefgwutUcCyhrd+d7nSLczXClbTX3hL1DByuPYqI4YhJoaxU2GhXjvs17AQCrXd0596f3kdhlKNu2fMeK1StwhIdxyU9+RsfOvQD3ANOwTpe1/gcUERG/U0CRZssYeh0se8vz+89ecIeTdI4w3L6eGCo8c2XcZP+CgccNgU2ixBNMKhzJRFxwF7ZBvwTLBgV7OJK3m6+Lkxlx0YWee7R0HZJF1yFjzuAnFBERf1NAkWYbdflIqpZHEmFqO6QaF5PsC5ke9vqxkT3HqbJFUTjgLpIv/CV7Dx6h6PCP9MhMIrL9UPcojDoxybQ9ZyCKIiIiooAizWbZbET0uRo2vgHAvIiHPEN4N7g60Ta7J5mRlViVJTjbnUfEBVNIiXPPY5KV1BE4z0+Vi4jI2UIBRVpm5MOegNLPtpNqexQ7+9/PZ2FjuG9Ud89N8PQXTEREWkLnD2mZ+EzKblvOmi/fJTbCxoDRt3Buwjnc7++6REQkKCigSItFt+vNJb/o7e8yREQkCGleaBEREQk4CigiIiIScBRQREREJOAooIiIiEjAUUARERGRgKOAIiIiIgFHAUVEREQCjgKKiIiIBBwFFBEREQk4CigiIiIScBRQREREJOAooIiIiEjAUUARERGRgHNW3s3YGANAUVGRnysRERGRpqo7b9edx0/mrAwoxcXFAGRlZfm5EhEREWmu4uJiEhISTrqOZZoSYwKMy+Vi3759xMXFYVlWq+67qKiIrKwscnNziY+Pb9V9y6np+PuXjr//6c/Av3T8fcsYQ3FxMZmZmdhsJ+9lcla2oNhsNtq1a+fT94iPj9dfTj/S8fcvHX//05+Bf+n4+86pWk7qqJOsiIiIBBwFFBEREQk4CigNOBwOHn74YRwOh79LCUk6/v6l4+9/+jPwLx3/wHFWdpIVERGR4KYWFBEREQk4CigiIiIScBRQREREJOAooIiIiEjAUUA5zqxZs+jQoQORkZEMGTKEr7/+2t8lhYxHHnkEy7LqPbp37+7vsoLW0qVLGTduHJmZmViWxbx58+otN8bw0EMPkZGRQVRUFCNHjmTbtm3+KTYIner433zzzY2+D6NHj/ZPsUFo5syZnH/++cTFxZGamsrVV1/Nli1b6q1TUVHB5MmTadu2LbGxsUyYMIEDBw74qeLQpIBS680332TatGk8/PDDrFu3jn79+jFq1CgOHjzo79JCRq9evdi/f7/nsWzZMn+XFLRKS0vp168fs2bN8rr8D3/4A8888wwvvPACq1evJiYmhlGjRlFRUXGGKw1Opzr+AKNHj673fZg7d+4ZrDC4LVmyhMmTJ7Nq1SoWLlxIdXU1P/nJTygtLfWsc++99/Lhhx/y9ttvs2TJEvbt28e1117rx6pDkBFjjDGDBw82kydP9vzudDpNZmammTlzph+rCh0PP/yw6devn7/LCEmAee+99zy/u1wuk56ebv74xz96XisoKDAOh8PMnTvXDxUGt4bH3xhjJk2aZMaPH++XekLRwYMHDWCWLFlijHH/fQ8PDzdvv/22Z53NmzcbwKxcudJfZYYctaAAVVVVrF27lpEjR3pes9lsjBw5kpUrV/qxstCybds2MjMz6dSpExMnTmTPnj3+Likk5eTkkJeXV+/7kJCQwJAhQ/R9OIMWL15Mamoq5557LnfddRdHjhzxd0lBq7CwEICkpCQA1q5dS3V1db3vQPfu3cnOztZ34AxSQAEOHz6M0+kkLS2t3utpaWnk5eX5qarQMmTIEObMmcP8+fN5/vnnycnJ4eKLL6a4uNjfpYWcur/z+j74z+jRo3n11VdZtGgRTz75JEuWLGHMmDE4nU5/lxZ0XC4X99xzDxdeeCG9e/cG3N+BiIgIEhMT662r78CZdVbezViCz5gxYzzP+/bty5AhQ2jfvj1vvfUWt956qx8rEznzbrzxRs/zPn360LdvXzp37szixYsZMWKEHysLPpMnT+a7775Tn7cApBYUIDk5Gbvd3qiH9oEDB0hPT/dTVaEtMTGRbt26sX37dn+XEnLq/s7r+xA4OnXqRHJysr4PrWzKlCl89NFHfPnll7Rr187zenp6OlVVVRQUFNRbX9+BM0sBBYiIiGDQoEEsWrTI85rL5WLRokUMGzbMj5WFrpKSEnbs2EFGRoa/Swk5HTt2JD09vd73oaioiNWrV+v74Cd79+7lyJEj+j60EmMMU6ZM4b333uOLL76gY8eO9ZYPGjSI8PDwet+BLVu2sGfPHn0HziBd4qk1bdo0Jk2axHnnncfgwYN5+umnKS0t5ZZbbvF3aSHhvvvuY9y4cbRv3559+/bx8MMPY7fbuemmm/xdWlAqKSmp97/xnJwc1q9fT1JSEtnZ2dxzzz08/vjjdO3alY4dO/Lggw+SmZnJ1Vdf7b+ig8jJjn9SUhKPPvooEyZMID09nR07dnD//ffTpUsXRo0a5ceqg8fkyZN5/fXXef/994mLi/P0K0lISCAqKoqEhARuvfVWpk2bRlJSEvHx8fzqV79i2LBhDB061M/VhxB/DyMKJM8++6zJzs42ERERZvDgwWbVqlX+Lilk3HDDDSYjI8NERESYc845x9xwww1m+/bt/i4raH355ZcGaPSYNGmSMcY91PjBBx80aWlpxuFwmBEjRpgtW7b4t+ggcrLjX1ZWZn7yk5+YlJQUEx4ebtq3b29uv/12k5eX5++yg4a3Yw+YV155xbNOeXm5ufvuu02bNm1MdHS0ueaaa8z+/fv9V3QIsowx5szHIhEREZETUx8UERERCTgKKCIiIhJwFFBEREQk4CigiIiISMBRQBEREZGAo4AiIiIiAUcBRURERAKOAoqIiIgEHAUUERERCTgKKCIiIhJwFFBEREQk4CigiIiISMD5/wFL5MaISO0gHwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# get first column of every row as time from [(time,(ax,ay,az)),...] = a.measured_values\n", + "time1, ax, ay, az = zip(*accel_noisy_nosecone.measured_values)\n", + "time2, bx, by, bz = zip(*accel_clean_cdm.measured_values)\n", + "\n", + "\n", + "import matplotlib.pyplot as plt\n", + "plt.plot(time1, ax, label='Noisy Accelerometer')\n", + "plt.plot(time2, bx, label='Clean Accelerometer')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "plt.plot(time1, ay, label='Noisy Accelerometer')\n", + "plt.plot(time2, by, label='Clean Accelerometer')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "plt.plot(time1, az, label='Noisy Accelerometer')\n", + "plt.plot(time2, bz, label='Clean Accelerometer')\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 4.0)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "abs_a = (np.array(ax)**2 + np.array(ay)**2 + np.array(az)**2)**0.5\n", + "abs_b = (np.array(bx)**2 + np.array(by)**2 + np.array(bz)**2)**0.5\n", + "plt.plot(time1, abs_a, label='noisy')\n", + "plt.plot(time2, abs_b, label='clean')\n", + "plt.legend()\n", + "plt.xlim(0,4)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "time1, wx, wy, wz = zip(*gyro_noisy.measured_values)\n", + "time2, zx, zy, zz = zip(*gyro_clean.measured_values)\n", + "\n", + "plt.plot(time1, wx, label='Noisy Gyroscope')\n", + "plt.plot(time2, zx, label='Clean Gyroscope')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "plt.plot(time1, wy, label='Noisy Gyroscope')\n", + "plt.plot(time2, zy, label='Clean Gyroscope')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "plt.plot(time1, wz, label='Noisy Gyroscope')\n", + "plt.plot(time2, zz, label='Clean Gyroscope')\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "name": "getting_started.ipynb", + "provenance": [], + "toc_visible": true + }, + "hide_input": false, + "kernelspec": { + "display_name": "Python 3.10.0 ('rocketpy_dev')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + }, + "vscode": { + "interpreter": { + "hash": "18e93d5347af13ace37d47ea4e2a2ad720f0331bd9cb28f9983f5585f4dfaa5c" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 1dd5781f3b1303a7c8b8cbd750bdf9d1a36127d5 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 2 Apr 2024 15:18:14 +0200 Subject: [PATCH 10/77] ENH: add option to add noise to each axis seperatly --- rocketpy/mathutils/vector_matrix.py | 23 +++++++++ rocketpy/sensors/accelerometer.py | 39 +++++++++----- rocketpy/sensors/gyroscope.py | 51 ++++++++++++------ rocketpy/sensors/sensors.py | 60 +++++++++++++++------- tests/fixtures/sensors/sensors_fixtures.py | 26 +++++----- 5 files changed, 136 insertions(+), 63 deletions(-) diff --git a/rocketpy/mathutils/vector_matrix.py b/rocketpy/mathutils/vector_matrix.py index 8263da2bf..b8640ddea 100644 --- a/rocketpy/mathutils/vector_matrix.py +++ b/rocketpy/mathutils/vector_matrix.py @@ -242,6 +242,29 @@ def __xor__(self, other): ] ) + def __and__(self, other): + """Element wise multiplication between two R3 vectors. + + Parameters + ---------- + other : Vector + R3 vector to be multiplied with self. + + Returns + ------- + Vector + R3 vector resulting from the element wise multiplication between + self and other. + + Examples + -------- + >>> v = Vector([1, 7, 3]) + >>> u = Vector([2, 5, 6]) + >>> (v & u) + Vector(2, 35, 18) + """ + return Vector([self.x * other[0], self.y * other[1], self.z * other[2]]) + def __matmul__(self, other): """Dot product between two R3 vectors.""" return self.x * other.x + self.y * other.y + self.z * other.z diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 1774fde76..1b8dd8680 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -59,27 +59,38 @@ def __init__( resolution : float, optional The resolution of the sensor in m/s^2/LSB. Default is 0, meaning no quantization is applied. - noise_density : float, optional + noise_density : float, list, optional The noise density of the sensor in m/s^2/√Hz. Sometimes called "white noise drift", "angular random walk" for gyroscopes, "velocity - random walk" for the accelerometers or "(rate) noise density". - Default is 0, meaning no noise is applied. - random_walk : float, optional + random walk" for the accelerometers or "(rate) noise density". If a + float or int is given, the same noise density is applied to all + axes. The values of each axis can be set individually by passing a + list of length 3. + random_walk : float, list, optional The random walk of the sensor in m/s^2/√Hz. Sometimes called "bias (in)stability" or "bias drift"". Default is 0, meaning no random - walk is applied. - constant_bias : float, optional + walk is applied. If a float or int is given, the same random walk is + applied to all axes. The values of each axis can be set individually + by passing a list of length 3. + constant_bias : float, list, optional The constant bias of the sensor in m/s^2. Default is 0, meaning no - constant bias is applied. + constant bias is applied. If a float or int is given, the same bias + is applied to all axes. The values of each axis can be set + individually by passing a list of length 3. operating_temperature : float, optional The operating temperature of the sensor in degrees Celsius. At 25°C, the temperature bias and scale factor are 0. Default is 25. - temperature_bias : float, optional + temperature_bias : float, list, optional The temperature bias of the sensor in m/s^2/°C. Default is 0, - meaning no temperature bias is applied. - temperature_scale_factor : float, optional + meaning no temperature bias is applied. If a float or int is given, + the same temperature bias is applied to all axes. The values of each + axis can be set individually by passing a list of length 3. + temperature_scale_factor : float, list, optional The temperature scale factor of the sensor in %/°C. Default is 0, - meaning no temperature scale factor is applied. + meaning no temperature scale factor is applied. If a float or int is + given, the same temperature scale factor is applied to all axes. The + values of each axis can be set individually by passing a list of + length 3. cross_axis_sensitivity : float, optional Skewness of the sensor's axes in percentage. Default is 0, meaning no cross-axis sensitivity is applied. @@ -93,9 +104,6 @@ def __init__( ------- None """ - self.type = "Accelerometer" - self.consider_gravity = consider_gravity - self.prints = _AccelerometerPrints(self) super().__init__( sampling_rate, orientation, @@ -110,6 +118,9 @@ def __init__( cross_axis_sensitivity=cross_axis_sensitivity, name=name, ) + self.type = "Accelerometer" + self.consider_gravity = consider_gravity + self.prints = _AccelerometerPrints(self) def measure(self, t, u, u_dot, relative_position, gravity, *args): """ diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index 21543e99c..be96c83d2 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -57,41 +57,53 @@ def __init__( resolution : float, optional The resolution of the sensor in rad/s/LSB. Default is 0, meaning no quantization is applied. - noise_density : float, optional + noise_density : float, list, optional The noise density of the sensor in rad/s/√Hz. Sometimes called "white noise drift", "angular random walk" for gyroscopes, "velocity random walk" for the accelerometers or "(rate) noise density". - Default is 0, meaning no noise is applied. - random_walk : float, optional + Default is 0, meaning no noise is applied. If a float or int is + given, the same noise density is applied to all axes. The values of + each axis can be set individually by passing a list of length 3. + random_walk : float, list, optional The random walk of the sensor in rad/s/√Hz. Sometimes called "bias (in)stability" or "bias drift"". Default is 0, meaning no random - walk is applied. - constant_bias : float, optional + walk is applied. If a float or int is given, the same random walk is + applied to all axes. The values of each axis can be set individually + by passing a list of length 3. + constant_bias : float, list, optional The constant bias of the sensor in rad/s. Default is 0, meaning no - constant bias is applied. + constant bias is applied. If a float or int is given, the same bias + is applied to all axes. The values of each axis can be set + individually by passing a list of length 3. operating_temperature : float, optional The operating temperature of the sensor in degrees Celsius. At 25°C, the temperature bias and scale factor are 0. Default is 25. - temperature_sensitivity : float, optional + temperature_sensitivity : float, list, optional The temperature bias of the sensor in rad/s/°C. Default is 0, - meaning no temperature bias is applied. - temperature_scale_factor : float, optional + meaning no temperature bias is applied. If a float or int is given, + the same temperature bias is applied to all axes. The values of each + axis can be set individually by passing a list of length 3. + temperature_scale_factor : float, list, optional The temperature scale factor of the sensor in %/°C. Default is 0, - meaning no temperature scale factor is applied. + meaning no temperature scale factor is applied. If a float or int is + given, the same temperature scale factor is applied to all axes. The + values of each axis can be set individually by passing a list of + length 3. cross_axis_sensitivity : float, optional Skewness of the sensor's axes in percentage. Default is 0, meaning no cross-axis sensitivity is applied. - acceleration_sensitivity : float, optional + of each axis can be set individually by passing a list of length 3. + acceleration_sensitivity : float, list, optional Sensitivity of the sensor to linear acceleration in rad/s/g. Default - is 0, meaning no sensitivity to linear acceleration is applied. + is 0, meaning no sensitivity to linear acceleration is applied. If a + float or int is given, the same sensitivity is applied to all axes. + The values of each axis can be set individually by passing a list of + length 3. Returns ------- None """ - self.type = "Gyroscope" - self.acceleration_sensitivity = acceleration_sensitivity - self.prints = _GyroscopePrints(self) super().__init__( sampling_rate, orientation, @@ -106,6 +118,11 @@ def __init__( cross_axis_sensitivity=cross_axis_sensitivity, name=name, ) + self.type = "Gyroscope" + self.acceleration_sensitivity = self._vectorize_input( + acceleration_sensitivity, "acceleration_sensitivity" + ) + self.prints = _GyroscopePrints(self) def measure(self, t, u, u_dot, relative_position, *args): """ @@ -126,7 +143,7 @@ def measure(self, t, u, u_dot, relative_position, *args): W = self.apply_temperature_drift(W) # Apply acceleration sensitivity - if self.acceleration_sensitivity != 0 and self.acceleration_sensitivity != None: + if self.acceleration_sensitivity != Vector.zeros(): W += self.apply_acceleration_sensitivity( omega, u_dot, relative_position, inertial_to_sensor ) @@ -174,7 +191,7 @@ def apply_acceleration_sensitivity( # Transform to sensor frame A = rotation_matrix @ A - return self.acceleration_sensitivity * A + return self.acceleration_sensitivity & A def export_measured_values(self, filename, format="csv"): """ diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index 8ba08317b..2813acbd8 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -55,27 +55,39 @@ def __init__( resolution : float, optional The resolution of the sensor in sensor units/LSB. Default is 0, meaning no quantization is applied. - noise_density : float, optional + noise_density : float, list, optional The noise density of the sensor in sensor units/√Hz. Sometimes called "white noise drift", "angular random walk" for gyroscopes, "velocity random walk" for the accelerometers or "(rate) noise density". Default is 0, meaning no noise is applied. - random_walk : float, optional + If a float or int is given, the same noise density is applied to all + axes. The values of each axis can be set individually by passing a + list of length 3. + random_walk : float, list, optional The random walk of the sensor in sensor units/√Hz. Sometimes called "bias (in)stability" or "bias drift"". Default is 0, meaning no - random walk is applied. - constant_bias : float, optional + random walk is applied. If a float or int is given, the same random + walk is applied to all axes. The values of each axis can be set + individually by passing a list of length 3. + constant_bias : float, list, optional The constant bias of the sensor in sensor units. Default is 0, - meaning no constant bias is applied. + meaning no constant bias is applied. If a float or int is given, the + same constant bias is applied to all axes. The values of each axis + can be set individually by passing a list of length 3. operating_temperature : float, optional The operating temperature of the sensor in degrees Celsius. At 25°C, the temperature bias and scale factor are 0. Default is 25. - temperature_bias : float, optional + temperature_bias : float, list, optional The temperature bias of the sensor in sensor units/°C. Default is 0, - meaning no temperature bias is applied. - temperature_scale_factor : float, optional + meaning no temperature bias is applied. If a float or int is given, + the same temperature bias is applied to all axes. The values of each + axis can be set individually by passing a list of length 3. + temperature_scale_factor : float, list, optional The temperature scale factor of the sensor in %/°C. Default is 0, - meaning no temperature scale factor is applied. + meaning no temperature scale factor is applied. If a float or int is + given, the same temperature scale factor is applied to all axes. The + values of each axis can be set individually by passing a list of + length 3. cross_axis_sensitivity : float, optional Skewness of the sensor's axes in percentage. Default is 0, meaning no cross-axis sensitivity is applied. @@ -89,12 +101,16 @@ def __init__( self.sampling_rate = sampling_rate self.orientation = orientation self.resolution = resolution - self.noise_density = noise_density * Vector([1, 1, 1]) - self.random_walk = random_walk * Vector([1, 1, 1]) - self.constant_bias = constant_bias * Vector([1, 1, 1]) self.operating_temperature = operating_temperature - self.temperature_bias = temperature_bias * Vector([1, 1, 1]) - self.temperature_scale_factor = temperature_scale_factor * Vector([1, 1, 1]) + self.noise_density = self._vectorize_input(noise_density, "noise_density") + self.random_walk = self._vectorize_input(random_walk, "random_walk") + self.constant_bias = self._vectorize_input(constant_bias, "constant_bias") + self.temperature_bias = self._vectorize_input( + temperature_bias, "temperature_bias" + ) + self.temperature_scale_factor = self._vectorize_input( + temperature_scale_factor, "temperature_scale_factor" + ) self.cross_axis_sensitivity = cross_axis_sensitivity self.name = name self._random_walk_drift = Vector([0, 0, 0]) @@ -138,11 +154,19 @@ def __init__( # compute total rotation matrix given cross axis sensitivity self._total_rotation_matrix = self.rotation_matrix @ _cross_axis_matrix + def _vectorize_input(self, value, name): + if isinstance(value, (int, float)): + return Vector([value, value, value]) + elif isinstance(value, (tuple, list)): + return Vector(value) + else: + raise ValueError(f"Invalid {name} format") + def __repr__(self): return f"{self.type} sensor, orientation: {self.orientation}" - def __call__(self, *args, **kwds): - return self.measure(*args, **kwds) + def __call__(self, *args, **kwargs): + return self.measure(*args, **kwargs) @abstractmethod def measure(self, *args, **kwargs): @@ -226,8 +250,6 @@ def apply_temperature_drift(self, value): Vector([1, 1, 1]) + (self.operating_temperature - 25) / 100 * self.temperature_scale_factor ) - value.x *= scale_factor.x - value.y *= scale_factor.y - value.z *= scale_factor.z + value = value & scale_factor return value diff --git a/tests/fixtures/sensors/sensors_fixtures.py b/tests/fixtures/sensors/sensors_fixtures.py index d334a0a46..bbb83b805 100644 --- a/tests/fixtures/sensors/sensors_fixtures.py +++ b/tests/fixtures/sensors/sensors_fixtures.py @@ -6,16 +6,16 @@ def noisy_rotated_accelerometer(): """Returns an accelerometer with all parameters set to non-default values, i.e. with noise and rotation.""" - # mpu6050 values + # mpu6050 approx values return Accelerometer( sampling_rate=100, orientation=(60, 60, 60), - noise_density=0.05, - random_walk=0.02, - constant_bias=0.5, + noise_density=[0, 0.03, 0.05], + random_walk=[0, 0.01, 0.02], + constant_bias=[0, 0.3, 0.5], operating_temperature=25, - temperature_bias=0.02, - temperature_scale_factor=0.02, + temperature_bias=[0, 0.01, 0.02], + temperature_scale_factor=[0, 0.01, 0.02], cross_axis_sensitivity=0.5, consider_gravity=True, name="Accelerometer", @@ -26,18 +26,18 @@ def noisy_rotated_accelerometer(): def noisy_rotated_gyroscope(): """Returns a gyroscope with all parameters set to non-default values, i.e. with noise and rotation.""" - # mpu6050 values + # mpu6050 approx values return Gyroscope( sampling_rate=100, orientation=(-60, -60, -60), - noise_density=0.05, - random_walk=0.02, - constant_bias=0.5, + noise_density=[0, 0.03, 0.05], + random_walk=[0, 0.01, 0.02], + constant_bias=[0, 0.3, 0.5], operating_temperature=25, - temperature_bias=0.02, - temperature_scale_factor=0.02, + temperature_bias=[0, 0.01, 0.02], + temperature_scale_factor=[0, 0.01, 0.02], cross_axis_sensitivity=0.5, - acceleration_sensitivity=0.0017, + acceleration_sensitivity=[0, 0.0008, 0.0017], name="Gyroscope", ) From 943542a3af83ec7ee1885aac46b982fd2cb2db48 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 2 Apr 2024 15:40:46 +0200 Subject: [PATCH 11/77] MNT: run isort --- rocketpy/control/controller.py | 1 + rocketpy/prints/sensors_prints.py | 1 - rocketpy/rocket/parachute.py | 3 ++- rocketpy/sensors/__init__.py | 4 ++-- rocketpy/sensors/accelerometer.py | 3 ++- rocketpy/sensors/gyroscope.py | 3 ++- rocketpy/sensors/sensors.py | 4 +++- tests/fixtures/sensors/sensors_fixtures.py | 1 + tests/unit/test_sensors.py | 2 ++ 9 files changed, 15 insertions(+), 7 deletions(-) diff --git a/rocketpy/control/controller.py b/rocketpy/control/controller.py index 497161c22..c2617f8eb 100644 --- a/rocketpy/control/controller.py +++ b/rocketpy/control/controller.py @@ -1,4 +1,5 @@ from inspect import signature + from ..prints.controller_prints import _ControllerPrints diff --git a/rocketpy/prints/sensors_prints.py b/rocketpy/prints/sensors_prints.py index d41227de7..8c073190f 100644 --- a/rocketpy/prints/sensors_prints.py +++ b/rocketpy/prints/sensors_prints.py @@ -1,6 +1,5 @@ from abc import ABC, abstractmethod - UNITS = { "Gyroscope": "rad/s", "Accelerometer": "m/s^2", diff --git a/rocketpy/rocket/parachute.py b/rocketpy/rocket/parachute.py index 4c5e5d7f3..c1bff2638 100644 --- a/rocketpy/rocket/parachute.py +++ b/rocketpy/rocket/parachute.py @@ -1,6 +1,7 @@ -import numpy as np from inspect import signature +import numpy as np + from ..mathutils.function import Function from ..prints.parachute_prints import _ParachutePrints diff --git a/rocketpy/sensors/__init__.py b/rocketpy/sensors/__init__.py index 044deec43..5bfe07805 100644 --- a/rocketpy/sensors/__init__.py +++ b/rocketpy/sensors/__init__.py @@ -1,3 +1,3 @@ -from .sensors import Sensors -from .gyroscope import Gyroscope from .accelerometer import Accelerometer +from .gyroscope import Gyroscope +from .sensors import Sensors diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 1b8dd8680..8e9e028d4 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -1,7 +1,8 @@ import numpy as np + from ..mathutils.vector_matrix import Matrix, Vector -from ..sensors.sensors import Sensors from ..prints.sensors_prints import _AccelerometerPrints +from ..sensors.sensors import Sensors class Accelerometer(Sensors): diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index be96c83d2..47e53333f 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -1,7 +1,8 @@ import numpy as np + from ..mathutils.vector_matrix import Matrix, Vector -from ..sensors.sensors import Sensors from ..prints.sensors_prints import _GyroscopePrints +from ..sensors.sensors import Sensors class Gyroscope(Sensors): diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index 2813acbd8..74cebeb4a 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -1,7 +1,9 @@ from abc import ABC, abstractmethod -from rocketpy.mathutils.vector_matrix import Matrix, Vector + import numpy as np +from rocketpy.mathutils.vector_matrix import Matrix, Vector + class Sensors(ABC): """ diff --git a/tests/fixtures/sensors/sensors_fixtures.py b/tests/fixtures/sensors/sensors_fixtures.py index bbb83b805..a4ea781c8 100644 --- a/tests/fixtures/sensors/sensors_fixtures.py +++ b/tests/fixtures/sensors/sensors_fixtures.py @@ -1,4 +1,5 @@ import pytest + from rocketpy import Accelerometer, Gyroscope diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensors.py index c7ee8175b..b15e1b0a2 100644 --- a/tests/unit/test_sensors.py +++ b/tests/unit/test_sensors.py @@ -1,7 +1,9 @@ import json import os + import numpy as np from pytest import approx + from rocketpy.mathutils.vector_matrix import Matrix, Vector from rocketpy.tools import euler_to_quaternions From 28ebc46e3f5e3640d4cf993093c978a5a5b3fec3 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 2 Apr 2024 15:55:16 +0200 Subject: [PATCH 12/77] ENH: calculate u_dot only once for all sensors --- rocketpy/simulation/flight.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/rocketpy/simulation/flight.py b/rocketpy/simulation/flight.py index dc922dba2..f82b63b1c 100644 --- a/rocketpy/simulation/flight.py +++ b/rocketpy/simulation/flight.py @@ -709,13 +709,12 @@ def __init__( for callback in node.callbacks: callback(self) + # calculate u_dot for sensors + u_dot = phase.derivative(self.t, self.y_sol) for sensor, position in node._component_sensors: relative_position = position - self.rocket._csys * Vector( [0, 0, self.rocket.center_of_dry_mass_position] ) - u_dot = phase.derivative( - self.t, self.y_sol - ) # calling udot for each sensor. Not optimal sensor.measure( self.t, self.y_sol, From 378bb54ea4b857157bce088ec2bb861ee1118761 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 2 Apr 2024 16:12:24 +0200 Subject: [PATCH 13/77] MNT: change `measured_values` to `measured_data` --- docs/notebooks/sensors_testing.ipynb | 10 +++--- rocketpy/sensors/accelerometer.py | 8 ++--- rocketpy/sensors/gyroscope.py | 8 ++--- rocketpy/sensors/sensors.py | 4 +-- tests/test_sensors.py | 4 +-- tests/unit/test_sensors.py | 48 ++++++++++++++-------------- 6 files changed, 41 insertions(+), 41 deletions(-) diff --git a/docs/notebooks/sensors_testing.ipynb b/docs/notebooks/sensors_testing.ipynb index 76a0815a9..797dcb232 100644 --- a/docs/notebooks/sensors_testing.ipynb +++ b/docs/notebooks/sensors_testing.ipynb @@ -533,9 +533,9 @@ } ], "source": [ - "# get first column of every row as time from [(time,(ax,ay,az)),...] = a.measured_values\n", - "time1, ax, ay, az = zip(*accel_noisy_nosecone.measured_values)\n", - "time2, bx, by, bz = zip(*accel_clean_cdm.measured_values)\n", + "# get first column of every row as time from [(time,(ax,ay,az)),...] = a.measured_data\n", + "time1, ax, ay, az = zip(*accel_noisy_nosecone.measured_data)\n", + "time2, bx, by, bz = zip(*accel_clean_cdm.measured_data)\n", "\n", "\n", "import matplotlib.pyplot as plt\n", @@ -628,8 +628,8 @@ } ], "source": [ - "time1, wx, wy, wz = zip(*gyro_noisy.measured_values)\n", - "time2, zx, zy, zz = zip(*gyro_clean.measured_values)\n", + "time1, wx, wy, wz = zip(*gyro_noisy.measured_data)\n", + "time2, zx, zy, zz = zip(*gyro_clean.measured_data)\n", "\n", "plt.plot(time1, wx, label='Noisy Gyroscope')\n", "plt.plot(time2, zx, label='Clean Gyroscope')\n", diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 8e9e028d4..8599816bb 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -158,9 +158,9 @@ def measure(self, t, u, u_dot, relative_position, gravity, *args): A = self.quantize(A) self.measurement = tuple([*A]) - self.measured_values.append((t, *A)) + self.measured_data.append((t, *A)) - def export_measured_values(self, filename, format="csv"): + def export_measured_data(self, filename, format="csv"): """ Export the measured values to a file @@ -179,13 +179,13 @@ def export_measured_values(self, filename, format="csv"): if format == "csv": with open(filename, "w") as f: f.write("t,ax,ay,az\n") - for t, ax, ay, az in self.measured_values: + for t, ax, ay, az in self.measured_data: f.write(f"{t},{ax},{ay},{az}\n") elif format == "json": import json data = {"t": [], "ax": [], "ay": [], "az": []} - for t, ax, ay, az in self.measured_values: + for t, ax, ay, az in self.measured_data: data["t"].append(t) data["ax"].append(ax) data["ay"].append(ay) diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index 47e53333f..de26ed7ff 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -152,7 +152,7 @@ def measure(self, t, u, u_dot, relative_position, *args): W = self.quantize(W) self.measurement = tuple([*W]) - self.measured_values.append((t, *W)) + self.measured_data.append((t, *W)) def apply_acceleration_sensitivity( self, omega, u_dot, relative_position, rotation_matrix @@ -194,7 +194,7 @@ def apply_acceleration_sensitivity( return self.acceleration_sensitivity & A - def export_measured_values(self, filename, format="csv"): + def export_measured_data(self, filename, format="csv"): """ Export the measured values to a file @@ -213,13 +213,13 @@ def export_measured_values(self, filename, format="csv"): if format == "csv": with open(filename, "w") as f: f.write("t,wx,wy,wz\n") - for t, wx, wy, wz in self.measured_values: + for t, wx, wy, wz in self.measured_data: f.write(f"{t},{wx},{wy},{wz}\n") elif format == "json": import json data = {"t": [], "wx": [], "wy": [], "wz": []} - for t, wx, wy, wz in self.measured_values: + for t, wx, wy, wz in self.measured_data: data["t"].append(t) data["wx"].append(wx) data["wy"].append(wy) diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index 74cebeb4a..8a626b941 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -117,7 +117,7 @@ def __init__( self.name = name self._random_walk_drift = Vector([0, 0, 0]) self.measurement = None - self.measured_values = [] # change to data + self.measured_data = [] # change to data # handle measurement range if isinstance(measurement_range, (tuple, list)): @@ -175,7 +175,7 @@ def measure(self, *args, **kwargs): pass @abstractmethod - def export_measured_values(self): + def export_measured_data(self): pass def quantize(self, value): diff --git a/tests/test_sensors.py b/tests/test_sensors.py index 666e5f8e3..ddca685a4 100644 --- a/tests/test_sensors.py +++ b/tests/test_sensors.py @@ -31,7 +31,7 @@ def test_ideal_accelerometer(flight_calisto_accel_gyro): Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. """ accelerometer = flight_calisto_accel_gyro.rocket.sensors[0].component - time, ax, ay, az = zip(*accelerometer.measured_values) + time, ax, ay, az = zip(*accelerometer.measured_data) ax = np.array(ax) ay = np.array(ay) az = np.array(az) @@ -51,7 +51,7 @@ def test_ideal_gyroscope(flight_calisto_accel_gyro): Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. """ gyroscope = flight_calisto_accel_gyro.rocket.sensors[1].component - time, wx, wy, wz = zip(*gyroscope.measured_values) + time, wx, wy, wz = zip(*gyroscope.measured_data) wx = np.array(wx) wy = np.array(wy) wz = np.array(wz) diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensors.py index b15e1b0a2..3dbce1d34 100644 --- a/tests/unit/test_sensors.py +++ b/tests/unit/test_sensors.py @@ -76,7 +76,7 @@ def test_rotation_matrix(noisy_rotated_accelerometer): def test_ideal_accelerometer_measure(ideal_accelerometer): """Test the measure method of the Accelerometer class. Checks if saved - measurement is (ax,ay,az) and if measured_values is [(t, (ax,ay,az)), ...] + measurement is (ax,ay,az) and if measured_data is [(t, (ax,ay,az)), ...] """ t = SOLUTION[0] u = SOLUTION[1:] @@ -100,18 +100,18 @@ def test_ideal_accelerometer_measure(ideal_accelerometer): assert ideal_accelerometer.measurement == approx([ax, ay, az], abs=1e-10) # check measured values - assert len(ideal_accelerometer.measured_values) == 1 + assert len(ideal_accelerometer.measured_data) == 1 ideal_accelerometer.measure(t, u, UDOT, relative_position, gravity) - assert len(ideal_accelerometer.measured_values) == 2 + assert len(ideal_accelerometer.measured_data) == 2 - assert all(isinstance(i, tuple) for i in ideal_accelerometer.measured_values) - assert ideal_accelerometer.measured_values[0][0] == t - assert ideal_accelerometer.measured_values[0][1:] == approx([ax, ay, az], abs=1e-10) + assert all(isinstance(i, tuple) for i in ideal_accelerometer.measured_data) + assert ideal_accelerometer.measured_data[0][0] == t + assert ideal_accelerometer.measured_data[0][1:] == approx([ax, ay, az], abs=1e-10) def test_ideal_gyroscope_measure(ideal_gyroscope): """Test the measure method of the Gyroscope class. Checks if saved - measurement is (wx,wy,wz) and if measured_values is [(t, (wx,wy,wz)), ...] + measurement is (wx,wy,wz) and if measured_data is [(t, (wx,wy,wz)), ...] """ t = SOLUTION[0] u = SOLUTION[1:] @@ -130,18 +130,18 @@ def test_ideal_gyroscope_measure(ideal_gyroscope): assert ideal_gyroscope.measurement == approx([ax, ay, az], abs=1e-10) # check measured values - assert len(ideal_gyroscope.measured_values) == 1 + assert len(ideal_gyroscope.measured_data) == 1 ideal_gyroscope.measure(t, u, UDOT, relative_position) - assert len(ideal_gyroscope.measured_values) == 2 + assert len(ideal_gyroscope.measured_data) == 2 - assert all(isinstance(i, tuple) for i in ideal_gyroscope.measured_values) - assert ideal_gyroscope.measured_values[0][0] == t - assert ideal_gyroscope.measured_values[0][1:] == approx([ax, ay, az], abs=1e-10) + assert all(isinstance(i, tuple) for i in ideal_gyroscope.measured_data) + assert ideal_gyroscope.measured_data[0][0] == t + assert ideal_gyroscope.measured_data[0][1:] == approx([ax, ay, az], abs=1e-10) def test_noisy_rotated_accelerometer(noisy_rotated_accelerometer): """Test the measure method of the Accelerometer class. Checks if saved - measurement is (ax,ay,az) and if measured_values is [(t, (ax,ay,az)), ...] + measurement is (ax,ay,az) and if measured_data is [(t, (ax,ay,az)), ...] """ t = SOLUTION[0] u = SOLUTION[1:] @@ -183,7 +183,7 @@ def test_noisy_rotated_accelerometer(noisy_rotated_accelerometer): def test_noisy_rotated_gyroscope(noisy_rotated_gyroscope): """Test the measure method of the Gyroscope class. Checks if saved - measurement is (wx,wy,wz) and if measured_values is [(t, (wx,wy,wz)), ...] + measurement is (wx,wy,wz) and if measured_data is [(t, (wx,wy,wz)), ...] """ t = SOLUTION[0] u = SOLUTION[1:] @@ -216,7 +216,7 @@ def test_noisy_rotated_gyroscope(noisy_rotated_gyroscope): def test_quatization_accelerometer(quantized_accelerometer): """Test the measure method of the Accelerometer class. Checks if saved - measurement is (ax,ay,az) and if measured_values is [(t, (ax,ay,az)), ...] + measurement is (ax,ay,az) and if measured_data is [(t, (ax,ay,az)), ...] """ t = SOLUTION[0] u = SOLUTION[1:] @@ -249,7 +249,7 @@ def test_quatization_accelerometer(quantized_accelerometer): def test_quatization_gyroscope(quantized_gyroscope): """Test the measure method of the Gyroscope class. Checks if saved - measurement is (wx,wy,wz) and if measured_values is [(t, (wx,wy,wz)), ...] + measurement is (wx,wy,wz) and if measured_data is [(t, (wx,wy,wz)), ...] """ t = SOLUTION[0] u = SOLUTION[1:] @@ -290,13 +290,13 @@ def test_export_accel_data_csv(ideal_accelerometer): file_name = "sensors.csv" - ideal_accelerometer.export_measured_values(file_name, format="csv") + ideal_accelerometer.export_measured_data(file_name, format="csv") with open(file_name, "r") as file: contents = file.read() expected_data = "t,ax,ay,az\n" - for t, ax, ay, az in ideal_accelerometer.measured_values: + for t, ax, ay, az in ideal_accelerometer.measured_data: expected_data += f"{t},{ax},{ay},{az}\n" assert contents == expected_data @@ -322,12 +322,12 @@ def test_export_accel_data_json(ideal_accelerometer): file_name = "sensors.json" - ideal_accelerometer.export_measured_values(file_name, format="json") + ideal_accelerometer.export_measured_data(file_name, format="json") contents = json.load(open(file_name, "r")) expected_data = {"t": [], "ax": [], "ay": [], "az": []} - for t, ax, ay, az in ideal_accelerometer.measured_values: + for t, ax, ay, az in ideal_accelerometer.measured_data: expected_data["t"].append(t) expected_data["ax"].append(ax) expected_data["ay"].append(ay) @@ -355,13 +355,13 @@ def test_export_gyro_data_csv(ideal_gyroscope): file_name = "sensors.csv" - ideal_gyroscope.export_measured_values(file_name, format="csv") + ideal_gyroscope.export_measured_data(file_name, format="csv") with open(file_name, "r") as file: contents = file.read() expected_data = "t,wx,wy,wz\n" - for t, wx, wy, wz in ideal_gyroscope.measured_values: + for t, wx, wy, wz in ideal_gyroscope.measured_data: expected_data += f"{t},{wx},{wy},{wz}\n" assert contents == expected_data @@ -385,12 +385,12 @@ def test_export_gyro_data_json(ideal_gyroscope): file_name = "sensors.json" - ideal_gyroscope.export_measured_values(file_name, format="json") + ideal_gyroscope.export_measured_data(file_name, format="json") contents = json.load(open(file_name, "r")) expected_data = {"t": [], "wx": [], "wy": [], "wz": []} - for t, wx, wy, wz in ideal_gyroscope.measured_values: + for t, wx, wy, wz in ideal_gyroscope.measured_data: expected_data["t"].append(t) expected_data["wx"].append(wx) expected_data["wy"].append(wy) From d8440f2e8eda80ad4047be1ea02d616e7b49bd11 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 2 Apr 2024 18:44:38 +0200 Subject: [PATCH 14/77] TST: unite gyro and accel tests --- tests/test_sensors.py | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) diff --git a/tests/test_sensors.py b/tests/test_sensors.py index ddca685a4..43a42942c 100644 --- a/tests/test_sensors.py +++ b/tests/test_sensors.py @@ -22,8 +22,9 @@ def test_sensor_on_rocket(calisto_accel_gyro): assert isinstance(sensors[1].position, Vector) -def test_ideal_accelerometer(flight_calisto_accel_gyro): - """Test the ideal accelerometer. +def test_ideal_sensors(flight_calisto_accel_gyro): + """Test the ideal sensors. All types of sensors are here to reduvce + testing time. Parameters ---------- @@ -41,15 +42,6 @@ def test_ideal_accelerometer(flight_calisto_accel_gyro): # tolerance is bounded to numerical errors in the transformation matrixes assert np.allclose(a, sim_accel, atol=1e-2) - -def test_ideal_gyroscope(flight_calisto_accel_gyro): - """Test the ideal gyroscope. - - Parameters - ---------- - flight_calisto_accel_gyro : Flight - Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. - """ gyroscope = flight_calisto_accel_gyro.rocket.sensors[1].component time, wx, wy, wz = zip(*gyroscope.measured_data) wx = np.array(wx) From 99f445f4b35a9b2cd5af36f53a04d64054be0eba Mon Sep 17 00:00:00 2001 From: MateusStano <69485049+MateusStano@users.noreply.github.com> Date: Thu, 11 Apr 2024 16:05:08 -0300 Subject: [PATCH 15/77] Update rocketpy/plots/rocket_plots.py Co-authored-by: Pedro Henrique Marinho Bressan <87212571+phmbressan@users.noreply.github.com> --- rocketpy/plots/rocket_plots.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rocketpy/plots/rocket_plots.py b/rocketpy/plots/rocket_plots.py index 50b24e0e9..e801da3c7 100644 --- a/rocketpy/plots/rocket_plots.py +++ b/rocketpy/plots/rocket_plots.py @@ -566,7 +566,7 @@ def _draw_sensor(self, ax, sensors, plane, vis_args): else: raise ValueError("Plane must be 'xz' or 'yz'.") - # line length is 1/10 of the rocket radius + # line length is 2/5 of the rocket radius line_length = self.rocket.radius / 2.5 ax.plot( From 4db26f00beb6f225c0d3dec76bde5658160bd1bf Mon Sep 17 00:00:00 2001 From: MateusStano Date: Fri, 12 Apr 2024 14:11:58 +0200 Subject: [PATCH 16/77] ENH: normalize quaternions for transform matrix --- rocketpy/mathutils/vector_matrix.py | 38 +++++++++++++++++++++-------- 1 file changed, 28 insertions(+), 10 deletions(-) diff --git a/rocketpy/mathutils/vector_matrix.py b/rocketpy/mathutils/vector_matrix.py index b8640ddea..6e93b3151 100644 --- a/rocketpy/mathutils/vector_matrix.py +++ b/rocketpy/mathutils/vector_matrix.py @@ -982,7 +982,6 @@ def transformation(quaternion): The quaternion representing the rotation from frame A to frame B. Example: (cos(phi/2), 0, 0, sin(phi/2)) represents a rotation of phi around the z-axis. - Note: the quaternion must be normalized. Returns ------- @@ -990,22 +989,41 @@ def transformation(quaternion): The transformation matrix from frame B to frame A. """ q_w, q_x, q_y, q_z = quaternion + # #normalize quaternion + q_norm = (q_w**2 + q_x**2 + q_y**2 + q_z**2) ** 0.5 + try: + q_w /= q_norm + q_x /= q_norm + q_y /= q_norm + q_z /= q_norm + except ZeroDivisionError: + return Matrix.identity() + # precompute common terms + q_x2 = q_x**2 + q_y2 = q_y**2 + q_z2 = q_z**2 + q_wx = q_w * q_x + q_wy = q_w * q_y + q_wz = q_w * q_z + q_xy = q_x * q_y + q_xz = q_x * q_z + q_yz = q_y * q_z return Matrix( [ [ - 1 - 2 * (q_y**2 + q_z**2), - 2 * (q_x * q_y - q_w * q_z), - 2 * (q_x * q_z + q_w * q_y), + 1 - 2 * (q_y2 + q_z2), + 2 * (q_xy - q_wz), + 2 * (q_xz + q_wy), ], [ - 2 * (q_x * q_y + q_w * q_z), - 1 - 2 * (q_x**2 + q_z**2), - 2 * (q_y * q_z - q_w * q_x), + 2 * (q_xy + q_wz), + 1 - 2 * (q_x2 + q_z2), + 2 * (q_yz - q_wx), ], [ - 2 * (q_x * q_z - q_w * q_y), - 2 * (q_y * q_z + q_w * q_x), - 1 - 2 * (q_x**2 + q_y**2), + 2 * (q_xz - q_wy), + 2 * (q_yz + q_wx), + 1 - 2 * (q_x2 + q_y2), ], ] ) From 4356af799d17b436455fb412006d322d4649e926 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Fri, 12 Apr 2024 14:12:40 +0200 Subject: [PATCH 17/77] TST: lower tolerances --- tests/fixtures/rockets/rocket_fixtures.py | 17 +++++++++++++---- tests/test_sensors.py | 4 ++-- 2 files changed, 15 insertions(+), 6 deletions(-) diff --git a/tests/fixtures/rockets/rocket_fixtures.py b/tests/fixtures/rockets/rocket_fixtures.py index c461a78f4..e6231209a 100644 --- a/tests/fixtures/rockets/rocket_fixtures.py +++ b/tests/fixtures/rockets/rocket_fixtures.py @@ -244,7 +244,14 @@ def calisto_air_brakes_clamp_off(calisto_robust, controller_function): @pytest.fixture -def calisto_accel_gyro(calisto_robust, ideal_accelerometer, ideal_gyroscope): +def calisto_accel_gyro( + calisto, + calisto_nose_cone, + calisto_tail, + calisto_trapezoidal_fins, + ideal_accelerometer, + ideal_gyroscope, +): """Create an object class of the Rocket class to be used in the tests. This is the same Calisto rocket that was defined in the calisto fixture, but with an ideal accelerometer and a gyroscope added at the center of dry mass. @@ -264,9 +271,11 @@ def calisto_accel_gyro(calisto_robust, ideal_accelerometer, ideal_gyroscope): rocketpy.Rocket An object of the Rocket class """ - calisto = calisto_robust - calisto.add_sensor(ideal_accelerometer, -0.10482544178314143) - calisto.add_sensor(ideal_gyroscope, -0.10482544178314143) + calisto.add_surfaces(calisto_nose_cone, 1.160) + calisto.add_surfaces(calisto_tail, -1.313) + calisto.add_surfaces(calisto_trapezoidal_fins, -1.168) + calisto.add_sensor(ideal_accelerometer, -0.1180124376577797) + calisto.add_sensor(ideal_gyroscope, -0.1180124376577797) return calisto diff --git a/tests/test_sensors.py b/tests/test_sensors.py index 43a42942c..b94d2bc7f 100644 --- a/tests/test_sensors.py +++ b/tests/test_sensors.py @@ -40,7 +40,7 @@ def test_ideal_sensors(flight_calisto_accel_gyro): sim_accel = flight_calisto_accel_gyro.acceleration(time) # tolerance is bounded to numerical errors in the transformation matrixes - assert np.allclose(a, sim_accel, atol=1e-2) + assert np.allclose(a, sim_accel, atol=1e-12) gyroscope = flight_calisto_accel_gyro.rocket.sensors[1].component time, wx, wy, wz = zip(*gyroscope.measured_data) @@ -52,4 +52,4 @@ def test_ideal_sensors(flight_calisto_accel_gyro): flight_wy = np.array(flight_calisto_accel_gyro.w2(time)) flight_wz = np.array(flight_calisto_accel_gyro.w3(time)) sim_w = np.sqrt(flight_wx**2 + flight_wy**2 + flight_wz**2) - assert np.allclose(w, sim_w, atol=1e-8) + assert np.allclose(w, sim_w, atol=1e-12) From 5c37f06332c1caf98d8b1efd46dd74a01bcd9d57 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 15 Apr 2024 16:51:34 +0200 Subject: [PATCH 18/77] BUG: handle zero norm differently due to numpy.float64 --- rocketpy/mathutils/vector_matrix.py | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/rocketpy/mathutils/vector_matrix.py b/rocketpy/mathutils/vector_matrix.py index 6e93b3151..7900f30cc 100644 --- a/rocketpy/mathutils/vector_matrix.py +++ b/rocketpy/mathutils/vector_matrix.py @@ -989,15 +989,14 @@ def transformation(quaternion): The transformation matrix from frame B to frame A. """ q_w, q_x, q_y, q_z = quaternion - # #normalize quaternion + # normalize quaternion q_norm = (q_w**2 + q_x**2 + q_y**2 + q_z**2) ** 0.5 - try: - q_w /= q_norm - q_x /= q_norm - q_y /= q_norm - q_z /= q_norm - except ZeroDivisionError: + if q_norm == 0: return Matrix.identity() + q_w /= q_norm + q_x /= q_norm + q_y /= q_norm + q_z /= q_norm # precompute common terms q_x2 = q_x**2 q_y2 = q_y**2 From 8d649980c0e9e5a8355932957f866dcd4c51f84a Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 15 Apr 2024 17:02:27 +0200 Subject: [PATCH 19/77] MNT: quantization typos --- tests/unit/test_sensors.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensors.py index 3dbce1d34..81448c2a4 100644 --- a/tests/unit/test_sensors.py +++ b/tests/unit/test_sensors.py @@ -214,7 +214,7 @@ def test_noisy_rotated_gyroscope(noisy_rotated_gyroscope): assert noisy_rotated_gyroscope.measurement == approx([wx, wy, wz], rel=0.5) -def test_quatization_accelerometer(quantized_accelerometer): +def test_quantization_accelerometer(quantized_accelerometer): """Test the measure method of the Accelerometer class. Checks if saved measurement is (ax,ay,az) and if measured_data is [(t, (ax,ay,az)), ...] """ @@ -247,7 +247,7 @@ def test_quatization_accelerometer(quantized_accelerometer): assert quantized_accelerometer.measurement == approx([ax, ay, az], abs=1e-10) -def test_quatization_gyroscope(quantized_gyroscope): +def test_quantization_gyroscope(quantized_gyroscope): """Test the measure method of the Gyroscope class. Checks if saved measurement is (wx,wy,wz) and if measured_data is [(t, (wx,wy,wz)), ...] """ From 28da8f3a2872302785830fc7ac8eb77ba026aea9 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 15 Apr 2024 17:08:52 +0200 Subject: [PATCH 20/77] DOCS: mention Hadamard product --- rocketpy/mathutils/vector_matrix.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/rocketpy/mathutils/vector_matrix.py b/rocketpy/mathutils/vector_matrix.py index 7900f30cc..7a658de04 100644 --- a/rocketpy/mathutils/vector_matrix.py +++ b/rocketpy/mathutils/vector_matrix.py @@ -243,7 +243,8 @@ def __xor__(self, other): ) def __and__(self, other): - """Element wise multiplication between two R3 vectors. + """Element wise multiplication between two R3 vectors. Also known as + Hadamard product. Parameters ---------- From cef72a0cb398a4b3471c9682f44bc5be019ab417 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 15 Apr 2024 17:34:23 +0200 Subject: [PATCH 21/77] DOC: complete sensors class docstrings --- rocketpy/sensors/accelerometer.py | 67 +++++++++++++++++++++++++-- rocketpy/sensors/gyroscope.py | 76 ++++++++++++++++++++++++++----- rocketpy/sensors/sensors.py | 45 +++++++++++++++++- 3 files changed, 170 insertions(+), 18 deletions(-) diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 8599816bb..38e423439 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -6,8 +6,53 @@ class Accelerometer(Sensors): - """ - Class for the accelerometer sensor + """Class for the accelerometer sensor + + Attributes + ---------- + type : str + Type of the sensor, in this case "Accelerometer". + consider_gravity : bool + Whether the sensor considers the effect of gravity on the acceleration. + prints : _AccelerometerPrints + Object that contains the print functions for the sensor. + sampling_rate : float + Sample rate of the sensor in Hz. + orientation : tuple, list + Orientation of the sensor in the rocket. + measurement_range : float, tuple + The measurement range of the sensor in m/s^2. + resolution : float + The resolution of the sensor in m/s^2/LSB. + noise_density : float, list + The noise density of the sensor in m/s^2/√Hz. + random_walk : float, list + The random walk of the sensor in m/s^2/√Hz. + constant_bias : float, list + The constant bias of the sensor in m/s^2. + operating_temperature : float + The operating temperature of the sensor in degrees Celsius. + temperature_bias : float, list + The temperature bias of the sensor in m/s^2/°C. + temperature_scale_factor : float, list + The temperature scale factor of the sensor in %/°C. + cross_axis_sensitivity : float + The cross axis sensitivity of the sensor in percentage. + name : str + The name of the sensor. + rotation_matrix : Matrix + The rotation matrix of the sensor from the sensor frame to the rocket + frame of reference. + normal_vector : Vector + The normal vector of the sensor in the rocket frame of reference. + _random_walk_drift : Vector + The random walk drift of the sensor in m/s^2. + measurement : float + The measurement of the sensor after quantization, noise and temperature + drift. + measured_data : list + The stored measured data of the sensor after quantization, noise and + temperature drift. """ def __init__( @@ -32,7 +77,7 @@ def __init__( Parameters ---------- sampling_rate : float - Sample rate of the sensor + Sample rate of the sensor in Hz. orientation : tuple, list, optional Orientation of the sensor in the rocket. The orientation can be given as: @@ -124,8 +169,20 @@ def __init__( self.prints = _AccelerometerPrints(self) def measure(self, t, u, u_dot, relative_position, gravity, *args): - """ - Measure the acceleration of the rocket + """Measure the acceleration of the rocket + + Parameters + ---------- + t : float + Current time + u : list + State vector of the rocket + u_dot : list + Derivative of the state vector of the rocket + relative_position : Vector + Position of the sensor relative to the rocket cdm + gravity : float + Acceleration due to gravity """ # Linear acceleration of rocket cdm in inertial frame gravity = ( diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index de26ed7ff..21053edbe 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -6,8 +6,53 @@ class Gyroscope(Sensors): - """ - Class for the gyroscope sensor + """Class for the gyroscope sensor + + Attributes + ---------- + type : str + Type of the sensor, in this case "Gyroscope". + acceleration_sensitivity : float, list + Sensitivity of the sensor to linear acceleration in rad/s/g. + prints : _GyroscopePrints + Object that contains the print functions for the sensor. + sampling_rate : float + Sample rate of the sensor in Hz. + orientation : tuple, list + Orientation of the sensor in the rocket. + measurement_range : float, tuple + The measurement range of the sensor in the rad/s. + resolution : float + The resolution of the sensor in rad/s/LSB. + noise_density : float, list + The noise density of the sensor in rad/s/√Hz. + random_walk : float, list + The random walk of the sensor in rad/s/√Hz. + constant_bias : float, list + The constant bias of the sensor in rad/s. + operating_temperature : float + The operating temperature of the sensor in degrees Celsius. + temperature_bias : float, list + The temperature bias of the sensor in rad/s/°C. + temperature_scale_factor : float, list + The temperature scale factor of the sensor in %/°C. + cross_axis_sensitivity : float + The cross axis sensitivity of the sensor in percentage. + name : str + The name of the sensor. + rotation_matrix : Matrix + The rotation matrix of the sensor from the sensor frame to the rocket + frame of reference. + normal_vector : Vector + The normal vector of the sensor in the rocket frame of reference. + _random_walk_drift : Vector + The random walk drift of the sensor in rad/s. + measurement : float + The measurement of the sensor after quantization, noise and temperature + drift. + measured_data : list + The stored measured data of the sensor after quantization, noise and + temperature drift. """ def __init__( @@ -32,7 +77,7 @@ def __init__( Parameters ---------- sampling_rate : float - Sample rate of the sensor + Sample rate of the sensor in Hz. orientation : tuple, list, optional Orientation of the sensor in the rocket. The orientation can be given as: @@ -126,8 +171,18 @@ def __init__( self.prints = _GyroscopePrints(self) def measure(self, t, u, u_dot, relative_position, *args): - """ - Measure the angular velocity of the rocket + """Measure the angular velocity of the rocket + + Parameters + ---------- + t : float + Time at which the measurement is taken + u : list + State vector of the rocket + u_dot : list + Time derivative of the state vector of the rocket + relative_position : Vector + Vector from the rocket's center of mass to the sensor """ # Angular velocity of the rocket in the rocket frame omega = Vector(u[10:13]) @@ -164,18 +219,17 @@ def apply_acceleration_sensitivity( ---------- omega : Vector The angular velocity to apply acceleration sensitivity to - cache : tuple - The cache of the rocket state + u_dot : list + The time derivative of the state vector relative_position : Vector - The vector from the rocket's center of mass to the sensor in the - rocket frame + The vector from the rocket's center of mass to the sensor rotation_matrix : Matrix - The rotation matrix from the inertial frame to the sensor frame + The rotation matrix from the rocket frame to the sensor frame Returns ------- Vector - The angular velocity with applied acceleration sensitivity + The angular velocity with the acceleration sensitivity applied """ # Linear acceleration of rocket cdm in inertial frame a_I = Vector(u_dot[3:6]) diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index 8a626b941..fadb9ae73 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -6,8 +6,49 @@ class Sensors(ABC): - """ - Abstract class for sensors + """Abstract class for sensors + + Attributes + ---------- + type : str + Type of the sensor (e.g. Accelerometer, Gyroscope). + sampling_rate : float + Sample rate of the sensor in Hz. + orientation : tuple, list + Orientation of the sensor in the rocket. + measurement_range : float, tuple + The measurement range of the sensor in the sensor units. + resolution : float + The resolution of the sensor in sensor units/LSB. + noise_density : float, list + The noise density of the sensor in sensor units/√Hz. + random_walk : float, list + The random walk of the sensor in sensor units/√Hz. + constant_bias : float, list + The constant bias of the sensor in sensor units. + operating_temperature : float + The operating temperature of the sensor in degrees Celsius. + temperature_bias : float, list + The temperature bias of the sensor in sensor units/°C. + temperature_scale_factor : float, list + The temperature scale factor of the sensor in %/°C. + cross_axis_sensitivity : float + The cross axis sensitivity of the sensor in percentage. + name : str + The name of the sensor. + rotation_matrix : Matrix + The rotation matrix of the sensor from the sensor frame to the rocket + frame of reference. + normal_vector : Vector + The normal vector of the sensor in the rocket frame of reference. + _random_walk_drift : Vector + The random walk drift of the sensor in sensor units. + measurement : float + The measurement of the sensor after quantization, noise and temperature + drift. + measured_data : list + The stored measured data of the sensor after quantization, noise and + temperature drift. """ def __init__( From 5f8f1f453331d091b11ae362f7a3404c478c2f77 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 29 Apr 2024 17:32:54 +0200 Subject: [PATCH 22/77] Squashed commit of the following: commit b18ae9cc04e5460ca07c8c3be50f60ef44204603 Merge: 67515f6 9a8e0c1 Author: Gui-FernandesBR <63590233+Gui-FernandesBR@users.noreply.github.com> Date: Thu Apr 25 18:15:24 2024 -0400 Merge branch 'develop' into bug/airbrakes-postprocess commit 67515f64be6f1702d6497055fbb071f888ac5c09 Author: MateusStano Date: Thu Apr 25 23:02:11 2024 +0200 ENH: automatically disable time overshoot for controllers commit f60c53bfb138abbb0b19c1438daddb8c9777a2ad Merge: 4974e8d 3df7586 Author: MateusStano Date: Thu Apr 25 22:53:10 2024 +0200 Merge branch 'bug/airbrakes-postprocess' of https://github.com/RocketPy-Team/RocketPy into bug/airbrakes-postprocess commit 4974e8d7417e0d102088d40007b3c429aed1b896 Author: MateusStano Date: Thu Apr 25 22:52:48 2024 +0200 BUG: initialize state derivatives for controllers commit a49baf4d0160ca01282b101daa9444b3872b44f7 Author: MateusStano Date: Thu Apr 25 22:52:13 2024 +0200 MNT: move controller initialization to private method commit 9a8e0c1920914c3f916ea8c8f7e4c8373487af2d Merge: 14375ed 2cbaa77 Author: MateusStano <69485049+MateusStano@users.noreply.github.com> Date: Thu Apr 25 15:37:05 2024 -0300 Merge pull request #580 from RocketPy-Team/mnt/modularize-rocket-draw MNT: Modularize Rocket Draw commit 2cbaa77e91f23a6f32386082a079d9852021917b Merge: 822a89e 14375ed Author: MateusStano <69485049+MateusStano@users.noreply.github.com> Date: Thu Apr 25 11:44:22 2024 -0300 Merge branch 'develop' into mnt/modularize-rocket-draw commit 3df758642662b808664d76783e2d6a53081dd39a Merge: bf8c68b 14375ed Author: Gui-FernandesBR <63590233+Gui-FernandesBR@users.noreply.github.com> Date: Thu Apr 25 06:49:58 2024 -0400 Merge branch 'develop' into bug/airbrakes-postprocess commit 14375ed9aad490e97603cf3ff551b198e06343ca Merge: c31c6f8 b899064 Author: Gui-FernandesBR <63590233+Gui-FernandesBR@users.noreply.github.com> Date: Thu Apr 25 06:47:36 2024 -0400 Merge pull request #588 from RocketPy-Team/enh/exponential-backoff-decorator ENH: Exponential backoff decorator (fix #449) commit c31c6f87b6fb210501f80e90d251419374c8b431 Merge: a011c5a 684b997 Author: Gui-FernandesBR <63590233+Gui-FernandesBR@users.noreply.github.com> Date: Thu Apr 25 06:45:26 2024 -0400 Merge pull request #587 from RocketPy-Team/mnt/delete-cached-property DEP: delete deprecated rocketpy.tools.cached_property commit b8990644616801a9c25e91ae141f2cacf8d7501c Author: Gui-FernandesBR Date: Fri Apr 19 12:13:23 2024 -0400 DEV: adds PR 588 to the CHANGELOG commit a8a185eca86883a71580a68e6030c760e5cbd8d5 Author: Gui-FernandesBR Date: Fri Apr 19 12:08:58 2024 -0400 TST: Fix tests with Environment class after exponential_backoff decorator was used commit d0fbcd72e049618ed14f21a9355d88eee98c3792 Author: Gui-FernandesBR Date: Fri Apr 19 12:07:45 2024 -0400 MNT: Refactor code to use the exponential_backoff decorator commit ccd78af7d29e4036d92ffb731e2fca4c38212377 Author: Gui-FernandesBR Date: Fri Apr 19 12:07:17 2024 -0400 ENH: Add exponential backoff decorator to tools.py commit 684b9979b1d194fcb94e5c4da9bcf006f3c831ad Author: Gui-FernandesBR Date: Thu Apr 18 21:47:19 2024 -0400 DEV: Adds PR 587 to the CHANGELOG.md commit bb0f46a267a79787f4af32b2c7e5cf9fcaf1c90d Author: Gui-FernandesBR Date: Thu Apr 18 21:41:38 2024 -0400 MNT: refactors cached_property imports commit afb3b3227262c33bd49579db87fc85a482f41204 Author: dyu056 Date: Fri Jan 26 00:35:36 2024 +1300 Completed changes commit bf8c68bdaa477580e45f44bf5df31ba647bb1dc9 Merge: aaa3f7b a011c5a Author: Gui-FernandesBR <63590233+Gui-FernandesBR@users.noreply.github.com> Date: Thu Apr 18 21:17:06 2024 -0400 Merge branch 'develop' into bug/airbrakes-postprocess commit a011c5af1b2840186ebb6ecb89760a79f242addd Merge: 624cc15 6b26f61 Author: Gui-FernandesBR <63590233+Gui-FernandesBR@users.noreply.github.com> Date: Thu Apr 18 15:12:40 2024 -0400 Merge pull request #585 from RocketPy-Team/enh/swap-diff-for-flow-rate BUG: Swap `rocket.total_mass.differentiate` for `motor.total_mass_flow rate` commit 6b26f6153d070d269a872314f85d70f7a6d25443 Author: MateusStano Date: Wed Apr 17 22:19:16 2024 +0200 DEV: changelog commit 8ee2c95f6961e94f93ef569303588c643647778f Author: MateusStano Date: Wed Apr 17 22:16:59 2024 +0200 ENH: create rocket total_mass_flow_rate attribute commit aaa3f7b953d7450eec6056c723f83afa82a67bbb Author: MateusStano Date: Mon Apr 15 16:52:49 2024 +0200 DOCS: change accelerations names in docs commit 7fe3d0ba3b805f4a134eb399be796f7cb2e20425 Author: MateusStano Date: Mon Apr 15 16:12:39 2024 +0200 ENH: optmize post process loop commit a66fc53323248c74db32874f8dff8ee8e5cd4289 Author: MateusStano Date: Mon Apr 15 15:18:37 2024 +0200 ENH: add reset function commit b9a97a454880a3ffbb7194c9807304dfbea0899e Author: MateusStano Date: Mon Apr 15 15:06:01 2024 +0200 ENH: add warning for improper time_overshoot commit 830ea15445d9f30cf520981388e07557fe2f8da3 Author: MateusStano Date: Mon Apr 15 15:05:31 2024 +0200 ENH: refactor retrieve arrays cached properties and controller sim post processing commit e2a94c8577bf2f2bcfe19a167793cac6ea3b5f2b Author: MateusStano Date: Tue Apr 9 18:03:08 2024 +0200 TST: fix tests commit e5c75334b08313de1a2bfbeda15dd22571120187 Author: MateusStano Date: Tue Apr 9 17:59:22 2024 +0200 ENH: use mass_flow_rate instead of differentiate commit 822a89ea4b5eebede774ba8341819e99cef735fd Merge: e3e1a59 624cc15 Author: MateusStano <69485049+MateusStano@users.noreply.github.com> Date: Sun Apr 7 13:52:02 2024 +0200 Merge branch 'develop' into mnt/modularize-rocket-draw commit e3e1a59df277151fa41bb53659b41ef1fc197990 Author: MateusStano <69485049+MateusStano@users.noreply.github.com> Date: Thu Apr 4 14:53:37 2024 +0200 DEV: fix changelog order commit 624cc15cdee1806f8d08516c367a4455a9a37fd2 Merge: 0a4d89b 61bf4d7 Author: Pedro Henrique Marinho Bressan <87212571+phmbressan@users.noreply.github.com> Date: Tue Apr 2 14:23:05 2024 -0300 Merge pull request #565 from RocketPy-Team/doc/environment-docstring DOC: Improvements of Environment docstring phrasing. commit 61bf4d7aa3961d4e6d3a2911379027a4401345c4 Author: Pedro Bressan Date: Mon Apr 1 15:00:10 2024 -0300 MNT: add docs change to CHANGELOG. commit 9c1a4619ee2beb273d81f63fa78343dfa84ca790 Author: Pedro Bressan Date: Mon Apr 1 14:47:03 2024 -0300 DOC: fix typing issues regarding Environment docs. commit 477620890952571071623f14bf8cdd7a03838bad Author: Pedro Henrique Marinho Bressan <87212571+phmbressan@users.noreply.github.com> Date: Fri Mar 29 08:47:18 2024 -0300 DOC: Update Longitude value ranges. Co-authored-by: Gui-FernandesBR <63590233+Gui-FernandesBR@users.noreply.github.com> commit 32a28c12276521bbacd60a6a80f75a136ddb07f9 Merge: 27dd73d 0a4d89b Author: Pedro Henrique Marinho Bressan <87212571+phmbressan@users.noreply.github.com> Date: Thu Mar 28 18:26:46 2024 -0300 Merge branch 'develop' into doc/environment-docstring commit 27dd73d24fa82f3cbf066d6edb5aa3063b102099 Author: Pedro Bressan Date: Thu Mar 28 18:24:23 2024 -0300 DOC: standardize grammar on time zones. commit 4b42c9ec173188fa0022fe17a198b6982534ffe3 Author: Pedro Bressan Date: Thu Mar 28 18:20:01 2024 -0300 DOC: clarify timezones and dates Environment docs. commit 95b61efc8070f59373e81e049eba7dd83c5f7520 Author: Pedro Bressan Date: Thu Mar 28 16:38:17 2024 -0300 DOC: specify latitude and longitude defaults. commit 6b84c03bdaafd96c140067cfbf0a00fe05556d1e Author: Pedro Bressan Date: Mon Mar 25 19:53:37 2024 -0300 DOC: improve wording of Environment init. Co-authored-by: Gui-FernandesBR <63590233+Gui-FernandesBR@users.noreply.github.com> commit 826efcc3125a0cf1d9a24ce1039135a6877e742a Author: Pedro Bressan Date: Sun Mar 24 16:47:14 2024 -0300 DOC: specify datum as optional. commit a2aa71467b3be87c8124343cd49768c1ac4d6a9d Author: Pedro Bressan Date: Sun Mar 24 16:41:39 2024 -0300 DOC: add examples and improvements to Environment gravity docstring. commit 51bdd918b8143a419f34ef7b74847b6d3b359914 Author: MateusStano Date: Sun Mar 24 15:14:45 2024 +0100 MNT: changelog commit 6805e3277f3b576e813605a5508397e060e9f927 Author: MateusStano Date: Sun Mar 24 14:05:00 2024 +0100 MNT: refactor rocket drawing plot methods commit 3cc91e7523348fee4fc48b80174cd6229607a55e Merge: f637a9d 65b3315 Author: Pedro Henrique Marinho Bressan <87212571+phmbressan@users.noreply.github.com> Date: Thu Feb 29 20:06:09 2024 -0300 Merge branch 'develop' into doc/environment-docstring commit f637a9dc80fd7424e9defc68397c96ef73218297 Author: Pedro Bressan Date: Thu Feb 29 17:49:38 2024 -0300 STY: run black for code linting. commit 9198ac704f2d5cd1c1448da05c44b9a129a3b83c Author: Pedro Bressan Date: Thu Feb 29 17:46:23 2024 -0300 DOC: phrasing improvements of Environment docstring. --- CHANGELOG.md | 5 + rocketpy/environment/environment.py | 369 ++++++++++++------ rocketpy/environment/environment_analysis.py | 8 +- rocketpy/mathutils/function.py | 6 +- rocketpy/mathutils/vector_matrix.py | 3 +- rocketpy/motors/hybrid_motor.py | 7 +- rocketpy/motors/liquid_motor.py | 7 +- rocketpy/motors/motor.py | 6 +- rocketpy/motors/solid_motor.py | 7 +- rocketpy/motors/tank_geometry.py | 5 +- rocketpy/plots/flight_plots.py | 7 +- rocketpy/plots/rocket_plots.py | 46 ++- rocketpy/rocket/aero_surface.py | 13 +- rocketpy/rocket/rocket.py | 4 + rocketpy/simulation/flight.py | 285 +++++++++----- rocketpy/tools.py | 49 ++- .../environment/environment_fixtures.py | 5 +- tests/test_environment.py | 10 +- tests/test_flight.py | 14 +- tests/unit/test_environment.py | 2 +- 20 files changed, 534 insertions(+), 324 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 87e3c50a4..4d2509adf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -32,11 +32,15 @@ and this project adheres to [Semantic Versioning](http://semver.org/). ### Added +- ENH: Exponential backoff decorator (fix #449) [#588](https://github.com/RocketPy-Team/RocketPy/pull/588) - ENH: Add new stability margin properties to Flight class [#572](https://github.com/RocketPy-Team/RocketPy/pull/572) - ENH: adds `Function.remove_outliers` method [#554](https://github.com/RocketPy-Team/RocketPy/pull/554) ### Changed +- DEP: delete deprecated rocketpy.tools.cached_property [#587](https://github.com/RocketPy-Team/RocketPy/pull/587) +- MNT: Modularize Rocket Draw [#580](https://github.com/RocketPy-Team/RocketPy/pull/580) +- DOC: Improvements of Environment docstring phrasing [#565](https://github.com/RocketPy-Team/RocketPy/pull/565) - MNT: Refactor flight prints module [#579](https://github.com/RocketPy-Team/RocketPy/pull/579) - DOC: Convert CompareFlights example notebooks to .rst files [#576](https://github.com/RocketPy-Team/RocketPy/pull/576) - MNT: Refactor inertia calculations using parallel axis theorem [#573] (https://github.com/RocketPy-Team/RocketPy/pull/573) @@ -44,6 +48,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/). ### Fixed +- BUG: Swap rocket.total_mass.differentiate for motor.total_mass_flow rate [#585](https://github.com/RocketPy-Team/RocketPy/pull/585) - BUG: export_eng 'Motor' method would not work for liquid motors. [#559](https://github.com/RocketPy-Team/RocketPy/pull/559) ## [v1.2.2] - 2024-03-22 diff --git a/rocketpy/environment/environment.py b/rocketpy/environment/environment.py index 546d446e8..5a845a173 100644 --- a/rocketpy/environment/environment.py +++ b/rocketpy/environment/environment.py @@ -3,7 +3,7 @@ import re import warnings from collections import namedtuple -from datetime import datetime, timedelta +from datetime import datetime, timedelta, timezone import numpy as np import numpy.ma as ma @@ -13,6 +13,7 @@ from ..mathutils.function import Function, funcify_method from ..plots.environment_plots import _EnvironmentPlots from ..prints.environment_prints import _EnvironmentPrints +from ..tools import exponential_backoff try: import netCDF4 @@ -57,8 +58,7 @@ class Environment: Environment.datum : string The desired reference ellipsoid model, the following options are available: "SAD69", "WGS84", "NAD83", and "SIRGAS2000". The default - is "SIRGAS2000", then this model will be used if the user make some - typing mistake + is "SIRGAS2000". Environment.initial_east : float Launch site East UTM coordinate Environment.initial_north : float @@ -74,7 +74,7 @@ class Environment: Launch site E/W hemisphere Environment.elevation : float Launch site elevation. - Environment.date : datetime + Environment.datetime_date : datetime Date time of launch in UTC. Environment.local_date : datetime Date time of launch in the local time zone, defined by @@ -276,49 +276,70 @@ def __init__( timezone="UTC", max_expected_height=80000.0, ): - """Initialize Environment class, saving launch rail length, - launch date, location coordinates and elevation. Note that - by default the standard atmosphere is loaded until another + """Initializes the Environment class, capturing essential parameters of + the launch site, including the launch date, geographical coordinates, + and elevation. This class is designed to calculate crucial variables + for the Flight simulation, such as atmospheric air pressure, density, + and gravitational acceleration. + + Note that the default atmospheric model is the International Standard + Atmosphere as defined by ISO 2533 unless specified otherwise in + :meth:`Environment.set_atmospheric_model`. Parameters ---------- gravity : int, float, callable, string, array, optional Surface gravitational acceleration. Positive values point the - acceleration down. If None, the Somigliana formula is used to - date : array, optional - Array of length 4, stating (year, month, day, hour (UTC)) - of rocket launch. Must be given if a Forecast, Reanalysis + acceleration down. If None, the Somigliana formula is used. + See :meth:`Environment.set_gravity_model` for more information. + date : list or tuple, optional + List or tuple of length 4, stating (year, month, day, hour) in the + time zone of the parameter ``timezone``. + Alternatively, can be a ``datetime`` object specifying launch + date and time. The dates are stored as follows: + + - :attr:`Environment.local_date`: Local time of launch in + the time zone specified by the parameter ``timezone``. + + - :attr:`Environment.datetime_date`: UTC time of launch. + + Must be given if a Forecast, Reanalysis or Ensemble, will be set as an atmospheric model. + Default is None. + See :meth:`Environment.set_date` for more information. latitude : float, optional Latitude in degrees (ranging from -90 to 90) of rocket launch location. Must be given if a Forecast, Reanalysis or Ensemble will be used as an atmospheric model or if - Open-Elevation will be used to compute elevation. + Open-Elevation will be used to compute elevation. Positive + values correspond to the North. Default value is 0, which + corresponds to the equator. longitude : float, optional - Longitude in degrees (ranging from -180 to 360) of rocket + Longitude in degrees (ranging from -180 to 180) of rocket launch location. Must be given if a Forecast, Reanalysis or Ensemble will be used as an atmospheric model or if - Open-Elevation will be used to compute elevation. + Open-Elevation will be used to compute elevation. Positive + values correspond to the East. Default value is 0, which + corresponds to the Greenwich Meridian. elevation : float, optional Elevation of launch site measured as height above sea level in meters. Alternatively, can be set as 'Open-Elevation' which uses the Open-Elevation API to find elevation data. For this option, latitude and longitude must also be specified. Default value is 0. - datum : string + datum : string, optional The desired reference ellipsoidal model, the following options are available: "SAD69", "WGS84", "NAD83", and "SIRGAS2000". The default - is "SIRGAS2000", then this model will be used if the user make some - typing mistake. + is "SIRGAS2000". timezone : string, optional Name of the time zone. To see all time zones, import pytz and run - print(pytz.all_timezones). Default time zone is "UTC". + ``print(pytz.all_timezones)``. Default time zone is "UTC". max_expected_height : float, optional Maximum altitude in meters to keep weather data. The altitude must be above sea level (ASL). Especially useful for visualization. Can be altered as desired by doing `max_expected_height = number`. Depending on the atmospheric model, this value may be automatically - mofified. + modified. Returns ------- @@ -396,15 +417,57 @@ def set_date(self, date, timezone="UTC"): Parameters ---------- - date : Datetime - Datetime object specifying launch date and time. + date : list, tuple, datetime + List or tuple of length 4, stating (year, month, day, hour) in the + time zone of the parameter ``timezone``. See Notes for more + information. + Alternatively, can be a ``datetime`` object specifying launch + date and time. timezone : string, optional Name of the time zone. To see all time zones, import pytz and run - print(pytz.all_timezones). Default time zone is "UTC". + ``print(pytz.all_timezones)``. Default time zone is "UTC". Returns ------- None + + Notes + ----- + - If the ``date`` is given as a list or tuple, it should be in the same + time zone as specified by the ``timezone`` parameter. This local + time will be available in the attribute :attr:`Environment.local_date` + while the UTC time will be available in the attribute + :attr:`Environment.datetime_date`. + + - If the ``date`` is given as a ``datetime`` object without a time zone, + it will be assumed to be in the same time zone as specified by the + ``timezone`` parameter. However, if the ``datetime`` object has a time + zone specified in its ``tzinfo`` attribute, the ``timezone`` + parameter will be ignored. + + Examples + -------- + + Let's set the launch date as an list: + + >>> date = [2000, 1, 1, 13] # January 1st, 2000 at 13:00 UTC+1 + >>> env = Environment() + >>> env.set_date(date, timezone="Europe/Rome") + >>> print(env.datetime_date) # Get UTC time + 2000-01-01 12:00:00+00:00 + >>> print(env.local_date) + 2000-01-01 13:00:00+01:00 + + Now let's set the launch date as a ``datetime`` object: + + >>> from datetime import datetime + >>> date = datetime(2000, 1, 1, 13, 0, 0) + >>> env = Environment() + >>> env.set_date(date, timezone="Europe/Rome") + >>> print(env.datetime_date) # Get UTC time + 2000-01-01 12:00:00+00:00 + >>> print(env.local_date) + 2000-01-01 13:00:00+01:00 """ # Store date and configure time zone self.timezone = timezone @@ -458,23 +521,66 @@ def set_location(self, latitude, longitude): self.atmospheric_model_file, self.atmospheric_model_dict ) - # Return None - - def set_gravity_model(self, gravity): - """Sets the gravity model to be used in the simulation based on the - given user input to the gravity parameter. + def set_gravity_model(self, gravity=None): + """Defines the gravity model based on the given user input to the + gravity parameter. The gravity model is responsible for computing the + gravity acceleration at a given height above sea level in meters. Parameters ---------- - gravity : None or Function source - If None, the Somigliana formula is used to compute the gravity - acceleration. Otherwise, the user can provide a Function object - representing the gravity model. + gravity : int, float, callable, string, list, optional + The gravitational acceleration in m/s² to be used in the + simulation, this value is positive when pointing downwards. + The input type can be one of the following: + + - ``int`` or ``float``: The gravity acceleration is set as a\ + constant function with respect to height; + + - ``callable``: This callable should receive the height above\ + sea level in meters and return the gravity acceleration; + + - ``list``: The datapoints should be structured as\ + ``[(h_i,g_i), ...]`` where ``h_i`` is the height above sea\ + level in meters and ``g_i`` is the gravity acceleration in m/s²; + + - ``string``: The string should correspond to a path to a CSV file\ + containing the gravity acceleration data; + + - ``None``: The Somigliana formula is used to compute the gravity\ + acceleration. + + This parameter is used as a :class:`Function` object source, check\ + out the available input types for a more detailed explanation. Returns ------- Function Function object representing the gravity model. + + Notes + ----- + This method **does not** set the gravity acceleration, it only returns + a :class:`Function` object representing the gravity model. + + Examples + -------- + Let's prepare a `Environment` object with a constant gravity + acceleration: + + >>> g_0 = 9.80665 + >>> env_cte_g = Environment(gravity=g_0) + >>> env_cte_g.gravity([0, 100, 1000]) + [9.80665, 9.80665, 9.80665] + + It's also possible to variate the gravity acceleration by defining + its function of height: + + >>> R_t = 6371000 + >>> g_func = lambda h : g_0 * (R_t / (R_t + h))**2 + >>> env_var_g = Environment(gravity=g_func) + >>> g = env_var_g.gravity(1000) + >>> print(f"{g:.6f}") + 9.803572 """ if gravity is None: return self.somigliana_gravity.set_discrete( @@ -500,7 +606,7 @@ def max_expected_height(self, value): @funcify_method("height (m)", "gravity (m/s²)") def somigliana_gravity(self, height): - """Computes the gravity acceleration with the Somigliana formula. + """Computes the gravity acceleration with the Somigliana formula [1]_. An height correction is applied to the normal gravity that is accurate for heights used in aviation. The formula is based on the WGS84 ellipsoid, but is accurate for other reference ellipsoids. @@ -514,6 +620,10 @@ def somigliana_gravity(self, height): ------- Function Function object representing the gravity model. + + References + ---------- + .. [1] https://en.wikipedia.org/wiki/Theoretical_gravity#Somigliana_equation """ a = 6378137.0 # semi_major_axis f = 1 / 298.257223563 # flattening_factor @@ -571,18 +681,9 @@ def set_elevation(self, elevation="Open-Elevation"): # self.elevation = elev - elif self.latitude != None and self.longitude != None: - try: - print("Fetching elevation from open-elevation.com...") - request_url = "https://api.open-elevation.com/api/v1/lookup?locations={:f},{:f}".format( - self.latitude, self.longitude - ) - response = requests.get(request_url) - results = response.json()["results"] - self.elevation = results[0]["elevation"] - print("Elevation received:", self.elevation) - except: - raise RuntimeError("Unable to reach Open-Elevation API servers.") + elif self.latitude is not None and self.longitude is not None: + self.elevation = self.__fetch_open_elevation() + print("Elevation received: ", self.elevation) else: raise ValueError( "Latitude and longitude must be set to use" @@ -1194,26 +1295,8 @@ def set_atmospheric_model( "v_wind": "vgrdprs", } # Attempt to get latest forecast - time_attempt = datetime.utcnow() - success = False - attempt_count = 0 - while not success and attempt_count < 10: - time_attempt -= timedelta(hours=6 * attempt_count) - file = "https://nomads.ncep.noaa.gov/dods/gens_bc/gens{:04d}{:02d}{:02d}/gep_all_{:02d}z".format( - time_attempt.year, - time_attempt.month, - time_attempt.day, - 6 * (time_attempt.hour // 6), - ) - try: - self.process_ensemble(file, dictionary) - success = True - except OSError: - attempt_count += 1 - if not success: - raise RuntimeError( - "Unable to load latest weather data for GEFS through " + file - ) + self.__fetch_gefs_ensemble(dictionary) + elif file == "CMC": # Define dictionary dictionary = { @@ -1229,27 +1312,7 @@ def set_atmospheric_model( "u_wind": "ugrdprs", "v_wind": "vgrdprs", } - # Attempt to get latest forecast - time_attempt = datetime.utcnow() - success = False - attempt_count = 0 - while not success and attempt_count < 10: - time_attempt -= timedelta(hours=12 * attempt_count) - file = "https://nomads.ncep.noaa.gov/dods/cmcens/cmcens{:04d}{:02d}{:02d}/cmcens_all_{:02d}z".format( - time_attempt.year, - time_attempt.month, - time_attempt.day, - 12 * (time_attempt.hour // 12), - ) - try: - self.process_ensemble(file, dictionary) - success = True - except OSError: - attempt_count += 1 - if not success: - raise RuntimeError( - "Unable to load latest weather data for CMC through " + file - ) + self.__fetch_cmc_ensemble(dictionary) # Process other forecasts or reanalysis else: # Check if default dictionary was requested @@ -1541,20 +1604,7 @@ def process_windy_atmosphere(self, model="ECMWF"): model. """ - # Process the model string - model = model.lower() - if model[-1] == "u": # case iconEu - model = "".join([model[:4], model[4].upper(), model[4 + 1 :]]) - # Load data from Windy.com: json file - url = f"https://node.windy.com/forecast/meteogram/{model}/{self.latitude}/{self.longitude}/?step=undefined" - try: - response = requests.get(url).json() - except: - if model == "iconEu": - raise ValueError( - "Could not get a valid response for Icon-EU from Windy. Check if the latitude and longitude coordinates set are inside Europe.", - ) - raise + response = self.__fetch_atmospheric_data_from_windy(model) # Determine time index from model time_array = np.array(response["data"]["hours"]) @@ -1715,18 +1765,7 @@ def process_wyoming_sounding(self, file): None """ # Request Wyoming Sounding from file url - response = requests.get(file) - if response.status_code != 200: - raise ImportError("Unable to load " + file + ".") - if len(re.findall("Can't get .+ Observations at", response.text)): - raise ValueError( - re.findall("Can't get .+ Observations at .+", response.text)[0] - + " Check station number and date." - ) - if response.text == "Invalid OUTPUT: specified\n": - raise ValueError( - "Invalid OUTPUT: specified. Make sure the output is Text: List." - ) + response = self.__fetch_wyoming_sounding(file) # Process Wyoming Sounding by finding data table and station info response_split_text = re.split("(<.{0,1}PRE>)", response.text) @@ -1852,9 +1891,7 @@ def process_noaaruc_sounding(self, file): None """ # Request NOAA Ruc Sounding from file url - response = requests.get(file) - if response.status_code != 200 or len(response.text) < 10: - raise ImportError("Unable to load " + file + ".") + response = self.__fetch_noaaruc_sounding(file) # Split response into lines lines = response.text.split("\n") @@ -3429,6 +3466,110 @@ def set_earth_geometry(self, datum): f"The reference system {datum} for Earth geometry " "is not recognized." ) + # Auxiliary functions - Fetching Data from 3rd party APIs + + @exponential_backoff(max_attempts=3, base_delay=1, max_delay=60) + def __fetch_open_elevation(self): + print("Fetching elevation from open-elevation.com...") + request_url = ( + "https://api.open-elevation.com/api/v1/lookup?locations" + f"={self.latitude},{self.longitude}" + ) + try: + response = requests.get(request_url) + except Exception as e: + raise RuntimeError("Unable to reach Open-Elevation API servers.") + results = response.json()["results"] + return results[0]["elevation"] + + @exponential_backoff(max_attempts=5, base_delay=2, max_delay=60) + def __fetch_atmospheric_data_from_windy(self, model): + model = model.lower() + if model[-1] == "u": # case iconEu + model = "".join([model[:4], model[4].upper(), model[4 + 1 :]]) + url = ( + f"https://node.windy.com/forecast/meteogram/{model}/" + f"{self.latitude}/{self.longitude}/?step=undefined" + ) + try: + response = requests.get(url).json() + except Exception as e: + if model == "iconEu": + raise ValueError( + "Could not get a valid response for Icon-EU from Windy. " + "Check if the coordinates are set inside Europe." + ) + return response + + @exponential_backoff(max_attempts=5, base_delay=2, max_delay=60) + def __fetch_wyoming_sounding(self, file): + response = requests.get(file) + if response.status_code != 200: + raise ImportError(f"Unable to load {file}.") + if len(re.findall("Can't get .+ Observations at", response.text)): + raise ValueError( + re.findall("Can't get .+ Observations at .+", response.text)[0] + + " Check station number and date." + ) + if response.text == "Invalid OUTPUT: specified\n": + raise ValueError( + "Invalid OUTPUT: specified. Make sure the output is Text: List." + ) + return response + + @exponential_backoff(max_attempts=5, base_delay=2, max_delay=60) + def __fetch_noaaruc_sounding(self, file): + response = requests.get(file) + if response.status_code != 200 or len(response.text) < 10: + raise ImportError("Unable to load " + file + ".") + + @exponential_backoff(max_attempts=5, base_delay=2, max_delay=60) + def __fetch_gefs_ensemble(self, dictionary): + time_attempt = datetime.now(tz=timezone.utc) + success = False + attempt_count = 0 + while not success and attempt_count < 10: + time_attempt -= timedelta(hours=6 * attempt_count) + file = ( + f"https://nomads.ncep.noaa.gov/dods/gens_bc/gens" + f"{time_attempt.year:04d}{time_attempt.month:02d}" + f"{time_attempt.day:02d}/" + f"gep_all_{6 * (time_attempt.hour // 6):02d}z" + ) + try: + self.process_ensemble(file, dictionary) + success = True + except OSError: + attempt_count += 1 + if not success: + raise RuntimeError( + "Unable to load latest weather data for GEFS through " + file + ) + + @exponential_backoff(max_attempts=5, base_delay=2, max_delay=60) + def __fetch_cmc_ensemble(self, dictionary): + # Attempt to get latest forecast + time_attempt = datetime.now(tz=timezone.utc) + success = False + attempt_count = 0 + while not success and attempt_count < 10: + time_attempt -= timedelta(hours=12 * attempt_count) + file = ( + f"https://nomads.ncep.noaa.gov/dods/cmcens/" + f"cmcens{time_attempt.year:04d}{time_attempt.month:02d}" + f"{time_attempt.day:02d}/" + f"cmcens_all_{12 * (time_attempt.hour // 12):02d}z" + ) + try: + self.process_ensemble(file, dictionary) + success = True + except OSError: + attempt_count += 1 + if not success: + raise RuntimeError( + "Unable to load latest weather data for CMC through " + file + ) + # Auxiliary functions - Geodesic Coordinates @staticmethod diff --git a/rocketpy/environment/environment_analysis.py b/rocketpy/environment/environment_analysis.py index c15b32551..da6fde364 100644 --- a/rocketpy/environment/environment_analysis.py +++ b/rocketpy/environment/environment_analysis.py @@ -3,6 +3,7 @@ import datetime import json from collections import defaultdict +from functools import cached_property import netCDF4 import numpy as np @@ -22,11 +23,6 @@ from ..units import convert_units from .environment import Environment -try: - from functools import cached_property -except ImportError: - from ..tools import cached_property - # TODO: the average_wind_speed_profile_by_hour and similar methods could be more abstract than currently are @@ -441,7 +437,7 @@ def __localize_input_dates(self): def __find_preferred_timezone(self): if self.preferred_timezone is None: - # Use local timezone based on lat lon pair + # Use local time zone based on lat lon pair try: timezonefinder = import_optional_dependency("timezonefinder") tf = timezonefinder.TimezoneFinder() diff --git a/rocketpy/mathutils/function.py b/rocketpy/mathutils/function.py index cefed044d..eda903bcc 100644 --- a/rocketpy/mathutils/function.py +++ b/rocketpy/mathutils/function.py @@ -7,6 +7,7 @@ import warnings from collections.abc import Iterable from copy import deepcopy +from functools import cached_property from inspect import signature from pathlib import Path @@ -14,11 +15,6 @@ import numpy as np from scipy import integrate, linalg, optimize -try: - from functools import cached_property -except ImportError: - from ..tools import cached_property - NUMERICAL_TYPES = (float, int, complex, np.ndarray, np.integer, np.floating) diff --git a/rocketpy/mathutils/vector_matrix.py b/rocketpy/mathutils/vector_matrix.py index 7a658de04..9c3efe616 100644 --- a/rocketpy/mathutils/vector_matrix.py +++ b/rocketpy/mathutils/vector_matrix.py @@ -1,7 +1,8 @@ from cmath import isclose +from functools import cached_property from itertools import product -from rocketpy.tools import cached_property, euler_to_quaternions +from rocketpy.tools import euler_to_quaternions class Vector: diff --git a/rocketpy/motors/hybrid_motor.py b/rocketpy/motors/hybrid_motor.py index 6f0849cd0..557333fe7 100644 --- a/rocketpy/motors/hybrid_motor.py +++ b/rocketpy/motors/hybrid_motor.py @@ -1,3 +1,5 @@ +from functools import cached_property + from rocketpy.tools import parallel_axis_theorem_from_com from ..mathutils.function import Function, funcify_method, reset_funcified_methods @@ -7,11 +9,6 @@ from .motor import Motor from .solid_motor import SolidMotor -try: - from functools import cached_property -except ImportError: - from ..tools import cached_property - class HybridMotor(Motor): """Class to specify characteristics and useful operations for Hybrid diff --git a/rocketpy/motors/liquid_motor.py b/rocketpy/motors/liquid_motor.py index 01f728473..7314e11ba 100644 --- a/rocketpy/motors/liquid_motor.py +++ b/rocketpy/motors/liquid_motor.py @@ -1,4 +1,4 @@ -import warnings +from functools import cached_property import numpy as np @@ -13,11 +13,6 @@ from ..prints.liquid_motor_prints import _LiquidMotorPrints from .motor import Motor -try: - from functools import cached_property -except ImportError: - from ..tools import cached_property - class LiquidMotor(Motor): """Class to specify characteristics and useful operations for Liquid diff --git a/rocketpy/motors/motor.py b/rocketpy/motors/motor.py index 3834f4a15..9429da88e 100644 --- a/rocketpy/motors/motor.py +++ b/rocketpy/motors/motor.py @@ -1,6 +1,7 @@ import re import warnings from abc import ABC, abstractmethod +from functools import cached_property import numpy as np @@ -9,11 +10,6 @@ from ..prints.motor_prints import _MotorPrints from ..tools import parallel_axis_theorem_from_com, tuple_handler -try: - from functools import cached_property -except ImportError: - from ..tools import cached_property - class Motor(ABC): """Abstract class to specify characteristics and useful operations for diff --git a/rocketpy/motors/solid_motor.py b/rocketpy/motors/solid_motor.py index 8b1c2362e..db3527a95 100644 --- a/rocketpy/motors/solid_motor.py +++ b/rocketpy/motors/solid_motor.py @@ -1,3 +1,5 @@ +from functools import cached_property + import numpy as np from scipy import integrate @@ -6,11 +8,6 @@ from ..prints.solid_motor_prints import _SolidMotorPrints from .motor import Motor -try: - from functools import cached_property -except ImportError: - from ..tools import cached_property - class SolidMotor(Motor): """Class to specify characteristics and useful operations for solid motors. diff --git a/rocketpy/motors/tank_geometry.py b/rocketpy/motors/tank_geometry.py index f1940cbea..2eb7bd27e 100644 --- a/rocketpy/motors/tank_geometry.py +++ b/rocketpy/motors/tank_geometry.py @@ -11,10 +11,7 @@ cache = lru_cache(maxsize=None) -try: - from functools import cached_property -except ImportError: - from ..tools import cached_property +from functools import cached_property class TankGeometry: diff --git a/rocketpy/plots/flight_plots.py b/rocketpy/plots/flight_plots.py index 4ae5141c9..21266a1f3 100644 --- a/rocketpy/plots/flight_plots.py +++ b/rocketpy/plots/flight_plots.py @@ -1,11 +1,8 @@ +from functools import cached_property + import matplotlib.pyplot as plt import numpy as np -try: - from functools import cached_property -except ImportError: - from ..tools import cached_property - class _FlightPlots: """Class that holds plot methods for Flight class. diff --git a/rocketpy/plots/rocket_plots.py b/rocketpy/plots/rocket_plots.py index e801da3c7..0d7b5b130 100644 --- a/rocketpy/plots/rocket_plots.py +++ b/rocketpy/plots/rocket_plots.py @@ -230,6 +230,8 @@ def draw(self, vis_args=None, plane="xz"): plt.show() def _draw_aerodynamic_surfaces(self, ax, vis_args): + """Draws the aerodynamic surfaces and saves the position of the points + of interest for the tubes.""" # List of drawn surfaces with the position of points of interest # and the radius of the rocket at that point drawn_surfaces = [] @@ -250,6 +252,8 @@ def _draw_aerodynamic_surfaces(self, ax, vis_args): return drawn_surfaces def _draw_nose_cone(self, ax, surface, position, drawn_surfaces, vis_args): + """Draws the nosecone and saves the position of the points of interest + for the tubes.""" x_nosecone = -self.rocket._csys * surface.shape_vec[0] + position y_nosecone = surface.shape_vec[1] ax.plot( @@ -277,6 +281,8 @@ def _draw_nose_cone(self, ax, surface, position, drawn_surfaces, vis_args): ) def _draw_tail(self, ax, surface, position, drawn_surfaces, vis_args): + """Draws the tail and saves the position of the points of interest + for the tubes.""" x_tail = -self.rocket._csys * surface.shape_vec[0] + position y_tail = surface.shape_vec[1] ax.plot( @@ -302,13 +308,30 @@ def _draw_tail(self, ax, surface, position, drawn_surfaces, vis_args): drawn_surfaces.append((surface, position, surface.bottom_radius, x_tail[-1])) def _draw_fins(self, ax, surface, position, drawn_surfaces, vis_args): + """Draws the fins and saves the position of the points of interest + for the tubes.""" num_fins = surface.n x_fin = -self.rocket._csys * surface.shape_vec[0] + position y_fin = surface.shape_vec[1] + surface.rocket_radius rotation_angles = [2 * np.pi * i / num_fins for i in range(num_fins)] for angle in rotation_angles: - x_rotated, y_rotated = self._rotate_points(x_fin, y_fin, angle) + # Create a rotation matrix for the current angle around the x-axis + rotation_matrix = np.array([[1, 0], [0, np.cos(angle)]]) + + # Apply the rotation to the original fin points + rotated_points_2d = np.dot(rotation_matrix, np.vstack((x_fin, y_fin))) + + # Extract x and y coordinates of the rotated points + x_rotated, y_rotated = rotated_points_2d + + # Project points above the XY plane back into the XY plane (set z-coordinate to 0) + x_rotated = np.where( + rotated_points_2d[1] > 0, rotated_points_2d[0], x_rotated + ) + y_rotated = np.where( + rotated_points_2d[1] > 0, rotated_points_2d[1], y_rotated + ) ax.plot( x_rotated, y_rotated, @@ -318,22 +341,8 @@ def _draw_fins(self, ax, surface, position, drawn_surfaces, vis_args): drawn_surfaces.append((surface, position, surface.rocket_radius, x_rotated[-1])) - def _rotate_points(self, x_fin, y_fin, angle): - # Create a rotation matrix for the current angle around the x-axis - rotation_matrix = np.array([[1, 0], [0, np.cos(angle)]]) - - # Apply the rotation to the original fin points - rotated_points_2d = np.dot(rotation_matrix, np.vstack((x_fin, y_fin))) - - # Extract x and y coordinates of the rotated points - x_rotated, y_rotated = rotated_points_2d - - # Project points above the XY plane back into the XY plane (set z-coordinate to 0) - x_rotated = np.where(rotated_points_2d[1] > 0, rotated_points_2d[0], x_rotated) - y_rotated = np.where(rotated_points_2d[1] > 0, rotated_points_2d[1], y_rotated) - return x_rotated, y_rotated - def _draw_tubes(self, ax, drawn_surfaces, vis_args): + """Draws the tubes between the aerodynamic surfaces.""" for i, d_surface in enumerate(drawn_surfaces): # Draw the tubes, from the end of the first surface to the beginning # of the next surface, with the radius of the rocket at that point @@ -373,6 +382,7 @@ def _draw_tubes(self, ax, drawn_surfaces, vis_args): return radius, last_x def _draw_motor(self, last_radius, last_x, ax, vis_args): + """Draws the motor from motor patches""" total_csys = self.rocket._csys * self.rocket.motor._csys nozzle_position = ( self.rocket.motor_position + self.rocket.motor.nozzle_position * total_csys @@ -400,6 +410,7 @@ def _draw_motor(self, last_radius, last_x, ax, vis_args): self._draw_nozzle_tube(last_radius, last_x, nozzle_position, ax, vis_args) def _generate_motor_patches(self, total_csys, ax, vis_args): + """Generates motor patches for drawing""" motor_patches = [] if isinstance(self.rocket.motor, SolidMotor): @@ -478,6 +489,7 @@ def _generate_motor_patches(self, total_csys, ax, vis_args): return motor_patches def _draw_nozzle_tube(self, last_radius, last_x, nozzle_position, ax, vis_args): + """Draws the tube from the last surface to the nozzle position.""" # Check if nozzle is beyond the last surface, if so draw a tube # to it, with the radius of the last surface if self.rocket._csys == 1: @@ -518,6 +530,7 @@ def _draw_nozzle_tube(self, last_radius, last_x, nozzle_position, ax, vis_args): ) def _draw_rail_buttons(self, ax, vis_args): + """Draws the rail buttons of the rocket.""" try: buttons, pos = self.rocket.rail_buttons[0] lower = pos @@ -532,6 +545,7 @@ def _draw_rail_buttons(self, ax, vis_args): pass def _draw_center_of_mass_and_pressure(self, ax): + """Draws the center of mass and center of pressure of the rocket.""" # Draw center of mass and center of pressure cm = self.rocket.center_of_mass(0) ax.scatter(cm, 0, color="#1565c0", label="Center of Mass", s=10) diff --git a/rocketpy/rocket/aero_surface.py b/rocketpy/rocket/aero_surface.py index c5d154f3e..9649d1bf0 100644 --- a/rocketpy/rocket/aero_surface.py +++ b/rocketpy/rocket/aero_surface.py @@ -1,6 +1,5 @@ import warnings from abc import ABC, abstractmethod -from functools import cached_property import numpy as np from scipy.optimize import fsolve @@ -1978,8 +1977,9 @@ def __init__( brakes drag coefficient will be used for the entire rocket instead. Default is False. deployment_level : float, optional - Current deployment level, ranging from 0 to 1. Deployment level is the - fraction of the total airbrake area that is Deployment. Default is 0. + Initial deployment level, ranging from 0 to 1. Deployment level is + the fraction of the total airbrake area that is Deployment. Default + is 0. name : str, optional Name of the air brakes. Default is "AirBrakes". @@ -1997,6 +1997,7 @@ def __init__( self.reference_area = reference_area self.clamp = clamp self.override_rocket_drag = override_rocket_drag + self.initial_deployment_level = deployment_level self.deployment_level = deployment_level self.prints = _AirBrakesPrints(self) self.plots = _AirBrakesPlots(self) @@ -2023,6 +2024,12 @@ def deployment_level(self, value): ) self._deployment_level = value + def _reset(self): + """Resets the air brakes to their initial state. This is ran at the + beginning of each simulation to ensure the air brakes are in the correct + state.""" + self.deployment_level = self.initial_deployment_level + def evaluate_center_of_pressure(self): """Evaluates the center of pressure of the aerodynamic surface in local coordinates. diff --git a/rocketpy/rocket/rocket.py b/rocketpy/rocket/rocket.py index 9c179557e..45fce0cd5 100644 --- a/rocketpy/rocket/rocket.py +++ b/rocketpy/rocket/rocket.py @@ -82,6 +82,9 @@ class Rocket: Function of time expressing the total mass of the rocket, defined as the sum of the propellant mass and the rocket mass without propellant. + Rocket.total_mass_flow_rate : Function + Time derivative of rocket's total mass in kg/s as a function + of time as obtained by the thrust source of the added motor. Rocket.thrust_to_weight : Function Function of time expressing the motor thrust force divided by rocket weight. The gravitational acceleration is assumed as 9.80665 m/s^2. @@ -760,6 +763,7 @@ def add_motor(self, motor, position): self.motor.center_of_dry_mass_position * _ + self.motor_position ) self.nozzle_position = self.motor.nozzle_position * _ + self.motor_position + self.total_mass_flow_rate = self.motor.total_mass_flow_rate self.evaluate_dry_mass() self.evaluate_total_mass() self.evaluate_center_of_dry_mass() diff --git a/rocketpy/simulation/flight.py b/rocketpy/simulation/flight.py index f82b63b1c..8aa3f4cd6 100644 --- a/rocketpy/simulation/flight.py +++ b/rocketpy/simulation/flight.py @@ -611,6 +611,9 @@ def __init__( self.name = name self.equations_of_motion = equations_of_motion + # Controller initialization + self.__init_controllers() + # Flight initialization self.__init_post_process_variables() self.__init_solution_monitors() @@ -1107,8 +1110,14 @@ def __init__( [self.t, parachute] ) + # If controlled flight, post process must be done on sim time + if self._controllers: + phase.derivative(self.t, self.y_sol, post_processing=True) + self.t_final = self.t self._calculate_pressure_signal() + if self._controllers: + self.__cache_post_process_variables() if verbose: print("Simulation Completed at Time: {:3.4f} s".format(self.t)) @@ -1120,6 +1129,25 @@ def __init_post_process_variables(self): self._bearing = Function(0) self._latitude = Function(0) self._longitude = Function(0) + # Initialize state derivatives, force and atmospheric arrays + self.ax_list = [] + self.ay_list = [] + self.az_list = [] + self.alpha1_list = [] + self.alpha2_list = [] + self.alpha3_list = [] + self.R1_list = [] + self.R2_list = [] + self.R3_list = [] + self.M1_list = [] + self.M2_list = [] + self.M3_list = [] + self.pressure_list = [] + self.density_list = [] + self.dynamic_viscosity_list = [] + self.speed_of_sound_list = [] + self.wind_velocity_x_list = [] + self.wind_velocity_y_list = [] def __init_solution_monitors(self): # Initialize solution monitors @@ -1192,6 +1220,11 @@ def __init_flight_state(self): self.out_of_rail_time = self.initial_solution[0] self.out_of_rail_time_index = 0 self.initial_derivative = self.u_dot_generalized + if self._controllers: + # Handle post process during simulation, get initial accel/forces + self.initial_derivative( + self.t_initial, self.initial_solution[1:], post_processing=True + ) def __init_solver_monitors(self): # Initialize solver monitors @@ -1212,10 +1245,41 @@ def __init_equations_of_motion(self): if self.equations_of_motion == "solid_propulsion": self.u_dot_generalized = self.u_dot - def __init_equations_of_motion(self): - """Initialize equations of motion.""" - if self.equations_of_motion == "solid_propulsion": - self.u_dot_generalized = self.u_dot + def __init_controllers(self): + """Initialize controllers""" + self._controllers = self.rocket._controllers[:] + if self._controllers: + if self.time_overshoot == True: + self.time_overshoot = False + warnings.warn( + "time_overshoot has been set to False due to the presence of controllers. " + ) + # reset controllable object to initial state (only airbrakes for now) + for air_brakes in self.rocket.air_brakes: + air_brakes._reset() + + def __cache_post_process_variables(self): + """Cache post-process variables for simulations with controllers.""" + self.__retrieve_arrays = [ + self.ax_list, + self.ay_list, + self.az_list, + self.alpha1_list, + self.alpha2_list, + self.alpha3_list, + self.R1_list, + self.R2_list, + self.R3_list, + self.M1_list, + self.M2_list, + self.M3_list, + self.pressure_list, + self.density_list, + self.dynamic_viscosity_list, + self.speed_of_sound_list, + self.wind_velocity_x_list, + self.wind_velocity_y_list, + ] @cached_property def effective_1rl(self): @@ -1292,11 +1356,6 @@ def udot_rail1(self, t, u, post_processing=False): e0dot, e1dot, e2dot, e3dot, alpha1, alpha2, alpha3]. """ - # Check if post processing mode is on - if post_processing: - # Use u_dot post processing code - return self.u_dot_generalized(t, u, True) - # Retrieve integration data x, y, z, vx, vy, vz, e0, e1, e2, e3, omega1, omega2, omega3 = u @@ -1327,6 +1386,17 @@ def udot_rail1(self, t, u, post_processing=False): else: ax, ay, az = 0, 0, 0 + if post_processing: + # Use u_dot post processing code for forces, moments and env data + self.u_dot_generalized(t, u, post_processing=True) + # Save feasible accelerations + self.ax_list[-1] = [t, ax] + self.ay_list[-1] = [t, ay] + self.az_list[-1] = [t, az] + self.alpha1_list[-1] = [t, 0] + self.alpha2_list[-1] = [t, 0] + self.alpha3_list[-1] = [t, 0] + return [vx, vy, vz, ax, ay, az, 0, 0, 0, 0, 0, 0, 0] def udot_rail2(self, t, u, post_processing=False): @@ -1616,6 +1686,13 @@ def u_dot(self, t, u, post_processing=False): ] if post_processing: + # Accelerations + self.ax_list.append([t, ax]) + self.ay_list.append([t, ay]) + self.az_list.append([t, az]) + self.alpha1_list.append([t, alpha1]) + self.alpha2_list.append([t, alpha2]) + self.alpha3_list.append([t, alpha3]) # Dynamics variables self.R1_list.append([t, R1]) self.R2_list.append([t, R2]) @@ -1676,8 +1753,8 @@ def u_dot_generalized(self, t, u, post_processing=False): # Retrieve necessary quantities rho = self.env.density.get_value_opt(z) total_mass = self.rocket.total_mass.get_value_opt(t) - total_mass_dot = self.rocket.total_mass.differentiate(t) - total_mass_ddot = self.rocket.total_mass.differentiate(t, order=2) + total_mass_dot = self.rocket.total_mass_flow_rate.get_value_opt(t) + total_mass_ddot = self.rocket.total_mass_flow_rate.differentiate(t) ## CM position vector and time derivatives relative to CDM in body frame r_CM_z = ( -1 @@ -1891,6 +1968,13 @@ def u_dot_generalized(self, t, u, post_processing=False): u_dot = [*r_dot, *v_dot, *e_dot, *w_dot] if post_processing: + # Accelerations + self.ax_list.append([t, v_dot[0]]) + self.ay_list.append([t, v_dot[1]]) + self.az_list.append([t, v_dot[2]]) + self.alpha1_list.append([t, w_dot[0]]) + self.alpha2_list.append([t, w_dot[1]]) + self.alpha3_list.append([t, w_dot[2]]) # Dynamics variables self.R1_list.append([t, R1]) self.R2_list.append([t, R2]) @@ -1977,6 +2061,13 @@ def u_dot_parachute(self, t, u, post_processing=False): u_dot = [vx, vy, vz, ax, ay, az, 0, 0, 0, 0, 0, 0, 0] if post_processing: + # Accelerations + self.ax_list.append([t, ax]) + self.ay_list.append([t, ay]) + self.az_list.append([t, az]) + self.alpha1_list.append([t, 0]) + self.alpha2_list.append([t, 0]) + self.alpha3_list.append([t, 0]) # Dynamics variables self.R1_list.append([t, Dx]) self.R2_list.append([t, Dy]) @@ -1985,13 +2076,20 @@ def u_dot_parachute(self, t, u, post_processing=False): self.M2_list.append([t, 0]) self.M3_list.append([t, 0]) # Atmospheric Conditions - self.wind_velocity_x_list.append([t, self.env.wind_velocity_x(z)]) - self.wind_velocity_y_list.append([t, self.env.wind_velocity_y(z)]) - self.density_list.append([t, self.env.density(z)]) - self.dynamic_viscosity_list.append([t, self.env.dynamic_viscosity(z)]) - self.pressure_list.append([t, self.env.pressure(z)]) - self.speed_of_sound_list.append([t, self.env.speed_of_sound(z)]) - + self.wind_velocity_x_list.append( + [t, self.env.wind_velocity_x.get_value_opt(z)] + ) + self.wind_velocity_y_list.append( + [t, self.env.wind_velocity_y.get_value_opt(z)] + ) + self.density_list.append([t, self.env.density.get_value_opt(z)]) + self.dynamic_viscosity_list.append( + [t, self.env.dynamic_viscosity.get_value_opt(z)] + ) + self.pressure_list.append([t, self.env.pressure.get_value_opt(z)]) + self.speed_of_sound_list.append( + [t, self.env.speed_of_sound.get_value_opt(z)] + ) return [vx, vy, vz, ax, ay, az, 0, 0, 0, 0, 0, 0, 0] @cached_property @@ -2824,31 +2922,20 @@ def longitude(self): return np.column_stack((self.time, longitude)) @cached_property - def retrieve_acceleration_arrays(self): - """Retrieve acceleration arrays from the integration scheme - - Parameters - ---------- + def __retrieve_arrays(self): + """post processing function to retrieve arrays from the integration + scheme and store them in lists for further analysis. Returns ------- - ax: list - acceleration in x direction - ay: list - acceleration in y direction - az: list - acceleration in z direction - alpha1: list - angular acceleration in x direction - alpha2: list - angular acceleration in y direction - alpha3: list - angular acceleration in z direction + temp_values: list + List containing the following arrays: ``ax`` , ``ay`` , ``az`` , + ``alpha1`` , ``alpha2`` , ``alpha3`` , ``R1`` , ``R2`` , ``R3`` , + ``M1`` , ``M2`` , ``M3`` , ``pressure`` , ``density`` , + ``dynamic_viscosity`` , ``speed_of_sound`` , ``wind_velocity_x`` , + ``wind_velocity_y``. """ - # Initialize acceleration arrays - ax, ay, az = [[0, 0]], [[0, 0]], [[0, 0]] - alpha1, alpha2, alpha3 = [[0, 0]], [[0, 0]], [[0, 0]] - # Go through each time step and calculate accelerations + # Go through each time step and calculate forces and atmospheric values # Get flight phases for phase_index, phase in self.time_iterator(self.FlightPhases): init_time = phase.t @@ -2857,23 +2944,60 @@ def retrieve_acceleration_arrays(self): # Call callback functions for callback in phase.callbacks: callback(self) - # Loop through time steps in flight phase - for step in self.solution: # Can be optimized - if init_time < step[0] <= final_time: - # Get derivatives - u_dot = current_derivative(step[0], step[1:]) - # Get accelerations - ax_value, ay_value, az_value = u_dot[3:6] - alpha1_value, alpha2_value, alpha3_value = u_dot[10:] - # Save accelerations - ax.append([step[0], ax_value]) - ay.append([step[0], ay_value]) - az.append([step[0], az_value]) - alpha1.append([step[0], alpha1_value]) - alpha2.append([step[0], alpha2_value]) - alpha3.append([step[0], alpha3_value]) - - return ax, ay, az, alpha1, alpha2, alpha3 + # find index of initial and final time of phase in solution array + init_time_index = find_closest(self.time, init_time) + final_time_index = find_closest(self.time, final_time) + 1 + # Loop through time steps solution array + for step in self.solution[init_time_index:final_time_index]: + if init_time != step[0] or ( + init_time == self.t_initial and step[0] == self.t_initial + ): + # Call derivatives in post processing mode + current_derivative(step[0], step[1:], post_processing=True) + + temp_values = [ + self.ax_list, + self.ay_list, + self.az_list, + self.alpha1_list, + self.alpha2_list, + self.alpha3_list, + self.R1_list, + self.R2_list, + self.R3_list, + self.M1_list, + self.M2_list, + self.M3_list, + self.pressure_list, + self.density_list, + self.dynamic_viscosity_list, + self.speed_of_sound_list, + self.wind_velocity_x_list, + self.wind_velocity_y_list, + ] + + return temp_values + + @cached_property + def retrieve_acceleration_arrays(self): + """Retrieve acceleration arrays from the integration scheme + + Returns + ------- + ax_list: list + acceleration in x direction + ay_list: list + acceleration in y direction + az_list: list + acceleration in z direction + alpha1_list: list + angular acceleration in x direction + alpha2_list: list + angular acceleration in y direction + alpha3_list: list + angular acceleration in z direction + """ + return self.__retrieve_arrays[:6] @cached_property def retrieve_temporary_values_arrays(self): @@ -2910,54 +3034,7 @@ def retrieve_temporary_values_arrays(self): self.wind_velocity_y_list: list Wind velocity in y direction at each time step. """ - - # Initialize force and atmospheric arrays - self.R1_list = [] - self.R2_list = [] - self.R3_list = [] - self.M1_list = [] - self.M2_list = [] - self.M3_list = [] - self.pressure_list = [] - self.density_list = [] - self.dynamic_viscosity_list = [] - self.speed_of_sound_list = [] - self.wind_velocity_x_list = [] - self.wind_velocity_y_list = [] - - # Go through each time step and calculate forces and atmospheric values - # Get flight phases - for phase_index, phase in self.time_iterator(self.FlightPhases): - init_time = phase.t - final_time = self.FlightPhases[phase_index + 1].t - current_derivative = phase.derivative - # Call callback functions - for callback in phase.callbacks: - callback(self) - # Loop through time steps in flight phase - for step in self.solution: # Can be optimized - if init_time < step[0] <= final_time or ( - init_time == self.t_initial and step[0] == self.t_initial - ): - # Call derivatives in post processing mode - u_dot = current_derivative(step[0], step[1:], post_processing=True) - - temporary_values = [ - self.R1_list, - self.R2_list, - self.R3_list, - self.M1_list, - self.M2_list, - self.M3_list, - self.pressure_list, - self.density_list, - self.dynamic_viscosity_list, - self.speed_of_sound_list, - self.wind_velocity_x_list, - self.wind_velocity_y_list, - ] - - return temporary_values + return self.__retrieve_arrays[6:] def get_controller_observed_variables(self): """Retrieve the observed variables related to air brakes from the diff --git a/rocketpy/tools.py b/rocketpy/tools.py index 5666fdbdf..edea8aada 100644 --- a/rocketpy/tools.py +++ b/rocketpy/tools.py @@ -1,6 +1,8 @@ +import functools import importlib import importlib.metadata import re +import time from bisect import bisect_left import numpy as np @@ -8,36 +10,10 @@ from cftime import num2pydate from packaging import version as packaging_version -_NOT_FOUND = object() - # Mapping of module name and the name of the package that should be installed INSTALL_MAPPING = {"IPython": "ipython"} -class cached_property: - def __init__(self, func): - self.func = func - self.attrname = None - self.__doc__ = func.__doc__ - - def __set_name__(self, owner, name): - self.attrname = name - - def __get__(self, instance, owner=None): - if instance is None: - return self - if self.attrname is None: - raise TypeError( - "Cannot use cached_property instance without calling __set_name__ on it." - ) - cache = instance.__dict__ - val = cache.get(self.attrname, _NOT_FOUND) - if val is _NOT_FOUND: - val = self.func(instance) - cache[self.attrname] = val - return val - - def tuple_handler(value): """Transforms the input value into a tuple that represents a range. If the input is an int or float, @@ -153,7 +129,7 @@ def time_num_to_date_string(time_num, units, timezone, calendar="gregorian"): """Convert time number (usually hours before a certain date) into two strings: one for the date (example: 2022.04.31) and one for the hour (example: 14). See cftime.num2date for details on units and calendar. - Automatically converts time number from UTC to local timezone based on + Automatically converts time number from UTC to local time zone based on lat, lon coordinates. This function was created originally for the EnvironmentAnalysis class. @@ -382,6 +358,25 @@ def check_requirement_version(module_name, version): return True +def exponential_backoff(max_attempts, base_delay=1, max_delay=60): + def decorator(func): + @functools.wraps(func) + def wrapper(*args, **kwargs): + delay = base_delay + for i in range(max_attempts): + try: + return func(*args, **kwargs) + except Exception as e: + if i == max_attempts - 1: + raise e from None + delay = min(delay * 2, max_delay) + time.sleep(delay) + + return wrapper + + return decorator + + def parallel_axis_theorem_from_com(com_inertia_moment, mass, distance): """Calculates the moment of inertia of a object relative to a new axis using the parallel axis theorem. The new axis is parallel to and at a distance diff --git a/tests/fixtures/environment/environment_fixtures.py b/tests/fixtures/environment/environment_fixtures.py index 8949f9973..851be3203 100644 --- a/tests/fixtures/environment/environment_fixtures.py +++ b/tests/fixtures/environment/environment_fixtures.py @@ -1,6 +1,7 @@ from datetime import datetime, timedelta import pytest + from rocketpy import Environment, EnvironmentAnalysis @@ -54,8 +55,8 @@ def env_analysis(): EnvironmentAnalysis """ env_analysis = EnvironmentAnalysis( - start_date=datetime.datetime(2019, 10, 23), - end_date=datetime.datetime(2021, 10, 23), + start_date=datetime(2019, 10, 23), + end_date=datetime(2021, 10, 23), latitude=39.3897, longitude=-8.28896388889, start_hour=6, diff --git a/tests/test_environment.py b/tests/test_environment.py index 5fa0e2c45..7349d512b 100644 --- a/tests/test_environment.py +++ b/tests/test_environment.py @@ -1,5 +1,4 @@ import datetime -import time from unittest.mock import patch import pytest @@ -64,13 +63,8 @@ def test_wyoming_sounding_atmosphere(mock_show, example_plain_env): # "file" option, instead of receiving the URL as a string. URL = "http://weather.uwyo.edu/cgi-bin/sounding?region=samer&TYPE=TEXT%3ALIST&YEAR=2019&MONTH=02&FROM=0500&TO=0512&STNM=83779" # give it at least 5 times to try to download the file - for i in range(5): - try: - example_plain_env.set_atmospheric_model(type="wyoming_sounding", file=URL) - break - except: - time.sleep(1) # wait 1 second before trying again - pass + example_plain_env.set_atmospheric_model(type="wyoming_sounding", file=URL) + assert example_plain_env.all_info() == None assert abs(example_plain_env.pressure(0) - 93600.0) < 1e-8 assert ( diff --git a/tests/test_flight.py b/tests/test_flight.py index db882e185..4fb4036eb 100644 --- a/tests/test_flight.py +++ b/tests/test_flight.py @@ -604,12 +604,12 @@ def test_max_values(flight_calisto_robust): calculated by hand, it was just copied from the test results. This is because the expected values are not easy to calculate by hand, and the results are not expected to change. If the results change, the test will - fail, and the expected values must be updated. If if want to update the - values, always double check if the results are really correct. Acceptable - reasons for changes in the results are: 1) changes in the code that - improve the accuracy of the simulation, 2) a bug was found and fixed. Keep - in mind that other tests may be more accurate than this one, for example, - the acceptance tests, which are based on the results of real flights. + fail, and the expected values must be updated. If the values are updated, + always double check if the results are really correct. Acceptable reasons + for changes in the results are: 1) changes in the code that improve the + accuracy of the simulation, 2) a bug was found and fixed. Keep in mind that + other tests may be more accurate than this one, for example, the acceptance + tests, which are based on the results of real flights. Parameters ---------- @@ -622,7 +622,7 @@ def test_max_values(flight_calisto_robust): assert pytest.approx(105.2774, abs=atol) == test.max_acceleration_power_on assert pytest.approx(105.2774, abs=atol) == test.max_acceleration assert pytest.approx(0.85999, abs=atol) == test.max_mach_number - assert pytest.approx(285.90240, abs=atol) == test.max_speed + assert pytest.approx(285.94948, abs=atol) == test.max_speed def test_rail_buttons_forces(flight_calisto_custom_wind): diff --git a/tests/unit/test_environment.py b/tests/unit/test_environment.py index ac25533eb..8d676f426 100644 --- a/tests/unit/test_environment.py +++ b/tests/unit/test_environment.py @@ -1,10 +1,10 @@ +import json import os import numpy as np import numpy.ma as ma import pytest import pytz -import json from rocketpy import Environment From 9a6b052a3bab349e0359157cdb870f43215611a0 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 30 Apr 2024 14:32:11 +0200 Subject: [PATCH 23/77] MNT: fix component repr for sensors --- rocketpy/rocket/components.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rocketpy/rocket/components.py b/rocketpy/rocket/components.py index 4a033507c..f97d54cab 100644 --- a/rocketpy/rocket/components.py +++ b/rocketpy/rocket/components.py @@ -32,7 +32,7 @@ def __repr__(self): """Return a string representation of the Components instance.""" components_str = "\n".join( [ - f"\tComponent: {str(c.component):80} Position: {c.position:>6.3f}" + f"\tComponent: {str(c.component):80} Position: {c.position}" for c in self._components ] ) From 7953cb08eea37565528f8c8f7a625457074e0861 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 30 Apr 2024 15:40:44 +0200 Subject: [PATCH 24/77] ENH: add _attatched_rockets to sensors --- rocketpy/rocket/rocket.py | 4 ++++ rocketpy/sensors/sensors.py | 3 +++ 2 files changed, 7 insertions(+) diff --git a/rocketpy/rocket/rocket.py b/rocketpy/rocket/rocket.py index 45fce0cd5..073c9c60a 100644 --- a/rocketpy/rocket/rocket.py +++ b/rocketpy/rocket/rocket.py @@ -1192,6 +1192,10 @@ def add_sensor(self, sensor, position, x_position=0, y_position=0): None """ self.sensors.add(sensor, Vector([x_position, y_position, position])) + try: + sensor._attached_rockets[self] += 1 + except: + sensor._attached_rockets[self] = 1 def add_air_brakes( self, diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index fadb9ae73..1cc624f52 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -197,6 +197,9 @@ def __init__( # compute total rotation matrix given cross axis sensitivity self._total_rotation_matrix = self.rotation_matrix @ _cross_axis_matrix + # map which rocket(s) the sensor is attached to and how many times + self._attached_rockets = {} + def _vectorize_input(self, value, name): if isinstance(value, (int, float)): return Vector([value, value, value]) From 5a375532abfb063477d968df26a273136d91a74a Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 30 Apr 2024 15:42:34 +0200 Subject: [PATCH 25/77] ENH: add sensors saving methods --- rocketpy/sensors/sensors.py | 29 ++++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index 1cc624f52..d7ebed8d2 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -158,7 +158,8 @@ def __init__( self.name = name self._random_walk_drift = Vector([0, 0, 0]) self.measurement = None - self.measured_data = [] # change to data + self.measured_data = [] + self._counter = 0 # handle measurement range if isinstance(measurement_range, (tuple, list)): @@ -208,6 +209,32 @@ def _vectorize_input(self, value, name): else: raise ValueError(f"Invalid {name} format") + def _reset(self, simulated_rocket): + """Reset the sensor data for a new simulation.""" + self._random_walk_drift = Vector([0, 0, 0]) + self.measured_data = [] + if self._attached_rockets[simulated_rocket] > 1: + self.measured_data = [ + [] for _ in range(self._attached_rockets[simulated_rocket]) + ] + self._save_data = self._save_data_multiple + else: + self._save_data = self._save_data_single + + def _save_data_single(self, data, index=0): + """Save the measured data to the sensor data list for a sensor that is + added only once to the simulated rocket.""" + self.measured_data.append(data) + + def _save_data_multiple(self, data): + """Save the measured data to the sensor data list for a sensor that is + added multiple times to the simulated rocket.""" + self.measured_data[self._counter].append(data) + # counter for cases where the sensor is added multiple times in a rocket + self._counter += 1 + if self._counter == len(self.measured_data): + self._counter = 0 + def __repr__(self): return f"{self.type} sensor, orientation: {self.orientation}" From 09ea25202fc0fac43ca2cecba0760f94e1d10e0e Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 30 Apr 2024 15:42:52 +0200 Subject: [PATCH 26/77] MNT: simplify sensors repr --- rocketpy/sensors/sensors.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index d7ebed8d2..8ecf20c2c 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -236,7 +236,7 @@ def _save_data_multiple(self, data): self._counter = 0 def __repr__(self): - return f"{self.type} sensor, orientation: {self.orientation}" + return f"{self.name}" def __call__(self, *args, **kwargs): return self.measure(*args, **kwargs) From 9851392d69b833c08fa19988cc9711a350af0cc3 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 30 Apr 2024 15:44:23 +0200 Subject: [PATCH 27/77] ENH: use _save_data in accel and gyro --- rocketpy/sensors/accelerometer.py | 2 +- rocketpy/sensors/gyroscope.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 38e423439..96cadffce 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -215,7 +215,7 @@ def measure(self, t, u, u_dot, relative_position, gravity, *args): A = self.quantize(A) self.measurement = tuple([*A]) - self.measured_data.append((t, *A)) + self._save_data((t, *A)) def export_measured_data(self, filename, format="csv"): """ diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index 21053edbe..d7c34088d 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -207,7 +207,7 @@ def measure(self, t, u, u_dot, relative_position, *args): W = self.quantize(W) self.measurement = tuple([*W]) - self.measured_data.append((t, *W)) + self._save_data((t, *W)) def apply_acceleration_sensitivity( self, omega, u_dot, relative_position, rotation_matrix From 0f81bc31951267800e34d5603a9c95e11923f462 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 30 Apr 2024 15:44:49 +0200 Subject: [PATCH 28/77] ENH: improve accelerometer export --- rocketpy/sensors/accelerometer.py | 52 ++++++++++++++++++++++--------- 1 file changed, 38 insertions(+), 14 deletions(-) diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 96cadffce..0028b9aa1 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -1,4 +1,5 @@ import numpy as np +import json from ..mathutils.vector_matrix import Matrix, Vector from ..prints.sensors_prints import _AccelerometerPrints @@ -234,20 +235,43 @@ def export_measured_data(self, filename, format="csv"): None """ if format == "csv": - with open(filename, "w") as f: - f.write("t,ax,ay,az\n") - for t, ax, ay, az in self.measured_data: - f.write(f"{t},{ax},{ay},{az}\n") + # if sensor has been added multiple times to the simulated rocket + if isinstance(self.measured_data[0], list): + print("Data saved to", end=" ") + for i, data in enumerate(self.measured_data): + with open(filename + f"_{i+1}", "w") as f: + f.write("t,ax,ay,az\n") + for t, ax, ay, az in data: + f.write(f"{t},{ax},{ay},{az}\n") + print(filename + f"_{i+1},", end=" ") + else: + with open(filename, "w") as f: + f.write("t,ax,ay,az\n") + for t, ax, ay, az in self.measured_data: + f.write(f"{t},{ax},{ay},{az}\n") + print(f"Data saved to {filename}") elif format == "json": - import json - - data = {"t": [], "ax": [], "ay": [], "az": []} - for t, ax, ay, az in self.measured_data: - data["t"].append(t) - data["ax"].append(ax) - data["ay"].append(ay) - data["az"].append(az) - with open(filename, "w") as f: - json.dump(data, f) + if isinstance(self.measured_data[0], list): + print("Data saved to", end=" ") + for i, data in enumerate(self.measured_data): + dict = {"t": [], "ax": [], "ay": [], "az": []} + for t, ax, ay, az in data: + dict["t"].append(t) + dict["ax"].append(ax) + dict["ay"].append(ay) + dict["az"].append(az) + with open(filename + f"_{i+1}", "w") as f: + json.dump(dict, f) + print(filename + f"_{i+1},", end=" ") + else: + dict = {"t": [], "ax": [], "ay": [], "az": []} + for t, ax, ay, az in self.measured_data: + dict["t"].append(t) + dict["ax"].append(ax) + dict["ay"].append(ay) + dict["az"].append(az) + with open(filename, "w") as f: + json.dump(dict, f) + print(f"Data saved to {filename}") else: raise ValueError("Invalid format") From a740fc2b4820efc7c02d8456a3849f468807dcbb Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 30 Apr 2024 15:45:03 +0200 Subject: [PATCH 29/77] ENH: imrpove gyroscope export --- rocketpy/sensors/gyroscope.py | 52 +++++++++++++++++++++++++---------- 1 file changed, 38 insertions(+), 14 deletions(-) diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index d7c34088d..5275ed600 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -1,4 +1,5 @@ import numpy as np +import json from ..mathutils.vector_matrix import Matrix, Vector from ..prints.sensors_prints import _GyroscopePrints @@ -265,20 +266,43 @@ def export_measured_data(self, filename, format="csv"): None """ if format == "csv": - with open(filename, "w") as f: - f.write("t,wx,wy,wz\n") - for t, wx, wy, wz in self.measured_data: - f.write(f"{t},{wx},{wy},{wz}\n") + # if sensor has been added multiple times to the simulated rocket + if isinstance(self.measured_data[0], list): + print("Data saved to", end=" ") + for i, data in enumerate(self.measured_data): + with open(filename + f"_{i+1}", "w") as f: + f.write("t,wx,wy,wz\n") + for t, wx, wy, wz in data: + f.write(f"{t},{wx},{wy},{wz}\n") + print(filename + f"_{i+1},", end=" ") + else: + with open(filename, "w") as f: + f.write("t,wx,wy,wz\n") + for t, wx, wy, wz in self.measured_data: + f.write(f"{t},{wx},{wy},{wz}\n") + print(f"Data saved to {filename}") elif format == "json": - import json - - data = {"t": [], "wx": [], "wy": [], "wz": []} - for t, wx, wy, wz in self.measured_data: - data["t"].append(t) - data["wx"].append(wx) - data["wy"].append(wy) - data["wz"].append(wz) - with open(filename, "w") as f: - json.dump(data, f) + if isinstance(self.measured_data[0], list): + print("Data saved to", end=" ") + for i, data in enumerate(self.measured_data): + dict = {"t": [], "wx": [], "wy": [], "wz": []} + for t, wx, wy, wz in data: + dict["t"].append(t) + dict["wx"].append(wx) + dict["wy"].append(wy) + dict["wz"].append(wz) + with open(filename + f"_{i+1}", "w") as f: + json.dump(dict, f) + print(filename + f"_{i+1},", end=" ") + else: + dict = {"t": [], "wx": [], "wy": [], "wz": []} + for t, wx, wy, wz in self.measured_data: + dict["t"].append(t) + dict["wx"].append(wx) + dict["wy"].append(wy) + dict["wz"].append(wz) + with open(filename, "w") as f: + json.dump(dict, f) + print(f"Data saved to {filename}") else: raise ValueError("Invalid format") From cf6c26d772de0137c2c1ba0b9f45a259f94564d8 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 30 Apr 2024 15:48:03 +0200 Subject: [PATCH 30/77] ENH: add sensor initialization --- rocketpy/simulation/flight.py | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/rocketpy/simulation/flight.py b/rocketpy/simulation/flight.py index 8aa3f4cd6..928bf63d4 100644 --- a/rocketpy/simulation/flight.py +++ b/rocketpy/simulation/flight.py @@ -595,9 +595,6 @@ def __init__( if self.rail_length <= 0: raise ValueError("Rail length must be a positive value.") self.parachutes = self.rocket.parachutes[:] - self._controllers = self.rocket._controllers[:] - self._component_sensors = self.rocket.sensors - self._sensors_list = self.rocket.sensors.get_components() self.inclination = inclination self.heading = heading self.max_time = max_time @@ -676,7 +673,7 @@ def __init__( self.parachutes, phase.t, phase.time_bound ) phase.TimeNodes.add_sensors( - self._component_sensors, phase.t, phase.time_bound + self.rocket.sensors, phase.t, phase.time_bound ) phase.TimeNodes.add_controllers( self._controllers, phase.t, phase.time_bound @@ -1060,7 +1057,7 @@ def __init__( pressure + noise, hAGL, overshootable_node.y, - self._sensors_list, + self.sensors, ): # print('\nEVENT DETECTED') # print('Parachute Triggered') @@ -1246,18 +1243,25 @@ def __init_equations_of_motion(self): self.u_dot_generalized = self.u_dot def __init_controllers(self): - """Initialize controllers""" + """Initialize controllers and sensors""" self._controllers = self.rocket._controllers[:] - if self._controllers: + if self._controllers or self.sensors: if self.time_overshoot == True: self.time_overshoot = False warnings.warn( - "time_overshoot has been set to False due to the presence of controllers. " + "time_overshoot has been set to False due to the presence " + "of controllers or sensors. " ) # reset controllable object to initial state (only airbrakes for now) for air_brakes in self.rocket.air_brakes: air_brakes._reset() + self.sensors = self.rocket.sensors.get_components() + self.sensor_data = {} + for sensor in self.sensors: + sensor._reset(self.rocket) # resets noise and measurement list + self.sensor_data[sensor] = [] + def __cache_post_process_variables(self): """Cache post-process variables for simulations with controllers.""" self.__retrieve_arrays = [ From 2a14f1de247659b3a51a3cf4fd3e142c64873692 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 30 Apr 2024 15:48:55 +0200 Subject: [PATCH 31/77] ENH: speed up measure call --- rocketpy/simulation/flight.py | 33 ++++++++++++++++----------------- 1 file changed, 16 insertions(+), 17 deletions(-) diff --git a/rocketpy/simulation/flight.py b/rocketpy/simulation/flight.py index 928bf63d4..46de2dbc7 100644 --- a/rocketpy/simulation/flight.py +++ b/rocketpy/simulation/flight.py @@ -57,8 +57,6 @@ class Flight: Name of the flight. Flight._controllers : list List of controllers to be used during simulation. - Flight._component_sensors : list - List of sensors to be used during simulation. Flight.max_time : int, float Maximum simulation time allowed. Refers to physical time being simulated, not time taken to run simulation. @@ -709,26 +707,27 @@ def __init__( for callback in node.callbacks: callback(self) - # calculate u_dot for sensors - u_dot = phase.derivative(self.t, self.y_sol) - for sensor, position in node._component_sensors: - relative_position = position - self.rocket._csys * Vector( - [0, 0, self.rocket.center_of_dry_mass_position] - ) - sensor.measure( - self.t, - self.y_sol, - u_dot, - relative_position, - self.env.gravity(self.solution[-1][3]), - ) + if self.sensors: + # u_dot for all sensors + u_dot = phase.derivative(self.t, self.y_sol) + for sensor, position in node._component_sensors: + relative_position = position - self.rocket._csys * Vector( + [0, 0, self.rocket.center_of_dry_mass_position] + ) + sensor.measure( + self.t, + self.y_sol, + u_dot, + relative_position, + self.env.gravity(self.solution[-1][3]), + ) for controller in node._controllers: controller( self.t, self.y_sol, self.solution, - self._sensors_list, + self.sensors, ) for parachute in node.parachutes: @@ -745,7 +744,7 @@ def __init__( - self.env.elevation ) if parachute.triggerfunc( - pressure + noise, hAGL, self.y_sol, self._sensors_list + pressure + noise, hAGL, self.y_sol, self.sensors ): # print('\nEVENT DETECTED') # print('Parachute Triggered') From 216523c1252a57a829435584152f276d62ca4fe6 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 30 Apr 2024 15:49:41 +0200 Subject: [PATCH 32/77] ENH: add final sensor cache --- rocketpy/simulation/flight.py | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/rocketpy/simulation/flight.py b/rocketpy/simulation/flight.py index 46de2dbc7..eb25283c1 100644 --- a/rocketpy/simulation/flight.py +++ b/rocketpy/simulation/flight.py @@ -1114,6 +1114,8 @@ def __init__( self._calculate_pressure_signal() if self._controllers: self.__cache_post_process_variables() + if self.sensors: + self.__cache_sensor_data() if verbose: print("Simulation Completed at Time: {:3.4f} s".format(self.t)) @@ -1284,6 +1286,25 @@ def __cache_post_process_variables(self): self.wind_velocity_y_list, ] + def __cache_sensor_data(self): + sensor_data = {} + sensors = [] + for sensor in self.sensors: + # skip sensors that are used more then once in the rocket + if sensor not in sensors: + sensors.append(sensor) + num_instances = sensor._attached_rockets[self.rocket] + # sensor added only once + if num_instances == 1: + sensor_data[sensor] = sensor.measured_data[:] + # sensor added more then once + if num_instances > 1: + sensor_data[sensor] = {} + # iterate through each of the same sensor instances + for index in range(num_instances): + sensor_data[sensor][index + 1] = sensor.measured_data[index][:] + self.sensor_data = sensor_data + @cached_property def effective_1rl(self): """Original rail length minus the distance measured from nozzle exit @@ -3796,6 +3817,6 @@ def __repr__(self): + " | Controllers: " + str(len(self._controllers)) + " | Sensors: " - + str(len(self._sensors_list)) + + str(len(self._component_sensors)) + "}" ) From 09288d4478685a39d17b18f20ecfed19c1d9a208 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 30 Apr 2024 15:49:53 +0200 Subject: [PATCH 33/77] ENH: add export sensor data --- rocketpy/simulation/flight.py | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/rocketpy/simulation/flight.py b/rocketpy/simulation/flight.py index eb25283c1..a1edc497f 100644 --- a/rocketpy/simulation/flight.py +++ b/rocketpy/simulation/flight.py @@ -1,3 +1,4 @@ +import json import math import warnings from copy import deepcopy @@ -3394,7 +3395,31 @@ class attributes which are instances of the Function class. Usage encoding="utf-8", ) - return + 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, optional + The sensor to export data. If None, all sensors data will be exported. + Default is None. + """ + if sensor is None: + data_dict = {} + for key, value in self.sensor_data.items(): + data_dict[key.name] = value + else: + # export data of only that sensor + data_dict = {} + data_dict[sensor.name] = self.sensor_data[sensor] + with open(file_name, "w") as file: + json.dump(data_dict, file) + print("Sensor data exported to", file_name) def export_kml( self, From aa6fcdf18553e22df8da8c7f9ab486ee5d77e627 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 30 Apr 2024 22:53:10 +0200 Subject: [PATCH 34/77] BUG: wrong initialization order --- rocketpy/sensors/sensors.py | 3 ++- rocketpy/simulation/flight.py | 4 ++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index 8ecf20c2c..a377bb7c9 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -160,6 +160,7 @@ def __init__( self.measurement = None self.measured_data = [] self._counter = 0 + self._save_data = self._save_data_single # handle measurement range if isinstance(measurement_range, (tuple, list)): @@ -221,7 +222,7 @@ def _reset(self, simulated_rocket): else: self._save_data = self._save_data_single - def _save_data_single(self, data, index=0): + def _save_data_single(self, data): """Save the measured data to the sensor data list for a sensor that is added only once to the simulated rocket.""" self.measured_data.append(data) diff --git a/rocketpy/simulation/flight.py b/rocketpy/simulation/flight.py index a1edc497f..6386157d3 100644 --- a/rocketpy/simulation/flight.py +++ b/rocketpy/simulation/flight.py @@ -1247,6 +1247,7 @@ def __init_equations_of_motion(self): def __init_controllers(self): """Initialize controllers and sensors""" self._controllers = self.rocket._controllers[:] + self.sensors = self.rocket.sensors.get_components() if self._controllers or self.sensors: if self.time_overshoot == True: self.time_overshoot = False @@ -1258,7 +1259,6 @@ def __init_controllers(self): for air_brakes in self.rocket.air_brakes: air_brakes._reset() - self.sensors = self.rocket.sensors.get_components() self.sensor_data = {} for sensor in self.sensors: sensor._reset(self.rocket) # resets noise and measurement list @@ -3418,7 +3418,7 @@ def export_sensor_data(self, file_name, sensor=None): data_dict = {} data_dict[sensor.name] = self.sensor_data[sensor] with open(file_name, "w") as file: - json.dump(data_dict, file) + json.dump(data_dict, file) print("Sensor data exported to", file_name) def export_kml( From bf6b083270940454f3caa23b284616b49ed1f773 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 30 Apr 2024 23:19:28 +0200 Subject: [PATCH 35/77] TST: test for new measured_data and exports --- tests/fixtures/rockets/rocket_fixtures.py | 2 + tests/test_sensors.py | 56 ++++++++++++++++++-- tests/unit/test_sensors.py | 64 +++++++++++++++++++++++ 3 files changed, 118 insertions(+), 4 deletions(-) diff --git a/tests/fixtures/rockets/rocket_fixtures.py b/tests/fixtures/rockets/rocket_fixtures.py index e6231209a..0161f3950 100644 --- a/tests/fixtures/rockets/rocket_fixtures.py +++ b/tests/fixtures/rockets/rocket_fixtures.py @@ -274,6 +274,8 @@ def calisto_accel_gyro( calisto.add_surfaces(calisto_nose_cone, 1.160) calisto.add_surfaces(calisto_tail, -1.313) calisto.add_surfaces(calisto_trapezoidal_fins, -1.168) + # double sensors to test using same instance twice + calisto.add_sensor(ideal_accelerometer, -0.1180124376577797) calisto.add_sensor(ideal_accelerometer, -0.1180124376577797) calisto.add_sensor(ideal_gyroscope, -0.1180124376577797) return calisto diff --git a/tests/test_sensors.py b/tests/test_sensors.py index b94d2bc7f..92960732e 100644 --- a/tests/test_sensors.py +++ b/tests/test_sensors.py @@ -1,3 +1,5 @@ +import json +import os import numpy as np from rocketpy.mathutils.vector_matrix import Vector @@ -18,8 +20,8 @@ def test_sensor_on_rocket(calisto_accel_gyro): assert isinstance(sensors, Components) assert isinstance(sensors[0].component, Accelerometer) assert isinstance(sensors[1].position, Vector) - assert isinstance(sensors[1].component, Gyroscope) - assert isinstance(sensors[1].position, Vector) + assert isinstance(sensors[2].component, Gyroscope) + assert isinstance(sensors[2].position, Vector) def test_ideal_sensors(flight_calisto_accel_gyro): @@ -32,7 +34,7 @@ def test_ideal_sensors(flight_calisto_accel_gyro): Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. """ accelerometer = flight_calisto_accel_gyro.rocket.sensors[0].component - time, ax, ay, az = zip(*accelerometer.measured_data) + time, ax, ay, az = zip(*accelerometer.measured_data[0]) ax = np.array(ax) ay = np.array(ay) az = np.array(az) @@ -41,8 +43,13 @@ def test_ideal_sensors(flight_calisto_accel_gyro): # tolerance is bounded to numerical errors in the transformation matrixes assert np.allclose(a, sim_accel, atol=1e-12) + # check if both added accelerometer instances saved the same data + assert ( + flight_calisto_accel_gyro.sensors[0].measured_data[0] + == flight_calisto_accel_gyro.sensors[0].measured_data[1] + ) - gyroscope = flight_calisto_accel_gyro.rocket.sensors[1].component + gyroscope = flight_calisto_accel_gyro.rocket.sensors[2].component time, wx, wy, wz = zip(*gyroscope.measured_data) wx = np.array(wx) wy = np.array(wy) @@ -53,3 +60,44 @@ def test_ideal_sensors(flight_calisto_accel_gyro): flight_wz = np.array(flight_calisto_accel_gyro.w3(time)) sim_w = np.sqrt(flight_wx**2 + flight_wy**2 + flight_wz**2) assert np.allclose(w, sim_w, atol=1e-12) + + +def test_export_sensor_data(flight_calisto_accel_gyro): + """Test the export of sensor data. + + Parameters + ---------- + flight_calisto_accel_gyro : Flight + Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. + """ + flight_calisto_accel_gyro.export_sensor_data("test_sensor_data.json") + # read the json and parse as dict + filename = "test_sensor_data.json" + with open(filename, "r") as f: + data = f.read() + sensor_data = json.loads(data) + # convert list of tuples into list of lists to compare with the json + flight_calisto_accel_gyro.sensors[0].measured_data[0] = [ + list(measurement) + for measurement in flight_calisto_accel_gyro.sensors[0].measured_data[0] + ] + flight_calisto_accel_gyro.sensors[1].measured_data[1] = [ + list(measurement) + for measurement in flight_calisto_accel_gyro.sensors[1].measured_data[1] + ] + flight_calisto_accel_gyro.sensors[2].measured_data = [ + list(measurement) + for measurement in flight_calisto_accel_gyro.sensors[2].measured_data + ] + assert ( + sensor_data["Accelerometer"]["1"] + == flight_calisto_accel_gyro.sensors[0].measured_data[0] + ) + assert ( + sensor_data["Accelerometer"]["2"] + == flight_calisto_accel_gyro.sensors[1].measured_data[1] + ) + assert ( + sensor_data["Gyroscope"] == flight_calisto_accel_gyro.sensors[2].measured_data + ) + os.remove(filename) diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensors.py index 81448c2a4..ebb0c5b60 100644 --- a/tests/unit/test_sensors.py +++ b/tests/unit/test_sensors.py @@ -300,7 +300,24 @@ def test_export_accel_data_csv(ideal_accelerometer): expected_data += f"{t},{ax},{ay},{az}\n" assert contents == expected_data + + # check exports for accelerometers added more than once to the rocket + ideal_accelerometer.measured_data = [ + ideal_accelerometer.measured_data[:], + ideal_accelerometer.measured_data[:], + ] + ideal_accelerometer.export_measured_data(file_name, format="csv") + with open(file_name + "_1", "r") as file: + contents = file.read() + assert contents == expected_data + + with open(file_name + "_2", "r") as file: + contents = file.read() + assert contents == expected_data + os.remove(file_name) + os.remove(file_name + "_1") + os.remove(file_name + "_2") def test_export_accel_data_json(ideal_accelerometer): @@ -334,7 +351,22 @@ def test_export_accel_data_json(ideal_accelerometer): expected_data["az"].append(az) assert contents == expected_data + + # check exports for accelerometers added more than once to the rocket + ideal_accelerometer.measured_data = [ + ideal_accelerometer.measured_data[:], + ideal_accelerometer.measured_data[:], + ] + ideal_accelerometer.export_measured_data(file_name, format="json") + contents = json.load(open(file_name + "_1", "r")) + assert contents == expected_data + + contents = json.load(open(file_name + "_2", "r")) + assert contents == expected_data + os.remove(file_name) + os.remove(file_name + "_1") + os.remove(file_name + "_2") def test_export_gyro_data_csv(ideal_gyroscope): @@ -365,7 +397,24 @@ def test_export_gyro_data_csv(ideal_gyroscope): expected_data += f"{t},{wx},{wy},{wz}\n" assert contents == expected_data + + # check exports for gyroscopes added more than once to the rocket + ideal_gyroscope.measured_data = [ + ideal_gyroscope.measured_data[:], + ideal_gyroscope.measured_data[:], + ] + ideal_gyroscope.export_measured_data(file_name, format="csv") + with open(file_name + "_1", "r") as file: + contents = file.read() + assert contents == expected_data + + with open(file_name + "_2", "r") as file: + contents = file.read() + assert contents == expected_data + os.remove(file_name) + os.remove(file_name + "_1") + os.remove(file_name + "_2") def test_export_gyro_data_json(ideal_gyroscope): @@ -397,4 +446,19 @@ def test_export_gyro_data_json(ideal_gyroscope): expected_data["wz"].append(wz) assert contents == expected_data + + # check exports for gyroscopes added more than once to the rocket + ideal_gyroscope.measured_data = [ + ideal_gyroscope.measured_data[:], + ideal_gyroscope.measured_data[:], + ] + ideal_gyroscope.export_measured_data(file_name, format="json") + contents = json.load(open(file_name + "_1", "r")) + assert contents == expected_data + + contents = json.load(open(file_name + "_2", "r")) + assert contents == expected_data + os.remove(file_name) + os.remove(file_name + "_1") + os.remove(file_name + "_2") From 5f8622300a77af3b2927526b66ed5798d7b745c8 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Tue, 30 Apr 2024 23:30:59 +0200 Subject: [PATCH 36/77] ENH: abstract noise printings --- rocketpy/prints/sensors_prints.py | 22 +++++++++++++++++----- 1 file changed, 17 insertions(+), 5 deletions(-) diff --git a/rocketpy/prints/sensors_prints.py b/rocketpy/prints/sensors_prints.py index 8c073190f..554d817e0 100644 --- a/rocketpy/prints/sensors_prints.py +++ b/rocketpy/prints/sensors_prints.py @@ -44,7 +44,12 @@ def quantization(self): ) self._print_aligned("Resolution:", f"{self.sensor.resolution} {self.units}/LSB") + @abstractmethod def noise(self): + """Prints the noise of the sensor.""" + pass + + def _general_noise(self): """Prints the noise of the sensor.""" print("\nNoise of the Sensor:\n") self._print_aligned( @@ -68,11 +73,6 @@ def noise(self): self._print_aligned( "Cross Axis Sensitivity:", f"{self.sensor.cross_axis_sensitivity} %" ) - if self.sensor.type == "Gyroscope": - self._print_aligned( - "Acceleration Sensitivity:", - f"{self.sensor.acceleration_sensitivity} rad/s/g", - ) def all(self): """Prints all information of the sensor.""" @@ -89,6 +89,10 @@ def __init__(self, accelerometer): """Initialize the class.""" super().__init__(accelerometer) + def noise(self): + """Prints the noise of the sensor.""" + self._general_noise() + class _GyroscopePrints(_SensorsPrints): """Class that contains all gyroscope prints.""" @@ -96,3 +100,11 @@ class _GyroscopePrints(_SensorsPrints): def __init__(self, gyroscope): """Initialize the class.""" super().__init__(gyroscope) + + def noise(self): + """Prints the noise of the sensor.""" + self._general_noise() + self._print_aligned( + "Acceleration Sensitivity:", + f"{self.sensor.acceleration_sensitivity} rad/s/g", + ) From 4dcc26bf792d36653da1d3dc29fb3558767227d6 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Wed, 1 May 2024 17:53:31 +0200 Subject: [PATCH 37/77] MNT: run isort --- rocketpy/sensors/accelerometer.py | 3 ++- rocketpy/sensors/gyroscope.py | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 0028b9aa1..e1b5f1c43 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -1,6 +1,7 @@ -import numpy as np import json +import numpy as np + from ..mathutils.vector_matrix import Matrix, Vector from ..prints.sensors_prints import _AccelerometerPrints from ..sensors.sensors import Sensors diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index 5275ed600..c18446032 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -1,6 +1,7 @@ -import numpy as np import json +import numpy as np + from ..mathutils.vector_matrix import Matrix, Vector from ..prints.sensors_prints import _GyroscopePrints from ..sensors.sensors import Sensors From 2131ee9cc28620dd0ee05a59bda3e6a5e7cdb267 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 2 May 2024 16:31:48 +0200 Subject: [PATCH 38/77] ENH: add noise variance --- rocketpy/sensors/accelerometer.py | 53 +++++++++++++----- rocketpy/sensors/gyroscope.py | 55 +++++++++++++------ rocketpy/sensors/sensors.py | 90 ++++++++++++++++++++++--------- 3 files changed, 145 insertions(+), 53 deletions(-) diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index e1b5f1c43..b5e447085 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -28,8 +28,12 @@ class Accelerometer(Sensors): The resolution of the sensor in m/s^2/LSB. noise_density : float, list The noise density of the sensor in m/s^2/√Hz. - random_walk : float, list - The random walk of the sensor in m/s^2/√Hz. + noise_variance : float, list + The variance of the noise of the sensor in (m/s^2)^2. + random_walk_density : float, list + The random walk density of the sensor in m/s^2/√Hz. + random_walk_variance : float, list + The variance of the random walk of the sensor in (m/s^2)^2. constant_bias : float, list The constant bias of the sensor in m/s^2. operating_temperature : float @@ -64,7 +68,9 @@ def __init__( measurement_range=np.inf, resolution=0, noise_density=0, - random_walk=0, + noise_variance=1, + random_walk_density=0, + random_walk_variance=1, constant_bias=0, operating_temperature=25, temperature_bias=0, @@ -108,18 +114,31 @@ def __init__( The resolution of the sensor in m/s^2/LSB. Default is 0, meaning no quantization is applied. noise_density : float, list, optional - The noise density of the sensor in m/s^2/√Hz. Sometimes called - "white noise drift", "angular random walk" for gyroscopes, "velocity - random walk" for the accelerometers or "(rate) noise density". If a - float or int is given, the same noise density is applied to all + The noise density of the sensor for a Gaussian white noise in m/s^2/√Hz. + Sometimes called "white noise drift", "angular random walk" for + gyroscopes, "velocity random walk" for accelerometers or + "(rate) noise density". Default is 0, meaning no noise is applied. + If a float or int is given, the same noise density is applied to all axes. The values of each axis can be set individually by passing a list of length 3. - random_walk : float, list, optional - The random walk of the sensor in m/s^2/√Hz. Sometimes called "bias - (in)stability" or "bias drift"". Default is 0, meaning no random - walk is applied. If a float or int is given, the same random walk is - applied to all axes. The values of each axis can be set individually - by passing a list of length 3. + noise_variance : float, list, optional + The noise variance of the sensor for a Gaussian white noise in (m/s^2)^2. + Default is 1, meaning the noise is normally distributed with a + standard deviation of 1 m/s^2. If a float or int is given, the same + variance is applied to all axes. The values of each axis can be set + individually by passing a list of length 3. + random_walk_density : float, list, optional + The random walk of the sensor for a Gaussian random walk in m/s^2/√Hz. + Sometimes called "bias (in)stability" or "bias drift"". Default is 0, + meaning no random walk is applied. If a float or int is given, the + same random walk is applied to all axes. The values of each axis can + be set individually by passing a list of length 3. + random_walk_variance : float, list, optional + The random walk variance of the sensor for a Gaussian random walk in + (m/s^2)^2. Default is 1, meaning the noise is normally distributed + with a standard deviation of 1 m/s^2. If a float or int is given, + the same variance is applied to all axes. The values of each axis + can be set individually by passing a list of length 3. constant_bias : float, list, optional The constant bias of the sensor in m/s^2. Default is 0, meaning no constant bias is applied. If a float or int is given, the same bias @@ -151,6 +170,10 @@ def __init__( Returns ------- None + + See Also + -------- + TODO link to documentation on noise model """ super().__init__( sampling_rate, @@ -158,7 +181,9 @@ def __init__( measurement_range=measurement_range, resolution=resolution, noise_density=noise_density, - random_walk=random_walk, + noise_variance=noise_variance, + random_walk_density=random_walk_density, + random_walk_variance=random_walk_variance, constant_bias=constant_bias, operating_temperature=operating_temperature, temperature_bias=temperature_bias, diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index c18446032..6ba2b945d 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -28,8 +28,12 @@ class Gyroscope(Sensors): The resolution of the sensor in rad/s/LSB. noise_density : float, list The noise density of the sensor in rad/s/√Hz. - random_walk : float, list - The random walk of the sensor in rad/s/√Hz. + noise_variance : float, list + The variance of the noise of the sensor in (rad/s)^2. + random_walk_density : float, list + The random walk density of the sensor in rad/s/√Hz. + random_walk_variance : float, list + The random walk variance of the sensor in (rad/s)^2. constant_bias : float, list The constant bias of the sensor in rad/s. operating_temperature : float @@ -64,7 +68,9 @@ def __init__( measurement_range=np.inf, resolution=0, noise_density=0, - random_walk=0, + noise_variance=1, + random_walk_density=0, + random_walk_variance=1, constant_bias=0, operating_temperature=25, temperature_bias=0, @@ -106,18 +112,31 @@ def __init__( The resolution of the sensor in rad/s/LSB. Default is 0, meaning no quantization is applied. noise_density : float, list, optional - The noise density of the sensor in rad/s/√Hz. Sometimes called - "white noise drift", "angular random walk" for gyroscopes, "velocity - random walk" for the accelerometers or "(rate) noise density". - Default is 0, meaning no noise is applied. If a float or int is - given, the same noise density is applied to all axes. The values of + The noise density of the sensor for a Gaussian white noise in rad/s/√Hz. + Sometimes called "white noise drift", "angular random walk" for + gyroscopes, "velocity random walk" for the accelerometers or + "(rate) noise density". Default is 0, meaning no noise is applied. + If a float or int is given, the same noise density is applied to all + axes. The values of each axis can be set individually by passing a + list of length 3. + noise_variance : float, list, optional + The noise variance of the sensor for a Gaussian white noise in (rad/s)^2. + Default is 1, meaning the noise is normally distributed with a + standard deviation of 1 rad/s. If a float or int is given, the same + variance is applied to all axes. The values of each axis can be set + individually by passing a list of length 3. + random_walk_density : float, list, optional + The random walk density of the sensor for a Gaussian random walk in + rad/s/√Hz. Sometimes called "bias (in)stability" or "bias drift"". + Default is 0, meaning no random walk is applied. If a float or int + is given, the same random walk is applied to all axes. The values of + each axis can be set individually by passing a list of length 3. + random_walk_variance : float, list, optional + The random walk variance of the sensor for a Gaussian random walk in + (rad/s)^2. Default is 1, meaning the random walk is normally + distributed with a standard deviation of 1 rad/s. If a float or int + is given, the same variance is applied to all axes. The values of each axis can be set individually by passing a list of length 3. - random_walk : float, list, optional - The random walk of the sensor in rad/s/√Hz. Sometimes called "bias - (in)stability" or "bias drift"". Default is 0, meaning no random - walk is applied. If a float or int is given, the same random walk is - applied to all axes. The values of each axis can be set individually - by passing a list of length 3. constant_bias : float, list, optional The constant bias of the sensor in rad/s. Default is 0, meaning no constant bias is applied. If a float or int is given, the same bias @@ -151,6 +170,10 @@ def __init__( Returns ------- None + + See Also + -------- + TODO link to documentation on noise model """ super().__init__( sampling_rate, @@ -158,7 +181,9 @@ def __init__( measurement_range=measurement_range, resolution=resolution, noise_density=noise_density, - random_walk=random_walk, + noise_variance=noise_variance, + random_walk_density=random_walk_density, + random_walk_variance=random_walk_variance, constant_bias=constant_bias, operating_temperature=operating_temperature, temperature_bias=temperature_bias, diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index a377bb7c9..0a8438840 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -22,8 +22,12 @@ class Sensors(ABC): The resolution of the sensor in sensor units/LSB. noise_density : float, list The noise density of the sensor in sensor units/√Hz. - random_walk : float, list - The random walk of the sensor in sensor units/√Hz. + noise_variance : float, list + The variance of the noise of the sensor in sensor units^2. + random_walk_density : float, list + The random walk density of the sensor in sensor units/√Hz. + random_walk_variance : float, list + The variance of the random walk of the sensor in sensor units^2. constant_bias : float, list The constant bias of the sensor in sensor units. operating_temperature : float @@ -58,7 +62,9 @@ def __init__( measurement_range=np.inf, resolution=0, noise_density=0, - random_walk=0, + noise_variance=1, + random_walk_density=0, + random_walk_variance=1, constant_bias=0, operating_temperature=25, temperature_bias=0, @@ -99,19 +105,33 @@ def __init__( The resolution of the sensor in sensor units/LSB. Default is 0, meaning no quantization is applied. noise_density : float, list, optional - The noise density of the sensor in sensor units/√Hz. Sometimes - called "white noise drift", "angular random walk" for gyroscopes, - "velocity random walk" for the accelerometers or - "(rate) noise density". Default is 0, meaning no noise is applied. - If a float or int is given, the same noise density is applied to all + The noise density of the sensor for a Gaussian white noise in sensor + units/√Hz. Sometimes called "white noise drift", + "angular random walk" for gyroscopes, "velocity random walk" for + accelerometers or "(rate) noise density". Default is 0, meaning no + noise is applied. If a float or int is given, the same noise density + is applied to all axes. The values of each axis can be set + individually by passing a list of length 3. + noise_variance : float, list, optional + The noise variance of the sensor for a Gaussian white noise in + sensor units^2. Default is 1, meaning the noise is normally + distributed with a standard deviation of 1 unit. If a float or int + is given, the same noise variance is applied to all axes. The values + of each axis can be set individually by passing a list of length 3. + random_walk_density : float, list, optional + The random walk density of the sensor for a Gaussian random walk in + sensor units/√Hz. Sometimes called "bias (in)stability" or + "bias drift". Default is 0, meaning no random walk is applied. + If a float or int is given, the same random walk is applied to all axes. The values of each axis can be set individually by passing a list of length 3. - random_walk : float, list, optional - The random walk of the sensor in sensor units/√Hz. Sometimes called - "bias (in)stability" or "bias drift"". Default is 0, meaning no - random walk is applied. If a float or int is given, the same random - walk is applied to all axes. The values of each axis can be set - individually by passing a list of length 3. + random_walk_variance : float, list, optional + The random walk variance of the sensor for a Gaussian random walk in + sensor units^2. Default is 1, meaning the noise is normally + distributed with a standard deviation of 1 unit. If a float or int + is given, the same random walk variance is applied to all axes. The + values of each axis can be set individually by passing a list of + length 3. constant_bias : float, list, optional The constant bias of the sensor in sensor units. Default is 0, meaning no constant bias is applied. If a float or int is given, the @@ -140,13 +160,23 @@ def __init__( Returns ------- None + + See Also + -------- + TODO link to documentation on noise model """ self.sampling_rate = sampling_rate self.orientation = orientation self.resolution = resolution self.operating_temperature = operating_temperature self.noise_density = self._vectorize_input(noise_density, "noise_density") - self.random_walk = self._vectorize_input(random_walk, "random_walk") + self.noise_variance = self._vectorize_input(noise_variance, "noise_variance") + self.random_walk_density = self._vectorize_input( + random_walk_density, "random_walk_density" + ) + self.random_walk_variance = self._vectorize_input( + random_walk_variance, "random_walk_variance" + ) self.constant_bias = self._vectorize_input(constant_bias, "constant_bias") self.temperature_bias = self._vectorize_input( temperature_bias, "temperature_bias" @@ -202,6 +232,12 @@ def __init__( # map which rocket(s) the sensor is attached to and how many times self._attached_rockets = {} + def __repr__(self): + return f"{self.name}" + + def __call__(self, *args, **kwargs): + return self.measure(*args, **kwargs) + def _vectorize_input(self, value, name): if isinstance(value, (int, float)): return Vector([value, value, value]) @@ -236,12 +272,6 @@ def _save_data_multiple(self, data): if self._counter == len(self.measured_data): self._counter = 0 - def __repr__(self): - return f"{self.name}" - - def __call__(self, *args, **kwargs): - return self.measure(*args, **kwargs) - @abstractmethod def measure(self, *args, **kwargs): pass @@ -289,13 +319,25 @@ def apply_noise(self, value): """ # white noise white_noise = ( - np.random.normal(0, 1) * self.noise_density * self.sampling_rate**0.5 - ) + Vector( + [np.random.normal(0, self.noise_variance[i] ** 0.5) for i in range(3)] + ) + & self.noise_density + ) * self.sampling_rate**0.5 # random walk self._random_walk_drift = ( self._random_walk_drift - + np.random.normal(0, 1) * self.random_walk / self.sampling_rate**0.5 + + ( + Vector( + [ + np.random.normal(0, self.random_walk_variance[i] ** 0.5) + for i in range(3) + ] + ) + & self.random_walk_density + ) + / self.sampling_rate**0.5 ) # add noise From b2da0c3ab4e649951754739298893ef5ae0981a7 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 2 May 2024 16:33:53 +0200 Subject: [PATCH 39/77] BUG: fix prints for noise variance --- rocketpy/prints/sensors_prints.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/rocketpy/prints/sensors_prints.py b/rocketpy/prints/sensors_prints.py index 554d817e0..95e3458c0 100644 --- a/rocketpy/prints/sensors_prints.py +++ b/rocketpy/prints/sensors_prints.py @@ -56,7 +56,15 @@ def _general_noise(self): "Noise Density:", f"{self.sensor.noise_density} {self.units}/√Hz" ) self._print_aligned( - "Random Walk:", f"{self.sensor.random_walk} {self.units}/√Hz" + "Noise Variance:", f"{self.sensor.noise_variance} ({self.units})^2" + ) + self._print_aligned( + "Random Walk Density:", + f"{self.sensor.random_walk_density} {self.units}/√Hz", + ) + self._print_aligned( + "Random Walk Variance:", + f"{self.sensor.random_walk_variance} ({self.units})^2", ) self._print_aligned( "Constant Bias:", f"{self.sensor.constant_bias} {self.units}" From 123d033d0038bcef612a2ba71013d2f33c5c191d Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 2 May 2024 16:34:07 +0200 Subject: [PATCH 40/77] TST: add variances --- tests/fixtures/sensors/sensors_fixtures.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/tests/fixtures/sensors/sensors_fixtures.py b/tests/fixtures/sensors/sensors_fixtures.py index a4ea781c8..c32a41124 100644 --- a/tests/fixtures/sensors/sensors_fixtures.py +++ b/tests/fixtures/sensors/sensors_fixtures.py @@ -7,12 +7,14 @@ def noisy_rotated_accelerometer(): """Returns an accelerometer with all parameters set to non-default values, i.e. with noise and rotation.""" - # mpu6050 approx values + # mpu6050 approx values, variances are made up return Accelerometer( sampling_rate=100, orientation=(60, 60, 60), noise_density=[0, 0.03, 0.05], - random_walk=[0, 0.01, 0.02], + noise_variance=1.01, + random_walk_density=[0, 0.01, 0.02], + random_walk_variance=[1, 1, 1.05], constant_bias=[0, 0.3, 0.5], operating_temperature=25, temperature_bias=[0, 0.01, 0.02], @@ -27,12 +29,14 @@ def noisy_rotated_accelerometer(): def noisy_rotated_gyroscope(): """Returns a gyroscope with all parameters set to non-default values, i.e. with noise and rotation.""" - # mpu6050 approx values + # mpu6050 approx values, variances are made up return Gyroscope( sampling_rate=100, orientation=(-60, -60, -60), noise_density=[0, 0.03, 0.05], - random_walk=[0, 0.01, 0.02], + noise_variance=1.01, + random_walk_density=[0, 0.01, 0.02], + random_walk_variance=[1, 1, 1.05], constant_bias=[0, 0.3, 0.5], operating_temperature=25, temperature_bias=[0, 0.01, 0.02], From 00f0f3a2a562e3fbb3b2ae22edc3da1625f1d3d2 Mon Sep 17 00:00:00 2001 From: MateusStano <69485049+MateusStano@users.noreply.github.com> Date: Fri, 3 May 2024 15:30:25 -0300 Subject: [PATCH 41/77] Update rocketpy/rocket/rocket.py Co-authored-by: Pedro Henrique Marinho Bressan <87212571+phmbressan@users.noreply.github.com> --- rocketpy/rocket/rocket.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rocketpy/rocket/rocket.py b/rocketpy/rocket/rocket.py index 073c9c60a..7e03d2522 100644 --- a/rocketpy/rocket/rocket.py +++ b/rocketpy/rocket/rocket.py @@ -1194,7 +1194,7 @@ def add_sensor(self, sensor, position, x_position=0, y_position=0): self.sensors.add(sensor, Vector([x_position, y_position, position])) try: sensor._attached_rockets[self] += 1 - except: + except KeyError: sensor._attached_rockets[self] = 1 def add_air_brakes( From de2d8bd46332c1ffaff890e8b07bcdad44b0729d Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 6 May 2024 11:46:46 +0200 Subject: [PATCH 42/77] MNT: remove .type attribute --- rocketpy/prints/sensors_prints.py | 4 ++-- rocketpy/sensors/accelerometer.py | 1 - rocketpy/sensors/gyroscope.py | 1 - 3 files changed, 2 insertions(+), 4 deletions(-) diff --git a/rocketpy/prints/sensors_prints.py b/rocketpy/prints/sensors_prints.py index 95e3458c0..40d66d2bb 100644 --- a/rocketpy/prints/sensors_prints.py +++ b/rocketpy/prints/sensors_prints.py @@ -12,7 +12,7 @@ class _SensorsPrints(ABC): def __init__(self, sensor): self.sensor = sensor - self.units = UNITS[sensor.type] + self.units = UNITS[sensor.__class__.__name__] def _print_aligned(self, label, value): """Prints a label and a value aligned vertically.""" @@ -22,7 +22,7 @@ def identity(self): """Prints the identity of the sensor.""" print("Identification of the Sensor:\n") self._print_aligned("Name:", self.sensor.name) - self._print_aligned("Type:", self.sensor.type) + self._print_aligned("Type:", self.sensor.__class__.__name__) def orientation(self): """Prints the orientation of the sensor.""" diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index b5e447085..256c1efe5 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -191,7 +191,6 @@ def __init__( cross_axis_sensitivity=cross_axis_sensitivity, name=name, ) - self.type = "Accelerometer" self.consider_gravity = consider_gravity self.prints = _AccelerometerPrints(self) diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index 6ba2b945d..466c2d446 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -191,7 +191,6 @@ def __init__( cross_axis_sensitivity=cross_axis_sensitivity, name=name, ) - self.type = "Gyroscope" self.acceleration_sensitivity = self._vectorize_input( acceleration_sensitivity, "acceleration_sensitivity" ) From fec672512bba1b820bf6fcd606eedb56d09dc609 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 6 May 2024 13:21:17 +0200 Subject: [PATCH 43/77] DOC: fix units of transformation_euler_anges --- rocketpy/mathutils/vector_matrix.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/rocketpy/mathutils/vector_matrix.py b/rocketpy/mathutils/vector_matrix.py index 9c3efe616..f355a8d09 100644 --- a/rocketpy/mathutils/vector_matrix.py +++ b/rocketpy/mathutils/vector_matrix.py @@ -1037,11 +1037,11 @@ def transformation_euler_angles(roll, pitch, yaw): Parameters ---------- roll : float - The roll angle in radians. + The roll angle in degrees. pitch : float - The pitch angle in radians. + The pitch angle in degrees. yaw : float - The yaw angle in radians. + The yaw angle in degrees. Returns ------- From ce2a63d7325c0272a2275ad97d8dde19ba4c8f5d Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 6 May 2024 13:44:05 +0200 Subject: [PATCH 44/77] DOC: add examples to transformation_euler_angles --- rocketpy/mathutils/vector_matrix.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/rocketpy/mathutils/vector_matrix.py b/rocketpy/mathutils/vector_matrix.py index f355a8d09..e5613e4dd 100644 --- a/rocketpy/mathutils/vector_matrix.py +++ b/rocketpy/mathutils/vector_matrix.py @@ -1047,6 +1047,20 @@ def transformation_euler_angles(roll, pitch, yaw): ------- Matrix The transformation matrix from frame B to frame A. + + Examples + -------- + >>> M = Matrix.transformation_euler_angles(0, 0, 0) + >>> M + Matrix([1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0]) + + >>> M = Matrix.transformation_euler_angles(90, 0, 0) + >>> M + Matrix([-2.220446049250313e-16, -1.0000000000000002, 0.0], + [1.0000000000000002, -2.220446049250313e-16, 0.0], + [0.0, 0.0, 1.0]) """ return Matrix.transformation(euler_to_quaternions(roll, pitch, yaw)) From f2656c5d0bc77f193812bcea10394e4ff226de4a Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 6 May 2024 13:44:57 +0200 Subject: [PATCH 45/77] DOC: mention Euler parameters in docs --- rocketpy/tools.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/rocketpy/tools.py b/rocketpy/tools.py index edea8aada..9941d3793 100644 --- a/rocketpy/tools.py +++ b/rocketpy/tools.py @@ -468,7 +468,8 @@ def quaternions_to_nutation(e1, e2): def euler_to_quaternions(roll, pitch, yaw): - """Calculates the quaternions from the Euler angles in 3-2-1 sequence. + """Calculates the quaternions (Euler parameters) from the Euler angles in + 3-2-1 sequence. Parameters ---------- From 41bf9e9d5e34aebd252000dda056827f2c5d1f04 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 6 May 2024 15:04:47 +0200 Subject: [PATCH 46/77] TST: test_euler_to_quaternions --- tests/unit/test_tools.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 tests/unit/test_tools.py diff --git a/tests/unit/test_tools.py b/tests/unit/test_tools.py new file mode 100644 index 000000000..e1692720b --- /dev/null +++ b/tests/unit/test_tools.py @@ -0,0 +1,17 @@ +import numpy as np +import pytest + +from rocketpy.tools import euler_to_quaternions + + +def test_euler_to_quaternions(): + q0, q1, q2, q3 = euler_to_quaternions(0, 0, 0) + assert q0 == 1 + assert q1 == 0 + assert q2 == 0 + assert q3 == 0 + q0, q1, q2, q3 = euler_to_quaternions(90, 90, 90) + assert round(q0, 7) == 0.7071068 + assert round(q1, 7) == 0 + assert round(q2, 7) == 0.7071068 + assert round(q3, 7) == 0 From 11873cd6db9340dbd5ebab35725da075eb21158a Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 6 May 2024 15:06:09 +0200 Subject: [PATCH 47/77] TST: fix doc tests --- rocketpy/mathutils/vector_matrix.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rocketpy/mathutils/vector_matrix.py b/rocketpy/mathutils/vector_matrix.py index e5613e4dd..14ea9ba54 100644 --- a/rocketpy/mathutils/vector_matrix.py +++ b/rocketpy/mathutils/vector_matrix.py @@ -1058,8 +1058,8 @@ def transformation_euler_angles(roll, pitch, yaw): >>> M = Matrix.transformation_euler_angles(90, 0, 0) >>> M - Matrix([-2.220446049250313e-16, -1.0000000000000002, 0.0], - [1.0000000000000002, -2.220446049250313e-16, 0.0], + Matrix([-2.220446049250313e-16, -1, 0.0], + [1, -2.220446049250313e-16, 0.0], [0.0, 0.0, 1.0]) """ return Matrix.transformation(euler_to_quaternions(roll, pitch, yaw)) From b795031d1fc686afb3455b39682ae0267ead9423 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 6 May 2024 15:07:56 +0200 Subject: [PATCH 48/77] MNT: privatize components attributes and improve docs --- rocketpy/rocket/components.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/rocketpy/rocket/components.py b/rocketpy/rocket/components.py index f97d54cab..66c9f09a7 100644 --- a/rocketpy/rocket/components.py +++ b/rocketpy/rocket/components.py @@ -25,8 +25,8 @@ def __init__(self): # List of components and their positions to avoid extra for loops in # simulation time - self._component_list = [] - self._position_list = [] + self.__component_list = [] + self.__position_list = [] def __repr__(self): """Return a string representation of the Components instance.""" @@ -66,8 +66,8 @@ def add(self, component, position): ------- None """ - self._component_list.append(component) - self._position_list.append(position) + self.__component_list.append(component) + self.__position_list.append(position) self._components.append(self.component_tuple(component, position)) def get_by_type(self, component_type): @@ -115,10 +115,10 @@ def get_components(self): Returns ------- - list + list[Component] A list of all the components in the list of components. """ - return self._component_list + return self.__component_list def get_positions(self): """Return a list of all the positions of the components in the list of @@ -130,7 +130,7 @@ def get_positions(self): A list of all the positions of the components in the list of components. """ - return self._position_list + return self.__position_list def remove(self, component): """Remove a component from the list of components. If more than one From 968f55adf3439b8a3c09a3335400c576aae51704 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 6 May 2024 15:10:14 +0200 Subject: [PATCH 49/77] TST: add index to var names --- tests/unit/test_sensors.py | 90 +++++++++++++++++++------------------- 1 file changed, 46 insertions(+), 44 deletions(-) diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensors.py index ebb0c5b60..d98bd8f4a 100644 --- a/tests/unit/test_sensors.py +++ b/tests/unit/test_sensors.py @@ -8,7 +8,7 @@ from rocketpy.tools import euler_to_quaternions # calisto standard simulation no wind solution index 200 -SOLUTION = [ +SOLUTION_INDEX_200 = [ 3.338513236767685, 0.02856482783411794, 50.919436628139216, @@ -24,7 +24,7 @@ 0.00010697759229808481, 19.72526891699468, ] -UDOT = [ +U_DOT_INDEX_200 = [ 0.021620542063162787, 30.468683793837055, 284.19140267225384, @@ -78,21 +78,21 @@ def test_ideal_accelerometer_measure(ideal_accelerometer): """Test the measure method of the Accelerometer class. Checks if saved measurement is (ax,ay,az) and if measured_data is [(t, (ax,ay,az)), ...] """ - t = SOLUTION[0] - u = SOLUTION[1:] + t = SOLUTION_INDEX_200[0] + u = SOLUTION_INDEX_200[1:] relative_position = Vector([0, 0, 0]) gravity = 9.81 - a_I = Vector(UDOT[3:6]) + a_I = Vector(U_DOT_INDEX_200[3:6]) omega = Vector(u[10:13]) - omega_dot = Vector(UDOT[10:13]) + omega_dot = Vector(U_DOT_INDEX_200[10:13]) accel = ( a_I + Vector.cross(omega_dot, relative_position) + Vector.cross(omega, Vector.cross(omega, relative_position)) ) ax, ay, az = Matrix.transformation(u[6:10]) @ accel - ideal_accelerometer.measure(t, u, UDOT, relative_position, gravity) + ideal_accelerometer.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) # check last measurement assert len(ideal_accelerometer.measurement) == 3 @@ -101,7 +101,7 @@ def test_ideal_accelerometer_measure(ideal_accelerometer): # check measured values assert len(ideal_accelerometer.measured_data) == 1 - ideal_accelerometer.measure(t, u, UDOT, relative_position, gravity) + ideal_accelerometer.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) assert len(ideal_accelerometer.measured_data) == 2 assert all(isinstance(i, tuple) for i in ideal_accelerometer.measured_data) @@ -113,8 +113,8 @@ def test_ideal_gyroscope_measure(ideal_gyroscope): """Test the measure method of the Gyroscope class. Checks if saved measurement is (wx,wy,wz) and if measured_data is [(t, (wx,wy,wz)), ...] """ - t = SOLUTION[0] - u = SOLUTION[1:] + t = SOLUTION_INDEX_200[0] + u = SOLUTION_INDEX_200[1:] relative_position = Vector( [np.random.randint(-1, 1), np.random.randint(-1, 1), np.random.randint(-1, 1)] ) @@ -122,7 +122,7 @@ def test_ideal_gyroscope_measure(ideal_gyroscope): rot = Matrix.transformation(u[6:10]) ax, ay, az = rot @ Vector(u[10:13]) - ideal_gyroscope.measure(t, u, UDOT, relative_position) + ideal_gyroscope.measure(t, u, U_DOT_INDEX_200, relative_position) # check last measurement assert len(ideal_gyroscope.measurement) == 3 @@ -131,7 +131,7 @@ def test_ideal_gyroscope_measure(ideal_gyroscope): # check measured values assert len(ideal_gyroscope.measured_data) == 1 - ideal_gyroscope.measure(t, u, UDOT, relative_position) + ideal_gyroscope.measure(t, u, U_DOT_INDEX_200, relative_position) assert len(ideal_gyroscope.measured_data) == 2 assert all(isinstance(i, tuple) for i in ideal_gyroscope.measured_data) @@ -143,15 +143,15 @@ def test_noisy_rotated_accelerometer(noisy_rotated_accelerometer): """Test the measure method of the Accelerometer class. Checks if saved measurement is (ax,ay,az) and if measured_data is [(t, (ax,ay,az)), ...] """ - t = SOLUTION[0] - u = SOLUTION[1:] + t = SOLUTION_INDEX_200[0] + u = SOLUTION_INDEX_200[1:] # calculate acceleration at sensor position in inertial frame relative_position = Vector([0.4, 0.4, 1]) gravity = 9.81 - a_I = Vector(UDOT[3:6]) + Vector([0, 0, -gravity]) + a_I = Vector(U_DOT_INDEX_200[3:6]) + Vector([0, 0, -gravity]) omega = Vector(u[10:13]) - omega_dot = Vector(UDOT[10:13]) + omega_dot = Vector(U_DOT_INDEX_200[10:13]) accel = ( a_I + Vector.cross(omega_dot, relative_position) @@ -177,7 +177,9 @@ def test_noisy_rotated_accelerometer(noisy_rotated_accelerometer): az += 0.5 # check last measurement considering noise error bounds - noisy_rotated_accelerometer.measure(t, u, UDOT, relative_position, gravity) + noisy_rotated_accelerometer.measure( + t, u, U_DOT_INDEX_200, relative_position, gravity + ) assert noisy_rotated_accelerometer.measurement == approx([ax, ay, az], rel=0.5) @@ -185,8 +187,8 @@ def test_noisy_rotated_gyroscope(noisy_rotated_gyroscope): """Test the measure method of the Gyroscope class. Checks if saved measurement is (wx,wy,wz) and if measured_data is [(t, (wx,wy,wz)), ...] """ - t = SOLUTION[0] - u = SOLUTION[1:] + t = SOLUTION_INDEX_200[0] + u = SOLUTION_INDEX_200[1:] # calculate acceleration at sensor position in inertial frame relative_position = Vector([0.4, 0.4, 1]) gravity = 9.81 @@ -210,7 +212,7 @@ def test_noisy_rotated_gyroscope(noisy_rotated_gyroscope): wz += 0.5 # check last measurement considering noise error bounds - noisy_rotated_gyroscope.measure(t, u, UDOT, relative_position, gravity) + noisy_rotated_gyroscope.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) assert noisy_rotated_gyroscope.measurement == approx([wx, wy, wz], rel=0.5) @@ -218,14 +220,14 @@ def test_quantization_accelerometer(quantized_accelerometer): """Test the measure method of the Accelerometer class. Checks if saved measurement is (ax,ay,az) and if measured_data is [(t, (ax,ay,az)), ...] """ - t = SOLUTION[0] - u = SOLUTION[1:] + t = SOLUTION_INDEX_200[0] + u = SOLUTION_INDEX_200[1:] # calculate acceleration at sensor position in inertial frame relative_position = Vector([0, 0, 0]) gravity = 9.81 - a_I = Vector(UDOT[3:6]) + a_I = Vector(U_DOT_INDEX_200[3:6]) omega = Vector(u[10:13]) - omega_dot = Vector(UDOT[10:13]) + omega_dot = Vector(U_DOT_INDEX_200[10:13]) accel = ( a_I + Vector.cross(omega_dot, relative_position) @@ -243,7 +245,7 @@ def test_quantization_accelerometer(quantized_accelerometer): az = round(az / 0.4882) * 0.4882 # check last measurement considering noise error bounds - quantized_accelerometer.measure(t, u, UDOT, relative_position, gravity) + quantized_accelerometer.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) assert quantized_accelerometer.measurement == approx([ax, ay, az], abs=1e-10) @@ -251,8 +253,8 @@ def test_quantization_gyroscope(quantized_gyroscope): """Test the measure method of the Gyroscope class. Checks if saved measurement is (wx,wy,wz) and if measured_data is [(t, (wx,wy,wz)), ...] """ - t = SOLUTION[0] - u = SOLUTION[1:] + t = SOLUTION_INDEX_200[0] + u = SOLUTION_INDEX_200[1:] # calculate acceleration at sensor position in inertial frame relative_position = Vector([0.4, 0.4, 1]) gravity = 9.81 @@ -268,7 +270,7 @@ def test_quantization_gyroscope(quantized_gyroscope): wz = round(wz / 0.4882) * 0.4882 # check last measurement considering noise error bounds - quantized_gyroscope.measure(t, u, UDOT, relative_position, gravity) + quantized_gyroscope.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) assert quantized_gyroscope.measurement == approx([wx, wy, wz], abs=1e-10) @@ -281,12 +283,12 @@ def test_export_accel_data_csv(ideal_accelerometer): flight_calisto_accel_gyro : Flight Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. """ - t = SOLUTION[0] - u = SOLUTION[1:] + t = SOLUTION_INDEX_200[0] + u = SOLUTION_INDEX_200[1:] relative_position = Vector([0, 0, 0]) gravity = 9.81 - ideal_accelerometer.measure(t, u, UDOT, relative_position, gravity) - ideal_accelerometer.measure(t, u, UDOT, relative_position, gravity) + ideal_accelerometer.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) + ideal_accelerometer.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) file_name = "sensors.csv" @@ -330,12 +332,12 @@ def test_export_accel_data_json(ideal_accelerometer): Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. """ - t = SOLUTION[0] - u = SOLUTION[1:] + t = SOLUTION_INDEX_200[0] + u = SOLUTION_INDEX_200[1:] relative_position = Vector([0, 0, 0]) gravity = 9.81 - ideal_accelerometer.measure(t, u, UDOT, relative_position, gravity) - ideal_accelerometer.measure(t, u, UDOT, relative_position, gravity) + ideal_accelerometer.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) + ideal_accelerometer.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) file_name = "sensors.json" @@ -379,11 +381,11 @@ def test_export_gyro_data_csv(ideal_gyroscope): Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. """ - t = SOLUTION[0] - u = SOLUTION[1:] + t = SOLUTION_INDEX_200[0] + u = SOLUTION_INDEX_200[1:] relative_position = Vector([0, 0, 0]) - ideal_gyroscope.measure(t, u, UDOT, relative_position) - ideal_gyroscope.measure(t, u, UDOT, relative_position) + ideal_gyroscope.measure(t, u, U_DOT_INDEX_200, relative_position) + ideal_gyroscope.measure(t, u, U_DOT_INDEX_200, relative_position) file_name = "sensors.csv" @@ -426,11 +428,11 @@ def test_export_gyro_data_json(ideal_gyroscope): flight_calisto_accel_gyro : Flight Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. """ - t = SOLUTION[0] - u = SOLUTION[1:] + t = SOLUTION_INDEX_200[0] + u = SOLUTION_INDEX_200[1:] relative_position = Vector([0, 0, 0]) - ideal_gyroscope.measure(t, u, UDOT, relative_position) - ideal_gyroscope.measure(t, u, UDOT, relative_position) + ideal_gyroscope.measure(t, u, U_DOT_INDEX_200, relative_position) + ideal_gyroscope.measure(t, u, U_DOT_INDEX_200, relative_position) file_name = "sensors.json" From d827b8ed55e524a806ba1bbc88c80afd1d8afcb8 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 6 May 2024 15:12:30 +0200 Subject: [PATCH 50/77] MNT: return temp drift directly --- rocketpy/sensors/sensors.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index 0a8438840..2196b25bc 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -366,6 +366,4 @@ def apply_temperature_drift(self, value): Vector([1, 1, 1]) + (self.operating_temperature - 25) / 100 * self.temperature_scale_factor ) - value = value & scale_factor - - return value + return value & scale_factor From 0b0f20175864f150776d2da37caadc1c05e14c2c Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 6 May 2024 15:29:48 +0200 Subject: [PATCH 51/77] ENH: improve export methods --- rocketpy/sensors/accelerometer.py | 10 ++++++---- rocketpy/sensors/gyroscope.py | 10 ++++++---- 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 256c1efe5..35c501792 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -259,7 +259,9 @@ def export_measured_data(self, filename, format="csv"): ------- None """ - if format == "csv": + if format.lower() not in ["json", "csv"]: + raise ValueError("Invalid format") + if format.lower() == "csv": # if sensor has been added multiple times to the simulated rocket if isinstance(self.measured_data[0], list): print("Data saved to", end=" ") @@ -275,7 +277,8 @@ def export_measured_data(self, filename, format="csv"): for t, ax, ay, az in self.measured_data: f.write(f"{t},{ax},{ay},{az}\n") print(f"Data saved to {filename}") - elif format == "json": + return + if format.lower() == "json": if isinstance(self.measured_data[0], list): print("Data saved to", end=" ") for i, data in enumerate(self.measured_data): @@ -298,5 +301,4 @@ def export_measured_data(self, filename, format="csv"): with open(filename, "w") as f: json.dump(dict, f) print(f"Data saved to {filename}") - else: - raise ValueError("Invalid format") + return diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index 466c2d446..743b80c21 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -290,7 +290,9 @@ def export_measured_data(self, filename, format="csv"): ------- None """ - if format == "csv": + if format.lower() not in ["csv", "json"]: + raise ValueError("Invalid format") + if format.lower() == "csv": # if sensor has been added multiple times to the simulated rocket if isinstance(self.measured_data[0], list): print("Data saved to", end=" ") @@ -306,7 +308,8 @@ def export_measured_data(self, filename, format="csv"): for t, wx, wy, wz in self.measured_data: f.write(f"{t},{wx},{wy},{wz}\n") print(f"Data saved to {filename}") - elif format == "json": + return + if format.lower() == "json": if isinstance(self.measured_data[0], list): print("Data saved to", end=" ") for i, data in enumerate(self.measured_data): @@ -329,5 +332,4 @@ def export_measured_data(self, filename, format="csv"): with open(filename, "w") as f: json.dump(dict, f) print(f"Data saved to {filename}") - else: - raise ValueError("Invalid format") + return From bad3b0748ef0394f68071c08c753e39af6dbbc5b Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 6 May 2024 15:30:04 +0200 Subject: [PATCH 52/77] DOC: typos --- rocketpy/rocket/aero_surface.py | 2 +- rocketpy/rocket/rocket.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/rocketpy/rocket/aero_surface.py b/rocketpy/rocket/aero_surface.py index 9649d1bf0..a5ea26638 100644 --- a/rocketpy/rocket/aero_surface.py +++ b/rocketpy/rocket/aero_surface.py @@ -1978,7 +1978,7 @@ def __init__( Default is False. deployment_level : float, optional Initial deployment level, ranging from 0 to 1. Deployment level is - the fraction of the total airbrake area that is Deployment. Default + the fraction of the total airbrake area that is deployed. Default is 0. name : str, optional Name of the air brakes. Default is "AirBrakes". diff --git a/rocketpy/rocket/rocket.py b/rocketpy/rocket/rocket.py index 7e03d2522..c09e7c160 100644 --- a/rocketpy/rocket/rocket.py +++ b/rocketpy/rocket/rocket.py @@ -1181,10 +1181,10 @@ def add_sensor(self, sensor, position, x_position=0, y_position=0): Position, in meters, of the sensor's coordinate system origin relative to the user defined rocket coordinate system. x_position : int, float, optional - Distance in meters by which the CM is to be translated in the x + Distance in meters by which the sensor is to be translated in the x direction relative to geometrical center line. Default is 0. y_position : int, float, optional - Distance in meters by which the CM is to be translated in the y + Distance in meters by which the sensor is to be translated in the y direction relative to geometrical center line. Default is 0. Returns From 0891c6c9c5e5ef185192b61ec88176f8e9235599 Mon Sep 17 00:00:00 2001 From: MateusStano <69485049+MateusStano@users.noreply.github.com> Date: Mon, 6 May 2024 13:27:20 -0300 Subject: [PATCH 53/77] MNT: improve flight init Co-authored-by: Gui-FernandesBR <63590233+Gui-FernandesBR@users.noreply.github.com> --- tests/unit/test_sensors.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensors.py index d98bd8f4a..365c1165c 100644 --- a/tests/unit/test_sensors.py +++ b/tests/unit/test_sensors.py @@ -50,12 +50,12 @@ def test_accelerometer_prints(noisy_rotated_accelerometer, quantized_acceleromet assert True -def test_gyroscope_prints(noisy_rotated_gyroscope, quantized_gyroscope): +@pytest.mark.parametrize("gyroscope", ["noisy_rotated_gyroscope", "quantized_gyroscope"]) +def test_gyroscope_prints(gyroscope): """Test the print methods of the Gyroscope class. Checks if all attributes are printed correctly. """ - noisy_rotated_gyroscope.prints.all() - quantized_gyroscope.prints.all() + gyroscope.prints.all() assert True From fa1b6a828817d8fb7dceabc051ff2c67c3a70005 Mon Sep 17 00:00:00 2001 From: Lint Action Date: Mon, 6 May 2024 16:27:49 +0000 Subject: [PATCH 54/77] Fix code style issues with Black --- tests/unit/test_sensors.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensors.py index 365c1165c..0240365a3 100644 --- a/tests/unit/test_sensors.py +++ b/tests/unit/test_sensors.py @@ -50,7 +50,9 @@ def test_accelerometer_prints(noisy_rotated_accelerometer, quantized_acceleromet assert True -@pytest.mark.parametrize("gyroscope", ["noisy_rotated_gyroscope", "quantized_gyroscope"]) +@pytest.mark.parametrize( + "gyroscope", ["noisy_rotated_gyroscope", "quantized_gyroscope"] +) def test_gyroscope_prints(gyroscope): """Test the print methods of the Gyroscope class. Checks if all attributes are printed correctly. From 8c71432dc6e87d028bb774d7ea5dd67441a92adb Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 6 May 2024 21:03:59 +0200 Subject: [PATCH 55/77] TST: overall improvements on sensor testing --- tests/test_sensors.py | 41 ---- tests/unit/test_flight.py | 42 ++++ tests/unit/test_sensors.py | 401 ++++++++++++------------------------- 3 files changed, 166 insertions(+), 318 deletions(-) diff --git a/tests/test_sensors.py b/tests/test_sensors.py index 92960732e..62c872b90 100644 --- a/tests/test_sensors.py +++ b/tests/test_sensors.py @@ -60,44 +60,3 @@ def test_ideal_sensors(flight_calisto_accel_gyro): flight_wz = np.array(flight_calisto_accel_gyro.w3(time)) sim_w = np.sqrt(flight_wx**2 + flight_wy**2 + flight_wz**2) assert np.allclose(w, sim_w, atol=1e-12) - - -def test_export_sensor_data(flight_calisto_accel_gyro): - """Test the export of sensor data. - - Parameters - ---------- - flight_calisto_accel_gyro : Flight - Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. - """ - flight_calisto_accel_gyro.export_sensor_data("test_sensor_data.json") - # read the json and parse as dict - filename = "test_sensor_data.json" - with open(filename, "r") as f: - data = f.read() - sensor_data = json.loads(data) - # convert list of tuples into list of lists to compare with the json - flight_calisto_accel_gyro.sensors[0].measured_data[0] = [ - list(measurement) - for measurement in flight_calisto_accel_gyro.sensors[0].measured_data[0] - ] - flight_calisto_accel_gyro.sensors[1].measured_data[1] = [ - list(measurement) - for measurement in flight_calisto_accel_gyro.sensors[1].measured_data[1] - ] - flight_calisto_accel_gyro.sensors[2].measured_data = [ - list(measurement) - for measurement in flight_calisto_accel_gyro.sensors[2].measured_data - ] - assert ( - sensor_data["Accelerometer"]["1"] - == flight_calisto_accel_gyro.sensors[0].measured_data[0] - ) - assert ( - sensor_data["Accelerometer"]["2"] - == flight_calisto_accel_gyro.sensors[1].measured_data[1] - ) - assert ( - sensor_data["Gyroscope"] == flight_calisto_accel_gyro.sensors[2].measured_data - ) - os.remove(filename) diff --git a/tests/unit/test_flight.py b/tests/unit/test_flight.py index e6ab6b8b8..59368c268 100644 --- a/tests/unit/test_flight.py +++ b/tests/unit/test_flight.py @@ -1,3 +1,4 @@ +import json import os from unittest.mock import patch @@ -286,3 +287,44 @@ def test_out_of_rail_stability_margin(flight_calisto_custom_wind): flight_calisto_custom_wind.out_of_rail_time ) assert np.isclose(res, 2.14, atol=0.1) + + +def test_export_sensor_data(flight_calisto_accel_gyro): + """Test the export of sensor data. + + Parameters + ---------- + flight_calisto_accel_gyro : Flight + Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. + """ + flight_calisto_accel_gyro.export_sensor_data("test_sensor_data.json") + # read the json and parse as dict + filename = "test_sensor_data.json" + with open(filename, "r") as f: + data = f.read() + sensor_data = json.loads(data) + # convert list of tuples into list of lists to compare with the json + flight_calisto_accel_gyro.sensors[0].measured_data[0] = [ + list(measurement) + for measurement in flight_calisto_accel_gyro.sensors[0].measured_data[0] + ] + flight_calisto_accel_gyro.sensors[1].measured_data[1] = [ + list(measurement) + for measurement in flight_calisto_accel_gyro.sensors[1].measured_data[1] + ] + flight_calisto_accel_gyro.sensors[2].measured_data = [ + list(measurement) + for measurement in flight_calisto_accel_gyro.sensors[2].measured_data + ] + assert ( + sensor_data["Accelerometer"]["1"] + == flight_calisto_accel_gyro.sensors[0].measured_data[0] + ) + assert ( + sensor_data["Accelerometer"]["2"] + == flight_calisto_accel_gyro.sensors[1].measured_data[1] + ) + assert ( + sensor_data["Gyroscope"] == flight_calisto_accel_gyro.sensors[2].measured_data + ) + os.remove(filename) diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensors.py index 0240365a3..07ed01f65 100644 --- a/tests/unit/test_sensors.py +++ b/tests/unit/test_sensors.py @@ -3,13 +3,14 @@ import numpy as np from pytest import approx +import pytest from rocketpy.mathutils.vector_matrix import Matrix, Vector from rocketpy.tools import euler_to_quaternions # calisto standard simulation no wind solution index 200 -SOLUTION_INDEX_200 = [ - 3.338513236767685, +TIME = 3.338513236767685 +U = [ 0.02856482783411794, 50.919436628139216, 1898.9056294848442, @@ -24,7 +25,7 @@ 0.00010697759229808481, 19.72526891699468, ] -U_DOT_INDEX_200 = [ +U_DOT = [ 0.021620542063162787, 30.468683793837055, 284.19140267225384, @@ -39,25 +40,24 @@ -0.052789015849051935, 2.276425320359305, ] - - -def test_accelerometer_prints(noisy_rotated_accelerometer, quantized_accelerometer): - """Test the print methods of the Accelerometer class. Checks if all - attributes are printed correctly. - """ - noisy_rotated_accelerometer.prints.all() - quantized_accelerometer.prints.all() - assert True +GRAVITY = 9.81 @pytest.mark.parametrize( - "gyroscope", ["noisy_rotated_gyroscope", "quantized_gyroscope"] + "sensor", + [ + "noisy_rotated_accelerometer", + "quantized_accelerometer", + "noisy_rotated_gyroscope", + "quantized_gyroscope", + ], ) -def test_gyroscope_prints(gyroscope): - """Test the print methods of the Gyroscope class. Checks if all - attributes are printed correctly. +def test_sensors_prints(sensor, request): + """Test the print methods of the Sensor class. Checks if all attributes are + printed correctly. """ - gyroscope.prints.all() + sensor = request.getfixturevalue(sensor) + sensor.prints.all() assert True @@ -65,6 +65,7 @@ def test_rotation_matrix(noisy_rotated_accelerometer): """Test the rotation_matrix property of the Accelerometer class. Checks if the rotation matrix is correctly calculated. """ + # values from external source expected_matrix = np.array( [ [0.2500000, -0.0580127, 0.9665064], @@ -76,84 +77,67 @@ def test_rotation_matrix(noisy_rotated_accelerometer): assert np.allclose(expected_matrix, rotation_matrix, atol=1e-8) -def test_ideal_accelerometer_measure(ideal_accelerometer): - """Test the measure method of the Accelerometer class. Checks if saved - measurement is (ax,ay,az) and if measured_data is [(t, (ax,ay,az)), ...] +def test_quantization(quantized_accelerometer): + """Test the quantize method of the Sensor class. Checks if returned values + are as expected. """ - t = SOLUTION_INDEX_200[0] - u = SOLUTION_INDEX_200[1:] - - relative_position = Vector([0, 0, 0]) - gravity = 9.81 - a_I = Vector(U_DOT_INDEX_200[3:6]) - omega = Vector(u[10:13]) - omega_dot = Vector(U_DOT_INDEX_200[10:13]) - accel = ( - a_I - + Vector.cross(omega_dot, relative_position) - + Vector.cross(omega, Vector.cross(omega, relative_position)) + # expected values calculated by hand + assert quantized_accelerometer.quantize(Vector([3, 3, 3])) == Vector( + [1.9528, 1.9528, 1.9528] ) - ax, ay, az = Matrix.transformation(u[6:10]) @ accel - ideal_accelerometer.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) - - # check last measurement - assert len(ideal_accelerometer.measurement) == 3 - assert all(isinstance(i, float) for i in ideal_accelerometer.measurement) - assert ideal_accelerometer.measurement == approx([ax, ay, az], abs=1e-10) - - # check measured values - assert len(ideal_accelerometer.measured_data) == 1 - ideal_accelerometer.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) - assert len(ideal_accelerometer.measured_data) == 2 - - assert all(isinstance(i, tuple) for i in ideal_accelerometer.measured_data) - assert ideal_accelerometer.measured_data[0][0] == t - assert ideal_accelerometer.measured_data[0][1:] == approx([ax, ay, az], abs=1e-10) - - -def test_ideal_gyroscope_measure(ideal_gyroscope): - """Test the measure method of the Gyroscope class. Checks if saved - measurement is (wx,wy,wz) and if measured_data is [(t, (wx,wy,wz)), ...] - """ - t = SOLUTION_INDEX_200[0] - u = SOLUTION_INDEX_200[1:] - relative_position = Vector( - [np.random.randint(-1, 1), np.random.randint(-1, 1), np.random.randint(-1, 1)] + assert quantized_accelerometer.quantize(Vector([-3, -3, -3])) == Vector( + [-1.9528, -1.9528, -1.9528] + ) + assert quantized_accelerometer.quantize(Vector([1, 1, 1])) == Vector( + [0.9764, 0.9764, 0.9764] ) - rot = Matrix.transformation(u[6:10]) - ax, ay, az = rot @ Vector(u[10:13]) - - ideal_gyroscope.measure(t, u, U_DOT_INDEX_200, relative_position) - - # check last measurement - assert len(ideal_gyroscope.measurement) == 3 - assert all(isinstance(i, float) for i in ideal_gyroscope.measurement) - assert ideal_gyroscope.measurement == approx([ax, ay, az], abs=1e-10) - - # check measured values - assert len(ideal_gyroscope.measured_data) == 1 - ideal_gyroscope.measure(t, u, U_DOT_INDEX_200, relative_position) - assert len(ideal_gyroscope.measured_data) == 2 - assert all(isinstance(i, tuple) for i in ideal_gyroscope.measured_data) - assert ideal_gyroscope.measured_data[0][0] == t - assert ideal_gyroscope.measured_data[0][1:] == approx([ax, ay, az], abs=1e-10) +@pytest.mark.parametrize( + "sensor", + [ + "ideal_accelerometer", + "ideal_gyroscope", + ], +) +def test_measured_data(sensor, request): + """Test the measured_data property of the Sensors class. Checks if + the measured data is treated properly when the sensor is added once or more + than once to the rocket. + """ + sensor = request.getfixturevalue(sensor) + + sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY) + assert len(sensor.measured_data) == 1 + sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY) + assert len(sensor.measured_data) == 2 + assert all(isinstance(i, tuple) for i in sensor.measured_data) + + # check case when sensor is added more than once to the rocket + sensor.measured_data = [ + sensor.measured_data[:], + sensor.measured_data[:], + ] + sensor._save_data = sensor._save_data_multiple + sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY) + assert len(sensor.measured_data) == 2 + assert len(sensor.measured_data[0]) == 3 + assert len(sensor.measured_data[1]) == 2 + sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY) + assert len(sensor.measured_data[0]) == 3 + assert len(sensor.measured_data[1]) == 3 def test_noisy_rotated_accelerometer(noisy_rotated_accelerometer): """Test the measure method of the Accelerometer class. Checks if saved measurement is (ax,ay,az) and if measured_data is [(t, (ax,ay,az)), ...] """ - t = SOLUTION_INDEX_200[0] - u = SOLUTION_INDEX_200[1:] # calculate acceleration at sensor position in inertial frame relative_position = Vector([0.4, 0.4, 1]) - gravity = 9.81 - a_I = Vector(U_DOT_INDEX_200[3:6]) + Vector([0, 0, -gravity]) - omega = Vector(u[10:13]) - omega_dot = Vector(U_DOT_INDEX_200[10:13]) + a_I = Vector(U_DOT[3:6]) + Vector([0, 0, -GRAVITY]) + omega = Vector(U[10:13]) + omega_dot = Vector(U_DOT[10:13]) accel = ( a_I + Vector.cross(omega_dot, relative_position) @@ -170,7 +154,7 @@ def test_noisy_rotated_accelerometer(noisy_rotated_accelerometer): ) sensor_rotation = Matrix.transformation(euler_to_quaternions(60, 60, 60)) total_rotation = sensor_rotation @ cross_axis_sensitivity - rocket_rotation = Matrix.transformation(u[6:10]) + rocket_rotation = Matrix.transformation(U[6:10]) # expected measurement without noise ax, ay, az = total_rotation @ (rocket_rotation @ accel) # expected measurement with constant bias @@ -179,22 +163,22 @@ def test_noisy_rotated_accelerometer(noisy_rotated_accelerometer): az += 0.5 # check last measurement considering noise error bounds - noisy_rotated_accelerometer.measure( - t, u, U_DOT_INDEX_200, relative_position, gravity + noisy_rotated_accelerometer.measure(TIME, U, U_DOT, relative_position, GRAVITY) + assert noisy_rotated_accelerometer.measurement == approx([ax, ay, az], rel=0.1) + assert len(noisy_rotated_accelerometer.measurement) == 3 + assert noisy_rotated_accelerometer.measured_data[0][1:] == approx( + [ax, ay, az], rel=0.1 ) - assert noisy_rotated_accelerometer.measurement == approx([ax, ay, az], rel=0.5) + assert noisy_rotated_accelerometer.measured_data[0][0] == TIME def test_noisy_rotated_gyroscope(noisy_rotated_gyroscope): """Test the measure method of the Gyroscope class. Checks if saved measurement is (wx,wy,wz) and if measured_data is [(t, (wx,wy,wz)), ...] """ - t = SOLUTION_INDEX_200[0] - u = SOLUTION_INDEX_200[1:] # calculate acceleration at sensor position in inertial frame relative_position = Vector([0.4, 0.4, 1]) - gravity = 9.81 - omega = Vector(u[10:13]) + omega = Vector(U[10:13]) # calculate total rotation matrix cross_axis_sensitivity = Matrix( [ @@ -205,7 +189,7 @@ def test_noisy_rotated_gyroscope(noisy_rotated_gyroscope): ) sensor_rotation = Matrix.transformation(euler_to_quaternions(-60, -60, -60)) total_rotation = sensor_rotation @ cross_axis_sensitivity - rocket_rotation = Matrix.transformation(u[6:10]) + rocket_rotation = Matrix.transformation(U[6:10]) # expected measurement without noise wx, wy, wz = total_rotation @ (rocket_rotation @ omega) # expected measurement with constant bias @@ -214,69 +198,21 @@ def test_noisy_rotated_gyroscope(noisy_rotated_gyroscope): wz += 0.5 # check last measurement considering noise error bounds - noisy_rotated_gyroscope.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) - assert noisy_rotated_gyroscope.measurement == approx([wx, wy, wz], rel=0.5) + noisy_rotated_gyroscope.measure(TIME, U, U_DOT, relative_position, GRAVITY) + assert noisy_rotated_gyroscope.measurement == approx([wx, wy, wz], rel=0.2) + assert len(noisy_rotated_gyroscope.measurement) == 3 + assert noisy_rotated_gyroscope.measured_data[0][1:] == approx([wx, wy, wz], rel=0.2) + assert noisy_rotated_gyroscope.measured_data[0][0] == TIME -def test_quantization_accelerometer(quantized_accelerometer): - """Test the measure method of the Accelerometer class. Checks if saved - measurement is (ax,ay,az) and if measured_data is [(t, (ax,ay,az)), ...] - """ - t = SOLUTION_INDEX_200[0] - u = SOLUTION_INDEX_200[1:] - # calculate acceleration at sensor position in inertial frame - relative_position = Vector([0, 0, 0]) - gravity = 9.81 - a_I = Vector(U_DOT_INDEX_200[3:6]) - omega = Vector(u[10:13]) - omega_dot = Vector(U_DOT_INDEX_200[10:13]) - accel = ( - a_I - + Vector.cross(omega_dot, relative_position) - + Vector.cross(omega, Vector.cross(omega, relative_position)) - ) - - # calculate total rotation matrix - rocket_rotation = Matrix.transformation(u[6:10]) - # expected measurement without noise - ax, ay, az = rocket_rotation @ accel - # expected measurement with quantization - az = 2 # saturated - ax = round(ax / 0.4882) * 0.4882 - ay = round(ay / 0.4882) * 0.4882 - az = round(az / 0.4882) * 0.4882 - - # check last measurement considering noise error bounds - quantized_accelerometer.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) - assert quantized_accelerometer.measurement == approx([ax, ay, az], abs=1e-10) - - -def test_quantization_gyroscope(quantized_gyroscope): - """Test the measure method of the Gyroscope class. Checks if saved - measurement is (wx,wy,wz) and if measured_data is [(t, (wx,wy,wz)), ...] - """ - t = SOLUTION_INDEX_200[0] - u = SOLUTION_INDEX_200[1:] - # calculate acceleration at sensor position in inertial frame - relative_position = Vector([0.4, 0.4, 1]) - gravity = 9.81 - omega = Vector(u[10:13]) - # calculate total rotation matrix - rocket_rotation = Matrix.transformation(u[6:10]) - # expected measurement without noise - wx, wy, wz = rocket_rotation @ omega - # expected measurement with quantization - wz = 15 # saturated - wx = round(wx / 0.4882) * 0.4882 - wy = round(wy / 0.4882) * 0.4882 - wz = round(wz / 0.4882) * 0.4882 - - # check last measurement considering noise error bounds - quantized_gyroscope.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) - assert quantized_gyroscope.measurement == approx([wx, wy, wz], abs=1e-10) - - -def test_export_accel_data_csv(ideal_accelerometer): +@pytest.mark.parametrize( + "sensor, expected_string", + [ + ("ideal_accelerometer", "t,ax,ay,az\n"), + ("ideal_gyroscope", "t,wx,wy,wz\n"), + ], +) +def test_export_data_csv(sensor, expected_string, request): """Test the export_data method of accelerometer. Checks if the data is exported correctly. @@ -285,32 +221,29 @@ def test_export_accel_data_csv(ideal_accelerometer): flight_calisto_accel_gyro : Flight Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. """ - t = SOLUTION_INDEX_200[0] - u = SOLUTION_INDEX_200[1:] - relative_position = Vector([0, 0, 0]) - gravity = 9.81 - ideal_accelerometer.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) - ideal_accelerometer.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) + sensor = request.getfixturevalue(sensor) + sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY) + sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY) file_name = "sensors.csv" - ideal_accelerometer.export_measured_data(file_name, format="csv") + sensor.export_measured_data(file_name, format="csv") with open(file_name, "r") as file: contents = file.read() - expected_data = "t,ax,ay,az\n" - for t, ax, ay, az in ideal_accelerometer.measured_data: - expected_data += f"{t},{ax},{ay},{az}\n" + expected_data = expected_string + for t, x, y, z in sensor.measured_data: + expected_data += f"{t},{x},{y},{z}\n" assert contents == expected_data # check exports for accelerometers added more than once to the rocket - ideal_accelerometer.measured_data = [ - ideal_accelerometer.measured_data[:], - ideal_accelerometer.measured_data[:], + sensor.measured_data = [ + sensor.measured_data[:], + sensor.measured_data[:], ] - ideal_accelerometer.export_measured_data(file_name, format="csv") + sensor.export_measured_data(file_name, format="csv") with open(file_name + "_1", "r") as file: contents = file.read() assert contents == expected_data @@ -324,7 +257,14 @@ def test_export_accel_data_csv(ideal_accelerometer): os.remove(file_name + "_2") -def test_export_accel_data_json(ideal_accelerometer): +@pytest.mark.parametrize( + "sensor, expected_string", + [ + ("ideal_accelerometer", ("ax", "ay", "az")), + ("ideal_gyroscope", ("wx", "wy", "wz")), + ], +) +def test_export_data_json(sensor, expected_string, request): """Test the export_data method of the accelerometer. Checks if the data is exported correctly. @@ -334,129 +274,36 @@ def test_export_accel_data_json(ideal_accelerometer): Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. """ - t = SOLUTION_INDEX_200[0] - u = SOLUTION_INDEX_200[1:] - relative_position = Vector([0, 0, 0]) - gravity = 9.81 - ideal_accelerometer.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) - ideal_accelerometer.measure(t, u, U_DOT_INDEX_200, relative_position, gravity) + sensor = request.getfixturevalue(sensor) + sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY) + sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY) file_name = "sensors.json" - ideal_accelerometer.export_measured_data(file_name, format="json") + sensor.export_measured_data(file_name, format="json") contents = json.load(open(file_name, "r")) - expected_data = {"t": [], "ax": [], "ay": [], "az": []} - for t, ax, ay, az in ideal_accelerometer.measured_data: + expected_data = { + "t": [], + expected_string[0]: [], + expected_string[1]: [], + expected_string[2]: [], + } + for t, x, y, z in sensor.measured_data: expected_data["t"].append(t) - expected_data["ax"].append(ax) - expected_data["ay"].append(ay) - expected_data["az"].append(az) + expected_data[expected_string[0]].append(x) + expected_data[expected_string[1]].append(y) + expected_data[expected_string[2]].append(z) assert contents == expected_data # check exports for accelerometers added more than once to the rocket - ideal_accelerometer.measured_data = [ - ideal_accelerometer.measured_data[:], - ideal_accelerometer.measured_data[:], - ] - ideal_accelerometer.export_measured_data(file_name, format="json") - contents = json.load(open(file_name + "_1", "r")) - assert contents == expected_data - - contents = json.load(open(file_name + "_2", "r")) - assert contents == expected_data - - os.remove(file_name) - os.remove(file_name + "_1") - os.remove(file_name + "_2") - - -def test_export_gyro_data_csv(ideal_gyroscope): - """Test the export_data method of the gyroscope. Checks if the data is - exported correctly. - - Parameters - ---------- - flight_calisto_accel_gyro : Flight - Pytest fixture for the flight of the calisto rocket with an ideal - accelerometer and a gyroscope. - """ - t = SOLUTION_INDEX_200[0] - u = SOLUTION_INDEX_200[1:] - relative_position = Vector([0, 0, 0]) - ideal_gyroscope.measure(t, u, U_DOT_INDEX_200, relative_position) - ideal_gyroscope.measure(t, u, U_DOT_INDEX_200, relative_position) - - file_name = "sensors.csv" - - ideal_gyroscope.export_measured_data(file_name, format="csv") - - with open(file_name, "r") as file: - contents = file.read() - - expected_data = "t,wx,wy,wz\n" - for t, wx, wy, wz in ideal_gyroscope.measured_data: - expected_data += f"{t},{wx},{wy},{wz}\n" - - assert contents == expected_data - - # check exports for gyroscopes added more than once to the rocket - ideal_gyroscope.measured_data = [ - ideal_gyroscope.measured_data[:], - ideal_gyroscope.measured_data[:], - ] - ideal_gyroscope.export_measured_data(file_name, format="csv") - with open(file_name + "_1", "r") as file: - contents = file.read() - assert contents == expected_data - - with open(file_name + "_2", "r") as file: - contents = file.read() - assert contents == expected_data - - os.remove(file_name) - os.remove(file_name + "_1") - os.remove(file_name + "_2") - - -def test_export_gyro_data_json(ideal_gyroscope): - """Test the export_data method of the gyroscope. Checks if the data is - exported correctly. - - Parameters - ---------- - flight_calisto_accel_gyro : Flight - Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. - """ - t = SOLUTION_INDEX_200[0] - u = SOLUTION_INDEX_200[1:] - relative_position = Vector([0, 0, 0]) - ideal_gyroscope.measure(t, u, U_DOT_INDEX_200, relative_position) - ideal_gyroscope.measure(t, u, U_DOT_INDEX_200, relative_position) - - file_name = "sensors.json" - - ideal_gyroscope.export_measured_data(file_name, format="json") - - contents = json.load(open(file_name, "r")) - - expected_data = {"t": [], "wx": [], "wy": [], "wz": []} - for t, wx, wy, wz in ideal_gyroscope.measured_data: - expected_data["t"].append(t) - expected_data["wx"].append(wx) - expected_data["wy"].append(wy) - expected_data["wz"].append(wz) - - assert contents == expected_data - - # check exports for gyroscopes added more than once to the rocket - ideal_gyroscope.measured_data = [ - ideal_gyroscope.measured_data[:], - ideal_gyroscope.measured_data[:], + sensor.measured_data = [ + sensor.measured_data[:], + sensor.measured_data[:], ] - ideal_gyroscope.export_measured_data(file_name, format="json") + sensor.export_measured_data(file_name, format="json") contents = json.load(open(file_name + "_1", "r")) assert contents == expected_data From 58859926b4e907f7edda15d4d22ab74f7c34d172 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 6 May 2024 21:04:06 +0200 Subject: [PATCH 56/77] ENH: change format of sensor_data dict --- rocketpy/simulation/flight.py | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-) diff --git a/rocketpy/simulation/flight.py b/rocketpy/simulation/flight.py index 6386157d3..250b909bb 100644 --- a/rocketpy/simulation/flight.py +++ b/rocketpy/simulation/flight.py @@ -1288,6 +1288,7 @@ def __cache_post_process_variables(self): ] def __cache_sensor_data(self): + """Cache sensor data for simulations with sensors.""" sensor_data = {} sensors = [] for sensor in self.sensors: @@ -1295,15 +1296,7 @@ def __cache_sensor_data(self): if sensor not in sensors: sensors.append(sensor) num_instances = sensor._attached_rockets[self.rocket] - # sensor added only once - if num_instances == 1: - sensor_data[sensor] = sensor.measured_data[:] - # sensor added more then once - if num_instances > 1: - sensor_data[sensor] = {} - # iterate through each of the same sensor instances - for index in range(num_instances): - sensor_data[sensor][index + 1] = sensor.measured_data[index][:] + sensor_data[sensor] = sensor.measured_data[:] self.sensor_data = sensor_data @cached_property From 02cad058a996a86aae4b3fdf376685acd582862b Mon Sep 17 00:00:00 2001 From: MateusStano <69485049+MateusStano@users.noreply.github.com> Date: Mon, 6 May 2024 16:05:42 -0300 Subject: [PATCH 57/77] MNT: improve flight init Co-authored-by: Gui-FernandesBR <63590233+Gui-FernandesBR@users.noreply.github.com> --- rocketpy/simulation/flight.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/rocketpy/simulation/flight.py b/rocketpy/simulation/flight.py index 250b909bb..f5d37a323 100644 --- a/rocketpy/simulation/flight.py +++ b/rocketpy/simulation/flight.py @@ -606,11 +606,8 @@ def __init__( self.terminate_on_apogee = terminate_on_apogee self.name = name self.equations_of_motion = equations_of_motion - - # Controller initialization - self.__init_controllers() - # Flight initialization + self.__init_controllers() self.__init_post_process_variables() self.__init_solution_monitors() self.__init_equations_of_motion() From 69f17cdfa33a3dba0f61a9d2ba48c807dfcddac4 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 6 May 2024 21:15:23 +0200 Subject: [PATCH 58/77] TST: increase rel tolerances --- tests/unit/test_sensors.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensors.py index 07ed01f65..4e08dfcea 100644 --- a/tests/unit/test_sensors.py +++ b/tests/unit/test_sensors.py @@ -199,9 +199,9 @@ def test_noisy_rotated_gyroscope(noisy_rotated_gyroscope): # check last measurement considering noise error bounds noisy_rotated_gyroscope.measure(TIME, U, U_DOT, relative_position, GRAVITY) - assert noisy_rotated_gyroscope.measurement == approx([wx, wy, wz], rel=0.2) + assert noisy_rotated_gyroscope.measurement == approx([wx, wy, wz], rel=0.3) assert len(noisy_rotated_gyroscope.measurement) == 3 - assert noisy_rotated_gyroscope.measured_data[0][1:] == approx([wx, wy, wz], rel=0.2) + assert noisy_rotated_gyroscope.measured_data[0][1:] == approx([wx, wy, wz], rel=0.3) assert noisy_rotated_gyroscope.measured_data[0][0] == TIME From 8d96e58a284148ac60e2d8a86848668946e02535 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 6 May 2024 21:21:31 +0200 Subject: [PATCH 59/77] TST: fix export sensor data test --- tests/unit/test_flight.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/unit/test_flight.py b/tests/unit/test_flight.py index 59368c268..10ecbe4fe 100644 --- a/tests/unit/test_flight.py +++ b/tests/unit/test_flight.py @@ -317,11 +317,11 @@ def test_export_sensor_data(flight_calisto_accel_gyro): for measurement in flight_calisto_accel_gyro.sensors[2].measured_data ] assert ( - sensor_data["Accelerometer"]["1"] + sensor_data["Accelerometer"][0] == flight_calisto_accel_gyro.sensors[0].measured_data[0] ) assert ( - sensor_data["Accelerometer"]["2"] + sensor_data["Accelerometer"][1] == flight_calisto_accel_gyro.sensors[1].measured_data[1] ) assert ( From ec4e25ea354fe628a9cf7120d60223333234fd01 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 6 May 2024 23:16:16 +0200 Subject: [PATCH 60/77] TST: fix doctests --- rocketpy/mathutils/vector_matrix.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rocketpy/mathutils/vector_matrix.py b/rocketpy/mathutils/vector_matrix.py index 14ea9ba54..5157f5463 100644 --- a/rocketpy/mathutils/vector_matrix.py +++ b/rocketpy/mathutils/vector_matrix.py @@ -1058,8 +1058,8 @@ def transformation_euler_angles(roll, pitch, yaw): >>> M = Matrix.transformation_euler_angles(90, 0, 0) >>> M - Matrix([-2.220446049250313e-16, -1, 0.0], - [1, -2.220446049250313e-16, 0.0], + Matrix([-2.220446049250313e-16, -1.0, 0.0], + [1.0, -2.220446049250313e-16, 0.0], [0.0, 0.0, 1.0]) """ return Matrix.transformation(euler_to_quaternions(roll, pitch, yaw)) From adb2dbbac406cd2dccf4be22f1ff076f10d573c2 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 6 May 2024 23:35:03 +0200 Subject: [PATCH 61/77] TST: fix doctests --- rocketpy/mathutils/vector_matrix.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rocketpy/mathutils/vector_matrix.py b/rocketpy/mathutils/vector_matrix.py index 5157f5463..8a59469b5 100644 --- a/rocketpy/mathutils/vector_matrix.py +++ b/rocketpy/mathutils/vector_matrix.py @@ -1058,8 +1058,8 @@ def transformation_euler_angles(roll, pitch, yaw): >>> M = Matrix.transformation_euler_angles(90, 0, 0) >>> M - Matrix([-2.220446049250313e-16, -1.0, 0.0], - [1.0, -2.220446049250313e-16, 0.0], + Matrix([2.220446049250313e-16, -1.0, 0.0], + [1.0, 2.220446049250313e-16, 0.0], [0.0, 0.0, 1.0]) """ return Matrix.transformation(euler_to_quaternions(roll, pitch, yaw)) From e0812a2244c7e6b5710e502e8cea8c3125e89c32 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 9 May 2024 13:36:39 +0200 Subject: [PATCH 62/77] ENH: change units in prints --- rocketpy/prints/sensors_prints.py | 10 +--------- rocketpy/sensors/accelerometer.py | 2 ++ rocketpy/sensors/gyroscope.py | 2 ++ 3 files changed, 5 insertions(+), 9 deletions(-) diff --git a/rocketpy/prints/sensors_prints.py b/rocketpy/prints/sensors_prints.py index 40d66d2bb..9ec0e492d 100644 --- a/rocketpy/prints/sensors_prints.py +++ b/rocketpy/prints/sensors_prints.py @@ -1,18 +1,10 @@ from abc import ABC, abstractmethod -UNITS = { - "Gyroscope": "rad/s", - "Accelerometer": "m/s^2", - "Magnetometer": "T", - "PressureSensor": "Pa", - "TemperatureSensor": "K", -} - class _SensorsPrints(ABC): def __init__(self, sensor): self.sensor = sensor - self.units = UNITS[sensor.__class__.__name__] + self.units = sensor.__units__ def _print_aligned(self, label, value): """Prints a label and a value aligned vertically.""" diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 35c501792..29fe7f0ec 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -61,6 +61,8 @@ class Accelerometer(Sensors): temperature drift. """ + __units__ = "m/s^2" + def __init__( self, sampling_rate, diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index 743b80c21..0f8629d77 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -61,6 +61,8 @@ class Gyroscope(Sensors): temperature drift. """ + __units__ = "rad/s" + def __init__( self, sampling_rate, From 6ec4c0ba2cbb318c426309313c95e748fc29602e Mon Sep 17 00:00:00 2001 From: MateusStano Date: Fri, 10 May 2024 14:01:16 +0200 Subject: [PATCH 63/77] ENH: add .round to Matrix and remove broken doctests --- rocketpy/mathutils/vector_matrix.py | 55 +++++++++++++++++++++-------- rocketpy/sensors/sensors.py | 6 +++- rocketpy/tools.py | 31 ++++++++-------- 3 files changed, 62 insertions(+), 30 deletions(-) diff --git a/rocketpy/mathutils/vector_matrix.py b/rocketpy/mathutils/vector_matrix.py index 8a59469b5..c10ec5faf 100644 --- a/rocketpy/mathutils/vector_matrix.py +++ b/rocketpy/mathutils/vector_matrix.py @@ -949,6 +949,47 @@ def dot(self, other): """ return self.__matmul__(other) + def round(self, decimals=0): + """Round the matrix to a given number of decimals. + + Parameters + ---------- + decimals : int, optional + Number of decimal places to round to. Defaults to 0. + + Returns + ------- + Matrix + The rounded matrix. + + Examples + -------- + >>> M = Matrix([[1.1234, 2.3456, 3.4567], [4.5678, 5.6789, 6.7890], [7.8901, 8.9012, 9.0123]]) + >>> M.round(2) + Matrix([1.12, 2.35, 3.46], + [4.57, 5.68, 6.79], + [7.89, 8.9, 9.01]) + """ + return Matrix( + [ + [ + round(self.xx, decimals), + round(self.xy, decimals), + round(self.xz, decimals), + ], + [ + round(self.yx, decimals), + round(self.yy, decimals), + round(self.yz, decimals), + ], + [ + round(self.zx, decimals), + round(self.zy, decimals), + round(self.zz, decimals), + ], + ] + ) + def __str__(self): return ( f"[{self.xx}, {self.xy}, {self.xz}]\n" @@ -1047,20 +1088,6 @@ def transformation_euler_angles(roll, pitch, yaw): ------- Matrix The transformation matrix from frame B to frame A. - - Examples - -------- - >>> M = Matrix.transformation_euler_angles(0, 0, 0) - >>> M - Matrix([1.0, 0.0, 0.0], - [0.0, 1.0, 0.0], - [0.0, 0.0, 1.0]) - - >>> M = Matrix.transformation_euler_angles(90, 0, 0) - >>> M - Matrix([2.220446049250313e-16, -1.0, 0.0], - [1.0, 2.220446049250313e-16, 0.0], - [0.0, 0.0, 1.0]) """ return Matrix.transformation(euler_to_quaternions(roll, pitch, yaw)) diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index 2196b25bc..d3d7f16d8 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -87,6 +87,8 @@ def __init__( standard rotation sequence is z-y-x (3-2-1) is used, meaning the sensor is first rotated by ψ around the z axis, then by θ around the new y axis and finally by φ around the new x axis. + TODO: x and y are not defined in the rocket class. User has no + way to know which axis is which. - A list of lists (matrix) of shape 3x3, representing the rotation matrix from the sensor frame to the rocket frame. The sensor frame of reference is defined as to have z axis along the sensor's normal @@ -206,7 +208,9 @@ def __init__( if any(isinstance(row, (tuple, list)) for row in orientation): # matrix self.rotation_matrix = Matrix(orientation) elif len(orientation) == 3: # euler angles - self.rotation_matrix = Matrix.transformation_euler_angles(*orientation) + self.rotation_matrix = Matrix.transformation_euler_angles( + *orientation + ).round(12) else: raise ValueError("Invalid orientation format") self.normal_vector = Vector( diff --git a/rocketpy/tools.py b/rocketpy/tools.py index 9941d3793..213225410 100644 --- a/rocketpy/tools.py +++ b/rocketpy/tools.py @@ -3,6 +3,7 @@ import importlib.metadata import re import time +import math from bisect import bisect_left import numpy as np @@ -467,33 +468,33 @@ def quaternions_to_nutation(e1, e2): return (180 / np.pi) * 2 * np.arcsin(-((e1**2 + e2**2) ** 0.5)) -def euler_to_quaternions(roll, pitch, yaw): +def euler_to_quaternions(yaw, pitch, roll): """Calculates the quaternions (Euler parameters) from the Euler angles in - 3-2-1 sequence. + yaw, pitch, and roll sequence (3-2-1). Parameters ---------- - roll : float - Euler angle due to roll (psi) in degrees - pitch : float - Euler angle due to pitch (theta) in degrees yaw : float Euler angle due to yaw (phi) in degrees + pitch : float + Euler angle due to pitch (theta) in degrees + roll : float + Euler angle due to roll (psi) in degrees Returns ------- tuple Tuple containing the Euler parameters e0, e1, e2, e3 """ - psi = np.radians(roll) - theta = np.radians(pitch) - phi = np.radians(yaw) - cr = np.cos(phi / 2) - sr = np.sin(phi / 2) - cp = np.cos(theta / 2) - sp = np.sin(theta / 2) - cy = np.cos(psi / 2) - sy = np.sin(psi / 2) + phi = math.radians(yaw) + theta = math.radians(pitch) + psi = math.radians(roll) + cr = math.cos(phi / 2) + sr = math.sin(phi / 2) + cp = math.cos(theta / 2) + sp = math.sin(theta / 2) + cy = math.cos(psi / 2) + sy = math.sin(psi / 2) e0 = cr * cp * cy + sr * sp * sy e1 = sr * cp * cy - cr * sp * sy e2 = cr * sp * cy + sr * cp * sy From 78e67f240f3cf289f104df6e5206717f063bb8b5 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Fri, 10 May 2024 14:01:33 +0200 Subject: [PATCH 64/77] TST: test transfromation euler angles --- tests/unit/test_tools_matrix.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/tests/unit/test_tools_matrix.py b/tests/unit/test_tools_matrix.py index b43818450..bd33c4940 100644 --- a/tests/unit/test_tools_matrix.py +++ b/tests/unit/test_tools_matrix.py @@ -242,3 +242,21 @@ def test_matrix_transformation(): q1, q2, q3 = np.sin(phi / 2) * n matrix = Matrix.transformation((q0, q1, q2, q3)) assert matrix @ Vector([0, 0, 1]) == Vector([0, -1, 0]) + + +def test_matrix_transformation_euler_angles(): + phi = 90 + theta = 0 + psi = 0 + matrix = Matrix.transformation_euler_angles(phi, theta, psi) + matrix = matrix.round(12) + # Check that the matrix is orthogonal + assert matrix @ matrix.transpose == Matrix.identity() + # Check that the matrix rotates the vector correctly + assert matrix @ Vector([0, 0, 1]) == Vector([0, -1, 0]) + + +def test_matrix_round(): + matrix = [[2e-10, -2e-10, 0], [5.1234, -5.1234, 0], [0, 0, 9]] + matrix = Matrix(matrix).round(3) + assert matrix == Matrix([[0, 0, 0], [5.123, -5.123, 0], [0, 0, 9]]) From d49b5c48d599244672497b1863ad21ccf81c2c28 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Fri, 10 May 2024 14:03:21 +0200 Subject: [PATCH 65/77] TST: imrpove test_euler_to_quaternions --- tests/unit/test_tools.py | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/tests/unit/test_tools.py b/tests/unit/test_tools.py index e1692720b..476451c85 100644 --- a/tests/unit/test_tools.py +++ b/tests/unit/test_tools.py @@ -4,14 +4,13 @@ from rocketpy.tools import euler_to_quaternions -def test_euler_to_quaternions(): - q0, q1, q2, q3 = euler_to_quaternions(0, 0, 0) - assert q0 == 1 - assert q1 == 0 - assert q2 == 0 - assert q3 == 0 - q0, q1, q2, q3 = euler_to_quaternions(90, 90, 90) - assert round(q0, 7) == 0.7071068 - assert round(q1, 7) == 0 - assert round(q2, 7) == 0.7071068 - assert round(q3, 7) == 0 +@pytest.mark.parametrize( + "angles, expected_quaternions", + [((0, 0, 0), (1, 0, 0, 0)), ((90, 90, 90), (0.7071068, 0, 0.7071068, 0))], +) +def test_euler_to_quaternions(angles, expected_quaternions): + q0, q1, q2, q3 = euler_to_quaternions(*angles) + assert round(q0, 7) == expected_quaternions[0] + assert round(q1, 7) == expected_quaternions[1] + assert round(q2, 7) == expected_quaternions[2] + assert round(q3, 7) == expected_quaternions[3] From 57b41ab641faeed4c2d28f3db84aaf2a4302dec1 Mon Sep 17 00:00:00 2001 From: Gui-FernandesBR Date: Wed, 15 May 2024 06:20:53 -0400 Subject: [PATCH 66/77] DEV: update sensors_testing notebook --- docs/notebooks/sensors_testing.ipynb | 448 ++++++++------------------- 1 file changed, 121 insertions(+), 327 deletions(-) diff --git a/docs/notebooks/sensors_testing.ipynb b/docs/notebooks/sensors_testing.ipynb index 797dcb232..842558dbd 100644 --- a/docs/notebooks/sensors_testing.ipynb +++ b/docs/notebooks/sensors_testing.ipynb @@ -15,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", @@ -23,12 +23,15 @@ }, "outputs": [], "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", "from rocketpy import Environment, SolidMotor, Rocket, Flight" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", @@ -41,74 +44,13 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "5kl-Je8dNVFI" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Gravity Details\n", - "\n", - "Acceleration of gravity at surface level: 9.7913 m/s²\n", - "Acceleration of gravity at 10.000 km (ASL): 9.7649 m/s²\n", - "\n", - "\n", - "Launch Site Details\n", - "\n", - "Launch Site Latitude: 32.99025°\n", - "Launch Site Longitude: -106.97500°\n", - "Reference Datum: SIRGAS2000\n", - "Launch Site UTM coordinates: 315468.64 W 3651938.65 N\n", - "Launch Site UTM zone: 13S\n", - "Launch Site Surface Elevation: 1400.0 m\n", - "\n", - "\n", - "Atmospheric Model Details\n", - "\n", - "Atmospheric Model Type: custom_atmosphere\n", - "custom_atmosphere Maximum Height: 10.000 km\n", - "\n", - "\n", - "Surface Atmospheric Conditions\n", - "\n", - "Surface Wind Speed: 4.69 m/s\n", - "Surface Wind Direction: 219.81°\n", - "Surface Wind Heading: 39.81°\n", - "Surface Pressure: 856.02 hPa\n", - "Surface Temperature: 279.07 K\n", - "Surface Air Density: 1.069 kg/m³\n", - "Surface Speed of Sound: 334.55 m/s\n", - "\n", - "\n", - "Earth Model Details\n", - "\n", - "Earth Radius at Launch site: 6371.83 km\n", - "Semi-major Axis: 6378.14 km\n", - "Semi-minor Axis: 6356.75 km\n", - "Flattening: 0.0034\n", - "\n", - "\n", - "Atmospheric Model Plots\n", - "\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "env = Environment(latitude=32.990254, longitude=-106.974998, elevation=1400)\n", "env.set_atmospheric_model(\n", @@ -119,7 +61,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", @@ -149,7 +91,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", @@ -194,177 +136,97 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from rocketpy import Accelerometer, Gyroscope\n", - "accel_noisy_nosecone = Accelerometer(sampling_rate=100,\n", - " consider_gravity=False,\n", - " orientation=(60,60,60),\n", - " measurement_range=70,\n", - " resolution=0.4882,\n", - " noise_density=0.05,\n", - " random_walk=0.02,\n", - " constant_bias=1 ,\n", - " operating_temperature=25,\n", - " temperature_bias=0.02,\n", - " temperature_scale_factor=0.02,\n", - " cross_axis_sensitivity=0.02,\n", - " name='Accelerometer in Nosecone'\n", - " )\n", - "accel_clean_cdm = Accelerometer(sampling_rate=100,\n", - " consider_gravity=False,\n", - " orientation=[[0.25, -0.0581, 0.9665],\n", - " [0.433, 0.8995, -0.0581],\n", - " [-0.8661, 0.433, 0.25]\n", - " ],\n", - " name='Accelerometer in CDM'\n", - " )\n", + "\n", + "accel_noisy_nosecone = Accelerometer(\n", + " sampling_rate=100,\n", + " consider_gravity=False,\n", + " orientation=(60, 60, 60),\n", + " measurement_range=70,\n", + " resolution=0.4882,\n", + " noise_density=0.05,\n", + " random_walk_density=0.02,\n", + " constant_bias=1,\n", + " operating_temperature=25,\n", + " temperature_bias=0.02,\n", + " temperature_scale_factor=0.02,\n", + " cross_axis_sensitivity=0.02,\n", + " name=\"Accelerometer in Nosecone\",\n", + ")\n", + "accel_clean_cdm = Accelerometer(\n", + " sampling_rate=100,\n", + " consider_gravity=False,\n", + " orientation=[\n", + " [0.25, -0.0581, 0.9665],\n", + " [0.433, 0.8995, -0.0581],\n", + " [-0.8661, 0.433, 0.25],\n", + " ],\n", + " name=\"Accelerometer in CDM\",\n", + ")\n", "calisto.add_sensor(accel_noisy_nosecone, 1.278)\n", - "calisto.add_sensor(accel_clean_cdm, -0.10482544178314143)#, 127/2000)\n" + "calisto.add_sensor(accel_clean_cdm, -0.10482544178314143) # , 127/2000)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Identification of the Sensor:\n", - "\n", - "Name: Accelerometer in Nosecone\n", - "Type: Accelerometer\n", - "\n", - "Orientation of the Sensor:\n", - "\n", - "Orientation: (60, 60, 60)\n", - "Normal Vector: (0.9665063509461097, -0.05801270189221941, 0.2500000000000002)\n", - "Rotation Matrix:\n", - " [0.25, -0.06, 0.97]\n", - " [0.43, 0.9, -0.06]\n", - " [-0.87, 0.43, 0.25]\n", - "\n", - "Quantization of the Sensor:\n", - "\n", - "Measurement Range: -70 to 70 (m/s^2)\n", - "Resolution: 0.4882 m/s^2/LSB\n", - "\n", - "Noise of the Sensor:\n", - "\n", - "Noise Density: (0.05, 0.05, 0.05) m/s^2/√Hz\n", - "Random Walk: (0.02, 0.02, 0.02) m/s^2/√Hz\n", - "Constant Bias: (1, 1, 1) m/s^2\n", - "Operating Temperature: 25 °C\n", - "Temperature Bias: (0.02, 0.02, 0.02) m/s^2/°C\n", - "Temperature Scale Factor: (0.02, 0.02, 0.02) %/°C\n", - "Cross Axis Sensitivity: 0.02 %\n", - "Identification of the Sensor:\n", - "\n", - "Name: Accelerometer in CDM\n", - "Type: Accelerometer\n", - "\n", - "Orientation of the Sensor:\n", - "\n", - "Orientation: [[0.25, -0.0581, 0.9665], [0.433, 0.8995, -0.0581], [-0.8661, 0.433, 0.25]]\n", - "Normal Vector: (0.9665010341566599, -0.05810006216709978, 0.25000026750042936)\n", - "Rotation Matrix:\n", - " [0.25, -0.06, 0.97]\n", - " [0.43, 0.9, -0.06]\n", - " [-0.87, 0.43, 0.25]\n", - "\n", - "Quantization of the Sensor:\n", - "\n", - "Measurement Range: -inf to inf (m/s^2)\n", - "Resolution: 0 m/s^2/LSB\n", - "\n", - "Noise of the Sensor:\n", - "\n", - "Noise Density: (0, 0, 0) m/s^2/√Hz\n", - "Random Walk: (0, 0, 0) m/s^2/√Hz\n", - "Constant Bias: (0, 0, 0) m/s^2\n", - "Operating Temperature: 25 °C\n", - "Temperature Bias: (0, 0, 0) m/s^2/°C\n", - "Temperature Scale Factor: (0, 0, 0) %/°C\n", - "Cross Axis Sensitivity: 0 %\n" - ] - } - ], + "outputs": [], "source": [ "accel_noisy_nosecone.prints.all()\n", - "accel_clean_cdm.prints.all() # should have the same rotation matrix" + "accel_clean_cdm.prints.all() # should have the same rotation matrix" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "gyro_clean = Gyroscope(sampling_rate=100)\n", - "gyro_noisy = Gyroscope(sampling_rate=100, \n", - " orientation=(180, 0, 0),\n", - " acceleration_sensitivity=0.02,\n", - " measurement_range=70,\n", - " resolution=0.4882,\n", - " noise_density=0.05,\n", - " random_walk=0.02,\n", - " constant_bias=1 ,\n", - " operating_temperature=25,\n", - " temperature_bias=0.02,\n", - " temperature_scale_factor=0.02,\n", - " cross_axis_sensitivity=0.02,\n", - " )\n", - "calisto.add_sensor(gyro_clean, -0.10482544178314143+0.5, 127/2000)\n", - "calisto.add_sensor(gyro_noisy, 1.278-0.4, 127/2000-127/4000)" + "gyro_noisy = Gyroscope(\n", + " sampling_rate=100,\n", + " orientation=(180, 0, 0),\n", + " acceleration_sensitivity=0.02,\n", + " measurement_range=70,\n", + " resolution=0.4882,\n", + " noise_density=0.05,\n", + " random_walk_density=0.02,\n", + " constant_bias=1,\n", + " operating_temperature=25,\n", + " temperature_bias=0.02,\n", + " temperature_scale_factor=0.02,\n", + " cross_axis_sensitivity=0.02,\n", + ")\n", + "calisto.add_sensor(gyro_clean, -0.10482544178314143 + 0.5, 127 / 2000)\n", + "calisto.add_sensor(gyro_noisy, 1.278 - 0.4, 127 / 2000 - 127 / 4000)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxUAAADxCAYAAAC9IJoDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACaOUlEQVR4nOzddVhW5//A8Tfd3UoLWCAIdk9UNjuwnR0zZ3znZis2zs65qcOZs3V24pyK3VgIijMoAen8/cGPMx8JeRBE5H5dF5dy4j6f8+ERz33uUoiKispEEARBEARBEAShkBRLOgBBEARBEARBEEo3UakQBEEQBEEQBOGjiEqFIAiCIAiCIAgfRVQqBEEQBEEQBEH4KKJSIQiCIAiCIAjCRxGVCkEQBEEQBEEQPoqoVAiCIAiCIAiC8FFEpUIQBEEQBEEQhI8iKhWCIAiCIAiCIHwUUakQhM/cli1bMDQ05Pr16yUdivAZePbsGYaGhmzZsqWkQxEEQRAEiahUCEIBZT/cZ3+ZmJhQtWpVhg8fzosXL0o6vAJbtGgRBw8eLNCx2Q+w2V9GRkbY29vTuXNnLl26VMyRll73799n3rx5PHv2rNBl7Ny5k9WrVxdhVIIgCIJQfJRLOgBBKG0mTJiAjY0NSUlJXLlyha1bt3Lx4kX++ecf1NXVSzq8D1q8eDFt27alVatWBT6nU6dONG/enPT0dIKCgli3bh3t2rXj5MmTVKlSpRijLZ0ePHiAr68vDRo0wNraulBl7Ny5k8DAQIYOHSqz3crKihcvXqCiolIUoQqCIAhCkRCVCkGQU7NmzahevToAvXv3xsjIiKVLl3L48GE6dOhQwtEVj2rVqtGlSxfp+zp16tClSxfWr1/Pzz///EljiY+PR0tL65Ne83OioKBQKiqvgiAIQtkiuj8JwkeqW7cuACEhITLbz549S8uWLbG0tMTW1paePXvy4MGDHOe/ePGCkSNHUqVKFczNzXFzc2PcuHGkpKTkec3o6GiaNWtG1apVefToEQDJycnMnTsXDw8PzM3NcXZ2Ztq0aSQnJ0vnGRoaEh8fz9atW6UuTcOHDy/0PQcHB8tsj4mJYcKECTg7O2Nubo6HhwdLly4lIyNDOia7S9Xy5ctZtWoV1apVo1y5crRu3Zp79+7JlDd8+HCsrKwIDg6mS5cuWFtbM2TIEAAyMjJYvXo1devWxcLCgooVKzJmzBiio6Nlyrh+/TqdOnXCwcGBcuXK4ebmxogRI2SOKWhZrq6udOvWjYsXL9KsWTMsLCyoXr0627Ztk47ZsmUL/fr1A6Bt27ZSns+dOwfAoUOH6Nq1q/Tzdnd3Z8GCBaSnp0tltGnThmPHjhEaGiqd7+rqKpO/98dUFOTzNm/ePAwNDXny5AnDhw/H1tYWGxsbhg8fTkJCAoIgCIJQWKKlQhA+Una/eX19fWnbmTNn6NKlC7a2towfP56kpCR+/fVXvvnmG86cOSN1iXn58iXNmzcnJiaG3r174+TkxIsXL9i/fz+JiYmoqqrmuF5kZCQdO3bkzZs3/PXXX9jZ2ZGRkUGPHj0ICAiQygkMDGT16tUEBQWxadMmANasWcP333+Pu7s7ffr0AcDW1rZI7jkhIYHWrVvz8uVL+vbti6WlJZcuXcLHx4dXr14xd+5cmTK2b99OXFwcAwcOJCkpiV9++YX27dtz7tw5TE1NpePS0tLw9vamTp06+Pj4oKGhAcCYMWPYunUrPXr0YMiQITx9+pTffvuN27dvc/jwYVRUVAgPD6dTp04YGxvz/fffo6enR2hoKAcOHJCJpSBlZQsODqZv37706tWLbt26sXnzZoYPH46rqyuVK1emXr16DB48mLVr1zJ27FicnJwApD+3bt2KlpYWQ4cORVtbm7NnzzJ37lzevn2Lj48PAGPHjiU2NpYXL14we/ZsgHxbZwr6ecvWv39/rK2tmTp1Kjdv3uSPP/7AxMSE6dOnf/BnLwiCIAi5EZUKQZBTbGwskZGRJCUlcfXqVXx9fVFTU6NFixbSMdOmTcPAwICjR49iYGAAQKtWrWjcuDHz5s1j1apVAMycOZPXr19z/PhxqUsVwMSJE8nMzMxx7devX9OhQweSkpI4ePAgVlZWQFb/e39/f/766y/q1KkjHV+5cmXGjh1LQEAAtWvXpkuXLowbNw5bW1uZ7kwfkpiYSGRkJOnp6Tx58oTJkycDWW/is61atYqQkBDOnDlDhQoVAOjbty/m5uYsX76c4cOHY2lpKR0fHBzM5cuXKVeuHACenp40b96cpUuXSg/SkNUC065dO6ZOnSptu3jxIn/88Qdr167F29tb2t6gQQM6d+7Mvn378Pb25tKlS0RHR7Nr1y6Z/E6aNEnusrI9evSIgwcPSq017du3x8XFhS1btjBz5kxsbW2pW7cua9eupUmTJjRo0EAml2vXrpUqRgD9+vVj7NixrF+/nkmTJqGmpsZXX33FL7/8QnR0dIF+TgX9vGVzcXFh+fLl0vdv3rxh06ZNolIhCIIgFJro/iQIcurQoQOOjo64uLjQt29fNDU12bx5M+XLlwfg1atX3L59m+7du0sPeABVq1alSZMmHD9+HMjqcnPw4EG+/vprmQfebAoKCjLfv3jxgjZt2pCWlsZff/0lVSgA9u3bh5OTE46OjkRGRkpfDRs2BJC63hTWvHnzcHR0pFKlSrRs2ZKHDx8yc+ZM2rVrJxNDnTp10NfXl4mhcePGpKenc+HCBZkyW7ZsKVUoADw8PPDw8ODEiRM5rt+/f3+Z7/fu3Yuuri5NmjSRuZabmxva2tr8/fffAOjp6QFw9OhRUlNTc723gpaVrWLFilKFAsDY2BgHBweePn1akFTKVCjevn1LZGQkdevWJSEhQerKJo+Cft7eld09K1udOnWIiooiNjZW7usLgiAIAoiWCkGQ24IFC6hQoQKxsbFs3ryZCxcuoKamJu0PDQ0FwMHBIce5Tk5OnDp1ivj4eOLj43n79i2VK1cu0HWHDh2KkpISFy9exMzMTGZfUFAQDx8+xNHRMddzw8PDC3p7uerTpw/t2rUjOTmZs2fPsnbtWpkxAABPnjzh7t27BY7B3t4+xzEODg7s3btXZpuysrJM5SP7WrGxsVKXovdFREQAUL9+fdq0aYOvry+rV6+mQYMGtGzZEm9vb+lnVtCysr3b2pJNX18/x/iLvAQGBjJnzhzOnj3L27dvZfYV5qG+oJ+3d7tPvX8P2d3YYmJi0NXVlTsGQRAEQRCVCkGQk7u7u9Sy0KpVK7755hsGDx5MQEAA2traxXbd1q1bs23bNn755ReZrkAAmZmZVKlShVmzZuV6bnYrSmHZ29vTpEkTALy8vFBSUsLHx4eGDRtKucjIyKBJkyaMGjUq1zJye+gtCDU1NRQVZRtVMzIyMDEx4Zdffsn1HGNjYyCrtcfPz4/Lly9z9OhRTp06xciRI1m5ciXHjh1DW1u7wGVlU1JSyvW43LqrvS8mJoY2bdqgo6PDhAkTsLOzQ01NjVu3bjF9+nSZAe3F6WPuQRAEQRByIyoVgvARlJSUmDp1Km3btuW3335j9OjRUrekx48f5zj+0aNHGBkZoaWlhYaGBjo6OgQGBhboWoMGDcLOzo65c+eiq6vL6NGjpX22trbcuXOHxo0b5+g29b4P7S+IcePGsXHjRmbPns3OnTulGOLj46XKx4c8efIkx7bHjx8XaF0HOzs7/P39qV27tkx3orzUrFmTmjVrMnnyZHbu3MngwYPZvXs3vXv3lrusgsgrx+fOnSMqKoqNGzdSr149aXtuXacK+nMq6OdNEARBEIqTGFMhCB+pQYMGuLu7s2bNGpKSkjA3N8fFxYVt27YRExMjHXfv3j1Onz5N8+bNAVBUVKRVq1YcOXKE69ev5yg3t7fGP/zwAyNGjMDHx4f169dL29u3b8/Lly/x8/PLcU5iYiLx8fHS95qamjJxFYaenh59+/bl1KlT3L59W4rh8uXLnDx5MsfxMTExpKWlyWw7dOiQzErkV69e5erVq3h6en7w+u3btyc9PT3XNTLS0tKk+4uOjs6RR2dnZwBpyt6CliUPTU1NgBznZrcQvBtTSkqKzM/y3TIK0h2qoJ83QRAEQShOoqVCEIrAyJEj6devH1u3bqVfv37MmDGDLl260KJFC3r16iVN8amrq8uPP/4onTd58mROnz5NmzZtpKlgX79+zb59+zh8+LA00PhdPj4+xMbG8sMPP6CtrU2XLl3o2rUre/fuZdy4cZw7d47atWuTnp7Oo0eP2Lt3Lzt37pS6Kbm6uuLv78/KlSsxNzfHxsaGGjVqyH3PQ4YMYc2aNSxZsoR169YxcuRIjhw5Qvfu3enevTtubm7Ex8cTGBjI/v37uXHjBkZGRtL5dnZ2tGzZkv79+5OcnMyaNWswNDTMs/vUu+rXr0/fvn1ZvHgxt2/f5quvvkJFRYWgoCD279/PnDlzaNeuHVu3bmX9+vW0atUKW1tb4uLi+OOPP9DR0ZEetgtaljxcXFxQUlJi6dKlxMbGoqqqSqNGjahVqxb6+voMGzaMwYMHo6CgwJ9//plrBdLV1ZU9e/YwadIk3N3d0dLS4uuvv871egX9vAmCIAhCcRGVCkEoAm3atMHOzo4VK1bQu3dvmjRpwo4dO5g3bx7z5s1DWVmZ+vXrM23aNGxsbKTzypUrx/Hjx5kzZw47d+7k7du3WFhY0KxZs3y74ixatIj4+HhGjBiBtrY2LVu2ZNOmTaxevZpt27Zx8OBBNDQ0sLW1ZciQIdIUrwCzZs1izJgxzJkzh8TERLp3716oSoWFhQWdOnXizz//JDg4GDs7Ow4cOMDixYvZt28f27dvR0dHhwoVKvDjjz/mGADctWtXFBUVWbNmDREREbi7u+Pr64u5uXmBrr9o0SJcXV3x8/Nj1qxZKCkpYW1tTefOnalduzaQVWG4du0au3fvJjw8HF1dXdzd3fnll19kfg4FKUseZmZmLFy4kCVLljBq1CjS09PZv38/DRo0YOvWrUyZMoU5c+agr69P586dadSokcy0tQADBgzgzp07bNmyhdWrV2NlZZVnpaKgnzdBEARBKC4KUVFRYmSeIAifzLNnz3Bzc2PGjBmMHDmypMMRBEEQBKEIiDEVgiAIgiAIgiB8FFGpEARBEARBEATho4hKhSAIgiAIgiAIH0WMqRAEQRAEQRAE4aOIlgpBEARBEARBED6KmFK2CGRkZPDy5Uu0tbWLZLViQRAEQSgOmZmZxMXFYWFhgaKieK8oCELREZWKIvDy5UtcXFxKOgxBEARBKJDbt29Tvnz5kg5DEIQviKhUFAFtbW0AQkNDcyzw9aW5cuVKoRZKK8tEzuQnciY/kTP5lcWcxcbGYmVlJf2/JQiCUFREpaIIZHd50tXV/eIrFSYmJl/8PRY1kTP5iZzJT+RMfmU5Z6KrriAIRU10qBTkUqlSpZIOodQROZOfyJn8RM7kJ3ImCIJQdESlQpDLtWvXSjqEUkfkTH4iZ/ITOZOfyJkgCELREZUKQRAEQRAEQRA+ihhTIcjF0tKypEModUTO5CdyJj+RM/mJnH16GRkZpKWllXQYgiAUgLKyslxTT4tKhSAXZWXxkZGXyJn8RM7kJ3ImP5GzTyczM5Po6GgSEhLEIHFBKCUyMzPR1NREX1+/QP9uxW9UQS4hISGYmZmVdBilisiZ/ETO5CdyJj+Rs08nOjqaxMRETE1N0dDQEBULQfjMZWZmkpiYSHh4OAAGBgYfPEdUKgRBEARBKDYZGRkkJCRgamqKoaFhSYcjCEIBaWhoABAWFoaent4Hu0KJgdqCXMTK4fITOZOfyJn8RM7kJ3L2aaSlpaGgoCA9oAiCUHpktywWZCyUqFQIcnn27FlJh1DqiJzJT+RMfiJn8hM5+7RElydBKH3k+XcrKhWCXGJiYko6hFJH5Ex+ImfyEzmTn8iZIAhC0RGVCkEu6urqJR1CqSNyJj+RM/mJnMlP5EwQBKHoFKpSkZqayvPnz3n06BFv3rwp6piEz5izs3NJh1DqiJzJT+RMfiJn8hM5E0pa//796dSpU0mH8cVISEigS5cuGBoaoqKiQnR0dEmHVKYUuFLx9u1b1q9fT+vWrbGxscHNzY06derg6OhItWrV+P7777l27Vpxxip8Bq5cuVLSIZQ6ImfyEzmTn8iZ/ETOhA959eoVY8aMoVKlSmhra1O+fHkaNWrEmjVrSEhI+OjyFy9ezLp164og0rylpKTw888/4+7ujq6uLubm5jRq1Ijff/+d1NTUIruOj48PHh4eRVZeYWzcuJFz585x9uxZQkND0dPTy3GMn58fKioquU7UsHPnTlRUVHBwcPgU4X5xCjSl7MqVK1m0aBF2dnZ4eXkxZswYLCwsUFdX582bNwQGBnLhwgU6deqEh4cH8+fPp0KFCsUduyAIgiAIQrF48uQJjRs3Rl9fn5kzZ+Ls7Iyamhp37tzht99+o3z58rRp0ybXc1NTU1FRUfngNXJ76C1KKSkptGzZklu3bjF9+nTq1auHrq4uAQEBLFq0CDc3N9zc3Io1BnmlpKSgqqpaqHOfPHlCpUqVPtgKqaWlRVhYGBcuXKBu3brS9g0bNmBtbV2oawsFbKm4fv06f/31FydOnOCHH37A09OTKlWqYG9vj4eHB7169WLlypXcv3+fVq1aceHChWIL+LfffsPV1RULCwuaNWvG1atX8zzWz8+Pli1bYmdnh52dHR06dMhx/PDhwzE0NJT58vb2Lrb4SzsLC4uSDqHUETmTn8iZ/ETO5CdyVvqkJycT9/w56cnJxX6tkSNHoqyszMWLF+ncuTOVK1fG3t6etm3bsn//flq3bi0dq6Kiwpo1a+jQoQN6enrMnTuX9PR0Bg0ahKOjIzo6OlStWpVly5bJXOP97k+enp6MHj2an376CVNTUywtLfHx8ZH2Z2Zm4uPjg729PVpaWlhbWzN69Og872HZsmX8/fffHD16lGHDhuHm5oa9vT3du3fn/PnzODo6AllricyfP1+K1d3dnV27dknl+Pv7o6KiwqlTp6hduza6uro0bNiQBw8eAFnPWzNnzuTWrVuoqKigoqKCn58fkLXw4eDBg7GwsMDQ0JDmzZtz8+ZNqezsFo5169bh6OiItrZ2nveze/duXF1d0dLSwsHBgcWLF8vkbvHixfz999+oqKjg6emZZznKysp069aN33//Xdr2/Plz/P396datm8yxQUFBdOzYkfLly6Ovr0+dOnU4efKkzDGrV6+mcuXKUmtW165dpX27du3Czc0NHR0dzMzM8PLyIj4+Ps/YSrMCtVT89ttvBSpMTU2Nfv36fVRA+dm9ezeTJ09m4cKFeHh4sGbNGry9vbl06RImJiY5jv/nn3/o1KkTtWrVQk1NjaVLl9KpUyfOnz9PuXLlpOM8PT1ZsWKFzH0IudPU1CzpEEodkTP5iZzJT+RMfiJnpcvrgAD+GTOGtPh4lLW0qL94MWa1axfLtSIjIzl+/DizZs1CS0sr12Pen2pz5syZzJ49m4ULF6KsrExGRgaWlpZs3boVIyMjLly4wNChQ7GwsKBz5855XvuPP/5g9OjR/PPPP1y8eJEBAwZQr149mjVrxu7du1m6dCmbN2+mSpUqvHr1ilu3buVZ1pYtW/D09KR69eo59mU//APMnz+fLVu2sHLlShwcHPj777/p06cPJiYmNGrUSDpnypQpLFiwAGNjY4YPH86gQYM4e/YsXbp04e7duxw7dowjR44A/7XCdOvWDQ0NDQ4cOICenh6//vorXl5e3Lt3T1oMMSgoiD179vDnn3+ipKSU671cvXqV7t27M3XqVDp37syFCxcYOXIkhoaG9OnThx07djBx4kTu3r3Ljh07Ptja0bdvX5o1a8bixYvR1NRk48aNeHl5YWpqKnNcXFwcX3/9NT4+PqipqbFp0ybat2/P3bt3sba25sqVK4wZM4bff/+dunXrEhUVxblz5wB4+fIlvXr1Yu7cubRv3563b99y7tw5MjMz842ttCpVK2qvWrWK3r1707NnTwAWLVrE8ePH2bx5c6419bVr18p8v2zZMg4cOMDZs2dlaqJqamqYmZkVa+xfiqCgIIyNjUs6jFJF5Ex+ImfyEzmTn8hZ6ZGenJxVofj/cQxpCQn8M2YM7U6fRqkYXgQ+fvyYzMxMnJycZLabm5uTlJQEwNChQ5k7d660r1u3bvTt21fm+GnTpkl/t7Oz4+LFi+zcuTPfSoWLiwtTpkwBwNHRkVWrVnHq1CmaNWvGs2fPMDc3x9PTExUVFaytralVq1a+99G4ceN87zU5OZl58+Zx5MgRqSuQvb09//zzD7/++qtMpWLmzJnS9+PHj6dt27YkJSWhoaGBtrY2SkpKmJubS8efO3eOy5cv8+LFC+mFra+vL/v372fXrl0MGjQIyOrytGHDhlxfEGdbsmQJTZs2ZdKkSQA4OTkRGBjIokWL6NOnD4aGhmhqaqKqqioTQ16qV6+OnZ0du3btolevXmzcuJEFCxbw5MkTmeNcXV1xdXWVvp8xYwb79u3jwIEDDB8+nNDQULS0tGjVqhU6OjrY2NhIlbiXL1+SlpZGhw4dsLGxAb7sRTflrlQkJSWxdu1azp07R0REBBkZGTL7z5w5U1SxyUhJSeHmzZuMGTNG2qaoqEjjxo25fPlygcpISEggLS0NAwMDme3nzp3DyckJfX19GjZsyKRJk6Tac26Sk5NJfqfp9e3bt3LejSAIgiAIBZUYHk7au11GMjNJi48nMTwcbUvLTxbH+fPnycjIoHfv3jLPAUCug5RXrVrF77//TmhoKImJiaSkpMg8oObm/YdOCwsLwsLCAPD29mb58uU4OTnRokULvvnmG1q3bo2ycu6PcwV5I/748WMSEhL45ptvZLanpKTkGG/xbmzZD+5hYWF5jkO4desWcXFxOV7cJiYmyjy829jY5FuhALh//z5t27aV2VavXj2WLVtGenp6ni0c+enbty9+fn5YW1sTHx/PN998w8qVK2WOiYuLw8fHh8OHD0uVhMTEREJDQwFo1qwZ1tbW0s/Ey8uL9u3bo6mpiaurK02bNqV69eq0aNGCZs2a0alTpxzPoV8KuSsVo0aN4vTp07Rt2xZ3d/dPtkJmZGQk6enpOT50JiYmPHz4sEBlzJgxA3Nzc5lae9OmTaUZrYKDg5k5cyZdunTh6NGjeX5AFy9ejK+vb47tV65cQUtLC3d3dwIDA0lMTERHRwc7OzupedLGxoaMjAzpw+jm5sbjx4+Ji4tDS0sLJycnrl+/DoClpSVKSko8ffoUgGrVqhESEkJsbCzq6upUrVpVGiNSrlw51NXVpX+kzs7OPH/+nOjoaFRVVXFzc+PSpUtA1i8CbW1tHj9+DEDlypV5/fo1UVFRKCsr4+HhwaVLl8jMzMTExAQDAwMpx1ZWVjx58oTw8HAUFRWpWbMmV65cIT09HSMjI0xNTQkMDASy3rDExsby+vVrAGrXrs21a9dITU3FwMCAcuXKcffuXQAqVKhAQkICL1++BKBGjRrcuXOHpKQk9PT0sLa25vbt2wDY2tqSlpbG8+fPAXB3d+f+/fskJCSgra1NhQoVpP6a2b/oslfOdXV1JSgoiLi4ODQ1NalUqZI0a5mlpSXKysqEhIQAWb88nz17RkxMDOrq6jg7O0uzxVhYWKCpqUlQUBAAVatW5cWLF7x58wYVFRXc3d0JCAgAQF9fn6ioKB49eiTlOywsjMjISJSUlKhRowaXL18mIyMDExMTDA0NpX6qTk5OvHnzhvDwcBQUFKhVqxZXr14lLS0NQ0NDzMzMpHw7ODgQFxfHq1evAKhVqxY3btwgJSUFfX19LC0tuXPnDpD1FiopKYkXL14AWf8Z3r17l6SkJHR1dbG1tZX5zKanp0v5rl69Og8fPiQ+Ph5tbW0cHBy4ceOG9PlQVFSU+cwGBwfz9u1bNDQ0qFy5spTv8uXLo6qqSnBwsJTv0NBQoqOjUVRUJCMjQ3phYG5ujpaWlpTv7Gb/qKioHPk2NTVFT09PynelSpWIiIggIiJC+sxm59vY2BhjY2Pu378vfWZjYmKk/8Df/cwaGhpibm7OvXv3pM9sfHy8lO+aNWty69YtkpOT0dfXx8rKSvrM2tnZkZKSwr///it9Zov6d0T2f3Ql/TuiYsWKREVFlYrfEWlpaVJ5Jfk7wszMDF1d3U/yOyL7fksbDRMTlLW0sloqMjNBQQFlTU00PvAgWlgODg4oKCjkeL6wt7fPikdDI8c573eT2r59Oz/++CO+vr7UqVMHHR0dFi5cKP07y8v7A7wVFBSkF7hWVlbcvXuXkydPcuLECUaOHMnChQs5depUrgPDHR0dpc9KXuLi4gDYv3+/TNdwyNkd/N1rZD//vf9y+V3x8fFYWFhw4sSJHPv09fWlv5dUV8QePXowYcIEfHx86NmzZ66Vs/Hjx3Py5ElpEiINDQ26du1KSkoKADo6Oly+fBl/f3+OHz/OjBkzmDlzJhcuXEBfX58jR45w/vx5Tpw4wcqVK5k6dSr//PMPdnZ2n/p2i51CVFSUXB27bGxs2L59O3Xq1CmumHL18uVLqlatypEjR2Sa+qZNm8Y///yT6wf2XUuWLJG6P1WtWjXP40JCQnB3d2fPnj15Nhnm1lLh4uJCTEwMurq6ct5Z6fLw4cMczcFC/kTO5CdyJj+RM/mVxZzFxsaip6dHSEjIJ/v/KiUlhYiICGxsbD5qwcFPOaYCoGXLlty7d4+7d+/mqDB4enri6urKokWLgKyH7Z07d9KuXTvpmO+//57AwECOHTsmbfPy8iIiIkKq7Pfv35+YmBhpUPT75QJ06tQJPT091q9fnyPGBw8e4OzsTEBAAO7u7jn2L1iwgMmTJ3Px4sUc4ypSU1NJSUkhIyMDCwsL1qxZQ69evXLNhb+/P82aNSM8PFyqDNy4cYOaNWvy6NEjbG1tmTdvHtu2bZNeMgGcOHGC1q1bc//+fWxtbXMt28fHh3379uU78Q7At99+S0REBIcPH5a2/fTTTxw5ckS65tixY7l582aOgdTv8vPzY9y4cURERABZFYsdO3Zw+/ZtKlWqxNKlS1m+fLn0UsXNzY3OnTtL3a7i4uKwtbWld+/eMj+nbPHx8RgbG7NlyxY6dOggsy89PZ0KFSrw/fffy/S8+ZwlJSXx9OlTjI2NPzhORe6WCgsLC3R0dAodXGEZGRmhpKREeHi4zPbw8PAPjodYvnw5S5YsYc+ePflWKCDrDZeRkRHBwcF5VirU1NTK7GBusdih/ETO5CdyJj+RM/mJnJUuZrVr0+70aRLDw9EwMSmWsRTvWr58OY0bN6ZOnTpMmTIFFxcXFBUVuXLlCg8ePMj1If5dDg4ObNq0iWPHjmFra8vmzZu5cuVKng/XBeHn50d6ejq1atVCU1OTLVu2oKGhIfXXf9+oUaM4dOgQXl5eTJ8+nfr166Ojo8PVq1dZsGABa9euxc3NjbFjx/K///2PjIwM6tevT0xMDOfPn0dXV5fevXsXKDYbGxtCQkK4ceMGlpaW6Ojo4OnpSZ06dejUqRPz5s3D0dGRFy9ecPjwYdq1a0eNGjUKfO9jxoyhbt26zJ49m86dO3Px4kVWrVrF8uXLC1xGbtatW8fy5csxMjLKdb+joyN79uyhVatWKCgoMH36dJnWmYMHD/LkyRMaNmyIgYEBhw8fJiMjAycnJwICAjh9+jTNmjXD1NSUS5cuER4eTuXKlT8q5s+V3Ctqz5w5k+nTp0tN85+Kqqoqrq6unD17VtqWkZGBv78/NWvWzPO8ZcuW8fPPP7Njx45cZz9437///ktUVJQYuJ2Hgsy7LcgSOZOfyJn8RM7kJ3JW+iipqaFtaVnsFQrI6nJ3+fJlmjZtyuTJk/Hw8KBOnTqsXLmSsWPHMmPGjHzPHzx4MO3bt6dHjx7Ur1+fyMhIvvvuu4+KSV9fn3Xr1tG4cWPc3d05efIke/fuzfOBWE1NjSNHjvC///2PX3/9lQYNGlC3bl1WrFjBiBEjpPUcZsyYwcSJE/H19cXFxYXWrVtz+PBhubrodOzYES8vL5o3b46FhQXbtm1DQUGBAwcO0LBhQwYOHEiVKlXo1asXT58+lfs5y93dna1bt/Lnn3/i5ubGjBkzmD59On369JGrnPdpaGjkmT/Iau0xMDCgUaNGdOjQgebNm8s8T+rp6bF3715atGiBi4sLa9euZdOmTVStWhVdXV3+/vtv2rZtS5UqVZg2bRq+vr58/fXXHxXz50ru7k8RERH079+f8+fPo6mpmaP/2fuj5ovS7t27GT58OIsWLcLd3Z01a9awd+9eAgICMDU1laZqmzp1KgBLly5l7ty5rF27ltrvNJFqaWmhra1NXFwcvr6+tGnTBjMzM4KDg5k+fTpxcXGcO3euwK0RsbGx2NralonuT4IgCELpVZq7PwmC8OkVa/enQYMG8fLlS6ZMmYKJicknG6gNWbXgyMhI5s6dS1hYGM7OzuzYsUOaU/j58+coKv7X+LJ+/XpSUlJyTPE2fvx4fvrpJ5SUlLh79y7btm0jJiYGc3NzvvrqKyZOnFhmuzd9SEBAgEwFTfgwkTP5iZzJT+RMfiJngiAIRUfuSsWlS5c4evToB5dALy6DBg2S5jV+34EDB2S+f3fFxtxoaGjIrBgpCIIgCIIgCIL85B5T4ejoSGJiYnHEIpQCYqyJ/ETO5CdyJj+RM/mJnAmCIBQduSsVU6dOZcqUKZw7d46oqChiY2NlvoQvmxgzIj+RM/mJnMlP5Ex+ImeCIAhFR+5KRefOnbl8+TLt27fHyckJe3t77O3tsbOzkxaFEb5c2YszCQUnciY/kTP5iZzJT+RMEASh6Mg9pmL//v3FEYfwESIiIjhy5AiZmflP5FWuXDmaNm36SQfXC4IgCIIgCF8+uSsV9evXL444hI+wYsWKD86Xne2vv/6iVatWhb7Wl7pgS3ESOZOfyJn8RM7kJ3ImCIJQdArU/en58+dyFfrixYtCBSMUTmpqKjY2NiQnJ+f79dVXX/Hjjz+Snp5e6GuFhYUVYeRlg8iZ/ETO5CdyJj+RM0EQhKJToJYKT09PWrZsybfffpvnsvSxsbHs2bOHX375hT59+jBkyJAiDVTIn4KCwgcXJfH19aVmzZr4+fnRv3//Ql0nMjISBweHQp1bVomcyU/kTH4iZ/ITOStZMTHPSEiI+GTX09Q0Rk/P+pNdTxDKmgJVKi5cuMDChQvp2LEj6urquLq6Ym5ujrq6OtHR0Tx48ID79+9TrVo1ZsyYQfPmzYs7bqEQatSoQbdu3ZgyZQrdunVDU1NT7jKUlJSKIbIvm8jZfzIzMws0pkfkTH4iZ/Ir9TnLzIRSOkYuJuYZv/ziTGrqp5uiXkVFgyFD7nxWFYv+/fsTExMj1swSvggFqlQYGhoye/ZsJk+ezLFjx7h48SLPnz8nMTERIyMjvL29adq0KVWqVCnueIWPNHv2bCpVqsSSJUuYOHGi3OfXqFGjGKL6somcZbn08hKupq6oKX14tXqRM/mJnMmv1Ofs8QlwLJ0v8RISIkhNTeTrr3pgaGBa7NeLehPGkdNbSEiIkLtS8erVK+bPn8/hw4d5/vw5enp6VKhQgR49etC7d+9CvaDLtnjx4g9OsiIIpYVcA7U1NDRo164d7dq1K654hGJmb2/PsGHDmDdvHoMGDcLExESu8y9fvkzNmjWLKbovk8gZZGRmsOjqIv745o8CHS9yJj+RM/mV6pylJMCZeaW2UpHN0MAUU2PLkg4jT0+ePKFx48bo6+szc+ZMnJ2dUVNT486dO/z222+UL1+eNm3a5DgvNTUVFRWVD5avp6dXHGELQomQe50KofSbPHkyCgoKzJo1S+5zMzIyiiGiL5vIGRwLOcbdyLsFns5Y5Ex+ImfyK9U5u7gK4l6XdBRfvJEjR6KsrMzFixfp3LkzlStXxt7enrZt27J//35at24NgIqKCmvWrKFDhw7o6ekxd+5c0tPTGTRoEI6Ojujo6FC1alWWLVsmU37//v3p1KmT9L2npyejR4/mp59+wtTUFEtLS3x8fKT9mZmZ+Pj4YG9vj5aWFtbW1owePfqT5EIQPkRUKsogY2NjJkyYwOrVqwkKCpLrXHlbNgSRs9T0VJZeWwqAokLBfuWU9ZwVhsiZ/EptzuIj4NySUjueorSIjIzk+PHjDB06FC0trVyPefdFycyZM2nXrh3Xr1+nb9++ZGRkYGlpydatW7l16xaTJk1iypQp7NixI9/r/vHHH2hpafHPP/8wd+5cZs2axYkTJwDYvXs3S5cuZdWqVQQGBrJz506cnZ2L7qYF4SOISkUZ9f3332NqasqkSZPkOs/Q0LCYIvpylfWc/fnwT57HZU1LrUDBHoLKes4KQ+RMfqU2Z2cXQMpbKGAlXSicx48fk5mZiZOTk8x2c3Nz9PX10dfXZ8KECdL2bt260bdvX+zt7bG2tkZFRYVp06ZRo0YN7Ozs6NGjB3369GHnzp35XtfFxYUpU6bg6OjIt99+i4eHB6dOnQLg2bNnmJub4+npibW1NbVq1WLgwIFFf/OCUAjiN1IZpaGhwcyZM9m+fTuXLl0q8HkPHjwoxqi+TGU5Z3Epcfxy8xcgq0JR0O5PZTlnhSVyJr9SmbOoYLi8LuvvolJRIs6fP8+VK1eoUqUKycnJ0nYPD48cx65atYpatWphYWGBvr4+v/32G8+ePcu3fBcXF5nvLSwspDVVvL29SUxMxMnJiSFDhrB3717S0tKK4K4E4eOJ30hlWO/evXF2dmb8+PFi9gmhWKy/s543yW+Agnd9EgQhH6dmQkZq1t/Fv6li5eDggIKCAg8fPpTZbm9vj4ODAxoaGjLb3+8itX37dn788Uf69evHoUOHuHLlCn369CElJSXf674/wFtBQUEa/2NlZcXdu3dZvnw5GhoajBw5kq+++orU1NTC3qYgFBm5fyNt3bqVY8eOSd9PmzYNW1tbvLy8CA0NLdLghOKlpKTE/Pnz8ff359ChQwU65/1mYOHDymrOwhLC+OPef7M9FbSVAspuzj6GyJn8Sl3O/r0Gd95Zz0BUKoqVkZERzZo1Y9WqVcTHx8t9/vnz56lbty5Dhw6levXqODg48OTJk4+OS0NDg9atW7NkyRJOnDjBxYsXuX379keXKwgfS64pZSFrTuWff/4ZgEuXLrFu3TpmzZrFsWPHmDRpEhs3bizyIIXi88033/DVV18xfvx4vLy8UFbO/yPx5s0bDAwMPlF0X4aymrNVN1aRlJ4kfa8oxzuMspaz4E7epEVEoGxsjN2u/Ptb56Ws5awolKqcZWbC8amy2xRK+eJ9ZK0f8TlfZ/ny5TRu3Jg6deowZcoUXFxcUFRU5MqVKzx48AB3d/c8z3VwcGDTpk0cO3YMW1tbNm/ezJUrV7C1tS3kXYCfnx/p6enUqlULTU1NtmzZgoaGBjY2NoUuUxCKityVin///Rd7e3sADh06RJs2bejbty+1a9embdu2RR6gULwUFBTw9fWlZs2a+Pn5MWDAgHyPDw8Pl37+QsGUxZwFRQex5/EemW3ydH8qazlLi4gg7fXHTQ9a1nJWFEpVzh6fgJC/ZbeV4pYKTU1jVFQ0OHJ6yye7poqKBpqaxnKdU6FCBS5fvsy8efOYPHkyz58/R01NjcqVKzN27Fi+++67PM8dPHgwN27coEePHigoKNC1a1e+++47jhw5Uuh70NfXx9fXlx9++IH09HScnZ3Zu3cvRkZGhS5TEIqK3JUKLS0toqKisLS05PTp0wwbNgwAdXV1kpKSPnC28DmqUaMG3bp1Y+rUqXTv3j3f1UHl6cIiZCmLOVtzcw0ZmbJrAMiTh7KYM3nE+fsT538WzVq10KxZA2UjI5GzQihVOTs9O+e2Ulyp0NOzZsiQOyQkRHyya2pqGsu9mjZkDZReunQpS5cuzfOY3MY0qKmpsW7dOtatWyezffbs/36W69evl9l38uTJHOXs2vVflzexALHwOZO7UtGkSRO+//57XFxcCAoKonnzrNU879+/j5WVVZEHKHwas2fPplKlSixZsoSJEyfmeVytWrU+YVRfhrKYs9oWtTkSIvs2Tp6WirKYM4DMlBQSrl3P95iUp095NXUqmampvNmS9ZZX1aEC1rVqERsVhWbNmiiLt5YFUqo+Z3aN4cV7n43SVCnKhZ6edaEe8gVB+DzJXalYsGABs2fP5t9//+X333+X5vm+ceOGzKqQQvHIzMzk5MmT+Pn58d1336GhocGrV69ITk4mISEh31aG/Njb2zNs2DDmzp1L7dq18+xnHBgYSOXKlT/mFsqcspgz20xbjFWMiUjNegupoqBCc4PmXLt2rUDnl7WcqaemoACkv3nD0x495D4/5XEQKY+DeLNlKwAZ5cuTUaUy6ZWrkFG5EujpFXHEuTt+/Dj37t2jatWqGBgYoKamhrq6OhoaGmhoaKClpSV9aWtro6Ojg4aGRom1GFy9ejXXaUA/S41+yFpFO/3/Zw5S14OaYn0CQRA+HwpRUVFiLtGPFBsbi62tLTExMejq6hZ5+ZmZmVy9epUdO3awY8cOgoODcz3u6tWr+Q4a+5CIiAgcHByIiYkpdBmCAKCgokDlVZVRVMlqnXg44SEpL/OfRrEsO2VfAfP3ppEsCiEpKVxKiGd7dDSB78ynX9yUlJRIT08v8LE6Ojro6emhp6cnLSqmr6+PgYEBBgYGGBoaYmBgQOJtczJTldDQUaHduGro6Oh8VIUkICCA2rVrF/r8TyrqCSyrnvV3dT0YeQ205BsfAFn/X+np6RESElIs/1/lJiUlhYiICGxsbFBXV/8k1xQEoWgkJSXx9OlTjI2NUVVVzfdYuVsqzp8/n+/+evXqyVukkIvcKhLGxsZ07NiRKlWqMHr0aDZt2iTzNrdSpUofdU1jY2MePHjAv//+m+cxz549w9paNFfLoyzm7F7cPeYHzwfASt0Kv7/85Dq/rOVMfcQIiHpDprIyGY6O+R6rEBWFYh6DujPMzcmoXPn/WykqY2ZoSBugTTHEnJvAwEB69eqFv78/9erVIzU1laSkJBITE0lMTCQ+Pp74+Hji4uKIi4vj7du3vH37ltjYWGJiYqSvN2/eEBQURHR0NJGRkbx584bk5GRm9tyGgbYJYWH/oqfXEBUVFYyNjTE2NsbExARTU1NMTU0xMzOTvszNzaW/v/8fYqlaUfuJ/39/t21YqAqFIAhCcZK7UtGmTc7/nt59UxQR8ekGXX2JLly4wJo1a/D395dqhh07dqRz5840adIEZWVlqQtJ5cqVpZaJZ8+ecf/+/WKPz8LCotivURoZGxvn+RDs4ODwyd4Ifi7OXTsn/b2xXWO5W9DKWs4eqaiSBqgYGeG4Z3e+x2YkJBA65DsSLl9G1cYma7B2rVpkVK6EgYPDpwn4A7K7NKmqqqKqqlokP8uEhAS2TrtC0ts0TEyM2b59O+Hh4URERBAeHk5YWBgvX77k1q1bvH79msjISMz0rfCuN4JnEQ959OIGMSkvMTYzwsLCAgsLC4yMjLC3t6d8+fJYWlpiaWmJqakpioqf4QDo4LP//d2uccnFIQiCkAe5KxXvd71JTU3l1q1bzJkzh8mTJxdZYGWVr68ve/fupWnTpowfPx4PDw/09PSIj4/n5s2bKCgoSD+DwMBA1NTUeP78Oe3atSc5ufhn35o4cSJz5swp9uuUNurq6jx48CDXikVgYGDp6WJRRAJeBUh/r20h/72XxZwVlKKmJla/rCH97VtUzMyk7QEBAdT+TCoVxUFTUxMlJSUgDSUFFarbN4Z8ZoNNSU7lwp4gkuPSqWxVA6/qPcgkg0TeEJYQQtC/tzh1YhcvX/9LWlqadJ6ysjLly5fHysoKa2tr6cvGxkb60tbWLv4bfldm5nuVikaf9vqCIAgFIHelIrc3Tl999RWqqqpMnjyZ06dPF0lgZZWXlxd79+7F2dkZNzc3TExMAGSa7VX+v+919iDH5ORkTIzVad+tP/8+f42puRnGJoVvGo9PzJoKVEsj59s6B2t7Js2ammN7YcoqyrgKQ1kpk7T0jx8gGvMmgr3bthAREVGmuuzkJS4ljrsRd4GsGZ88zErJQNhSRFFTE8VCTsrwJUhOSOPYb3flPk8BRTQxwlbTCNsKHjRz6IeprS76lqoo6iQSm/aaF6+eExoaSmhoKM+ePeOff/7h339lKx7GxsbY2tpib2+PnZ0dFSpUwN7eHgcHBywtLf+/8lOEwgIhe+pVbTMwqVi05QuCIBQBuSsVeTExMeHx48dFVVyZtWPHDgCWLVvGsmXLsLW1pXHjxjRo0IBatWrl+oZMTTWVy2fHs3LtWVZsP0K9OvYc2j2s0DGkpGagoAAqyjkf3qPfxtGhWcG7MuRXVlHGVRgZGRlF1M1Bl0nDxhMWm3tLkcMX/PY4N13+6kJ6ZtYg3apGVdFR1ZG7jLKWM2VjY5k/C6Os5awoZGbC6+BY0lK0KOdkgGvlCrRtb4SiouzLhvT0dF68eMHTp08JCQkhJCSE4OBgnjx5QkBAAKGhoWRkZL30UFVVxd7eHkdHRypWrIiTkxMVK1akcuXK0ksiuW32/u/vdo1K/VSygiB8meSuVNy9K/t2KDMzk1evXrF06VKcnZ2LLLC8/PbbbyxfvpywsDCqVq3K/Pnz850ScO/evcydO5dnz55hb2/P9OnTpbU1suOfO3cuf/zxBzExMdSuXZuff/6ZChUqFPu9FERISAihoaH4+fmhqKiIq6urNDg7e3YVFeV0Vq49y6z5WesChIU/Z/OuxYW6nqGBKd807QnA4VObiXoTJrNfU6suCfEXiqSsooxLXrZWFalfq2WRlJUdm2JczsWPAOLi4srUaqcRif+NqypM1ycoezmz27Xzo8soSzlTUlGkQvX8H9DT0zIJuh4GucxvaFQ+qxKhapCKaz1HNLTzn9FESUkJKysrrKysaNCgQY79KSkpPH36lMePH0tfDx8+ZNeuXTx9+lSqcBgZGVGlShWqVq2Ks7MzLi4uVKtWDX19/fxvOCHyv79/QV2fnj179knHYeY39k0QhI8nd6WiUaNGKCgokJkp+5u6Ro0aLF++vMgCy83u3buZPHkyCxcuxMPDgzVr1uDt7c2lS5dyfQMUEBDAoEGDmDJlCl5eXuzcuZNevXpx+vRpqlSpAmS1CKxdu5ZVq1ZhY2PDnDlz8Pb25sKFC5/N1HfZlYeMjAyuX7/OzZs3AejevTsNGjRAVSWDw0f+63aWmpZCeGTeMzjlJzUthbiEWDIy0nkd/pzomHCZ/Xa6ToRHFuwB6ENlZVNIV0ApUZl0jTQylXKf4bigZRWUjo4BsXFviqSs1LQUYuPe5L4zIIC0w4fhm2/gMx8jcPVJLEGvE6lgpoGHfeEH1qam/1e5qmVeuMXFXr16hY2NTaFjKIvKUs7UtVRo3r/qB4+7f/Elpzbex9BCk3JOBpR30qeco75UiQgICPhghaIgVFVVcXR0xDGXmbuSk5N59OgR9+/f5969e9y7d49z586xbt06aRVmW1tb3N3d8fDwoFatWtSqVeu/rsbpaZD2znTAX0il4tmzZ1StWpWkpOIfC5hNXV2du3fvlqqKRUhICI6Ojly+fBk3N7eSDkcQ8iV3peLGjRsy3ysoKGBsbPxJHsBXrVpF79696dkz6431okWLOH78OJs3b2b06NE5jv/ll1/w9PRk1KhRAEyaNIkzZ87w22+/sWjRIjIzM1mzZg3jxo2jZcuWAKxevZqKFSty8ODBz3Yxv+y3XsnJyZw+fVr6vihEx4Sz/8g6oqLDSEvL/c17UZal8VoLi38sUUpTIl05nZf1n5NoFl+scQFER4ez8U/foikrJqus5p7VZHf8+CP4+lIBYMYMGD8e5s//6OsVB59dT1hxNFT6foSXFVM75TMKNg9vkt6Qlvlf33M3U7eiCE8QCqVSHQsqVDdFRa2IxzjIQU1NDWdn5xwt+ampqTx48ICbN29y/fp1rl27xvz584mNjUVBQYFq1arx1Vdf0aWBA3Wzm1sUlMDA9tPfRDGIiIj4pBUKyJpvX96xb/379+ePP/5g9uzZjB8/Xtq+b98+vL29pYqhIAiFqFRYWVkVRxwflJKSws2bNxkzZoy0TVFRkcaNG3P58uVcz7l8+TLDhsmOLWjatCmHDh0C4OnTp7x+/ZomTZpI+3V1dfHw8ODy5ct5ViqSk5NJfmchqbdv3xb2tj5abhUKRQV9tNXqFKq8uPgYzl+4jUW5VDq17oGhganM/szMBOpWH12gsqLehHHx2nHS0lL5+qucZWWkpHNjyBmpJUYpXQmbS/a4/dIERVUlucqS178vg/G/sK9Iyop6E8aR01tITnln0cCAAPD1lT3Q1xc6dvzsWiyuPomVqVAArDgaSqvqxnK3WPwb9y+KCopkZGagoqiChrJGoWKqVatwLRxlmchZ7vKrUJRkzlRUVKTKRvaLsoyMDB48eMCFCxc4e/Ysu3btIuTIS3Z21kBJUQGU1Uos3rJMXV2dBQsWMGjQIAwMDEo6HEH4bBWoUvHLL7/Qp08f1NXV+eWXX/I9dsiQIUUS2PsiIyNJT0/P0c3JxMSEhw8f5npOWFgYpqayD4ympqaEhWX1oX/9/wtI5VZm9jG5Wbx4Mb7vPzACV65cQUtLC3d3dwIDA0lMTERHRwc7Oztu3boFgI2NDRkZGYSGZj3Eubm58fjxY+Li4tDS0pJmdurfvz/3798nOTkZLy8vIOvn4OXlhbq6OuvXr0dZWZnx48dz584d9u/fL8URHBLN/yYcyTP+ghg8uDVxyU3RSc9ERyuJpy+yF4nKwEA3iTexmigqZFLV8RX3HpuRnqGIvk4iBnoJBD/P6teto/kAbZ0kDAwrEZdsTyXjaO4/MSU1TQld7SS0U16QnvjOqruZkJ6YzsuQilSrk0zQM2OSU5TR1kxGR+cBpqbDMTBMQVVNHRRMeR2ZNQC4sv1rgv81JClZBU2NFKzMo3kQnPVzNzeJBeBVeNbDcUW7MEJf6ZOcXpHy5Y3R09PndVTWGgpmRm9RUsrgRZgeAI424bwM1yUuQQ011TQqWEdw77E5ACaGcaippvH8lT7JKYmoqp4mMVGTgIAAVFRUcM/jMxl0+DAmlSsTFhZGZGQkSkpK1KhRg8uXL5ORkYGJiQmGhoY8ePAAACcnJ968eUN4eDgKCgrUqlWLq1evkpaWhqGhIWZmZgQGBgJZA3Xj4uJ49eoVkPXAdOPGDVJSUtDX18fS0pI7d+4AYG9vT1JSEi9evODfqGRUFTPxrpyIgUYGz2OVOPtMjacPbpAWroaNjQ3p6ek8f/4cgOrVq/Pw4UPi4+PR1tbGwcFBasG0srLCQMWAyJRI1BXUSUxMJDg4mLdv36KhoUHlypWldVbKly+PqqqqNEWyi4sLoaGhREdHExcXx1dffSW9MDA3N0dLS4ugoCAAqlSpwqtXr4iKisrKt7s7AQFZ09iampqip6fHo0ePgKxFISMiIoiIiEBRUZGaNWtK+c5eOC17jRdHR0diYmKkf/+1a9fm2rVrpKamYmhoiLm5Offu3QOgQoUKxMfHS/muWbMmt27dIjk5GX19faysrLh9+zYAdnZ2pKSkSAtLfszvCCcnJ65fvw4gzTT09OlTYmJiaNiwISEhIcTGxqKurk7VqlW5evUqAOXKlUNdXZ0nT54A4OzszPPnz4mOjkZVVRU3NzcuXbok5VtbW1uafKNy5cq8fv2aqKgolJWV8fDw4NKlS2RmZmJiYoKBgQEPHz6U8vj8+XNSU1OlfF+5coX09HSMjIwwNTWVPrOOjo7ExsZKv4vfzbeBgQHlypWTxvFVqFABZXVQ0VQgUymV9PR07ty5Q1JSEnp6elhbW0v5trW1JS0tTfrMuru7c//+fRISEtDW1qZChQrcvHmTmJgYXFxcgKzuOACurq4EBQURFxeHpqYmlSpVkj6zlpaWKCsrExISIn1mnz17RkxMDOrq6jg7O3PlyhUga00fTU1N6TNbtWpVXrx4wZs3b3J8Zs3MzNDV1eXRo0dERUWhoaGBkpIS6urq7L2fxsu4TCx1FUhBledPnnzU74iXL18iyMfT05OgoCDmz5/PvHnzcj1m9+7dzJgxg8ePH2NhYcHw4cOll6D+/v40a9Ysxznffvst69evx8HBgadPn+bYn1cryJ07d/jpp584d+4cWlpaNGvWjIULF2L8ERM9CEJRUIiKisq9E/s73NzcOHXqFIaGhvn26VNQUJD+sytqL1++pGrVqhw5ckTm7dK0adP4559/OHHiRI5zzMzMWLVqlUyLw7p16/D19eXBgwcEBATwzTffcO/ePczNzaVj+vXrh4KCAuvXr881ltxaKlxcXIiJifnoRZ48PT05derUR5VhZ6vP8CGFb6l4HHwbi3JxubZUPHvljLX5nQKVld26EB0Tnn9LRVJ61mBKBVBSV8q3pSKvsuRVHC0VTb9aS8NGg7I2BgRAnVx+BhcvfpYtFd/My/nv9vBP1Qs1tsJzhydhCWGYappysvPJQsUUEBAg1qmQ0+eQs2vXruHh4cHVq1flXvCwJJRkzrInOXm3+9OVK1ekCoulpSVfffUVX3/9Nd1ezEAx7hXolINxgR913djYWPT09AgJCflkC0ympKQQERGBjY2N1FX62rVrJZL7gIAAuT6b/fv3JyYmhm+//ZZvv/2WwMBALC0tZbo/Xb16lXr16jF16lQ6d+7MhQsXGDlyJMuXL6dPnz6kpKQQFRUllXn//n3atGnDsmXL6NevH+Hh4VKLfXp6Ol27dkVFRYXTp0/nGFMRHR1NlSpV6N+/P7169SIxMZGJEyeSlpbG8ePHizxfgpCUlCQtxvzu8ga5KVBLxbvjKN4fU/GpGBkZoaSkRHi47KDa8PBwzN5ZAOpd77ZKZHu39SL7vPDwcJlKRXh4eL4zWampqaGmVnLN0EpKSqSnp6OgoED16tVRU0vnwoWb0v6MzGjikgvZUqEM9eqWJyo6mSOnt+TYbWbWmXPndxS4OFPj8igrq+RaFoBGrXfGVCil87zWU+7/dbtQZcnDUN+syMoCUFZWQU1V778NtWtnjaF4t0Xrxx8/uwoFgIe9LiO8rGS6QI382uqjBmt/rA/OhiPkIHImv0+Rs+zKw/379wkMDOTu3bvcvXuXO3fuEBmZNauTrq4u1atXp2PHjtSqVYs6derIDrpfOLPY4xTy1759e1xdXZkxYwa//vqrzL4lS5bQtGlTJk2aBGS1HgUGBrJo0SL69OmDqqqq9IwRGRnJkCFD6Nu3L/369QNke0uMGTOGV69eceFC7rMsrlq1Cjc3N2bNmiVt+/XXX7Gzs+Phw4c4OTkV6X0LgjyKbJ2K4qaqqoqrqytnz56lVatWQFb/U39/fwYNGpTrOTVr1uTs2bMMHTpU2nbmzBlq1qwJZHUzMDMzw9/fX2oCj42N5erVq9I/9s9BdiUCspr1XVxcOHDgAFu3bqVmzZoEB11m29ZF/Lbh0kdfS1/PhLZfDyAjI53dB9fmmBnpzZu/i6wsgESzeILbPfzg7E8FKUse+vomtG85sGjK0jOhY6vBxCS+V7mdPx86diT59m3UXFw+ywpFtqmd7GlV3bhIZn8qCpaWliV6/dJI5Ex+RZWzzMxMoqKiCAoK4vHjxzx69IhHjx7x4MEDHj58SGxsVjdMFRUVHB0dqVq1Kt9//700paydnR0KYu2Jz97cuXNp3rw5Y8eOldl+//592rZtK7OtXr16LFu2jPT0dGkxxNTUVLp06YK1tTWLF+ec9v3XX39lw4YNnD17Ns81TW7dusWZM2dyrRA/efJEVCqEElWgSkV27bsgZs+eXehgPmTYsGEMHz4cNzc33N3dWbNmDQkJCfTo0QOAoUOHYmFhwdSpWSs+DxkyhDZt2rBixQpatGjB7t27uXHjhvSPWUFBge+++46FCxdSoUIFaUpZc3NzqeJS0gwMDGjUqBENGjSgfv36mJmZcefOHQ4cOICGRtYgWAUFBRbM6syLV8EcOhyOirIqJkaFW2TJ0MAUbc2sB0ozE0tUlGWbugyNhxAVkf+4moKWVZRxyctI3xRdbYMiKcvQIKusmMRcdtauzQ0o8W4pBeFhr1vilYlsd+7cKRU5+5yInMlPnpwlJCRIi98FBwcTEhLCkydPpK+YmP8majA1NcXR0REXFxe8vb2pWLEilSpVokKFCtK4OaH0adiwIS1atGDy5Mn07t1b7vOHDx/O8+fPOX/+PMrKso9fZ86cYfTo0WzatIlq1arlUULWejStW7dmzpw5OfZZWFjIHZMgFKUCVSqyB79lu3nzJunp6dIKrkFBQSgqKhb7HModO3YkMjKSuXPnEhYWhrOzMzt27JC6Mz1//lxmheTatWuzdu1a5syZw6xZs7C3t2fTpk3SGhUAo0aNIj4+njFjxhATE0OdOnXYsWNHia1R0aFDB06dOkX//v3x9vbGycnpg2+wUtOUSEpKZfNv4/nt9/O4u1niUb3w89Vnr1ydvdjcu24/tOCbxmNyOUv+sooyrsLIyMgosrISE1PIyBAPCwDGGsYyfwrC5y4lJYUXL17w/Plznj9/TmhoqPT17NmzHIu0KSsrY21tjZ2dHTVq1KBLly5UqFCBChUq4ODgUPRjFbRNZf8USszs2bOpUaOGTItApUqVOH/+vMxx58+fx8nJSWqlWLx4MTt37uTs2bM5Fql8/PgxXbt25aeffqJDhw75Xr969ers2bMHW1vbHBUTQShpBfpEvjuz0MqVK9HW1mbVqlVS81t0dDQjRoygTm4DU4vYoEGD8uzudODAgRzb2rdvT/v27fMsT0FBgYkTJzJx4sSiCvGjnD17FoCYmBjS0tI+cHSW5BQVajbypX23HugZuHDqOpy6HlvoGOITs6ap1dJQzLFPRyuTI+cKPoVufmUVZVyFoayUSVq6bIUtKiKS5JSUHMeqqapiaJz7asUxbyLYu20L+/Z75brf3l7+9R5Ks+2tt390GQXN2aNHj3Kd0llHRyfXhci+ZGXtc1YQSUlJvH79mlevXvHq1StevnzJixcvePXqFS9evJCmFX9/rJ6Ojo60graHhwcdO3bExsZG+ipfvrz0sPhJDPH/dNcS8uXi4kL37t1ZsWKFtG3MmDHUrVuX2bNn07lzZy5evMiqVaukBYFPnjzJhAkTWLZsGcbGxtKMcRoaGqiqqtKhQwfc3NwYOHCgtA+QGeuZbejQoaxbt45evXoxbtw4DA0NCQoKYvv27axdu/bTfi4F4T1yV3NXrVrFzp07Zfrz6evrM3HiRLy9vRkxYkRRxlfmtGjRgh07dnD06FF27dqFlZUVzZs3p2nTplSsWBFtbW3pIert27ekpKRkDWCPSGLFwlXFHl/jxo3x9xf/wb1PXV09z+n8PvUCT1+CguTs0aNH+fYffvjwYZmqWHzpn7PMzEwSEhKIjIyUviIiIggPD5e+wsLCCAsL4/Xr14SFhcl0SYKs8WlmZmaUK1cOCwsLXF1dqVixIuXLl6d8+fJYWlpiaWmJnp5eHlEIRSV70dxPvaJ2UUy7On36dHbs+G/CEnd3d7Zu3cqMGTOYPXs2FhYWTJ8+nT59+gDwzz//kJ6ezvDhwxk+fLh03rfffsvUqVO5f/8+9+/fz7EoX25TypYrVw5/f38mTpxIy5YtSU5OxsbGhhYtWsj01BCEkiB3peLt27fSjBXvioyMJC4urkiCKst69OiBu7s7FSpUICAggB07drB7927Wr19PhQoV6Ny5szQzVeXKlalUqRKVKlXi4cMHMs3zhZWamppvn9/w8HAWLVr00df5HAUGBtKrV68892/atInKlSvnus/Y2DjPVVpfvHhRYotGllYFydmHFp0syUUpS8Ln/DlLTU0lMTGR+Ph46evt27fSV2xsLDExMdJXdHQ00dHRvHnzhqioKKKionjz5k2uD6CqqqqYmJhIX7a2ttSuXRtTU1PMzMwwMzPD3NwcCwsLjI2NZd7kfg7T8JZV1tbW3L17t0j+3yqo/H5P5yW3qeVtbW2Jj4+X2daxY0c6duyYaxlTp06VxnrmJr9VuW1tbXPsd3R0lKnUCMLnQu5KRatWrRgxYgQzZ86U5nq+evUq06ZNo3Xr1kUeYFmjqakp5bVFixa0aNGCVatWcfr0af7880/Wrl0rzXedvaiVn58fZ86c4cKFC2hqahb62jExMTg7OzN69Gi++uqrXI959epVnrNSlGXZi6vl5v79+2JwppwKkrPsBb0Ku/9L8zl8zkaPHg0gLfSVkpJCUlKSNHtdfnR0dNDT00NfX1/608bGBjc3N4yMjDAwMMDIyEj6yl64UFtbW8ycVEpZW1vL/ZAvCMLnq0CL370rISGBqVOnsnnzZqn2rKysTK9evZgxYwZaWlrFEujnLDY2Fltb2yJZ/O5DUlNTmTJlCvPnz8+x72MXnJo0aRILFy6UWdhPEARBXt7e3tSoUQM1NTXU1dXR0NBAQ0MDTU1NtLW10dLSQltbGx0dHXR1ddHS0iqRvuBpaWllbrDr57L4nSAIpYM8i9/JXanIFh8fL638aWtrWyYrE9k+ZaUCst6KHz16FFtbWzQ0NFi5ciWHDx/m8ePHhW6p+Pfff3F0dGTkyJF07do1z+O+5MV1Pqb7U36+5JwVl4LkrLh+XqXV5/A5S0xMJCQkBC8vryLpu17cbt68iaura0mH8UmJSoUgCPIo8hW1c6OlpUXVqlULe7rwEYyNjenZ87+pUM3NzVFTU/uork/Tpk1DS0uLSZMm5fsfTWpq6ke1hpRmlStXLtS9l+WcFVZR5KywP6/S6nP5nNWvX7+kQyiwL31wuyAIwqdUqErF9evX2bt3L8+fP88xgGjjxo1FEpjw6dy5c4cNGzawZMmSD765+lRvtkqCjo7OR+3Py5ecs+JSkJwV18+rtBKfM/mJnAmCIBQduSsVu3btYtiwYTRt2pTTp0/z1VdfERQURFhY2GezCrUgn59++gk7OzuGDBnywWNtbW2LP6AS4ujoyMOHD4t83YMvOWfFpSA5K66fV2klPmfyEzkTBEEoOnJXKhYvXszs2bMZOHAg1tbWzJ07FxsbG8aMGYOZmVlxxCgUozNnznDw4EG2b9/+wb5yALdu3fqip2AsjgfRLz1nxaGgOStrFYf8iM+Z/ETOBEEQio7cK6WEhITQokULAFRUVEhISEBBQYGhQ4eKrk+lTEZGBj/88AM1a9akc+fOJR2OIAiCIAiCUErJ3VKhp6cnLXJnYWFBYGAgVapUISYmhoSEhCIPUCg+O3bs4MqVK5w5c6bA87zb2NgUc1RfHpEz+YmcyU/kTH4iZ4IgCEVH7paKevXqcfr0aQDatWvHhAkT+P777xk0aBCNGzcu8gCF4pGSksLEiRNp3bq1XD+3gixiJcgSOZOfyJn8RM7kJ3ImCP+5f/8+9evXR1tbGw8Pj5IORyiF5K5U+Pr6SkvRjxs3jmHDhhEeHk6bNm1YtmxZkQcoFI81a9YQEhLCvHnz5Drv+fPnxRTRl0vkTH4iZ/ITOZOfyJnwIa9eveL777/HyckJLS0t7OzsaN++PadOnSrS63h6ejJ27NgiLVNePj4+aGlpcffuXY4dO5brMf3790dFRYVhw4bl2Ddy5EhUVFTo379/cYcqfKbk7v5kYGAg/V1RUZHRo0dL3ycmJhZJUELxiomJwcfHh/79+4u1RgRBEAQhFyEhITRu3Bh9fX3mzZuHs7MzqampHDt2jFGjRnHnzp2SDjGHlJSUAk26kpugoCBatmz5wW6BVlZW/PnnnyxcuBANDQ0ga82Xbdu2YW1tXahrC18GuVsqcpOcnMzKlSupXr16URQnFDNfX18SEhKYMWOG3OeKn7H8RM7kJ3ImP5Ez+YmclT7Xgt+yMyCMa8E5p5IuaiNHjkRBQYHz58/TsWNHnJycqFq1KmPGjOHcuXPScdHR0QwePBgLCwsMDQ1p3rw5N2/elPb7+Pjg4eHBpk2bcHBwwMjIiJ49e0rTYffv35+zZ8+yfPlyVFRUUFFRISQkBMhaR6p169bo6+tTvnx5+vTpQ0REhFS2p6cno0aNYuzYsZibm9OyZctc7yUjI4NZs2Zha2uLlpYWHh4eHD16VNqvoqLCtWvXmDVrFioqKvj4+OSZl+rVq2NpacmePXukbXv27MHKygo3NzeZY48ePUrjxo0xNjbGzMyMdu3aERQUJO1PSUlh1KhRWFlZoa2tTYUKFZg/fz4AmZmZ+Pj4YG9vj5aWFtbW1jIvsoXPT4ErFcnJyfj4+NC0aVO8vLw4ePAgAJs3b6Z69eqsXr2aoUOHFlugQtH4999/Wbx4MWPHjqVcuXJyn//w4cNiiOrLJnImP5Ez+YmcyU/krHSZvSeE1gtuMcrvEa0X3GL2npBiu1ZUVBRHjx5l6NChaGlp5divr68v/b1bt26Eh4dz4MABAgICqF69Ol5eXkRFRUnHPHnyhP3797N371727dvH2bNn8fX1BbKm6q9Tpw4DBgwgNDSU0NBQrKysiI6OpkWLFri5uXHx4kX++usvwsLC6N69u0wsf/zxB6qqqvj7+7Ny5cpc72fZsmUsXryY+fPnc+3aNVq0aEGHDh149OgRAKGhoVKFKTQ09INdsfr27Yufn5/0/e+//06fPn1yHBcfH8/o0aO5ePEiR48eRVFREW9vbzIyMgBYsWIFf/31F1u3buXu3bv4+flJLSW7d+9m6dKlrFq1isDAQHbu3Imzs3O+cQklq8Ddn+bOncvvv/9O48aNuXz5Mv369aNHjx5cuXKFmTNn0r59e5SUlIozVqEITJs2DS0tLcaPH1+o8+Pj44s4oi+fyJn8RM7kJ3ImP5Gz0uNa8FtWHv9XZtvK4//yjZsR7nY6RX69x48fk5mZScWKFfM97ty5c1y+fJkXL16gpqYGZPUG2L9/P7t27WLQoEFAVkvBunXr0NHJirVnz56cOnWKmTNnoqenh6qqKpqampibm0tlr1q1Cjc3N2bNmiVt+/XXX7Gzs+Phw4c4OTkB4ODg8MHxkYsXL+aHH36ga9euQNYz3ZkzZ1i2bBnLly/H3NwcJSUltLW1ZWLIS8+ePZk8eTJPnz4F4Pz582zevJmzZ8/KHJc9Bvfd+C0sLLh37x7Ozs48e/YMBwcH6tevj4KCgkzXq2fPnmFubo6npycqKipYW1tTq1atD8YmlJwCVyr27dvH6tWr+eabb7h37x4NGzYkLS2Nv//+u8DTkQol686dO2zYsIElS5agq6tbqDK0tbWLOKovn8iZ/ETO5CdyJj+Rs9LjSVjuYzafhCUWS6UiMzOzQMfdunWLuLi4HIv/JiYm8uTJE+l7W1tbqUIBYG5uTnh4+AfLPnPmjEyrSLYnT55IlQp3d/d8y4mNjeXFixfUq1dPZnu9evW4detWvufmxcTEhJYtW7Jx40YyMzNp2bIlxsbGOY579OgRM2bM4NKlS0REREgtFKGhoTg7O9O7d2+++eYbqlatSosWLWjVqhXNmzcHwNvbm+XLl+Pk5ESLFi345ptvaN26NcrKcg8HFj6RAv9kXrx4gaurKwBVqlRBTU2NYcOGiQpFKfLTTz9hZ2fHkCFDCl2Gg4NDEUZUNoicyU/kTH4iZ/ITOSs97E015Nr+sRwdHVFQUODBgwf5HhcfH4+FhQUnTpzIse/dysD7D8IKCgrSA3Ze4uLiaN26NXPmzMmxz8LCQvp7bt2zPoW+ffvy/fffA+Q5+2eHDh2wtrZmzZo1WFhYkJGRgZubGykpKUBWhejRo0ccOXKEkydP0r17dzw9Pdm+fTtWVlbcvXuXkydPcuLECUaOHMnChQs5deoUKioqn+w+hYIr8JiK9PR0mRkFlJWVS+yDLMhSUlIiJCQEHR2dfL8OHjzI3LlzCz0zBMCNGzeKLvAyQuRMfiJn8hM5k5/IWenhbqfD8OblZbaNaFG+WFopAAwNDWnRogWrV6/OtZtcdHQ0kDVo+dWrVygrK+Pg4CDzldub+7yoqqrmWDelevXq3Lt3D1tb2xxly/P8paurS7ly5Th//rzM9vPnz1O5cuUCl/M+Ly8vUlJSSE1NpUWLFjn2R0ZG8uDBAyZOnEjTpk2pXLkyb968yTW+Ll268Msvv7BlyxZ2794tjUfR0NCgdevWLFmyhBMnTnDx4kVu375d6JiF4lXglorMzEyGDx8u9RlMSkpi7NixOT7YGzduLNoIhQ8aPHgwRkZGH2yuLVeuHN7e3p8oKkEQBEEoOpM62PKNmxFPwhKxN9UotgpFtmXLltG4cWPq1avHtGnTcHFxIS0tjRMnTrB27Vpu376Np6cnderUoVOnTsybNw9HR0devHjB4cOHadeuHTVq1CjQtWxsbLh06RIhISFoa2tjaGjI0KFDWbduHb169WLcuHEYGhoSFBTE9u3bWbt2rVzjWMeOHSvNpOTq6oqfnx83b978qGc2JSUl6QE/t1gMDAwwMjLi119/xdzcnNDQUCZOnChzzOLFi7GwsMDNzQ1FRUV27tyJubk5+vr6+Pn5kZ6eTq1atdDU1GTLli1oaGh8cMpboeQUuFLRrVs3me87d+5c5MEIhWNpaSk1QRY3KyurT3KdL4nImfxEzuQnciY/kbPSx91Op9grE9ns7e25dOkSc+fOZfz48bx8+RITExPc3d1ZsWIFkNWN6cCBA0yZMoWBAwcSHh6Oubk5DRo0yDHOIj9jx46lf//+VKtWjcTERB49eoStrS3+/v5MnDiRli1bkpycjI2NDS1atEBRUb4VAUaOHElsbCzjx48nLCyMypUrs2fPHhwdHeUq5335jc9UVFRk8+bNjBkzBjc3N5ycnFiyZAmenp7SMTo6Ovz88888fvwYJSUlatSowf79+1FUVERfXx9fX19++OEH0tPTcXZ2Zu/evRgZGX1UzELxUYiKiirYaCQhT7Gxsdja2hITE1PoAdClxatXrwo0M4TwH5Ez+YmcyU/kTH5lMWexsbHo6ekREhLyyf6/SklJISIiAhsbG9TV1T/JNQVBKBpJSUk8ffoUY2PjD3afL5LF74SyI3v6OKHgRM7kJ3ImP5Ez+YmcCYIgFB1RqRAEQRAEQRAE4aOISoUgl2rVqpV0CKWOyJn8RM7kJ3ImP5EzQRCEoiMqFYJcgoODSzqEUkfkTH4iZ/ITOZOfyJkgCELREZUKQS5v374t6RBKHZEz+YmcyU/kTH4iZ4IgCEWn1FQq3rx5w+DBg7G2tsbW1paRI0cSFxeX7/E//vgjtWrVoly5cri4uPDTTz8RGxsrc5yhoWGOr127dhX37ZRaGhrFs3rpl0zkTH4iZ/ITOZOfyJkgCELRKfA6FSVt8ODBvH79mt27d5OWlsaIESMYM2YMv/76a67Hv3z5kpcvX+Lj40PFihUJDQ1l3LhxvHz5Ej8/P5ljV6xYITNvsp6eXrHeS2n2MatvllUiZ/ITOZOfyJn8RM4EQRCKTqloqXjw4AEnT55k6dKl1KhRgzp16jBv3jx2797Ny5cvcz2nSpUqbNy4ka+//ho7OzsaNWrEpEmTOHr0KGlpaTLH6unpYWZmJn2JebTzdu3atZIOodQROZOfyJn8RM7kJ3ImCIJQdEpFS8Xly5fR09OjevXq0rYmTZqgqKjI1atXad26dYHKiY2NRUdHB2Vl2dseP34833//Pba2tvTt25eePXuioKCQZznJyckkJyfLlPvun1+y+Pj4MnGfRUnkTH4iZ/ITOZNfWcxZ9v1mZop1bwVBKFqlolIRFhaGiYmJzDZlZWUMDAwICwsrUBmRkZH8/PPP9OnTR2b7hAkTaNiwIZqampw+fZoffviB+Ph4hgwZkmdZixcvxtfXN8d2KyurAsUiCIIgCCUpLi5OdPX9zPj5+TFu3DgiIiJKOpRSISEhgb59+3LixAnevn1LeHg4+vr6JR1WmVailYoZM2awdOnSfI+5ePHiR18nNjaWrl27UrFiRX788UeZfT/88IP092rVqhEfH8/y5cvzrVSMGTOGYcOGSd9nZGQQHR2NgYFBvi0cpd3bt29xcXHh9u3b6OjolHQ4pYLImfxEzuQncia/spqzzMxM4uLisLCwKOlQPnvh4eFMnz6dw4cP8/r1awwMDKhWrRqTJk2ifv36AKioqLBz507atWsnV9kODg6MHDmS77//XtrWpUsXvvnmm4+KOSUlhWXLlrFlyxYeP36MpqYmTk5O9O/fn549e6KiovJR5Wfz8fFh3759XL16tUjKK4yNGzdy7tw5zp49i7Gxca6VZD8/PwYOHAiAgoIC5cqVw9PTk7lz52JqavqpQ/7ilWilYvjw4XTv3j3fY2xtbTE1NSU8PFxme1paGm/evPngh+Lt27d07twZHR0d/vjjjw/+g6pRowY///wzycnJqKmp5XqMmppajn1lqXaso6ODrq5uSYdRqoicyU/kTH4iZ/IrizkTLRQF06VLF1JSUli/fj12dna8fv2a06dPExUVVSzX09DQ+KgZyVJSUmjZsiW3bt1i+vTp1KtXD11dXQICAli0aBFubm64ubkVXcBFICUlBVVV1UKd++TJEypVqoSzs3O+x+nq6nL37l0yMjK4desWAwcO5OXLlxw6dCjHsenp6SgoKKCo+PkMOf4cY8pLiUZobGyMk5NTvl+qqqrUrFmTmJgYbty4IZ179uxZMjIy8PDwyLP82NhYOnXqhKqqKps3by7QAOzbt2+jr6+fZ4VCEARBEIQSEhCAwqZNEBBQrJeJjo7m3LlzzJ07lyZNmmBjY0OtWrX48ccfadOmDZDV2gDg7e2NioqK9H1QUBAdO3akfPny6OvrU6dOHU6ePCmV7enpydOnT/nf//6HioqK9LLTz88PY2NjmTj++usv6tSpg7a2Nubm5nh7e+cZ87Jly/j77785evQow4YNw83NDXt7e7p378758+dxdHQEsnpXzJ8/H0dHR3R0dHB3d5eZSt/f3x8VFRVOnTpF7dq10dXVpWHDhjx48ECKc+bMmdy6dUuKP3tWzejoaAYPHoyFhQWGhoY0b96cmzdvSmX7+Pjg4eHBunXrcHR0RFtbO8/72b17N66urmhpaeHg4MDixYtlcrh48WL+/vtvVFRUZGbwfJ+CggLm5uaUK1eOr7/+mhEjRnDy5EkSExOlnB84cIBq1aqhpaXFs2fPSE5OZvz48djY2KCnp0e9evXw9/eXynz69Cnt27fHxMQEPT09XF1dOXz4MJC1pMG3336LhYUFOjo6VK5cmd9//10mt9HR0VJZN27cQEVFhZCQECm/hYnpc1AqxlRUrFgRT09PRo8ezcKFC0lNTeXHH3+kY8eOUhPuixcv6NChA6tWrcLDw0OqUCQmJvLLL7/w9u1baaEjY2NjlJSUOHLkCGFhYdSoUQN1dXXOnDnD4sWLGT58eEneriAIgiAI71GcMAHFn3+Wvs/43//ImDu3WK6lra2NtrY2+/bto3bt2rm+aLxw4QLlypXjt99+w8vLCyUlJSBrvMrXX3+Nj48PampqbNq0ifbt23P37l2sra3ZsWMHHh4eDBw4kAEDBuQZw6FDh/D29mbChAls2LCBlJQUjhw5kufxW7ZswdPTU2ZSm2zvVl7mz5/Pli1bWLlyJQ4ODvz999/06dMHExMTGjVqJJ0zZcoUFixYgLGxMcOHD2fQoEGcPXuWLl26cPfuXY4dOybFk9361a1bNzQ0NDhw4AB6enr8+uuveHl5ce/ePQwNDYGsSteePXv4888/pZy97+rVq3Tv3p2pU6fSuXNnLly4wMiRIzE0NKRPnz7s2LGDiRMncvfuXXbs2CFXa4e6ujoZGRnSTKAJCQksWLCANWvWYGRkhKmpKaNGjSIwMJDNmzdjYWHBvn37aNWqFdevX8fR0ZFRo0aRkpLCqVOn0NLSIjAwUKogTZs2jcDAQA4cOICxsTFBQUEkJiYWOL7CxvQ5KBWVCoC1a9cyfvx4OnTogIKCAm3atGHevHnS/rS0NB49eiT94G7duiX19Xu/NePGjRtYW1ujrKzMunXrmDx5MpmZmdjZ2TFr1ix69+796W6sFFFTU2P8+PGiFUcOImfyEzmTn8iZ/ETOSpmAAJkKBYDizz+T0b491K5d5JfLfj747rvvWLt2LdWrV6dRo0Z06dKFatWqAUgTyOjr62Nubi6d6+rqiqurq/T9jBkz2LdvHwcOHGD48OEYGhqipKQktT7kZe7cuXTp0oVp06bJlJ2Xx48f07hx43zvKzk5mXnz5nHkyBHq1q0LgL29Pf/88w+//vqrTKVi5syZ0vfjx4+nbdu2JCUloaGhgba2NkpKSjLxnzt3jsuXL/PixQvp35Wvry/79+9n165dDBo0CMjq8rRhw4YcE/C8a8mSJTRt2pRJkyYB4OTkRGBgIIsWLaJPnz4YGhqiqamJqqpqvjl836NHj/j111/x8PCQxlKlpqayfPlyKbfPnj3Dz8+PJ0+eUK5cOQDGjh3L0aNH8fPzY9asWTx79oyOHTvi4uIi5TBbaGgobm5u1KhRA8jqxi+vwsT0OSg1lQoDA4M8F7oDsLa2lunn2KBBgw/2e2zWrBnNmjUrshi/dGpqavz0008lHUapInImP5Ez+YmcyU/krHRRePQoz+2ZxVCpAOjYsSMtW7bk3LlzBAQEcOTIEX7++Wd++eWXHDNJvisuLg4fHx8OHz7My5cvSUtLIzExkdDQULmuf/PmzXxbMt5XkGmCHz9+TEJCQo4B4SkpKTnGW2Q/MAPSg3tYWBjW1ta5ln3r1i3i4uIwMzOT2Z6YmMiTJ0+k721sbPKtUADcv3+ftm3bymyrV68ey5YtIz09Pc8WjtzExMSgr69PRkYGSUlJ1K9fn19++UXar6qqKlUUAe7cuUN6ejpVqlSRKSc5ORkjIyMARowYwYgRIzh+/Dienp506NBBKmPIkCF06dKF69ev07x5c9q2bUu9evUKHG9hY/oclJpKhSAIgiAIZVNmHt078tpeVNTV1aUXkJMmTWLw4MH4+PjkW6kYP348J0+eZP78+VSoUAENDQ26du1KSkqKXNeWd9C2o6OjNO4hL3FxcQDs379feuOd7f1Wu3cntsme2TIjIyPPsuPj47GwsODEiRM59r07mY2mpma+MRY1HR0dLl26hKKiIhYWFjnyqqGhITNzZ1xcHEpKSgQEBOSovGR3cRowYAAtWrTg0KFDnDhxgvnz5+Pr68uIESP4+uuvCQoK4vDhw5w4cQIvLy+GDh2Kr6+vNNj63QpgampqjpgLE9Pn4PMfSi4IgiAIQtlWuzYZ//ufzKaMH34olq5P+alcuTLx8fHS9yoqKqSnp8scc/78eXr37k379u1xcXHB3Nycp0+fyhyjqqqa7wM6ZLUUnDp1qsCxde/enZMnT3L9+vUc+1JTU4mPj6dKlSqoqanx7NkzHBwcZL7kWWtLVVU1x31Xr16dV69eoaysnKPs9wegf0ilSpU4f/68zLbz58/j5OQkVysFgKKiIg4ODtjb2xeooubm5kZ6ejrh4eE57uPdrlZWVlYMGTKEHTt2MGbMGNatWyftMzExoXfv3mzcuJGFCxfy22+/AUh5ePnypXTsuwPZPzamkiYqFYIgCIIgfPYy5s4l7dw50jdsIO3cOTLmzCm2a0VGRtK8eXM2b97MrVu3CA4OZufOnSxcuFCa/Qmy+sufOnWKV69e8ebNGyCrxWDPnj3cuHGDmzdv8u233+aoQNjY2PD333/z77//5rnY3ZQpU9i+fTszZswgMDCQ27dvs2DBgjxjHjVqFPXq1cPLy4tVq1Zx8+ZNnjx5wo4dO6hfvz6PHj1CR0eHsWPH8r///Y+NGzcSFBTEtWvXWLFiBRs3bixwfmxsbAgJCeHGjRtERESQnJyMp6cnderUoVOnThw/fpyQkBDOnz/PlClTuHLlSoHLhqz1wE6dOsXs2bN5+PAhGzduZNWqVYwZM0aucgrDycmJ7t27069fP/bs2UNwcDCXLl1i/vz50jS0Y8eO5dixYwQHB3Pt2jXOnDlD5cqVAZg+fTr79+/n8ePH3L17l0OHDlGpUiUAqfI2c+ZMHj16xKFDh1iyZEmRxPQ5EJUKQRAEQRBKh9q1yezVq9hbKLS1talVqxZLly6ladOmuLm5MX36dAYMGMCyZcuk43x9fTl58iR2dnbUrFkTgAULFmBgYECjRo3o0KEDzZs3zzEj07Rp0wgJCaFixYp5LkTYuHFjtm3bxoEDB6hRowYtWrTg8uXLecaspqbGkSNH+N///sevv/5KgwYNqFu3LitWrGDEiBHSeg4zZsxg4sSJ+Pr64uLiQuvWrTl8+DB2dnYFzk/Hjh3x8vKiefPmWFhYsG3bNhQUFDhw4AANGzZk4MCBVKlShV69evH06dMc4yw+xN3dna1bt/Lnn3/i5ubGjBkzmD59er7dzorSunXr6NWrF+PHj6dq1ap4e3tz5coVqTUnPT2dUaNGSflzdHRk+fLlQFYrzuTJk3F3d6dp06YoKSmxefNmIKtl648//uD+/fu4u7uzYMECZsyYUSQxfQ4UoqKiPjyyRxAEQRAEoRBSUlKIiIjAxsamQOtFCYLw+UhKSuLp06cYGxt/cOpe0VIh5GvhwoV4eXlRvnz5Ak+LlpmZyZw5c6hcuTLlypWjQ4cOBAUFFW+gn5E3b94wePBgrK2tsbW1ZeTIkdLguLy0adMGQ0NDma+xY8d+oog/vd9++w1XV1csLCxo1qyZNP1zXvbu3Uvt2rWxsLCgfv36HD9+/BNF+vmQJ2dbtmzJ8XnK623ol+r8+fN0796dKlWqYGhoyMGDBz94zrlz52jSpAnm5uZ4eHiwZcuWTxCpIAjCl0FUKoR8paSk0K5dO/r161fgc5YtW8batWtZuHAhx48fR1NTE29vb5KSkoox0s/H4MGDuX//Prt372bbtm1cuHChQP1Ae/fuTWBgoPQ1ffr04g+2BOzevZvJkyczfvx4Tp8+jbOzM97e3oSHh+d6fEBAAIMGDaJnz56cOXOGli1b0qtXL+7du/eJIy858uYMsmY8effzVJDBgF+S+Ph4nJ2d8fX1LdDxT58+pVu3bjRo0AB/f3++++47vv/+e5mVkAVBEIS8ie5PQoFs2bKFiRMnSsvI5yUzM5MqVaowbNgwRo4cCUBsbCwVK1ZkxYoVdOrU6RNEW3IePHhA3bp1OXnypNSH9sSJE3Tt2pU7d+7k+ba4TZs2ODs7M7eYVof9nDRr1gx3d3fpYS8jIwMXFxcGDRrE6NGjcxzfv39/EhIS2LZtm7StefPmuLi4sGjRok8VdomSN2cF/fdaVhgaGvLHH3/QqlWrPI+ZPn06x44dk5lxZsCAAcTExLBz585PEeYXS3R/EoTSS3R/EkrM06dPef36NU2aNJG26erq4uHhke8Asy/F5cuX0dPTkxmU16RJExQVFT/YxWfnzp04ODhQr149fHx8SEhIKO5wP7mUlBRu3rwps+qroqIijRs3zvPzcfny5RyrxDZt2rRMfJ6gcDmDrDf11apVw9nZmZ49exIYGPgpwi21yvrnTBAE4WOJxe+EIvX69WuAHKtlmpiYEBYWVhIhfVJhYWE57l1ZWRkDA4N8779Tp05YWVlhYWHB3bt3mT59Oo8fP5Zrir/SIDIykvT09Fw/Hw8fPsz1nLCwMExNTWW2mZqalonPExQuZw4ODixfvpyqVasSGxvLihUr+Prrrzl//jzly5f/FGGXOnl9zt6+fUtiYqLcC5EJgiCUNaJSUQbNmDGDpUuX5nvMxYsXcXJy+kQRff4KmrPC6tu3r/T3KlWqYGZmRvv27QkODpZrmj9BAKhVqxa1atWS+b5OnTr8/vvvTJo0qQQjEwRBEL5UolJRBg0fPpzu3bvne0xBZ3p6X/Zc1OHh4TKrPIaHh0tzZJdGBc2ZqalpjsGzaWlpvHnzJsdb0Px4eHgA8OTJky+qUmFkZISSklKOHIWHh+c5j3lurRK5vVX+UhUmZ+9TUVHBxcWF4ODg4gjxi5DX50xHR0e0UgiCIBSAqFSUQcbGxtJS8UXNxsYGMzMz/P39cXFxAbIGal+9elWuGaQ+NwXNWc2aNYmJieHGjRu4ubkBcPbsWTIyMqSKQkHcvn0bQKZi9iVQVVXF1dWVs2fPSoNmMzIy8Pf3Z9CgQbmeU7NmTc6ePcvQoUOlbWfOnJEWmvrSFSZn70tPTycwMJBmzZoVZ6ilWs2aNXNMVVyWPmeCIAgfSwzUFvL1/Plzbt++zfPnz8nIyOD27dvcvn1bZt2F2rVr89dffwGgoKDAd999x8KFCzl8+DD37t1j2LBhmJub5zvzypeiYsWKeHp6Mnr0aK5evcrFixf58ccf6dixozTz04sXL6hdu7Y0cDs4OJgFCxZw48YNnj17xuHDhxk2bBj16tWjatWqJXk7xWLYsGFs3LiRrVu38uDBA8aNG0dCQgI9evQAYOjQofj4+EjHDxkyhJMnT7JixQoePnzIvHnzuHHjBgMHDiypW/jk5M2Zr68vp06dIiQkhJs3bzJkyBBCQ0P59ttvS+oWPrm4uDjp9xVkTSKR/bsMwMfHR6ai2q9fP54+fcq0adN4+PAh69atY+/evTLHCIIgCHkTLRVCvubOncvWrVul77NnR9m/fz8NGjQA4NGjR8TGxkrHjBo1ivj4eMaMGUNMTAx16tRhx44dZWYqwbVr1zJ+/Hg6dOiAgoICbdq0Yd68edL+tLQ0Hj16RGJiIpDVNcXf3581a9aQkJBA+fLladOmDePGjSupWyhWHTt2JDIykrlz5xIWFoazszM7duyQujM9f/4cRcX/3nfUrl2btWvXMmfOHGbNmoW9vT2bNm2iSpUqJXULn5y8OYuOjmb06NGEhYWhr6+Pq6srR44coVKlSiV1C5/cjRs3aNu2rfT95MmTAejevTsrV67k9evXUgUDslpZt23bxqRJk/jll18oV64cS5cuxdPT85PHLgjZPD09cXV1LTPTZ8vL39+fZs2aER4ejr6+fkmHU+aJdSoEQRAEQSg2pX2digsXLtCkSRO8vLzYv3//J712aa9U+Pn5MW7cOCIiIoql/JSUFKKiojAzM0NBQaFQZYSEhODo6IiJiQkPHjxAR0dH2ufh4UG7du2YOnVqUYVc6oh1KgRBEARBEIrAhg0bGD58OH///TcvXrwo6XDkkp6eTkZGRkmH8dHyug9VVVXMzc0LXaF419u3b0tt5e1zISoVgiAIgiAIuYiLi2PHjh0MGTKEli1b5rp20F9//UWdOnXQ1tbG3Nwcb29vaV9ycjITJkzAzs4OLS0tKlWqxPr166X9d+7coXXr1ujr61O+fHn69OmT71v95ORkxo8fj42NDXp6etSrVw9/f39pv5+fH8bGxhw4cIBq1aqhpaXFs2fPePPmDX379sXExARdXV1at27No0ePcpx38OBBqlatiq6uLl27diUhIYGNGzfi4OCAiYkJo0ePJj09vUDx+Pv7M3DgQGJiYlBRUUFFRUUa+1XY+3ifv78/KioqREdHy5x37NgxXFxc0NfXp1WrVrx8+TLPnGYbPnw4S5YsyXcNpA/l8enTp7Rv3x4TExP09PRwdXXl8OHD0v4P/bwzMjL4+eefqVSpElpaWtjb2zN37lxp/+3bt2nevDk6OjqYmZnx3XffyYxx7d+/P506dWLRokVYWVlhZmbGyJEjSU1NLdDP7GOJMRWCIAiCIHxSSuuaQlwJLGCpbUr6gFMFPnzHjh1UrFiRihUr0qNHD8aNG8ePP/4ovRk/dOgQ3t7eTJgwgQ0bNpCSksKRI0ek8/v168fFixdZvHgx1apVIyQkRHqIjI6OpkWLFvTv35+ff/6ZxMREJk6cSPfu3XPMRJZt1KhRBAYGsnnzZiwsLNi3bx+tWrXi+vXrODo6ApCQkMCCBQtYs2YNRkZGmJqa0qtXLx4/fsyePXvQ0dFh4sSJtG3bllu3bqGioiKdt2LFCjZt2kRcXBydO3fG29sbfX199u/fT3BwMF26dKFevXp06dLlg/HUrVuXhQsXMmPGDO7evZuVfm3tj7qPgkhISGDRokVs2LABRUVF+vbty/jx4/njjz/yPa9r166cOHGCWbNmsWzZslyPGTBgQL55HDVqFCkpKZw6dQotLS0CAwOley7Iz3vSpEmsW7eOn3/+mfr16/Py5UsePHgAQHx8PK1ataJOnTpcuHCB8PBwhgwZwqhRo2QqqmfOnMHc3Jzjx48TFBREjx49cHV1lSY3KUjuC0uMqRAEQRAEodjkNqZCaakzCm8//Pa4qGXqWJD+/Z0CH9+oUSO8vb0ZNWoUaWlpWFlZsW3bNmnSkoYNG2JnZ5drC8bDhw+pWrUqR44cyXXA/5w5czh37hyHDh2Stj1//hw7Ozvu3r2Lk5OTzJiKZ8+e4eTkxJMnTyhXrpx0jpeXFzVr1mTWrFn4+fkxcOBArly5gqurK5A1mUqVKlXw9/enXr16AERGRmJnZ8f69evx9vaWzrt//z4VKlQAsmad27x5M//++6/0YNyqVStsbGxYtWpVgeN5f0xFYe8jN+8P1M7tPlavXs3s2bNlJmZ4V/aYisuXLxMWFkb79u25ffs2FSpUkBlTUZA8Vq9enY4dOzJlyhS5f94WFhZYWFiwdOlSBgwYkOP83377jYkTJxIcHIyWlhYAhw8fpn379jx79gwzMzP69+/P2bNnefDgAUpKSkDW5BSKiops3ry5QLl/nzxjKkRLhSAIgiAIn5a2KSXyRlO74ItmPnjwgMuXL7Nz504AlJWV6dy5M+vXr5cqFTdv3sz1ATB7n5KSEo0aNcp1/61btzhz5kyusxY9efIEJycnmW137twhPT09x8x3ycnJGBkZSd+rqqpSrVo16fv79++jrKxM7dq1pW1GRkY4OTlx//59aZumpqb0IA5Zi9na2tpKFQpAZoHXgsbzvsLeR0G9fx8WFhb5dml6V4sWLahfvz7Tp0/P0bJRkDyOGDGCESNGcPz4cTw9PenQoYN0Dx/6eUdHR5OcnEzTpk1zje3+/ftSV7Bs9erVIyMjg4cPH0qLoVapUkWqUEDWeld37mRVpAv7MysoUakQBEEQBOGTkqcLUknZsGEDaWlpWFtbS9syMzNRU1Nj2bJl6Onp5bva+odWYo+Li6N169bMmTMnx77sdY3eP15JSYmAgACZh0ZA5sFfQ0OjUAOXs7tBZVNQUEBZWTnHtuwB0wWN53O4j8zMgldhZ8+eTcOGDRk7dqzc1x4wYAAtWrTg0KFDnDhxgvnz5+Pr68uIESM++PN+8uSJ3NfLTW73/7E/s4ISlQpBEARBEIR3pKWlsWnTJnx9fWnevLnMPm9vb7Zt28aQIUNwcXHh1KlT9O3bN0cZzs7OZGRkcPbs2Vy7P1WvXp09e/Zga2ub4+E9N25ubqSnpxMeHi6tE1UQlSpVIi0tjYCAAJluOw8fPqRy5coFLqcw8aiqqsoM7P6Y+/hUatWqRYcOHZg0aZLM9oLm0crKiiFDhjBkyBBpjMSIESM++PN2dHREQ0ODU6dO5dr6ValSJTZu3Eh8fLzUWnH+/HkUFRVztGrlpbhzL2Z/EgRBEARBeMfBgwd58+YN/fv3x9nZWearQ4cObNiwAYApU6awfft2ZsyYQWBgILdv32bBggUA2Nra8u233zJo0CD27dtHcHAw/v7+7NixA4ChQ4cSFRVFr169uHz5MkFBQRw7dowBAwbkeBAHcHJyonv37vTr1489e/YQHBzMpUuXmD9/vkw//fc5OjrStm1bhg4dyrlz57h58yZ9+vShfPnyMgtEyqsg8djY2BAXF8epU6eIiIggISGh0PfxKfn4+HD69GkePnwobStIHseOHcuxY8cIDg7m2rVrnDlzRqpwfOjnra6uzg8//MCECRP4448/CAoK4uLFi9Ig7B49eqCurk7//v25c+cOZ86cYfTo0fTs2VPq+vQhxZ17UakQBKFYnDt3DkNDQ2JiYvI9ztXVldWrV3+SmL777ruPnof8xIkTNGrU6IuY+10QhNxt2LABT09P9PT0cuzr0KEDV69e5datWzRu3Jht27Zx4MABatSoQYsWLbh8+bJ07MqVK+nYsSMjR47E2dmZ7777jvj4eADKlSuHv78/6enptGzZkurVqzNu3Dj09fVRVMz98WzdunX06tWL8ePHU7VqVby9vbly5QpWVlb53s9vv/1G9erVad++PQ0bNiQzM5P9+/fn6Cojrw/FU69ePQYPHkyPHj2wsLDg559//qj7+FScnJzo27cvSUlJMts/lMf09HRGjRqFi4sLrVu3xtHRkeXLlwMF+3lPmjSJMWPGMGPGDFxcXOjZs6c0hkVTU5ODBw8SFRVF3bp16dq1K1999VWeM1XlpThzL2Z/EoQybPjw4WzduhXI6odpaWlJ165dGTt2bIGa4/OTkpLCmzdvMDU1RUFBgS1btjBx4kRCQkJkjouIiEBTUxNNTc2Put6H3Llzh3bt2nHz5s2P7jvq6enJ4MGD6dq1axFFJwhfrtK+orYglGViRW1BEArM09OTwMBArly5wvDhw5k/f770ZuVjqKqqYmZm9sGBdsbGxsVeoQBYu3Yt7dq1K5LBaN27d2ft2rVFEJUgCIIgfBlEpUIQyjg1NTXMzMywsrKif//+NG7cWFoBNDo6mqFDh2JnZ0f58uXp3LkzQUFB0rmhoaF0794dOzs7LC0tqVu3rrSIz7vdn86dO8eIESOIjY3F0NAQQ0ND5s2bB+Ts/vT8+XN69uyJlZUV1tbW9OvXT2Y6wHnz5tGoUSO2b9+Oq6srNjY2DBgwgLdv3+Z5j+np6ezfv5+vv/5aZrurqys///wzQ4cOxcrKimrVqnH48GEiIiKkGBo0aMD169dlzvv666+5fv06wcHBhcy6IAiCIHxZRKVCEAQZGhoapKamAlndo65fv86WLVs4evQomZmZdO3aVdr/ww8/kJyczMGDBzl37hzTp0+XmUM7W61atZgzZw46OjoEBgYSGBjIiBEjchyXkZFBz549efPmDQcOHGD37t08ffo0x0wYISEhHDx4kK1bt7Jt2zbOnz/P0qVL87ynu3fvEhsbi5ubW459q1evpnbt2pw5c4YWLVrw3XffMXToUDp37szp06exs7Nj6NChMlMSWlpaYmpqyoULFwqUU0EQBEH40okpZQVBALLmX/f39+fUqVMMGjSIoKAgDh8+zOHDh6XFftauXYuLiwsHDx6kffv2PH/+nDZt2kgL6dja2uZatqqqKrq6uigoKOQ7S4W/vz/37t3j+vXrWFpaArBq1Srq1avHtWvXcHd3B7IqHytXrkRHRweALl264O/vz+TJk3MtNzQ0FCUlJUxMTHLsa968uTQd5A8//MD69eulgXgAo0aNwsvLi7CwMJnYzc3NCQ0NzfNeBEEQBKEsES0VglDGHT16FCsrKywsLOjSpQsdOnTgxx9/5OHDhygrK1OjRg3pWENDQxwcHKRp9gYPHszChQv5+uuvmTt3Lnfv3v2oWB4+fEj58uWlCgVkzc2tp6cnM7WflZWVVKGArJVfIyIi8iw3KSkJNTW1XMd3vLuyqKmpaZ7b3i9fXV2dxMTEgt6aIAiCIHzRRKVCEMq4Bg0a4O/vz5UrV3jx4gWrVq3KtQtTbnr37s21a9fo2rUrgYGBNG3a9JMMYM5vxdDcGBoakpCQQEpKSr5lZVc6ctv2fvlv3rzByMhI/uAFQRAE4QskKhWCUMZpaWlhb2+PpaWlzDSyTk5OpKWlceXKFWlbVFQUjx8/pmLFitI2S0tL+vXrx8aNGxk+fDgbN27M9TqqqqofXNvBycmJf//9l+fPn0vb7t+/T0xMjMw15eXi4gLAgwcPCl3Gu5KSkggJCaFatWpFUp4gCIIglHaiUiEIQq4qVKhAy5YtGT16NBcvXuTOnTsMGTIECwsLWrZsCcCECRM4efIkT58+5ebNm/z99984OTnlWp6VlRVxcXH4+/sTGRlJQkJCjmOaNGlClSpVGDJkCDdv3uTq1asMGzaM+vXrU7169ULfi7GxMa6urly8eLHQZbzrypUrqKmpUbNmzSIpTxAEQRBKO1GpEAQhTytWrMDNzY1u3brh5eVFZmYm27dvl7oHZWRkMH78eOrUqUPnzp1xcHCQVkx9X+3atenXrx8DBgzA0dEx11VAFRQU2Lx5M/r6+rRu3ZoOHTpgY2PDunXrPvpevv32W3bs2PHR5QDs2rULb2/vT7K+hiAIZZenpydjx44t6TA+W/7+/qioqBAdHV3SoQiIFbUFQSgjEhMTqVWrFuvWraNWrVqFLicyMpJatWpx6tQpbGxsijBCQfgylfYVtS9cuECTJk3w8vJi//79n/Tanp6euLq6smjRok963aLi5+fHuHHj8p1I42OkpKQQFRVVoIVWP2T37t2sXLmSGzdukJ6ejp2dHZ06dWLYsGEYGhri5+fHwIEDAVBUVERXVxdHR0datmzJyJEj0dPTk8rq378/f/zxB4MGDWLVqlUy1xk5ciRr1qzh22+/Zf369R8V86cgVtQWBEF4j4aGBqtXryYqKuqjynn27BkLFiwQFQpBKCM2bNjA8OHD+fvvv3nx4kVJhyOX9PT0D45lKw3yug9VVVXMzc0/ukIxZcoUevToQY0aNThw4AA3btxgwYIF3Lp1i02bNknH6erqEhoaSkhICGfPnmXgwIFs2rSJGjVq5PhsWFlZ8eeff8rMEpiUlMS2bduwtrb+qHg/V6JSIQhCmdGgQYMcq2rLq3r16nTs2LGIIhIE4XMWFxfHjh07GDJkCC1btsx1Ioq//vqLOnXqoK2tjbm5Od7e3tK+5ORkJkyYgJ2dHVpaWlSqVEnm7fSdO3do3bo1+vr6lC9fnj59+uT7Vj85OZnx48djY2ODnp4e9erVw9/fX9rv5+eHsbExBw4coFq1amhpafHs2TPevHlD3759MTExQVdXl9atW/Po0aMc5x08eJCqVauiq6tL165dSUhIYOPGjTg4OGBiYsLo0aNJT08vUDz+/v4MHDiQmJgYVFRUUFFRwcfH56Pu433vd3/KPu/YsWO4uLigr69Pq1atePnyZZ45vXTpEvPmzcPX15f58+dTr149bG1tadasGX/++Se9e/eWjlVQUMDc3BwLCwsqV65M//79OXv2LHFxcfz0008y5VavXh1LS0v27NkjbduzZw9WVla5LsT6JRCVCkEQBEEQhFzs2LGDihUrUrFiRXr06MHvv/9OZuZ/vcYPHTqEt7c333zzDZcvX+bo0aMyEzj069eP7du3s3jxYm7fvs2qVavQ1tYGIDo6mhYtWuDm5sbFixf566+/CAsLo3v37nnGM2rUKC5evMjmzZu5du0a3t7etGrVSqaCkJCQwIIFC1izZg03b97E1NSUAQMGcO3aNfbs2cPff/9NZmYmbdu2JTU1Vea8FStWsGnTJg4ePIi/vz/e3t4cOXKE/fv38/vvv/Prr7+ya9euAsVTt25dFi5cKL3dDw0NlcaHFPY+CiIhIYFFixaxYcMGTp06RWhoKOPHj8/z+K1bt6Ktrc3QoUNz3a+vr5/v9UxNTenevTt//fWXTIULoG/fvvj5+Unf//777/Tp06dA91EaiRW1BUEQBEH4pHoc7kFkYuQnv66RhhFbvtlS4OM3bNhAjx49APDy8mLgwIGcPXuWxo0bAzB37ly6dOnCtGnTpHNcXV2BrMU8d+zYwZEjR/D09ATA3t5eOm7VqlW4ubkxa9Ysaduvv/6KnZ0dDx8+zDGT3rNnz/Dz8+PJkyeUK1cOgLFjx3L06FH8/PykclJTU1m+fLkUx6NHjzhw4AD+/v7Uq1cPgI0bN2JnZ8e+ffuklpXU1FRWrFhBhQoVAOjYsSObN2/m33//RVtbmypVqtCkSRPOnDlDly5dChSPnp6e9Hb/Y++joFJTU1m5cqV0H0OHDmX27Nl5Hv/48WPs7OxyrH8kj4oVK/L27VsiIyNlKj89e/Zk8uTJPH36FIDz58+zefNmzp49W+hrfc5EpUIQBEEQhE8qMjGSsMSwkg4jXw8ePODy5cvs3LkTAGVlZTp37sz69eulSsXNmzcZMGBAruffvHkTJSUlGjVqlOv+W7ducebMmVzfhD958iRHpeLOnTukp6dTpUoVme3JyckyC3GqqqrKrKFz//59lJWVqV27trTNyMgIJycn7t+/L23T1NSUHsQBzMzMsLW1lVpWIOutfHh4uFzxvK+w91FQ79+HhYUFYWF5f9bebXkqrOwy3h/bYWJiInWby8zMpGXLlhgbG3/09T5XolIhCIIgCMInZaRRMqvRy3PdDRs2kJaWJjOoNjMzEzU1NZYtW4aenh4aGhp5np/fPsgar9G6dWvmzJmTY5+FhUWuxyspKREQEICSkpLMvncf/DU0NAo1cPn9N/UKCgoyC6Jmb8seMF3QeD6H+8iv4uDo6Mg///xDampqoVsr7t+/j66ubq6Vqb59+/L9998D5DqV+pdEVCoEQRAEQfik5OmCVBLS0tLYtGkTvr6+NG/eXGaft7c327ZtY8iQIbi4uHDq1Cn69u2bowxnZ2cyMjL4v/buPybLev/j+JNb5g9+SUqJICGiBB4YkpSmBg2YOE1+eewbTjCg4yCFvD0sHYHL2y38cVwOJV1CzFytvitJHSc7Gk07IYh864QLo9CJBiqIpohIt9zfP1z3ORwpfyBg9Hps/sHnuq7P/b4+m9v9uj+fz3UdOnTIuvzpPwUFBVFcXMzYsWNv+fLenUmTJnHjxg2ampqYMWPGHd+Lr68vZrOZiooK6/KnCxcuUFtbi5+f3x33cy/1DB48+JZ9Bvd6H73l+eefZ8uWLWzdupWMjIxbjl+6dOk391WcP3+e999/n6ioKAyGW7cqR0ZG0tHRgY2NDTNnzryfpT9wtFFbRERE5D+UlJRw8eJFkpOT8ff37/IvNjaWoqIi4OajSD/44ANWr15NTU0N1dXVbNiwAYCxY8eSkJDAX/7yF3bv3s3Jkyc5ePCg9SWcaWlptLS0sHDhQiorK6mrq+Mf//gHKSkpt3wRB/Dx8SE+Pp6kpCSKi4s5efIkR44cYd26dfz973//1XuZMGECUVFRpKWl8c9//pN//etfLFq0CHd3d6Kiou55jO6kHk9PT1pbWyktLaW5uZm2trZ7vo/eMmXKFDIzM3nllVdYuXIlhw8f5tSpU5SWlvL88893eeKXxWLh7NmzNDY2UlNTQ1FRESEhIQwfPrzbGSeAQYMGUV1dzTfffHPLzMxAo1AhIiIi8h+KiooIDw/v8kKzX8TGxlJVVcU333xDaGgo77//Pnv37iU4OJiZM2dSWVlpPTc/P5+4uDjS09Px9/cnNTWVq1evAuDm5sbBgwe5ceMGs2fPJigoiL/+9a84Ozt3+4s3QGFhIQsXLuSVV17hT3/6E3/+8585evQoHh4ev3k/BQUFBAUFERMTw9NPP43FYmHPnj092px8J/VMmzaNxYsXs2DBAkaPHs3f/va3Ht1Hb8nNzWXnzp0cOXKEOXPmEBgYSGZmJgEBAV0eKXv58mU8PDzw9PTk6aefZvv27SQkJFBZWdntkrVfODk54eTk1Be30q/0Rm0RERHpNb/3N2qL/JHpjdoiIiIiItJnFCpERERERKRHFCpERERERKRHFCpERERERKRHFCpERERERKRHFCpERERERKRHFCpERERERKRHFCpERERERKRHFCpERERERKRHFCpERERERKRHFCpEREREfsXZs2cxGo34+vri4OCAu7s7ISEhbNu2jba2tv4uT+SBYdvfBYiIiIg8iE6cOEFoaCjOzs6sWbMGf39/hgwZwrFjxygoKMDd3Z25c+fedb8dHR0MHjy4FyoW6T+aqRARERHpRnp6Ora2tpSXlzN//nz8/PwYN24cUVFR7Nmzh2effZYXX3yR6OjoLtf9/PPPuLm58fbbbwMQHh5ORkYGy5cvx9XVldmzZwNw6NAhnnrqKezt7fHw8CArKwuz2Wzt56OPPmLSpEk4OjoyatQoIiMjuXr1qvV4UVERgYGB1uszMjKsx+rr64mLi8PZ2ZkRI0YQHx/PuXPnrMdNJhOTJ0/mrbfewsvLCycnJ+Lj4/npp5+63EthYSEBAQE4ODjg7+/P1q1b798Ay4CiUCEiIiLyXy5cuMD+/ftJS0vD3t6+23NsbGxITk7m008/pbGx0dpeUlJCW1sbzz33nLVt586dDB48mIMHD5Kfn8+PP/7I3LlzCQ4Opqqqii1btlBUVMTrr78OQGNjIwsXLuSFF16gurqaAwcOEBMTg8ViAWDbtm1kZGSQkpLCV199xa5du/D29gags7OTuLg4Wlpa+Oyzz/jkk084ceIECxYs6FJ/XV0dH374IcXFxZSUlPD111+zdOlS6/H33nuP1atXYzKZqK6uZs2aNbz22mu8884792eQZUDR8icRERHpU/XP/Q83LjT3+ecOGunCo//7wR2d+8MPP2CxWPDx8enS7urqSnt7OwBpaWnk5uby2GOP8e6775KZmQnAjh07mDdvHg4ODtbrxo8fz9q1a61/5+Tk4OHhQV5eHjY2Nvj6+tLQ0EBWVhbZ2dk0NjZiNpuJjY3F09MTgICAAOv1ubm5GI3GLrMTTzzxBAClpaUcO3aM77//Hg8PD+DfsxqVlZXW89rb2ykqKsLd3R2ATZs2ERUVxYYNG3B1dcVkMrF+/XpiY2MB8PLyoqamhu3bt5OYmHhH4yh/HAoVIiIi0qduXGjGfO58f5dxT8rKyujs7CQxMZHr168DkJSURGFhIZmZmZw7d459+/axf//+Ltc9/vjjXf4+fvw4U6ZMwcbGxto2bdo0WltbOXPmDIGBgYSFhREUFMTMmTOJiIhg3rx5PPTQQ5w/f56GhgbCwsK6rbGmpgYPDw9roACYOHEizs7OHD9+3BoqHn30UWugAJg6dSqdnZ3U1tbi6OhIXV0dixcvJjU11XqO2Wxm+PDh9zh6MpApVIiIiEifGjTS5YH/3PHjx2NjY0NtbW2X9nHjxgEwbNgwa1tCQgKvvvoqhw8fpry8HC8vL2bMmNHlul9bQvWrtQ4axL59+ygrK+PAgQPk5+ezatUqvvzyS1xcen/8WltbgZvLrJ588slbahP5bwoVIiIi0qfudAlSfxo5ciQRERG8+eabLFmy5DdDwciRI4mOjmbHjh2Ul5ezaNGi2/bv6+tLcXExFovFOltRVlaGo6MjY8aMAW7u2Zg+fTrTp08nOzsbb29vPv74Y4xGI2PHjqW0tJRnnnnmlr79/Pw4ffo0p0+fts5WfPvtt1y6dAk/Pz/refX19TQ0NODm5gZARUUFBoMBHx8fRo0ahZubGydPnrxlL4ZIdxQqRERERLqxefNmQkNDmTp1Kjk5OQQEBGAwGDh69CjfffddlyVNycnJREdHc+PGDRISEm7bd2pqKnl5ebz88su89NJL1NbWYjKZWLZsGQaDgYqKCj7//HMiIiJ45JFHOHLkCE1NTdZQkJOTw5IlS3j44YeZNWsWV65coaysjKVLlxIeHo6/vz+JiYls3LgRs9lMeno6ISEhBAcHW2sYOnQoycnJrFu3jitXrmA0Gpk/fz6urq4ArFq1CqPRiJOTE5GRkVy/fp2qqiouXryI0Wi8z6Mtv3cKFSIiIiLd8Pb2prKykrVr15Kdnc2ZM2cYMmQIfn5+LF++vMteg/DwcEaPHs3EiROtv/z/Fnd3d/bu3cuKFSuYPHkyI0aMICkpiaysLACcnJz44osvyMvL4/Lly3h6erJ+/XpmzZoFQGJiIu3t7eTl5bFixQpcXFyIi4sDbs5w7Nq1i2XLlhEWFobBYCAyMpJNmzbdcn8xMTFERUXR0tLCnDlz2Lx5s/V4SkoKdnZ2bNy4kZUrV2Jvb4+/v3+XzeEiv7BpaWmx9HcRIiIiMjB1dHTQ3NyMp6cnQ4cO7e9yek1rayuenp4UFBRYn5b0IDOZTOzevZuqqqr+LkUeYO3t7Zw6dQoXF5fbvrBRMxUiIiIi96izs5Pm5mbeeOMNnJ2d7+kN2yIDgUKFiIiIyD2qr69nwoQJjBkzhsLCQmxt9dVK/pi0/ElERER6zR9l+ZPIQHQ3y58MfVSTiIiIiIgMUAoVIiIiIiLSIwoVIiIiIiLSIwoVIiIiIiLSIwoVIiIiIiLSIwoVIiIiIiLSIwoVIiIiIiLSIwoVIiIiIr/i7NmzGI1GfH19cXBwwN3dnZCQELZt20ZbW1t/lyfywNBrH0VERES6ceLECUJDQ3F2dmbNmjX4+/szZMgQjh07RkFBAe7u7sydO/eu++3o6Ljti8REfm80UyEiIiLSjfT0dGxtbSkvL2f+/Pn4+fkxbtw4oqKi2LNnD88++ywvvvgi0dHRXa77+eefcXNz4+233wYgPDycjIwMli9fjqurK7Nnzwbg0KFDPPXUU9jb2+Ph4UFWVhZms9naz0cffcSkSZNwdHRk1KhRREZGcvXqVevxoqIiAgMDrddnZGRYj9XX1xMXF4ezszMjRowgPj6ec+fOWY+bTCYmT57MW2+9hZeXF05OTsTHx/PTTz91uZfCwkICAgJwcHDA39+frVu33r8BlgFFoUJERETkv1y4cIH9+/eTlpaGvb19t+fY2NiQnJzMp59+SmNjo7W9pKSEtrY2nnvuOWvbzp07GTx4MAcPHiQ/P58ff/yRuXPnEhwcTFVVFVu2bKGoqIjXX38dgMbGRhYuXMgLL7xAdXU1Bw4cICYmBovFAsC2bdvIyMggJSWFr776il27duHt7Q1AZ2cncXFxtLS08Nlnn/HJJ59w4sQJFixY0KX+uro6PvzwQ4qLiykpKeHrr79m6dKl1uPvvfceq1evxmQyUV1dzZo1a3jttdd455137s8gy4Ci5U8iIiLSpz5a939cu9LR5587zHEw81Y8fkfn/vDDD1gsFnx8fLq0u7q60t7eDkBaWhq5ubk89thjvPvuu2RmZgKwY8cO5s2bh4ODg/W68ePHs3btWuvfOTk5eHh4kJeXh42NDb6+vjQ0NJCVlUV2djaNjY2YzWZiY2Px9PQEICAgwHp9bm4uRqOxy+zEE088AUBpaSnHjh3j+++/x8PDA/j3rEZlZaX1vPb2doqKinB3dwdg06ZNREVFsWHDBlxdXTGZTKxfv57Y2FgAvLy8qKmpYfv27SQmJt7ROMofh0KFiIiI9KlrVzq4eqnvQ8X9UFZWRmdnJ4mJiVy/fh2ApKQkCgsLyczM5Ny5c+zbt4/9+/d3ue7xx7uGmePHjzNlyhRsbGysbdOmTaO1tZUzZ84QGBhIWFgYQUFBzJw5k4iICObNm8dDDz3E+fPnaWhoICwsrNsaa2pq8PDwsAYKgIkTJ+Ls7Mzx48etoeLRRx+1BgqAqVOn0tnZSW1tLY6OjtTV1bF48WJSU1Ot55jNZoYPH36PoycDmUKFiIiI9Klhjv2zSfluPnf8+PHY2NhQW1vbpX3cuHE3+xo2zNqWkJDAq6++yuHDhykvL8fLy4sZM2Z0ue7XllD9mkGDBrFv3z7Kyso4cOAA+fn5rFq1ii+//BIXF5e76utetLa2AjeXWT355JO31Cby3xQqREREpE/d6RKk/jRy5EgiIiJ48803WbJkyW+GgpEjRxIdHc2OHTsoLy9n0aJFt+3f19eX4uJiLBaLdbairKwMR0dHxowZA9zcszF9+nSmT59OdnY23t7efPzxxxiNRsaOHUtpaSnPPPPMLX37+flx+vRpTp8+bZ2t+Pbbb7l06RJ+fn7W8+rr62loaMDNzQ2AiooKDAYDPj4+jBo1Cjc3N06ePHnLXgyR7ihUiIiIiHRj8+bNhIaGMnXqVHJycggICMBgMHD06FG+++67LkuakpOTiY6O5saNGyQkJNy279TUVPLy8nj55Zd56aWXqK2txWQysWzZMgwGAxUVFXz++edERETwyCOPcOTIEZqamqyhICcnhyVLlvDwww8za9Ysrly5QllZGUuXLiU8PBx/f38SExPZuHEjZrOZ9PR0QkJCCA4OttYwdOhQkpOTWbduHVeuXMFoNDJ//nxcXV0BWLVqFUajEScnJyIjI7l+/TpVVVVcvHgRo9F4n0dbfu8UKkRERES64e3tTWVlJWvXriU7O5szZ84wZMgQ/Pz8WL58eZe9BuHh4YwePZqJEydaf/n/Le7u7uzdu5cVK1YwefJkRowYQVJSEllZWQA4OTnxxRdfkJeXx+XLl/H09GT9+vXMmjULgMTERNrb28nLy2PFihW4uLgQFxcH3Jzh2LVrF8uWLSMsLAyDwUBkZCSbNm265f5iYmKIioqipaWFOXPmsHnzZuvxlJQU7Ozs2LhxIytXrsTe3h5/f/8um8NFfmHT0tJi6e8iREREZGDq6OigubkZT09Phg4d2t/l9JrW1lY8PT0pKCiwPi3pQWYymdi9ezdVVVX9XYo8wNrb2zl16hQuLi63fWGjZipERERE7lFnZyfNzc288cYbODs739MbtkUGAoUKERERkXtUX1/PhAkTGDNmDIWFhdja6quV/DFp+ZOIiIj0mj/K8ieRgehulj8Z+qgmEREREREZoBQqREREpNdZLFoYIfJ7czf/bxUqREREpNfY2tpisVi4du1af5ciInfp2rVrWCyWO9orpN1EIiIi0msMBgN2dnY0NTUBMGzYMOsbpEXkwfTLDwFNTU3Y2dlhMNx+HkKhQkRERHqVs7MzAOfPn1egEPmdsFgs2NnZWf//3o6e/iQiIiJ9orOzE7PZ3N9liMgdsLW1vaMZCuv5vViLiIiIiJXBYLjtYylF5PdJG7VFRERERKRHFCpERERERKRHFCpERERERKRHFCpERERERKRHFCpERERERKRHFCpERERERKRHFCpERERERKRH/h/m9G7xkIRbAgAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "calisto.draw(plane=\"xz\")" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "calisto.draw(plane=\"yz\")" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -392,7 +254,6 @@ " # If we wanted to we could get the returned values from observed_variables:\n", " # returned_time, deployment_level, drag_coefficient = observed_variables[-1]\n", "\n", - "\n", " # Check if the rocket has reached burnout\n", " accelerometer = sensors[0]\n", " if accelerometer.measurement[2] > 0:\n", @@ -429,7 +290,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -448,7 +309,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -457,7 +318,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", @@ -478,173 +339,106 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "test_flight.altitude()" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# get first column of every row as time from [(time,(ax,ay,az)),...] = a.measured_data\n", "time1, ax, ay, az = zip(*accel_noisy_nosecone.measured_data)\n", "time2, bx, by, bz = zip(*accel_clean_cdm.measured_data)\n", "\n", "\n", - "import matplotlib.pyplot as plt\n", - "plt.plot(time1, ax, label='Noisy Accelerometer')\n", - "plt.plot(time2, bx, label='Clean Accelerometer')\n", + "plt.plot(time1, ax, label=\"Noisy Accelerometer\")\n", + "plt.plot(time2, bx, label=\"Clean Accelerometer\")\n", + "plt.xlabel(\"Time (s)\")\n", + "plt.ylabel(\"Acceleration ax (m/s^2)\")\n", "plt.legend()\n", "plt.show()\n", "\n", - "plt.plot(time1, ay, label='Noisy Accelerometer')\n", - "plt.plot(time2, by, label='Clean Accelerometer')\n", + "plt.plot(time1, ay, label=\"Noisy Accelerometer\")\n", + "plt.plot(time2, by, label=\"Clean Accelerometer\")\n", + "plt.xlabel(\"Time (s)\")\n", + "plt.ylabel(\"Acceleration ay (m/s^2)\")\n", "plt.legend()\n", "plt.show()\n", "\n", - "plt.plot(time1, az, label='Noisy Accelerometer')\n", - "plt.plot(time2, bz, label='Clean Accelerometer')\n", + "plt.plot(time1, az, label=\"Noisy Accelerometer\")\n", + "plt.plot(time2, bz, label=\"Clean Accelerometer\")\n", + "plt.xlabel(\"Time (s)\")\n", + "plt.ylabel(\"Acceleration az (m/s^2)\")\n", "plt.legend()\n", "plt.show()\n" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.0, 4.0)" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "import numpy as np\n", - "abs_a = (np.array(ax)**2 + np.array(ay)**2 + np.array(az)**2)**0.5\n", - "abs_b = (np.array(bx)**2 + np.array(by)**2 + np.array(bz)**2)**0.5\n", - "plt.plot(time1, abs_a, label='noisy')\n", - "plt.plot(time2, abs_b, label='clean')\n", + "# now plot the total acceleration\n", + "\n", + "abs_a = (np.array(ax) ** 2 + np.array(ay) ** 2 + np.array(az) ** 2) ** 0.5\n", + "abs_b = (np.array(bx) ** 2 + np.array(by) ** 2 + np.array(bz) ** 2) ** 0.5\n", + "plt.plot(time1, abs_a, label=\"noisy\")\n", + "plt.plot(time2, abs_b, label=\"clean\")\n", + "plt.xlabel(\"Time (s)\")\n", + "plt.ylabel(\"Acceleration (m/s^2)\")\n", "plt.legend()\n", - "plt.xlim(0,4)" + "plt.xlim(0, 10)\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGdCAYAAADaPpOnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACGyElEQVR4nO2dd3wUVff/P7Mpm947JIFASKihhBJAehH9Ktg7RcFHBX18sOJPUcBH7GJBEQvYUB4ULIhIB+k1dAKEhARIQkhIJXX3/v7YZMlm++7MTtnz9hXZmblz75k7t5w599x7OcYYA0EQBEEQhExQiS0AQRAEQRCEPZDyQhAEQRCErCDlhSAIgiAIWUHKC0EQBEEQsoKUF4IgCIIgZAUpLwRBEARByApSXgiCIAiCkBWkvBAEQRAEISs8xRaAb7RaLS5duoTAwEBwHCe2OARBEARB2ABjDJWVlYiLi4NKZdm2ojjl5dKlS4iPjxdbDIIgCIIgHCA/Px9t27a1GEZxyktgYCAA3cMHBQWJLA1BEARBELZQUVGB+Ph4fT9uCcUpL81DRUFBQaS8EARBEITMsMXlgxx2CYIgCIKQFaS8EARBEAQhK0h5IQiCIAhCVgjq8zJ//nysXLkSp06dgq+vLwYOHIi33noLKSkpZu9ZunQppkyZYnBOrVajtraWN7kYY2hsbIRGo+EtToJwBg8PD3h6etL0foIgCBsQVHnZunUrpk+fjr59+6KxsREvvfQSxowZgxMnTsDf39/sfUFBQcjKytIf89mg19fXo6CgANeuXeMtToLgAz8/P8TGxsLb21tsUQiCICSNoMrL2rVrDY6XLl2KqKgoHDhwAEOGDDF7H8dxiImJ4V0erVaLnJwceHh4IC4uDt7e3vSlS4gOYwz19fUoLi5GTk4OkpOTrS7QRBAE4c64dKp0eXk5ACAsLMxiuKqqKiQmJkKr1aJ3795444030LVrV6fTr6+vh1arRXx8PPz8/JyOjyD4wtfXF15eXjh//jzq6+vh4+MjtkgEQRCSxWWfd1qtFk8//TQGDRqEbt26mQ2XkpKCr7/+Gr/99hu+//57aLVaDBw4EBcuXDAZvq6uDhUVFQZ/1qCvWkKKULkkCIKwDZdZXqZPn45jx45h+/btFsNlZGQgIyNDfzxw4EB07twZn3/+OebNm2cUfv78+ZgzZw7v8hIEQRAEIU1c8qk3Y8YMrF69Gps3b7a6X0FrvLy80KtXL5w9e9bk9VmzZqG8vFz/l5+fz4fIiqZdu3ZYsGCB2GIQBEEQhEMIqrwwxjBjxgysWrUKmzZtQvv27e2OQ6PR4OjRo4iNjTV5Xa1W67cCUPKWAJMnTwbHcXjzzTcNzv/66692Ox3v27cPjz76KJ/iGfHLL79gxIgRCA0Nha+vL1JSUvDwww/j0KFDgqZLEARBKB9BlZfp06fj+++/x7JlyxAYGIjCwkIUFhaipqZGH2bixImYNWuW/nju3LlYt24dzp07h4MHD+LBBx/E+fPnMXXqVCFFlQU+Pj546623cPXqVafiiYyMFNRh+YUXXsA999yDnj174vfff0dWVhaWLVuGpKQkg3dtL83r8xAEQRDujaDKy2effYby8nIMGzYMsbGx+r/ly5frw+Tl5aGgoEB/fPXqVUybNg2dO3fGTTfdhIqKCuzcuRNdunQRUlRZMGrUKMTExGD+/PkWw/3yyy/o2rUr1Go12rVrh/fee8/gesthI8YYXnvtNSQkJECtViMuLg5PPfUUAJ0iacq5umfPnnjllVdMpr179268/fbbeP/99/H+++/jhhtuQEJCAvr06YOXX34Zf/31FwAgNzcXKpUK+/fvN7h/wYIF+plmW7ZsAcdx+Ouvv9CnTx+o1Wps374ddXV1eOqppxAVFQUfHx8MHjwY+/bt08dx9epVPPDAA4iMjISvry+Sk5OxZMkS/fULFy7gvvvuQ1hYGPz9/ZGeno49e/bor3/22Wfo0KEDvL29kZKSgu+++85ARo7j8Nlnn2HcuHHw9fVFUlISfv75Z4Mw+fn5uPvuuxESEoKwsDCMHz8eubm5JvOMIAjh2HzqMn7LvCi2GATfMIVRXl7OALDy8nKjazU1NezEiROspqZGf06r1bLqugZR/rRarc3PNWnSJDZ+/Hi2cuVK5uPjw/Lz8xljjK1atYq1fI379+9nKpWKzZ07l2VlZbElS5YwX19ftmTJEn2YxMRE9sEHHzDGGFuxYgULCgpia9asYefPn2d79uxhixcvZowxlp+fz1QqFdu7d6/+3oMHDzKO41h2drZJOZ966ikWEBDAGhoarD7T6NGj2RNPPGFwrkePHmz27NmMMcY2b97MALAePXqwdevWsbNnz7KSkhL21FNPsbi4OLZmzRp2/PhxNmnSJBYaGspKSkoYY4xNnz6d9ezZk+3bt4/l5OSw9evXs99//50xxlhlZSVLSkpiN9xwA/vnn3/YmTNn2PLly9nOnTsZY4ytXLmSeXl5sYULF7KsrCz23nvvMQ8PD7Zp0ya9jABYeHg4++KLL1hWVhZ7+eWXmYeHBztx4gRjjLH6+nrWuXNn9vDDD7MjR46wEydOsPvvv5+lpKSwuro6s/lhqnwSBOEciS+sZokvrGaXyq6JLQphBUv9d2tcus6LFKlp0KDL7L9FSfvE3LHw87bvFdx2223o2bMnXn31VXz11VdG199//32MHDlSbxnp1KkTTpw4gXfeeQeTJ082Cp+Xl4eYmBiMGjUKXl5eSEhIQL9+/QAAbdu2xdixY7FkyRL07dsXALBkyRIMHToUSUlJJuU7ffo0kpKS4Ol5/bnef/99zJ49W3988eJFBAcHY+rUqXjsscfw/vvvQ61W4+DBgzh69Ch+++03gzjnzp2L0aNHAwCqq6vx2WefYenSpRg3bhwA4IsvvsD69evx1Vdf4bnnnkNeXh569eqF9PR0ADpLUzPLli1DcXEx9u3bp19vqGPHjvrr7777LiZPnownnngCADBz5kzs3r0b7777LoYPH64Pd9ddd+mHMufNm4f169fj448/xqefforly5dDq9Xiyy+/1PsjLVmyBCEhIdiyZQvGjBljMu8IghCOq9UNiA32FVsMgidoYQkZ8tZbb+Gbb77ByZMnja6dPHkSgwYNMjg3aNAgnDlzxuReTnfddRdqamqQlJSEadOmYdWqVQZ+JdOmTcOPP/6I2tpa1NfXY9myZXj44Yftkvfhhx9GZmYmPv/8c1RXV4MxBgCYMGECPDw8sGrVKgC6FZiHDx9uoGwA0CshAJCdnY2GhgaDZ/Ty8kK/fv30+fH444/jp59+Qs+ePfH8889j586d+rCZmZno1auX2YUSzeVf67xuOZ2/+bg5zOHDh3H27FkEBgYiICAAAQEBCAsLQ21tLbKzs63mF0EQBGEZt7e8+Hp54MTcsaKl7QhDhgzB2LFjMWvWLJPWFHuIj49HVlYWNmzYgPXr1+OJJ57AO++8g61bt8LLywu33HIL1Go1Vq1aBW9vbzQ0NODOO+80G19ycjK2b9+OhoYGeHl5AQBCQkIQEhJitNCgt7c3Jk6ciCVLluD222/HsmXL8OGHHxrFaWkfLFOMGzcO58+fx5o1a7B+/XqMHDkS06dPx7vvvgtfX+G/vKqqqtCnTx/88MMPRtciIyMFT58gCELpuL3lheM4+Hl7ivLnzL5Kb775Jv744w/s2rXL4Hznzp2xY8cOg3M7duxAp06d4OFhWlny9fXFLbfcgo8++ghbtmzBrl27cPToUQCAp6cnJk2ahCVLlmDJkiW49957LSoA9913H6qqqvDpp5/a9BxTp07Fhg0b8Omnn6KxsRG33367xfDNjrQtn7GhoQH79u0zcOqOjIzEpEmT8P3332PBggVYvHgxAKBHjx7IzMxEaWmpyfjN5V9rh/Hdu3cbHXfu3BkA0Lt3b5w5cwZRUVHo2LGjwV9wcLCVHCEIgiCs4faWF7nSvXt3PPDAA/joo48Mzj/zzDPo27cv5s2bh3vuuQe7du3CJ598YlaZWLp0KTQaDfr37w8/Pz98//338PX1RWJioj7M1KlT9R1z6469NRkZGXjmmWfwzDPP4Pz587j99tsRHx+PgoICfPXVV+A4zmAZ/M6dO2PAgAF44YUX8PDDD1u1jPj7++Pxxx/Hc889h7CwMCQkJODtt9/GtWvX8MgjjwAAZs+ejT59+qBr166oq6vD6tWr9fLfd999eOONNzBhwgTMnz8fsbGxOHToEOLi4pCRkYHnnnsOd999N3r16oVRo0bhjz/+wMqVK7FhwwYDOVasWIH09HQMHjwYP/zwA/bu3av3QXrggQfwzjvvYPz48Zg7dy7atm2L8+fPY+XKlXj++eftXqiRIAiCaIXw/sOuxd7ZRnKhebZRS3Jycpi3tzdr/Rp//vln1qVLF+bl5cUSEhLYO++8Y3C95WyjVatWsf79+7OgoCDm7+/PBgwYwDZs2GCU/g033MC6du1qs7zLly9nw4YNY8HBwczLy4u1bduW3X///Wz37t1GYb/66isGwGBWE2PXZxtdvXrV4HxNTQ178sknWUREBFOr1WzQoEEG986bN4917tyZ+fr6srCwMDZ+/Hh27tw5/fXc3Fx2xx13sKCgIObn58fS09PZnj179Nc//fRTlpSUxLy8vFinTp3Yt99+a5A+ALZw4UI2evRoplarWbt27djy5csNwhQUFLCJEyfqZUxKSmLTpk2z6EUv5/JJEFKlebbR8YvWZ7AQ4mLPbCOOsSbvSYVQUVGB4OBglJeXG622W1tbi5ycHLRv35527bUDxhiSk5PxxBNPYObMmbzHP2/ePKxYsQJHjhzhPW4h4DgOq1atwoQJE3iNl8onQfBPuxf/BACseeoGdIlT5grsSsFS/90aGjYiLFJcXIyffvoJhYWFmDJlCq9xV1VVITc3F5988glef/11XuMmCIIglAspL4RFoqKiEBERgcWLFyM0NJTXuGfMmIEff/wREyZMsHv6NUEQBOG+kPJCWETIUcWlS5di6dKlgsUvFAobaSUIgpAdbj9VmiAIglAm9KGhXEh5IQiCIAhCVpDyQhAEQRCErCDlhSAIgiAIWUHKC0EQBKFIyOVFuZDyQhAEQRCErCDlRWFwHIdff/1VbDEIgiAIQjBIeZERhYWFePLJJ5GUlAS1Wo34+Hjccsst2Lhxo9iimeTs2bN4+OGHkZCQALVajTZt2mDkyJH44Ycf0NjYKLZ4BEEQhEyhRepkQm5uLgYNGoSQkBC888476N69OxoaGvD3339j+vTpOHXqlNgiGrB3716MGjUKXbt2xcKFC5GamgoA2L9/PxYuXIhu3bohLS3Nobjr6+vh7e3Np7gEQSgQcnlRLmR5kQlPPPEEOI7D3r17cccdd6BTp07o2rUrZs6cid27d5u9Lz8/H3fffTdCQkIQFhaG8ePHIzc3V3993759GD16NCIiIhAcHIyhQ4fi4MGDBnFwHIcvv/wSt912G/z8/JCcnIzff//dbJqMMUyePBmdOnXCjh07cMsttyA5ORnJycm47777sH37dvTo0QMAMGLECMyYMcPg/uLiYnh7e+stSu3atcO8efMwceJEBAUF4dFHHwUA/PLLL+jatSvUajXatWuH9957zyCeTz/9FMnJyfDx8UF0dDTuvPNO/TWtVou3334bHTt2hFqtRkJCAv773//qrx89ehQjRoyAr68vwsPD8eijj6Kqqkp/ffLkyZgwYQLmzJmDyMhIBAUF4bHHHkN9fb1BGvPnz0f79u3h6+uLtLQ0/Pzzz2bzjSAIgrANUl4YA+qrxfmz0RW+tLQUa9euxfTp0+Hv7290PSQkxOR9DQ0NGDt2LAIDA/HPP/9gx44dCAgIwI033qjvZCsrKzFp0iRs374du3fvRnJyMm666SZUVlYaxDVnzhzcfffdOHLkCG666SY88MADKC0tNZluZmYmTp48iWeffRYqlekixnEcAGDq1KlYtmwZ6urq9Ne+//57tGnTBiNGjNCfe/fdd5GWloZDhw7hlVdewYEDB3D33Xfj3nvvxdGjR/Haa6/hlVde0W83sH//fjz11FOYO3cusrKysHbtWgwZMkQf36xZs/Dmm2/ilVdewYkTJ7Bs2TJER0cDAKqrqzF27FiEhoZi3759WLFiBTZs2GCkZG3cuBEnT57Eli1b8OOPP2LlypWYM2eO/vr8+fPx7bffYtGiRTh+/Dj+85//4MEHH8TWrVtN5glBEARhI0xhlJeXMwCsvLzc6FpNTQ07ceIEq6mpuX6yroqxV4PE+aursumZ9uzZwwCwlStXWg0LgK1atYoxxth3333HUlJSmFarvf64dXXM19eX/f333ybv12g0LDAwkP3xxx8Gcb788sv646qqKgaA/fXXXybj+OmnnxgAdvDgQf25oqIi5u/vr/9buHAhY0z3TkJDQ9ny5cv1YXv06MFee+01/XFiYiKbMGGCQRr3338/Gz16tMG55557jnXp0oUxxtgvv/zCgoKCWEVFhZF8FRUVTK1Wsy+++MKk/IsXL2ahoaGsqur6+/nzzz+ZSqVihYWFjDHGJk2axMLCwlh1dbU+zGeffcYCAgKYRqNhtbW1zM/Pj+3cudMg7kceeYTdd999JtM1WT4JgnCYRo2WJb6wmiW+sJodv2jcJxDSwlL/3RqyvMgA5uBiBYcPH8bZs2cRGBiIgIAABAQEICwsDLW1tcjOzgYAFBUVYdq0aUhOTkZwcDCCgoJQVVWFvLw8g7iah3kAwN/fH0FBQbh8+bLNsoSHhyMzMxOZmZkICQnRW358fHzw0EMP4euvvwYAHDx4EMeOHcPkyZMN7k9PTzc4PnnyJAYNGmRwbtCgQThz5gw0Gg1Gjx6NxMREJCUl4aGHHsIPP/yAa9eu6e+tq6vDyJEjTcp68uRJpKWlGVi5Bg0aBK1Wi6ysLP25tLQ0+Pn56Y8zMjJQVVWF/Px8nD17FteuXcPo0aP1eR8QEIBvv/1Wn/cEQQiLo20nIX3IYdfLD3jpknhp20BycjI4jrPbKbeqqgp9+vTBDz/8YHQtMjISADBp0iSUlJTgww8/RGJiItRqNTIyMgx8NwDAy8vL4JjjOGi1WrPyAkBWVhZ69eoFAPDw8EDHjh0BAJ6ehsVu6tSp6NmzJy5cuIAlS5ZgxIgRSExMNAhjarjMEoGBgTh48CC2bNmCdevWYfbs2Xjttdewb98++Pr62hWXIzT7x/z5559o06aNwTW1Wi14+gRBEEqGLC8cB3j7i/PX5PdhjbCwMIwdOxYLFy5EdXW10fWysjKT9/Xu3RtnzpxBVFQUOnbsaPAXHBwMANixYweeeuop3HTTTXrn1ytXrjicnQDQq1cvpKam4t133zWr4LSke/fuSE9PxxdffIFly5bh4YcftnpP586dsWPHDoNzO3bsQKdOneDh4QFApySNGjUKb7/9No4cOYLc3Fxs2rQJycnJ8PX1NTvFvHPnzjh8+LBBXu/YsQMqlQopKSn6c4cPH0ZNTY3+ePfu3QgICEB8fDy6dOkCtVqNvLw8o7yPj4+3+nwEQRCEeUh5kQkLFy6ERqNBv3798Msvv+DMmTM4efIkPvroI2RkZJi854EHHkBERATGjx+Pf/75Bzk5OdiyZQueeuopXLhwAYDOSvLdd9/h5MmT2LNnDx544AGnLRMcx2HJkiXIysrCoEGD8Pvvv+PMmTM4ceIEFi1ahOLiYr2C0czUqVPx5ptvgjGG2267zWoazzzzDDZu3Ih58+bh9OnT+Oabb/DJJ5/g2WefBQCsXr0aH330ETIzM3H+/Hl8++230Gq1SElJgY+PD1544QU8//zz+mGc3bt346uvvtLnm4+PDyZNmoRjx45h8+bNePLJJ/HQQw/pnXoB3ZTtRx55BCdOnMCaNWvw6quvYsaMGVCpVAgMDMSzzz6L//znP/jmm2+QnZ2NgwcP4uOPP8Y333zjVP4SBEG4PUI74Lgaux12ZcSlS5fY9OnTWWJiIvP29mZt2rRht956K9u8ebM+DFo47DLGWEFBAZs4cSKLiIhgarWaJSUlsWnTpunz5+DBgyw9PZ35+Piw5ORktmLFCpaYmMg++OADs3EyxlhwcDBbsmSJRXmzsrLYpEmTWNu2bZmnpycLDg5mQ4YMYZ9//jlraGgwCFtZWcn8/PzYE088YRRPa3ma+fnnn1mXLl2Yl5cXS0hIYO+8847+2j///MOGDh3KQkNDma+vL+vRo4eBU7BGo2Gvv/46S0xM1N//xhtv6K8fOXKEDR8+nPn4+LCwsDA2bdo0VllZqb8+adIkNn78eDZ79mwWHh7OAgIC2LRp01htba0+jFarZQsWLGApKSnMy8uLRUZGsrFjx7KtW7eazC+5l0+CkBr1jRpy2JUR9jjscowpy6OpoqICwcHBKC8vR1BQkMG12tpa5OTkoH379vDx8RFJQsIUubm56NChA/bt24fevXuLLY5VJk+ejLKyMl63YqDySRD80qDRIvn//QUAWPPUDegSF2TlDkJMLPXfrSGHXUJUGhoaUFJSgpdffhkDBgyQheJCEARBiAv5vBCismPHDsTGxmLfvn1YtGiR2OIQBEEQMoAsL4SoDBs2TJZrMTSv5EsQhHSRYdNC2AhZXgiCIAiCkBWkvBAEQRAEISvcUnmR4zAFoXyoXBIEQdiGWykvzUvcN+9xQxBSorlctt6KgSAIx2CgDwKl4lYOux4eHggJCdFvKOjn5wfOxiX6CUIoGGO4du0aLl++jJCQEKPVhwmCIAhD3Ep5AYCYmBgAsGtHZIJwBSEhIfrySRAEQZjH7ZQXjuMQGxuLqKgoNDQ0iC0OQQDQDRWRxYUg+IXcyJSL2ykvzXh4eFBnQRAEQRAyRFCH3fnz56Nv374IDAxEVFQUJkyYgKysLKv3rVixAqmpqfDx8UH37t2xZs0aIcUkCIIgCEJGCKq8bN26FdOnT8fu3buxfv16NDQ0YMyYMaiurjZ7z86dO3HffffhkUcewaFDhzBhwgRMmDABx44dE1JUgiAIgiBkgkt3lS4uLkZUVBS2bt2KIUOGmAxzzz33oLq6GqtXr9afGzBgAHr27GnT3jf27EpJEARBKJfaBg1SX1kLgHaVlgP29N8uXeelvLwcABAWFmY2zK5duzBq1CiDc2PHjsWuXbtMhq+rq0NFRYXBH0EQBEEQysVlyotWq8XTTz+NQYMGoVu3bmbDFRYWIjo62uBcdHQ0CgsLTYafP38+goOD9X/x8fG8yk0QBEEQhLRwmfIyffp0HDt2DD/99BOv8c6aNQvl5eX6v/z8fF7jJwiCIAhCWrhkqvSMGTOwevVqbNu2DW3btrUYNiYmBkVFRQbnioqKzC7epVaroVareZOVIAiCUAa0zotyEdTywhjDjBkzsGrVKmzatAnt27e3ek9GRgY2btxocG79+vXIyMgQSkyb2Xa6GE/9eAiLt2VDozVfK7afuYIV+81bgMprGvDmX6cwfdlBdH/tbzz90yHMW30C93y+C59sOoNr9Y1YticPN3/0D8qvOb+Q3pWqOizamo3iyjqH7i+u1N1/pcqx+wl+OFdchS+2nUNtg0ZsUSxS0lTeLlfUii2KKNQ2aPDFtnNYefACvtmZq9gNN5fvy8Ou7BKz1/fmlGLZnjyr8TRqtPhqew6OXyrnUzyzNL+fs5erDM4fv1SOr7bnoFGjdYkctpKZX8ZLOVp16AK2ni7mSSrxEdTyMn36dCxbtgy//fYbAgMD9X4rwcHB8PX1BQBMnDgRbdq0wfz58wEA//73vzF06FC89957uPnmm/HTTz9h//79WLx4sZCi2sTEr/cCAH4/fAkhvt64u69p/5oHv9oDAOjeNhipMcYe0y+tPIo/jxboj3/NvKT/vSenFG1D/fDSqqO6NJfsxW/TBzkl97++O4AD56/ir2OFDsX1yDf7cORCOTacKMLPjw90ShbCcUa8txUAcKW6DrPGdRZZGvNMX3YQu8+V4vfMS1jz7xvEFsflLNhwBou2ZuuPIwPVuKl7rIgS8c/BvKt44RddG5X75s0mw9z9uW6SRVKkPwYkhZuN66d9+Zi3+oTFuPjkk01n8cnms/jvmpMG6d380XYAgLenCg8NSBRcDluZsHAHAOfKUe6Vavxn+WHdbxfksSsQ1PLy2Wefoby8HMOGDUNsbKz+b/ny5foweXl5KCi43pEPHDgQy5Ytw+LFi5GWloaff/4Zv/76q0UnXzE4WWh9VlNBuekvz21nLGu/VXWN+t+H88vskssUB85fdSquIxd0X0T7m+IhxOWgxN/D7nOlAIATBe458+/A+VKD49Zf+Eogv/SazWHzSiyHdZXFpZmDeZbrz4lL0iy3zpSjIgVaQQW1vNhi5tqyZYvRubvuugt33XWXABK5FtqvmhAChY5CEDKC4+TRujFQZQGgyFxw6TovSsKWDsRsBbdyrxILGkEQhClcrYzLRO/iFSV+8JDyIiBuWEcIwu3hqOYThOCQ8iICVpVgJarJBOEmuMNQBZ/qGTV3wqPEMknKi4A4ap5UXjEj+ITKB0HYhinFyC0tYwpsNEh5cRBbnJHNVRJr92otrCFDEIS0ccvO0QLWvvqVaBWQGkrMYVJeBIQsLwRBKBF3dHolpAUpLw7ijIJh7V4aAyYIwl2g2Ua24YzYSuxTSHkREEcLm1aJJY3gDaUuN08QfKOkmuLcB7OSckIHKS8OYlP/YW6ZF+WVI4Ig3Ag+/Xqk1xxKTyJnUWKfQ8qLgDhawcnyQhAEQRDmIeXFQZwxw1m7lyYbEYSMkalPhVBY+xYT8lvNsSFWab5Ap3xeeJNCOpDyIiAOzzZSYkkjeIOKByE2cnV6tQ3l1TAl+smR8uIg5spCy0Jirn5b/RJRYOUhCIKQAnLZVLI11CsYQsqLg5grSC0VE3OVhKZKEwRB6JDex5o8lRtLSC2H+YCUFwcxa3lp8dusgm91DFiJRY0gCKVgT/cuZmvmWNrSbH+dUqmk+UhOQcoLz2htGDayBukuhCWofBCKgsqz4EjPuuU8pLw4jOnCYDhsZO5Omm1EEEpFeYMOysL6+6E3KAdIeeEZQ8XEsUqgRC2ZINwFd6i9fPq8Si+/pCeRsyjRWkvKi4209kMxP9vIlricu04QBEFYh9pSHUrMB1JeBMTxdV4UWNII3qDSIW1o0ME+XN3eWW+XlfcGldhmkPJiI7bWLwOfF0fTcvA+giAI16DkvY2UhxI/iEl5cRDzU6WtFxJrIWhvI4Ig3AVXN3fKs6tYR4k9CikvNmLry7dlkTp74iAII6iAEIRtmKgqcl1h1xmU2GSQ8uIg5iwstsw1smbCU2A5IwhCQdjT/1vfDoUQHuXlMikvNmLrmKHB3kYOKvg0bEQQ8sUNP+wJwuWQ8uIgtmwPYPZepwMQBEEoA5fPNnJpavzhjFKsxO9hUl5sxCGfF4cXqSMI81D5IMRGLgqAkhb8dEYBUU4uXIeUFwcxWxhs2R7ASknS0v4ABEG4CdTaCQ9ZXtwYm9d54aEqKrCcEQRBSALySVIGpLw4iDPbAzgaN0EQhBSwZ7qx1Q86au9swimfFwVmMikvNmLryzeYKk2zjQgBoOIhbRz1dSP4h+qKDiXmAykvDmJ2nZeWU6WpESMIt0OJX7lCQvllG+SwawgpLzZiu8/LdcjyQhCEEmnZtMlv3xz3/qiU3/syDSkvjiKgzwspLwQhX9zN4mp1BV0nrzuDklpS59Z5UVJO6CDlhWd4mW2kvHJG8AiZ2QlCSKh+yQFSXhzElnVeeI+bIAhCArS0AjjbXrl8V2n3MowpFlJebMQRnxdHK6USTXwEQSgT5bVXytNuWr4ipbwuUl4cxFyFpXVeCIIgbEfIYVDHFCvlNcBKHGoWVHnZtm0bbrnlFsTFxYHjOPz6668Ww2/ZsgUcxxn9FRYWCimmTdi+zgv5vBDCQuWDEBs+h41cjfLsKtZRYpshqPJSXV2NtLQ0LFy40K77srKyUFBQoP+LiooSSELHMVcWaLYR4e64u0+Buz2/1dlETt7vetzsBcoUTyEjHzduHMaNG2f3fVFRUQgJCeFfICdwyOfFwW8SydVlgiAIt0F5LbCBz4t4YvCKJH1eevbsidjYWIwePRo7duywGLaurg4VFRUGf67A/N5GNGxEEISyabmWjbND5UI2d6bidjfLGKAchaUlklJeYmNjsWjRIvzyyy/45ZdfEB8fj2HDhuHgwYNm75k/fz6Cg4P1f/Hx8YLIZuvL58dhV4lFjeALKh6ElFBeeVSedqPEPkXQYSN7SUlJQUpKiv544MCByM7OxgcffIDvvvvO5D2zZs3CzJkz9ccVFRWCKTAtcfXXAkHIBQ5UhgnbcVW/aruFiEqvHJCU8mKKfv36Yfv27Wavq9VqqNVqweVorbn+cfgSiipq8fiwDujfPgzf7z6PMV1isC+3VB/mwtUabD9zBXenx2PZ3jz8eaQAEYHWZV116KLB8cLNZ9ElLgjDU6Kw/kQRGjRa3NQ9FrUNGizedg57c0rBccA/Z65AxQH39E1AkI8n7ukbj6TIAKP4d58rwYu/HMFrt3bFsBRjZ+hjF8uxJ6cUkzIS4elhaJxbtDUb9/VLQLCvF7aeLkZpdR1u69XW6jPZwsqDFxARoMaQTpEt8uICNp68jPv7JWBgxwiD8D/tzUO7CH8MSApHfaMW3+7KxQ3JkUiJCbSYzpmiSmw9XYyHMhKh9vSwW86swkr8c6YYEzPawdtThQaNFt/szEWfxFDsyy3F6C4xaB/hb3Tf6iOX4OPpgVFdou1OsyUnCiqwaGs2buoWizXHCnBLWhzahPgapOPBcbhYVoMhnSLRKToQa44WwMtDhdE2pN38PJfKarEz+wp+nDYAof7eVu/LzC9DZt5Vg6Z/V3YJMjqEG4U9mHcVxy+W48EBieBM2PFX7M9HXIgvBrV657ZwuqgS21q939bvfH9uKbKKKnF/vwST6QPAjrNX8NyKw3jj9u44fqkCjDHc2C0GHaMCzaaz6tAF7MwuMYjn/fWnUdugQZCvF+7q0xbhAYZtQGVtA5btycNN3WMRH+YHxhiW7c1Dp+hAdIwMwPL9+RjXLQZ/Hy9E//bh2HWuBAM7hGNndglu790GUYE+0GgZlu7MRf/2YejWJtjoWQrLa/Fr5kXc2zceIX7X32VVXSN+2H0e47rFwk/tgZ8PXMAdvdsiskU79c+ZYlyuqMMdfdoi90o1/j5eiPgwP/318yXXsCXrMh4ckAh/tSc2nChCbaNGf722XoPF27LRKToQL608ivfu7okLV6+ZfL+XK2tR16DFn0cLcH//BAT5eOH4pXJ8se0cgn29EBvii4cGJKKythE/7ctDz/gQrD1WiOggHzw2tANWHbqIjlEB6Nc+DFeq6vD51mx93OXXGrBoazYKK+pMvu9mftybjyeGdUR8mB9OXKrAzuwrmDywHf46VghfL139ZYzh+93nkRobhCMXyjEgKQyXK+rw2ZZsvDAuBX0Sw3C5shavrz4JFQfEh/nBx8sDnWMDMSI1GhfLavDH4Uv6thSA0bkV+/Nx9Vq9Xq7fMi+ha5tg1NRr8PbaU+gaF4xQfy9MH94RpworcfFqDarrGnFT91jsyy1FRIAaoX7e+HL7OfyWeUkfj64vMy7z644XQqNlGNc91uD8gfOlOHGpAg8OSMTW08Uou9aACb3aWMxDV8AxF9mTOI7DqlWrMGHCBLvuGz16NAIDA7Fy5UqbwldUVCA4OBjl5eUICgpyQFIz8dY2oMdr60xem5SRiG92nYenikOjVrjsPP36OHR6+S8AQObs0fh6Ry4+2njG4j25b96Mdi/+afG4Nc3XX5/QDQ8OSDQIDwC3pMXh4/t66c9vfnaYyc7aHrKLqzDyva0GMuVeqcawd7eYlHVfbinuWrRLf37R1my8+dcps8/Ukma5nx3TCTNGJNsta/P9s8al4l9DO+DLf87h9T9PGoRpLcOVqjqkv74BAHDujZugUtlvmm79HpqJDlJjz0ujAAAlVXXo05ROM4deGY1e89YD0JUhb0/Lo8VLduRgzh8nrqcb7octzw13WD5LZeyLielGCtWJSxW46aN/zN5rqxzPjU3B9OEdDc7NHN0JT41M1h9//0h/DE42rSBZe57W5eh8STWGvrPFomwZSeH48dEBBueeXXEYPx+4gEAfTxx9bSx2nr2C+7/cAwC4ITkC/5y5Yja+tLbB+G3GYPyw5zz+36pjBvK1ZPi7W5BzpRojUqPw9eS++vOzVh7Bj3vz4e/tgdTYIBw4fxVp8SH4bfogo3zYMHMIxi74BxotQ7twP+SWXDNI46EBiXjt1q7o8NIag/O+Xh6oadDAFLlv3oyp3+zHhpNFAIBubYJw4WoNyq414PbebfD+3T2N3sMD/RNQdq0Bfx4tMDjfo20wjlwo18d752c7sf/8Vf31NiG+uFhWY5R+6+cEoH8XzeeeHNERH286C0BXfzeduoyp3+43+UzN8d780T84fsnYBzP3zZvR778bcLmyTt+WAkDG/I0oKK/Fzd1jMX14R30dsEZ8mC/yS2usB2zi7H/HGX2U1jZokPrKWgDA4dljEOznpb/WnAdLpvTFlCX7AAD/PD/cQIHlC3v6b0EtL1VVVTh79qz+OCcnB5mZmQgLC0NCQgJmzZqFixcv4ttvvwUALFiwAO3bt0fXrl1RW1uLL7/8Eps2bcK6daaVBqmwJ0dnbRFScdHFr9X/rqprxKG8qxZCO8/JAtPOzzvOGjamxZV1TisvRRW1Np1r5nyrhvPIhTK708zML7f7HoM0L+ruP3rRejzlNQ3633yXkqIWX5IVtY1G16vqrp+zZRp+6+dp3UnxybniKgCGysulMtsbYksczi+zei6npNqs8mIrzeWouNLyFz0A7DpXYnyuyVJT2fTuckqq9dcsKS4AcLipsz5hopNsSc4VXZzbThebTLu6XoMDTR29qXwDdOVM09TGmSoTe3NKTZYvc4qLKY5dvP4cO88a51VzOrkt8qiZZsWlmZaKCwAjxcUSla3qUcs2T8sYzhZXWY3DlOLSzOWmstIy3oJyXXv3z5li3GaHZcMexcUc9ZrrfUt1faOB8tLMueLreV5cVSeI8mIPgiov+/fvx/Dh17/Ymn1TJk2ahKVLl6KgoAB5eXn66/X19XjmmWdw8eJF+Pn5oUePHtiwYYNBHGJhqc03Z3aWO7Y+Fi/GOxNRWIqVnxznR42w9/HNmW35kUX+4/UurU485FezvHzJ7cpXyHfb5SrZORE9q/hMVSr11f42TBg57EFQ5WXYsGEWX87SpUsNjp9//nk8//zzQopEyAgpVBB3hFPgbItmhChScsotOX1nSXVJe7m3S9bEN1dGpKJoNSOpqdKSxpLlxXVSEE3IqREm3AX5FUq+JXaZwiG/rFYY4isypLwQZjH3Be6qdkOqX17N2JMP1NbajpCKqRBR8y2vI6VeKsq8Ix/n5r/07QvvKvhsl8zFJPYzWkMKRhhSXmzEUoGVekGTLRb9jFwnBt9IoN67LcIMG+kKoyzLpBxlhrhiS6Hj5h0ZPhMpL4Rksac+KdlPw9XIshMmbELoesJnxy6l/rS1Y7OQCozQE0CsyW6ujEhtfyRSXmzE8mwj18nhSmyebcRDWvbG0bqCOWLK5asBsjcaIRs+KTQqzuJKRZSP/NLPNuIhLgAu/bSXq8+Lq9vcls6qvCpopmZZysC0IwURSXkhJIsUKghBWEOpHy+OIHTHLgWc3ohSqg9mBan5IJLyYiOW1xyh1ksI7PEzktM7ELMRkGm7KQvkuN4T7+u88BqbeVxd31vmk9B1SIxyZG+bJAUFjJQXmeKKsmOuCrmqbkmgfvCGKxs/OWEyK/ha7M3UOQEyn++OVK7Fg4E5lL/mc890XGJ8qBgMGzkdl+l4WyJkG2tNUbFl9pcUyigpLzYiBU1TAiIQMkdqpl9FwLfPiwvh3+dF+UihLxADqT01KS+EZLE4VCcBE70UZBACVz6VkGmZilu578zG5xJ0DR3OZT4vrn6NBpZTuOdHgKHFSDw5miHlxUYk8K4EkcHSV4T5hp7/lsNer3s+JJDCO+Uba42KFBoda/BVulw3bNT0ryz3NuIvLgamzErVCmffDzPzW0xaPpMtRUIKyhspL4Rksat6yOiDWkwFQvwmxxCpyeMIzUq+nJzGm+HfX0f41WcBkas7k+e7bsbR9kcKCktLSHmxESl8sQrx1cjLhtAi5I3RF6OYCoEUCgdhhE1fkDy+OjmOSPEpMwcOWl6HjaRZr1jTf26NBB6flBcZIYHy4loU9MAt+whxp0pbT9uVnbCQfimum7YrH4SU1eHZRuZmt1gIL6bvktPDRrbUQQmWKpptJFOkoGkL8SEi/lOZx+I6L60rt/TqOuEm8L4xo0QtDrYgX8lth9dnlEiGGYghk7aUlBdCski9DXe0jpPPy3WElEcmbTAvSGHIyqWzjfhLxiYMLKcCV2ApvEtrSKFtJuXFViTwsoSQwfJsI/vOOyWHnQ/Hhwxy/sI1j/yfScjZRkLA92wjV8Ln8IuSfUH4nCFk7X6pNkuGC/WJLyQpLzJCCgXGlUi1EjuLmI9lS566crxdhv29EXJaYl9wBctVDrtK2ZiRv6gER2rtMSkvNiKF9yZVnxehlCrJTpVshRTKBmGMbbON+Ht7UnSytAafEnPgFFsXDC0vTNCOXAwLXst6YEs5loIiQ8qLjGhZXlyxIJbYjbHUh3XseQctw4r6XLZYXkR2QJXb8AvvS+w7UDxslUHoOu2qou3qIsIMtRfe4jJbN4Tc28jhdV5M/xYLUl5sRAr9qNQ7c75xr6dVLnyu/SFJ+Fb2+I3OpbhskToXa7gtZeF1LRv+ohIcm5QuF0LKi4wQorjw0tgItNCdrXubOFqReMtPOyMSstpb3R5AhObSmYZO6EaSj9ibrRlysxgB1mW2N/8dsxrZn3Euz2uJOavyjb1PJIUcIOXFRqRQYF2t7FpqIFyjeduWhgQ+AhQF78NG9qbfojPj+90KUVTkpLQILasS10BpjfN7G4n7YNbSN79ooLReCCkvMkKIwiPfjt9wl1c5IarLiwhpy7eM2Qd/fmiuyzDrlhf74nOV7C43vJj57XS8MqobfPr98AEpLzYip0ImNK5qOGzNc7HGX+3JB7Gdn8XEGaWb7zcrxFuQwpsVc7n8lrhiGrEYz6o1mCotfHsjjbdpSOsZV2JDyouccPWwkYVrrtAXLDvs2RZOkkh7shH/adqZqJAzs9x92Kg11pRqqdYtee9txI8cfGKTTBITnJQXG5HCa5OCDK7EdsuLNL9U5AvlplIRfI06Vy1S52KEEsWUBUOq78jA8iKBV0PKi4wwnKrmaBys1bETAjXH4XwUDjh1trzXMSMmXxXQ3tSFNLlai1mMDsGZJIWWlo/saLZeSKFBtxfeZxs58MYcMaKIuc6L0O9ZFOtoi1RteT4plHVSXmxECl8BfHR69jyGxdlGTktiHVufVwKvhrCA3ftWtbxXBu9WzsNGfKPUpfNb+3tIoT9wNVJ7ZFJebEQKL04IK4m1jkXMSmp5nRfDHkNO/Yers9Tgq9G1SRulr2Tk+JzW6o1U1/9wtcIo1N5GphClLbPF2tLSOiOgKLZCyoubYY8yYs4pzlUNh62SitVp2OM0KKevc7HXeYGBM7YUmknL8L+dAr/xtURoR1dHPnbMritiJiqxq5IrpkoL+Z4clZ9W2CUchg+HKSPLi5V4zF0XsvDaEndrnxc54Wpp7R3P5j19p1bY5VEQwWjyeZFZOQRgVfOye50XO5N3vGy4eHsAHjtuKZZpW6ZBS01sUl5khIHp0sGipLWz5ohZYC01EobTaV0gDI9I4avFlbjX0yoLu53R7VV2LISXkjJosM6LiHKIidTygJQXG5FCf8OLz0urOCxFae7bRogF1+wdU+ZjnRcJvFLesbZHlDh7G9kXnq/yZSpZIepxc1kUa/aaM/BZk3VyK7FW8TtNWGq+I4CNz+TCGVe2QMqLTHFV4TFnJXDJbCMbE2GMSWaFUVuQQL13LRa/rq3cKoPMkk/Jsx8+LSkmwzsYl7jVncmiXJpD9I1seYKUFxuRgglTEMsLD5GKUZENNu+DdGdFSQFm9sBV6YuTQbb0bxJ/dYLDpxLAgVNsfrpytpEYGNRRm55P/Ewg5UVG8GFutKsj4USaWqv/17bU5daYSF1evj9qLX5BmzrH02wjuU7bFXS2kXBRN61/Yuc9jJkdJjQXFceJvEgdj3GZi0yK1jypKXCkvNiIFF6Wq31e7IlHCCymYTjdSPLDRmKWH0NHbxHSd+ZeCdQ7a8h6hV2e45OChVpo5PierSGXVXVbIqjysm3bNtxyyy2Ii4sDx3H49ddfrd6zZcsW9O7dG2q1Gh07dsTSpUuFFFG2uGrcUtxO18ZwEh6WMIU7NPAtsVRWhcwJaauz/MKH7m4qDrtW5AbH79RqCfm82DKVmC8EX4uHh/uk0IIJqrxUV1cjLS0NCxcutCl8Tk4Obr75ZgwfPhyZmZl4+umnMXXqVPz9999CimkTUnhZfMhgz95G5sy5QtQtQ29+60/KxxLySpyybKph5XOmhCPYm2Qro5rL0nUU/WwjnlJ05Svis6N0ZNhILvA5ZGJNERJl/zEzvw3CSGy2kaeQkY8bNw7jxo2zOfyiRYvQvn17vPfeewCAzp07Y/v27fjggw8wduxYocSUDXyY/+22vJhdsEj40mtrChKoR1ax3yFOPFzpw2F1eXoptJJWkJWFx4KwHIyLptCbjjq6zosQyzVYovUHgPRLJf9IzWIsKZ+XXbt2YdSoUQbnxo4di127dpm9p66uDhUVFQZ/QiCFRpQfywv/kQpVqC0vUsfZFM4VSKBoWET0dV4kPKzHZ9mRejkwBZ8qgCPDRnLBlXVIDP89V+wezjeSUl4KCwsRHR1tcC46OhoVFRWoqakxec/8+fMRHBys/4uPj3eFqKLAi9nOnjFsTtxhBiVZXloiN3mdxuLXtTEGiinPyQqR93x3NlLaq8seWRzp0BiYWQ3K/L4/Yvi88DhsZMMQlJDP5/gwu/Nx8Imgw0auYNasWZg5c6b+uKKiQhAFxtK7OnqxnPf0TDHq/a36338cvoR/zlyxes+B81cNjtPmrjM43n72Cm7uEYsD50uxYMMZdIkN0l9bvO0cHh7U3mS8dY1a/e+r1xoMrv24Nw+eKg6v/n4c6e3C8PCgdjh7uQp7ckqx/kQRJmUkIjbEFzvOXsGtaXEorqrD22uz9PeXVNUjJtgH3+8+bzLt+kYt5q0+oT9Of30DfLyu6+HtXvwTvRJCsOCenvjrWCEGdgjH66tPYkBSGGaMSNaH25Vdov/9zt+nsHBzNpZM7os+7UIxf81J/HLwItLaBiPIxwsbT13GCzemIi7ER3/PykMXUa/Rmmy02734J356dAAGJIWjqq4RL/96TH9txf58/LQvHxeu1uDN27vj3n4JOFVYgXXHi+Ch4nBz91hcuFqDB7/agzv7tMV9/eJx5ILlMlZUUYtjF8vx17FCo2vZxVX63z/tzcd/RnfCr4cuYs4fx9GoZWjQaLHtueE4cqEc1xo0+H53nlEc9y7ehX8N7YAj+eUY1z0GMcE+WLYnD2O7xmDN0QLkXqk2K9v8v04hMdwPbUP98L99+ci8UKa/9uZfp3D0YjmyCitx9nIVQv280Ki5np89XtOV12EpkejRJhg7skuQ3i4U9/VNQGFFLb7ffR6BPl74cW8ebu4Ri6hAtUHa5TUN+Hp7jv542+liDJy/UX/8+p8nUa/RondCKAYkhWP7mSuY88dxpLcLNfs8L606ilA/L/3x0p25WH+iCInhfmbvacmB86XYevoKlu05Dz9vT1wsu/5h1u7FP22KoyUVtQ1YsiNXf3zkQhkWbc1Gx6hAnCqowL7cUv21ytpGTFmyF/5qT6w+UmAQj0Z7Pd8/25KNduF+8Pa8Xq8e+HKPRTlOF1Xh/z7ebpfsH288i4Ot2qhmGrUMw97ZbHT+2EXr1vXW7Z451p8owhM/HECDxrgOj3hvi/53fun1d/TSqqM4ccmyDPP/Omn2Wsv61ahlmPPHcWQVVurPlVbX43zJNVvEd4j7v9iNhwe1x9GL5SiurENkoNogvz7bko1ubYIR5OOJnw9c0J9f26JtefLHQ+gZH4L4MNvKvBBwzEU2d47jsGrVKkyYMMFsmCFDhqB3795YsGCB/tySJUvw9NNPo7zcNgWhoqICwcHBKC8vR1BQkPUbbCS7uAoj39tqPaAMyX3zZnR+ZS1qGjRG127sGoO1xw07xNhgH9zRuy0+2XwWAKDigHPzbwYA7MstxV2LzA/z2UJafAi+mNgH/f670eB87pu6NFYduoD/LD/sUNxjukRj3YkigzjPl1Rj6Dtb9OfG94zDb5mXHIq/Nblv3oxZK4/ix73GCkEzh18dg7Q515VKTxWHRq191fLm7rH482iB9YAAlj86APcs3m1X/C1JjgpAl7gg3vLIEVQcYC2LxnSJRseoAHy6JdtqfBwH5My/2SHlQWwm9IzDryK+C8I9adnu84U9/bekLC8ZGRlYs2aNwbn169cjIyNDJImuE+LrZT2QjDGluADAjmxj6w4HIDO/TH/cshOx9AVuK4fzy1DeyprTkpZfQfay5XSx0bniyjqD4x1nrVu07GHPuRKL12vqDfPeXsUF0H1B2kpuiXPv6MzlKpRW1zsVh7PYkkUMhuXUYlgJmMEdZUe25fJFEELgQDPFK4L6vFRVVSEzMxOZmZkAdFOhMzMzkZen+wqdNWsWJk6cqA//2GOP4dy5c3j++edx6tQpfPrpp/jf//6H//znP0KKaRPhAWrc1quN2GK4HpEKqKVknRoOtqXT4/mZrUXHx/i2Pf4GfMzUkEtfL/G1CwmCcBBBlZf9+/ejV69e6NWrFwBg5syZ6NWrF2bPng0AKCgo0CsyANC+fXv8+eefWL9+PdLS0vDee+/hyy+/pGnSImJ2zr/ZKdTSRgpe8q3ho3+1S+HiQ1mSgamC9BaCUC6CDhsNGzbMYiNnavXcYcOG4dChQwJKRcgBoXaUlUGf6xAu1l1kAYPr1wMhCMI1SGqqNCE97P7C5kk5EGztGJ7C8AoP/avWjvfEx9ReheqABEHIBFJeCItIsZNypvOV4nAHLz4oLn4sCWajERzI54UglAopL3YgxY5PDCwpD7zt7yJQVtMb5Ac51AXpS0gQhKOQ8kJYRKw+ylS6fHSYtm39zu9DW4uPrAMEQRD2QcoLYRGzs4rM9Mcy+CCXHHLUXeTwmuWYrwRB2AYpL4QksbijLPVK4iMD7YVBnE3uCIIQHkmtsEtID3tXUeSrTzM9bOQaxcXV/bIcO1gZ6C4EQfAMBy26cHlIV2WhER4A+N0ewB5IeSEcQsxhI6HX7nD10Jf8VBf5QHlLEM4RgkoMUR3BUI/DGKI6gkhOtynlOW0MgA9Ek4uUF8Iydm7ZLvXZRgQ/yGG2EUEQjhGAaxij2o/xHjsxSHUMnpxWf62K+WC/NgX7tCl4TqsFVOJ4n5DyQjhEc9/lgzq84fUV8MajQLsboG77vEG4EFTiDo9tCOKuYZ0mHcdZe9viN6EENZ8RepSF99lGVq7LcNRINsNGcsxbghADNeoxTJWJWz12YqTqEHy465vjntTGY6u2J7Zo03BA2wkNTarDcyIpLgApL3YhlwabT6xZUuZ5LsHtHtuBegCn/8KoS6cRhudQiiD04LKxyPsDxHGlAIAnPX7FN5oxeLvxHtTABwCQzF3AaNUB+HG1OK5th03aXqiDt9CPZYDY71WORgw5yqxU6F0QjuIBDTJUJ3Craidu9NiLIK5Gfy1bG4vfNIPwuzYDuSxWRClNQ8oLYdHSwBjgh1rM8lyGaO4q3m+8C1VcCgCgB5eNuzy3Qcs4qMbNB3Z8iJDKbPzg/V+s0/bFYx5/QM01IEcbjdMsHmM99mOK598YoTqEzdqeSFedRjdVrkF6pSwAv2iGICCvDiNUx9GBu4SO3CVEcmXgVq4C4tIQU94G3lChHl5CZguhAMjwQhCtYejFncWtHjvxfx67EcmV669cYmH4XTMQf2gG4jhLhJRrECkvhNUvt5c9v8f9npsAAL1UZzCFfQgwX7zktQwAsEo7GHcMeBzoOAo1i8eic30+OqvyAQDrNH0ws+FxVMEPQzSH8abXF0hUXcZk1ToAQAPzwBZtGi6zUAz1OIy23BVM81wDrFuDr1sbYI5lAsdWYAKAcWpPFLFQ1MMLHtDAi9PAExp4QIMK5o9LLByXWAQusXAUIAy1TI0GeKABnmiEB+rhiUrmB5Tlg2s0rAb0IWsdKe7O7b7QuyCs04nLx3iPHbhFtQsJqmL9+VIWgDWa/vhNMwj7WScwmaygQsqLHSjVPGvpsUJRgTs8tgEANIxDJFeBl+o/we7acRigOok65oX3Gu7CHQAQkYy1A76DdvN8RKMUf2oH4EfNCDRr79u0aRhT9zbGe+xEIleEbBaHdZo+uIogAICqUYuRqoO40WMvboq4gpySGpxjsTjL4nCJhWP+mBh4XDqAmnO74NtwFQlcsUmZI7kKdECBbQ+/4GWkAziq9kU5/HGNqVHHfFDt7Y1rTI0aeKMGPrjG1KiCL6qYLyrhi2rmgxqodX9MjWvQha2FWn9frY3DX3IsVnKpC3Kchm4vcnkXhOtpy13GrapduNVjJ1KbPigBoJqpsU6bjt80A7Fd2x2NMlQF5CcxwTuWho3GcHuh5hpxRNsezzY8hj+8X8ZA7QEMvHoAALBYczMuIUIfvsq3DV5peNxsfFXwww+aUSavaaHCem061mvTkXTbQNz26U6D628MHgd4qPDd1rP4du0/iEIZvLlGNDAPNEL3p4EHQrgqtMEVxHFXEMeVIJq7Cm80wIvTwBuN8EQjvNGIIO4aYj0qAW0DArkaBKLmupWUrz7vdV/81uiJKrUatcwb1dApPdeaFR6mht/GTZjpeQWVzA+V8Gv61xeVzA8V8ENF03mdMiSNzpj6S+lA74JoSSJXiDGq/RjnsRe9VWf15+uYJ7Zq0/CbZhA2anuhFmoRpXQeUl4Ii43fYNVRAMAGTR+cZvH4f40P4y2vL+ABLfZrO2Fh43iXyXR9tpEKF1gULiDKckAbyHljHA6dycMzSzcgBFXw4eoR4tkAj8Ya+HJ18EUdfFEPf64GAahFAGoQwNUgADXw4er115vD+qHOwEsfjTUIARDCVZrXOw5uw1M21MQG5qFXagyUHL2CY+JakwLUfFwj8wbLXqSh6gkLTVt3dxi6cucxxmMfxqr2G1hYNIzDLm0X/K4diLWavqhAgIhy8gspL4RZs7MKWmSojgMAtmu7AQB+1gxFYUBX9PC/ii8vtTNympVbM8rAQaMOQk6zNz0DfJgKtVqt5RstwEELH9TDD3U48MIgTPx8C8rLy+DbpOz4oxa+nE7R8UMdnhwcjZ93nEAgdw2BuIZArgZBuKY/DkANPDgGL06DMFQhjKtyWLYG5gHt2gD08/ZGBfxRxvxRhkBcZQG4igCUMcPfZfDHVRaICvgZjoXL7UUrGHoV7ocvatFfdRJDVUcw2uMA2nJX9NcamAd2aztjnTYdazV9UYxQESUVDlJeCLPOl925cwjhqlHB/HCYddCfP+8Rj0afTqhHqXAyWWiR+XRjMGm4cbI3YFChBj666eChichVJSCPRZjtZabeMAqzt26wGKM/avWKTSCuIaiFohPYQtExvG54rVkBQkM5ElQAYNpnyBQaxqG8SZEpQwDKEYhSVQDKmO5cKQJRyoJwhQWhBEEoYcGohC/Etn24gcsL+by4BQzJ3EUMVR3GUNVh9FOdgppr1F+tYd7Yqk3D35p0bNT2UpSFxRykvBBmG78bmoaMdmq7QgMPF0pkGiEaaVMmd1f3BdbT41ANX1TDF4XNge0WksEPdQjENcy9MR6f/30IQdw1hKAKoVwlQriqpt9V+nPNvwO4WnhwzG6rTx3zbFJkdMpMCZqUG/1xoO7fJoXH1ev7KAUaNlIiDB24S+inOoX+qpPorzqFWM7wY/ECi8BWTRq2aNPwj7a77H1Y7IWUFztQahPBGJDAFaEzl4fN2p76oaAbPHTKS/OQka1x8SQVXxFZRMtM2AYU+aI5XIMPrsEHlYEdcZBV2/ycXmhECKoQwlUhFDqlJkxVhWBWiRCuGiGoRDhXiTCuAuGoQDhXgUCuBmquEXEo1S9SaI1K5osSFoTLCEExC0YxC9H9IRiXm3+zEJQgyA5lWvmmF0UWVzfDE41I4S6gjyoL/VUn0U91Sr+HUDO1zAu7tV2wVdsDW7VpOMdi4Q7l2xykvBDAlVNY5/08fLgGbNd0xUMNs+CHOvTmzgAAtml7uFwkk7tKNzXTfE5/NTVkpuV9ewB5dy8N8EQxdIoDAIABKmZ5x3E16vWKTDhXjogWik04V44I/e8KhKMc3pxGN+TF1aAdiizKo2UcShCIK6xJyWmS7bLBcTB8Nf6oUfnzlxFSRd7Fyw1hSOAuoyeXjTSV7q8bl2Po6A+dsnJIm4y9LBW7tZ1xUJtM1skWkPJCwGvHB/BsqjiDPY5jgmYHKuEHL06DXG008li00T3md5WWV0tqWkkSXwapY03kOnjjEiJwyYKvT8vYAlGDcK4ckShHBFeOKK4MkVwZIlGu+5crQxRXhnBUwJPTIhIViOQq0NlStOeBes4bRd7BKEazJScYl1mo3ppTxEJxmYWipGmtITkiw+LjNvigDsncRaSq8pDK5SOFy0NX1XmEmhh+LWd+OKztgD3aztijTcUR1oFWEbcAKS9ujhca4XFmDQDdarhjPA7gWa//4bi2HQBgs7anKHJZapCFNpTKTQGTP5x+encuYi2+fBW0CEUlIrkmpQZlTYpOuYGyE8WVIYi7Bm9Wj3hVMeKtOCdrGAe8G40/vH30Cs1lNCs3un+LWChKEAytxFYgpfIqPkGoRjuuEO24QiSpCpDMXUAql492XCE8OOP3U8e8cJwl4rC2AzK1HXCYdcB5Fi2b1W2lACkvbk5v7gy4+moUsyA81TADG1XPog1XgjYeJQB0U6Ptga9m1KRFRBCHXeNzloZDCB1i9ZdaqFCCYJSwYJxiCRbD3pQagmDNVZw6e7bJetNk0cF1S07zsSenBaoK0V0FdEeu2Tg1jMMVBOuVmmYfnFIWhBIWiFK9g3IQShGk331XSKi4Cg8HLSJRjrZcMeK4EsRzxWjPFaC9qgDtuEIj/5SWXGFBOKWNRxZLwCkWj5PaBGSxBJeUDSVDuefmpKuyAAC7tF1RCzXmNjyEz70XAAD+1qTjOGsnnnBm4HeqtPgeKeJLoEwaVWqUesTgEOOsWnPCUYF9/+6GKR//gWjuKqJQpvuXu4ooTvc7EmXw4BiiUYZorswmGSqanJBLmxScKyxIP638KgtAOfxRzvx108+ZPyrgb7dfAxlenMMbDYjQD0/q/o3hSnUfcU0rdcdyJfDmNBbjucxCkMNicE4bi2wWh1MsAae0CbiCYBc9iXtByosdKNE826VpV+ej2vYAgL+1/XB73WuI40qwXtvH5D2chYEbvrLIVXnNGDX+SoXBtiFGLVQoRggQm4bN2gtmwzUrOVHc1SbFRme1CeMqEcGVIwxNM664SoQ1+eYEcTUI4mrQ3ooTcktqmDfK4Y+yJuWmgukWE2xWdCrgj2r4oIr5oho+aIAfSjk1qpkPqqA7J8e9avjAGw0IRhWCuWoEoxohXFXTv9VN56oQzlUgkivXKyzB3DWb4m5kKhQiDJdYOC6wSORqY3TKCotFLotBNXwFfjqiJe5Zwgk9XbnzAGBgYTnIOuGgyB26q3xeGIRXlEg5Eg9Lira9NCs5xSwEx1l7K+lqEYRrCOcqEAadQnP9dwXCuEqEoArBLTrXIFTDg2NNKzHXI4a7artwrWaO1zEvVMEH1cwH1fBFLbxRy7xRBy/UwQu18EYda/EbXgbXm3df1zAVNFBBo987TGXwrxYqNDKVkR8QB9b0B/2/AMBxuvOAzt9O96fbc8wLjfDiGuHZ8hiN8OYa9KtR+3G1Tb9r4adfpVr3W7dydb3teWaQX7oZdVdYUNPMtVBcZBG4yMJxkekcz4sQKon1rggdpLy4MQG4hnYq3RfhSa1l/4HWmOuP5dZPMyaBQRvRBVAmYq6AwaBCOQJQzgJwDnE2vWMOWgSgtoVC08JqgGr9+UDuGgJQe32/La4WftD9VjfNGlRzDVCjAeFcpcBPKj20jEMF/PSWq/Imq1Xz8VUWiMssBFf06wcFowL+cOc1U+QIKS9uTCqXBwDQBsbhaq20popa3h6Az3VeyDKiVBjktT0Ag0o/6+qC7oRNeHuoUK/R7cXliUb4N20g6s9d/9cH9VBDp9CouYbrx1w9fNAAtcFxPTyhhQc0Bv+qOC08oTE6r9vLXdv0DByaRWcGNhfDYwbd+kEN8EQ9PNHAPFscezRZfjxRz3S/a+CD6qad2K/Bp2lXdh/dMdP9Ww0fVDB/VMKXZu24AaS8uDFdVboho8ao7vZsc2MRvoZgTNlDhJptJAHbC0E4TMvy2whPncUHAdeVHyrehAIh9dQtMN16dWnyd2mM7OpKYWzDRRszNn0iigr1LcIhJ8uLo5DlkHBHSHlROGNV+3BEPRW/eL+KUBiuRdA806gxurtdcVrqEHibbcRPNDakQ3YXQt5Q+SXcEVJeFIwXGvFfr68QxNWgj+oMZnr+bHCtE6ebFtoQafvGi3oEbjEt7W3EdzpCf7nSl7F48DnbSKoocQkHgrAGKS92ILcmYpgqExEtVn683eMf+KMGANCJy4eaa0QZ84cmKJ63NOVmx9CNGokrM/U9hDNQ8SHcEVJeFMxg1VEAwNLGMcjWxsKfq8ONqn0AgO6qHADAMW072DtF0BXfspYUCj47e8YYKQ9KRvmGFyq/hFtCyouC6a06AwDYp03Fr5pBAIBbPHYBALpzTcoLS+L1y42/FXaFi9sgTtCXK0EQhNwg5UWh+KIWnZvWcTmoTcZqbQYAnTUmDBXoozoNADisTXJIKRBzqIXPMX6dz4vIw0akPgmGGxheCMItIeVFoXThzsOT06KQhaIA4chhsTiqbQdPTouJnuuQqsqHlnHYre3sUOdpzhGSt12leYrHejqkOhAEQcgNlygvCxcuRLt27eDj44P+/ftj7969ZsMuXboUHMcZ/Pn4+LhCTEXRUXUJAJClve6M+7tmIADgac+VAIBjrB2uIkiSlhdT1hBB1tyicSNFw+dqzARBSAfBlZfly5dj5syZePXVV3Hw4EGkpaVh7NixuHz5stl7goKCUFBQoP87f/680GLahow6uSROp7ycY7H6c79pBqGOeemPV2puAMDvY8nNeZBmGxEEQcgPwZWX999/H9OmTcOUKVPQpUsXLFq0CH5+fvj666/N3sNxHGJiYvR/0dHRQoupOJK4AgBANovTn7uMULzcOAXFLBjrNH3wg2YUAPt9PlzxNWtJIn5nG7mf8iC2j48rIbsLQSgTQZWX+vp6HDhwAKNGjbqeoEqFUaNGYdeuXWbvq6qqQmJiIuLj4zF+/HgcP37cbNi6ujpUVFQY/BFAhybLS0vlBQBWaIahb91neLThGTQ0bW3FqzLAlxXD5GwjARapg/tNlXazxyUIQoEIujHjlStXoNFojCwn0dHROHXqlMl7UlJS8PXXX6NHjx4oLy/Hu+++i4EDB+L48eNo27atUfj58+djzpw5gsjfGrGHF2zFC41I4HTDcue0sVZCA/cu3m1X/DlXqpFzpdrg3KA3NyHQxxOnCivtisscU5buMzrX/bV1vMTdkrl/nEDHqADe422m19x1uHqtwWKY99adFix9Uzz/8xGXpicW608U2RV+/MIdAklCEATfSG5X6YyMDGRkZOiPBw4ciM6dO+Pzzz/HvHnzjMLPmjULM2fO1B9XVFQgPp6/FWNbUl5juROSCglcETw5LaqYD4oQajX8xbIap9PkIw4x+OtYoaDxW1NcAOCXgxcElYGwjcP5ZWKLQBCEjQiqvERERMDDwwNFRYZfQEVFRYiJibEpDi8vL/Tq1Qtnz541eV2tVkOtVjstqy2kxgRhx9kSu+4Z0yUa66x8Ab4+oRs4DogN9sHDS/fbLdetaXEI9vXCd7t1js0dDJx1adSfIAiC4JfubYJFTV9Qnxdvb2/06dMHGzdu1J/TarXYuHGjgXXFEhqNBkePHkVsrPXhD6EJ8/c2OvfyzZ3Nhh/aKRKLJ6Yj6/UbzYZJjQnEgwMS8UD/RIxIteyY/PadPRDoY6hv/ntkMj66rxfmTbi+uWKHJmfdljONlMojg9sjPsxXbDEIwi1pH+EvavpPjegoavrujJ+3h6jpCz5sNHPmTEyaNAnp6eno168fFixYgOrqakyZMgUAMHHiRLRp0wbz588HAMydOxcDBgxAx44dUVZWhnfeeQfnz5/H1KlThRbVKlJYMqK1CKZkap4mna2NM76oQNxh52CCIEwghUbZTRHbA1Rw5eWee+5BcXExZs+ejcLCQvTs2RNr167VO/Hm5eVBpbpuALp69SqmTZuGwsJChIaGok+fPti5cye6dOkitKi801yv+OpcORhPUzY1UyZJ1Wx5Ub7ywhi1XwQhFmJXPZXYAhCi4RKH3RkzZmDGjBkmr23ZssXg+IMPPsAHH3zgAqnsRwpf+OEoQ0fuAjJZR2hgymzHWvm8KB/x3wpBEGIghTbZbRHZ9CK52UZKhC/LQHDFKfzOnkKAugZbNGl4uOE5o/ITjgqEcNXQMs4tlBcGRkvAE4RYiFz1qOq7L7Qxox0IUVHs6Xh7Hn8bAdBNSR7mcRi3qHYajRs1W10usAjUwdjBWIlQ+0UQ7gkNG4mH2OuekfIiIFyrf50hkStEVMleNEKFHxpHAgCmeq4xCtdBZXplXaXCGEh7IQiRELvqkdXVfSHlxQ5MVRNXVZ5xKt1O3Pu5bni38S40MhW6q3IRUmO4aaW5bQGUDDVfBEEQrkXsbVVIeXEBfCg4Iz0OAgA2cRm4iiBs13YHAKQUrzcI17FJeTnL2jidplygry+CEAex656K6r7bQsqLHQji82JDGDXq0YM7BwDYp9IpLX9q+wMAOpZuMQjbwc3WeAHI8kIQ7grpLuIh9jovpLwISPNXibP1qyuXCzXXiFrvcFyEbluFDZre0DAO0ddOA1dzAQBBqEK8qhgAcJoZb2KpRBhj1IARhEiIXfXIYdd9IeXFDkytKeCKupOuygIAlIT1BNdUW68iCPtYqi7AKZ3jbjdVLgDgvDYK5RBup2SpQWs9EIR7QsNG4sFEdnoh5cUFWKpfttS93irdppQloT0NOuq/Nem6H6dWA4B+aOkoS3JMUBnCQKZjghALqnuEWJDyYgdiVdQuXC4A4GpINwMZ1jUrL3m7gOor6KnKBgAc1bZ3sYQEQbgjYls9yfIiHuTzomD067w4UcH8UYOEJj+W8qBOBtcuIhIFfikA0wInfsMg1TEAwG6t+Z2ulYZubyNqwAhCDMSuemKnT4gHKS8SJ4XLBwAUslDUe4cYXT8dNlT348+ZCORqUMyCccSNho0A8Z0GCYIQB6r74kHrvMgcZzV/a/enqnTKyyltgsmKejjiVsDLX3/8s2YImBu9Vt3eRmJLQRCEGKhoupHb4j69HA+IMTyRyuUBAE6xBJPXq7wjgFsWAP6R2K7pik8bx7tQOmlAygtBuCdU9cWDfF4UDB+daqpKp7yc1MabD9TjbuC5s3iw4f+hEn7OJyojGBPfaZAg3BXR/c3ETp8QDVJe7MD11YQhtcnnJcuM5UXsufZSgNovgnBPqOqLCK3z4t5YshrEoQRB3DU0MA+zGy26u+5Cm0oThHiIXffow8V9IeXFDlxdUZqHjM6yODTAk7d4lVbhRTddEwQhCu7+8SYmYmc9KS92YH8X6Vynen3ISOfvYqqPFrsASQHSXQiCINwLUl7swNVf+ClN06SztKb9XYhmh12CIMRA7A8HsdN3Z8S2epHy4iTO1h1Lla9Tk+XlFDM/08iRAqS0+k7DRgRBEO4FKS92YG8f6Uyf6olGdOAuAQBOa9uajY+5/cARU5wyRhBygb4b3Bex+x5SXiRKe64Q3pwGlcwXFxHBa9xKs1Qo7HEIgrARWuPJfSHlxQ5cWU2a9zQ6zdpaTFnscUexoUXqCEI8qO65L2L3PaS8iIy5qn/dWbety9KULYp7IIIgCMISpLzYg53jE870qSlWVtZ1BiUNs9BsI4IQD7HbErHTd2fI8iJzhPIf6cRdANA8bGQeR7YHUJKpl3aVJgiCcD9IeZEgvqhFAncZAJDVYkNGU0qHm7u8kM8LQYgI1Tz3Rey+h5QXOxCkopowG6RwF6DiGIpZMEoRJECa/EcpJmR5IQj3hKq++0LKi4A42ql2V50DABzVtrcaVuxxR7FhIOWFIESDKp/b4ojLAp+Q8mIHpuqpEHW3B9ekvDAblBcHjHdKa25o2Igg3BPSndwXUl5ExlTd66bKAQAc1Sa5VhgZwhg1YAQhFlT1CLEg5cUOXPGF74M6/UyjIzYoLw7tbUQtDkEQBCFjSHkREEeUnS7ceXhwDEUsBJcRajW8m7u8NE2VJm2MIMRA7KpHQ8biIba/JSkvduCKitpHdRoAcETbQbA0lFbhlfU0BEHYitibAxLiQcqLkzjbcbZWiAaoTgIAdms7Ww0LiK/9ig75vBCEaFDVc1/EVhxJebEDwSuqVoO+qlMAgN3aLjbe5MBsI4W1OAp7HIIgbERpVmTCdkh5ERC7lYSCwwjialDB/HBSgD2NlIhunRdqwAhCDMSue2J//bszYlv9XaK8LFy4EO3atYOPjw/69++PvXv3Wgy/YsUKpKamwsfHB927d8eaNWtcIaZVBK+nZ9YBAHZpu0Br46txaLaR/bdIGqU9D0EQBGEZwZWX5cuXY+bMmXj11Vdx8OBBpKWlYezYsbh8+bLJ8Dt37sR9992HRx55BIcOHcKECRMwYcIEHDt2TGhRRcGg4z21GgCwTpNu8/1ia79iwxhtzEgQYiF21aNhI/EQu+sRXHl5//33MW3aNEyZMgVdunTBokWL4Ofnh6+//tpk+A8//BA33ngjnnvuOXTu3Bnz5s1D79698cknnwgtqlUErSjFp4HCo9AwDpu0PYVLB+KbevlHac9DEIQt0LCR++IpZOT19fU4cOAAZs2apT+nUqkwatQo7Nq1y+Q9u3btwsyZMw3OjR07Fr/++qvJ8HV1dairq9MfV1RUOC+4KaqvoNexN/CK51VooIIWKjRChbSzMfi3xxU0wgOlCMTfmr76zRTt0hEOLAEAbNL2xlU7NmN098rr3k9PEOKiuO8gwmbE3ttIUOXlypUr0Gg0iI6ONjgfHR2NU6dOmbynsLDQZPjCwkKT4efPn485c+bwI7Alaq4i+fwyJLfOsWygh9f1w7meS7FJ2ws/a4Ygve09VqMd2CECqL4CHPwWAPCDZgQAQO2pQl2j1iBsu3B/DEuJwo978/TntA6Un1Gdo1BSXY9/zlyx/2aJ0TshFNvPyv85CPfF20OFeo3WekAJIvawTVSQj6jpE+Ih+9lGs2bNQnl5uf4vPz9fmIR8Q4Ehz+F0p2n4zf9OfNF4E/ZF3w30nYbyLg9iR9DNqAjtBi9Og7Ee+/GF9/uYsn0E8OP9wP4l+P2hRLxwYyp2zRqBeRO64V9Dk3Bz91jMGN4B+Pv/AfVVQGxPTHpoKvq1C8OuWSPxzcP9kBYfgjYhvnhqREekxYfglf/rjHv7xjv0CB/f1wvzxnfFvAnd8PF9vZAQ5mfzvY8N7YAebYPtSq9f+zC7wv9fj1gM7RRp1z0P9Dc/K+vOPm3tistW/L098NzYFIfujQ5S8yyN60iNCTR5PiLAG14eHJKjAhyOe0ir9z48xbZy8Pgw48Uc3787zWz4jKRwjEyNslqWIwK8bUofAHy9PGwKd0+6cb1NiQ7ET/8agOWPDkConxeig9SYPrwD5t/e3eb0W7LowT64NS0OccH2deohfl4IUHti/8uj8OG9PRGotvG7lgN+enQA2ob6Gpx+amQy/jXUcHuTkalRmDu+K54Z3QltQgzDO8KiB/ugrQPxfP9If8wd3xU3JEeYvD6oY7j+t8qEbvb/bupsVI9XPJaBp0clIy0+BAAQGajG6icH4+07e5hth2ItvKO0+BBkJIXjjdscKweWSIrwx6SMRDw0INHhOCb0jMP9/R2/nw8EtbxERETAw8MDRUVFBueLiooQExNj8p6YmBi7wqvVaqjVLugQ/COAES+jE4BOrS4FAxjUfFB0Aji8DDiyAlxVIZD1J5D1J3oA6BHaHigfjIfa3QB07A0gEFj3PHDkJ4BTATe+ieGJMRjeWfesQztFGnXmft6eePOOHvhpn05JM2W5e/vOHnj+5yMG53olhOCWtDiDc/8emYxnVhy26fE7RgXgxXGpaPfinwbnIwK8caWq3ij8jhdHoKCsBncuMhweXDK5L6Ys3WcUPiJAjU/u741jF8ux9XSxTTK1CfGFp4d5/fvfI5Nx7GI5ThVWGpxPCPNDXuk1m9Jo5sN7e+LfP2UCACYObIfpwzvC18sDc1efAABsf2E4Br+1WR9+6uD2+HJ7jlE8W54djs6z11pNz0PF4b270vD08kyja/f2jde/f6FJjQnE2qeH6I8f//4A/jpmaAXd//Jog+PWZaSZl25KxRtrjC2uCWF++Pbhfrjl4+04erEcALBkSj8s35eHF345alG+maM7oX24P57/5Xp5v7lHLGb+73q5Ht0lGutP6NqUp0clo39SuJGcz9+YgrfXZumPtz0/HEcvlOOexbsB6N5vmxBftJ9lPPPx5LwbTT6z2lOF23u31VtK37qzB6YNScKo97fqwzw+rAN6J+i2ATk0e4zB/bNWGj/7zNGd8P760+ayA/3ah+HGbtfbSnPvom2oLy5crdEff3hvL31bM75nG4zv2cbsva0ZkBSO7S+MwOdbszH/r1N6OQHg863n9OG+mtxX/3tUl2iM+/Afg3jGdInGuqb3ZMry3Jobu8XgTFGlxTCtCVR7YnByBAYnR2BiRjsAQPm1BqTNXacP88XEdHSZ/TcA4IN7rtf7ZqYNScK0IUkG+dO3XRj6tgvD06MMe4dubYJxd3o8fj5wwUiWkZ2j8NPefDSaMJ//Nl3fo+ClVZbrgD2E+3tj07PD9Mfenip8ZaKdssaCe3vxJpOjCGp58fb2Rp8+fbBx40b9Oa1Wi40bNyIjI8PkPRkZGQbhAWD9+vVmw0uO6C7AmNeBmSeBR7cCw18G2vbVKSdXc4BD3wGrHgU+Sdf97f9Kd9+NbwKJ9j+jMz4vQo5Xm42axzRtkd+Uc7Ijz90ynmaF0bF4nA/rSodrV6TVnETrsmzLkLop6RwZyjB1T8tn5zjO7rwwJb6z2SmUm4GjYrW8z9my7cij8VI8udaH7uPII+fZqoJaXgBg5syZmDRpEtLT09GvXz8sWLAA1dXVmDJlCgBg4sSJaNOmDebPnw8A+Pe//42hQ4fivffew80334yffvoJ+/fvx+LFi4UWlV9UKiCup+5v6HNAbQWQtxvI/QfI3Q5cOQ1oNUBcL+CGZ4DkUWJLzCuONip8dO5CYLqTbPG7lTDOymbpdjGf25nGzlqn4NgO6daV05aH5pIwNTygZGdUozzi4Vnt6fT5UhDsLjMSe6f2iM9xzisbrd+znCd8CK683HPPPSguLsbs2bNRWFiInj17Yu3atXqn3Ly8PKhU1w1AAwcOxLJly/Dyyy/jpZdeQnJyMn799Vd069ZNaFGFxScI6DRG98cnopc9060BB85kg2it7eC7AbSmdNicVoubmiu8I1YJ+5Qzc3krT8xakpyJk6f4jBUew9LFV54L/e5cXTZc8ZGiVMSx8Cgn4wVXXgBgxowZmDFjhslrW7ZsMTp311134a677hJYKmUguu5iBilbXhxSOkwOK7S8blsatjZYHGe+mXGp5cWFX2qtvyptScmkguxABql4Gl6UK3x0pHbVXRPnHLO82X+PtTik+t45ON/eG9VnqXYgNiD72UaENDHf8VpuGZxtAJ2Jz+Z4mn1enI3HUVlc+PXkioa8uUw45vNgQumwEN6+xrqlz4s99zUnZiJGJzNUKOXR4Q8BB8siX+XK3s5XonqJTZhSsN0ZUl5kjtgLBZmtT5z+f/bFZ8+wkYOV2SGlw7QApn5aTMPWtC3lg5htmFM+Ly4S3FIy5jr/1h0Dx0n3C9wS8pFZNoIKhr3vip8PH+VAyovMkarVz1zna9XnxRWWFwdqsMFsI8ej4aUDd2UD5AorT3MKrRVxRxUlvnyRDH1e+MkHqXYejsplMHRqR76bDmr/Cxe6Q5fzsIopjIeN5PuApLwQguC4GVqowM5h2reipSi2mV5sFtlCQNdOlTY8dqapE6vjtiW7TPu8SFXVcB5by6t9cQoT1hJ2DxtJ7J3aozzw4pfUKg75qi6kvMgesRVnS8Mj1jp8k/c5YHmxlAcmHW1tT8LkPc0NjkPriUir7XQplocYHceaH4hB+TAT1KrlxQEZTckl9Dovrp7B4kqneaVhdw5QlhlAyovMkarm7LA/il2mZ+HTaMbabBRbo+Rl2MiVFqdWx0Iqy8azjVxXuvlazFCuuPdsI2N/JynCh1g024ggrMDBdGWz1kg6Ynq21NgIMtuoVfpCYClul35d89iSC2R44SU/TC5S13K2kQNxmuoYpLp6Kx+zjeyquyJlg5QUE3s/ZPiYbSShx3caUl5kjhAOV3ystWLv+evXnXX6s+E+R+5pcZOp7QFc6kQragsk4DovDsZtz33mQrZWKoxmGwmoBPOKTHonqSpx7oacV9gl5UXmSLXoObz+A89pmLT+OCCa6fVEhGuALVqTBEtV2LTMLtzXvM5L62EjFxZuU5YXe3CVQilUljgqPp+zjcRqy1qL0rJeS6lzF2KIjIaNCEXBSzvMmevwrdzGg9VHaPT1XYAvc1sQdYVdp9Z5cU4Ws/FaG4o0YTWzFMbUOaVbCuTmi+UoUhPRrr2NBJNCnpDyIndEn21k7mua3/hMp2FDWAEtJsL6vJiPXWkzNZqfpnVRtrVo8/F1bDRshNa7G1m73xgxqqZcioZJy4uczQAOYO+74sXnpfXHiNMxigcpLzJHCLOmoAupWfV54SENa/c5MmzU4vd1n5eWzoqu6zXEHDYScp0XUTsva5YXufi82IjRitB8DEnYlb44GWHTLuQSeUdGCCCXnPVFUl4IQeA44btzmwwvQqYvZNyWpxu5DF47GbM+L/wlYQ1zyr6zvlEu64wF6m0c/xBwTMOTqn6gdCSrmDkAKS8yR4i2jI8pjxxMf6Xb45/gaNpC09wBCvFlbgtibtAmpHXEKGYB0jLv82JitpGTU6VtSYdv5NI3SclhVyw4cHYVcT7erXH7K99cJ+VF5rja7Gf7YmyOxm/P15sNs41MDgfw5PMiYE8hEcMLv7ONzJ5vuiKtUSMeFl2TT8fAx7IDdn30iKRmmXzPRv5O15HSKxTCqVpKz2cvpLwQRvAz/m26ebK6zos9aYhleTG5+Jgy4dPBT0rvqzV8rj9kMR5eYhEC1842UtLwhaugPDOElBeZ4+p1CFrXH7Nf05xjHR3fDrumv7T4Qdh1Xjiz+SfusJHj91qbmebobCN7MLtIXWunTUhTkbaWJ652hHV0OrlpS5Xz8igZPt5s67ZDznlOygthhKXNDJ1tHK3dbZdC4KAszi5Sp9+YkTN9HXBesbF0t7MLqtkDnwqatXzXitiSmizzBh2z/Zj0+ZLI17PRRwgf1lb7xo14gY8iYzzbSCIvqRVCzAIVs845CykvMkfssmd+1VRH47MjrGNJCALvslh0ehHR8uLEvUJJba0O2CKzXDowa8hFaqUv+mcLohQxBWU7KS8yRxDdxUIBt7Xsmx8isDLbyMb4dXHZEsbyF7UjiP2t4tL2xwWJuXJ7APucaFvMNrLqq2UcQIiNGYX6WHFUKocddnmabWRvXbZ3eQWxPw5bIkRVlNDj2Q0pL4QgOKwguMDywtsKu5ztnZvdcVtMl9+0LNE6KWdm0FiTWyj/rZYim/d5UdAnqQ0YTw13scOu06npkJJyITRCLCQo5/wj5UXmuHqdF5unSjt4P9/bAwjytSL2UJ1Mbb9mrXEulsMUphzR7XJGtbVeCPywrtbBHFV63E1ZlApKyndSXmSPNFVnxxs1O8I6lIKDDrtWzvGtUFjKP5daXlyYlvGwEV9l23o8zj6n3LsEPuS3pw6Ycjp35H3b/96sDyPLfLFkixhZXiTaf9gCKS+EEZYqr60NlFnLi4P3mQxrk8+Lc2mYwlUV3tE85FcGHlMzE5V+qrQrstXcCrsWZtgZH5i430mLpK0IVfb4WKTOviFffsqV2FZQ1yJAzZdx/pHyInNcVXntTUYyK+wKuhaLQULCxW3HNb7hc0VOsawTtsjc2hIgV+u6o+Xd4ftc4NumVMSwesi1XJuClBeZI8Q8fYsNmc1j++ZmG1lL2w5sCWzK8uJkDRb7a8+V49auSMpcGq7MZmvbSPDmqyXRzsPx98yZ+CVkes7FY9oSa955WcgyaG87wtfK5wYyOB+laJDyQkgKOa3zYrBxn2JnG7Vu7JyZbWRZcKH2AmIGv+XcXPOHEEXIPqspP9itAPCUrhjw4pdkZEmVb30g5UXmCFH0LPu8OB27lav2zDZyLDW5r/MiV8z78DhpCXPqbtNwnKFUVn21bDa8CGv1c/1sI0fvk7MaQUgBUl5kjowVZ9O4wOnPkbtMDyuYj9PZL3yLs41c+P3oyl1ojfY24imtll+XiqsvPCHEGiL2hnXk3bh8WwMekYLVQ3wJHIeUF8IIIYcsrN1vz749js42kjtyfSZzcgs9TdnRBtrS3lX2ymAqTinBx4eAXUO+IuWDVPPfFvhR1GScAa0g5UXmCGUyFwrr5nd+h42cTcMUJpd9d2Gj4MqNGVsjqOXFwbit3cbL5n3OR8FrPHJHrgst8ondMzgFyDMJGH8chpQXmeNq06ORAyfP6dtnenZsqrQcOiKL1i+XDhvxl5ZZy0vTv62H2oQo2fYUV75Xe+YDoWo7HxupOmt5EcuZ2pLYQrav0likTr6Q8kIYIWTnbtX8LgPTs6kqr9TvSD59eYRSuuwZNuJjCMkZpGq2F2IarhSRg4xCItHi5xCkvBB2YU/hd2iXWN6X2ec1OknEraQGCID+gYQaNnIUOU3bFwuXL26nIOz9EBDCOVkKTsOOQsqLzBGk7AnZKVu7bpflxYXDJy0kN+3z4jJRRF2kzqkVdq2IbTzbiJ/CzUc8vO1EzkssPMC1PuRhEQQnZwqK1Y+KZQ2Tgt4gAREchpQXwi6cnQ7paoRtl8TxenFlvroiLVc+j2Bfmi56CMHE58HnxRX3OYucLT58iK6kYTNSXmSOEE5ufBVvU5JZXWbdBXXL2RwzaXkRce0VVyKl5dJdCV/1TM6dJ59QNohj9TAqfxKuc9Yg5UXmuLrBb21i5Tt53n1eBGwmRfN5ES5Z47R4nW1kOq7rp6XVkrqTz4uj8tuzFo7hfRIaNrJwTWnKOp8O+GIjqPJSWlqKBx54AEFBQQgJCcEjjzyCqqoqi/cMGzZMtzR3i7/HHntMSDGJVvDVYZmcbWRtewAZ9AKmKrxifV5an5D5rtKOis9XRyNVs70UVth1BdLMfduQ6kw1sfAUMvIHHngABQUFWL9+PRoaGjBlyhQ8+uijWLZsmcX7pk2bhrlz5+qP/fz8hBRT1rjc8mJHWMdmG/GLyfUkeMo00dZ5UVgbpl/nRWIfgc5aEoRAal/KNNvIGcQwvbSynEurONmFYMrLyZMnsXbtWuzbtw/p6ekAgI8//hg33XQT3n33XcTFxZm918/PDzExMUKJpigE8XmRyfTi5qi0WuFrYEu5xa7wrh02Mjx2bldpy9cF29uoRcyiT8eWSKdtLIaLZxuZGjYSa5E6kd6JJIaNZKy8CDZstGvXLoSEhOgVFwAYNWoUVCoV9uzZY/HeH374AREREejWrRtmzZqFa9euCSWmbGleIn5AUrjRtQ6R/kbnBnYwDtc+wjgcAAzuGGE2bL/2YQbnh6dGmZXRXJtgqbFQOdCSnCqsNHk+0MfTZP7ckBxpMb7eCSFG52KDfRDs6wUA6BIXBACICFTrr3u0WrO/W1ywxTSsMSI1yuz7sYWe8SEO39u3XWiL34bvO6ODcdmwheggNdqFm36egU1xjmgqS/FhvgCATjGBBuGSTJRrc3RtekcAkJ54/RkSwq5bcaODrr+/iIDrv5sJ9Ln+beflYblcjuocbXRuZGoUesYblgO1p2GT287Od2ytXLUuh8NTTJf11nUg1M/LKIyvl4dVefokXi8rpt5v/6b2YkBSmNG11rSsq6O7GOdnS3q01eVDiJ+31XhbMjTFfHtlClNtqSM0tx0ZLZ4xLT7EZLkJ8zd8pqimdmaYmXcJAKmt6kozLcswAAzqaNgepreo67Ziqn8QA8EsL4WFhYiKMiwonp6eCAsLQ2Fhodn77r//fiQmJiIuLg5HjhzBCy+8gKysLKxcudJk+Lq6OtTV1emPKyoq+HkAibPl2eHYdqYYd6W31Z/7bfog5FypRp9Ew4biqZHJeGJYB6M4eiWE4sN7e+LPIwUI8fNCakwQbkiOgIeKw+ojBQCAtqG+eHJER30jNW9CN3j8fhzrThRhaKdIPDcmBQ/0T8CPe/Ow+1wp0hND9TKZU+q3PjscQ97ZbPKaSsWhT2IoDpy/CgC4q09bDEgKR17pNRzMu4p/zlwxuqflMNDgjhG4eq0e/xnVCSF+3ph2QxLe+TtLf/2bh/shIykcUUFqDOoQgW93ncfXO3IAAC/f3BneniqM79kG+3NLofb0gNpLheLKOiRFBuD7R/pj//lS3NcvQZd/8SF4647uiA32hZeHChtmDsH3u/OQEhOI/+sRi7gQX1wqq0GjVovvd+dhzq1dAQAbnxmKPedK0b1NMO7+fBeGdoqEr7cHhqVEon/7cKw/UYjbe7eFv9oTPdoG48iFcgDAFxPT4e/tgexiQ7+xwR0jEBHgjdTYIHSODYKWMfSKD8Hvhy9h9m/H9eFeuikVXWKDse5EIQZ1jMCOs1fwy4ELqK7X6MP8PmMQQv28sWhrNmKCfPDw4PYGaU0f3gHl1+rxza7zZt4usO254fj98EW8u+60/tyv0wchNtgXH9/XC3EhvjhdVIlvdubizj5t8eCARADAa7d2RVrbYIzpqrO6DkmOwLzxXTH/r1NIjg7ElxPTsftcCf63Px/DU6KQ0aSQt/x6XPPUDfr3vGDDaYT7qzFtSBKGdIrEpbIaveIJAH8/PQSPfX8AjwxOQp/EULx5e3ecKKjAjd106Qf5eGHJ5L7wUHFQe+o68rVP34Af9+ShS1wQtOy6cjdnfFckRfqjpl6DW3vGYfe5Eozv2QYBak9oGZDeVH98vDzw9eR0/HroEgZ3jLCoZK5+cjDm/nECs2/pgsMXyjCoQwQSw/1wpqgSxVX12HH2CvJKdR92H97bE2H+3vDyMFSOFtzTCz8fvICya/Woa9RidJdonCqsxJ29dfm+YMNp3JoWh3ATytv6mUOwOasY43vG4ffMS+A4oLSqHnEhvuiVEILd50pxd4v2p1ubYP37bWbRg32w+sgl/F8PY0v7sqn9sfVMMXZnl+Dzh9IR6u+FiAA1hiRHItTfC/3bh+GVFuX37Tt7ICHMD6eLKnFz91gAOqXzy4np+G73eWgZw7CUKMxfcxKNTdbY5ro2pFMENp+6jDv6tDWSwxQt29K/nx6CQ3m69qhXwvXO/s+nBmPO7ycwd0JXq/Gt+fcN2HTqMu7q0xafbclGQXkN7k6Px03dY7Fifz5e//MkAODWtDi8OC7VUJYZg7DhRBHu6NMWE3q1QXFlHXonhGLdiUI0ahhuSI5AiJ831h4rwKgu0ciYv0l/77bnhmP9iSLUa7QAgDtbPf+kge3g5+2JjA7hqKnX4NilciRHBeBwfhlUKg63psVh3fEinCiowLhuMcgqqsStaeZHTVwJx+x0AHjxxRfx1ltvWQxz8uRJrFy5Et988w2ysrIMrkVFRWHOnDl4/PHHbUpv06ZNGDlyJM6ePYsOHYw74Ndeew1z5swxOl9eXo6goCCj8+5Cuxf/BAAEqj1xdM5Yu+69VFaDgW/qKsCP0wboOwl7ycwvw4SFOwzOrX5yMLq1CcaLvxzBT/vy9ecjAtTY//IoAMD767Lw0aazAIDcN282uL/lfUM7ReKbh/th4PyNuFReazI8ANzz+S7sySk1e705r96/Ow2397atcXMVX2w7h/+u0TVszbJ/tyvXoFFfcE9PTOjVxuT9zc/WMSoAG2YOtRimZRrWeG9dFj42846auWvRTuzLvWpXvI6wbE8eXlp1VPB0pMbX23Mwd/UJAMp9bkfKZu9561FaXW/XPY6kwxd1jRqkvLwWAPC/f2UYWbftpflZBiSF4adHM5yWz5VUVFQgODjYpv7bbsvLM888g8mTJ1sMk5SUhJiYGFy+fNngfGNjI0pLS+3yZ+nfvz8AmFVeZs2ahZkzZ+qPKyoqEB8fb3P8hDGObrZmFI+FaxZVZjsT5WvYVq7jv7b4CoixDLirkiTnT4JwP+xWXiIjIxEZadlnAAAyMjJQVlaGAwcOoE+fPgB0VhStVqtXSGwhMzMTABAbG2vyulqthlptbPIk+MGZfkGmugAhM+SqdDoLKW2EOyOYw27nzp1x4403Ytq0adi7dy927NiBGTNm4N5779XPNLp48SJSU1Oxd+9eAEB2djbmzZuHAwcOIDc3F7///jsmTpyIIUOGoEePHkKJSrSi5fRHoaaA8jmzwFrnJee+zZbst6XzlnMeEISSkeraP1JH0EXqfvjhB6SmpmLkyJG46aabMHjwYCxevFh/vaGhAVlZWfrZRN7e3tiwYQPGjBmD1NRUPPPMM7jjjjvwxx9/CCkmYQFRho0Iu7ApLym/CYJQEIIuUhcWFmZxQbp27doZjMXHx8dj69atQopE2ICBz4sT8biqv5Tawl2CI5PxAjd7Ky5HHqWAIISB9jZSOk62cEL1k9SxOUErU4sYhheynBEEPwjWxiq8jpLyonQcKMCchSPH4zHEUsWyN0WrldTGPFByXRdjthFBEIRQkPJCWMSZrwLqLgXCaH8S1+e0TEauFA1t1EdYQunFg5QXpeNIAebJ58USvM424i0meSLVYSOy9hCEdQRrYxVe/Uh5ISzizNcdzTaSDpTfBEEoCVJeCCMM1nlxVZo8rerrFrTWREgxcUuonhDuDCkvhBGuUCT4HFIgq4J13G46OUHIBPJdcgxSXgiLCLX6oyu7Uls7btn4aLR22LVpbyOhhLGQpuuTJAjCTSDlhTCiZdcoj48C6iZdjZQsOVKSxZXIomoSoqH0WkHKCyEKcjFyiI0tJmXbZv7wIAxBELxDSqhjkPJCGOGKMVhLfam9Q1Xu3jGL8fhS2kxOSrK4FHmYRQmRUHrpIOWFsIgS2kd3V26EQEp+Nu46bEQQllB6rSDlReE4uUadYPA624i3mOQJLRhHEPJFCR+IYkDKi8JxtstSwmwjW5GiTHyh5GdzV6jPI9wZUl4II+T2JeDuVgUaNiEIwt0g5UXhOKuHCKbI8Njf8rSptCSxJfulOttIzvlOEK6CFqlzDFJeCCMMtgdw0a7StnauLeVpvsXavUqzzLR+Jcp6OvtR2OslCMIGSHkhRIGGOhzHKOds6L0pvwmCUBKkvBDGtNzbyImBJ0d3lbbX2sObZUXB/buSrRPuanV31+cmCICUF0JAFNxfugxTHZRsho1cpDEpWTEjCMI0pLwQRrhmV2ke43LyutyxyWFXeDEIgiBcBikvhGBYHDai7tSlKM1pmXDjbREIAqS8ECbgzPy2F5d1l27eL5NiQhCEu0HKi8KR6hoCjva31E87Bt/5RkNVBCFxFF4BSXlROI58lbdUeJzRfSwPGzl2n6lwVn1ebMwCuQ5l2SK1PJ+MsIREv0sIwiWQ8kIIBnWYyoU6TvGhV0BYROEFhJQXhePIsBFn4YgveJ1t5OZjSWLsKi3VLQkIgmhC4fWPlBdCMCyrPQqvWS6Eho0IgnA3SHkhjBBjnRdXpClHKCsIc1A9IdwZUl4II1yxfgSflgB3tyrYMiREQzgEQSgJUl4IiwilxrjST8XWlJTcwYvhFyTX2VsEQUgfUl4II+Rmjlay0iFVpJTlUpLFldAKu4QllP7xQMoLYRGhFrlTdrVyLbRgHEEQ7gYpL4QoWOpw7VWYlP6FwQs8Z5GUvvmlJAtBSAWlW+ZIeSEsoojiL+NxJVsUOTGUN5umZ7tILPm+XSdRROUkhELpH3WkvCgcR0Z9XOHzwutsI2XXUV6gLCIIQkmQ8qJwnO3YhVvnRXrdqfQkMk3rdyLGCrsEQRBiQsoLYYTc+jmZies0rd+Puz0/oYNGjQh3hpQXheOs5UQJTl/UuYuTB3JTggmCkA+CKS///e9/MXDgQPj5+SEkJMSmexhjmD17NmJjY+Hr64tRo0bhzJkzQolIiAivHZubdZKODRsJIwtBEIQYCKa81NfX46677sLjjz9u8z1vv/02PvroIyxatAh79uyBv78/xo4di9raWqHEVCyJ4X4AgBGpUXbf66G63jsG+Xo6LENkoNroXESA7tyApDCD88NTIvW/O8cGmo2zZ3yI/ne/9ro4RneNBgCkRJu+b2CHCACAj5fl4t4hMsDidTFIjjaWqWMrOVNjzOdXh0h/AMCoLtFmw/RtFwoAGNwxwma5usUFWw0zOFkXn5+3h83xOkJylPTemyvo4AbPnZ6oK5s3JNteNpvbvPgwX0FkEpKYIB+n42huvzOSwp2OS9IwgVmyZAkLDg62Gk6r1bKYmBj2zjvv6M+VlZUxtVrNfvzxR5vTKy8vZwBYeXm5I+IqhqLyGvbtzhxWWdvg0P3bTl9mG08WOi3H2mMFbOfZK2zn2Svs72MF+vN1DRr2/e5ctjenhH27M4dVtZBTq9Wy/+3LY8culhnF16jRsjf/Osle+/0Yq2vQMMYYK6+pZ9/uzGGXK2pNylBT38i+3ZXL8kqqTV4/nH+VrTyY78xjCsrKg/nsSH6Z0bkf95xn/9uXx7Rardl7iyp05aCipt5smJKqOvbNzhx2tbrOZpm0Wi1bvjePnSwwX89q6hvZd7tyWX6p6Xznk5UH89nh/KuCpyM1fj10gR3Kuyq2GILhSNmsrG1g3+7MYYXlNTbfsy+nhP3r2/3swPlSR8R0mt3ZV9hfRy/xEldeSTX7blcuq21o5CU+V2JP/80xJqxBeenSpXj66adRVlZmMdy5c+fQoUMHHDp0CD179tSfHzp0KHr27IkPP/zQ5H11dXWoq6vTH1dUVCA+Ph7l5eUICgri4xEIgiAIghCYiooKBAcH29R/S8Zht7CwEAAQHW1o3o6OjtZfM8X8+fMRHBys/4uPjxdUToIgCIIgxMUu5eXFF18Ex3EW/06dOiWUrCaZNWsWysvL9X/5+fkuTZ8gCIIgCNdilzfmM888g8mTJ1sMk5SU5JAgMTExAICioiLExsbqzxcVFRkMI7VGrVZDrTZ2DCUIgiAIQpnYpbxERkYiMjLSekAHaN++PWJiYrBx40a9slJRUYE9e/bYNWOJIAiCIAhlI5jPS15eHjIzM5GXlweNRoPMzExkZmaiqqpKHyY1NRWrVq0CoNuA7umnn8brr7+O33//HUePHsXEiRMRFxeHCRMmCCUmQRAEQRAyw/FFPKwwe/ZsfPPNN/rjXr16AQA2b96MYcOGAQCysrJQXl6uD/P888+juroajz76KMrKyjB48GCsXbsWPj7Oz30nCIIgCEIZCD5V2tXYM9WKIAiCIAhpIMup0gRBEARBELZAygtBEARBELKClBeCIAiCIGQFKS8EQRAEQcgKUl4IgiAIgpAVpLwQBEEQBCErBFvnRSyaZ35XVFSILAlBEARBELbS3G/bsoKL4pSXyspKAKDdpQmCIAhChlRWViI4ONhiGMUtUqfVanHp0iUEBgaC4zhe466oqEB8fDzy8/NpATwRoPwXH3oH4kL5Ly6U/8LCGENlZSXi4uKgUln2alGc5UWlUqFt27aCphEUFEQFV0Qo/8WH3oG4UP6LC+W/cFizuDRDDrsEQRAEQcgKUl4IgiAIgpAVpLzYgVqtxquvvgq1Wi22KG4J5b/40DsQF8p/caH8lw6Kc9glCIIgCELZkOWFIAiCIAhZQcoLQRAEQRCygpQXgiAIgiBkBSkvBEEQBEHIClJebGThwoVo164dfHx80L9/f+zdu1dskdyG1157DRzHGfylpqaKLZZi2bZtG2655RbExcWB4zj8+uuvBtcZY5g9ezZiY2Ph6+uLUaNG4cyZM+IIq1CsvYPJkycb1Ykbb7xRHGEVxvz589G3b18EBgYiKioKEyZMQFZWlkGY2tpaTJ8+HeHh4QgICMAdd9yBoqIikSR2T0h5sYHly5dj5syZePXVV3Hw4EGkpaVh7NixuHz5stiiuQ1du3ZFQUGB/m/79u1ii6RYqqurkZaWhoULF5q8/vbbb+Ojjz7CokWLsGfPHvj7+2Ps2LGora11saTKxdo7AIAbb7zRoE78+OOPLpRQuWzduhXTp0/H7t27sX79ejQ0NGDMmDGorq7Wh/nPf/6DP/74AytWrMDWrVtx6dIl3H777SJK7YYwwir9+vVj06dP1x9rNBoWFxfH5s+fL6JU7sOrr77K0tLSxBbDLQHAVq1apT/WarUsJiaGvfPOO/pzZWVlTK1Wsx9//FEECZVP63fAGGOTJk1i48ePF0Ued+Py5csMANu6dStjTFfevby82IoVK/RhTp48yQCwXbt2iSWm20GWFyvU19fjwIEDGDVqlP6cSqXCqFGjsGvXLhElcy/OnDmDuLg4JCUl4YEHHkBeXp7YIrklOTk5KCwsNKgPwcHB6N+/P9UHF7NlyxZERUUhJSUFjz/+OEpKSsQWSZGUl5cDAMLCwgAABw4cQENDg0EdSE1NRUJCAtUBF0LKixWuXLkCjUaD6Ohog/PR0dEoLCwUSSr3on///li6dCnWrl2Lzz77DDk5ObjhhhtQWVkptmhuR3OZp/ogLjfeeCO+/fZbbNy4EW+99Ra2bt2KcePGQaPRiC2aotBqtXj66acxaNAgdOvWDYCuDnh7eyMkJMQgLNUB16K4XaUJ5TFu3Dj97x49eqB///5ITEzE//73PzzyyCMiSkYQ4nDvvffqf3fv3h09evRAhw4dsGXLFowcOVJEyZTF9OnTcezYMfKxkyBkebFCREQEPDw8jDzJi4qKEBMTI5JU7k1ISAg6deqEs2fPii2K29Fc5qk+SIukpCRERERQneCRGTNmYPXq1di8eTPatm2rPx8TE4P6+nqUlZUZhKc64FpIebGCt7c3+vTpg40bN+rPabVabNy4ERkZGSJK5r5UVVUhOzsbsbGxYovidrRv3x4xMTEG9aGiogJ79uyh+iAiFy5cQElJCdUJHmCMYcaMGVi1ahU2bdqE9u3bG1zv06cPvLy8DOpAVlYW8vLyqA64EBo2soGZM2di0qRJSE9PR79+/bBgwQJUV1djypQpYovmFjz77LO45ZZbkJiYiEuXLuHVV1+Fh4cH7rvvPrFFUyRVVVUGX/A5OTnIzMxEWFgYEhIS8PTTT+P1119HcnIy2rdvj1deeQVxcXGYMGGCeEIrDEvvICwsDHPmzMEdd9yBmJgYZGdn4/nnn0fHjh0xduxYEaVWBtOnT8eyZcvw22+/ITAwUO/HEhwcDF9fXwQHB+ORRx7BzJkzERYWhqCgIDz55JPIyMjAgAEDRJbejRB7upNc+Pjjj1lCQgLz9vZm/fr1Y7t37xZbJLfhnnvuYbGxsczb25u1adOG3XPPPezs2bNii6VYNm/ezAAY/U2aNIkxppsu/corr7Do6GimVqvZyJEjWVZWlrhCKwxL7+DatWtszJgxLDIyknl5ebHExEQ2bdo0VlhYKLbYisBUvgNgS5Ys0YepqalhTzzxBAsNDWV+fn7stttuYwUFBeIJ7YZwjDHmepWJIAiCIAjCMcjnhSAIgiAIWUHKC0EQBEEQsoKUF4IgCIIgZAUpLwRBEARByApSXgiCIAiCkBWkvBAEQRAEIStIeSEIgiAIQlaQ8kIQBEEQhKwg5YUgCIIgCFlBygtBEARBELKClBeCIAiCIGQFKS8EQRAEQciK/w+6BrHAGpOW4QAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "time1, wx, wy, wz = zip(*gyro_noisy.measured_data)\n", "time2, zx, zy, zz = zip(*gyro_clean.measured_data)\n", "\n", - "plt.plot(time1, wx, label='Noisy Gyroscope')\n", - "plt.plot(time2, zx, label='Clean Gyroscope')\n", + "plt.plot(time1, wx, label=\"Noisy Gyroscope\")\n", + "plt.plot(time2, zx, label=\"Clean Gyroscope\")\n", + "plt.xlabel(\"Time (s)\")\n", + "plt.ylabel(\"Angular Velocity wx (rad/s)\")\n", "plt.legend()\n", "plt.show()\n", "\n", - "plt.plot(time1, wy, label='Noisy Gyroscope')\n", - "plt.plot(time2, zy, label='Clean Gyroscope')\n", + "plt.plot(time1, wy, label=\"Noisy Gyroscope\")\n", + "plt.plot(time2, zy, label=\"Clean Gyroscope\")\n", + "plt.xlabel(\"Time (s)\")\n", + "plt.ylabel(\"Angular Velocity wy (rad/s)\")\n", "plt.legend()\n", "plt.show()\n", "\n", - "plt.plot(time1, wz, label='Noisy Gyroscope')\n", - "plt.plot(time2, zz, label='Clean Gyroscope')\n", + "plt.plot(time1, wz, label=\"Noisy Gyroscope\")\n", + "plt.plot(time2, zz, label=\"Clean Gyroscope\")\n", + "plt.xlabel(\"Time (s)\")\n", + "plt.ylabel(\"Angular Velocity wz (rad/s)\")\n", "plt.legend()\n", - "plt.show()\n" + "plt.show()\n", + "\n", + "# now plot the total angular velocity\n", + "\n", + "abs_w = (np.array(wx) ** 2 + np.array(wy) ** 2 + np.array(wz) ** 2) ** 0.5\n", + "abs_z = (np.array(zx) ** 2 + np.array(zy) ** 2 + np.array(zz) ** 2) ** 0.5\n", + "plt.plot(time1, abs_w, label=\"noisy\")\n", + "plt.plot(time2, abs_z, label=\"clean\")\n", + "plt.xlabel(\"Time (s)\")\n", + "plt.ylabel(\"Angular Velocity (rad/s)\")\n", + "plt.legend()\n", + "plt.xlim(0, 10)\n", + "plt.show()" ] }, { @@ -677,7 +471,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.0" + "version": "3.10.11" }, "vscode": { "interpreter": { From 7a2e50a7467e5119ca1e5becf12092491769cac0 Mon Sep 17 00:00:00 2001 From: Gui-FernandesBR Date: Wed, 15 May 2024 06:26:05 -0400 Subject: [PATCH 67/77] MNT: minor fixes - typos and isort --- rocketpy/mathutils/vector_matrix.py | 4 ++-- rocketpy/sensors/accelerometer.py | 2 +- rocketpy/tools.py | 2 +- tests/test_sensors.py | 3 ++- tests/unit/test_sensors.py | 2 +- 5 files changed, 7 insertions(+), 6 deletions(-) diff --git a/rocketpy/mathutils/vector_matrix.py b/rocketpy/mathutils/vector_matrix.py index c10ec5faf..fb884a672 100644 --- a/rocketpy/mathutils/vector_matrix.py +++ b/rocketpy/mathutils/vector_matrix.py @@ -950,7 +950,7 @@ def dot(self, other): return self.__matmul__(other) def round(self, decimals=0): - """Round the matrix to a given number of decimals. + """Round all the values matrix to a given number of decimals. Parameters ---------- @@ -1040,7 +1040,7 @@ def transformation(quaternion): q_x /= q_norm q_y /= q_norm q_z /= q_norm - # precompute common terms + # pre-compute common terms q_x2 = q_x**2 q_y2 = q_y**2 q_z2 = q_z**2 diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 29fe7f0ec..38628fcbc 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -237,7 +237,7 @@ def measure(self, t, u, u_dot, relative_position, gravity, *args): ) A = inertial_to_sensor @ A - # Apply noise + bias and quatize + # Apply noise + bias and quantize A = self.apply_noise(A) A = self.apply_temperature_drift(A) A = self.quantize(A) diff --git a/rocketpy/tools.py b/rocketpy/tools.py index 213225410..d5526c1d1 100644 --- a/rocketpy/tools.py +++ b/rocketpy/tools.py @@ -1,9 +1,9 @@ import functools import importlib import importlib.metadata +import math import re import time -import math from bisect import bisect_left import numpy as np diff --git a/tests/test_sensors.py b/tests/test_sensors.py index 62c872b90..99ae7a0dd 100644 --- a/tests/test_sensors.py +++ b/tests/test_sensors.py @@ -1,5 +1,6 @@ import json import os + import numpy as np from rocketpy.mathutils.vector_matrix import Vector @@ -25,7 +26,7 @@ def test_sensor_on_rocket(calisto_accel_gyro): def test_ideal_sensors(flight_calisto_accel_gyro): - """Test the ideal sensors. All types of sensors are here to reduvce + """Test the ideal sensors. All types of sensors are here to reduce testing time. Parameters diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensors.py index 4e08dfcea..ff746e4ae 100644 --- a/tests/unit/test_sensors.py +++ b/tests/unit/test_sensors.py @@ -2,8 +2,8 @@ import os import numpy as np -from pytest import approx import pytest +from pytest import approx from rocketpy.mathutils.vector_matrix import Matrix, Vector from rocketpy.tools import euler_to_quaternions From a57308d10a6815ef984a01f8bea175cc3432afaa Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 16 May 2024 14:46:54 +0200 Subject: [PATCH 68/77] MNT: remove aft double underscore from __units --- rocketpy/prints/sensors_prints.py | 2 +- rocketpy/sensors/accelerometer.py | 2 +- rocketpy/sensors/gyroscope.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/rocketpy/prints/sensors_prints.py b/rocketpy/prints/sensors_prints.py index 9ec0e492d..1d6bb88ab 100644 --- a/rocketpy/prints/sensors_prints.py +++ b/rocketpy/prints/sensors_prints.py @@ -4,7 +4,7 @@ class _SensorsPrints(ABC): def __init__(self, sensor): self.sensor = sensor - self.units = sensor.__units__ + self.units = sensor.__units def _print_aligned(self, label, value): """Prints a label and a value aligned vertically.""" diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 38628fcbc..42f6e7eb7 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -61,7 +61,7 @@ class Accelerometer(Sensors): temperature drift. """ - __units__ = "m/s^2" + __units = "m/s^2" def __init__( self, diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index 0f8629d77..6ef6f6b9b 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -61,7 +61,7 @@ class Gyroscope(Sensors): temperature drift. """ - __units__ = "rad/s" + __units = "rad/s" def __init__( self, From 11a8ab60486f3032ec1fae1b9d9328a46168e607 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 16 May 2024 14:51:36 +0200 Subject: [PATCH 69/77] DOC: remove .type --- rocketpy/sensors/accelerometer.py | 2 -- rocketpy/sensors/gyroscope.py | 2 -- rocketpy/sensors/sensors.py | 2 -- 3 files changed, 6 deletions(-) diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 42f6e7eb7..170402f7f 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -12,8 +12,6 @@ class Accelerometer(Sensors): Attributes ---------- - type : str - Type of the sensor, in this case "Accelerometer". consider_gravity : bool Whether the sensor considers the effect of gravity on the acceleration. prints : _AccelerometerPrints diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index 6ef6f6b9b..8928419a0 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -12,8 +12,6 @@ class Gyroscope(Sensors): Attributes ---------- - type : str - Type of the sensor, in this case "Gyroscope". acceleration_sensitivity : float, list Sensitivity of the sensor to linear acceleration in rad/s/g. prints : _GyroscopePrints diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index d3d7f16d8..c7df1b9fe 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -10,8 +10,6 @@ class Sensors(ABC): Attributes ---------- - type : str - Type of the sensor (e.g. Accelerometer, Gyroscope). sampling_rate : float Sample rate of the sensor in Hz. orientation : tuple, list From 298406568508bc6529458da192ac1443a917e1be Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 16 May 2024 14:59:46 +0200 Subject: [PATCH 70/77] MNT: remove .units underscores --- rocketpy/prints/sensors_prints.py | 2 +- rocketpy/sensors/accelerometer.py | 2 +- rocketpy/sensors/gyroscope.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/rocketpy/prints/sensors_prints.py b/rocketpy/prints/sensors_prints.py index 1d6bb88ab..41f5fd937 100644 --- a/rocketpy/prints/sensors_prints.py +++ b/rocketpy/prints/sensors_prints.py @@ -4,7 +4,7 @@ class _SensorsPrints(ABC): def __init__(self, sensor): self.sensor = sensor - self.units = sensor.__units + self.units = sensor.units def _print_aligned(self, label, value): """Prints a label and a value aligned vertically.""" diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 170402f7f..00fbe25ef 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -59,7 +59,7 @@ class Accelerometer(Sensors): temperature drift. """ - __units = "m/s^2" + units = "m/s^2" def __init__( self, diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index 8928419a0..d40be7758 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -59,7 +59,7 @@ class Gyroscope(Sensors): temperature drift. """ - __units = "rad/s" + units = "rad/s" def __init__( self, From 82f79e7433d97f09ea6c9acb54d0ef72dfb030c7 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 16 May 2024 15:01:33 +0200 Subject: [PATCH 71/77] MNT: remove repetition from sensors prints --- rocketpy/prints/sensors_prints.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/rocketpy/prints/sensors_prints.py b/rocketpy/prints/sensors_prints.py index 41f5fd937..2d646a4f4 100644 --- a/rocketpy/prints/sensors_prints.py +++ b/rocketpy/prints/sensors_prints.py @@ -12,13 +12,13 @@ def _print_aligned(self, label, value): def identity(self): """Prints the identity of the sensor.""" - print("Identification of the Sensor:\n") + print("Identification:\n") self._print_aligned("Name:", self.sensor.name) self._print_aligned("Type:", self.sensor.__class__.__name__) def orientation(self): """Prints the orientation of the sensor.""" - print("\nOrientation of the Sensor:\n") + print("\nOrientation:\n") self._print_aligned("Orientation:", self.sensor.orientation) self._print_aligned("Normal Vector:", self.sensor.normal_vector) print("Rotation Matrix:") @@ -29,7 +29,7 @@ def orientation(self): def quantization(self): """Prints the quantization of the sensor.""" - print("\nQuantization of the Sensor:\n") + print("\nQuantization:\n") self._print_aligned( "Measurement Range:", f"{self.sensor.measurement_range[0]} to {self.sensor.measurement_range[1]} ({self.units})", @@ -43,7 +43,7 @@ def noise(self): def _general_noise(self): """Prints the noise of the sensor.""" - print("\nNoise of the Sensor:\n") + print("\nNoise:\n") self._print_aligned( "Noise Density:", f"{self.sensor.noise_density} {self.units}/√Hz" ) From 5016283c190bdb431404c696396fe8a8c7be1d12 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 16 May 2024 15:15:42 +0200 Subject: [PATCH 72/77] ENH: normalize_quaternions in tools.py --- rocketpy/mathutils/vector_matrix.py | 12 +++--------- rocketpy/tools.py | 22 ++++++++++++++++++++++ 2 files changed, 25 insertions(+), 9 deletions(-) diff --git a/rocketpy/mathutils/vector_matrix.py b/rocketpy/mathutils/vector_matrix.py index fb884a672..2776b3aa7 100644 --- a/rocketpy/mathutils/vector_matrix.py +++ b/rocketpy/mathutils/vector_matrix.py @@ -2,7 +2,7 @@ from functools import cached_property from itertools import product -from rocketpy.tools import euler_to_quaternions +from rocketpy.tools import euler_to_quaternions, normalize_quaternions class Vector: @@ -1031,15 +1031,9 @@ def transformation(quaternion): Matrix The transformation matrix from frame B to frame A. """ - q_w, q_x, q_y, q_z = quaternion # normalize quaternion - q_norm = (q_w**2 + q_x**2 + q_y**2 + q_z**2) ** 0.5 - if q_norm == 0: - return Matrix.identity() - q_w /= q_norm - q_x /= q_norm - q_y /= q_norm - q_z /= q_norm + q_w, q_x, q_y, q_z = normalize_quaternions(quaternion) + # pre-compute common terms q_x2 = q_x**2 q_y2 = q_y**2 diff --git a/rocketpy/tools.py b/rocketpy/tools.py index d5526c1d1..f3943a91b 100644 --- a/rocketpy/tools.py +++ b/rocketpy/tools.py @@ -11,6 +11,8 @@ from cftime import num2pydate from packaging import version as packaging_version +from rocketpy.mathutils.vector_matrix import Matrix + # Mapping of module name and the name of the package that should be installed INSTALL_MAPPING = {"IPython": "ipython"} @@ -502,6 +504,26 @@ def euler_to_quaternions(yaw, pitch, roll): return e0, e1, e2, e3 +def normalize_quaternions(quaternions): + """Normalizes the quaternions (Euler parameters) to have unit magnitude. + + Parameters + ---------- + quaternions : tuple + Tuple containing the Euler parameters e0, e1, e2, e3 + + Returns + ------- + tuple + Tuple containing the Euler parameters e0, e1, e2, e3 + """ + q_w, q_x, q_y, q_z = quaternions + q_norm = (q_w**2 + q_x**2 + q_y**2 + q_z**2) ** 0.5 + if q_norm == 0: + return Matrix.identity() + return q_w / q_norm, q_x / q_norm, q_y / q_norm, q_z / q_norm + + if __name__ == "__main__": import doctest From 6806912003576cf4559ac2c0f57ed7067f4e90da Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 16 May 2024 17:27:03 +0200 Subject: [PATCH 73/77] BUG: remove Matrix circuklar import in tools --- rocketpy/tools.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/rocketpy/tools.py b/rocketpy/tools.py index f3943a91b..0cbd16628 100644 --- a/rocketpy/tools.py +++ b/rocketpy/tools.py @@ -11,8 +11,6 @@ from cftime import num2pydate from packaging import version as packaging_version -from rocketpy.mathutils.vector_matrix import Matrix - # Mapping of module name and the name of the package that should be installed INSTALL_MAPPING = {"IPython": "ipython"} @@ -520,7 +518,7 @@ def normalize_quaternions(quaternions): q_w, q_x, q_y, q_z = quaternions q_norm = (q_w**2 + q_x**2 + q_y**2 + q_z**2) ** 0.5 if q_norm == 0: - return Matrix.identity() + return 1, 0, 0, 0 return q_w / q_norm, q_x / q_norm, q_y / q_norm, q_z / q_norm From b99b301feb49c3da37444ac32209ebd733c27d9f Mon Sep 17 00:00:00 2001 From: MateusStano <69485049+MateusStano@users.noreply.github.com> Date: Thu, 16 May 2024 12:45:46 -0300 Subject: [PATCH 74/77] MNT: remove unused variable Co-authored-by: Gui-FernandesBR <63590233+Gui-FernandesBR@users.noreply.github.com> --- rocketpy/simulation/flight.py | 1 - 1 file changed, 1 deletion(-) diff --git a/rocketpy/simulation/flight.py b/rocketpy/simulation/flight.py index f5d37a323..49460aeea 100644 --- a/rocketpy/simulation/flight.py +++ b/rocketpy/simulation/flight.py @@ -1292,7 +1292,6 @@ def __cache_sensor_data(self): # skip sensors that are used more then once in the rocket if sensor not in sensors: sensors.append(sensor) - num_instances = sensor._attached_rockets[self.rocket] sensor_data[sensor] = sensor.measured_data[:] self.sensor_data = sensor_data From 75f8d9e47900ba2798661d88fb279bd44704f0cd Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 16 May 2024 17:50:22 +0200 Subject: [PATCH 75/77] ENH: explicit for loop variables --- rocketpy/simulation/flight.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rocketpy/simulation/flight.py b/rocketpy/simulation/flight.py index f5d37a323..3e5c56b3e 100644 --- a/rocketpy/simulation/flight.py +++ b/rocketpy/simulation/flight.py @@ -3401,8 +3401,8 @@ def export_sensor_data(self, file_name, sensor=None): """ if sensor is None: data_dict = {} - for key, value in self.sensor_data.items(): - data_dict[key.name] = value + 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 = {} From a20d31dbb3853e4aa4ad5a0cc8a9def7c4e66962 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 16 May 2024 17:59:15 +0200 Subject: [PATCH 76/77] DOC: improve orientation docs --- rocketpy/sensors/accelerometer.py | 6 +++--- rocketpy/sensors/gyroscope.py | 6 +++--- rocketpy/sensors/sensors.py | 6 +++--- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 00fbe25ef..f4a637b66 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -90,10 +90,10 @@ def __init__( Orientation of the sensor in the rocket. The orientation can be given as: - A list of length 3, where the elements are the Euler angles for - the rotation roll (φ), pitch (θ) and yaw (ψ) in radians. The + the rotation yaw (ψ), pitch (θ) and roll (φ) in radians. The standard rotation sequence is z-y-x (3-2-1) is used, meaning the - sensor is first rotated by ψ around the z axis, then by θ around - the new y axis and finally by φ around the new x axis. + sensor is first rotated by ψ around the x axis, then by θ around + the new y axis and finally by φ around the new z axis. - A list of lists (matrix) of shape 3x3, representing the rotation matrix from the sensor frame to the rocket frame. The sensor frame of reference is defined as to have z axis along the sensor's normal diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index d40be7758..26df61d4d 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -90,10 +90,10 @@ def __init__( Orientation of the sensor in the rocket. The orientation can be given as: - A list of length 3, where the elements are the Euler angles for - the rotation roll (φ), pitch (θ) and yaw (ψ) in radians. The + the rotation yaw (ψ), pitch (θ) and roll (φ) in radians. The standard rotation sequence is z-y-x (3-2-1) is used, meaning the - sensor is first rotated by ψ around the z axis, then by θ around - the new y axis and finally by φ around the new x axis. + sensor is first rotated by ψ around the x axis, then by θ around + the new y axis and finally by φ around the new z axis. - A list of lists (matrix) of shape 3x3, representing the rotation matrix from the sensor frame to the rocket frame. The sensor frame of reference is defined as to have z axis along the sensor's normal diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index c7df1b9fe..eea0b9384 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -81,10 +81,10 @@ def __init__( Orientation of the sensor in the rocket. The orientation can be given as: - A list of length 3, where the elements are the Euler angles for - the rotation roll (φ), pitch (θ) and yaw (ψ) in radians. The + the rotation yaw (ψ), pitch (θ) and roll (φ) in radians. The standard rotation sequence is z-y-x (3-2-1) is used, meaning the - sensor is first rotated by ψ around the z axis, then by θ around - the new y axis and finally by φ around the new x axis. + sensor is first rotated by ψ around the x axis, then by θ around + the new y axis and finally by φ around the new z axis. TODO: x and y are not defined in the rocket class. User has no way to know which axis is which. - A list of lists (matrix) of shape 3x3, representing the rotation From ce1d179412115965cee9a561fbe8d846477683a1 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Fri, 17 May 2024 01:33:10 +0200 Subject: [PATCH 77/77] ENH: x_position to x_offset --- rocketpy/rocket/rocket.py | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/rocketpy/rocket/rocket.py b/rocketpy/rocket/rocket.py index c09e7c160..c7bbd380a 100644 --- a/rocketpy/rocket/rocket.py +++ b/rocketpy/rocket/rocket.py @@ -1170,7 +1170,7 @@ def add_parachute( self.parachutes.append(parachute) return self.parachutes[-1] - def add_sensor(self, sensor, position, x_position=0, y_position=0): + def add_sensor(self, sensor, position, x_offset=0, y_offset=0): """Adds a sensor to the rocket. Parameters @@ -1180,18 +1180,20 @@ def add_sensor(self, sensor, position, x_position=0, y_position=0): position : int, float, tuple Position, in meters, of the sensor's coordinate system origin relative to the user defined rocket coordinate system. - x_position : int, float, optional - Distance in meters by which the sensor is to be translated in the x - direction relative to geometrical center line. Default is 0. - y_position : int, float, optional - Distance in meters by which the sensor is to be translated in the y - direction relative to geometrical center line. Default is 0. + x_offset : int, float, optional + Distance in meters by which the sensor is to be translated in the + rocket's x direction relative to geometrical center line. + Default is 0. + y_offset : int, float, optional + Distance in meters by which the sensor is to be translated in the + rocket's y direction relative to geometrical center line. + Default is 0. Returns ------- None """ - self.sensors.add(sensor, Vector([x_position, y_position, position])) + self.sensors.add(sensor, Vector([x_offset, y_offset, position])) try: sensor._attached_rockets[self] += 1 except KeyError: