From b4b51a4f471d80fff1ab58eea1308b5a978044b8 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Fri, 3 May 2024 23:55:33 +0200 Subject: [PATCH 01/31] ENH: add pressure to .measure params --- rocketpy/sensors/accelerometer.py | 33 ++++++++++++++++++++----------- rocketpy/sensors/gyroscope.py | 30 ++++++++++++++++++---------- rocketpy/simulation/flight.py | 13 +++++++----- 3 files changed, 49 insertions(+), 27 deletions(-) diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index b5e447085..e0d7a4f38 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -195,22 +195,31 @@ def __init__( self.consider_gravity = consider_gravity self.prints = _AccelerometerPrints(self) - def measure(self, t, u, u_dot, relative_position, gravity, *args): + def measure(self, time, **kwargs): """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 + time : float + Current time in seconds. + kwargs : dict + Keyword arguments dictionary containing the following keys: + - u : np.array + State vector of the rocket. + - u_dot : np.array + Derivative of the state vector of the rocket. + - relative_position : np.array + Position of the sensor relative to the rocket center of mass. + - gravity : float + Gravitational acceleration in m/s^2. + - pressure : Function + Atmospheric pressure profile as a function of altitude in Pa. """ + u = kwargs["u"] + u_dot = kwargs["u_dot"] + relative_position = kwargs["relative_position"] + gravity = kwargs["gravity"] + # Linear acceleration of rocket cdm in inertial frame gravity = ( Vector([0, 0, -gravity]) if self.consider_gravity else Vector([0, 0, 0]) @@ -242,7 +251,7 @@ def measure(self, t, u, u_dot, relative_position, gravity, *args): A = self.quantize(A) self.measurement = tuple([*A]) - self._save_data((t, *A)) + self._save_data((time, *A)) def export_measured_data(self, filename, format="csv"): """ diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index 6ba2b945d..c23d64d46 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -197,20 +197,30 @@ def __init__( ) self.prints = _GyroscopePrints(self) - def measure(self, t, u, u_dot, relative_position, *args): + def measure(self, time, **kwargs): """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 + time : float + Current time in seconds. + kwargs : dict + Keyword arguments dictionary containing the following keys: + - u : np.array + State vector of the rocket. + - u_dot : np.array + Derivative of the state vector of the rocket. + - relative_position : np.array + Position of the sensor relative to the rocket center of mass. + - gravity : float + Gravitational acceleration in m/s^2. + - pressure : Function + Atmospheric pressure profile as a function of altitude in Pa. """ + u = kwargs["u"] + u_dot = kwargs["u_dot"] + relative_position = kwargs["relative_position"] + # Angular velocity of the rocket in the rocket frame omega = Vector(u[10:13]) @@ -234,7 +244,7 @@ def measure(self, t, u, u_dot, relative_position, *args): W = self.quantize(W) self.measurement = tuple([*W]) - self._save_data((t, *W)) + self._save_data((time, *W)) def apply_acceleration_sensitivity( self, omega, u_dot, relative_position, rotation_matrix diff --git a/rocketpy/simulation/flight.py b/rocketpy/simulation/flight.py index 6386157d3..50bcf9b07 100644 --- a/rocketpy/simulation/flight.py +++ b/rocketpy/simulation/flight.py @@ -709,7 +709,7 @@ def __init__( callback(self) if self.sensors: - # u_dot for all sensors + # udot 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( @@ -717,10 +717,13 @@ def __init__( ) sensor.measure( self.t, - self.y_sol, - u_dot, - relative_position, - self.env.gravity(self.solution[-1][3]), + u=self.y_sol, + u_dot=u_dot, + relative_position=relative_position, + gravity=self.env.gravity.get_value_opt( + self.solution[-1][3] + ), + pressure=self.env.pressure, ) for controller in node._controllers: From 4c0fbf920edcaccde5266b7eff95e40a0c56dc3e Mon Sep 17 00:00:00 2001 From: MateusStano Date: Sat, 4 May 2024 00:00:37 +0200 Subject: [PATCH 02/31] ENH: add InertialSensors and ScalarSensors --- rocketpy/sensors/accelerometer.py | 4 +- rocketpy/sensors/gyroscope.py | 4 +- rocketpy/sensors/sensors.py | 558 +++++++++++++++++++++++++----- 3 files changed, 467 insertions(+), 99 deletions(-) diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index e0d7a4f38..7e332eebf 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -4,10 +4,10 @@ from ..mathutils.vector_matrix import Matrix, Vector from ..prints.sensors_prints import _AccelerometerPrints -from ..sensors.sensors import Sensors +from ..sensors.sensors import InertialSensors -class Accelerometer(Sensors): +class Accelerometer(InertialSensors): """Class for the accelerometer sensor Attributes diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index c23d64d46..bdfb36a05 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -4,10 +4,10 @@ from ..mathutils.vector_matrix import Matrix, Vector from ..prints.sensors_prints import _GyroscopePrints -from ..sensors.sensors import Sensors +from ..sensors.sensors import InertialSensors -class Gyroscope(Sensors): +class Gyroscope(InertialSensors): """Class for the gyroscope sensor Attributes diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index 0a8438840..24dd01b8a 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -8,6 +8,222 @@ class Sensors(ABC): """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. + 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. + 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 + 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. + name : str + The name of the sensor. + 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__( + self, + sampling_rate, + measurement_range=np.inf, + resolution=0, + noise_density=0, + noise_variance=1, + random_walk_density=0, + random_walk_variance=1, + constant_bias=0, + operating_temperature=25, + temperature_bias=0, + temperature_scale_factor=0, + name="Sensor", + ): + """ + Initialize the accelerometer sensor + + Parameters + ---------- + sampling_rate : float + Sample rate of the sensor + 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, list, optional + 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_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 + 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, list, optional + The temperature bias of the sensor in sensor units/°C. Default is 0, + 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. 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. + name : str, optional + The name of the sensor. Default is "Sensor". + + Returns + ------- + None + + See Also + -------- + TODO link to documentation on noise model + """ + self.sampling_rate = sampling_rate + self.resolution = resolution + self.operating_temperature = operating_temperature + self.noise_density = noise_density + self.noise_variance = noise_variance + self.random_walk_density = random_walk_density + self.random_walk_variance = random_walk_variance + self.constant_bias = constant_bias + self.temperature_bias = temperature_bias + self.temperature_scale_factor = temperature_scale_factor + self.name = name + self.measurement = None + self.measured_data = [] + self._counter = 0 + self._save_data = self._save_data_single + self._random_walk_drift = 0 + self.normal_vector = Vector([0, 0, 0]) + + # 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") + + # 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 _reset(self, simulated_rocket): + """Reset the sensor data for a new simulation.""" + self._random_walk_drift = ( + Vector([0, 0, 0]) if isinstance(self._random_walk_drift, Vector) else 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): + """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 + + @abstractmethod + def measure(self, time, **kwargs): + pass + + @abstractmethod + def export_measured_data(self): + pass + + @abstractmethod + def quantize(self, value): + """Quantize the sensor measurement""" + pass + + @abstractmethod + def apply_noise(self, value): + """Add noise to the sensor measurement""" + pass + + @abstractmethod + def apply_temperature_drift(self, value): + """Apply temperature drift to the sensor measurement""" + pass + + +class InertialSensors(Sensors): + """Abstract class for sensors + Attributes ---------- type : str @@ -45,8 +261,6 @@ class Sensors(ABC): 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. @@ -165,42 +379,32 @@ def __init__( -------- 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.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" - ) - self.temperature_scale_factor = self._vectorize_input( - temperature_scale_factor, "temperature_scale_factor" + super().__init__( + sampling_rate=sampling_rate, + measurement_range=measurement_range, + resolution=resolution, + noise_density=self._vectorize_input(noise_density, "noise_density"), + noise_variance=self._vectorize_input(noise_variance, "noise_variance"), + random_walk_density=self._vectorize_input( + random_walk_density, "random_walk_density" + ), + random_walk_variance=self._vectorize_input( + random_walk_variance, "random_walk_variance" + ), + constant_bias=self._vectorize_input(constant_bias, "constant_bias"), + operating_temperature=operating_temperature, + temperature_bias=self._vectorize_input( + temperature_bias, "temperature_bias" + ), + temperature_scale_factor=self._vectorize_input( + temperature_scale_factor, "temperature_scale_factor" + ), + name=name, ) + + self.orientation = orientation self.cross_axis_sensitivity = cross_axis_sensitivity - self.name = name self._random_walk_drift = Vector([0, 0, 0]) - 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)): - 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 @@ -229,15 +433,6 @@ 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 __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]) @@ -246,40 +441,6 @@ 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): - """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 - - @abstractmethod - def measure(self, *args, **kwargs): - pass - - @abstractmethod - def export_measured_data(self): - pass - def quantize(self, value): """ Quantize the sensor measurement @@ -303,6 +464,222 @@ def quantize(self, value): 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 = 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 + 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 + 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 = value & scale_factor + + return value + + +class ScalarSensors(Sensors): + """Abstract class for sensors + + Attributes + ---------- + type : str + Type of the sensor (e.g. Barometer, GPS). + sampling_rate : float + Sample rate of the sensor in Hz. + 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 + The noise density of the sensor in sensor units/√Hz. + noise_variance : float + The variance of the noise of the sensor in sensor units^2. + random_walk_density : float + The random walk density of the sensor in sensor units/√Hz. + random_walk_variance : float + The variance of the random walk of the sensor in sensor units^2. + constant_bias : float + The constant bias of the sensor in sensor units. + operating_temperature : float + The operating temperature of the sensor in degrees Celsius. + temperature_bias : float + The temperature bias of the sensor in sensor units/°C. + temperature_scale_factor : float + The temperature scale factor of the sensor in %/°C. + name : str + The name of the sensor. + 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__( + self, + sampling_rate, + measurement_range=np.inf, + resolution=0, + noise_density=0, + noise_variance=1, + random_walk_density=0, + random_walk_variance=1, + constant_bias=0, + operating_temperature=25, + temperature_bias=0, + temperature_scale_factor=0, + name="Sensor", + ): + """ + Initialize the accelerometer sensor + + Parameters + ---------- + sampling_rate : float + Sample rate of the sensor + 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, list, optional + 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_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 + 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, list, optional + The temperature bias of the sensor in sensor units/°C. Default is 0, + 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. 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. + name : str, optional + The name of the sensor. Default is "Sensor". + + Returns + ------- + None + + See Also + -------- + TODO link to documentation on noise model + """ + super().__init__( + sampling_rate=sampling_rate, + measurement_range=measurement_range, + resolution=resolution, + noise_density=noise_density, + 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, + temperature_scale_factor=temperature_scale_factor, + name=name, + ) + + def quantize(self, value): + """ + Quantize the sensor measurement + + Parameters + ---------- + value : float + The value to quantize + + Returns + ------- + float + The quantized value + """ + value = min(max(value, self.measurement_range[0]), self.measurement_range[1]) + if self.resolution != 0: + value = round(value / self.resolution) * self.resolution + return value + def apply_noise(self, value): """ Add noise to the sensor measurement @@ -319,24 +696,16 @@ def apply_noise(self, value): """ # white noise white_noise = ( - Vector( - [np.random.normal(0, self.noise_variance[i] ** 0.5) for i in range(3)] - ) - & self.noise_density - ) * self.sampling_rate**0.5 + np.random.normal(0, self.noise_variance**0.5) + * self.noise_density + * self.sampling_rate**0.5 + ) # random walk self._random_walk_drift = ( self._random_walk_drift - + ( - Vector( - [ - np.random.normal(0, self.random_walk_variance[i] ** 0.5) - for i in range(3) - ] - ) - & self.random_walk_density - ) + + np.random.normal(0, self.random_walk_variance**0.5) + * self.random_walk_density / self.sampling_rate**0.5 ) @@ -363,9 +732,8 @@ def apply_temperature_drift(self, value): 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 + 1 + (self.operating_temperature - 25) / 100 * self.temperature_scale_factor ) - value = value & scale_factor + value = value * scale_factor return value From 6c4229d274e77605991f9ca0984404f88de4dcc5 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Sat, 4 May 2024 00:02:15 +0200 Subject: [PATCH 03/31] ENH: add Barometer class --- rocketpy/__init__.py | 2 +- rocketpy/sensors/__init__.py | 3 +- rocketpy/sensors/barometer.py | 183 ++++++++++++++++++++++++++++++++++ 3 files changed, 186 insertions(+), 2 deletions(-) create mode 100644 rocketpy/sensors/barometer.py diff --git a/rocketpy/__init__.py b/rocketpy/__init__.py index fe55dda41..1e0c0bef5 100644 --- a/rocketpy/__init__.py +++ b/rocketpy/__init__.py @@ -37,5 +37,5 @@ Tail, TrapezoidalFins, ) -from .sensors import Accelerometer, Gyroscope, Sensors +from .sensors import Accelerometer, Gyroscope, Barometer from .simulation import Flight diff --git a/rocketpy/sensors/__init__.py b/rocketpy/sensors/__init__.py index 5bfe07805..754a3f704 100644 --- a/rocketpy/sensors/__init__.py +++ b/rocketpy/sensors/__init__.py @@ -1,3 +1,4 @@ from .accelerometer import Accelerometer from .gyroscope import Gyroscope -from .sensors import Sensors +from .sensors import Sensors, InertialSensors, ScalarSensors +from .barometer import Barometer diff --git a/rocketpy/sensors/barometer.py b/rocketpy/sensors/barometer.py new file mode 100644 index 000000000..3a98154c4 --- /dev/null +++ b/rocketpy/sensors/barometer.py @@ -0,0 +1,183 @@ +import json + +import numpy as np + +from ..mathutils.vector_matrix import Matrix, Vector +from ..prints.sensors_prints import _BarometerPrints +from ..sensors.sensors import ScalarSensors + + +class Barometer(ScalarSensors): + """Class for the barometer sensor + + Attributes + ---------- + type : str + Type of the sensor, in this case "Barometer". + prints : _BarometerPrints + 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 Pa. + resolution : float + The resolution of the sensor in Pa/LSB. + noise_density : float + The noise density of the sensor in Pa/√Hz. + noise_variance : float + The variance of the noise of the sensor in Pa^2. + random_walk_density : float + The random walk density of the sensor in Pa/√Hz. + random_walk_variance : float + The variance of the random walk of the sensor in Pa^2. + constant_bias : float + The constant bias of the sensor in Pa. + operating_temperature : float + The operating temperature of the sensor in degrees Celsius. + temperature_bias : float + The temperature bias of the sensor in Pa/°C. + temperature_scale_factor : float + The temperature scale factor of the sensor in %/°C. + name : str + The name of the sensor. + 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__( + self, + sampling_rate, + measurement_range=np.inf, + resolution=0, + noise_density=0, + noise_variance=1, + random_walk_density=0, + random_walk_variance=1, + constant_bias=0, + operating_temperature=25, + temperature_bias=0, + temperature_scale_factor=0, + name="Barometer", + ): + """ + Initialize the barometer sensor + + Parameters + ---------- + sampling_rate : float + Sample rate of the sensor in Hz. + measurement_range : float, tuple, optional + The measurement range of the sensor in the Pa. 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 Pa/LSB. Default is 0, meaning no + quantization is applied. + noise_density : float, optional + The noise density of the sensor for a Gaussian white noise in Pa/√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. + noise_variance : float, optional + The noise variance of the sensor for a Gaussian white noise in Pa^2. + Default is 1, meaning the noise is normally distributed with a + standard deviation of 1 Pa. 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, optional + The random walk of the sensor for a Gaussian random walk in Pa/√Hz. + Sometimes called "bias (in)stability" or "bias drift"". Default is 0, + meaning no random walk is applied. + random_walk_variance : float, optional + The random walk variance of the sensor for a Gaussian random walk in + Pa^2. Default is 1, meaning the noise is normally distributed with a + standard deviation of 1 Pa. 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, optional + The constant bias of the sensor in Pa. 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 Pa/°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. + name : str, optional + The name of the sensor. Default is "Barometer". + + Returns + ------- + None + + See Also + -------- + TODO link to documentation on noise model + """ + super().__init__( + sampling_rate=sampling_rate, + measurement_range=measurement_range, + resolution=resolution, + noise_density=noise_density, + 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, + temperature_scale_factor=temperature_scale_factor, + name=name, + ) + self.type = "Barometer" + self.prints = _BarometerPrints(self) + + def measure(self, time, **kwargs): + """Measures the pressure at barometer location + + Parameters + ---------- + time : float + Current time in seconds. + kwargs : dict + Keyword arguments dictionary containing the following keys: + - u : np.array + State vector of the rocket. + - u_dot : np.array + Derivative of the state vector of the rocket. + - relative_position : np.array + Position of the sensor relative to the rocket center of mass. + - gravity : float + Gravitational acceleration in m/s^2. + - pressure : Function + Atmospheric pressure profile as a function of altitude in Pa. + - elevation : float + Elevation of the launch site in meters. + """ + u = kwargs["u"] + relative_position = kwargs["relative_position"] + pressure = kwargs["pressure"] + + # Calculate the altitude of the sensor + relative_altitude = (Matrix.transformation(u[6:10]) @ relative_position).z + + # Calculate the pressure at the sensor location and add noise + P = pressure(relative_altitude + u[2]) + P = self.apply_noise(P) + P = self.apply_temperature_drift(P) + P = self.quantize(P) + + self.measurement = P + self.measured_data.append((time, P)) + + def export_measured_data(self): + pass From 99959048785016415e0b2c3081ca333d6c8a1e6c Mon Sep 17 00:00:00 2001 From: MateusStano Date: Sat, 4 May 2024 00:02:35 +0200 Subject: [PATCH 04/31] BUG: fix drawing for scalar sensors --- rocketpy/plots/rocket_plots.py | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/rocketpy/plots/rocket_plots.py b/rocketpy/plots/rocket_plots.py index 0d7b5b130..e57fe87e4 100644 --- a/rocketpy/plots/rocket_plots.py +++ b/rocketpy/plots/rocket_plots.py @@ -218,7 +218,7 @@ def draw(self, vis_args=None, plane="xz"): 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) + self._draw_sensors(ax, self.rocket.sensors, plane, vis_args) plt.title("Rocket Representation") plt.xlim() @@ -555,7 +555,7 @@ def _draw_center_of_mass_and_pressure(self, ax): cp, 0, label="Static Center of Pressure", color="red", s=10, zorder=10 ) - def _draw_sensor(self, ax, sensors, plane, vis_args): + def _draw_sensors(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.""" @@ -591,19 +591,20 @@ def _draw_sensor(self, ax, sensors, plane, vis_args): 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, - ) + if abs(sensor.normal_vector) != 0: + 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 From 354e681eaee2841fdbf2af25afffb7785e17004a Mon Sep 17 00:00:00 2001 From: MateusStano Date: Sat, 4 May 2024 00:02:57 +0200 Subject: [PATCH 05/31] ENH: barometer prints --- rocketpy/prints/sensors_prints.py | 43 ++++++++++++++++++++++++------- 1 file changed, 34 insertions(+), 9 deletions(-) diff --git a/rocketpy/prints/sensors_prints.py b/rocketpy/prints/sensors_prints.py index 95e3458c0..731fc3fcc 100644 --- a/rocketpy/prints/sensors_prints.py +++ b/rocketpy/prints/sensors_prints.py @@ -4,7 +4,7 @@ "Gyroscope": "rad/s", "Accelerometer": "m/s^2", "Magnetometer": "T", - "PressureSensor": "Pa", + "Barometer": "Pa", "TemperatureSensor": "K", } @@ -44,10 +44,9 @@ 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 + self._general_noise() def _general_noise(self): """Prints the noise of the sensor.""" @@ -82,6 +81,28 @@ def _general_noise(self): "Cross Axis Sensitivity:", f"{self.sensor.cross_axis_sensitivity} %" ) + def all(self): + """Prints all information of the sensor.""" + self.identity() + self.quantization() + self.noise() + + +class _InertialSensorsPrints(_SensorsPrints): + def __init__(self, sensor): + super().__init__(sensor) + + 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 all(self): """Prints all information of the sensor.""" self.identity() @@ -90,19 +111,15 @@ def all(self): self.noise() -class _AccelerometerPrints(_SensorsPrints): +class _AccelerometerPrints(_InertialSensorsPrints): """Class that contains all accelerometer prints.""" 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 _GyroscopePrints(_InertialSensorsPrints): """Class that contains all gyroscope prints.""" def __init__(self, gyroscope): @@ -116,3 +133,11 @@ def noise(self): "Acceleration Sensitivity:", f"{self.sensor.acceleration_sensitivity} rad/s/g", ) + + +class _BarometerPrints(_SensorsPrints): + """Class that contains all barometer prints.""" + + def __init__(self, barometer): + """Initialize the class.""" + super().__init__(barometer) From 1f761c020e9aed1003c6082779bf2e58ba2a7b6e Mon Sep 17 00:00:00 2001 From: MateusStano Date: Sat, 4 May 2024 14:12:50 +0200 Subject: [PATCH 06/31] DOC: change docs for scalar sensors --- rocketpy/sensors/barometer.py | 10 ++---- rocketpy/sensors/sensors.py | 58 ++++++++--------------------------- 2 files changed, 15 insertions(+), 53 deletions(-) diff --git a/rocketpy/sensors/barometer.py b/rocketpy/sensors/barometer.py index 3a98154c4..c24d6b508 100644 --- a/rocketpy/sensors/barometer.py +++ b/rocketpy/sensors/barometer.py @@ -2,7 +2,7 @@ import numpy as np -from ..mathutils.vector_matrix import Matrix, Vector +from ..mathutils.vector_matrix import Matrix from ..prints.sensors_prints import _BarometerPrints from ..sensors.sensors import ScalarSensors @@ -88,9 +88,7 @@ def __init__( noise_variance : float, optional The noise variance of the sensor for a Gaussian white noise in Pa^2. Default is 1, meaning the noise is normally distributed with a - standard deviation of 1 Pa. 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. + standard deviation of 1 Pa. random_walk_density : float, optional The random walk of the sensor for a Gaussian random walk in Pa/√Hz. Sometimes called "bias (in)stability" or "bias drift"". Default is 0, @@ -98,9 +96,7 @@ def __init__( random_walk_variance : float, optional The random walk variance of the sensor for a Gaussian random walk in Pa^2. Default is 1, meaning the noise is normally distributed with a - standard deviation of 1 Pa. 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. + standard deviation of 1 Pa. constant_bias : float, optional The constant bias of the sensor in Pa. Default is 0, meaning no constant bias is applied. diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index 24dd01b8a..aecaf4e48 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -79,48 +79,31 @@ def __init__( 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 is applied. 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. + distributed with a standard deviation of 1 unit. 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_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. + distributed with a standard deviation of 1 unit. 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 - same constant bias is applied to all axes. The values of each axis - can be set individually by passing a list of length 3. + 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, list, optional The temperature bias of the sensor in sensor units/°C. Default is 0, - 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. + meaning no temperature bias is applied. 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. 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. + meaning no temperature scale factor is applied. name : str, optional The name of the sensor. Default is "Sensor". @@ -593,48 +576,31 @@ def __init__( 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 is applied. 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. + distributed with a standard deviation of 1 unit. 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_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. + distributed with a standard deviation of 1 unit. 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 - same constant bias is applied to all axes. The values of each axis - can be set individually by passing a list of length 3. + 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, list, optional The temperature bias of the sensor in sensor units/°C. Default is 0, - 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. + meaning no temperature bias is applied. 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. 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. + meaning no temperature scale factor is applied. name : str, optional The name of the sensor. Default is "Sensor". From 17feded08ee383ed8bc4c176a90b4ffdc9b0265b Mon Sep 17 00:00:00 2001 From: MateusStano Date: Sun, 5 May 2024 16:08:04 +0200 Subject: [PATCH 07/31] ENH: add barometer export data --- rocketpy/sensors/accelerometer.py | 3 +- rocketpy/sensors/barometer.py | 54 +++++++++++++++++++++++++++++-- rocketpy/sensors/gyroscope.py | 3 +- 3 files changed, 54 insertions(+), 6 deletions(-) diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 7e332eebf..bdd4f8bee 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -254,8 +254,7 @@ def measure(self, time, **kwargs): self._save_data((time, *A)) def export_measured_data(self, filename, format="csv"): - """ - Export the measured values to a file + """Export the measured values to a file Parameters ---------- diff --git a/rocketpy/sensors/barometer.py b/rocketpy/sensors/barometer.py index c24d6b508..7bbc8c02a 100644 --- a/rocketpy/sensors/barometer.py +++ b/rocketpy/sensors/barometer.py @@ -175,5 +175,55 @@ def measure(self, time, **kwargs): self.measurement = P self.measured_data.append((time, P)) - def export_measured_data(self): - pass + def export_measured_data(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": + # 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,pressure\n") + for t, pressure in data: + f.write(f"{t},{pressure}\n") + print(filename + f"_{i+1},", end=" ") + else: + with open(filename, "w") as f: + f.write("t,pressure\n") + for t, pressure in self.measured_data: + f.write(f"{t},{pressure}\n") + print(f"Data saved to {filename}") + elif format == "json": + if isinstance(self.measured_data[0], list): + print("Data saved to", end=" ") + for i, data in enumerate(self.measured_data): + dict = {"t": [], "pressure": []} + for t, pressure in data: + dict["t"].append(t) + dict["pressure"].append(pressure) + with open(filename + f"_{i+1}", "w") as f: + json.dump(dict, f) + print(filename + f"_{i+1},", end=" ") + else: + dict = {"t": [], "pressure": []} + for t, pressure in self.measured_data: + dict["t"].append(t) + dict["pressure"].append(pressure) + with open(filename, "w") as f: + json.dump(dict, f) + print(f"Data saved to {filename}") + else: + raise ValueError("Invalid format") diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index bdfb36a05..91f78b7eb 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -286,8 +286,7 @@ def apply_acceleration_sensitivity( return self.acceleration_sensitivity & A def export_measured_data(self, filename, format="csv"): - """ - Export the measured values to a file + """Export the measured values to a file Parameters ---------- From faf098ac3ca493fbf369862f3c2d73c4ca909a97 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Sun, 5 May 2024 16:08:25 +0200 Subject: [PATCH 08/31] BUG: fix scalars sensors prints --- rocketpy/prints/sensors_prints.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/rocketpy/prints/sensors_prints.py b/rocketpy/prints/sensors_prints.py index 731fc3fcc..fe636a53b 100644 --- a/rocketpy/prints/sensors_prints.py +++ b/rocketpy/prints/sensors_prints.py @@ -77,9 +77,6 @@ def _general_noise(self): 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} %" - ) def all(self): """Prints all information of the sensor.""" @@ -103,6 +100,12 @@ def orientation(self): value = [float(val) for val in value.split()] self._print_aligned("", value) + def _general_noise(self): + super()._general_noise() + self._print_aligned( + "Cross Axis Sensitivity:", f"{self.sensor.cross_axis_sensitivity} %" + ) + def all(self): """Prints all information of the sensor.""" self.identity() From 960b1c3d2d9b1bcfe567d74844abdc88c02dc033 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Sun, 5 May 2024 16:08:45 +0200 Subject: [PATCH 09/31] TST: add barometers to tests --- tests/fixtures/flight/flight_fixtures.py | 10 +- tests/fixtures/rockets/rocket_fixtures.py | 17 +- tests/fixtures/sensors/sensors_fixtures.py | 40 ++- tests/test_sensors.py | 69 ++--- tests/unit/test_sensors.py | 282 +++++++++++++++++---- 5 files changed, 324 insertions(+), 94 deletions(-) diff --git a/tests/fixtures/flight/flight_fixtures.py b/tests/fixtures/flight/flight_fixtures.py index 9976ddac2..0b47707b1 100644 --- a/tests/fixtures/flight/flight_fixtures.py +++ b/tests/fixtures/flight/flight_fixtures.py @@ -161,14 +161,14 @@ def flight_calisto_air_brakes(calisto_air_brakes_clamp_on, example_plain_env): @pytest.fixture -def flight_calisto_accel_gyro(calisto_accel_gyro, example_plain_env): +def flight_calisto_sensors(calisto_sensors, 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. + with a set of ideal sensors. The environment is the simplest possible, with + no parameters set. Parameters ---------- - calisto_accel_gyro : rocketpy.Rocket + calisto_sensors : rocketpy.Rocket An object of the Rocket class. example_plain_env : rocketpy.Environment An object of the Environment class. @@ -180,7 +180,7 @@ def flight_calisto_accel_gyro(calisto_accel_gyro, example_plain_env): condition. """ return Flight( - rocket=calisto_accel_gyro, + rocket=calisto_sensors, environment=example_plain_env, rail_length=5.2, inclination=85, diff --git a/tests/fixtures/rockets/rocket_fixtures.py b/tests/fixtures/rockets/rocket_fixtures.py index 0161f3950..9e971f124 100644 --- a/tests/fixtures/rockets/rocket_fixtures.py +++ b/tests/fixtures/rockets/rocket_fixtures.py @@ -244,27 +244,19 @@ def calisto_air_brakes_clamp_off(calisto_robust, controller_function): @pytest.fixture -def calisto_accel_gyro( +def calisto_sensors( calisto, calisto_nose_cone, calisto_tail, calisto_trapezoidal_fins, ideal_accelerometer, ideal_gyroscope, + ideal_barometer, ): """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. + a set of ideal sensors added at the center of dry mass, meaning the readings + will be the same as the values saved on a Flight object. Returns ------- @@ -278,6 +270,7 @@ def calisto_accel_gyro( calisto.add_sensor(ideal_accelerometer, -0.1180124376577797) calisto.add_sensor(ideal_accelerometer, -0.1180124376577797) calisto.add_sensor(ideal_gyroscope, -0.1180124376577797) + calisto.add_sensor(ideal_barometer, -0.1180124376577797) return calisto diff --git a/tests/fixtures/sensors/sensors_fixtures.py b/tests/fixtures/sensors/sensors_fixtures.py index c32a41124..08982c9d4 100644 --- a/tests/fixtures/sensors/sensors_fixtures.py +++ b/tests/fixtures/sensors/sensors_fixtures.py @@ -1,6 +1,8 @@ +import numpy as np import pytest from rocketpy import Accelerometer, Gyroscope +from rocketpy.sensors.barometer import Barometer @pytest.fixture @@ -47,6 +49,22 @@ def noisy_rotated_gyroscope(): ) +@pytest.fixture +def noisy_barometer(): + """Returns a barometer with all parameters set to non-default values, + i.e. with noise and temperature drift.""" + return Barometer( + sampling_rate=50, + noise_density=19, + noise_variance=19, + random_walk_density=0.01, + constant_bias=1000, + operating_temperature=25, + temperature_bias=0.02, + temperature_scale_factor=0.02, + ) + + @pytest.fixture def quantized_accelerometer(): """Returns an accelerometer with all parameters set to non-default values, @@ -69,15 +87,33 @@ def quantized_gyroscope(): ) +@pytest.fixture +def quantized_barometer(): + """Returns a barometer with all parameters set to non-default values, + i.e. with noise and temperature drift.""" + return Barometer( + sampling_rate=50, + measurement_range=7e4, + resolution=0.16, + ) + + @pytest.fixture def ideal_accelerometer(): return Accelerometer( - sampling_rate=100, + sampling_rate=10, ) @pytest.fixture def ideal_gyroscope(): return Gyroscope( - sampling_rate=100, + sampling_rate=10, + ) + + +@pytest.fixture +def ideal_barometer(): + return Barometer( + sampling_rate=10, ) diff --git a/tests/test_sensors.py b/tests/test_sensors.py index 92960732e..a06cb8926 100644 --- a/tests/test_sensors.py +++ b/tests/test_sensors.py @@ -8,15 +8,15 @@ from rocketpy.sensors.gyroscope import Gyroscope -def test_sensor_on_rocket(calisto_accel_gyro): +def test_sensor_on_rocket(calisto_sensors): """Test the sensor on the rocket. Parameters ---------- calisto_accel_gyro : Rocket - Pytest fixture for the calisto rocket with an accelerometer and a gyroscope. + Pytest fixture for the calisto rocket with a set of ideal sensors. """ - sensors = calisto_accel_gyro.sensors + sensors = calisto_sensors.sensors assert isinstance(sensors, Components) assert isinstance(sensors[0].component, Accelerometer) assert isinstance(sensors[1].position, Vector) @@ -24,80 +24,91 @@ def test_sensor_on_rocket(calisto_accel_gyro): assert isinstance(sensors[2].position, Vector) -def test_ideal_sensors(flight_calisto_accel_gyro): +def test_ideal_sensors(flight_calisto_sensors): """Test the ideal sensors. All types of sensors are here to reduvce testing time. Parameters ---------- - flight_calisto_accel_gyro : Flight - Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. + flight_calisto_sensors : Flight + Pytest fixture for the flight of the calisto rocket with a set of ideal + sensors. """ - accelerometer = flight_calisto_accel_gyro.rocket.sensors[0].component + accelerometer = flight_calisto_sensors.rocket.sensors[0].component time, ax, ay, az = zip(*accelerometer.measured_data[0]) 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) + sim_accel = flight_calisto_sensors.acceleration(time) # 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] + flight_calisto_sensors.sensors[0].measured_data[0] + == flight_calisto_sensors.sensors[0].measured_data[1] ) - gyroscope = flight_calisto_accel_gyro.rocket.sensors[2].component + gyroscope = flight_calisto_sensors.rocket.sensors[2].component time, wx, wy, wz = zip(*gyroscope.measured_data) 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)) + flight_wx = np.array(flight_calisto_sensors.w1(time)) + flight_wy = np.array(flight_calisto_sensors.w2(time)) + flight_wz = np.array(flight_calisto_sensors.w3(time)) sim_w = np.sqrt(flight_wx**2 + flight_wy**2 + flight_wz**2) assert np.allclose(w, sim_w, atol=1e-12) + barometer = flight_calisto_sensors.rocket.sensors[3].component + time, pressure = zip(*barometer.measured_data) + pressure = np.array(pressure) + sim_pressure = np.array(flight_calisto_sensors.pressure(time)) + assert np.allclose(pressure, sim_pressure, atol=1e-12) -def test_export_sensor_data(flight_calisto_accel_gyro): + +def test_export_sensor_data(flight_calisto_sensors): """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_sensors : Flight + Pytest fixture for the flight of the calisto rocket with a set of ideal + sensors. """ - flight_calisto_accel_gyro.export_sensor_data("test_sensor_data.json") + flight_calisto_sensors.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] = [ + flight_calisto_sensors.sensors[0].measured_data[0] = [ + list(measurement) + for measurement in flight_calisto_sensors.sensors[0].measured_data[0] + ] + flight_calisto_sensors.sensors[1].measured_data[1] = [ list(measurement) - for measurement in flight_calisto_accel_gyro.sensors[0].measured_data[0] + for measurement in flight_calisto_sensors.sensors[1].measured_data[1] ] - flight_calisto_accel_gyro.sensors[1].measured_data[1] = [ + flight_calisto_sensors.sensors[2].measured_data = [ list(measurement) - for measurement in flight_calisto_accel_gyro.sensors[1].measured_data[1] + for measurement in flight_calisto_sensors.sensors[2].measured_data ] - flight_calisto_accel_gyro.sensors[2].measured_data = [ + flight_calisto_sensors.sensors[3].measured_data = [ list(measurement) - for measurement in flight_calisto_accel_gyro.sensors[2].measured_data + for measurement in flight_calisto_sensors.sensors[3].measured_data ] assert ( sensor_data["Accelerometer"]["1"] - == flight_calisto_accel_gyro.sensors[0].measured_data[0] + == flight_calisto_sensors.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 + == flight_calisto_sensors.sensors[1].measured_data[1] ) + assert sensor_data["Gyroscope"] == flight_calisto_sensors.sensors[2].measured_data + assert sensor_data["Barometer"] == flight_calisto_sensors.sensors[3].measured_data os.remove(filename) diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensors.py index ebb0c5b60..b122243f1 100644 --- a/tests/unit/test_sensors.py +++ b/tests/unit/test_sensors.py @@ -59,6 +59,15 @@ def test_gyroscope_prints(noisy_rotated_gyroscope, quantized_gyroscope): assert True +def test_barometer_prints(noisy_barometer, quantized_barometer): + """Test the print methods of the Barometer class. Checks if all + attributes are printed correctly. + """ + noisy_barometer.prints.all() + quantized_barometer.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. @@ -92,7 +101,9 @@ def test_ideal_accelerometer_measure(ideal_accelerometer): + 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, u_dot=UDOT, relative_position=relative_position, gravity=gravity + ) # check last measurement assert len(ideal_accelerometer.measurement) == 3 @@ -101,7 +112,9 @@ 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, u_dot=UDOT, relative_position=relative_position, gravity=gravity + ) assert len(ideal_accelerometer.measured_data) == 2 assert all(isinstance(i, tuple) for i in ideal_accelerometer.measured_data) @@ -122,7 +135,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, u_dot=UDOT, relative_position=relative_position) # check last measurement assert len(ideal_gyroscope.measurement) == 3 @@ -131,7 +144,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, u_dot=UDOT, relative_position=relative_position) assert len(ideal_gyroscope.measured_data) == 2 assert all(isinstance(i, tuple) for i in ideal_gyroscope.measured_data) @@ -139,6 +152,45 @@ def test_ideal_gyroscope_measure(ideal_gyroscope): assert ideal_gyroscope.measured_data[0][1:] == approx([ax, ay, az], abs=1e-10) +def test_ideal_barometer_measure(ideal_barometer, example_plain_env): + """Test the measure method of the Barometer class. Checks if saved + measurement is (P) and if measured_data is [(t, P), ...] + """ + 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]) + P = example_plain_env.pressure((rot @ relative_position).z + u[2]) + + ideal_barometer.measure( + t, + u=u, + relative_position=relative_position, + pressure=example_plain_env.pressure, + ) + + # check last measurement + assert isinstance(ideal_barometer.measurement, (int, float)) + assert ideal_barometer.measurement == approx(P, abs=1e-10) + + # check measured values + assert len(ideal_barometer.measured_data) == 1 + ideal_barometer.measure( + t, + u=u, + relative_position=relative_position, + pressure=example_plain_env.pressure, + ) + assert len(ideal_barometer.measured_data) == 2 + + assert all(isinstance(i, tuple) for i in ideal_barometer.measured_data) + assert ideal_barometer.measured_data[0][0] == t + assert ideal_barometer.measured_data[0][1] == approx(P, 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_data is [(t, (ax,ay,az)), ...] @@ -177,7 +229,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, u_dot=UDOT, relative_position=relative_position, gravity=gravity + ) assert noisy_rotated_accelerometer.measurement == approx([ax, ay, az], rel=0.5) @@ -210,10 +264,37 @@ 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, u_dot=UDOT, relative_position=relative_position, gravity=gravity + ) assert noisy_rotated_gyroscope.measurement == approx([wx, wy, wz], rel=0.5) +def test_noisy_barometer_measure(noisy_barometer, example_plain_env): + """Test the measure method of the Barometer class. Checks if saved + measurement is (P) and if measured_data is [(t, P), ...] + """ + 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]) + P = example_plain_env.pressure((rot @ relative_position).z + u[2]) + # expected measurement with constant bias + P += 1000 + + # check last measurement considering noise error bounds + noisy_barometer.measure( + t, + u=u, + relative_position=relative_position, + pressure=example_plain_env.pressure, + ) + assert noisy_barometer.measurement == approx(P, rel=0.5) + + 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)), ...] @@ -243,7 +324,9 @@ 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, u_dot=UDOT, relative_position=relative_position, gravity=gravity + ) assert quantized_accelerometer.measurement == approx([ax, ay, az], abs=1e-10) @@ -268,25 +351,48 @@ 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, u_dot=UDOT, relative_position=relative_position, gravity=gravity + ) assert quantized_gyroscope.measurement == approx([wx, wy, wz], abs=1e-10) +def test_quantization_barometer(quantized_barometer, example_plain_env): + """Test the measure method of the Barometer class. Checks if saved + measurement is (P) and if measured_data is [(t, P), ...] + """ + t = SOLUTION[0] + u = SOLUTION[1:] + # calculate acceleration at sensor position in inertial frame + relative_position = Vector([0.4, 0.4, 1]) + # expected measurement without noise + P = example_plain_env.pressure( + (Matrix.transformation(u[6:10]) @ relative_position).z + u[2] + ) + # expected measurement with quantization + P = 7e4 # saturated + P = round(P / 0.16) * 0.16 + + # check last measurement considering noise error bounds + quantized_barometer.measure( + t, u=u, relative_position=relative_position, pressure=example_plain_env.pressure + ) + assert quantized_barometer.measurement == approx(P, 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. - """ + exported correctly.""" 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) + ideal_accelerometer.measure( + t, u=u, u_dot=UDOT, relative_position=relative_position, gravity=gravity + ) + ideal_accelerometer.measure( + t, u=u, u_dot=UDOT, relative_position=relative_position, gravity=gravity + ) file_name = "sensors.csv" @@ -322,20 +428,17 @@ def test_export_accel_data_csv(ideal_accelerometer): 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. - """ + exported correctly.""" 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) + ideal_accelerometer.measure( + t, u=u, u_dot=UDOT, relative_position=relative_position, gravity=gravity + ) + ideal_accelerometer.measure( + t, u=u, u_dot=UDOT, relative_position=relative_position, gravity=gravity + ) file_name = "sensors.json" @@ -371,19 +474,12 @@ def test_export_accel_data_json(ideal_accelerometer): 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. - """ + exported correctly.""" 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) + ideal_gyroscope.measure(t, u=u, u_dot=UDOT, relative_position=relative_position) + ideal_gyroscope.measure(t, u=u, u_dot=UDOT, relative_position=relative_position) file_name = "sensors.csv" @@ -419,18 +515,12 @@ def test_export_gyro_data_csv(ideal_gyroscope): 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. - """ + exported correctly.""" 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) + ideal_gyroscope.measure(t, u=u, u_dot=UDOT, relative_position=relative_position) + ideal_gyroscope.measure(t, u=u, u_dot=UDOT, relative_position=relative_position) file_name = "sensors.json" @@ -462,3 +552,103 @@ def test_export_gyro_data_json(ideal_gyroscope): os.remove(file_name) os.remove(file_name + "_1") os.remove(file_name + "_2") + + +def test_export_barometer_data_csv(ideal_barometer, example_plain_env): + """Test the export_data method of the barometer. Checks if the data is + exported correctly.""" + t = SOLUTION[0] + u = SOLUTION[1:] + relative_position = Vector([0, 0, 0]) + ideal_barometer.measure( + t, + u=u, + relative_position=relative_position, + pressure=example_plain_env.pressure, + ) + ideal_barometer.measure( + t, + u=u, + relative_position=relative_position, + pressure=example_plain_env.pressure, + ) + + file_name = "sensors.csv" + + ideal_barometer.export_measured_data(file_name, format="csv") + + with open(file_name, "r") as file: + contents = file.read() + + expected_data = "t,pressure\n" + for t, pressure in ideal_barometer.measured_data: + expected_data += f"{t},{pressure}\n" + + assert contents == expected_data + + # check exports for gyroscopes added more than once to the rocket + ideal_barometer.measured_data = [ + ideal_barometer.measured_data[:], + ideal_barometer.measured_data[:], + ] + ideal_barometer.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_barometer_data_json(ideal_barometer, example_plain_env): + """Test the export_data method of the barometer. Checks if the data is + exported correctly.""" + t = SOLUTION[0] + u = SOLUTION[1:] + relative_position = Vector([0, 0, 0]) + ideal_barometer.measure( + t, + u=u, + relative_position=relative_position, + pressure=example_plain_env.pressure, + ) + ideal_barometer.measure( + t, + u=u, + relative_position=relative_position, + pressure=example_plain_env.pressure, + ) + + file_name = "sensors.json" + + ideal_barometer.export_measured_data(file_name, format="json") + + contents = json.load(open(file_name, "r")) + + expected_data = {"t": [], "pressure": []} + for t, pressure in ideal_barometer.measured_data: + expected_data["t"].append(t) + expected_data["pressure"].append(pressure) + + assert contents == expected_data + + # check exports for gyroscopes added more than once to the rocket + ideal_barometer.measured_data = [ + ideal_barometer.measured_data[:], + ideal_barometer.measured_data[:], + ] + ideal_barometer.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 f535e0fd57fb6156dbec0a0e62f87bebca605545 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Sun, 5 May 2024 16:12:04 +0200 Subject: [PATCH 10/31] DEV: update sensors testing --- docs/notebooks/sensors_testing.ipynb | 192 +++++++++++++++++++++------ 1 file changed, 150 insertions(+), 42 deletions(-) diff --git a/docs/notebooks/sensors_testing.ipynb b/docs/notebooks/sensors_testing.ipynb index 797dcb232..2d4cd6081 100644 --- a/docs/notebooks/sensors_testing.ipynb +++ b/docs/notebooks/sensors_testing.ipynb @@ -198,14 +198,14 @@ "metadata": {}, "outputs": [], "source": [ - "from rocketpy import Accelerometer, Gyroscope\n", + "from rocketpy import Accelerometer, Gyroscope, Barometer\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", + " random_walk_density=0.02,\n", " constant_bias=1 ,\n", " operating_temperature=25,\n", " temperature_bias=0.02,\n", @@ -256,7 +256,9 @@ "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", + "Noise Variance: (1, 1, 1) (m/s^2)^2\n", + "Random Walk Density: (0.02, 0.02, 0.02) m/s^2/√Hz\n", + "Random Walk Variance: (1, 1, 1) (m/s^2)^2\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", @@ -284,7 +286,9 @@ "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", + "Noise Variance: (1, 1, 1) (m/s^2)^2\n", + "Random Walk Density: (0, 0, 0) m/s^2/√Hz\n", + "Random Walk Variance: (1, 1, 1) (m/s^2)^2\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", @@ -302,34 +306,78 @@ "cell_type": "code", "execution_count": 8, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.001064225153655079" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "np.radians(0.06097560975609756097560975609756)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "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", + "gyro_noisy = Gyroscope(\n", + " sampling_rate=100,\n", + " resolution=0.001064225153655079,\n", + " orientation=(-60, -60, -60),\n", + " noise_density=[0, 0.03, 0.05],\n", + " noise_variance=1.01,\n", + " random_walk_density=[0, 0.01, 0.02],\n", + " random_walk_variance=[1, 1, 1.05],\n", + " constant_bias=[0, 0.3, 0.5],\n", + " operating_temperature=25,\n", + " temperature_bias=[0, 0.01, 0.02],\n", + " temperature_scale_factor=[0, 0.01, 0.02],\n", + " cross_axis_sensitivity=0.5,\n", + " acceleration_sensitivity=[0, 0.0008, 0.0017],\n", + " name=\"Gyroscope\",\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": 10, + "metadata": {}, + "outputs": [], + "source": [ + "barometer_clean = Barometer(sampling_rate=50,\n", + " measurement_range=100000,\n", + " resolution=0.16,\n", + " noise_density=19,\n", + " noise_variance=19,\n", + " random_walk_density=0.01,\n", + " constant_bias=1,\n", + " operating_temperature=25,\n", + " temperature_bias=0.02,\n", + " temperature_scale_factor=0.02,\n", + " )\n", + "calisto.add_sensor(barometer_clean, -0.10482544178314143+0.5, -127/2000)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxUAAAEGCAYAAAATwLgWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACgSUlEQVR4nOzddVxV9//A8RfdIQ3SAhYIYmN+xdjsQJ0xa8bMGZubrRjYzo5Nnc7adDp1duKc3YWiAoIzKAHp/P3BjzOvhPcSIvJ5Ph485J74nPd5c8HzuZ9Sio6OzkIQBEEQBEEQBKGQlEs7AEEQBEEQBEEQyjZRqRAEQRAEQRAEoUhEpUIQBEEQBEEQhCIRlQpBEARBEARBEIpEVCoEQRAEQRAEQSgSUakQBEEQBEEQBKFIRKVCEARBEARBEIQiEZUKQRAEQRAEQRCKRFQqBEEQBEEQBEEoElGpEISP3Pbt2zEyMuLGjRulHYrwEQgNDcXIyIjt27eXdiiCIAiCIBGVCkGQU87Dfc6Xqakp1atXZ8SIETx//ry0w5PbkiVLOHjwoFzH5jzA5nwZGxvj6OhIt27duHz5cglHWnY9ePCAefPmERoaWugydu/ezZo1a4oxKkEQBEEoOaqlHYAglDUTJ07Ezs6O5ORkrl69yo4dO7h48SL//PMPmpqapR3eey1dupQOHTrQtm1buc/p2rUrLVu2JCMjgydPnrBhwwY6duzIyZMnqVatWglGWzY9fPiQBQsW0KhRI2xtbQtVxu7duwkICGDYsGEy221sbHj+/DlqamrFEaogCIIgFAtRqRAEBbVo0YKaNWsC0LdvX4yNjVm2bBmHDx+mc+fOpRxdyahRowbdu3eXXtevX5/u3buzceNGFi1a9EFjSUhIQEdH54Ne82OipKRUJiqvgiAIQvkiuj8JQhE1aNAAgJCQEJntZ8+epU2bNlhbW2Nvb0/v3r15+PBhrvOfP3/OqFGjqFatGhYWFnh4eDB+/HhSU1PzvWZMTAwtWrSgevXqPHr0CICUlBT8/PyoVasWFhYWuLq6Mn36dFJSUqTzjIyMSEhIYMeOHVKXphEjRhT6noODg2W2x8bGMnHiRFxdXbGwsKBWrVosW7aMzMxM6ZicLlUrVqxg9erV1KhRAysrK9q1a8f9+/dlyhsxYgQ2NjYEBwfTvXt3bG1tGTp0KACZmZmsWbOGBg0aYGlpSeXKlRk7diwxMTEyZdy4cYOuXbvi5OSElZUVHh4ejBw5UuYYectyd3fniy++4OLFi7Ro0QJLS0tq1qzJzp07pWO2b9/OgAEDAOjQoYOU53PnzgFw6NAhevToIf28PT09WbhwIRkZGVIZ7du359ixY4SFhUnnu7u7y+Tv3TEV8rzf5s2bh5GREUFBQYwYMQJ7e3vs7OwYMWIEiYmJCIIgCEJhiZYKQSiinH7zhoaG0rYzZ87QvXt37O3tmTBhAsnJyfz00098/vnnnDlzRuoS8+LFC1q2bElsbCx9+/bFxcWF58+fs3//fpKSklBXV891vaioKLp06cLr16/566+/cHBwIDMzk169enHp0iWpnICAANasWcOTJ0/YunUrAGvXruWbb77B09OTfv36AWBvb18s95yYmEi7du148eIF/fv3x9ramsuXL+Pr68vLly/x8/OTKeO3334jPj6eQYMGkZyczLp16+jUqRPnzp3DzMxMOi49PR0fHx/q16+Pr68vWlpaAIwdO5YdO3bQq1cvhg4dytOnT/n555+5c+cOhw8fRk1NjYiICLp27YqJiQnffPMNBgYGhIWFceDAAZlY5CkrR3BwMP3796dPnz588cUXbNu2jREjRuDu7k7VqlXx8vJiyJAhrF+/nnHjxuHi4gIg/btjxw50dHQYNmwYurq6nD17Fj8/P968eYOvry8A48aNIy4ujufPnzNnzhyAAltn5H2/5Rg4cCC2trZMmzaNW7du8euvv2JqasqMGTPe+7MXBEEQhLyISoUgKCguLo6oqCiSk5O5du0aCxYsQENDg1atWknHTJ8+nQoVKnD06FEqVKgAQNu2bWnatCnz5s1j9erVAMyaNYtXr15x/PhxqUsVwKRJk8jKysp17VevXtG5c2eSk5M5ePAgNjY2QHb/e39/f/766y/q168vHV+1alXGjRvHpUuXqFevHt27d2f8+PHY29vLdGd6n6SkJKKiosjIyCAoKIgpU6YA2Z/E51i9ejUhISGcOXOGSpUqAdC/f38sLCxYsWIFI0aMwNraWjo+ODiYK1euYGVlBYC3tzctW7Zk2bJl0oM0ZLfAdOzYkWnTpknbLl68yK+//sr69evx8fGRtjdq1Ihu3bqxb98+fHx8uHz5MjExMfzxxx8y+Z08ebLCZeV49OgRBw8elFprOnXqhJubG9u3b2fWrFnY29vToEED1q9fT7NmzWjUqJFMLtevXy9VjAAGDBjAuHHj2LhxI5MnT0ZDQ4P//e9/rFu3jpiYGLl+TvK+33K4ubmxYsUK6fXr16/ZunWrqFQIgiAIhSa6PwmCgjp37oyzszNubm70798fbW1ttm3bRsWKFQF4+fIld+7coWfPntIDHkD16tVp1qwZx48fB7K73Bw8eJDPPvtM5oE3h5KSkszr58+f0759e9LT0/nrr7+kCgXAvn37cHFxwdnZmaioKOmrcePGAFLXm8KaN28ezs7OVKlShTZt2hAYGMisWbPo2LGjTAz169fH0NBQJoamTZuSkZHBhQsXZMps06aNVKEAqFWrFrVq1eLEiRO5rj9w4ECZ13/++Sf6+vo0a9ZM5loeHh7o6ury999/A2BgYADA0aNHSUtLy/Pe5C0rR+XKlaUKBYCJiQlOTk48ffpUnlTKVCjevHlDVFQUDRo0IDExUerKpgh5329vy+melaN+/fpER0cTFxen8PUFQRAEAURLhSAobOHChVSqVIm4uDi2bdvGhQsX0NDQkPaHhYUB4OTklOtcFxcXTp06RUJCAgkJCbx584aqVavKdd1hw4ahoqLCxYsXMTc3l9n35MkTAgMDcXZ2zvPciIgIeW8vT/369aNjx46kpKRw9uxZ1q9fLzMGACAoKIh79+7JHYOjo2OuY5ycnPjzzz9ltqmqqspUPnKuFRcXJ3UpeldkZCQADRs2pH379ixYsIA1a9bQqFEj2rRpg4+Pj/Qzk7esHG+3tuQwNDTMNf4iPwEBAcydO5ezZ8/y5s0bmX2FeaiX9/32dvepd+8hpxtbbGws+vr6CscgCIIgCKJSIQgK8vT0lFoW2rZty+eff86QIUO4dOkSurq6JXbddu3asXPnTtatWyfTFQggKyuLatWqMXv27DzPzWlFKSxHR0eaNWsGQOvWrVFRUcHX15fGjRtLucjMzKRZs2aMHj06zzLyeuiVh4aGBsrKso2qmZmZmJqasm7dujzPMTExAbJbezZv3syVK1c4evQop06dYtSoUaxatYpjx46hq6srd1k5VFRU8jwur+5q74qNjaV9+/bo6ekxceJEHBwc0NDQ4Pbt28yYMUNmQHtJKso9CIIgCEJeRKVCEIpARUWFadOm0aFDB37++WfGjBkjdUt6/PhxruMfPXqEsbExOjo6aGlpoaenR0BAgFzXGjx4MA4ODvj5+aGvr8+YMWOkffb29ty9e5emTZvm6jb1rvftl8f48ePZsmULc+bMYffu3VIMCQkJUuXjfYKCgnJte/z4sVzrOjg4OODv70+9evVkuhPlp06dOtSpU4cpU6awe/duhgwZwp49e+jbt6/CZckjvxyfO3eO6OhotmzZgpeXl7Q9r65T8v6c5H2/CYIgCEJJEmMqBKGIGjVqhKenJ2vXriU5ORkLCwvc3NzYuXMnsbGx0nH379/n9OnTtGzZEgBlZWXatm3LkSNHuHHjRq5y8/rU+LvvvmPkyJH4+vqyceNGaXunTp148eIFmzdvznVOUlISCQkJ0mttbW2ZuArDwMCA/v37c+rUKe7cuSPFcOXKFU6ePJnr+NjYWNLT02W2HTp0SGYl8mvXrnHt2jW8vb3fe/1OnTqRkZGR5xoZ6enp0v3FxMTkyqOrqyuANGWvvGUpQltbGyDXuTktBG/HlJqaKvOzfLsMebpDyft+EwRBEISSJFoqBKEYjBo1igEDBrBjxw4GDBjAzJkz6d69O61ataJPnz7SFJ/6+vp8//330nlTpkzh9OnTtG/fXpoK9tWrV+zbt4/Dhw9LA43f5uvrS1xcHN999x26urp0796dHj168OeffzJ+/HjOnTtHvXr1yMjI4NGjR/z555/s3r1b6qbk7u6Ov78/q1atwsLCAjs7O2rXrq3wPQ8dOpS1a9fy448/smHDBkaNGsWRI0fo2bMnPXv2xMPDg4SEBAICAti/fz83b97E2NhYOt/BwYE2bdowcOBAUlJSWLt2LUZGRvl2n3pbw4YN6d+/P0uXLuXOnTv873//Q01NjSdPnrB//37mzp1Lx44d2bFjBxs3bqRt27bY29sTHx/Pr7/+ip6envSwLW9ZinBzc0NFRYVly5YRFxeHuro6TZo0oW7duhgaGjJ8+HCGDBmCkpISv//+e54VSHd3d/bu3cvkyZPx9PRER0eHzz77LM/ryft+EwRBEISSIioVglAM2rdvj4ODAytXrqRv3740a9aMXbt2MW/ePObNm4eqqioNGzZk+vTp2NnZSedZWVlx/Phx5s6dy+7du3nz5g2Wlpa0aNGiwK44S5YsISEhgZEjR6Krq0ubNm3YunUra9asYefOnRw8eBAtLS3s7e0ZOnSoNMUrwOzZsxk7dixz584lKSmJnj17FqpSYWlpSdeuXfn9998JDg7GwcGBAwcOsHTpUvbt28dvv/2Gnp4elSpV4vvvv881ALhHjx4oKyuzdu1aIiMj8fT0ZMGCBVhYWMh1/SVLluDu7s7mzZuZPXs2Kioq2Nra0q1bN+rVqwdkVxiuX7/Onj17iIiIQF9fH09PT9atWyfzc5CnLEWYm5uzePFifvzxR0aPHk1GRgb79++nUaNG7Nixg6lTpzJ37lwMDQ3p1q0bTZo0kZm2FuCrr77i7t27bN++nTVr1mBjY5NvpULe95sgCIIglBSl6OhoMTJPEIQPJjQ0FA8PD2bOnMmoUaNKOxxBEARBEIqBGFMhCIIgCIIgCEKRiEqFIAiCIAiCIAhFIioVgiAIgiAIgiAUiRhTIQiCIAiCIAhCkYiWCkEQBEEQBEEQikRMKVsMMjMzefHiBbq6usWyWrEgCIIglISsrCzi4+OxtLREWVl8rigIQvERlYpi8OLFC9zc3Eo7DEEQBEGQy507d6hYsWJphyEIwidEVCqKga6uLgBhYWG5Fvj61Fy9erVQC6WVZyJnihM5U5zImeLKY87i4uKwsbGR/t8SBEEoLqJSUQxyujzp6+t/8pUKU1PTT/4ei5vImeJEzhQncqa48pwz0VVXEITiJjpUCgqpUqVKaYdQ5oicKU7kTHEiZ4oTORMEQSg+olIhKOT69eulHUKZI3KmOJEzxYmcKU7kTBAEofiISoUgCIIgCIIgCEUixlQICrG2ti7tEMockTPFiZwpTuRMcSJnH15mZibp6emlHYYgCHJQVVVVaOppUakQFKKqKt4yihI5U5zImeJEzhQncvbhZGVlERMTQ2JiohgkLghlRFZWFtra2hgaGsr1eyv+ogoKCQkJwdzcvLTDKFNEzhQncqY4kTPFiZx9ODExMSQlJWFmZoaWlpaoWAjCRy4rK4ukpCQiIiIAqFChwnvPEZUKQRAEQRBKTGZmJomJiZiZmWFkZFTa4QiCICctLS0AwsPDMTAweG9XKDFQW1CIWDlccSJnihM5U5zImeJEzj6M9PR0lJSUpAcUQRDKjpyWRXnGQolKhaCQ0NDQ0g6hzBE5U5zImeJEzhQncvZhiS5PglD2KPJ7KyoVgkJiY2NLO4QyR+RMcSJnihM5U5zImSAIQvERlQpBIZqamqUdQpkjcqY4kTPFiZwpTuRMEASh+BSqUpGWlsazZ8949OgRr1+/Lu6YhI+Yq6traYdQ5oicKU7kTHEiZ4oTORNK28CBA+natWtph/HJSExMpHv37hgZGaGmpkZMTExph1SuyF2pePPmDRs3bqRdu3bY2dnh4eFB/fr1cXZ2pkaNGnzzzTdcv369JGMVPgJXr14t7RDKHJEzxYmcKU7kTHEiZ8L7vHz5krFjx1KlShV0dXWpWLEiTZo0Ye3atSQmJha5/KVLl7Jhw4ZiiDR/qampLFq0CE9PT/T19bGwsKBJkyb88ssvpKWlFdt1fH19qVWrVrGVVxhbtmzh3LlznD17lrCwMAwMDHIds3nzZtTU1PKcqGH37t2oqanh5OT0IcL95Mg1peyqVatYsmQJDg4OtG7dmrFjx2JpaYmmpiavX78mICCACxcu0LVrV2rVqsX8+fOpVKlSSccuCIIgCIJQIoKCgmjatCmGhobMmjULV1dXNDQ0uHv3Lj///DMVK1akffv2eZ6blpaGmprae6+R10NvcUpNTaVNmzbcvn2bGTNm4OXlhb6+PpcuXWLJkiV4eHjg4eFRojEoKjU1FXV19UKdGxQURJUqVd7bCqmjo0N4eDgXLlygQYMG0vZNmzZha2tbqGsLcrZU3Lhxg7/++osTJ07w3Xff4e3tTbVq1XB0dKRWrVr06dOHVatW8eDBA9q2bcuFCxdKLOCff/4Zd3d3LC0tadGiBdeuXcv32M2bN9OmTRscHBxwcHCgc+fOuY4fMWIERkZGMl8+Pj4lFn9ZZ2lpWdohlDkiZ4oTOVOcyJniRM7KnoyUFOKfPSMjJaXErzVq1ChUVVW5ePEi3bp1o2rVqjg6OtKhQwf2799Pu3btpGPV1NRYu3YtnTt3xsDAAD8/PzIyMhg8eDDOzs7o6elRvXp1li9fLnONd7s/eXt7M2bMGH744QfMzMywtrbG19dX2p+VlYWvry+Ojo7o6Ohga2vLmDFj8r2H5cuX8/fff3P06FGGDx+Oh4cHjo6O9OzZk/Pnz+Ps7AxkryUyf/58KVZPT0/++OMPqRx/f3/U1NQ4deoU9erVQ19fn8aNG/Pw4UMg+3lr1qxZ3L59GzU1NdTU1Ni8eTOQvfDhkCFDsLS0xMjIiJYtW3Lr1i2p7JwWjg0bNuDs7Iyurm6+97Nnzx7c3d3R0dHBycmJpUuXyuRu6dKl/P3336ipqeHt7Z1vOaqqqnzxxRf88ssv0rZnz57h7+/PF198IXPskydP6NKlCxUrVsTQ0JD69etz8uRJmWPWrFlD1apVpdasHj16SPv++OMPPDw80NPTw9zcnNatW5OQkJBvbGWZXC0VP//8s1yFaWhoMGDAgCIFVJA9e/YwZcoUFi9eTK1atVi7di0+Pj5cvnwZU1PTXMf/888/dO3albp166KhocGyZcvo2rUr58+fx8rKSjrO29ublStXytyHkDdtbe3SDqHMETlTnMiZ4kTOFCdyVra8unSJf8aOJT0hAVUdHRouXYp5vXolcq2oqCiOHz/O7Nmz0dHRyfOYd6fanDVrFnPmzGHx4sWoqqqSmZmJtbU1O3bswNjYmAsXLjBs2DAsLS3p1q1bvtf+9ddfGTNmDP/88w8XL17kq6++wsvLixYtWrBnzx6WLVvGtm3bqFatGi9fvuT27dv5lrV9+3a8vb2pWbNmrn05D/8A8+fPZ/v27axatQonJyf+/vtv+vXrh6mpKU2aNJHOmTp1KgsXLsTExIQRI0YwePBgzp49S/fu3bl37x7Hjh3jyJEjwH+tMF988QVaWlocOHAAAwMDfvrpJ1q3bs39+/elxRCfPHnC3r17+f3331FRUcnzXq5du0bPnj2ZNm0a3bp148KFC4waNQojIyP69evHrl27mDRpEvfu3WPXrl3vbe3o378/LVq0YOnSpWhra7NlyxZat26NmZmZzHHx8fF89tln+Pr6oqGhwdatW+nUqRP37t3D1taWq1evMnbsWH755RcaNGhAdHQ0586dA+DFixf06dMHPz8/OnXqxJs3bzh37hxZWVkFxlZWlakVtVevXk3fvn3p3bs3AEuWLOH48eNs27Ytz5r6+vXrZV4vX76cAwcOcPbsWZmaqIaGBubm5iUa+6fiyZMnmJiYlHYYZYrImeJEzhQncqY4kbOyIyMlJbtC8f/jGNITE/ln7Fg6nj6NSgl8EPj48WOysrJwcXGR2W5hYUFycjIAw4YNw8/PT9r3xRdf0L9/f5njp0+fLn3v4ODAxYsX2b17d4GVCjc3N6ZOnQqAs7Mzq1ev5tSpU7Ro0YLQ0FAsLCzw9vZGTU0NW1tb6tatW+B9NG3atMB7TUlJYd68eRw5ckTqCuTo6Mg///zDTz/9JFOpmDVrlvR6woQJdOjQgeTkZLS0tNDV1UVFRQULCwvp+HPnznHlyhWeP38ufWC7YMEC9u/fzx9//MHgwYOB7C5PmzZtyvMD4hw//vgjzZs3Z/LkyQC4uLgQEBDAkiVL6NevH0ZGRmhra6Ouri4TQ35q1qyJg4MDf/zxB3369GHLli0sXLiQoKAgmePc3d1xd3eXXs+cOZN9+/Zx4MABRowYQVhYGDo6OrRt2xY9PT3s7OykStyLFy9IT0+nc+fO2NnZAZ/2opsKVyqSk5NZv349586dIzIykszMTJn9Z86cKa7YZKSmpnLr1i3Gjh0rbVNWVqZp06ZcuXJFrjISExNJT0+nQoUKMtvPnTuHi4sLhoaGNG7cmMmTJ0u157ykpKSQ8lbT65s3bxS8G0EQBEEQ5JUUEUH6211GsrJIT0ggKSICXWvrDxbH+fPnyczMpG/fvjLPAUCeg5RXr17NL7/8QlhYGElJSaSmpso8oObl3YdOS0tLwsPDAfDx8WHFihW4uLjQqlUrPv/8c9q1a4eqat6Pc/J8Iv748WMSExP5/PPPZbanpqbmGm/xdmw5D+7h4eH5jkO4ffs28fHxuT64TUpKknl4t7OzK7BCAfDgwQM6dOggs83Ly4vly5eTkZGRbwtHQfr378/mzZuxtbUlISGBzz//nFWrVskcEx8fj6+vL4cPH5YqCUlJSYSFhQHQokULbG1tpZ9J69at6dSpE9ra2ri7u9O8eXNq1qxJq1ataNGiBV27ds31HPqpULhSMXr0aE6fPk2HDh3w9PT8YCtkRkVFkZGRketNZ2pqSmBgoFxlzJw5EwsLC5lae/PmzaUZrYKDg5k1axbdu3fn6NGj+b5Bly5dyoIFC3Jtv3r1Kjo6Onh6ehIQEEBSUhJ6eno4ODhIzZN2dnZkZmZKb0YPDw8eP35MfHw8Ojo6uLi4cOPGDQCsra1RUVHh6dOnANSoUYOQkBDi4uLQ1NSkevXq0hgRKysrNDU1pV9SV1dXnj17RkxMDOrq6nh4eHD58mUg+w+Brq4ujx8/BqBq1aq8evWK6OhoVFVVqVWrFpcvXyYrKwtTU1MqVKgg5djGxoagoCAiIiJQVlamTp06XL16lYyMDIyNjTEzMyMgIADI/oQlLi6OV69eAVCvXj2uX79OWloaFSpUwMrKinv37gFQqVIlEhMTefHiBQC1a9fm7t27JCcnY2BggK2tLXfu3AHA3t6e9PR0nj17BoCnpycPHjwgMTERXV1dKlWqJPXXzPlDl7Nyrru7O0+ePCE+Ph5tbW2qVKkizVpmbW2NqqoqISEhQPYfz9DQUGJjY9HU1MTV1VWaLcbS0hJtbW2ePHkCQPXq1Xn+/DmvX79GTU0NT09PLl26BIChoSHR0dE8evRIynd4eDhRUVGoqKhQu3Ztrly5QmZmJqamphgZGUn9VF1cXHj9+jUREREoKSlRt25drl27Rnp6OkZGRpibm0v5dnJyIj4+npcvXwJQt25dbt68SWpqKoaGhlhbW3P37l0g+1Oo5ORknj9/DmT/Z3jv3j2Sk5PR19fH3t5e5j2bkZEh5btmzZoEBgaSkJCArq4uTk5O3Lx5U3p/KCsry7xng4ODefPmDVpaWlStWlXKd8WKFVFXVyc4OFjKd1hYGDExMSgrK5OZmSl9YGBhYYGOjo6U75xm/+jo6Fz5NjMzw8DAQMp3lSpViIyMJDIyUnrP5uTbxMQEExMTHjx4IL1nY2Njpf/A337PGhkZYWFhwf3796X3bEJCgpTvOnXqcPv2bVJSUjA0NMTGxkZ6zzo4OJCamsq///4rvWeL+29Ezn90pf03onLlykRHR5eJvxHp6elSeaX5N8Lc3Bx9ff0P8jci537LGi1TU1R1dLJbKrKyQEkJVW1ttN7zIFpYTk5OKCkp5Xq+cHR0zI5HSyvXOe92k/rtt9/4/vvvWbBgAfXr10dPT4/FixdLv2f5eXeAt5KSkvQBro2NDffu3ePkyZOcOHGCUaNGsXjxYk6dOpXnwHBnZ2fpvZKf+Ph4APbv3y/TNRxydwd/+xo5z3/vfrj8toSEBCwtLTlx4kSufYaGhtL3pdUVsVevXkycOBFfX1969+6dZ+VswoQJnDx5UpqESEtLix49epCamgqAnp4eV65cwd/fn+PHjzNz5kxmzZrFhQsXMDQ05MiRI5w/f54TJ06watUqpk2bxj///IODg8OHvt0SpxQdHa1Qxy47Ozt+++036tevX1Ix5enFixdUr16dI0eOyDT1TZ8+nX/++SfPN+zbfvzxR6n7U/Xq1fM9LiQkBE9PT/bu3Ztvk2FeLRVubm7Exsair6+v4J2VLYGBgbmag4WCiZwpTuRMcSJniiuPOYuLi8PAwICQkJAP9v9VamoqkZGR2NnZFWnBwQ85pgKgTZs23L9/n3v37uWqMHh7e+Pu7s6SJUuA7Ift3bt307FjR+mYb775hoCAAI4dOyZta926NZGRkVJlf+DAgcTGxkqDot8tF6Br164YGBiwcePGXDE+fPgQV1dXLl26hKenZ679CxcuZMqUKVy8eDHXuIq0tDRSU1PJzMzE0tKStWvX0qdPnzxz4e/vT4sWLYiIiJAqAzdv3qROnTo8evQIe3t75s2bx86dO6UPmQBOnDhBu3btePDgAfb29nmW7evry759+wqceAfgyy+/JDIyksOHD0vbfvjhB44cOSJdc9y4cdy6dSvXQOq3bd68mfHjxxMZGQlkVyx27drFnTt3qFKlCsuWLWPFihXShyoeHh5069ZN6nYVHx+Pvb09ffv2lfk55UhISMDExITt27fTuXNnmX0ZGRlUqlSJb775RqbnzccsOTmZp0+fYmJi8t5xKgq3VFhaWqKnp1fo4ArL2NgYFRUVIiIiZLZHRES8dzzEihUr+PHHH9m7d2+BFQrI/oTL2NiY4ODgfCsVGhoa5XYwt1jsUHEiZ4oTOVOcyJniRM7KFvN69eh4+jRJERFomZqWyFiKt61YsYKmTZtSv359pk6dipubG8rKyly9epWHDx/m+RD/NicnJ7Zu3cqxY8ewt7dn27ZtXL16Nd+Ha3ls3ryZjIwM6tati7a2Ntu3b0dLS0vqr/+u0aNHc+jQIVq3bs2MGTNo2LAhenp6XLt2jYULF7J+/Xo8PDwYN24c3377LZmZmTRs2JDY2FjOnz+Pvr4+ffv2lSs2Ozs7QkJCuHnzJtbW1ujp6eHt7U39+vXp2rUr8+bNw9nZmefPn3P48GE6duxI7dq15b73sWPH0qBBA+bMmUO3bt24ePEiq1evZsWKFXKXkZcNGzawYsUKjI2N89zv7OzM3r17adu2LUpKSsyYMUOmdebgwYMEBQXRuHFjKlSowOHDh8nMzMTFxYVLly5x+vRpWrRogZmZGZcvXyYiIoKqVasWKeaPlcIras+aNYsZM2ZITfMfirq6Ou7u7pw9e1balpmZib+/P3Xq1Mn3vOXLl7No0SJ27dqV5+wH7/r333+Jjo4WA7fzIc+824IskTPFiZwpTuRMcSJnZY+Khga61tYlXqGA7C53V65coXnz5kyZMoVatWpRv359Vq1axbhx45g5c2aB5w8ZMoROnTrRq1cvGjZsSFRUFF9//XWRYjI0NGTDhg00bdoUT09PTp48yZ9//pnvA7GGhgZHjhzh22+/5aeffqJRo0Y0aNCAlStXMnLkSGk9h5kzZzJp0iQWLFiAm5sb7dq14/Dhwwp10enSpQutW7emZcuWWFpasnPnTpSUlDhw4ACNGzdm0KBBVKtWjT59+vD06VOFn7M8PT3ZsWMHv//+Ox4eHsycOZMZM2bQr18/hcp5l5aWVr75g+zWngoVKtCkSRM6d+5My5YtZZ4nDQwM+PPPP2nVqhVubm6sX7+erVu3Ur16dfT19fn777/p0KED1apVY/r06SxYsIDPPvusSDF/rBTu/hQZGcnAgQM5f/482traufqfvTtqvjjt2bOHESNGsGTJEjw9PVm7di1//vknly5dwszMTJqqbdq0aQAsW7YMPz8/1q9fT723mkh1dHTQ1dUlPj6eBQsW0L59e8zNzQkODmbGjBnEx8dz7tw5uVsj4uLisLe3LxfdnwRBEISyqyx3fxIE4cMr0e5PgwcP5sWLF0ydOhVTU9MPNlAbsmvBUVFR+Pn5ER4ejqurK7t27ZLmFH727BnKyv81vmzcuJHU1NRcU7xNmDCBH374ARUVFe7du8fOnTuJjY3FwsKC//3vf0yaNKncdm96n0uXLslU0IT3EzlTnMiZ4kTOFCdyJgiCUHwUrlRcvnyZo0ePvncJ9JIyePBgaV7jdx04cEDm9dsrNuZFS0tLZsVIQRAEQRAEQRAUp/CYCmdnZ5KSkkoiFqEMEGNNFCdypjiRM8WJnClO5EwQBKH4KFypmDZtGlOnTuXcuXNER0cTFxcn8yV82sSYEcWJnClO5ExxImeKEzkTBEEoPgpXKrp168aVK1fo1KkTLi4uODo64ujoiIODg7QojPDpylmcSZCfyJniRM4UJ3KmOJEzQRCE4qPwmIr9+/eXRBxCEcTGxuLv709WVsETeVlZWRU4/a4gCIIgCIIgFIbClYqGDRuWRBxCESxbtozp06fLdezx48dp0aJFoa/1qS7YUpJEzhQncqY4kTNZaSkZqGmoFHiMyJkgCELxkav707NnzxQq9Pnz54UKRiiclJQUbGxsiIiIKPDLy8uLCRMmyKwEqajw8PBijLx8EDlTnMiZ4kTO/vPsQTTPH8W89ziRM0EQhOIjV0uFt7c3bdq04csvv8x3Wfq4uDj27t3LunXr6NevH0OHDi3WQIWCqaioYGJiUuAxCxYsoFGjRuzcuZNevXoV6jpRUVE4OTkV6tzySuRMcSJnihM5yxYbkcSRn+7yxZT3rz8hcla6YmNDSUyM/GDX09Y2wcDA9oNdTxDKG7kqFRcuXGDx4sV06dIFTU1N3N3dsbCwQFNTk5iYGB4+fMiDBw+oUaMGM2fOpGXLliUdt1AIDRs2pFOnTkyaNImuXbsWaoE/FZWCuxMIuYmcKU7kTHEiZ5CanM6hNbdRVlZCx7DglV9B5Kw0xcaGsm6dK2lpH26KejU1LYYOvftRVSwGDhxIbGysWDNL+CTIVakwMjJizpw5TJkyhWPHjnHx4kWePXtGUlISxsbG+Pj40Lx5c6pVq1bS8QpF5Ofnh6urK6tWrWLcuHEKn1+7du0SiOrTJnKW7Wb4TaoYVUFTVfO9x4qcKa685ywrM4uTvwQQ/TwB2+pGKCkpvfecMp+z4LPg0KS0oyiUxMRI0tKS+Ox/vTCqYFbi14t+Hc6R09tJTIxUuFLx8uVL5s+fz+HDh3n27BkGBgZUqlSJXr160bdvX7S1tQsd19KlS987yYoglBUKDdTW0tKiY8eOdOzYsaTiEUpYlSpVGDx4MLNnz2bAgAFUqFBBofOvXLkiZpBSkMgZZGVlseTaEn5u9bNcx4ucKa685+zKoRCCbkYAYGqrJ985ZTlnaclwem6ZrVTkMKpghpmJdWmHka+goCCaNm2KoaEhs2bNwtXVFQ0NDe7evcvPP/9MxYoVad++fa7z0tLSUFNTe2/5BgYGJRG2IJQKhdepEMq+6dOnk5qayrx58xQ+tyiDvMsrkTM4FXaKG+E3UFaS70+OyJniynPOgm5EcOWvYOm1vJWKMp2zKz9BrGKTqAiKGzVqFKqqqly8eJFu3bpRtWpVHB0d6dChA/v376ddu3YAqKmpsXbtWjp37oyBgQF+fn5kZGQwePBgnJ2d0dPTo3r16ixfvlym/IEDB9K1a1fptbe3N2PGjOGHH37AzMwMa2trfH19pf1ZWVn4+vri6OiIjo4Otra2jBkz5oPkQhDeR1QqyiELCwu+/fZbli1bRmhoqELnmpqallBUn67ynrP0zHSWXV8GIHelorznrDDKa86i/o3n+C/3ZbaZ2shXqSizOUt6DWcXgRxdvITCi4qK4vjx4wwbNgwdHZ08j3m7m92sWbPo2LEjN27coH///mRmZmJtbc2OHTu4ffs2kydPZurUqezatavA6/7666/o6Ojwzz//4Ofnx+zZszlx4gQAe/bsYdmyZaxevZqAgAB2796Nq6tr8d20IBSBqFSUU+PHj8fAwIBp06YpdJ6RkVEJRfTpKu852/t4L8Gx2Z8iKyHfQ1B5z1lhlMecJcencWjNbdJTMqRtGtqq6Bm/f9wOlOGcnVsKyTEgZyVdKJzHjx+TlZWFi4uLzHYLCwsMDQ0xNDRk4sSJ0vYvvviC/v374+joiK2tLWpqakyfPp3atWvj4OBAr1696NevH7t37y7wum5ubkydOhVnZ2e+/PJLatWqxalTpwAIDQ3FwsICb29vbG1tqVu3LoMGDSr+mxeEQhB/kcopPT09ZsyYwZYtW7h165bc5z18+LAEo/o0leecJaYlsvrmaiC7QiHP4Fko3zkrrPKWs4yMTI78dJe4yGSZ7aa2ep/2+ywmDC6uzf5eVCpKxfnz57l69SrVqlUjJSVF2l6rVq1cx65evZq6detiaWmJoaEhP//883t7CLi5ucm8trS0lNZU8fHxISkpCRcXF4YOHcqff/5Jenp6MdyVIBSd+ItUjg0aNAhnZ2e+//770g5F+ERtub+FyKTseejl7fokCPJ4E5nMvw9f59oub9enMuv0XMj4/wdZ8TtVopycnFBSUiIwMFBmu6OjI05OTmhpaclsf7eL1G+//cb333/PgAEDOHToEFevXqVfv36kpqYWeN13B3grKSlJ439sbGy4d+8eK1asQEtLi1GjRvG///2PtLS0wt6mIBQbhf8i7dixg2PHjkmvp0+fjr29Pa1btyYsLKxYgxNKlpqaGn5+fhw9elTqr/k+7zYDC+9XXnMWlRTFprubpNfyfnoM5TdnRVHecmZorp3ngGx5B2lDGczZy7twa8d/r0WlokQZGxvTokULVq9eTUJCgsLnnz9/ngYNGjBs2DBq1qyJk5MTQUFBRY5LS0uLdu3a8eOPP3LixAkuXrzInTt3ilyuIBSVQlPKQvacyosWLQLg8uXLbNiwgdmzZ3Ps2DEmT57Mli1bij1IoeR07tyZBg0aMGHCBK5evYqycsH/Sb1+/VrhaWjLu/Kas3W315GYnii9VlbgM4zymrOiKI85U9eUXbxOx0Adcwd9uc8vczk7MQN4a02DT6BSEf06/KO+zooVK2jatCn169dn6tSpuLm5oayszNWrV3n48CGenp75nuvk5MTWrVs5duwY9vb2bNu2jatXr2Jvb1/Iu4DNmzeTkZFB3bp10dbWZvv27WhpaWFnZ1foMgWhuChcqfj3339xdHQE4NChQ7Rv357+/ftTr149OnToUOwBCiVLSUmJhQsX0qhRI3bs2EHv3r0LPD4iIkL6+QvyKY85C40LZddD2RlOFOn+VB5zVlTlLWevguP4NzAGAGUVJdoMr4FNVSOUleVvEStTOQs+C4+Py25TKrsrgmtrm6CmpsWR09s/2DXV1LTQ1jZR6JxKlSpx5coV5s2bx5QpU3j27BkaGhpUrVqVcePG8fXXX+d77pAhQ7h58ya9evVCSUmJHj168PXXX3PkyJFC34OhoSELFizgu+++IyMjA1dXV/7880+MjY0LXaYgFBeFKxU6OjpER0djbW3N6dOnGT58OACampokJye/52zhY9SwYUM6derE5MmT8fHxQUNDI99jFenCImQrjzlbfWs16VmygwcVyUN5zFlRlbecXT/2VPq+cj0L7Kor/lBVpnJ20jf3tjLcUmFgYMvQoXdJTIz8YNfU1jZReDVtyB4ovWzZMpYtW5bvMXmNadDQ0GDDhg1s2LBBZvucOXOk7zdu3Ciz7+TJk7nK+eOPP6TvxQLEwsdM4UpFs2bN+Oabb3Bzc+PJkye0bNkSgAcPHmBjY1PsAQofhp+fH66urqxatYpx48ble1zdunU/YFSfhvKYMzcTNw4GHZTZpkhLRXnMWVGVp5y9fpkgrZ6NEtRspfiDIpSxnFWsDc+uyG4rS5WiPBgY2BbqIV8QhI+TwpWKhQsXMmfOHP79919++eUXaZ7vmzdvyqwKKZScixcvsmnTJvr27YuWlhYvX74kJSWFxMREtLW1C1VmlSpVGDRoELNmzcLT0xN9/bz7JQcEBFC1atWihF/ulMecuWS5YKxmTFRaFJA9nqKxQWOuX78u1/nlMWdF9THk7OzZswQEBODu7o6xsTEaGhpoamqipaWFlpYWOjo60peuri6ampqFai24cSxUGlrg6G5KBYu8FyZ7n2vXruU5DehHqdkPcHUDZPz/zEGqWuDRq3RjEgRBeItSdHR01vsPEwoSFxeHvb09sbGx+T6MF1VgYCC7du1i165d+a4rce3atQIHjb3Py5cvcXR0JCkpqdBlCAKAkqoSVVdVRVkju3Xi8fTHJD8V3SMFWaqqqujp6aGvr4+BgQH6+vrSomKGhoZUqFCBChUqYGRkhJGREREXdclIgtTE//7b6vp9LSwcDAp1/UuXLlGvXr3iup2S9fopLKuR/b2GPgw7D4aK9w6Ii4vDwMCAkJCQEvv/6l2pqalERkZiZ2eHpqZ8CxMKgvBxSE5O5unTp5iYmKCurl7gsQq3VJw/f77A/V5eXooWKeTj3YqEjo4O7du3p3v37kyePJmtW7dStWpVMjMzycrKokqVKkW6noWFBQEBAURFReV7TGhoKLa2orlaEeUxZw8SHuAX5AeAlYYVm/dsVuj88pizovoYcnb//n2+/PJLTp48Se3atUlNTSUpKUn6SkhIICEhgfj4eBISEnjz5g1v3rwhNjaWuLg4YmNjiY2N5enTp9y8eZOYmBiio6NJTMyeRWxW751U0DWVrhcUfpdmnw/H1NQUU1NTzMzMpC9zc3PMzc2xsLDA3NwcfX39XK0iZWpF7eCz/31v17BQFQpBEISSpHClon379rm2vf2HOjLyww26+hTdvn2bdevW8ffff3Pnzh2pIjFt2jQ+//xztLS0uH79OpMnT6Zq1apSy0RoaCgPHjwo8fgsLS1L/BplkYmJSb4PdE5OTh/sE8GPxYWbF6Tvmzo0VbgFrTzmrKg+ppwZGhoWayypqalER0ezf0EAaW+1Upi7qtLWoS0RERGEh4dz+fJlIiIiePXqVa6Bs1paWlhYWGBlZYWlpSVWVlYYGRlRqVIlrKyssLa2xtrautBdSEvc25UKhyalF4cgCEI+FK5UBAcHy7xOS0vj9u3bzJ07lylTphRbYOXV5MmT+euvv2jQoAELFizAy8sLY2NjEhISuH//PkpKStLPICAgAA0NDZ49e0bHjp1ISSn57iWTJk1i7ty5JX6dskZTU5OHDx/mWbEICAgoO10sisnlF5el7+tZKH7v5TFnRfUp50xdXR0LCwvIfAhkAGBio8vwScPyHJORlZVFTEwMr1694uXLl7x69YoXL17w8uVLnj9/zvPnz7l//z5hYWG8efNG5twKFSpgbW2NjY0Ntra20pednR12dnZYWVmhovKBp3LNypKtVDg2/bDXFwRBkIPClYq8Pn363//+h7q6OlOmTOH06dPFElh51aFDB/766y+aNWtGq1at0NPLXh327X5sampqAOjp6aGlpUVKSgqmJpp0+mIgEeGvMbMwR9+g8J8SJiRlAqCjlXu2HidbRybPnlYsZRVnXIWhqpJFekbRZ0+JfR3Jnzu3ExkZWerdTz4GiWmJ3I64DYASStS2qF3KEQmfisz0TOl7z9Z2+Q7yVlJSksZjFNQt9NKlS7i5ufHvv//y77//8uzZM549e0ZYWBihoaGcP3+e3377jdevX0vnqKqqYmtri729PY6Ojjg4OFCpUiXpq0QW04sMhPiX2d9rm4CpmMRAEISPj8KVivyYmpry+PHj4iqu3Nq5cyeQPcXrvHnzcHV1pWnTpjRq1Ah3d/c8B8loqKdx5ewEtmy/zMrFf+JV35FDe4YXOobUtEyUlEBNNffDe8ybeDq3kL/CUlBZxRlXYWRmZr53BXH56DN5+ATC4/JuKXJyciqGa5Qd5z5rwIq4VGJ04Ndva2Cgofgg2vKWs+JQHnKmoaNGYmwqqmrKVPI0K3J5Tk5OaGtr4+zsjLOzc77HxcfH8/TpU54+fUpISAghISEEBwdz/fp1du/eTUxMjHSskZGRVJ6LiwsuLi5UqVIFFxcXtLS0Chfor53/+96hMRTL3y1BEITipXCl4t69ezKvs7KyePnyJcuWLcPV1bXYAsvPzz//zIoVKwgPD6d69erMnz+/wCkB//zzT/z8/AgNDcXR0ZEZM2ZIa2vkxO/n58evv/5KbGws9erVY9GiRVSqVKnE7+V9srKyuHPnDvfv32flypVoaGhQv3596eEhKyu7b7GaagZbtl/m+6l/AhAe8Yxtfywt1DWNKpjxefPsVbUPn9pG9Otwmf3aOg1ITLiQ16kKl1WccSnK3qYyDeu2KZaycmJTjs+9+BFkP5CUp9VOdeLSMPr/HiWF6foE5S9nxaE85CynZUJDR02hlbPzI2/OdHV1qV69OtWrV89z/+vXrwkKCuLx48c8fvyYR48e8ejRIw4fPixNfKGkpIS9vT3VqlXD1dWV6tWrU6NGDapWrfreGVVIfGvyjE9oPEVoaOgHHYdZ0Ng3QRCKTuFKRZMmTVBSUpIeaHPUrl2bFStWFFtgedmzZw9Tpkxh8eLF1KpVi7Vr1+Lj48Ply5cxNTXNdfylS5cYPHgwU6dOpXXr1uzevZs+ffpw+vRpqlWrBsDy5ctZv349q1evxs7Ojrlz5+Lj48OFCxc+mqnvMjKy+xCnpKTw999/4+/vD0Dfvn1p3rw5Kipp/PHHfwuNpaWnEhH1b6GulZaeSnxiHJmZGbyKeEZMbITMfgd9FyKidhdLWTmUMpRQSVIlQyudLJW8ZziWtyx56elVIC7+dbGUlZaeSlz867x3XrpE+uHD8Pnn8JH3d78WFMeTV0lUMteilmPhu89l8d/PsK7l+xcXe71zJ7EH/kK7bh106tZFy8ODly9fYmdnV+gYyiORM8UVV84qVKhArVq18vyAKzo6mgcPHvDgwQPu37/P/fv32bFjB6GhoUB2d6pq1arh6elJrVq1qFu3Lh4eHv9VNDIzID3lvwIdPo3xFKGhoVSvXp3k5A831bSmpib37t0rUxWLkJAQnJ2duXLlCh4eHqUdjiAUSOFKxc2bN2VeKykpYWJi8kEewFevXk3fvn3p3Tv7E+slS5Zw/Phxtm3bxpgxY3Idv27dOry9vRk9ejSQPQj6zJkz/PzzzyxZsoSsrCzWrl3L+PHjadOmDQBr1qyhcuXKHDx48KNczC8z878+xXFxcRw4cECqdBSHmNgI9h/ZQHRMOOnpeX/yXpxlab3SwfIfa1TSVchQzeBFw2ckmSeUaFwAMTERbPl9QfGUFZtdVkvvGrI7vv8eFiygEsDMmTBhAsyfX+TrlQTfP4JYeTRMej2ytQ3TujoqXE5sSqz0vUYq2J4N4bXK83yPT3v2L1Hr1wOQdO0aUWvWoqSmhraDAxEtvNH+/0qG8kdSwRcERRkZGeHl5ZVruvW4uDju3LnDrVu3uHnzJtevX2fbtm2kpaWhqalJ3bp1adasGV29KlEjp6KupAJGiv9efowiIyM/aIUCsufbV3Ts28CBA/n111+ZM2cOEyZMkLbv27cPHx+fXLOMCUJ5pnClwsamdObGTk1N5datW4wdO1bapqysTNOmTbly5Uqe51y5coXhw2XHFjRv3pxDhw4B8PTpU169ekWzZs2k/fr6+tSqVYsrV67kW6lISUkhJeW/T47enT3kQ8qrQqGsZIiuRv1ClRefEMv5C3ewtEqja7teGFWQ7beclZVIg5pj5Cor+nU4F68fJz09jc/+l7uszNQMbg49I92DSoYKdpcd8VjXDGV1FYXKUtS/L4Lxv7CvWMqKfh3OkdPbSUn974GaS5dgwQLZAxcsgC5dProWi2tBcTIVCoCVR8NoW9NE4RaLkLgQ6XvdFIieOUfheLLS0lANDCQyMBBWr0FJTQ1N9xro1K0rKhkFqFv3/a1CgqzSzJm+vj4NGzakYcOG0raUlBRu3rzJhQsXOHv2LCtWrOD+7jf85qOFspISqKhDIVYgF4pGU1OThQsXMnjw4JIZiC8Inwi5KhXr1q2jX79+aGpqsm7dugKPHTp0aLEE9q6oqCgyMjJydXMyNTUlMDAwz3PCw8MxM5N9YDQzMyM8PLsP/atXr6Qy3i0z55i8LF26lAXvPjACV69eRUdHB09PTwICAkhKSkJPTw8HBwdu386eDcfOzo7MzEzCwrIf4jw8PHj8+DHx8fHo6OhIMzsNHDiQBw8ekJKSQuvWrYHsn0Pr1q3R1NRk48aNqKqqMmHCBO7evcv+/fulOIJDYvh24pF845fHkCHtiE9pjl5GFno6yTx9nrNIVCYV9JN5HaeNslIW1Z1fcv+xORmZyhjqJVHBIJHgZ9l9lPW0H6Krl0wFoyrEpzhSxSSGB0FmpKWroK+bjG7qczKS3qoUZUFGUgYvQipTo34KT0JNSElVRVc7BT29h5iZjaCCUSrqGpqgZMarqOyZsao6viL4XyOSU9TQ1krFxiKGh8HZP3cL0zgAXkZkPxxXdggn7KUhKRmVqVjRBAMDQ15FZ6+hYG78BhWVTJ6HZw8sdraL4EWEPvGJGmiop1PJNpL7jy0AMDWKR0M9nWcvDUlJTUJd/TRJSdpcunQJNTU1PPN5Tz45fBjTqlUJDw8nKioKFRUVateuzZUrV8jMzMTU1BQjIyMePnwIgIuLC69fvyYiIgIlJSXq1q3LtWvXSE9Px8jICHNzcwICAoDsQafx8fG8fJk9S0zdunW5efMmqampGBoaYm1tzd27dwFwdHQkOTmZ58+f8290CurKWfhUTaKCVibP4lQ4G6rB04c3SY/QwM7OjoyMDJ49ewZAzZo1CQwMJCEhAV1dXZycnKQWTBsbGxJQBjIpLllpaSQ9eEiGphbPXseQ/u9zqrRqycuXL4mOjs7Ot6cnly5dArJ/xw0MDHj06BEAVapUITIyksjISJSVlalTp46UbxMTE0xMTKQ1XpydnYmNjZV+/+vVq8f169dJS0vDyMgICwsL7t+/D0ClSpVISEiQ8l2nTh1u375NSkoKhoaG2NjYcOfOHQAcHBxITU3l33+zuyUW5W+Ei4sLN27cAMDa2hoVFRWePn1KbGwsjRs3JiQkhLi4ODQ1NalevTrXrl0DwMrKCk1NTYKCggBwdXXl2bNnxMTEoK6ujoeHB5cvZ08FbGFhga6urjT5RtWqVXn16hXR0dGoqqpSq1YtLl++TFZWFqamplSoUIHAwEApj8+ePSMtLU3K99WrV8nIyMDY2BgzMzPpPevs7ExcXJz0t/jtfFeoUAErKytpHF+lSpVQ1QQ1bSWyVNLIyMjg7t27JCcnY2BggK2trZRve3t70tPTpfesp6cnDx48IDExEV1dXSpVqsStW7eIjY3Fzc0NQOqO5O7uzpMnT4iPj0dbW5sqVapw/fp1Kd+qqqqEhIQA4ObmRmhoKLGxsWhqauLq6srVq1eB7DV9tLW1efLkCQDVq1fn+fPnvH79Otd7NmdxvkePHpGYmIiTkxPBwcHY2dmx5/Ztnr/JwlpfiTQlDcKCgor0N+LFixdy/uYJOby9vXny5Anz589n3rx5eR6zZ88eZs6cyePHj7G0tGTEiBHSh6D+/v60aNEi1zlffvklGzduxMnJiadPn+ban18ryN27d/nhhx84d+4cOjo6tGjRgsWLF2NiYlKEuxSEolOKjo7OuxP7Wzw8PDh16hRGRkYF9ulTUlKS/rMrbi9evKB69eocOXJE5tOl6dOn888//3DixIlc55ibm7N69WqZFocNGzawYMECHj58yKVLl/j888+5f/9+9hzo/2/AgAEoKSmxcePGPGPJq6XCzc2N2NjYIi/45O3tzalTp4pUhoO9ISOGFr6l4nHwHSyt4vNsqQh96YqtxV25ysppXYiJjSi4pSI5A7IAJVDRVCmwpSK/shRVEi0Vzf+3nsZNBmdvvHQJ6ufxM7h48aNsqfh8Xu7f28M/1CzU2IrzdatTIS6TZDWw7NazwGNT//2XBP+zubZnaWujV7++NM5Co3JllD702gBlzKVLl0p9nYrr169Tq1Ytrl27pvCCh6WhtHP25s0b7ty5w40bN7h+/TpXr17l7t27ZGZmYmhoSNOmTWndujVD4peikvAK9KxgfECRrhkXF4eBgQEhISEfbLHE1NRUIiMjsbOzk7pKX79+vVRyf+nSJYXemwMHDiQ2NpYvv/ySL7/8koCAAKytrWW6P127dg0vLy+mTZtGt27duHDhAqNGjWLFihX069dPWrwxx4MHD2jfvj3Lly9nwIABRERESC32GRkZ9OjRAzU1NU6fPp1rTEVMTAzVqlVj4MCB9OnTh6SkJCZNmkR6ejrHjx8v9nwJQnJyMk+fPsXExOS9k0rI1VLx9jiKd8dUfCjGxsaoqKgQESE7qDYiIgJzc/M8z3m7VSLH260XOedFRETIVCoiIiIKnMlKQ0MDDQ2NQt1HcVBWVpbGVjg5OaGjo8ytW/99Mp6ZFUN8SiFbKlTBq0FFomNSOHJ6e67d5ubdOHd+l9zFmZlURFVVLc+yALTqvjWmQiWDZ3Wf8uCvO4UqSxFGhubFVhaAqqoaGupvTZ1ar172GIq3W7S+//6jq1AA1HLUZ2RrG5kuUKM+synSYG2AJC1lLKYVvKZJVlYWL319iTt4CO3ataVKRAhg8/+TKQjyMTQ0LO0QypwPlbOEhAQePHhAQEAA9+7d4969e9y9e1dayFRNTY3q1atTt25dRo4cSf369alevfp/U14vXv5B4hTy16lTJ9zd3Zk5cyY//fSTzL4ff/yR5s2bM3nyZCC79SggIIAlS5bQr1+//xZvJLvXxdChQ+nfvz8DBgwAZHtLjB07lpcvX3LhQt6zLK5evRoPDw9mz54tbfvpp59wcHAgMDAQFxeXYr1vQVBEsa1TUdLU1dVxd3fn7NmztG3bFsgetOzv78/gwYPzPKdOnTqcPXuWYcOGSdvOnDlDnTp1gOxuBubm5vj7+0tN4HFxcVy7dk36Zf8YKCsrk5WVRVZWFsbGxri7u3Pq1Ck2b95Mo0aNCHp8mQ0/z2fnrptFvpahgSkdPvuKzMwM9hxcn2tmpNev/y62sgCSzBMI7hj43tmf5ClLEYaGpnRqM6h4yjIwpUvbIcQmvVO5nT8funQh5c4dNNzcPsoKRY5pXR1pW9OkWGZ/UoSSkhIW06ZhMWWKTEuETULuwfpCwaytrUs7hDKnOHOWkpJCcHCwzJSygYGBPHz4UOqGlXPN6tWr06VLF9zc3HB3d6datWrvn1ZWKHV+fn60bNmScePGyWx/8OABHTp0kNnm5eXF8uXLycjIkFZgT0tLo3v37tja2rJ0ae5p33/66Sc2bdrE2bNn85zREuD27ducOXMmzwpxUFCQqFQIpUquSkVO7Vsec+YoPjBTXsOHD2fEiBF4eHjg6enJ2rVrSUxMpFevXgAMGzYMS0tLpv3/p6NDhw6lffv2rFy5klatWrFnzx5u3rwp/TIrKSnx9ddfs3jxYipVqiRNKWthYSFVXEpLTmuElpYWDRo0oHHjxjRs2BBHR0fu3bvHqVOnpD8qysrKrF7ai5fhoZzxj0ZNVR1T47z/IL2PUQUzdLWzHyjNTa1RU5X9j87IZCjRkQWPq5G3rOKMS1HGhmbo61YolrKMKmSXFZuUx8569bgJpd4tRR61HPU/WGXibUpKSvBO16a7d++WiZx9TETOFKdIzjIzM3nx4oXM4nfBwcEEBQURFBREWFiYNNW6lpYWTk5OuLi40LdvXypXrkyVKlWoUqXKB+tyJBS/xo0b06pVK6ZMmULfvn0VPn/EiBE8e/aM8+fPo6oq+/h15swZxowZw9atW6lRo0Y+JWSvrdKuXTvmzp2ba5+lpaXCMQlCcZKrUpEz+C3HrVu3yMjIkBZhe/LkCcrKyiU+h3KXLl2IiorCz8+P8PBwXF1d2bVrl9Sd6dmzZzIrJNerV4/169czd+5cZs+ejaOjI1u3bpXWqAAYPXo0CQkJjB07ltjYWOrXr8+uXbtKbY2K9u3bc+rUKXr06EHnzp2pUaOGNHg7P2npKqSkpLNn2w/8uPI0dWvb0cir8Kvr5qxcnbPY3NvuBFryedOxeZyleFnFGVdhZGZmFltZSUmpZGYW/HMqL5L0NYCU//9XkMfWiWNIiHmNjmEF+vj9WNrhlDtZWVnExMTw7NkzwsLCZL5CQ0MJDQ0lLCxMZuCssbExjo6OODo60qBBAypVqkSlSpVwcnLCyspK5v+iItM1k/1XKDVz5syhdu3aMi0CVapU4fz58zLHnT9/HhcXF6mVYunSpezevZuzZ8/mWnDx8ePH9OjRgx9++IHOnTtTkJo1a7J3717s7e1zVUwEobTJ9Y58e2ahVatWoaury+rVq6VPymNiYqR+oCVt8ODB+XZ3OnDgQK5tnTp1olOnTvmWp6SkxKRJk5g0aVJxhVgkObOvqKmpYWJi8t4KBUBKqhp1miyg0xe9MKhQhwsP4MKDuELHkJCUPV5DRyv3f4p6OlkcOSf/FLoFlVWccRWGqkoW6Rmy0zNGR0aRkpqa61gNdXWMTPJeeTf2dSR/7tzOvv2t89zv6PhpzCsvL+8T14tchrw5e/ToUZ5TOuvp6eHs7FzkOD6UhJjXxEdHvf/AApS395k8srKyiI2N5cWLF7x8+ZIXL15IX8+fPyckJISIiAj+/fdfkpL+a2pUVlbGysoKGxsbbG1tqVOnDnZ2dtjZ2WFvb4+9vT26urof7kaG+n+4awkFcnNzo2fPnqxcuVLaNnbsWBo0aMCcOXPo1q0bFy9eZPXq1dKCwCdPnmTixIksX74cExMTacY4LS0t1NXV6dy5Mx4eHgwaNEjaB8iM9cwxbNgwNmzYQJ8+fRg/fjxGRkY8efKE3377jfXr10uVGEEoDQpXc1evXs3u3btl+vMZGhoyadIkfHx8GDlyZHHGV+54eXmxY8cOdu7cyZYtW6hatSotW7akefPmWFtbo6OjIz1EvXnzhtTU1OwB7JHJrFy8usTja9q0qbSit/AfTU3NfKfz+9ALPH0K5MnZo0ePCuw/HBgYWKYqFkVVHt5nWVlZxMXFERUVJU0THBERIf0bHh5OeHg4r169kr5S3/mQQFdXF0tLS6ysrDAzM6Nhw4ZUrFiRihUrYm1tjbW1NZaWluJT4BKWs2juh15RuzimXZ0xYwa7dv03YYmnpyc7duxg5syZzJkzB0tLS2bMmEG/fv0A+Oeff8jIyGDEiBGMGDFCOu/LL79k2rRp0orr7y7Kl9eUslZWVvj7+zNp0iTatGlDSkoKdnZ2tGrVqnhbxwShEBT+q/nmzRuionJ/ohYVFUV8fHyxBFWeDRw4EC8vL2xtbTlz5gy7du3i559/Zvny5dSsWZPu3btTtWpVIHvu+Jx+uoGBD4mMjCzy9TMzMwv8wxQREcGSJUuKfJ2PUUBAAH369Ml3/9atW6Xcv8vExCTfVVqfP39eaotGllXy5Ox9i06W5qKUpeFjf59lZmaSlJREQkICCQkJvHnzRvqKi4sjNjZW+oqJiSEmJobXr1/z+vVroqOjpa/09PRcZevp6WFqaoqpqSnm5uZ4eHhgbm4ufVlYWGBpaYmlpaVMC0NpTylbntna2nLv3r1i+X9LXgX9nc5PXlPL29vbk/DOZBJdunShS5cueZYxbdo0aaxnXgpaldve3j7XfmdnZ5lKjSB8LBSuVLRt25aRI0cya9Ysaa7na9euMX36dNq1a1fsAZY32traUl59fHzw8fEhISGBw4cP8/vvvzNr1iwSExMBpEWttm/fzj///MPJkyfR1tYu9LXj4+OpVasWw4cPp3Hjxnke8/Lly3xnpSjPcj41zcuDBw/k6sYm/EeenOUs6FXY/R+TtNQ06d+chdYU9TG8z77//nsAOnTogJqaGikpKSQnJ5OUlCTXJ9L6+voYGhpiYGCAoaEhFSpUwNnZGWNjYypUqICxsbH0lbNwoYmJSalO8S0Unq2trcIP+YIgfLzkWvzubYmJiUybNo1t27ZJtWdVVVX69OnDzJkz0dHRKZFAP2ZxcXHY29sXy+J375OQkMCkSZNYvjz3vOVFXXDK19eXWbNm5flJoCAIJWdKu+YYamsRk5jE7L+Ktvjlx6Bt27a4u7ujoaGBpqYmWlpaaGlpoa2tja6uLjo6Oujq6qKnp4e+vj56enro6el98O4b6enp5a6b08ey+J0gCGWDIovfKVypyJGQkEBISAiQ3TxXHisTOT5kpQKyPxU/evQo9vb2aGlpsWrVKg4fPszjx48L3VLx6tUrnJycGDhwoNQPNC+f8uI6Ren+VJBPOWclRZ6cldTPqzScX7WIlPg4NHT18RrxbaHK+BjeZ0lJSYSEhNC6deti6bte0m7duoW7u3tph/FBiUqFIAiKKPYVtfOio6ND9erVC3u6UAQmJib07v3fVKgWFhZoaGgUqeuTr68vqqqqTJ8+HSMjo3yPS0tLK1JrSFlWtWrVQt17ec5ZYRVHzgr78yoNV9TVSAHU1NUKHfPH8j5r2LBhaYcgt/IwuF0QBOFDKVSl4saNG/z55588e/Ys1wCiLVu2FEtgwocTGBgoredRUIUC+KQXbtLT0yvS/vx8yjkrKfLkrKR+XmWVeJ8pTuRMEASh+Chcqfjjjz8YPnw4zZs35/Tp0/zvf//jyZMnhIeHl/oq1ELhTJo0CSsrK0aNGvXeY+3t7Us+oFLi7OxMYGBgsa978CnnrKTIk7OS+nmVVeJ9pjiRM0EQhOKjcKVi6dKlzJkzh0GDBmFra4ufnx92dnaMHTsWc3PzkohRKEEXLlzgjz/+YMuWLXL1db19+/YnPQVjSTyIfuo5Kwny5uxTqTjoGFaQ+bcwxPtMcSJngiAIxUfhSkVISAitWrUCsld9TkxMRElJiWHDhtGpUycmTpxY7EEKJSMrK4sJEybg7u4uM0ZDEIQPq4/fj6UdgiAIgiAUicKVCgMDA2mRO0tLSwICAqhWrRqxsbHS+glC2bB//37OnTvH0aNH5Z7K0c7OroSj+vSInClO5ExxImeKEzkTBEEoPgpPCu7l5cXp06cB6NixIxMnTuSbb75h8ODBNG3atNgDFEpGeno6P/zwAy1btpRanuSRkZFRglF9mkTOFCdypjiRM8WJnAnCfx48eEDDhg3R1dWlVq1apR2OUAYpXKlYsGCBtBT9+PHjGT58OBEREbRv3z7PBdmEj9PGjRt58OAB8+fPV+i8Z8+elVBEny6RM8WJnClO5ExxImfC+7x8+ZJvvvkGFxcXdHR0cHBwoFOnTpw6VbyLVHp7ezNu3LhiLVNRvr6+6OjocO/ePY4dO5bnMQMHDkRNTY3hw4fn2jdq1CjU1NQYOHBgSYcqfKQU7v5UocJ/AwmVlZUZM2aM9DopKalYghJKVnx8PNOnT6dPnz7UrFmztMMRBEEQhI9OSEgITZs2xdDQkHnz5uHq6kpaWhrHjh1j9OjR3L17t7RDzCU1NfW9C5Tl58mTJ7Rp0+a93QJtbGz4/fffWbx4MVpaWkD2mi87d+7E1ta2UNcWPg0Kt1TkJSUlhVWrVokH1DJiyZIlREdHM3v2bIXPFT9jxYmcKU7kTHEiZ4oTOSt7rge/YfelcK4H555KuriNGjUKJSUlzp8/T5cuXXBxcaF69eqMHTuWc+fOScfFxMQwZMgQLC0tMTIyomXLlty6dUva7+vrS61atdi6dStOTk4YGxvTu3dvaTrsgQMHcvbsWVasWIGamhpqamqEhIQAcPfuXdq1a4ehoSEVK1akX79+REZGSmV7e3szevRoxo0bh4WFBW3atMnzXjIzM5k9ezb29vbo6OhQq1Ytjh49Ku1XU1Pj+vXrzJ49GzU1NXx9ffPNS82aNbG2tmbv3r3Str1792JjY4OHh4fMsUePHqVp06aYmJhgbm5Ox44defLkibQ/NTWV0aNHY2Njg66uLpUqVZJ6UGRlZeHr64ujoyM6OjrY2trKfJAtfHzkrlSkpKTg6+tL8+bNad26NQcPHgRg27Zt1KxZkzVr1jBs2LASC1QoHq9evWLhwoWMGjWqUIMUAwMDSyCqT5vImeJEzhQncqY4kbOyZc7eENotvM3ozY9ot/A2c/aGlNi1oqOjOXr0KMOGDUNHRyfXfkNDQ+n7L774goiICA4cOMClS5eoWbMmrVu3Jjo6WjomKCiI/fv38+eff7Jv3z7Onj3LggULgOyp+uvXr89XX31FWFgYYWFh2NjYEBMTQ6tWrfDw8ODixYv89ddfhIeH07NnT5lYfv31V9TV1fH392fVqlV53s/y5ctZunQp8+fP5/r167Rq1YrOnTvz6NEjAMLCwqQKU1hY2Hu7YvXv35/NmzdLr3/55Rf69euX67iEhATGjBnDxYsXpUlhfHx8yMzMBGDlypX89ddf7Nixg3v37rF582bp2WTPnj0sW7aM1atXExAQwO7du3F1dS0wLqF0yd39yc/Pj19++YWmTZty5coVBgwYQK9evbh69SqzZs2iU6dOqKiolGSsQjHw9fVFVVWVSZMmFer8hISEYo7o0ydypjiRM8WJnClO5KzsuB78hlXH/5XZtur4v3zuYYyng16xX+/x48dkZWVRuXLlAo87d+4cV65c4fnz52hoaADZY0/379/PH3/8weDBg4HsloINGzagp5cda+/evTl16hSzZs3CwMAAdXV1tLW1sbCwkMpevXo1Hh4eMr0KfvrpJxwcHAgMDMTFxQUAJycn5s2bV2CcS5cu5bvvvqNHjx5A9jPdmTNnWL58OStWrMDCwgIVFRV0dXVlYshP7969mTJlCk+fPgXg/PnzbNu2jbNnz8oclzMG9+34LS0tuX//Pq6uroSGhuLk5ETDhg1RUlKS+bAzNDQUCwsLvL29UVNTw9bWlrp16743NqH0yF2p2LdvH2vWrOHzzz/n/v37NG7cmPT0dP7++2+UlJRKMkahmAQGBrJ+/Xr8/PwwMjIqVBm6urrFHNWnT+RMcSJnihM5U5zIWdkRFJ73mM2g8KQSqVRkZWXJddzt27eJj4/PtfhvUlISQUFB0mt7e3upQgFgYWFBRETEe8s+c+aMTKtIjqCgIKlS4enpWWA5cXFxPH/+HC8vL5ntXl5e3L59u8Bz82NqakqbNm3YsmULWVlZtGnTBhMTk1zHPXr0iJkzZ3L58mUiIyOlFoqwsDBcXV3p27cvn3/+OdWrV6dVq1a0bduWli1bAuDj48OKFStwcXGhVatWfP7557Rr1w5VVYWHAwsfiNw/mefPn+Pu7g5AtWrV0NDQYPjw4aJCUYZMmjQJKysrRo4cWegynJycijGi8kHkTHEiZ4oTOVOcyFnZ4WimpdD2onJ2dkZJSYmHDx8WeFxCQgKWlpacOHEi1763KwPvPggrKSlJD9j5iY+Pp127dsydOzfXPktLS+n7vLpnfQj9+/fnm2++Ach39s/OnTtja2vL2rVrsbS0JDMzEw8PD1JTU4HsCtGjR484cuQIJ0+epGfPnnh7e/Pbb79hY2PDvXv3OHnyJCdOnGDUqFEsXryYU6dOoaam9sHuU5Cf3GMqMjIyZGYUUFVVLbU3siBLWVmZ0NBQKlasWODXH3/8wezZs9HU1Cz0tW7evFl8gZcTImeKEzlTnMiZ4kTOyg5PBz1GtKwos21kq4ol0koBYGRkRKtWrVizZk2e3eRiYmKA7EHLL1++RFVVFScnJ5mvvD65z4+6unqudVNq1qzJ/fv3sbe3z1W2Is9f+vr6WFlZcf78eZnt58+fp2rVqnKX867WrVuTmppKWlpanutdRUVF8fDhQyZNmkTz5s2pWrUqr1+/zjO+7t27s27dOrZv386ePXuk8ShaWlq0a9eOH3/8kRMnTnDx4kXu3LlT6JiFkiV3S0VWVhYjRoyQ+gwmJyczbty4XG/sLVu2FG+EwnsNGDAANTW19zbXWllZ0bt37w8UlSAIgiAUn8md7fncw5ig8CQczbRKrEKRY/ny5TRt2hQvLy+mT5+Om5sb6enpnDhxgvXr13Pnzh28vb2pX78+Xbt2Zd68eTg7O/P8+XMOHz5Mx44dqV27tlzXsrOz4/Lly4SEhKCrq4uRkRHDhg1jw4YN9OnTh/Hjx2NkZMSTJ0/47bffWL9+vULjWMeNGyfNpOTu7s7mzZu5detWkZ7ZVFRUpAf8vGKpUKECxsbG/PTTT1hYWBAWFpZrPOfSpUuxtLTEw8MDZWVldu/ejYWFBYaGhmzevJmMjAzq1q2LtrY227dvR0tLq1CTzAgfhtyVii+++ELmdbdu3Yo9GKFwHB0dmTZt2ge5lo2NzQe5zqdE5ExxImeKEzlTnMhZ2ePpoFfilYkcjo6OXL58GT8/PyZMmMCLFy8wNTXF09OTlStXAtndmA4cOMDUqVMZNGgQERERWFhY0KhRo1zjLAoybtw4Bg4cSI0aNUhKSuLRo0fY29vj7+/PpEmTaNOmDSkpKdjZ2dGqVSuUlRVbEWDUqFHExcUxYcIEwsPDqVq1Knv37sXZ2Vmhct6lr6+f7z5lZWW2bdvG2LFj8fDwwMXFhR9//BFvb2/pGD09PRYtWsTjx49RUVGhdu3a7N+/H2VlZQwNDVmwYAHfffcdGRkZuLq68ueff2JsbFykmIWSoxQdHS3faCQhX3Fxcdjb2xMbG1vgL9in4OXLl3LNDCH8R+RMcSJnihM5U1x5zFlcXBwGBgaEhIR8sP+vUlNTiYyMxM7OrkjdbwVB+PCSk5N5+vQpJiYm711YsVgWvxPKj5zp4wT5iZwpTuRMcSJnihM5EwRBKD6iUiEIgiAIgiAIQpGISoWgkBo1apR2CGWOyJniRM4UJ3KmOJEzQRCE4iMqFYJCgoODSzuEMkfkTHEiZ4oTOVOcyJkgCELxEZUKQSFv3rwp7RDKHJEzxYmcKU7kTHEiZ4IgCMWnzFQqXr9+zZAhQ7C1tcXe3p5Ro0YRHx9f4PHff/89devWxcrKCjc3N3744Qfi4uJkjjMyMsr19ccff5T07ZRZWlols3rpp0zkTHEiZ4oTOVOcyJkgCELxkXuditI2ZMgQXr16xZ49e0hPT2fkyJGMHTuWn376Kc/jX7x4wYsXL/D19aVy5cqEhYUxfvx4Xrx4webNm2WOXblypcy8yQYGBiV6L2VZUVbfLK9EzhQncqY4kTPFiZwJgiAUnzLRUvHw4UNOnjzJsmXLqF27NvXr12fevHns2bOHFy9e5HlOtWrV2LJlC5999hkODg40adKEyZMnc/ToUdLT02WONTAwwNzcXPoS82jn7/r166UdQpkjcqY4kTPFiZwpTuRMEASh+JSJloorV65gYGBAzZo1pW3NmjVDWVmZa9eu0a5dO7nKiYuLQ09PD1VV2dueMGEC33zzDfb29vTv35/evXujpKSUbzkpKSmkpKTIlPv2v5+yhISEcnGfxUnkTHEiZ4oTOVNcecxZzv1mZYl1bwVBKF5lolIRHh6OqampzDZVVVUqVKhAeHi4XGVERUWxaNEi+vXrJ7N94sSJNG7cGG1tbU6fPs13331HQkICQ4cOzbespUuXsmDBglzbbWxs5IpFEARBEEpTfHy86Or7kdm8eTPjx48nMjKytEMpExITE+nfvz8nTpzgzZs3REREYGhoWNphlWulWqmYOXMmy5YtK/CYixcvFvk6cXFx9OjRg8qVK/P999/L7Pvuu++k72vUqEFCQgIrVqwosFIxduxYhg8fLr3OzMwkJiaGChUqFNjCUda9efMGNzc37ty5g56eXmmHUyaInClO5ExxImeKK685y8rKIj4+HktLy9IO5aMXERHBjBkzOHz4MK9evaJChQrUqFGDyZMn07BhQwDU1NTYvXs3HTt2VKhsJycnRo0axTfffCNt6969O59//nmRYk5NTWX58uVs376dx48fo62tjYuLCwMHDqR3796oqakVqfwcvr6+7Nu3j2vXrhVLeYWxZcsWzp07x9mzZzExMcmzkrx582YGDRoEgJKSElZWVnh7e+Pn54eZmdmHDvmTV6qVihEjRtCzZ88Cj7G3t8fMzIyIiAiZ7enp6bx+/fq9b4o3b97QrVs39PT0+PXXX9/7C1W7dm0WLVpESkoKGhoaeR6joaGRa195qh3r6emhr69f2mGUKSJnihM5U5zImeLKY85EC4V8unfvTmpqKhs3bsTBwYFXr15x+vRpoqOjS+R6WlpaRZqRLDU1lTZt2nD79m1mzJiBl5cX+vr6XLp0iSVLluDh4YGHh0fxBVwMUlNTUVdXL9S5QUFBVKlSBVdX1wKP09fX5969e2RmZnL79m0GDRrEixcvOHToUK5jMzIyUFJSQln54xly/DHGlJ9SjdDExAQXF5cCv9TV1alTpw6xsbHcvHlTOvfs2bNkZmZSq1atfMuPi4uja9euqKurs23bNrkGYN+5cwdDQ8N8KxSCIAiCIJSSS5dQ2roVLl0q0cvExMRw7tw5/Pz8aNasGXZ2dtStW5fvv/+e9u3bA9mtDQA+Pj6oqalJr588eUKXLl2oWLEihoaG1K9fn5MnT0ple3t78/TpU7799lvU1NSkDzs3b96MiYmJTBx//fUX9evXR1dXFwsLC3x8fPKNefny5fz9998cPXqU4cOH4+HhgaOjIz179uT8+fM4OzsD2b0r5s+fj7OzM3p6enh6espMpe/v74+amhqnTp2iXr166Ovr07hxYx4+fCjFOWvWLG7fvi3FnzOrZkxMDEOGDMHS0hIjIyNatmzJrVu3pLJ9fX2pVasWGzZswNnZGV1d3XzvZ8+ePbi7u6Ojo4OTkxNLly6VyeHSpUv5+++/UVNTk5nB811KSkpYWFhgZWXFZ599xsiRIzl58iRJSUlSzg8cOECNGjXQ0dEhNDSUlJQUJkyYgJ2dHQYGBnh5eeHv7y+V+fTpUzp16oSpqSkGBga4u7tz+PBhIHtJgy+//BJLS0v09PSoWrUqv/zyi0xuY2JipLJu3ryJmpoaISEhUn4LE9PHoEyMqahcuTLe3t6MGTOGxYsXk5aWxvfff0+XLl2kJtznz5/TuXNnVq9eTa1ataQKRVJSEuvWrePNmzfSQkcmJiaoqKhw5MgRwsPDqV27Npqampw5c4alS5cyYsSI0rxdQRAEQRDeoTxxIsqLFkmvM7/9lkw/vxK5lq6uLrq6uuzbt4969erl+UHjhQsXsLKy4ueff6Z169aoqKgA2eNVPvvsM3x9fdHQ0GDr1q106tSJe/fuYWtry65du6hVqxaDBg3iq6++yjeGQ4cO4ePjw8SJE9m0aROpqakcOXIk3+O3b9+Ot7e3zKQ2Od6uvMyfP5/t27ezatUqnJyc+Pvvv+nXrx+mpqY0adJEOmfq1KksXLgQExMTRowYweDBgzl79izdu3fn3r17HDt2TIonp/Xriy++QEtLiwMHDmBgYMBPP/1E69atuX//PkZGRkB2pWvv3r38/vvvUs7ede3aNXr27Mm0adPo1q0bFy5cYNSoURgZGdGvXz927drFpEmTuHfvHrt27VKotUNTU5PMzExpJtDExEQWLlzI2rVrMTY2xszMjNGjRxMQEMC2bduwtLRk3759tG3blhs3buDs7Mzo0aNJTU3l1KlT6OjoEBAQIFWQpk+fTkBAAAcOHMDExIQnT56QlJQkd3yFjeljUCYqFQDr169nwoQJdO7cGSUlJdq3b8+8efOk/enp6Tx69Ej6wd2+fVvq6/dua8bNmzextbVFVVWVDRs2MGXKFLKysnBwcGD27Nn07dv3w91YGaKhocGECRNEK44CRM4UJ3KmOJEzxYmclTGXLslUKACUFy0is1MnqFev2C+X83zw9ddfs379emrWrEmTJk3o3r07NWrUAJAmkDE0NMTCwkI6193dHXd3d+n1zJkz2bdvHwcOHGDEiBEYGRmhoqIitT7kx8/Pj+7duzN9+nSZsvPz+PFjmjZtWuB9paSkMG/ePI4cOUKDBg0AcHR05J9//uGnn36SqVTMmjVLej1hwgQ6dOhAcnIyWlpa6OrqoqKiIhP/uXPnuHLlCs+fP5d+rxYsWMD+/fv5448/GDx4MJDd5WnTpk25JuB5248//kjz5s2ZPHkyAC4uLgQEBLBkyRL69euHkZER2traqKurF5jDdz169IiffvqJWrVqSWOp0tLSWLFihZTb0NBQNm/eTFBQEFZWVgCMGzeOo0ePsnnzZmbPnk1oaChdunTBzc1NymGOsLAwPDw8qF27NpDdjV9RhYnpY1BmKhUVKlTId6E7AFtbW5l+jo0aNXpvv8cWLVrQokWLYovxU6ehocEPP/xQ2mGUKSJnihM5U5zImeJEzsoWpUeP8t2eVQKVCoAuXbrQpk0bzp07x6VLlzhy5AiLFi1i3bp1uWaSfFt8fDy+vr4cPnyYFy9ekJ6eTlJSEmFhYQpd/9atWwW2ZLxLnmmCHz9+TGJiYq4B4ampqbnGW+Q8MAPSg3t4eDi2trZ5ln379m3i4+MxNzeX2Z6UlERQUJD02s7OrsAKBcCDBw/o0KGDzDYvLy+WL19ORkZGvi0ceYmNjcXQ0JDMzEySk5Np2LAh69atk/arq6tLFUWAu3fvkpGRQbVq1WTKSUlJwdjYGICRI0cycuRIjh8/jre3N507d5bKGDp0KN27d+fGjRu0bNmSDh064OXlJXe8hY3pY1BmKhWCIAiCIJRPWfl078hve3HR1NSUPoCcPHkyQ4YMwdfXt8BKxYQJEzh58iTz58+nUqVKaGlp0aNHD1JTUxW6tqKDtp2dnaVxD/mJj48HYP/+/dIn3jnebbV7e2KbnJktMzMz8y07ISEBS0tLTpw4kWvf25PZaGtrFxhjcdPT0+Py5csoKytjaWmZK69aWloyM3fGx8ejoqLCpUuXclVecro4ffXVV7Rq1YpDhw5x4sQJ5s+fz4IFCxg5ciSfffYZT5484fDhw5w4cYLWrVszbNgwFixYIA22frsCmJaWlivmwsT0Mfj4h5ILgiAIglC+1atH5rffymzK/O67Eun6VJCqVauSkJAgvVZTUyMjI0PmmPPnz9O3b186deqEm5sbFhYWPH36VOYYdXX1Ah/QIbul4NSpU3LH1rNnT06ePMmNGzdy7UtLSyMhIYFq1aqhoaFBaGgoTk5OMl+KrLWlrq6e675r1qzJy5cvUVVVzVX2uwPQ36dKlSqcP39eZtv58+dxcXFRqJUCQFlZGScnJxwdHeWqqHl4eJCRkUFERESu+3i7q5WNjQ1Dhw5l165djB07lg0bNkj7TE1N6du3L1u2bGHx4sX8/PPPAFIeXrx4IR379kD2osZU2kSlQhAEQRCEj16mnx/p586RsWkT6efOkTl3boldKyoqipYtW7Jt2zZu375NcHAwu3fvZvHixdLsT5DdX/7UqVO8fPmS169fA9ktBnv37uXmzZvcunWLL7/8MlcFws7Ojr///pt///0338Xupk6dym+//cbMmTMJCAjgzp07LFy4MN+YR48ejZeXF61bt2b16tXcunWLoKAgdu3aRcOGDXn06BF6enqMGzeOb7/9li1btvDkyROuX7/OypUr2bJli9z5sbOzIyQkhJs3bxIZGUlKSgre3t7Ur1+frl27cvz4cUJCQjh//jxTp07l6tWrcpcN2euBnTp1ijlz5hAYGMiWLVtYvXo1Y8eOVaicwnBxcaFnz54MGDCAvXv3EhwczOXLl5k/f740De24ceM4duwYwcHBXL9+nTNnzlC1alUAZsyYwf79+3n8+DH37t3j0KFDVKlSBUCqvM2aNYtHjx5x6NAhfvzxx2KJ6WMgKhWCIAiCIJQN9eqR1adPibdQ6OrqUrduXZYtW0bz5s3x8PBgxowZfPXVVyxfvlw6bsGCBZw8eRIHBwfq1KkDwMKFC6lQoQJNmjShc+fOtGzZMteMTNOnTyckJITKlSvnuxBh06ZN2blzJwcOHKB27dq0atWKK1eu5BuzhoYGR44c4dtvv+Wnn36iUaNGNGjQgJUrVzJy5EhpPYeZM2cyadIkFixYgJubG+3atePw4cM4ODjInZ8uXbrQunVrWrZsiaWlJTt37kRJSYkDBw7QuHFjBg0aRLVq1ejTpw9Pnz7NNc7ifTw9PdmxYwe///47Hh4ezJw5kxkzZhTY7aw4bdiwgT59+jBhwgSqV6+Oj48PV69elVpzMjIyGD16tJQ/Z2dnVqxYAWS34kyZMgVPT0+aN2+OiooK27ZtA7Jbtn799VcePHiAp6cnCxcuZObMmcUS08dAKTo6+v0jewRBEARBEAohNTWVyMhI7Ozs5FovShCEj0dycjJPnz7FxMTkvVP3ipYKoUCLFy+mdevWVKxYUe5p0bKyspg7dy5Vq1bFysqKzp078+TJk5IN9CPy+vVrhgwZgq2tLfb29owaNUoaHJef9u3bY2RkJPM1bty4DxTxh/fzzz/j7u6OpaUlLVq0kKZ/zs+ff/5JvXr1sLS0pGHDhhw/fvwDRfrxUCRn27dvz/V+yu/T0E/V+fPn6dmzJ9WqVcPIyIiDBw++95xz587RrFkzLCwsqFWrFtu3b/8AkQqCIHwaRKVCKFBqaiodO3ZkwIABcp+zfPly1q9fz+LFizl+/Dja2tr4+PiQnJxcgpF+PIYMGcKDBw/Ys2cPO3fu5MKFC3L1A+3bty8BAQHS14wZM0o+2FKwZ88epkyZwoQJEzh9+jSurq74+PgQERGR5/GXLl1i8ODB9O7dmzNnztCmTRv69OnD/fv3P3DkpUfRnEH2jCdvv5/kGQz4KUlISMDV1ZUFCxbIdfzTp0/54osvaNSoEf7+/nz99dd88803MishC4IgCPkT3Z8EuWzfvp1JkyZJy8jnJysri2rVqjF8+HBGjRoFQFxcHJUrV2blypV07dr1A0Rbeh4+fEiDBg04efKk1If2xIkT9OjRg7t37+b7aXH79u1xdXXFr4RWh/2YtGjRAk9PT+lhLzMzEzc3NwYPHsyYMWNyHT9w4EASExPZuXOntK1ly5a4ubmxZMmSDxV2qVI0Z/L+vpYXRkZG/Prrr7Rt2zbfY2bMmMGxY8dkZpz56quviI2NZffu3R8izE+W6P4kCGWX6P4klJqnT5/y6tUrmjVrJm3T19enVq1aBQ4w+1RcuXIFAwMDmUF5zZo1Q1lZ+b1dfHbv3o2TkxNeXl74+vqSmJhY0uF+cKmpqdy6dUtm1VdlZWWaNm2a7/vjypUruVaJbd68ebl4P0HhcgbZn9TXqFEDV1dXevfuTUBAwIcIt8wq7+8zQRCEohKL3wnF6tWrVwC5Vss0NTUlPDy8NEL6oMLDw3Pdu6qqKhUqVCjw/rt27YqNjQ2Wlpbcu3ePGTNm8PjxY4Wm+CsLoqKiyMjIyPP9ERgYmOc54eHhmJmZyWwzMzMrF+8nKFzOnJycWLFiBdWrVycuLo6VK1fy2Wefcf78eSpWrPghwi5z8nufvXnzhqSkJIUXIhMEQShvRKWiHJo5cybLli0r8JiLFy/i4uLygSL6+Mmbs8Lq37+/9H21atUwNzenU6dOBAcHKzTNnyAA1K1bl7p168q8rl+/Pr/88guTJ08uxcgEQRCET5WoVJRDI0aMoGfPngUeI+9MT+/KmYs6IiJCZpXHiIgIaY7sskjenJmZmeUaPJuens7r169zfQpakFq1agEQFBT0SVUqjI2NUVFRyZWjiIiIfOcxz6tVIq9PlT9VhcnZu9TU1HBzcyM4OLgkQvwk5Pc+09PTE60UgiAIchCVinLIxMREWiq+uNnZ2WFubo6/vz9ubm5A9kDta9euKTSD1MdG3pzVqVOH2NhYbt68iYeHBwBnz54lMzNTqijI486dOwAyFbNPgbq6Ou7u7pw9e1YaNJuZmYm/vz+DBw/O85w6depw9uxZhg0bJm07c+aMtNDUp64wOXtXRkYGAQEBtGjRoiRDLdPq1KmTa6ri8vQ+EwRBKCoxUFso0LNnz7hz5w7Pnj0jMzOTO3fucOfOHZl1F+rVq8dff/0FgJKSEl9//TWLFy/m8OHD3L9/n+HDh2NhYVHgzCufisqVK+Pt7c2YMWO4du0aFy9e5Pvvv6dLly7SzE/Pnz+nXr160sDt4OBgFi5cyM2bNwkNDeXw4cMMHz4cLy8vqlevXpq3UyKGDx/Oli1b2LFjBw8fPmT8+PEkJibSq1cvAIYNG4avr690/NChQzl58iQrV64kMDCQefPmcfPmTQYNGlRat/DBKZqzBQsWcOrUKUJCQrh16xZDhw4lLCyML7/8srRu4YOLj4+X/l5B9iQSOX/LAHx9fWUqqgMGDODp06dMnz6dwMBANmzYwJ9//ilzjCAIgpA/0VIhFMjPz48dO3ZIr3NmR9m/fz+NGjUC4NGjR8TFxUnHjB49moSEBMaOHUtsbCz169dn165d5WYqwfXr1zNhwgQ6d+6MkpIS7du3Z968edL+9PR0Hj16RFJSEpDdNcXf35+1a9eSmJhIxYoVad++PePHjy+tWyhRXbp0ISoqCj8/P8LDw3F1dWXXrl1Sd6Znz56hrPzf5x316tVj/fr1zJ07l9mzZ+Po6MjWrVupVq1aad3CB6dozmJiYhgzZgzh4eEYGhri7u7OkSNHqFKlSmndwgd38+ZNOnToIL2eMmUKAD179mTVqlW8evVKqmBAdivrzp07mTx5MuvWrcPKyoply5bh7e39wWMXhBze3t64u7uXm+mzFeXv70+LFi2IiIjA0NCwtMMp98Q6FYIgCIIglJiyvk7FhQsXaNasGa1bt2b//v0f9NplvVKxefNmxo8fT2RkZImUn5qaSnR0NObm5igpKRWqjJCQEJydnTE1NeXhw4fo6elJ+2rVqkXHjh2ZNm1acYVc5oh1KgRBEARBEIrBpk2bGDFiBH///TfPnz8v7XAUkpGRQWZmZmmHUWT53Ye6ujoWFhaFrlC87c2bN2W28vaxEJUKQRAEQRCEPMTHx7Nr1y6GDh1KmzZt8lw76K+//qJ+/fro6upiYWGBj4+PtC8lJYWJEyfi4OCAjo4OVapUYePGjdL+u3fv0q5dOwwNDalYsSL9+vUr8FP9lJQUJkyYgJ2dHQYGBnh5eeHv7y/t37x5MyYmJhw4cIAaNWqgo6NDaGgor1+/pn///piamqKvr0+7du149OhRrvMOHjxI9erV0dfXp0ePHiQmJrJlyxacnJwwNTVlzJgxZGRkyBWPv78/gwYNIjY2FjU1NdTU1KSxX4W9j3f5+/ujpqZGTEyMzHnHjh3Dzc0NQ0ND2rZty4sXL/LNaY4RI0bw448/FrgG0vvy+PTpUzp16oSpqSkGBga4u7tz+PBhaf/7ft6ZmZksWrSIKlWqoKOjg6OjI35+ftL+O3fu0LJlS/T09DA3N+frr7+WGeM6cOBAunbtypIlS7CxscHc3JxRo0aRlpYm18+sqMSYCkEQBEEQPiiVDc0hvhQWsNQ1I+OrU3IfvmvXLipXrkzlypXp1asX48eP5/vvv5c+GT906BA+Pj5MnDiRTZs2kZqaypEjR6TzBwwYwMWLF1m6dCk1atQgJCREeoiMiYmhVatWDBw4kEWLFpGUlMSkSZPo2bNnrpnIcowePZqAgAC2bduGpaUl+/bto23btty4cQNnZ2cAEhMTWbhwIWvXrsXY2BgzMzP69OnD48eP2bt3L3p6ekyaNIkOHTpw+/Zt1NTUpPNWrlzJ1q1biY+Pp1u3bvj4+GBoaMj+/fsJDg6me/fueHl50b179/fG06BBAxYvXszMmTO5d+9edvp1dYt0H/JITExkyZIlbNq0CWVlZfr378+ECRP49ddfCzyvR48enDhxgtmzZ7N8+fI8j/nqq68KzOPo0aNJTU3l1KlT6OjoEBAQIN2zPD/vyZMns2HDBhYtWkTDhg158eIFDx8+BCAhIYG2bdtSv359Lly4QEREBEOHDmX06NEyFdUzZ85gYWHB8ePHefLkCb169cLd3V2a3ESe3BeWGFMhCIIgCEKJyWtMhcoyV5TevP/T4+KWpWdJxjd35T6+SZMm+Pj4MHr0aNLT07GxsWHnzp3SpCWNGzfGwcEhzxaMwMBAqlevzpEjR/Ic8D937lzOnTvHoUOHpG3Pnj3DwcGBe/fu4eLiIjOmIjQ0FBcXF4KCgrCyspLOad26NXXq1GH27Nls3ryZQYMGcfXqVdzd3YHsyVSqVauGv78/Xl5eAERFReHg4MDGjRvx8fGRznvw4AGVKlUCsmed27ZtG//++6/0YNy2bVvs7OxYvXq13PG8O6aisPeRl3cHaud1H2vWrGHOnDkyEzO8LWdMxZUrVwgPD6dTp07cuXOHSpUqyYypkCePNWvWpEuXLkydOlXhn7elpSWWlpYsW7aMr776Ktf5P//8M5MmTSI4OBgdHR0ADh8+TKdOnQgNDcXc3JyBAwdy9uxZHj58iIqKCpA9OYWysjLbtm2TK/fvUmRMhWipEARBEAThw9I1o1Q+0dSVf9HMhw8fcuXKFXbv3g2Aqqoq3bp1Y+PGjVKl4tatW3k+AObsU1FRoUmTJnnuv337NmfOnMlz1qKgoCBcXFxktt29e5eMjIxcM9+lpKRgbGwsvVZXV6dGjRrS6wcPHqCqqkq9evWkbcbGxri4uPDgwQNpm7a2tvQgDtmL2drb20sVCkBmgVd543lXYe9DXu/eh6WlZYFdmt7WqlUrGjZsyIwZM3K1bMiTx5EjRzJy5EiOHz+Ot7c3nTt3lu7hfT/vmJgYUlJSaN68eZ6xPXjwQOoKlsPLy4vMzEwCAwOlxVCrVasmVSgge72ru3ezK9KF/ZnJS1QqBEEQBEH4oBTpglRaNm3aRHp6Ora2ttK2rKwsNDQ0WL58OQYGBgWutv6+ldjj4+Np164dc+fOzbUvZ12jd49XUVHh0qVLMg+NgMyDv5aWVqEGLud0g8qhpKSEqqpqrm05A6bljedjuI+sLPmrsHPmzKFx48aMGzdO4Wt/9dVXtGrVikOHDnHixAnmz5/PggULGDly5Ht/3kFBQQpfLy953X9Rf2byEpUKQRAEQRCEt6Snp7N161YWLFhAy5YtZfb5+Piwc+dOhg4dipubG6dOnaJ///65ynB1dSUzM5OzZ8/m2f2pZs2a7N27F3t7+1wP73nx8PAgIyODiIgIaZ0oeVSpUoX09HQuXbok020nMDCQqlWryl1OYeJRV1eXGdhdlPv4UOrWrUvnzp2ZPHmyzHZ582hjY8PQoUMZOnSoNEZi5MiR7/15Ozs7o6WlxalTp/Js/apSpQpbtmwhISFBaq04f/48ysrKuVq18lPSuRezPwmCIAiCILzl4MGDvH79moEDB+Lq6irz1blzZzZt2gTA1KlT+e2335g5cyYBAQHcuXOHhQsXAmBvb8+XX37J4MGD2bdvH8HBwfj7+7Nr1y4Ahg0bRnR0NH369OHKlSs8efKEY8eO8dVXX+V6EAdwcXGhZ8+eDBgwgL179xIcHMzly5eZP3++TD/9dzk7O9OhQweGDRvGuXPnuHXrFv369aNixYoyC0QqSp547OzsiI+P59SpU0RGRpKYmFjo+/iQfH19OX36NIGBgdI2efI4btw4jh07RnBwMNevX+fMmTNSheN9P29NTU2+++47Jk6cyK+//sqTJ0+4ePGiNAi7V69eaGpqMnDgQO7evcuZM2cYM2YMvXv3lro+vU9J515UKgRBKBHnzp3DyMiI2NjYAo9zd3dnzZo1HySmr7/+usjzkJ84cYImTZp8EnO/C4KQt02bNuHt7Y2BgUGufZ07d+batWvcvn2bpk2bsnPnTg4cOEDt2rVp1aoVV65ckY5dtWoVXbp0YdSoUbi6uvL111+TkJAAgJWVFf7+/mRkZNCmTRtq1qzJ+PHjMTQ0RFk578ezDRs20KdPHyZMmED16tXx8fHh6tWr2NjYFHg/P//8MzVr1qRTp040btyYrKws9u/fn6urjKLeF4+XlxdDhgyhV69eWFpasmjRoiLdx4fi4uJC//79SU5Oltn+vjxmZGQwevRo3NzcaNeuHc7OzqxYsQKQ7+c9efJkxo4dy8yZM3Fzc6N3797SGBZtbW0OHjxIdHQ0DRo0oEePHvzvf//Ld6aq/JRk7sXsT4JQjo0YMYIdO3YA2f0wra2t6dGjB+PGjZOrOb4gqampvH79GjMzM5SUlNi+fTuTJk0iJCRE5rjIyEi0tbXR1tYu0vXe5+7du3Ts2JFbt24Vue+ot7c3Q4YMoUePHsUUnSB8usr6itqCUJ6JFbUFQZCbt7c3AQEBXL16lREjRjB//nzpk5WiUFdXx9zc/L0D7UxMTEq8QgGwfv16OnbsWCyD0Xr27Mn69euLISpBEARB+DSISoUglHMaGhqYm5tjY2PDwIEDadq0qbQCaExMDMOGDcPBwYGKFSvSrVs3njx5Ip0bFhZGz549cXBwwNramgYNGkiL+Lzd/encuXOMHDmSuLg4jIyMMDIyYt68eUDu7k/Pnj2jd+/e2NjYYGtry4ABA2SmA5w3bx5NmjTht99+w93dHTs7O7766ivevHmT7z1mZGSwf/9+PvvsM5nt7u7uLFq0iGHDhmFjY0ONGjU4fPgwkZGRUgyNGjXixo0bMud99tln3Lhxg+Dg4EJmXRAEQRA+LaJSIQiCDC0tLdLS0oDs7lE3btxg+/btHD16lKysLHr06CHt/+6770hJSeHgwYOcO3eOGTNmyMyhnaNu3brMnTsXPT09AgICCAgIYOTIkbmOy8zMpHfv3rx+/ZoDBw6wZ88enj59mmsmjJCQEA4ePMiOHTvYuXMn58+fZ9myZfne071794iLi8PDwyPXvjVr1lCvXj3OnDlDq1at+Prrrxk2bBjdunXj9OnTODg4MGzYMJkpCa2trTEzM+PChQty5VQQBEEQPnViSllBEIDs+df9/f05deoUgwcP5smTJxw+fJjDhw9Li/2sX78eNzc3Dh48SKdOnXj27Bnt27eXFtKxt7fPs2x1dXX09fVRUlIqcJYKf39/7t+/z40bN7C2tgZg9erVeHl5cf36dTw9PYHsyseqVavQ09MDoHv37vj7+zNlypQ8yw0LC0NFRQVTU9Nc+1q2bClNB/ndd9+xceNGaSAewOjRo2ndujXh4eEysVtYWBAWFpbvvQiCIAhCeSJaKgShnDt69Cg2NjZYWlrSvXt3OnfuzPfff09gYCCqqqrUrl1bOtbIyAgnJydpmr0hQ4awePFiPvvsM/z8/Lh3716RYgkMDKRixYpShQKy5+Y2MDCQmdrPxsZGqlBA9sqvkZGR+ZabnJyMhoZGnuM73l5Z1MzMLN9t75avqalJUlKSvLcmCIIgCJ80UakQhHKuUaNG+Pv7c/XqVZ4/f87q1avz7MKUl759+3L9+nV69OhBQEAAzZs3/yADmAtaMTQvRkZGJCYmkpqaWmBZOZWOvLa9W/7r168xNjZWPHhBEARB+ASJSoUglHM6Ojo4OjpibW0tM42si4sL6enpXL16VdoWHR3N48ePqVy5srTN2tqaAQMGsGXLFkaMGMGWLVvyvI66uvp713ZwcXHh33//5dmzZ9K2Bw8eEBsbK3NNRbm5uQHw8OHDQpfxtuTkZEJCQqhRo0axlCcIgiAIZZ2oVAiCkKdKlSrRpk0bxowZw8WLF7l79y5Dhw7F0tKSNm3aADBx4kROnjzJ06dPuXXrFn///TcuLi55lmdjY0N8fDz+/v5ERUWRmJiY65hmzZpRrVo1hg4dyq1bt7h27RrDhw+nYcOG1KxZs9D3YmJigru7OxcvXix0GW+7evUqGhoa1KlTp1jKEwRBEISyTlQqBEHI18qVK/Hw8OCLL76gdevWZGVl8dtvv0ndgzIzM5kwYQL169enW7duODk5SSumvqtevXoMGDCAr776Cmdn5zxXAVVSUmLbtm0YGhrSrl07OnfujJ2dHRs2bCjyvXz55Zfs2rWryOUA/PHHH/j4+HyQ9TUEQRAEoSwQK2oLglAuJCUlUbduXTZs2EDdunULXU5UVBR169bl1KlT2NnZFWOEgvBpEitqF563tzfu7u4sWbKktEP5KPn7+9OiRQsiIiIwNDQs7XA+SWJFbUEQhHdoaWmxZs0aoqOji1ROaGgoCxcuFBUKQSgnLly4gIaGBh06dCjtUMqczZs3Y2JiUmLlN2jQgLCwMAwMDIpc1p49e/D29sbY2BhDQ0Nq1qzJ7Nmzpf8zNm/ejJqaGmpqamhoaGBqaoqXlxezZ88mNjZWpqyBAweipqbG8OHDc11n1KhRqKmpMXDgwCLH/LERlQpBEMqNRo0a5VpVW1E1a9akS5cuxRSRIAgfu02bNjFixAj+/vtvnj9/XtrhKCQjI+O9E2SUBfndh7q6OhYWFnlOF66IqVOn0qtXL2rXrs2BAwe4efMmCxcu5Pbt22zdulU6Tl9fn7CwMEJCQjh79iyDBg1i69at1K5dO9d7w8bGht9//11m6vHk5GR27tyJra1tkeL9WIlKhSAIgiAIQh7i4+PZtWsXQ4cOpU2bNnnObvfXX39Rv359dHV1sbCwwMfHR9qXkpLCxIkTcXBwQEdHhypVqrBx40Zp/927d2nXrh2GhoZUrFiRfv36FbjmTkpKChMmTMDOzg4DAwO8vLzw9/eX9ue0DBw4cIAaNWqgo6NDaGgor1+/pn///piamqKvr0+7du149OhRrvMOHjxI9erV0dfXp0ePHiQmJrJlyxacnJwwNTVlzJgxZGRkyBWPv78/gwYNIjY2VvqE39fXt0j38S5/f3/U1NSIiYmROe/YsWO4ublhaGhI27ZtefHiRb45vXz5MvPmzWPBggXMnz8fLy8v7O3tadGiBb///jt9+/aVjlVSUsLCwgJLS0uqVq3KwIEDOXv2LPHx8fzwww8y5dasWRNra2v27t0rbdu7dy82NjZ4eHjkG09ZJlbUFgRBEAThg+p1uBdRSVEf/LrGWsZs/3y73Mfv2rWLypUrU7lyZXr16sX48eP5/vvvpU/GDx06hI+PDxMnTmTTpk2kpqZy5MgR6fwBAwZw8eJFli5dSo0aNQgJCZEqDTExMbRq1YqBAweyaNEikpKSmDRpEj179uT48eN5xjN69GgCAgLYtm0blpaW7Nu3j7Zt23Ljxg2cnZ0BSExMZOHChaxduxZjY2PMzMzo06cPjx8/Zu/evejp6TFp0iQ6dOjA7du3pYk3EhMTWblyJVu3biU+Pp5u3brh4+ODoaEh+/fvJzg4mO7du+Pl5UX37t3fG0+DBg1YvHgxM2fOlBZG1dXVLdJ9yCMxMZElS5awadMmlJWV6d+/PxMmTODXX3/N8/gdO3agq6vLsGHD8tz/vrEaZmZm9OzZk19++YWMjAxUVFSkff3792fz5s306tULgF9++YV+/fpx9uxZue6lrBGVCkEQBEEQPqiopCjCk8JLO4z32rRpk/RA2Lp1awYNGsTZs2dp2rQpAH5+fnTv3p3p06dL57i7uwMQGBjIrl27OHLkCN7e3gA4OjpKx61evRoPDw9mz54tbfvpp59wcHAgMDAw1/TcoaGhbN68maCgIKysrAAYN24cR48eZfPmzVI5aWlprFixQorj0aNHHDhwAH9/f7y8vADYsmULDg4O7Nu3T2pZSUtLY+XKlVSqVAmALl26sG3bNv799190dXWpVq0azZo148yZM3Tv3l2ueAwMDKRP94t6H/JKS0tj1apV0n0MGzaMOXPm5Hv848ePcXBwyLWoqiIqV67MmzdviIqKkqn89O7dmylTpvD06VMAzp8/z7Zt20SlQhAEQRAEoTgYa5XOavSKXPfhw4dcuXKF3bt3A6Cqqkq3bt3YuHGjVKm4desWX331VZ7n37p1CxUVFZo0aZLn/tu3b3PmzJk8PwkPCgrKVam4e/cuGRkZVKtWTWZ7SkoKxsb/3Ze6urrMwpwPHjxAVVWVevXqSduMjY1xcXHhwYMH0jZtbW3pQRzA3Nwce3t7qXUBsj+Vj4iIUCiedxX2PuT17n1YWloSHp5/BTYrq+iToOaU8e7YDlNTU6nbXFZWFm3atCnRgeulTVQqBEEQBEH4oBTpglRaNm3aRHp6usyg2qysLDQ0NFi+fDkGBgZoaWnle35B+/i/9u4+KMpyj//4exdC5ckNKHmQFhUNODBqUlqWOmDiSUXFoyccpcRyNBXFw8kiscLf+FRODmo5KTHWyZ96UlOPJ02lsQdEkVOpR4wCAwx8QLRERVyW3x/+3NMGPoGC0ec1s39w39d17/e6Z5jZz17XtTdX9msMHjyYuXPn1jnn4+NTb3sHBwf27t1rt8QGsPvg36ZNmwZtXP7tN/UGgwFHR8c6x65umL7Zeu6GcVwvOHTu3JmvvvqKy5cvN3i24siRI7i7u9cbpp599lmmTZsGUO/zmVoSbdQWERER+RWLxcI//vEPFi5cyP79+22v3NxcfH19WbNmDQBhYWFkZmbWe43Q0FCsVus1l7p0796dw4cPExAQQGBgoN3LxcWlTvtu3bpRU1PDqVOn6rT/9fKi3woKCsJisbB3717bsdOnT5Ofn09wcPCt3JZbrsfJycluY3djxnGnPP3001RWVvLOO+/Ue/7qJvBrOXnyJGvWrCE6Ohqjse7H6qioKKqrq7l8+TIDBgy4HSXftRQqRERERH5l69atnDlzhvj4eEJDQ+1ew4cPJyMjA7jyU6Rr167l9ddfJy8vj4MHD/LGG28AEBAQwNixY3n++efZtGkTR48eZffu3fzzn/8Erqz1r6ioYMyYMeTk5FBQUMCnn37K+PHj63wQB+jSpQuxsbGMGzeOjRs3cvToUfbt28eCBQv497//fc2xdO7cmejoaCZNmsSXX37Jt99+yzPPPIOfn1+jnr1xM/WYzWYqKyvJzMykvLycCxcuNHgcd0rPnj1JSkrixRdf5KWXXmLPnj0UFRWRmZnJ008/bfeLX7W1tRw/fpyysjLy8vLIyMigT58+tG3btt4ZJwAHBwcOHjzIgQMH6szMtDQKFSIiIiK/kpGRQWRkZL0PVRs+fDi5ubkcOHCAvn37smbNGrZs2UJ4eDgDBgwgJyfH1nbZsmXExMQwdepUQkNDmThxIufPnwfA19eX3bt3U1NTw1NPPUX37t3529/+hslkqvcbb4D09HTGjBnDiy++yJ/+9Cf+8pe/sH//fvz9/a87npUrV9K9e3eGDRvGE088QW1tLZs3b27U5uSbqeexxx5jwoQJjB49Gh8fH958881GjeNOmTdvHh988AH79u1j0KBBdO3alaSkJMLCwux+UvaXX37B398fs9nME088wYoVKxg7diw5OTn1Llm7yt3dHXd396YYSrMyVFRUNH6HioiIiEg9qqurKS8vx2w207p16+YuR0RuQVVVFUVFRXh5eeHk5HTdtpqpEBERERGRRlGoEBERERGRRlGoEBERERGRRlGoEBERERGRRlGoEBERERGRRlGoEBERERGRRlGoEBERERGRRlGoEBERERGRRlGoEBERERGRRlGoEBEREbmG48ePk5iYSFBQEK6urvj5+dGnTx+WL1/OhQsXmrs8kbuGY3MXICIiInI3KiwspG/fvphMJubMmUNoaCitWrXi0KFDrFy5Ej8/P4YMGXLL162ursbJyekOVCzSfDRTISIiIlKPqVOn4ujoSHZ2NiNHjiQ4OJiOHTsSHR3N5s2bGTx4MM899xxDhw6163f58mV8fX157733AIiMjCQhIYEZM2bg7e3NU089BcDnn3/Oo48+iouLC/7+/iQnJ2OxWGzXWb9+Pd26dcPNzY127doRFRXF+fPnbeczMjLo2rWrrX9CQoLtXHFxMTExMZhMJjw8PIiNjeXEiRO286mpqfTo0YN3332XDh064O7uTmxsLD///LPdWNLT0wkLC8PV1ZXQ0FDeeeed23eDpUVRqBARERH5jdOnT7Njxw4mTZqEi4tLvW0MBgPx8fFs376dsrIy2/GtW7dy4cIFRo0aZTv2wQcf4OTkxO7du1m2bBk//fQTQ4YMITw8nNzcXJYuXUpGRgZz584FoKysjDFjxvDss89y8OBBdu7cybBhw6itrQVg+fLlJCQkMH78eL7++ms2bNhAp06dALBarcTExFBRUcGuXbv45JNPKCwsZPTo0Xb1FxQU8NFHH7Fx40a2bt3KN998w5QpU2znV69ezeuvv05qaioHDx5kzpw5vPbaa7z//vu35yZLi6LlTyIiItKkikf9lZrT5U3+vg6eXjywbu1Ntf3hhx+ora2lS5cudse9vb2pqqoCYNKkScybN48HH3yQDz/8kKSkJABWrVrFiBEjcHV1tfULDAxk/vz5tr9TUlLw9/cnLS0Ng8FAUFAQpaWlJCcnM2vWLMrKyrBYLAwfPhyz2QxAWFiYrf+8efNITEy0m514+OGHAcjMzOTQoUN8//33+Pv7A/+b1cjJybG1q6qqIiMjAz8/PwAWL15MdHQ0b7zxBt7e3qSmprJw4UKGDx8OQIcOHcjLy2PFihXExcXd1H2UPw6FChEREWlSNafLsZw42dxlNEhWVhZWq5W4uDguXboEwLhx40hPTycpKYkTJ06wbds2duzYYdfvoYcesvv7yJEj9OzZE4PBYDv22GOPUVlZybFjx+jatSsRERF0796dAQMG0L9/f0aMGMG9997LyZMnKS0tJSIiot4a8/Ly8Pf3twUKgJCQEEwmE0eOHLGFigceeMAWKAB69eqF1WolPz8fNzc3CgoKmDBhAhMnTrS1sVgstG3btoF3T1oyhQoRERFpUg6eXnf9+wYGBmIwGMjPz7c73rFjRwDatGljOzZ27FheeeUV9uzZQ3Z2Nh06dODxxx+363etJVTXrNXBgW3btpGVlcXOnTtZtmwZs2fP5quvvsLL687fv8rKSuDKMqtHHnmkTm0iv6VQISIiIk3qZpcgNSdPT0/69+/P22+/zeTJk68bCjw9PRk6dCirVq0iOzubZ5555obXDwoKYuPGjdTW1tpmK7KysnBzc6N9+/bAlT0bvXv3pnfv3syaNYtOnTrx8ccfk5iYSEBAAJmZmfTr16/OtYODgykpKaGkpMQ2W3H48GHOnj1LcHCwrV1xcTGlpaX4+voCsHfvXoxGI126dKFdu3b4+vpy9OjROnsxROqjUCEiIiJSjyVLltC3b1969epFSkoKYWFhGI1G9u/fz3fffWe3pCk+Pp6hQ4dSU1PD2LFjb3jtiRMnkpaWxrRp03jhhRfIz88nNTWV6dOnYzQa2bt3L5999hn9+/fn/vvvZ9++fZw6dcoWClJSUpg8eTL33XcfAwcO5Ny5c2RlZTFlyhQiIyMJDQ0lLi6ORYsWYbFYmDp1Kn369CE8PNxWQ+vWrYmPj2fBggWcO3eOxMRERo4cibe3NwCzZ88mMTERd3d3oqKiuHTpErm5uZw5c4bExMTbfLfl906hQkRERKQenTp1Iicnh/nz5zNr1iyOHTtGq1atCA4OZsaMGXZ7DSIjI/Hx8SEkJMT2zf/1+Pn5sWXLFmbOnEmPHj3w8PBg3LhxJCcnA+Du7s4XX3xBWloav/zyC2azmYULFzJw4EAA4uLiqKqqIi0tjZkzZ+Ll5UVMTAxwZYZjw4YNTJ8+nYiICIxGI1FRUSxevLjO+IYNG0Z0dDQVFRUMGjSIJUuW2M6PHz8eZ2dnFi1axEsvvYSLiwuhoaF2m8NFrjJUVFTUNncRIiIi0jJVV1dTXl6O2WymdevWzV3OHVNZWYnZbGblypW2X0u6m6WmprJp0yZyc3ObuxS5i1VVVVFUVISXl9cNH9iomQoRERGRBrJarZSXl/PWW29hMpka9IRtkZZAoUJERESkgYqLi+ncuTPt27cnPT0dR0d9tJI/Ji1/EhERkTvmj7L8SaQlupXlT8YmqklERERERFoohQoREREREWkUhQoREREREWkUhQoREREREWkUhQoREREREWkUhQoREREREWkUhQoREREREWkUhQoRERGRazh+/DiJiYkEBQXh6uqKn58fffr0Yfny5Vy4cKG5yxO5a+ixjyIiIiL1KCwspG/fvphMJubMmUNoaCitWrXi0KFDrFy5Ej8/P4YMGXLL162urr7hg8REfm80UyEiIiJSj6lTp+Lo6Eh2djYjR44kODiYjh07Eh0dzebNmxk8eDDPPfccQ4cOtet3+fJlfH19ee+99wCIjIwkISGBGTNm4O3tzVNPPQXA559/zqOPPoqLiwv+/v4kJydjsVhs11m/fj3dunXDzc2Ndu3aERUVxfnz523nMzIy6Nq1q61/QkKC7VxxcTExMTGYTCY8PDyIjY3lxIkTtvOpqan06NGDd999lw4dOuDu7k5sbCw///yz3VjS09MJCwvD1dWV0NBQ3nnnndt3g6VFUagQERER+Y3Tp0+zY8cOJk2ahIuLS71tDAYD8fHxbN++nbKyMtvxrVu3cuHCBUaNGmU79sEHH+Dk5MTu3btZtmwZP/30E0OGDCE8PJzc3FyWLl1KRkYGc+fOBaCsrIwxY8bw7LPPcvDgQXbu3MmwYcOora0FYPny5SQkJDB+/Hi+/vprNmzYQKdOnQCwWq3ExMRQUVHBrl27+OSTTygsLGT06NF29RcUFPDRRx+xceNGtm7dyjfffMOUKVNs51evXs3rr79OamoqBw8eZM6cObz22mu8//77t+cmS4ui5U8iIiLSpNYv+A8Xz1U3+fu2cXNixMyHbqrtDz/8QG1tLV26dLE77u3tTVVVFQCTJk1i3rx5PPjgg3z44YckJSUBsGrVKkaMGIGrq6utX2BgIPPnz7f9nZKSgr+/P2lpaRgMBoKCgigtLSU5OZlZs2ZRVlaGxWJh+PDhmM1mAMLCwmz9582bR2Jiot3sxMMPPwxAZmYmhw4d4vvvv8ff3x/436xGTk6OrV1VVRUZGRn4+fkBsHjxYqKjo3njjTfw9vYmNTWVhQsXMnz4cAA6dOhAXl4eK1asIC4u7qbuo/xxKFSIiIhIk7p4rprzZ5s+VNwOWVlZWK1W4uLiuHTpEgDjxo0jPT2dpKQkTpw4wbZt29ixY4ddv4cesg8zR44coWfPnhgMBtuxxx57jMrKSo4dO0bXrl2JiIige/fuDBgwgP79+zNixAjuvfdeTp48SWlpKREREfXWmJeXh7+/vy1QAISEhGAymThy5IgtVDzwwAO2QAHQq1cvrFYr+fn5uLm5UVBQwIQJE5g4caKtjcVioW3btg28e9KSKVSIiIhIk2rj1jyblG/lfQMDAzEYDOTn59sd79ix45VrtWljOzZ27FheeeUV9uzZQ3Z2Nh06dODxxx+363etJVTX4uDgwLZt28jKymLnzp0sW7aM2bNn89VXX+Hl5XVL12qIyspK4Moyq0ceeaRObSK/pVAhIiIiTepmlyA1J09PT/r378/bb7/N5MmTrxsKPD09GTp0KKtWrSI7O5tnnnnmhtcPCgpi48aN1NbW2mYrsrKycHNzo3379sCVPRu9e/emd+/ezJo1i06dOvHxxx+TmJhIQEAAmZmZ9OvXr861g4ODKSkpoaSkxDZbcfjwYc6ePUtwcLCtXXFxMaWlpfj6+gKwd+9ejEYjXbp0oV27dvj6+nL06NE6ezFE6qNQISIiIlKPJUuW0LdvX3r16kVKSgphYWEYjUb279/Pd999Z7ekKT4+nqFDh1JTU8PYsWNveO2JEyeSlpbGtGnTeOGFF8jPzyc1NZXp06djNBrZu3cvn332Gf379+f+++9n3759nDp1yhYKUlJSmDx5Mvfddx8DBw7k3LlzZGVlMWXKFCIjIwkNDSUuLo5FixZhsViYOnUqffr0ITw83FZD69atiY+PZ8GCBZw7d47ExERGjhyJt7c3ALNnzyYxMRF3d3eioqK4dOkSubm5nDlzhsTExNt8t+X3TqFCREREpB6dOnUiJyeH+fPnM2vWLI4dO0arVq0IDg5mxowZdnsNIiMj8fHxISQkxPbN//X4+fmxZcsWZs6cSY8ePfDw8GDcuHEkJycD4O7uzhdffEFaWhq//PILZrOZhQsXMnDgQADi4uKoqqoiLS2NmTNn4uXlRUxMDHBlhmPDhg1Mnz6diIgIjEYjUVFRLF68uM74hg0bRnR0NBUVFQwaNIglS5bYzo8fPx5nZ2cWLVrESy+9hIuLC6GhoXabw0WuMlRUVNQ2dxEiIiLSMlVXV1NeXo7ZbKZ169bNXc4dU1lZidlsZuXKlbZfS7qbpaamsmnTJnJzc5u7FLmLVVVVUVRUhJeX1w0f2KiZChEREZEGslqtlJeX89Zbb2EymRr0hG2RlkChQkRERKSBiouL6dy5M+3btyc9PR1HR320kj8mLX8SERGRO+aPsvxJpCW6leVPxiaqSUREREREWiiFChERERERaRSFChERERERaRSFChERERERaRSFChERERERaRSFChERERERaRSFChERERERaRSFChEREZF6xMfHc88999he7dq1Y9CgQRw4cKC5S2uw1NRUevTo0dxlSAukUCEiIiJyDVFRUZSUlFBSUsL27dtxdHRk2LBhDb5edXX17SuuGbWUccjto1AhIiIicg2tWrXC29sbb29vunXrxt///ndKSko4deoUAC+//DIhISG4u7vTpUsXXn31VS5fvmzrf3VmID09nc6dO+Pq6gpAcXExMTExmEwmPDw8iI2N5cSJE3X6ZWRk0LFjR0wmE1OmTKGmpoY333yT9u3b4+vry7x58+zqPXv2LBMmTMDHxwcPDw+efPJJvv32WwBWrVrFnDlzOHDggG32ZdWqVTfsd71xiFzl2NwFiIiIiPweVFZWsnr1agIDA/H09ATAzc2NlStX4uvry6FDh5g4cSJubm4kJSXZ+hUUFLBx40bWrVuHg4MDVquVmJgYXF1d2bVrFxaLhYSEBEaPHs2uXbts/QoLC9m+fTv/+te/KCws5K9//StHjx6lc+fO7Nq1iz179vD8888TERFBz549AXj66adp06YNW7ZsoW3btqxYsYKoqCgOHz7MqFGj+O9//8unn37Ktm3bAGjbtu0N+3l4eNQ7DpFfU6gQERGRJvV/Z/2NC2fPNvn7OptMxP6fRbfUZ+vWrZhMJgDOnz+Pj48PH3/8MUbjlcUeycnJtrYBAQHMmDGDtWvX2oWK6upqMjIyuO+++wDYuXMnhw4d4vvvv8ff3x+AjIwMunbtSk5ODg8//DAAVquVFStW4ObmRkhICP369SM/P58tW7ZgNBp58MEHefPNN9m9ezc9e/bkyy+/JCcnh9LSUlq1agXAwoUL2bx5M+vXr+f555/H1dUVBwcHvL29bfXdTL/6xiHyawoVIiIi0qQunD1L5ZnTzV3GTenXrx9Lly4F4MyZMyxfvpwhQ4aQlZWF2Wxm3bp1LF26lMLCQiorK7FYLLi7u9tdw2w2230Qz8vLw9/f3xYoAEJCQjCZTBw5csQWKgICAnBzc7O1uf/++3FwcLAFmqvHTp48CcCBAweorKykXbt2du9/8eJFCgsLrznGm+3323GI/JpChYiIiDQp5///zf/v4X1dXFwIDAy0/f3QQw/h6elJeno6f/7zn4mLi+PVV1/lySefpG3btqxbt4633nrL/n2dnRtUr6Oj/cc0g8HAPffcU+eY1WoF/jeTsnPnzjrXMl1n7Dfbr6HjkD8GhQoRERFpUre6BOluYjAYMBqNXLx4kezsbMxmMy+//LLtfFFR0Q2vERwcbPtFqauzFYcPH+bs2bMEBwc3uLbu3btz/PhxHB0dCQgIqLeNk5MTNTU1t9xP5Eb0608iIiIi13Dp0iWOHz/O8ePHycvLY9q0aVRWVjJ48GACAwMpLi5m7dq1FBQUsGTJEjZt2nTDa0ZGRhIaGkpcXBz/+c9/2LdvH+PGjaNPnz6Eh4c3uNbIyEh69erFiBEj2LFjBz/++CNZWVmkpKSwf/9+4MoSph9//JFvvvmG8vJyLl26dFP9RG5EoUJERETkGrZv327b/9C7d2/279/PmjVr6Nu3L0OGDGHatGlMmzaN8PBwsrOz7TZuX4vBYGDDhg3ce++9REREMHDgQDp27Mjq1asbVavBYGDLli088cQTPPfcc4SEhDBmzBiKiops+yViYmKIioriySefxMfHhzVr1txUP5EbMVRUVNQ2dxEiIiLSMlVXV1NeXo7ZbKZ169bNXY6I3IKqqiqKiorw8vLCycnpum01UyEiIiIiIo2iUCEiIiIiIo2iUCEiIiIiIo2iUCEiIiIiIo2iUCEiIiJ3XG2tfhdG5PfmVv5vFSpERETkjnF0dKS2tpaLFy82dykicosuXrxIbW1tnae710dP1BYREZE7xmg04uzszKlTpwBo06YNBoOhmasSkeu5+kXAqVOncHZ2xmi88TyEQoWIiIjcUSaTCYCTJ08qUIj8TtTW1uLs7Gz7/70RPfxOREREmoTVasVisTR3GSJyExwdHW9qhsLW/g7WIiIiImJjNBpv+FReEfl90kZtERERERFpFIUKERERERFpFIUKERERERFpFIUKERERERFpFIUKERERERFpFIUKERERERFpFIUKERERERFplP8HFsaJ6zT2FgcAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -344,12 +392,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -364,7 +412,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -429,7 +477,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -448,7 +496,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -457,7 +505,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": { "colab": {}, "colab_type": "code", @@ -478,12 +526,29 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data saved to aaaa.csv\n" + ] + } + ], + "source": [ + "barometer_clean.export_measured_data(\"aaaa.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -498,12 +563,12 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -513,7 +578,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAGdCAYAAAA8F1jjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACQcUlEQVR4nO3dd3hUZfbA8e+dmp5QQi+h944iIgKKAvbeWNvaVnFd2yrurg11seva9aeCuvZeUBdEQEXACojUIB1CJyF1yr2/P26ZnkzKZAY4n+fJQ2bmzs07QyZz5rznPa+iaZqGEEIIIUQKsiV7AEIIIYQQsUigIoQQQoiUJYGKEEIIIVKWBCpCCCGESFkSqAghhBAiZUmgIoQQQoiUJYGKEEIIIVKWBCpCCCGESFmOZA+gvlRVZevWrWRnZ6MoSrKHI4QQQog4aJrG/v37adOmDTZb7LzJAR+obN26lfbt2yd7GEIIIYSog02bNtGuXbuYtx/wgUp2djagP9CcnJwkj0YIIYQQ8SgpKaF9+/bW+3gsB3ygYk735OTkSKAihBBCHGBqKtuQYlohhBBCpCwJVIQQQgiRsiRQEUIIIUTKOuBrVIQQIlVpmobP58Pv9yd7KEI0OrvdjsPhqHfrEAlUhBAiATweD9u2baO8vDzZQxEiaTIyMmjdujUul6vO55BARQghGpiqqqxbtw673U6bNm1wuVzSkFIcUjRNw+PxsHPnTtatW0e3bt2qbepWHQlUhBCigXk8HlRVpX379mRkZCR7OEIkRXp6Ok6nkw0bNuDxeEhLS6vTeaSYVgghEqSunyCFOFg0xGtAXkVCCCGESFkSqAghhGhwBQUFPP7448keRsLMnTsXRVHYt29fsody0JNARQghBACXXHIJiqJw//33h1z/0Ucf1boY+Mcff+TKK69syOFFNW7cOOx2Oz/++GPCf9bB5kAJJiVQEUIIYUlLS+OBBx5g79699TpPfn5+wguJN27cyPfff8+1117Lyy+/nNCflQgejyfZQ2gQiX4cEqjEYdr8dZz61HeUVHqTPRQhhEiosWPH0qpVK6ZOnVrtce+//z59+vTB7XZTUFDAI488EnJ78Kd1TdO466676NChA263mzZt2nDdddcBMGXKFPr27Rtx/oEDB3L77bdXO4Zp06Zx0kkncfXVV/Pmm29SUVERcvu+ffu46qqraNmyJWlpafTt25fPPvvMun3+/PmMHj2ajIwMmjRpwrhx46wATVVVpk6dSqdOnUhPT2fAgAG899571Y7nu+++Y+TIkaSnp9O+fXuuu+46ysrKQp6Te+65h4suuoicnBwr4xTPc3nvvfdy0UUXkZWVRceOHfnkk0/YuXMnp556KllZWfTv35+ffvop7vGMHj2aDRs2cMMNN6AoSkjGrK6PI2G0A1xxcbEGaMXFxQk5f5XXr3W89TOt462faX+e9kNCfoYQ4uBSUVGhLV++XKuoqLCuU1VVK6vyNvqXqqpxj/viiy/WTj31VO2DDz7Q0tLStE2bNmmapmkffvihFvx28dNPP2k2m02bMmWKtmrVKm3atGlaenq6Nm3aNOuYjh07ao899pimaZr27rvvajk5Odrnn3+ubdiwQVu0aJH2wgsvaJqmaZs2bdJsNpv2ww+Bv6+//PKLpiiKtnbt2phjVVVV69ixo/bZZ59pmqZpQ4YM0V599VXrdr/frx1xxBFanz59tJkzZ2pr167VPv30U+3zzz/XNE3Tfv31V83tdmtXX321tnjxYm3ZsmXak08+qe3cuVPTNE279957tZ49e2pffvmltnbtWm3atGma2+3W5s6dq2maps2ZM0cDtL1792qapmmFhYVaZmam9thjj2mrV6/W5s+frw0aNEi75JJLQp6TnJwc7eGHH9YKCwu1wsLCuJ/Lpk2bas8995y2evVq7eqrr9ZycnK08ePHa++88462atUq7bTTTtN69epl/X/XNJ7du3dr7dq106ZMmaJt27ZN27ZtW70eRyzRXgumeN+/FU3TtMSGQolVUlJCbm4uxcXF5OTkNPj5K71+et7+pXV5/f0nNvjPEEIcXCorK1m3bh2dOnWyekeUe3z0vuN/jT6W5VPGkeGKr2XWJZdcwr59+/joo48YPnw4vXv35qWXXuKjjz7i9NNPx3y7mDhxIjt37mTmzJnWfW+55RZmzJjB77//Duifuq+//nquv/56Hn30UZ5//nmWLVuG0+mM+LknnHACBQUFPPPMMwBcd911/Pbbb8yZMyfmWGfNmsXEiRPZunUrDoeDxx9/nI8++oi5c+cCMHPmTCZMmMCKFSvo3r17xP0vuOACNm7cyHfffRdxW1VVFU2bNuWrr75i+PDh1vWXX3455eXlvPHGG8ydO5cxY8awd+9e8vLyuPzyy7Hb7Tz//PPW8d999x2jRo2irKyMtLQ0CgoKGDRoEB9++KF1TLzP5ciRI3nttdcAKCoqonXr1tx+++1MmTIFgIULFzJ8+HC2bdtGq1at4h6P+X8U/Bjr8jhiifZaMMX7/i1TPzU4sMM4IYSomwceeIBXXnmFFStWRNy2YsUKRowYEXLdiBEjWLNmTdR9jc4++2wqKiro3LkzV1xxBR9++CE+n8+6/YorruDNN9+ksrISj8fDG2+8wZ///Odqx/fyyy9z7rnn4nDoQdj555/P/PnzWbt2LQCLFy+mXbt2UYMU8/Zjjz026m2FhYWUl5dz3HHHkZWVZX29+uqr1vnDLVmyhOnTp4ccP27cOKtLsWno0KEh94v3uezfv7/1fcuWLQHo169fxHU7duyo1Xga6nEkknSmrYFaTaSiqho2m7TFFkLULN1pZ/mUcUn5uXVx9NFHM27cOG677TYuueSSeo2hffv2rFq1iq+++opZs2ZxzTXX8NBDDzFv3jycTicnn3wybrebDz/8EJfLhdfr5ayzzop5vj179vDhhx/i9Xp59tlnrev9fj8vv/wy9913H+np6dWOqbrbS0tLAZgxYwZt27YNuc3tdse8z1VXXWXV3gTr0KGD9X1mZma144olOBNl1pNEu05V1VqNJ1yiH0ddSKBSg1iByi8b93Lxyz8weUJPJg7r2MijEkIcaBRFiXsKJlXcf//9DBw4kB49eoRc36tXL+bPnx9y3fz58+nevTt2e/TAKD09nZNPPpmTTz6ZSZMm0bNnT3777TcGDx6Mw+Hg4osvZtq0abhcLs4777xqA4nXX3+ddu3a8dFHH4VcP3PmTB555BGmTJlC//792bx5M6tXr46aVenfvz+zZ8/m7rvvjritd+/euN1uNm7cyKhRo2KOI9jgwYNZvnw5Xbt2jet4U12ey4Yaj8vlisiA1fVxJNKB9apJAiM4jXDzO0vYX+njnx8uk0BFCHFQ6tevHxMnTuSJJ54Iuf6mm27isMMO45577uHcc89lwYIFPPXUU1aNSbjp06fj9/sZNmwYGRkZ/Pe//yU9PZ2OHQN/Oy+//HJ69eoFEPHGHe6ll17irLPOilgt1L59e2677Ta+/PJLTjzxRI4++mjOPPNMHn30Ubp27crKlStRFIXx48dz22230a9fP6655hr+8pe/4HK5mDNnDmeffTbNmzfn5ptv5oYbbkBVVY466iiKi4uZP38+OTk5XHzxxRFjuvXWWzniiCO49tprufzyy8nMzGT58uXMmjWLp556KuZjqe1zGa94xlNQUMA333zDeeedh9vtpnnz5nV+HIkkNSo1iJVRkY1QhRCHgilTpljTCabBgwfzzjvv8NZbb9G3b1/uuOMOpkyZEnOKKC8vj//7v/9jxIgR9O/fn6+++opPP/2UZs2aWcd069aNI488kp49ezJs2LCY4/n5559ZsmQJZ555ZsRtubm5HHvssbz00kuAvuz3sMMO4/zzz6d3797ccsstVgahe/fuzJw5kyVLlnD44YczfPhwPv74Y6vm5Z577uH2229n6tSp9OrVi/HjxzNjxgw6deoUdVz9+/dn3rx5rF69mpEjRzJo0CDuuOMO2rRpE/vJrcNzGa94xjNlyhTWr19Ply5dyM/Pr9fjSCRZ9VOD3aVVDLn3K+uyuepn/OPfsLJof8h1QggB1a90ENFpmka3bt245ppruPHGG5M9HNFAZNVPI1BjhHFmkAKwYltJI41GCCEOPjt37uSpp56iqKiISy+9NNnDESlGalRqEC3h9P3aXSGXJ/znW8mqCCFEHbVo0YLmzZvzwgsv0KRJk2QPR6QYCVRqEC2jsmZ7aeMPRAghDlIHeAWCSDCZ+qmBP8oLqLreKkIIIYRoOBKo1ECNklKJFqfIJwIhhBCi4UmgUoPft0YWyj721eqI64bc+xVzVu5ojCEJIYQQhwwJVGrw9/eWRFy3v9IXcd2eMg+XTv+xMYYkhBBCHDIkUKmBx6c3OrKhkuaUp0sIIYRoTPLOWwNNgwvss1nqvpwBauQuokIIIYRInIQGKt988w0nn3wybdq0QVGUiA2kNE3jjjvuoHXr1qSnpzN27FjWrFmTyCHVml/T+LfzJbKUSu6z/1/U4lohhDiURPt7fqgqKCjg8ccfT/YwDmoJDVTKysoYMGAATz/9dNTbH3zwQZ544gmee+45Fi1aRGZmJuPGjaOysjKRw6qV4KXIPux8smRrEkcjhBCJVVRUxF//+lc6d+6M2+2mffv2nHzyycyePTvZQ4vpzTffxG63M2nSpGQP5YBz1113MXDgwGQPo1oJbfg2YcIEJkyYEPU2TdN4/PHH+de//sWpp54KwKuvvkrLli356KOPOO+88xI5tLgFrzquwM2SzfsAKFC28VfHR+zWcnjcdyblpNE8y5WcQQohRANYv349I0aMIC8vj4ceeoh+/frh9Xr53//+x6RJk1i5cmWyhxjVSy+9xC233MLzzz/PI488ckDtr+TxeHC5Dvz3jkQ+jqTVqKxbt46ioiLGjh1rXZebm8uwYcNYsGBBzPtVVVVRUlIS8pVICoFdQ8s0NwBZlPNf11TOtH/LlY4Z3O/8PwBcdin5EUIcuK655hoUReGHH37gzDPPpHv37vTp04cbb7yRhQsXxrzfpk2bOOecc8jLy6Np06aceuqprF+/3rr9xx9/5LjjjqN58+bk5uYyatQofvnll5BzKIrCiy++yOmnn05GRgbdunXjk08+qXHM69at4/vvv2fy5Ml0796dDz74IOKYl19+mT59+uB2u2ndujXXXnutddu+ffu46qqraNmyJWlpafTt25fPPvvMuv27775j5MiRpKen0759e6677jrKyspijmffvn1cfvnl5Ofnk5OTwzHHHMOSJYHVo2YG48UXXwzZqG/jxo2ceuqpZGVlkZOTwznnnMP27dsj7vfyyy/ToUMHsrKyuOaaa/D7/Tz44IO0atWKFi1acN9998U9nunTp3P33XezZMkSFEVBURSmT59er8eRCEl7Zy0qKgKgZcuWIde3bNnSui2aqVOnkpuba321b98+oeNsSmDzwQrcKCgcb/uJdkpgv59T7AvopGxDUZSEjkUIcQDTNPCUNf5XnM0o9+zZw5dffsmkSZPIzMyMuD0vLy/q/bxeL+PGjSM7O5tvv/2W+fPnk5WVxfjx4/F4PADs37+fiy++mO+++46FCxfSrVs3TjjhBPbv3x9yrrvvvptzzjmHpUuXcsIJJzBx4kT27NlT7binTZvGiSeeSG5uLn/605946aWXQm5/9tlnmTRpEldeeSW//fYbn3zyCV27dgVAVVUmTJjA/Pnz+e9//8vy5cu5//77sdvtAKxdu5bx48dz5plnsnTpUt5++22+++67kEAn3Nlnn82OHTv44osv+Pnnnxk8eDDHHntsyOMoLCzk/fff54MPPmDx4sWoqsqpp57Knj17mDdvHrNmzeKPP/7g3HPPDTn32rVr+eKLL/jyyy958803eemllzjxxBPZvHkz8+bN44EHHuBf//oXixYtims85557LjfddBN9+vRh27ZtbNu2zfqZdXkciXLA7fVz2223hWwBXlJSktBgpYWyz/o+DQ8vz1/HRfYKAGb4DyeXMo6y/87RtqW8sq81Pr+KQzIrQohw3nL4d5vG/7n/2AquyMAjXGFhIZqm0bNnz1qd/u2330ZVVV588UXrw9q0adPIy8tj7ty5HH/88RxzzDEh93nhhRfIy8tj3rx5nHTSSdb1l1xyCeeffz4A//73v3niiSf44YcfGD9+fNSfraoq06dP58knnwTgvPPO46abbmLdunV06tQJgHvvvZebbrqJv/3tb9b9DjvsMAC++uorfvjhB1asWEH37t0B6Ny5s3Xc1KlTmThxItdffz0A3bp144knnmDUqFE8++yzEVmE7777jh9++IEdO3bgdusZ+IcffpiPPvqI9957jyuvvBLQp0leffVV8vPzAZg1axa//fYb69ats97PXn31Vfr06cOPP/5ojVdVVV5++WWys7Pp3bs3Y8aMYdWqVXz++efYbDZ69OjBAw88wJw5cxg2bFhc48nKysLhcNCqVat6P45ESdo7qvmkBKe2zMvBT1g4t9tNTk5OyFcije8Y+D5L0Yt8nfgBGNgxnx9tAwA4yrYMgN+2FCd0PEIIkQh13QZkyZIlFBYWkp2dTVZWFllZWTRt2pTKykrWrl0L6H/Xr7jiCrp160Zubi45OTmUlpaycePGkHP179/f+j4zM5OcnBx27Ijd8XvWrFmUlZVxwgknANC8eXOOO+44Xn75ZQB27NjB1q1bOfbYY6Pef/HixbRr184KUqI9tunTp1uPKysri3HjxqGqKuvWrYt6fGlpKc2aNQu5z7p166znAqBjx44hb+4rVqygffv2IR+6e/fuTV5eHitWBNpiFBQUkJ2dbV1u2bIlvXv3xmazhVxnPmfxjqehHkeiJC2j0qlTJ1q1asXs2bOtiuOSkhIWLVrE1VdfnaxhRWhtDwQemeiZFIcRqLRtlsPYPqfB/96gv03/z5PpHyFEVM4MPbuRjJ8bh27duqEoSq0LZktLSxkyZAivv/56xG3mm9jFF1/M7t27+c9//kPHjh1xu90MHz7cmhqyhup0hlxWFAVVVYnlpZdeYs+ePaSnp1vXqarK0qVLufvuu0Ouj6am20tLS7nqqqu47rrrIm7r0KFD1ONbt27N3LlzI24LnjqLNrUWj2jPT3XPWbzjCZfox1FbCQ1USktLKSwstC6vW7eOxYsX07RpUzp06MD111/PvffeS7du3ejUqRO33347bdq04bTTTkvksGrF4Q8slc40MipmoILNQXmTXqiaQktlH80pxi6BihAiGkWJawomWZo2bcq4ceN4+umnue666yLehPbt2xf1zW3w4MG8/fbbtGjRImaGe/78+TzzzDNW5mPTpk3s2rUr6rHx2r17Nx9//DFvvfUWffr0sa73+/0cddRRzJw5k/Hjx1NQUMDs2bMZM2ZMxDn69+/P5s2bWb16ddSsyuDBg1m+fLlV01KTwYMHU1RUhMPhoKCgIO7H0qtXLzZt2sSmTZusrMry5cvZt28fvXv3jvs8dRmPy+XC7/fX+n6NKaFTPz/99BODBg1i0KBBANx4440MGjSIO+64A4BbbrmFv/71r1x55ZUcdthhlJaW8uWXX6bU0jJFC/wHZoVlVLA70VyZrNP0qao+tvX4qon+hRAilT399NP4/X4OP/xw3n//fdasWcOKFSt44oknGD58eNT7TJw4kebNm3Pqqafy7bffsm7dOubOnct1113H5s2bAT1b89prr7FixQoWLVrExIkTa8xm1OS1116jWbNmnHPOOfTt29f6GjBgACeccIJVVHvXXXfxyCOP8MQTT7BmzRp++eUXq6Zl1KhRHH300Zx55pnMmjWLdevWWcWqALfeeivff/891157LYsXL2bNmjV8/PHHMYtpx44dy/DhwznttNOYOXMm69ev5/vvv+ef//wnP/30U8zHMnbsWPr168fEiRP55Zdf+OGHH7jooosYNWoUQ4cOrfNzFM94CgoKrCTCrl27qKqqqvPjSJSEBiqjR49G07SIL3P5k6IoTJkyhaKiIiorK/nqq69izhUmi6IFAo9MKgENh2JmVJw0z3Lxu1YAQB9lvbU3kBBCHGg6d+7ML7/8wpgxY7jpppvo27cvxx13HLNnz+bZZ5+Nep+MjAy++eYbOnTowBlnnEGvXr247LLLqKystDIsL730Env37mXw4MFceOGFXHfddbRo0aJeY3355Zc5/fTTo063n3nmmXzyySfs2rWLiy++mMcff5xnnnmGPn36cNJJJ4V0QH///fc57LDDOP/88+nduze33HKLlWHo378/8+bNY/Xq1YwcOdL6oN2mTfSiaEVR+Pzzzzn66KO59NJL6d69O+eddx4bNmyIWOEafr+PP/6YJk2acPTRRzN27Fg6d+7M22+/Xa/nKJ7xnHnmmYwfP54xY8aQn5/Pm2++WefHkSiKVtcKqhRRUlJCbm4uxcXFCSms/ejpWzlt53PW5R6V07nB8T5/cXwKw6+Fcffx63//yaDCp3jPfzQtL3qZkd0SX1wkhEhdlZWV1sqTVMoQC9HYqnstxPv+Letoa6KFZkiyqMCBT79g00t8Bg0cAkCBUkSVVzIqQgghREORQKUGNi20yChTqQypUQGgqb7uvqNShMcvgYoQQgjRUCRQqUlYRqUJ+xlmM9a1u41UlRGo5CslqBWJbekvhBBCHEokUKmBEpZR+YfzDXrZNkFGMxhgbJyYlkOxLQ8AV8n6xh2gEEIIcRCTQKUGSlhGZZjNaIZ08hOQFaha3+XUq8Dd+0M7LQohhBCi7iRQqUF4oAKwps0p0OukkOuKXfqSLVd57A0VhRCHlgN8UaUQ9dYQrwEJVGoSNvWzWWvO4j63RRy236VnV5atWM6eMk/E7UKIQ4fZ1ry8vDzJIxEiuczXQHir/9o44HZPbmxmRqXS3YytFU5u9v6FG1pE9kmpSNe707ZW9nDGM/OZ+/fIds1CiEOD3W4nLy/P2hwuIyND9gEThxRN0ygvL2fHjh3k5eVht9vrfC4JVGpgFtNubH8a6wfdwjHb93NU1+YRxw3u2wc2QytlD+t3y6coIQ515i7w1e3+K8TBLi8vz3ot1JUEKjWwYdSo2Owc36cVx/eJ/oS3aNcFgNbK7sYamhAihSmKQuvWrWnRogVerzfZwxGi0TmdznplUkwSqNTAzKhoSg1Pdo6+6qclewPBjRDikGe32xvkj7UQhyoppq2BterHVsMfmqyW+DUFh6LSjOLED0wIIYQ4BEigUgMrUKkpo2KzU6zonWqbK9KdVgghhGgIEqjUwJz6UWrKqAAZTfT6lc7pUkwrhBBCNAQJVGqgmPUmSs1PlZapL1vO8u1N5JCEEEKIQ4YEKjWwdk+OI6OiZBmBin8vXtlFWQghhKg3CVRqoBBnMS1gM/b+aa6U8Ois1YkclhBCCHFIkEClJqoeqNhsNa/kVsxAhWLeWCSbEwohhBD1JYFKDcxiWpu95qfKZkz9NFNKqPD4azhaCCGEEDWRQKUGZqBijyOjYss2p36K8UiNihBCCFFvEqjUwOyjotjjmPrJ1AOVZtJHRQghhGgQEqjUxJr6iaMFdqa+WWFzSgAtgYMSQgghDg0SqNTAzKg44sioYPRRcStesqhI5LCEEEKIQ4IEKjUwA5W4MiquDCo1JwC5lCVyWEIIIcQhQQKVGigYxbTxZFSAfWQBkKdIoCKEEELUlwQqNTAzKvEGKsVaJgC5SmnCxiSEEEIcKiRQqYEdc9VPHFM/BGVUkEBFCCGEqC8JVKqhaRo2M1CJo4U+BDIqMvUjhBBC1J8EKtXQtKCMShwN3wD2aZJREUIIIRqKBCrVUIMyKtjie6rMqR+pURFCCCHqTwKVamgEMirxbEoIsM+Y+mnllD4qQgghRH1JoFKNkIxKnMW044b2BKCVSwIVIYQQor4kUKlGcI2KLc5iWiWjKQCZ6v6EjUsIIYQ4VEigUg1V04KKaeMLVFR3HgBZEqgIIYQQ9Zb0QOWuu+5CUZSQr549eyZ7WACoGrVenqym5QESqAghhBANIb4K0QTr06cPX331lXXZ4UiJYaGFZFTii+nMqZ9sTVb9CCGEEPWVEhGBw+GgVatWyR5GBFUDm6IBoCjxPVWuLD1QceMBbyU40xI2PiGEEOJgl/SpH4A1a9bQpk0bOnfuzMSJE9m4cWPMY6uqqigpKQn5SpSQjEqcq37cGTmBC1Uy/SOEEELUR9IDlWHDhjF9+nS+/PJLnn32WdatW8fIkSPZvz/6m/zUqVPJzc21vtq3b5+wsQXXqMS76icjzcV+LR2Ad+YvS9jYhBBCiENB0gOVCRMmcPbZZ9O/f3/GjRvH559/zr59+3jnnXeiHn/bbbdRXFxsfW3atClhY1PrsNdP00wX+9EDlVfnSqAihBBC1EdK1KgEy8vLo3v37hQWFka93e1243a7G2UsddnrJ81pp1RLBwWyFWn6JoQQQtRH0jMq4UpLS1m7di2tW7dO9lBCalSIM6MCsJ8MAHIoT8SwhBBCiENG0gOVm2++mXnz5rF+/Xq+//57Tj/9dOx2O+eff36yh2bUqOirflDif6pKjRqVLBomo6KqGsu2FOPxqXU+h6Zp/LJxLz9v2IumaQ0yLiGEECLRkh6obN68mfPPP58ePXpwzjnn0KxZMxYuXEh+fn6yhxbSmbYuGZVspWEyKi98+wcnPfkdN7+7pM7nmLNqB2c88z1nPvs9s1fsaJBxCSGEEImW9BqVt956K9lDiCkkUFHiD1T6d2kP6xc2WEbluXlrAfhkyVaeOH9Qnc7x/i9brO8//HULY3u3bJCxCSGEEImU9IxKKtOClifXJqOSk6c3fWvmrGyQcTji7IpbraDZHkWp/+mEEEKIxiCBSjWCV/3UJqOipOlN3zLVsgYZh8te/8hCDapLsUmkIoQQ4gAhgUo1VFW1WujXJqNiBirpWv1rVDw+la3F9c/MBAcq0eKUS6b9QMHkGWzaU/sx+/wqN76zmLd/jOwovGDtbv7y2s8UNcBjEEIIceiRQKUaquoLXKjFqh97ei4A2VTgV+u3wua9nzfX6/6m4GGEZ1T8qsbcVTsBOOu572t97i+WFfHBL1u49f3fIm47//8W8uXvRfzjw8jbhBBCiJpIoFINVfUHLtQio2IzAxWlvF5LigH2lnvqdX+TVk1GxacGxri9pKrW567w+ms8pi6ZGiGEEEIClWoowYFKLWpUHEagkkUFHn/9AhWbonC67VtmuG6ji7Kl5jvEUFNGpT4yXDU/N9K5RQghRF1IoFKNumZUHBkNl1GxKfCY61n62DYwyfFxtcdqmsaa7fvxRQmOgmtUwgOThgxUgs9VXWO5HSWV7C6tffYmFvOxhz+WWNfX5ryrt+9HredzFMumPeWUVvlqPrAe/Kr+HMT63UiUbcUV7CnzsHr7/pRqMmg+H/GMSdM0CnfU7XnbW+Zhy76KuH+WECI6CVSqodWxRkVx68W0WVTgrecbg0MN9GLppWysdgrltYUbOO6xb5j8QWQ9SPAb9Vcrtse8rS7SnYF2POWewHP25g/RN4ws9/g4/N+zGXLvVw32B/yl79Zx3GPfcNsHS0Ouf3pOIcc99g13flK3DSKfmF3I8Y99w70zVjTEMEOs31XGyAfnMHzq7AY/d7A7P1nGcY99w3GPfcPf3lqc0J9lKi73Mnzq1wy+ZxbHP/YNT8+JvndXMvzrI/35eGbu2hqPfeenTYx99BuufePXWv+cQffMYsT9X3PcY9/w2sINdRmqEAIJVKql+us29UOaGahU4vHW79Nyk4pAMa0THz+u3xPz2P98tQaIXoAbnNlp3yQj5DZfPQMVlyPwaxT8c56ZG/3NKXgFUFU9M06mR2etBuCdn0If+8Mz9ev/uzByRVI8HvtKv//L89fVY3TRfVu4C4D9lYnNqAQ/9hm/bUvozzIV7iwNuWz+P6SCN3/Qnw/zd6Y6z3/zBwBf/l5Uq58RHvw/M6fmoEgIEZ0EKtXw++s29YORUbEpGv6KknqNIcOzy/o+TykNCQrCVdcepTKo4DX8j2h9pzWCf25w4BErWeK0Bx5DuafmQtx41DfYSoqDeDrAGdb7x2FLvd498WTz6jrq8ALzNKf8qRWiruTVUw2/X/+kq6LUrp2rw43X2J3AV89AJc1XbH2fRylue93+yyq9gQDCq4ZmMRryTT6empzgQCl4qqg+ElVDIurGHhaYOOv4e5tsdW2OGP577XbU4oOOECLEgfnXo5FoRkZFre3TpCiUoe+grFYW13Bw9XbuCKScHYoas4mcz6+yqzT2UuZKX+AT3h87Qzvm/ral7mPcW+bhjGcCvVfMVU5+VWPLvkB9jfnp1edXQzZXPOqBOdw3YzmapvH+z5v5x4e/sXxrCX+e/iPv/BiocXl1wXoKJs+gYPIMHv8qNGXv9ashwVasoOXOjwN1KvMLd3HD24t556dN3PTOEirCMjtFxZUUTJ4Rcl34J/DdpVUUTJ7BWc9G7z2zcXe5NeY5q6JsBFnDm+CG3WUUTJ7BOc8viPrp/3+/FzH20XkUTJ7Bn6f/GJEpe+enTVz3ZmRtxZfLQqd/zJ9TMHmG9X/xwS/6/0XwOX9cv4e/vfUrj85abf0/XPfmr/y8YW/Ezwj+v4Pql7Dvr/Ty5+k/MmjKTOYX7op5nGnm70XWeI99ZC7//PC3GgPVCo+fm95Zwj9r0c9HVTXW7AhMYZ305LfV1nP9unEv1735K1v3VUT8PtU2o7KqaD/Xvfkrf4RNodWHqmrc/tEy3vkpeu2YEKlKApVqBDIqtX+aKhQ9UPFX1q+N/uYtoUuSgzMswT5duhWAwcpqWhD5xtGxWWbI5R37A3Uid3xct0JTgIdmrgq5XGVkbr5cFn1O//1fNvNT2Bvb/327jt+3lnDTu0t4Y9FGTnjiW75euYNb3g8Uxt7x8e/W948btTimd8PqUpZvi57FemVBoKBx4ouL+PDXLdzy3lLe/2Uz079fH3LsC0ZtQrDwN+T7jALbnzbsZePuyABy/H++sb6/dNqPUcdUnctf+QmAH9btYeEfkbVJV732M4XGG+nXK3fwmfE7YLrlvaV8smRrxP3+8t9fQi6Pfniu9f3/fbuOxZv2ceM7+v/FF0FBzdnPLeDjxVt5Yrb+/D/+1Ro+WbKVM6MEasHPtWlPWfRA+qk5hXy9cgd7y71MfHFR1GOCXfnaz9b3a3eW8fqijXy+rPram+nfr+f9Xzbz+qJAvU5NObivV4YGl8u2lDBreexaldOf+Z5PlmzlxncWR0xp1jajdNZz+rkuqcPvTSyzVmzntYUbuOW9pTUfLEQKSfruyalMU+uYUQEqlXTQQKuq3yeiPCX0/rbKfVGP213qYbRtMdNdD7JY7Qz8KeT2JhnOkMvBUzR1afJm3TesNb7HyELtKQs9p2JkD7bui95Kv7KaT9w1fVouKg7dpbouy313hS2V3rw3MvAIzwoEf9qOljGob/1N8PnL4nhMu6vJqFUnPFmzr9wb9fv6qvJFfz4aYnuFmn6Hd+6v/e94SWXkYy+Jo/B53a6yegcqZoH1xgZslLi9RLaxEAcmyahUoz4ZlSqbnlHRPPvrNYZcJSwj44meobEpCsfb9E/gA21/QFiA5PM3bO8UU3hxr1VMG2Naw6dGr2EJr2mIes4YvGGPJTztHg9HWPFntGcnvM4geOm5muDC2Oqen4YeQ/DzHc/PjZfXF3189gbYJDNWEGRyOiJ/Rk1PV7TgwhVnwBH+Oxj++5UMVd7G66EjREOSQKUa5vJktRY9VEyVRqDiKa9foJJHWEbGG/0TlqKAWwn6RF0SOmUU3s8l3kCl0uunqLiSrfui94RxhwUqVmYk7F2gcEcpXr+K1x/958YazaY95ZRFKbgNbhbnDQtkzE+zxVGyAbGyMxt3l7NpT7lVCxLtTSw4yNI0jZVFgf9b82fu3F9FucfHsih1P1uNmh2/qrFhdxnfB9VjhGcVtu4LzRJt3lte4//Z5r0V1d4er+AMVUMu1okVTGzfH/rYVxXtj/npP1bx9YZd5SE1UaD/H23cXU5xuZelm+Kvw9pT5qGk0huxcglqDogA/Cp8F1Zr89uWYtZs38+24oqYj2HTnnJUVYuYRqxrw0FV1SjcUcrWfRVs2lMekrVctqU45JzbSyqrzWqCnqncXVpFpdfPj+v34PWrbN5bTuGOUrYV1/93b1txRb0bZCZCaZUvIuMqGpdM/VQjUExb+4r9HZUOsMGHi1Yz9JS6jyF86ueTH9cw+NjI42yKQltld+CKsl2Q38O66PWrdFM2M872I6/7j407UDnpye+sOohBHfL48JoRIbenOUOfm1veW8pP/zqOeat3Rpzr0mk/0q1lVtSf82pYjYhp5INzOKpr84jrh9z7FWv/fQJ2mxIRQJV7fHj9KgOmzIy437Pz1jJpTNeI679YVsQXy4q45MgC7jqlD/4omZ8L/m8R6+8/EYD/zA6tk6nw+NldWsVh930V9XEAHHn/13w8aQTPzl0b0ZfjiKmz+fqmUXTOz2LrvgqOvP/rkNtv//h3vivcxfMXDgXg65WhTftAr8O4enQXWuakxRyDSdM0azou3F2fLre+N1e91PQmtnVfBW3yjLqsGL9b985YwSt/PjzkusWb9jG/cHfIdeMe12t75tw8mk7NQ2urDr8venO8t3/axNs/beKdq4ZzeKemgN4n5cmvq28098aijVwwrIN1udzjY/A9swB48aKhEcff+v5vnHtYh4jrg+0qreK5eaF9U/aVeznuMf1xZbkdLLt7XMjtH/26hevfXhz1fMc/9g3XjunKzeN6RL09lrs//T1qrRDor+uzh7TjobMHsH5XGaMfnkvbvHTmTz4m5vkG3j2z2hWCn157FP3a5dZqjKbfNhdz8lPf0at1Dl/8bWSdzpEo5uP+9fbjaJLpSvZwDkmSUamG3+hMW5eMyn7NDUAm9fuk0dSu379K02tM9pdELxS1KZDPvsAVVaGZHJ+q8ajzGW52vsv1jvdD/uAc3T0/5s8vDKqT+HXjvojbu7YIDTzMlUe56ZEv6O8Kd8X8ZPjR4siiz+D7RWO+eYZP/VR6/TGbqD30v1VRrzeZRbUZ7upj+PCC3nKPjyWb91V7H4APf90Ss3mYeX2s7sP/+z0QnDw/L7LYF2DhH7ujXh8u3kZ75tTPjhpqQNbvDkxJxvpUHC14rW4FylfLI4OxmuqP3voxUCxbU5AC8Ois0N+H4KxUonrzRHsMT9XQubem26OJFaSY3jUaQ5qdqsMzUuFqej4++LXuO71/+KueAV4RoxA+mczH/fvW1BvboUIClWrUeXkyUK7pn2ozlfqlDLOM++9E/6SSHuN8iqKQE1zPUhX6ovL4VPrZ1gMw1v5LtRmV2rS1j/WpvCJGR96G/NNv1mREm/qpb91DrDqXWM9NhdePEkd7sOoa9pl1RA1RPxTPct14mIGKv4bfieAaqIZK34fX3MQ1/VHLp666hxVrmicRPXsaok6nruJ5ucfzNyG8Du5g05D1WqJ2JFCphrkpoVaHjIrZRyWD+lXauzX9/ru0nGrPZwNyCPokHta/JXhTNb9mC3kzDH+jr80bpfkHrLOylRwCgVKsN8KGLDo1Z2fCP+mVe/xo9QyJYtURVMYoSIx3hU91xZjmFFZDfJKv6RzlNUzlmMypn2hTYcGCMzRV/vqtdjKFB0fV9WKpq+p+H2NNd4U3TGwItiS+CcbzmoznVzJWofyBLPhvoQQqySM1KjG889MmXv/fcka561ajUmZN/VTiV7U6/5K71QpQYJemZ1QyYmRUCrftwq0E3lx37N5Fi6DbHb5AEKEQ+ibgU1Xy2I8DlV3k4te0mL8YBZNn0LVFFteM7sKiP/bw9k+b6KBs52v3zfg0Gz2qXqGk0sucVWaa3/w5+uOv65470fhUlTmrdlhpY9N/Zq+JqCEJdvKT39V47liB1sJ1u/n7u5F9KG6LshFkNL9vjV3U+eTXhdwwtnu1DfiqfH7cDjuL1kXf8+nv7y7l/779g2Vbqk9TFxVX8NXy7azZUX2x91/f/JXXFmyIqBUJd8fHyxjbqwXLtpRw8lOxn9+CyTM4tmcL2jfNiOhdE+7BL1fhdtj5Y2cpt5/Uu8bjAT74dQtTz+wXdyfYvWEF11/8FpiWu/X96P+nPf71JVPP6Mfpg9pyz2fLGdu7Jb9trl3TxILJM1hw2zG0ztU/0MSzmMhsQPi3Y7vRvWU2P67fw+0n9cZuU9ixv9Kq33np4qFxL4f+9+crovYMem3hBnbtr+KaMV2465Pl/LoxsjdTuA9/3UKVT2Xzngp+WL+Hb/4+hg7NMmIcu5nlW0v4xwm9YmZlQZ8GfeDLlTTPcrPRKAi+ZXxPBrbPi3rOFdv2c9uEntWeE+DRmatolZtOyxw3T8xeQ+f8LI7p2YLv1+7ithN6ke60M+XT5SwImkpNZpyyY38lj/xvNROP6ED/dnnJG0iSSKASw/pdZdjRPyGUe2v/CbdTm5awEzKVSrx+FXtt9goyeD2VuBT9DXO3EaikEz1Q+XTRCu4IqqFcsW5zSKDi8gcCFbfiDfmk4PP5meH+B80pZkzVozVmVAp3lHLjO4Husm+57gH0zrk9lY3c/8VKADop23jPdRfrtNZc4PknHpxRz1dXflWrUyO1eDrxxsqQ3Pre0nqtAAgEcLFu31FtHc1/F27ksqM6xbzd41drDFJAn2+/85PfazwO4If1e/ihms0wAbYVV7KyaH+1QYpp9sooXXpjuOczvbC3TV56jfVFple+X8+VR3eJ+2cEe+yr+DZPvO2D39hdWsXrizaGNJGrjfNfWMjcv48BarekPjgIH9Qhj1MHtuWaoCZ+l73yE9lp8f1pjxakANz+kd4E0mlXrE0ca1LpVfngl8CHhste+ZFZN46KeuwNb+t/P0Z0bc7oHi2iHgN6R+rPloY28zvt6flWUXusc46qpu5uVdF+ngirX1qyudj6wOOy2+jWMjtix+tkZr0mv/8bX6/cwds/bYr62A92MvUTg8Nuw2YEKnZH7eO58YP1P5QZVNY5lV9eFvi027Wz/ubULS/6f1mOElqA6fCGflJ2+wKXcygLmU9O85fSVtmNW/ExzLai1uNtowTexAbb1rBmu/6zrrZ/QjNlP0NtqznaFshC2FD5t+NFXnHeTx6Rn+ifOaMAhTj2DEpg7xIzUPl72EqLHbVoHNYmt+bVN+Fqatq2Y39lg9RIlFU1/DRKIneBjlboecbgtlGPNQtia8oC1de6XfVrxrY+aBmyJ8rS/3iYjeyWhgXf9fm/CP792rSn7osBghsWxlJcUX1DwdI6/J7uruGDRE37i/2xqyxqE8Jk1hGtKqpfm4sDnQQqMThtCnZj2kKpQzYkLVPPgGRSGVEDEq+qMv2TsUdz4M7Qz2fXor+wQ+pTALs/9MWa5g/80UhTvGi+wAsx0x/4I9dMKanXG2FHZbs1n32kPfCJfYQt0KZ/tG0xFzi+ZpR9KX+yhy7nPcs+jwmfj+BZ538izn1GhwpudLxjrW4KL94L775bH2Y9xNheLet8jr+N7Vb7O9Xwt9BltzVIrUa0rqv1Vd0bwIAoqfraiPZhNtanZjMjGO19Jd5MQzzi6akSr1i1T/GqTQF8TYJrcBryMUZT06aPrjo0yqvpg1ZN04KqpiV1mieaRDeUTHUSqMRgsynYFP0Fq9XhabK59WW7GUplnYvvzEClQnGDQ695wRf900L4aiC7P/QTQXCgAoQU22b5A/PPOUqZ9UKPp6jWFpb5aKvs4vetxeRQSjslsKy4pxJYhjraFpg2GmsP3XfmKvtnKGiMt/9IRyVQL+DGwz933cp1jo+Y4pwGBN5sFVQedDzPx9p19FAi09RNKaG/spZ4l4Rs3Vdh7UuT4ar7rrfprtq/Ke4rrz6jsmlPedRl4rX1Uw1TOXUxt5pprbq84QSL1gI/VvPAP3aW8dvm4ojNNyH6/+eG3WXsKfPUus1+rGXktT2HX9Xq1OIf9OyRX9UarNP0mu37Qx5XPFmR6qiqxg6jeZ+maazbVcbeoD2fdu6vYtOeckqrAoHz5r3lbN1XwZrt+2MuCf5+7S72lHko9/jYXlJp/QwIZB92l1bh9asUl3ut15WmaTH3nDLtKKkKaeZo2rinnCqfP+T+O/ZXsnTzvoheTjtKKkOCx3KPL64PB5qmhTyWnfur8Kta1Gabe8o8KdkgLxGkRqUaZo1KXVb94NLTzplUsWZ7KS2yaz8N8L9f13I5UEE6ihGolJVHb6EfXrtiV0Mvu9WwP6rewHmy/IE/BtlUWBmV8O6o0bQi9A2vnbKTSo9KNyW0DqGLLdAnpYctELT0VDZix48fO/nso5stMMd9pO13NvhbATDMtoJmqh74TLD/SJa3nBOf0Oshjrb9xjmOeaDBPxxvcLF3snWOHMr4n/sW8pUS7vH+iZf8J4SM60jbMs63f83Lvgn8qukZkOBma+l2FRtqnZaopztrH+T8+/OV1d7+0eKt1facideP62sujqyt6opd6zOFAKE9ZGqy4I/dMWtlWuemR+wLNOqhuXUa05JaFtBGM/LBOfW6//Tv11Pu8cW1KiceZlM6U317h3T+x+cAvHDhEBZv2sczc0Mb4U35bDlTPlsect1RD9T8nFzwf/rmlc0yXewOCzxe+m4dRSWVzFi6jS75mewoqcKvaSz6x7E88OXKGgv61+wojRqg/TVoJ/JvbxmD3aZYfyvG9mrBixcfBsCnS7by1zd/5cIjOnLPaX0B6H+X3jRuxZTxpFfz4eeh/63imblr+ffp/ejRKpszn/2e0T3yrf5Upm3FFQyf+jWdm2fy9c2jq308BwPJqFTDZgUqdfhUbQYqSkWN87CxqMa+PuWk0SwvGwA33qhp3pbpodc51OoDF19lIHDJVgN/jHKUciujEs+GaB1toW8gbY0sSoGRDSlv2guAFso+a/lyp6BMSZripbOiF8t1tYWu3ukVlB053Bb6Bt5HCRS6mXscAQy3/R6yhPtU+3zyFf3xXe74nOCsSjqVPOV8gpPtC3nB9QhuQv8Y9FA20uy5fizLu5nWRDZSy6SCdw8vpIMS/U00z7eTj4aton2M21uxm384XucoW/TVJXb8THa8yb8dL9KU6G8Yo1pU8ILzEe5yTMdJ9KmXfPbxlutefu02jdzwLRmCHK6s4Jm81+mlbIh5DGhcav+CWa2eZrit+mLc7somnnL+h7873mJnSU27iGscm7465nMZ7fiBeRVx1TKZBiiFPD+ygto2W5k0pgvDOzer1X0ARnRtRlujW28ivfNT3RutNZYnvl4TEaQ0hPAgxTTDKMBdu7OM/VU+yj1+tpdUNtiqwy+XFTFnVeDD2FcrAt9P/VzfVd0sxvWrmvU3dVOUzU6Dmc/RnZ8s4xUj8I+WqTR39v5jV02vq4ODBCrVsNUno+LWA4tMKqOm7eLh9Om/1JnZueRl6+dz4Y3aVbRVetgmaGGBiVMNfUF7K8uCbgscm01gT5l4ViJ0CMucNFVKyaCSjsYbTkWzvpDdGoAuylYyqaCFsg+AVWo7AHor663bg/W2Bd4we4VN6fSzBVYr9LcF/gC6FD8Dgi4fZgusFGmt7An5GYfbVtHU2KIgXykJKfgFuN75AUrFHjIqi/ir48OIxz6/4EUOW3oH77vuihIAaPSd82cGLrmbN133kR7R/0bjBdejXOmYwX/THuLR0ZGdfC+1f8lfHJ9ygeNr7nO+FHF7uybpvNL8vxxv/5lLHDO5zP55xDEAdzmnc4RtOU02zeKltjOiHtNZ2crrafdzQuUM3nT/O2ZAc4ztV+50vka3ffN5M+sJumVGz5S48fCy6yFOsi9ikuMTrrZ/EvU40/oRX/GSdhfz0v4eM3AzNUtTWN/zObq+NpR1aX+qMWACWDBqOR+776DlB2dyp+PVGo83rb53An8f15M3rzyCI7vULlg577AOzJ98DGvum1Cr+x2MUqHEwhNjU8y68KpqzFqX8MLouvz917TqFwukwvPZmCRQqUZDTP1kUFXnYlq7Xw9UfPZ0nG79k5lL8UVdOmvWpHgVfYooPDAJD1x8VYHI3qEFByoVVqAST1OwaJ+AWyu7KTAyLd6cAmjaxTq2wDi+zNGEn1R9RY053WMFEd30fVB6KJswP/1a00Vd9I2O+trW6WPHR3dF/0T5h6MzAL2DMgL9lNDll8NtgTTzIFtor5Ujg97wFFSOUALHTrD/EPLpvS07yStaAEC+UsxZ9nkh5zpcWUn6Xj1Iaqfs4iT7wpDbhyir6W88BlQfAza9RrgL7bOs74+3/URzQqcaeti3wR+BNPmfHF8Rni3IpZQJtsAS7v57/xd1W4dL7P/DaRRq57E/4vGYrnJ8Frjg2c+J6tdRjzve9lNIjdLljs9xET2z2EdZBz/rdUeK5uMex8s4YmSHAI53/ATrv7Uuv+m6r9rMSmt20+qH+63Llzr+x2AlvmXIzg3fwIdXw6IXrL8H8TILIOPtaSISqyEb0nl9Wswu0+G7VNdlRZeqadUWSDdk8fSBQF5B1TD/MNWl4ZsZqDgVP35v3QrlXEag4ndkYHfqNS5uPFH7eDiMQKXSqa8Ocmqhx7jCLv+xNfAm4gxaSZStlFtLcJdu2lfjGDsqkT0xWil7rEJYb15HaKovrS5QttPJmObZm9aOQq0NAF2NAMUKVLqPQ1UcZCsVtGIPWZQH3vT6nQVADyM46aZswa34KNEyWOQeDkAvm559yaGMTubU1OFXAqHByWBF/365sx8AQ2yBN69uyhaaKKVgd4HdTROl1AqIAI6yB1YxAYyz/xRy+XR7aI3EOFtov5fRdqOgOFff4K7D9q9DCpPbKTvpaNuBV7OzWm2LXdEYZw89x1Haz/o3HY6kSkmjnbKLvsq6kGOOsC3HpmjQvDs07YJLrWRUUDEz6FNMp9rn6xd66TtonmGPrPFoRjHDzCm4UXod0InqNxHHAZxmnO8J32nstTcjTyljtG1x1GMn2o2NBrtPwJfWjE627Rxj+zXqsQB/Uj8FoKLlkKDHuSLm8Rc5ZqJoPigYCQP/BMCVjuiZpWDH2H5Bee00WPIGfPF3Jha/UON9TAoq7TZ+AjNugpUzaNjNI0RdnPLU/AY712Nfrea6N0N/Rwsmz+CfH/7G/qC9nAomz6D/XYHNUW//aBnXv/UrI+7/mpEPfs0nS7Zy9INzGP/4NyElAqoGnwc1Hwz24/o93P5x4ENVweQZ1pLs1dv3c/tHy2LuPn6gkkAlht6tc7AZf1xyMty1P4Ez0MNB8dRtDbzDr3/y9dkzwKFPDbjxsSxKwzKnqv9ielx5+uWgwERVNVxh9Rc+T2DqJziIyaLCava0M47GZu2jBCptlN1W5sSb0wma6pmOjrbtVu2KI78bO9OM3jBGANDZZjR2atmH0kz9DbybbQvdFD3jUu5uAR30YKSzshU7fiuzslzrSJse+s68Zkalj7G3EXkdoOtxAAwwMiwKKgONKaJ9A6+07mdO0Qwz3/g6Hql/EVonM9Kcnuh/LgCDlMKQ2pijzOXYY+8C4Ejb8pCMwhFmZufom8Cdg9O3P6Q2xJzO+MPVnS9sI41zhAZHR6iL9W96n8LuVvoxY8KCAWscncdA93HGdaFTK/2VP8hVyilTsuDER9BQ6GPbQD6hBbfmYy5v2huO+AsoNropmyLqd5z4rMf3hX8YO9rrUx/Rgw+NMXZjzIddRmmPMwAYHxaUmdqwiz7qakDBe9arvO0bDcBxtp+jHq+gcqbdyL4M+wsceS0Ax9p+qbZex4GP+5wvAxq0GaSPqfRD+oZl6GKZ4pjOkF8mw48vwlsX8Df7B3HdL5RGC/ZGmTY88BTWc/XQgaKm5n+L1u3ho8Vb2bKvgk17KrjuzV/ZuKeclUX7uXTaD3H9jLOfWxBx3Q1GA86Tn/yO1xZu4G9vxQ70D0QSqMQwqns+Fw3TG0o1y65DQZzdgUfRgwvNU7eCJ6cRqPgdGeDQMyqx0ucOI1DxuZvox2mBwMSrqrjD7ucOut0R9H2GUsUqo2Fb+ILS8w5rzw1juwddo9HdGVno1UXZSr6iB1OV2R2sQKVAKaKTTQ9UWhb05p7LzwT03ishy5mbd6ckS58u6qZsobtND2TS2/aBvI6Ua27cio8CpcgKSrr0P5KjR+pdPrvZtuDER3/zTaXNIGg7GICutq1kU04XZSs5Sjl+RzpHjr+AyrQWOBSVvka9zNUFxqeZjkdZwZEZqNw6rivj0o2gZeif8WW3w6n4rdvbKTtpb9sJih0OuxxfRksylCqGGvUy6VQy2G6MrfNoKxAKnpYyMwQFQ8dz0XkTARjhWI35yfyWYzvS02MEIV2OpdVgfTVTeKbH6l/TeTR0OQaAo+2/EfwJ3wxclrkHQFYLtNYDjOtDz3VNO33MGb3HQ3oTaKtnNJ4/MjRwHqgUkqlUoaY355aLz6DbkacBMDLs54IeHLZW9oAzAwpGUtZF77o51vZz1OJgK4DpeCQ5+e0YNk4PFM/Ijp5R6aOs12uiXFnQ7Tho0Qtv8944FT/Hh2XBgt3aZaM+rsx8uPRLKyC9yfFuzPuYjrP9xIWOr0CxQXc9SLvB+T5DlPg66wI8ckwGP7ecyg9pk1ieeTXXO96rVeEw6M0Kbx3fk69vGsVTFwziP+cN5ONJI3juT4M5vnfd+wMB3H9Gv6j7VsWq44l3t+5D2S9xtB1Ic0Z/y/7ZaDdgPs9LG2BFWiqRQCUGm03hyM5Ngbo1fAOosun7XCh1DFRcqhmopINdz+q4FW/UhkYuI1Dxp+mBSvAKFp9fI43YNSvBQU1wVsDr13DhtaZx7j+zf0gTs3+NzCHdH5ktMj9N79Gy8LtyQwIVM6OiNOtCk1YdwZ2DQ1E51vy0ndEMMpqyL0u/T1dls1GrAkqL3mCzsUbTA8huyhar4Da/61CUvA6QlosTH3cdYaefWQPSeiBkNremWfra1jHIprfQtrcdAnYHaQV6NmagrRDQaLPP+IReMAI6HAHoXXcBru5eitOzD9w50HYIjq6jgUAWxMqWtB0M7mwcXceEXD/Etga75oPc9pDXEQqOCr0fmvW9u+vRNOk6DBxp5Gn7rOmxizrsRvFXQVZLaN4NW1c9CBmsrLFqUNqwi862Iv0Ns2CEHhDZnLRTdoUUQY8wGvMtdenBnM0IaPTAwqTRrcx4TrqO1f81jutf9TNHdW1uHWkGS7YuoxjTsxW2ghF4cNBW2W2t8DJZGaBOo8CZhrf1UHZqueQoFRweZTpnvN341GlMURUcdiLYHORVbIi6usr6veo82upF5Ox3OgAn2BZFHG+6ItOY+hpwPjjTYPRkVBTG2JeE9PcJp6Byq+Mt/cKRf4UL3oJBFwJwt/MV4pkCasVuTvj5CpoV68+j4q/iescH/Mvxeo33NfVslc2kMV25enQXOqdXcBLfcao2hwFZxYzv25oXLhrK4+cOjPt8/zqxF11bZFmXzzu8A0dECUqOq2cAJKoXq4A3vAnkwdYgTgKV6hi7J1OX5cmAx6ZnYjwVdetFYDdW/fidGdYfWTfeqJ1jzUCFdD24Cs6YeP1qZKDiDxRUOkMClSrMP6Zbiyt42vkf5rlv5AL7bL3U/Ku7ecL5JPnsJb8s+sZ/A40VOeu01voLxqhRaaqUMkgx9tho1lVvHZqvF9SeYL4BNdczNnsz9UBFn/oxakNa6EudVxurhXoom+hprgZq2Vc/X6v++sXy1YFCWiN1b2ZVBiprrfoU2g0N+XeQrVAPBsp26lmstkOg7RBUxU5bZbc+zbHWKGAtGAl2p/4mSyAjYtVLFOjTMXQ0MzKrjNuNgKTgKH3MHUdYt9tQ6aDsoK2yG83mhPZH6P/37Q4zjtGzNq6tRnFuh+H6OZoUoDXphFPxW9NWI8zsStshkJar100Zj9MKhPAwyHguljj1544uemClT/XovwtdlS0oZTvBkW6NxQxU+GMeTlvgdzIkiwPgymCJ0ivonAHH2I1AwpiWstvtfO3X/7+ODZsqymcfQ80i2F4n6/+m5UL7YQCMClu1BTAm7PwA9D7NGmd2WEdngBbshTVGXYERZNC0M7+n68/dBWZNTRSjbEvoattKGRkw8mb9yuOmoLmy6GtbHzE1F809zumkV+2E/F5w40o45SkALnN8wYRqgqtgTrtNf70uegH+0x8+uAI+ngRPDIQv/wF+L+4YxaCxhHdrjda9taEaz4noYrW6UDW9UZ7J41Oty/vKPVR6/azfVUZxuddqKFfp9VPh8VNc7qWsyhezeVxNTSgbgwQq1VGN1HMdMypeu55R+fKXtTG3jK/Ovn37AKhS0q1AxUX0jIrbqDOxZegZFSc+Sir0XzCvXyNNCf1lC+6rElxMa1M08pwq36/dxfqNGznO6Bz7J/tXsGE+fPcop9gX8LDzedpWVJ/KXq+10ltku7PZoeVZ5wdFD1TAClSOsxuf1o1gpCw7MPXT01zxYwYqmh6ojLIvIVcpB5vDOg+t9MLYgpKf6GgzsgbGVIYZqPS3rbWyI9abrvHvQFthoBal3WH68+7OojhHP/9g25pAoGK8oZsBSV9lPTmUhgYiYAUig5RCXHgDUzxmINOqP7iyyVHK6alstO5f1XIQuDJCzmEGQY5NC0OuB1BCAowoAUPQmIZb2Z3VuBUfRVoTitP1jBPth+GxpZGvFFvZLCv46jDMqpei7RB9SqViDz2NKbgsyhloBqNBP3eRMsAYWyCYaEpJIHDtdjygv8HOVs1A5ReCMxDj7D9iUzS0tkMhN2ifn676SrDwQKU5xVbQbJ4fgPzu0Lw7LsUfNXA4y/4NaKoeJOYHpjoXNTvduj3WFOwVxhLxrzMmQFqOfmVGU5TDLgPgOseHVJdVGWH7jePsP6MqdjjnFchpDYMv5BmfnkGa4pxu9SOqTrMsF3x9L3zxd/CW64F8+yP0x7XwaXhrIlmO+Kdj3E47CgoKKmfYvoGXjueFjSex1H0505wPcLRRoO1Itd7zh5DgRnmqpl8ecf/XDJwyi563f8noh+cyYMpMDv/3bN5YtJEjps6m1x1fMmDKTPrc+T/GPDw34pwvfLOWgVNm8VacG1MmSkoEKk8//TQFBQWkpaUxbNgwfvghvqKihPMZWQdn3Zo2VSn6/TKpjKt5WrgMRY98t5TbQzMqYWk9j0/FbXSmzW2ip+BtisbWvXoBm9cfqFFRjeyQ2TtF0yILbc8f0IQHv1wVCBAwepr8+l/r8ij7Uoaue77a8ZdndaRPG/2PdVrLroEb8toH3oDze4beqUVv/fzDh+PXFPKUMqvexQpqRulvyION6Rua9whsMWBkVLoW6as69mQUQIaeZTJrKo51LKWHUfdifhqn9UBUbLRR9nBNU6N2ISgIyO6mf391u3WwyfhUa2YUclpTmdsFm6LxJ/ts2im7qMJpTRnRrCu7ycWteBlhW2YV8dLJCFTsDj0AQM+YjDCmkNxdjw48L53070c5fuecwa2wbTZeI0a2BtALZglkQszzhAYq+s/UAw/NCliWuwdw7+l6kIfDjWLUzZh1KlavEjP4Aj2bZFy+ur3+h2yYbQUORdWn+/I6WIcusA00zhMoKh5lW4JN0die0c0KPFrmuMnqfRxVmoOOth10VQJNACfY9Mes9D6FEMb/w1GO5SHLmq1sSuuBkN0q9D49TwLg+IiiXY3Ls4zVIYMvDLnl5LMuZpetGc2U/VzaLLJ3y9lt9zLC/jt+bPQ/69bQG4dfi1dxMchWyNHO6PU0dvzc7tBfY+rQywLBN1B+5N/Z4mhPvlLM3x1vR71/sEe6LYdvH9YvjL0brvoWLvsfnPeGnhVb8z9GLL+LeFcjnTW4HU21vbzh/DePup6DTYtwaVXkKOWMsS/hVdcDvJH7NGf3zWXisA41nzBOzbPcXD1a/9ByztB21vV5GU4y67G9BcCEvq1qPugAF20zT4D7v1jBvnJvjceanbInf1B9b6NES3qg8vbbb3PjjTdy55138ssvvzBgwADGjRvHjh3xbwWfMF4zUMmo093dmfqcbjpVNe01F0HTNDKNepFK3FaNigsfvrAUXYXHT7oRbDgzmwTO4dWv8/k1K1DxO/XGcTbVCFw0Igpt0xUPflULTLmYlryp/9ukIHCdzcleJS/ocmBXhgtPGmttjZ7TJmgX4uZBBbnNQ3cnNgOV9MwsNmiB+e51Snurid7hw0aE3sfIlADQun/ITU17BL2xth4AKIFVTi16Q5axsZ07C1tL/We3328s3zVrMQBHJ/08fXd8CqpX7w1j1N4ApHXTp39ucepvIutzhlpL1FEUltr0c9/ieEtf9t6sW8gbuVlQe1ffXZyapf9xUIxMAaBnd5yZ5GnFPFjwC3hK9WkP4/kC9GBGsdHVtpVjbb/oAZ4zI5A1Amh/ONhdtFb2UKAUWb1jjhl/Jh2bBVaqObsZb/6231BQOcppZM/MLJDJCI5ytn7H+vtP5KUj94Vcb1qldWSHlkemUsUQ22rG9mrJsUYg8UeToKyQovDon0bg7jYagK9OLGf9/Sey/vYjGOEwMl29wgKVVgMgoznpWgWFf2muH3//iTzU36iHCZ72MfXSA5XRtiUh9VzDlJU0rdqsZ4qMKSJTy7wsmh+lZ0ZuaxHaF+eJ8wfxUFt9dZG97+l07Bz2e53VAufQiwF4tdt31hhN3VpksfbMnfqHg/QmOMbcFnL3m0/oT9uJzwJwoWM2669txdtXHhHxsG4Z34P113eg2VwjUDr6FjjqerAZf+p7ngjn/RcUO7bf3mH98UusscwNa8V+XO+W1m3ppRt4tPQWhtuXU6654Zjb4dqfmFA1lZd8E/ApDo6smk/mK2O57yh3yGMLF3zb4QVNrZ+x/v4TWX/HcH4du4pXnVP51vU3FrknceuGq1h/9Fxu67MPM7D6/LqR/D5lfMTzGK/195/Is38aYt3/s78eVfOdgLOHtLPu07oOu6OnirI4mnmmkqQHKo8++ihXXHEFl156Kb179+a5554jIyODl19+OdlDCwpU6pZR8RtTP+lKVdSdXKujavoKHIDyoKkfm6Kh+UMDi3Kvz9qU0JGZZ12vGTsoe/yqtYLC79DHZDcawvmirAiyefWNCZubmYxgjjS49IvAm/SoW9ijBIIjs7kboKeaTcHBRPCn8uDrFVugZgRYoPaxvv/VERSA5LYNTB1BaMYgvxdkBX1SCn7DdGfrKXCTmRGJdjmjeejYuh0fsuScPqeHbs/b5/SQUy3NHhVy+XuH/rh6mVmq4KkIsBrZsepzqNijF+oGBxgOVyAD87lR+9B9fOi0ZHoetNHHrBduGo/JzDaB/rvcTi8cPtc+NzD1Ev5cdDYLgFcwwvY7uWoxuLKt8weOG63/u2GB/noxazvCgwNF4VtVz9iMsi3FoVZZfVX+aBr6XFmPDWDVl/q/Kz4Bza9P7Rk1TxabLTANt9aoH/FWQqHRjK5HlM6wbQazTWtGllIZsrP3uQ4jfd73DHBnRd5v8IWAAuu+CSmqTasogmXv6xeGT4q8H8CI6/RA/o+5sCV0OXUOZTDnPv3C6H8EsoDBOo3Ui3vR4LO/ofojV0XZKovh7T+Br1Jfkj/6tsjzdB0LJz+uf//Ng7BY/wASnqm1fru3/w4vjaO1WsQGtQUnev4NR98MzbuxQuvIPb4LearTM3px+J618OLYwPRoTcwf4vfp9TRPDqbJd3dztP032tt2Yi8rgm2L4YcXaPL2KXzhmsxY28/Uc4/LOrMHTW3Favh2IIhVS5SqNUZJfaY9Hg8///wzY8cGPrnabDbGjh3LggWRa8UBqqqqKCkpCflKiGXvB/5w1DGj4rPrEbdeoFq7V9b+Sq+1AqeSNGt5MgD+0P4m5R5/YFPCtFzresWnByA+VcWh6BG0arzZ2jX9j5yqElG/YvOV41dVmqGv6NnrbhO4scuxkNMG/jIfbloNo24JHbj5ht12iD6/bl1/BuS0g7Q86Htm4PrM5tbSTw6/MuRN9XX/sVRpTio1JzPcoZsJWm8GTbsECitBf9MyemWQ20H/BBlyv2v0fx1pYNQNWA67TA8QwHhTCQoCXBl67xDQH8Nhl4fet2AkK9P0OozValt+yj425Ob5ziMp0fSAV0OBwReF3r/1AGgRCMzod5Y+tRJs4AWhl3ufSgTjDdta6h3++AH6nAbA1Y5PsSkamzJ6Q2670GNa9oFmXUlXPEx3PqBf131coD7FlN8Dctrqv5Nzp0LxJn1qodPRIYdpGszz68/PeNsP9Kn4kSylkm1aU7Zn9yaCGahs/gHKdsNvxrLgfmdHHguBQK/QCFTWf6dvvJndWp/6CacofM1QYzz69E8TSjjRLFYdfHH0n5PXwcq0nWcPvBl3KXxFz7R1PMqaYox6337n6N9/+2jITRdVvQHlu/Wp0KF/jn5/gOPv1X//in6j9YppITfZUBm38p+wd72+muyMFwKZlHCDL4KjbtC//+SvsH5+RAdVm6LA1sUw/UQo28Ef9k6c5bmLdVrriNNtTu8JV87VP5xUFcN/z+RPQZ2VY1FA/z97boReT1OxF7V5T+72XsgZVXex7dz/wVnTYOCf0JwZ9LJt4kXXIzR5+2TY1HAlApqmP3/NKKa9sp2W7InY+wtCA5XaFiMfCLr843MKJs+gYPIM3vs5dfaQSuozvWvXLvx+Py1bhi5pa9myJUVF0ZcATp06ldzcXOurffv2iRlcUVAPifD57Tj57fobU/iKm3g8Omu1EeBAt/Yt9Q6pJl9ooBI89YMzE6+xKbbqN4ppfRouI6OiGkGXXQtkVByEpgHt3nJ6tc6hqbGZ367u5+vTPUpQEODKgOwoSxGPvhkmvg8XhPWbyGgK1/4I1/8WOuUBcNqzcPX3MG5qyNXLtQLGeh7kOM+DDBw0LPQ+Q/+sz7tf/lVoxgBg+LVw2Sz4y7eR2bAB58Pls+GahSFTN4D+GCf9ABd9AkdeF/nYjrkdLv4U/vJdaBAGoCgsOfpFLvRM5gzP3Qzr3ibk5uMHdeUa7/UsUntSOeExaNEz4v5MeEAPlJp11T9Vh+t5UuBNt+2QwJt52OOr1PQApzKjdUSmB9CDRlcgW7C33+WRxyiBYMqhGG9gQ6K8eStKIICa/x/9314nRTzvpw5syyx1MCVaOgW27fx1x50AfOY/gqEFUXpv5LWHlv304s+Z/9QLuVFCg9xgZkZo22Io3gzLjb2Zuo8jVjqzspse4J5oX0gupZxnn4tb8epBY6xgA6znYaLja/LYT2t202m9UTdy1PWx72fdrsDKz2C9XgszUCnkpCqjU+74+/WapVgym8NxUwDouPhhhirGNCEqdzleodO+BXqgeO5/o2dlgh1zhz6Npnrh7Ym02h+6i/H5zVbDK6dAxV5oO4Q5R7zMTvJCNlo0n9oRXZvpY7v4E/01pvm51zmNuxzTsRM5zZCf7aaTso2HvP+G/54BO1fqKxZPeBj+8h3T/BP4RetORschenbrtKfxXLeMp32nUKG5cG39EV46Dt69RA/MajCwfV7gYfdsoX/j9+rZrc9voeuHE1juvpSf067mW/cNLEq7llVplzDHdQNPOJ/kLPs88tgfsgz/lAGhr/GDzc3vLqn5oEZSzSsiNd12223ceOON1uWSkpLEBCvdx0FWC326INof+zhYGRWlstZTPyu2lZBpFNOO6NURbDZ8ihOH5o0IVLx+1Zr6wZmOFwdOfGhmoKIGpn7CMyp+VcMZ9ofE5iunZ6scmi7XMypde/SFE67T6yLCP3kDSnBBnt0J3cZGHAMECmjD2ez6J/gw3/x9DAvX7SbL7YjenyGsHiUwIEWvxYh1W9D0UoSc1pFBSPB9wzIFwc46ohuVnM/xCpw2sG3IbZPGdOVR32mUdLiU9Fi9JjqNhFv+0JfDR/skbLPDpZ/DH/P0cURbjdasC8XnfcLW37+g03F/iT5tmdkMznwJz6x72Jx/FP3GXRp9PEMuxbv0A5zbF6MN+wtKrMd+2BV6B9aKvYACR1wTccgt43swtKAJ7709ij879Okczeai9+m3MqJ7fvTzHn4FfHpdoDaq7xlRf/8APWguGKnvAfTto7DM6AQ74PzoxwMTzzmffU89SV7JKr7u/iEZW74DP3oH2+pesD1OgJZ9ydm+jPdb/5emzipsOyr0bELXGL/7pvwe+vTRL6/C+5dzhu0U/u58R69b6ntWYAqrOoMvgrWzUZZ/zNsZD7Gs3Xm0r1xN0+3z0VBQTns69msjmM0Gpz8PJVtgy8/kvXUK3w+9lD05vWiyZS5tfvgI0PQl8Be8w0XOLNq0as1hnQIB0PeTj2Hp5mKO62X8Tjvc+geP5t1h9t1c4pjJyS33cGfJqfyR0Y/plx4OW3/lm54f4l72JrZdfn067PAr9exsehNswGd/PYpKr5/cjEBW0Z3djBFXPUlhWRH9Vj0Jv74Ov38IK2fwUbdzuXjNSIrRA/Anzx9Et5ZZrNtZhqrBoA55HHn/12RSwT3dCuGD/4PVX0KlPr2dDlbSu1xz48KLQ1HpZNtOJ7Zzin0BmtMGS48D15+h23FcNaoLXfKzSHPauXR6aFH2aQPb8NHi0E1W43V4p6b8sE5v4DauT0uKK7ws/GNPnc51sEhqoNK8eXPsdjvbt4c2atq+fTutWkXPYrjdbtzuOrS0r60ORwRWbdSRmVFJx1On3S7NqR97mv7iMwMVJWzqx+NTgzIqGXhxApUoVkZFJcMIRjQjUHGo5rSQZn3i0VBQ0LD7K6hSVZqhZ1SUzOZ6/UN6Xu0fRD10aJZBh2Z1m3ZLBrtN4eIjC6Le5rTbuHV8z6i3hZ7EWf3trkzoeUK1h7TsdST0OrL68/QYj6vHeDpXd0xaDs6rvoaqEpT0JrGPy24Jf54Jv7yi19UE1/aYp3LaOaFfa/q/fiY9lE30dhXR5NT7GdF/YOzzDpwIy96Ddd9Adht99Up1DrtMD1R+MnaabtUvsKor2sNzOUg74U546wKabfwicB9zKjIWmx1OfASmn0iXvUZ7fmcGnPRY9QGO6fh79WmLnSv1FTTAZnt72p30aA13NCiKHgxUlmD/Yw4DNhhTQHYXyilPxs46RePKgAs/gg+uhNVf0GbZc4TkCYZcqmf6HG6cwIR+oUF869x0WueGBcOKAiNvhObd4IMrabb7J57iJyh1wZMK+Kuw7tF9PBx3T8gycIC+bXOJRs+M5EHPp/WAcua/4I+5DNz0Gj+432KmOoS5/oGc3LIDpGv0bFMJxZuoWrqYV53vcYRtOa5ZQR/MMppDj/H80WQEl35RwSatBSo2QGPWVX3opq6DjQth5eco23+DNf/Tv3La4RxyMRMGX8TS4sidzyce0bHOgcqT5w9i2L/1KcypZ/Tnf78XSaCSzB/ucrkYMmQIs2fP5rTTTgNAVVVmz57Ntddem8yhNQifFahU1b5ToKZZUz9moOK3uUAtj6hR8fo10ghkVHyKAzSsjIpP1ayMihWoGFM/flWzpn48zmzc3hIcvnL8KtbUDxnNqY5W6zVN4oBhs+vt8muS3x3G3VfjYSVkMtH7T0Z3zmd6/xhZL5PdAX/6EIqW6tNhZl+SWHqerNeIbPhOXyV34qM1Bw49T4Rj74BvH4PmXeHsV+Lrm9ThCDjvTZj7b/1nHXc3tIxSaxNNWi5c/BnM/BdrF8/jF7Ubn+dfw7S06G/OUbkyYeJ7eiC3do6e/R18sf4YaistB85/U988cenbULpdX5U25BJof1iNd4+p18lwzQI9w7X8Y6jcp1/vSNcz1kdcYy3Lr5NW/fQgq/Aryj6/g8y9yznZvpCT7QvhuedCDnUDRxv/rd7cTjj7nAQ9TtQzrzY7ezfsZYP2fdA9FPzpzaBVJ31accw/YNca+Hk6LH4dSjbrNYzzHqBjx+MZbhvEArU3ZlqmPvUrwW8VdpuSMl1mPT41aQXESZ/6ufHGG7n44osZOnQohx9+OI8//jhlZWVcemmMdPQBxMqoKFW1rqZ2aF6rNkAxlrmqiv7fFb7qx+P14DKKZXGk4TP/W316MOLxB+pQNONcZr+J4CDG69ADFae/AtXvoalibCSWWX2gIkRtxf2H3O6ImqGJeeyFH+h1B827R64OimXkTfpXbXU/Xv+qi6x8OON5jv1Br0053JFX+3PYHTDgPP2rvhRFry0ylm03mCYFcMoTerapZIv+Lpzbrs5NNCMoCnQ7jsLTh/KPZ1/nZPtChtpWMTR7L5Tv0ac+M/NRW/blvt9y+FodzLQLz6egeWbIaaL1qbOFB7nNu+nB+DG364HXTy/BpkXkrvucN12fs1Ztzbv+UcxSh5DeQG/oNgWcsQqiG1mFx3/oBirnnnsuO3fu5I477qCoqIiBAwfy5ZdfRhTYHoiCV/3UNlBxa0HNd4wsiN8IVGz+8J2QgzIsDpeVUcEIaHx+DadiLGU0AxWjG63fr2E3AiKfKxsqwOkvx1m1L3DO9OqL8pQ4m0YJMfWMfrz03Tr+dWKc2Yfacrij901JcfbaFrEdaGz2yCL6BtSvXR65nYdy/9pOTBzWgaFm80LzxwM7tV8pqPTSMcp0cv92eRzZpRntm2TgVVV2lXroFrS3UQhnGgw4V/8qWsbuec/iXv4eXWzbmGx7i8m8hfb2M7zerAtFmb3JatOD9wv9tG/Tjg+X7sCHjTS8ZCvlNHV4OLyNk8JN28iigjP75tBy8XKebbkGt+Ij+5uFnKE4KW+6l1/2pbODJkw84VimL63g54376NEy29pENtGq/H6ghqnpBEl6oAJw7bXXHhRTPeF8Qat+apu9S9OMpcmakzRjFYBq039JNLO1v8HvDdoG3u4OZFSMKSKfXw0UzBqBilMzMyoqacZtPqeeenaoFbi9ewEot+eQUd0qBCFq4fzDO3D+4Yl7wzpQ2aX1fL3YbApvXFF9TeET5w+KeZs9jvtH1aovRSP/zTm/juEU+/fc12MdtvXfouxdxwjWQdlXsAPGAayG26P1iNsOmGUuq/Uvq/PP9/qb9CXAJeYxX93LyRnNoXc/fQqy09HQdmhE64CCyTMiftT6+0/ktYUbuP2jZRG31cTrT94HUnkHSiC/teqnCn8tIxUzUCkjDfN325z6USIyKsGBihOfYkS9/sDUjzm9oxjLUh0EalTMYlqfS68BcPkrSKsyAhVnEw6cclYhDkwHe0LlYFdGOm/6j+WeiROw+cpgw/ew9Ve9D03xJijZglpRgs38wKjY9YaC7hy9VUBajr7C1PrK0Qvr/cYqz8pi2L9Nnz7bux7Kd8Efc/SvuVP1Yu7OY/TeSj3Gh/TTCuesY1DsC+uz05gkUEkgn9EFNoMqtu6vquHoUGnG1E8FgRVOZkaFsIyKaixX9ipOnIoSlFEJTP2YNSqKW8+omH1V/FpgebJqNDsr3V/CwmWrudAFFc6aCymlmFaI+pGMyoEruJbFbtM3YaX7uIgpyAe/WMnz89ZgR6Vw6il1j0495bBzhR4Erf9OXxVXvgtWzdC/bE7oMoaTbd2ZqQ6litBMi8NetzqTmb9v54qjq10nmDASqCRQ2xZ6I6s0qrj5vSUsviP+wrvOOcAeKNMCuULNFj2johoZFZ/iwgkRGRVv0NSPYrQFd5hTP0FBjCNDj8IzlCprxU+pPS/uMQshaifNaaPSq3J0txi9ZETKy88OfJhUqgk+BnfIQ8OGD1v9UmiuDL0hYdsh+pJ8VYXtv8GKz/Qi312rYM1MnnTNpETL4FP/cN7zH82vmr4irFfr7Dr92GVbo2yp0kgkUEmgrm30Pz4ZSlXETpU16Wj8LqlB7ftVRY+MFTX0XGZGxQxQfNYUkX6cN2hljzn148KLX9VCpn7ym+sdGzOopLkRqGQ2rbmoWYpphaibr28azY/r93BiWH8SceBonuXm9cuHkV7Dbs7H9W7J0xcMpnebGpbZ15bNpndTbj0Ajvkn7FwFv72L79c3yNm/hYmO2Ux0zMaT1wW+XU2fAefx4kVDaZOXTvMsF7d98BvXjOnKqwvW8/HirfzfRUNZv6uM+z5fgcthw2NsguusYyamIUigkkhG4aq1D08tOPzlANjdgejXyqhEFNPq5/dbgYpRdGtO/Xi92BQ9mLClGcW0ig+fqhrLk41si9EvI0OpoommV5LbMuWTnhCJ0iYvnVPDuhiLA8+IrjW3cFAUhRP7N0JAmt8DjvkXjtH/0HsKLX4Dln+Ma99amH03fH0PYzuP0be+yD+Rly7Re+UM6diE/5wXKDg2p3nMolxnsnaCRAKVxHIGGr7Vlt2nByoee2Dqx6xRUcL6qGhGRsVv0zMuZo2KYuyQrAa13Le7zYyKT8+o+P1WEGMWYGVQSVNFD1R8aTXsFyKEECL12Gz6iqBOR8MJD8HvH+nbUWyYr+8yvnY2uHP1rSkGTtS3FqlmSkoyKgcrY9rGpfitBmvxchiBitcWaE+tmYGKFhaoeEMDlZ0VGthh6Yad9AH8vsDxNndg6sfr1/AH7xtkBSpVNDXa5/tr6KECUkwrhBApzZ2t7zE1+ELY8wcseQsWvwnFG+HnafpXs24w8Hx909IozRLTnQ3UpK8OUqPl3cEqqL6kubt2S7scfn3Vj8ceOIdmj5FRMfqlmBkXc/fkwm36/hCqL1B860jTp5LMjIoaFMRYgYpSSRMjo1LQLkG7UwshhGh8TTvrWwL8bYm+G/yA8/X3qt1rYPYUeGIgPHcUzHsQdqzg+mO7UtAsg6tGdUnakCWjkkgON5piQ9FUWqZHbnVe7V2NGhVPlIyKTQ3PqBhTPEZGxavp/61uc8dkI1BRsWFz6edz4aPE50f1B2V6gjIqZrdae1Ycc69STCuEEAeW8Kmh5R/D0nf0Jc9Fv+lfc+7j+qadub7PcbA7AzLrsTdTPUigkkiKgupIx+4tw63Wrk7FmvqxBwcqRgt9LWwaycyo2I1AxfhvtTYiNLImfsWBzTjGpmj4/D5Ub3BGRa9Gz6DS2rlZ9vkRQoiDnDsbBv1J/yrfA6u+gBWfwNqv9amiH57XP8jWZxPJepBAJcFURwZ2bxkurbLmg4OUl+pr1iuV4D4q0Zcnm5sPmrd7zEDF2N/Hb2ZUbA6wB5r/qN4qVONcfmzYzaXLSlD2J44aFSGEEAeJjKYwaKL+VbUf/pgHhbP0ncaTRAKVBNMceqDhrmWgsq+4GOzw/aYqTjCvNGpUbGHFtGZGRbPrjYfCMypmh1pVceqbthl8ngprCbMfO3ZX6I6i5ZqbDFfNDfSlmFYIIQ5C7uzE7KpdS1JMm2Bmwza3WrtAJdOYeinXAoGFFaiEZVTMTrWakS3p20GfrunSVL+sBWdUbIHYVPV5rWJav6JnW/wEKrv3ULcOhkIIIURDkUAlwTRjvx93LXupZChGoELw1I+ZUQmtUbFa6huBSk6GXtdiN45TgzMqimJNDfl9HiujomLXbwsq3t2jxReoSDGtEEKIRJFAJcE0h/7Gn1bLqZ8sArsnW4yMij2sM63NKNTVzGkde1gti/GvFrZ8WfVWhWZUgKqgQGVvnIGKEEIIkSgSqCSYZk79aPFnVKp8fmvVTfCmhIoZqGjRp34Uo0bF5jCniIyAJnjqh0DnWr/Pg2Yc41f0KZ8yR551Xpn6EUIIkWwSqCSYZrTRdxN/RuWn9XvJNKZ+xg0KarJTw9SP4jBW9JhLkI3jzOkdsz7F2gvIVxWY+jEClWYt21nnjTejIsW0QgghEkUClUQzMippteyjYhbTDu0e1BnWCEDs4cuTjUDF7jSmfoyAxMq8mHv+GIGOWTDr9wbVqBhTP2l5gU2ztmjNajVmIYQQoqFJoJJg5tRPWm2KaVU/6YoRXDizAtc7zExJaJdbxViebHfp00SaNUVkHGd2n7WF7a7s86AZt5kZFbJaWOfdqLWMa7hSTCuEECJRJFBJNGftV/1s2r7T+t4XtF+QWaPiCKtR8Vbp2ReHEagoZubFPM5avmwEKkaNiub3BPVYMZYtN+9unXed1iruMQshhBCJIIFKgpk1Kum1KKZ9bMavAHg1O6oS6CRrBSBBOzFvK67AZXSgTUszVuyYUz/Gcdbqn7CMihpSTGsEKj0msCejM3P8AyjU2sb3GKVGRQghRIJIZ9oEU4xur7WZ+slS9J2Ty3ETvOdyYNVPIFApqfDhQg9EsjL1n6U5zIxK2NSPcX8zKNF8XiujopmBSkZTsm78mU0/buTrrrLPjxBCiOSSQCXRjKmb9Fqs+skwgppS0lGDyj/MVT2OoEDF61etXZKt/im20CkiK6MSFqjgDyqmDepY63LYuGh4QdzjFUIIIRJFpn4SzZz6oQpNi6/o1MqoaGmoQfdRHKHLjkEPVKw9fYyGb1bmBT2jEj714zf+1fweMKZ+NCXQOr+2pJhWCCFEokigkmjm1I/iYU+ZJ667ZAR1pQ0ObswARFE9eP36pJDXr1lTP9bOyGFFt+Ymhmag4w9e9aOaq34kuSaEECL1SKCSYIqRUcmgktcXbYzrPplBXWmP7BKoE8nP1ZcqO/CzvUQ/xudXrWLaQEYltEbF6lBrZFJUI1AhOKNiq3ugIsW0QgghEkUClQRT3HpGJYMqfH61hqN1ZlfaMtJIcwamZFwuPRBx4kM1TuXxq0EZldC9fqxVP1pYMa0tcnmyJhkVIYQQKUjenRJMMfuoKN6QwtjqZEbbkBCsAMSFD78xJeTza7isGhWjmNau/7eatSsOo0bFzLSYGRXF70UxBlWfjIrUqAghhEgUyagkmhGoZFAZUhhbHTNQKdeiByoO/PiNAMMbJaOiWMuT9UDFLL41a1zMVvr61I8+PVSfQEUIIYRIFAlUEsxuTP2k48HtiG9ljTn1UxqRUTEyJYrPKrL1qlpQjYqZUdEDETOjYgYsirGrshWU+L3WiiCZ+hFCCJGKJFBJMHe6XgCbrnjIdMVXdGpmVMYP6hp6g5FRceK3pn68PhV3rIyKsTzZHiujogZnVJy1elzBpJhWCCFEosjH6EQzVv0A4Iuv6VuuXW/4lpWTF3qDLZApMad+fGrQ1E/Yqh9HeKBiBDCqzci8+H0oZn2vre59VIQQQohEkUAl0YI3FfRWxHWXdK0CFLAZ00aWoCmdwKqfoGJaI0CxOcxiWj2AsVb/2M2pn0BGxQxU6pNRkWJaIYQQiSJTP4lms+E1Nha0+eIMVIypH1tadugNZiM3/FZhrs8fLaOi/2tHw+P1WZkVmxHImEGJTfWiGL1WFLtkVIQQQqQeCVQagdemF8UqcQQqqqqRgX6czR0eqOiBhlvx4TdSKj6vB7uihdzeqkngfht37rOKas2pH80evDzZKKatR0ZFCCGESJSkBioFBQUoihLydf/99ydzSAlhBio2X3nNx6oqmcamhLa0rNAb7YFgQjV2RFZ9QW35jUAlze0OnM9ThcMIVGwOs5jWqFFRvShGMS3SmVYIIUQKSnqNypQpU7jiiiusy9nZ2dUcfWDy2tPAC/Y4imm9fo1MY1NCR/jUT1DWQzMCFNUbdE5HaGdaAJ/Pi8uc+nGE7gWkT/2YGxYm/VdBCCGEiJD0d6fs7GxatWqV7GEklM/MqPhrzqhs3ltOa6NGxR5RoxIIQFSj9T1GwKKhoJjBRtAKHl9IRiW0RkVRPdjU0OClLqSYVgghRKIkvUbl/vvvp1mzZgwaNIiHHnoIn8+X7CE1OJ/dnPqpOaMy/vFvrD4q9mqmfvAbAYpxTp/iBMWYglEUPEYM6vdWBYppzYZwZp8V1WcV00pGRQghRCpK6rvTddddx+DBg2natCnff/89t912G9u2bePRRx+NeZ+qqiqqqqqsyyUlJY0x1Hrx2fReKnZ/zYGKGy8OY82wEl5Mqyj4sOPAb039eD36Of02F8E5ER8OXPjw+TxW59rA8mRjFZLmjWivL4QQQqSSBs+oTJ48OaJANvxr5cqVANx4442MHj2a/v3785e//IVHHnmEJ598MiQQCTd16lRyc3Otr/bt2zf0Q2hwPrseqDjimPoxsykAuDIjbvcRtPMx+tQOBApkA8fZrdvNjIpV4xJco6LWP1CRYlohhBCJ0uAZlZtuuolLLrmk2mM6d+4c9fphw4bh8/lYv349PXr0iHrMbbfdxo033mhdLikpSflgxW9M/TjiyKhkGPv8VGgu0qN0i/UpDtCq0IwaFZ+RUVHt4YGK/l+r+rzW8mSzxsUMSvSMitlHRaZ+hBBCpJ4Gf3fKz88nPz+/TvddvHgxNpuNFi1axDzG7XbjDlp+eyDwO/RAZcXGHZxUw7FZBDYkTI9yuxmAEBaoaGEZlSrNDgos2bCTsWZGxQxGjBoVm+qL2AeoLqSYVgghRKIk7WP0ggULWLRoEWPGjCE7O5sFCxZwww038Kc//YkmTZoka1gJUezVg4AMpZIqn7/aXZQzjEBFc0ZO+wD4FSdo4PfqUz9+rz71o4VlVLxGoPL171sY7zQDFTOjYhTTBmdUpJhWCCFECkrau5Pb7eatt97irrvuoqqqik6dOnHDDTeETOscLMwalXQ8eP0a7mqe9a55GlRAZnZe1NtVRb+zp8qY8vEZ9TyO0CyT1/ivdeAPTP1YNSpmoOKTYlohhBApLWmByuDBg1m4cGGyfnyjUo2pnzSqqPL6yaomUnH69WZvsTIqqs0BfvAamRTVawYq0YtpnYoPhxI69WN2qLUHrfqxhd2/NqSYVgghRKIkvY/KocDKqCgePH612mNdxsogzZ0V9XbVyIrs3FdqnFwPVJQYGRUn/ojdlc1NCx2aD7u1YaFM/QghhEg9Eqg0grzcHAAyqMLjqyFQUfVARYmyNBmMxm7Auu17jSuMfYHCAhUro4LP6kxrTv1YDd80L3azhb697hkVKaYVQgiRKBKoNIJBXdoCkE4VVTUFKsbUD+HN3gwOI8jIcerBgU3Vi2rDMyqekBoVc+onNFBxaD4cRjGt3XlgraQSQghxaJBApRHYXBkApCmeGjMq6VqFcZ/oGRWnuTRb1TMhZqASXkzr0wIZlUAfFaM2xTjWgRc7+nmkmFYIIUQqkkClMTj1QKWmjIrPr1qBihK+IaHJ6Jei+L1ommZN3VQ/9RO2PDlqRkU60wohhEg9Eqg0BqdeTJtBFVU+f8zDPH41sCFhjGJac+WOonrxqxrOGIGKOfXjUnzW3kFmjYrNGRSoUP9VP0IIIUSiSKDSGJzxTf1UelWrhb49PXpGxWzspqhGTxZzw0FneEZFD1TSCdo3yQhyWubp57YpGi48xk1STCuEECL1SKDSGIKmfqoLVCq8fquFvj1GMa3ZVRa/D49PxWXUmNic4cuT7dbPtBj3zc8NZGvMDI6ZZRFCCCFSiQQqjcEZ6ExbXY1KhcdnZVSi7ZwMgNHq3qZ58fhVq0dK+NSP2UclQwkKVMKmfvQx6bfXJ6MihBBCJIoEKo3BzKgoHjxeX8zDiit8VkaFWDUqRkBRUlqO1x/IqIQvTzZX/ZgZExVbUGfaQFDiMrrWSmdaIYQQqUgClcZgLE8G8FWVxzxs4R+7rU0JcUUPVBxOc2mxn+IKb0TXWZM3rEbFpwQ6z9ptdn3TwiDOevRRkRoVIYQQiSKBSmNwpFvf+qrKYh6maRqZitHwLUagkpupBz0uxcfecg8uxegsG5ZR6dgiFwhM/fiCtnWy2RQrkLGukxoVIYQQKUgClcZgs+FV9EDAVxk7UCn3+Mk0i19j1KiYPVCc+KjyBqZ+sIcGKvnGyh4zQ+NXQvukmMW2JofUqAghhEhBEqg0Eq9Nz6r4KktjHlNR5QkUv8ZY9WN2l3Xgp9IbtOFgeKBhFN1mGIFPZKASmlFRJFARQgiRgiRQaSQ+exoAi1ZviXmMPzjbEmvVjz0oo+JTg2pUwmpMjBU+5ioivy00MAkPVMzj60KKaYUQQiSKBCqNxGvTA5UmrtirflSPnm1RFTs40qIfZAQULnzVZlQ0I/NiTiVVqeGBSlhgIrsnCyGESEESqDSStAy9OFbxVsQ8xm4EKj57BigxshRGAOI0AxUleo2KZgQ06cZUUnp6aODji8iohNasCCGEEKlAApXGYvRSUbyxlyfbfPptPkdGzGPMzIdD8VMRXEwbtupHVcyMij71o4VN7XiDlit7cMQOjIQQQogkkkClkShGL5XK8tjFtIWbtwHgd8SoTwEro+LCR5XPH7OPihpWTKvZQm8Pzqj4w7MrQgghRIqQQKWR2F2B7rQ79ldG3P7b5mKcfn1ayO+sOVDRp36qyagYgYrbmBoya1ZMvqDlycHN4OpCimmFEEIkigQqjcRt1KikU8nuUk/E7T9v2GO1z1erDVSMqR9zebISI6MSthxZC7vdF3S7Ws9ARYpphRBCJIoEKo3F2kHZg1+N/sZuLiXWnNXUqNgCGRV96idWjUpY8BEeqARN9/iUui9NFkIIIRJJApXGYm1MWBUzUMlEn/rRYrTPBwI1Koo+9eOO0UdFDe+LEj71ExTI1DejIoQQQiSKBCqNxal3pk3Hgy9moFJ9+3wgZOrnty3FuGNkVDRb/BkVvwQqQgghUpQEKo3FmvqpJqNibEioxGqfDyGdaQt37LeKZWua+nG7Q/uo+IMyLhFBTS1JMa0QQohEkUClsbjimfrRa1SUaqd+9KDChS+wNBkiApXwlvmZGaF1L8F9VSKmiWpJimmFEEIkigQqjSVo6id2RsUopnVXF6gEMipWIS1E1qiEZVRs4S32g/qqaFJMK4QQIkVJoNJYgqZ+fKoacXOVTw10kY1zebI7OFCJ0ZnWpITv5RNUXKvWY58fIYQQIpEkUGksZkZFqULVIjMqC/7YTYYRqDjTq6lRMaZ0nEpg6senOCNa4GdlpIfeL2zVjxKUYfHZw46tJalREUIIkSgSqDQWI0uSjgefPzJQaZrhIsuY+snNbRL7PEb2w4UPt6I3jvPbIjMigzvlR72fKTjDotpj7NQshBBCJJkEKo3FqlGJXkxb7vFbGRXiqFFxENjnx29zRxymOMKCj/BAJSijojrql1GRYlohhBCJIoFKYzEClTTFgz/K1E+5128V01bfR8WY+sFn1aioUTIqRAQqoVM/tgYMVIQQQohEkUClsRjFtBlU8dTXhRE3V3h8VjEtrvj6qLjRp35Ue2RGxQyMwu9nsgUX34YfK4QQQqQICVQaiyuw6mfD7vKIm8urggOVmlf9OPFbzd6irtoJz6iEBSOqOyfmbbUlxbRCCCESRQKVxmJkVNIUL5rmj7jZ56nCqRjXVxeoGKt+bIpGhtlyP56MSvhGh2m51retmjWtfuxCCCFEkkig0liCAge7vzLydk9p4PtqO9MGsidWBsYRJaNid6EGZzrCA5egQMWeVs1uzXGQYlohhBCJkrBA5b777uPII48kIyODvLy8qMds3LiRE088kYyMDFq0aMHf//53fD5f1GMPeEEFq2la5MqfstJiwFgqbK9m752gQCXL2BsoYpoHQFHwEBTAhGVUfEF1MM60agIjIYQQIokSFqh4PB7OPvtsrr766qi3+/1+TjzxRDweD99//z2vvPIK06dP54477kjUkJLLZkNzmE3fPHj9ge60O/dXkYkRdFQ37QMhq3eyjPvYnFGmfgBf8LJlV2ig4kgP9GpxZsnUjxBCiNSUsEDl7rvv5oYbbqBfv35Rb585cybLly/nv//9LwMHDmTChAncc889PP3003g8nkQNK7nMJcpU4QvKqGwvqbSmcWzV9VABUBR8ip4pyVb0otzszOj3Sc8Iuj5s6mdY327W9/acNvGNPwYpphVCCJEoSatRWbBgAf369aNly5bWdePGjaOkpITff/895v2qqqooKSkJ+TpgWPv9ePD6AhkVr18N9FBxV7M02eA3pn9y0AMVxRE9o2J3BQUnYVM/aXkt4agboccJ0HZw3A8hGqlREUIIkSjVFEMkVlFRUUiQAliXi4qKYt5v6tSp3H333QkdW6IorkAvFW/QxoQ+VQt0pa1p6gfw29KAUnKMjErUGhUIzaJEW4I89s54hi2EEEIkTa0yKpMnT0ZRlGq/Vq5cmaixAnDbbbdRXFxsfW3atCmhP69BBW1MuHxrIBPk9atBPVRqLmw19/bJoUy/ItqqHwgNesKXJwshhBAHgFplVG666SYuueSSao/p3LlzXOdq1aoVP/zwQ8h127dvt26Lxe1243ZHn+pIeWYvFTws/GMPo3u0AMDr1+Jrn29QnGlQSc0ZFVtQ23wJVIQQQhyAahWo5Ofnk5+fX/OBcRg+fDj33XcfO3bsoEUL/Q171qxZ5OTk0Lt37wb5GSnHyKhkUIkatN+PLzijEkeNSmZmFuwP1KgQo0YFNWipdxwBUF1JMa0QQohESViNysaNG9mzZw8bN27E7/ezePFiALp27UpWVhbHH388vXv35sILL+TBBx+kqKiIf/3rX0yaNOnAzZjUxCymDVueHFJMG09Gxcig5CjG1E+0zrQAihL9+wYmxbRCCCESJWGByh133MErr7xiXR40aBAAc+bMYfTo0djtdj777DOuvvpqhg8fTmZmJhdffDFTpkxJ1JCSz5r6qaIqKFCp8tWuRgWnEajUlFEZ8TfYuAB6n1bXEQshhBBJlbBAZfr06UyfPr3aYzp27Mjnn3+eqCGkHrOYFg9l/kAWYs7KHQyvxaofsyYlXTH6zcQKVLqPhyvnQX7POg9ZCCGESKakLU8+JBkZlQylCk9QRiUn3UmWWRgbvKtxLOGBSaxARVGgzcA6DFQIIYRIDbIpYWNymQ3fqvAFZVS8fo2sWhTTBu8bpF+OseqnkUgxrRBCiESRQKUxWS30I4tprQ0Ga2qhD5EZlCQvPZZiWiGEEIkigUpjslb9VPHFMr37bkmll/d+3mxtMBhfRiUsg5LApcdCCCFEMkmNSmOy+qhUAbBuVxlvLNoAEJRRiSNQcYYFKtLMTQghxEFKMiqNyalnPtKNQMXjU9m8Vw9QrIyKqy4ZFQlUhBBCHJwkUGlMrsCqHwC7Te+hAlr9pn6cyZ36kWJaIYQQiSKBSmMymrmZzd0URaHc4yOdKuyKUZBapxoVKaYVQghxcJJApTEZQYhZj2Iz2tqbS5M1lPgKY8MDkyRnVIQQQohEkUClMZmBijHNo2kaA9rlBQppXVnx7ckT3hROalSEEEIcpCRQaUwhUz8aqqZ/mYGLkhZHV1qAtNzA9zZH0hu+CSGEEIkigUpjMpq5ORU/brz4VfCpWmhGJa7zBAU06U0SujNyPKSYVgghRKJIoNKYggKRTCop9/iYNn997Vb8QGhGJb1pAw6wbqSYVgghRKJIoNKYbHZUY5+eTKWCF775A6AOgUpYRkUIIYQ4SEmg0shsRpCRRSXrdpUBkKmYGxLGOfUTnFGxOxtyeEIIIURKkUClsRnTP1lUGM3eINvKqMRZTBu8hNmZHvs4IYQQ4gAngUpjM7ImmUoFZVU+ALKUcuO2OKd+APqdo/876E8NObo6kWJaIYQQiSKbEjY2l9lLpZId+/VW+man2rhX/QCc9iwcdQO06NXQI6w1KaYVQgiRKBKoNDYja2LVpQDZtdk52WR3QMveDTkyIYQQIuXI1E9jcwdqVEy1XvUjhBBCHCIkUGlsrshAJVMCFSGEECIqCVQam1VMG5j6yVX0Zcohy46FEEIIIYFKo3OFbkwIkIsZqOQlYUBCCCFE6pJApbFFKaZtajeClvS8JAxICCGESF0SqDS2sGJaBZVMTTIqQgghRDQSqDQ2IxjJMepSsikP9CGRjIoQQggRQgKVxmZsIphn1KVYhbSOdHC4kzUqIYQQIiVJoNLYzEBFKQWgudSnCCGEEDFJoNLYrIxKKaDx+CkF+vVSnyKEEEJEkBb6jc0IVJyKn0wqcfm8xvV5yRuTEEIIkaIko9LYnOlodr0WJY9SXN4S/XrJqAghhBARJFBpbIoSVKdSRpam16pIRkUIIYSIJIFKEihGoPLEaR1xe4v1K43rhBBCCBEggUoyGEFJlywvlO7Ur8tsnsQBCSGEEKlJApVkMLMnFXuhbIf+fVbL5I1HCCGESFEJC1Tuu+8+jjzySDIyMsjLy4t6jKIoEV9vvfVWooaUOjKMQKV8N5QagUpmi+SNRwghhEhRCVue7PF4OPvssxk+fDgvvfRSzOOmTZvG+PHjrcuxgpqDSlYr/d/92wOBSlZ+8sYjhBBCpKiEBSp33303ANOnT6/2uLy8PFq1apWoYaSmnDb6v8WbocyoUZGpHyGEECJC0mtUJk2aRPPmzTn88MN5+eWX0TSt2uOrqqooKSkJ+TrgmIHK9t9B8+vfZ0pGRQghhAiX1M60U6ZM4ZhjjiEjI4OZM2dyzTXXUFpaynXXXRfzPlOnTrWyNQcsK6OyUf83qxXYnckbjxBCCJGiapVRmTx5ctQC2OCvlStXxn2+22+/nREjRjBo0CBuvfVWbrnlFh566KFq73PbbbdRXFxsfW3atKk2DyE1ZLcJvdykICnDaCgaSrKHIIQQ4iBVq4zKTTfdxCWXXFLtMZ07d67zYIYNG8Y999xDVVUVbrc76jFutzvmbQeMzObgzoEqY9rqAA9UFKqfrhNCCCHqqlaBSn5+Pvn5iaulWLx4MU2aNDnwA5GaKAq07Asbv9cvt+6f3PEIIYQQKSphNSobN25kz549bNy4Eb/fz+LFiwHo2rUrWVlZfPrpp2zfvp0jjjiCtLQ0Zs2axb///W9uvvnmRA0ptRQcFQhUOgxP7liEEEKIFJWwQOWOO+7glVdesS4PGjQIgDlz5jB69GicTidPP/00N9xwA5qm0bVrVx599FGuuOKKRA0ptRxxNWz5CfJ7QZtByR6NEEIIkZIUrab1wCmupKSE3NxciouLycnJSfZwDklrpwyki7pOv3BXcXIHI4QQ4oAQ7/t30vuoiAOfFNMKIYRIFAlUhBBCCJGyJFARQgghRMqSQEUIIYQQKUsCFSGEEEKkLAlUhBBCCJGyJFARQgghRMqSQEUIIYQQKUsCFSGEEEKkLAlUhBBCCJGyJFARQgghRMqSQEUIIYQQKUsCFSGEEEKkLAlUhBBCCJGyJFARQgghRMqSQEUIIYQQKUsCFSGEEEKkLAlUhBBCCJGyJFARQgghRMqSQEUIIYQQKUsCFSGEEEKkLAlUhBBCCJGyJFARQgghRMqSQEUIIYQQKUsCFSGEEEKkLAlUhBBCCJGyJFARQgghRMqSQEUIIYQQKUsCFSGEEEKkLAlUhBBCCJGyJFARQgghRMqSQEUIIYQQKUsCFSGEEEKkLAlUhBBCCJGyJFARQgghRMpKWKCyfv16LrvsMjp16kR6ejpdunThzjvvxOPxhBy3dOlSRo4cSVpaGu3bt+fBBx9M1JCEEEIIcYBxJOrEK1euRFVVnn/+ebp27cqyZcu44oorKCsr4+GHHwagpKSE448/nrFjx/Lcc8/x22+/8ec//5m8vDyuvPLKRA1NCCGEEAeIhAUq48ePZ/z48dblzp07s2rVKp599lkrUHn99dfxeDy8/PLLuFwu+vTpw+LFi3n00UclUBFCCCFE49aoFBcX07RpU+vyggULOProo3G5XNZ148aNY9WqVezduzfqOaqqqigpKQn5EkIIIcTBqdEClcLCQp588kmuuuoq67qioiJatmwZcpx5uaioKOp5pk6dSm5urvXVvn37xA1aCCGEEElV60Bl8uTJKIpS7dfKlStD7rNlyxbGjx/P2WefzRVXXFGvAd92220UFxdbX5s2barX+YQQQgiRumpdo3LTTTdxySWXVHtM586dre+3bt3KmDFjOPLII3nhhRdCjmvVqhXbt28Puc683KpVq6jndrvduN3u2g5bCCGEEAegWgcq+fn55Ofnx3Xsli1bGDNmDEOGDGHatGnYbKEJnOHDh/PPf/4Tr9eL0+kEYNasWfTo0YMmTZrUdmhCCCGEOMgkrEZly5YtjB49mg4dOvDwww+zc+dOioqKQmpPLrjgAlwuF5dddhm///47b7/9Nv/5z3+48cYbEzUsIYQQQhxAErY8edasWRQWFlJYWEi7du1CbtM0DYDc3FxmzpzJpEmTGDJkCM2bN+eOO+6QpclCCCGEAEDRzKjhAFVSUkJubi7FxcXk5OQkeziHpD+mDKCzul6/cFdxUscihBDiwBDv+7fs9SOEEEKIlCWBihBCCCFSlgQqQgghhEhZEqgIIYQQImVJoCKEEEKIlCWBihBCCCFSlgQqQgghhEhZEqgIIYQQImVJoCKEEEKIlCWBihBCCCFSlgQqQgghhEhZEqgIIYQQImVJoCKEEEKIlCWBihBCCCFSlgQqQgghhEhZEqgIIYQQImVJoCLqrXm2O9lDEEIIcZCSQEXUW06aM9lDEEIIcZCSQEUIIYQQKUsCFSGEEEKkLAlUhBBCCJGyJFARQgghRMqSQEUIIYQQKUsCFSGEEEKkLAlUhBBCCJGyJFARQgghRMqSQEUIIYQQKUsCFSGEEEKkLAlUhBBCCJGyJFARQgghRMqSQEUIIYQQKUsCFVF/nUfr/7qykjoMIYQQBx9HsgcgDgLH/AuadoJuxyd7JEIIIQ4yEqiI+nOmw2GXJ3sUQgghDkIy9SOEEEKIlCWBihBCCCFSVsIClfXr13PZZZfRqVMn0tPT6dKlC3feeScejyfkGEVRIr4WLlyYqGEJIYQQ4gCSsBqVlStXoqoqzz//PF27dmXZsmVcccUVlJWV8fDDD4cc+9VXX9GnTx/rcrNmzRI1LCGEEEIcQBIWqIwfP57x48dblzt37syqVat49tlnIwKVZs2a0apVq0QNRQghhBAHqEatUSkuLqZp06YR159yyim0aNGCo446ik8++aTac1RVVVFSUhLyJYQQQoiDU6MFKoWFhTz55JNcddVV1nVZWVk88sgjvPvuu8yYMYOjjjqK0047rdpgZerUqeTm5lpf7du3b4zhCyGEECIJFE3TtNrcYfLkyTzwwAPVHrNixQp69uxpXd6yZQujRo1i9OjRvPjii9Xe96KLLmLdunV8++23UW+vqqqiqqrKulxSUkL79u0pLi4mJyenFo9ECCGEEMlSUlJCbm5uje/fta5Ruemmm7jkkkuqPaZz587W91u3bmXMmDEceeSRvPDCCzWef9iwYcyaNSvm7W63G7fbHfd4hRBCCHHgqnWgkp+fT35+flzHbtmyhTFjxjBkyBCmTZuGzVbzTNPixYtp3bp1bYclhBBCiINQwlb9bNmyhdGjR9OxY0cefvhhdu7cad1mrvB55ZVXcLlcDBo0CIAPPviAl19+ucbpISGEEEIcGhIWqMyaNYvCwkIKCwtp165dyG3BZTH33HMPGzZswOFw0LNnT95++23OOuusRA1LCCGEEAeQWhfTppp4i3GEEEIIkToSVkybasw4S/qpCCGEEAcO8327pnzJAR+o7N+/H0D6qQghhBAHoP3795Obmxvz9gN+6kdVVbZu3Up2djaKojTouc0eLZs2bZJppSSQ5z+55PlPLnn+k0/+DxJL0zT2799PmzZtql0VfMBnVGw2W0SxbkPLycmRX9Ikkuc/ueT5Ty55/pNP/g8Sp7pMiqlR9/oRQgghhKgNCVSEEEIIkbIkUKmG2+3mzjvvlJb9SSLPf3LJ859c8vwnn/wfpIYDvphWCCGEEAcvyagIIYQQImVJoCKEEEKIlCWBihBCCCFSlgQqQgghhEhZEqjE8PTTT1NQUEBaWhrDhg3jhx9+SPaQDhl33XUXiqKEfPXs2TPZwzpoffPNN5x88sm0adMGRVH46KOPQm7XNI077riD1q1bk56eztixY1mzZk1yBnsQqun5v+SSSyJeD+PHj0/OYA9CU6dO5bDDDiM7O5sWLVpw2mmnsWrVqpBjKisrmTRpEs2aNSMrK4szzzyT7du3J2nEhx4JVKJ4++23ufHGG7nzzjv55ZdfGDBgAOPGjWPHjh3JHtoho0+fPmzbts36+u6775I9pINWWVkZAwYM4Omnn456+4MPPsgTTzzBc889x6JFi8jMzGTcuHFUVlY28kgPTjU9/wDjx48PeT28+eabjTjCg9u8efOYNGkSCxcuZNasWXi9Xo4//njKysqsY2644QY+/fRT3n33XebNm8fWrVs544wzkjjqQ4wmIhx++OHapEmTrMt+v19r06aNNnXq1CSO6tBx5513agMGDEj2MA5JgPbhhx9al1VV1Vq1aqU99NBD1nX79u3T3G639uabbyZhhAe38Odf0zTt4osv1k499dSkjOdQtGPHDg3Q5s2bp2ma/vvudDq1d9991zpmxYoVGqAtWLAgWcM8pEhGJYzH4+Hnn39m7Nix1nU2m42xY8eyYMGCJI7s0LJmzRratGlD586dmThxIhs3bkz2kA5J69ato6ioKOT1kJuby7Bhw+T10Ijmzp1LixYt6NGjB1dffTW7d+9O9pAOWsXFxQA0bdoUgJ9//hmv1xvyGujZsycdOnSQ10AjkUAlzK5du/D7/bRs2TLk+pYtW1JUVJSkUR1ahg0bxvTp0/nyyy959tlnWbduHSNHjmT//v3JHtohx/ydl9dD8owfP55XX32V2bNn88ADDzBv3jwmTJiA3+9P9tAOOqqqcv311zNixAj69u0L6K8Bl8tFXl5eyLHyGmg8B/zuyeLgM2HCBOv7/v37M2zYMDp27Mg777zDZZddlsSRCdH4zjvvPOv7fv360b9/f7p06cLcuXM59thjkziyg8+kSZNYtmyZ1MSlGMmohGnevDl2uz2ionv79u20atUqSaM6tOXl5dG9e3cKCwuTPZRDjvk7L6+H1NG5c2eaN28ur4cGdu211/LZZ58xZ84c2rVrZ13fqlUrPB4P+/btCzleXgONRwKVMC6XiyFDhjB79mzrOlVVmT17NsOHD0/iyA5dpaWlrF27ltatWyd7KIecTp060apVq5DXQ0lJCYsWLZLXQ5Js3ryZ3bt3y+uhgWiaxrXXXsuHH37I119/TadOnUJuHzJkCE6nM+Q1sGrVKjZu3CivgUYiUz9R3HjjjVx88cUMHTqUww8/nMcff5yysjIuvfTSZA/tkHDzzTdz8skn07FjR7Zu3cqdd96J3W7n/PPPT/bQDkqlpaUhn87XrVvH4sWLadq0KR06dOD666/n3nvvpVu3bnTq1Inbb7+dNm3acNpppyVv0AeR6p7/pk2bcvfdd3PmmWfSqlUr1q5dyy233ELXrl0ZN25cEkd98Jg0aRJvvPEGH3/8MdnZ2VbdSW5uLunp6eTm5nLZZZdx44030rRpU3JycvjrX//K8OHDOeKII5I8+kNEspcdpaonn3xS69Chg+ZyubTDDz9cW7hwYbKHdMg499xztdatW2sul0tr27atdu6552qFhYXJHtZBa86cORoQ8XXxxRdrmqYvUb799tu1li1bam63Wzv22GO1VatWJXfQB5Hqnv/y8nLt+OOP1/Lz8zWn06l17NhRu+KKK7SioqJkD/ugEe25B7Rp06ZZx1RUVGjXXHON1qRJEy0jI0M7/fTTtW3btiVv0IcYRdM0rfHDIyGEEEKImkmNihBCCCFSlgQqQgghhEhZEqgIIYQQImVJoCKEEEKIlCWBihBCCCFSlgQqQgghhEhZEqgIIYQQImVJoCKEEEKIlCWBihBCCCFSlgQqQgghhEhZEqgIIYQQImVJoCKEEEKIlPX/XSPAPAtqwL8AAAAASUVORK5CYII=", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAGdCAYAAAA8F1jjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB16ElEQVR4nO3dd3hUVf7H8fedmp4QSmihgxTpImBDBQULi4KuuuyKvaGu4q4rv1UUdMXVXTuW3UWwYgesCKKgdARBkV4DQkJNL5PM3N8fd2aSSSMQhgzyeT3PPCT33rk5M2Eynznne841TNM0EREREYlAtrpugIiIiEhVFFREREQkYimoiIiISMRSUBEREZGIpaAiIiIiEUtBRURERCKWgoqIiIhELAUVERERiViOum5Abfl8Pnbv3k18fDyGYdR1c0RERKQGTNMkJyeHpk2bYrNV3W9ywgeV3bt3k5qaWtfNEBERkaOwc+dOmjdvXuX+Ez6oxMfHA9YDTUhIqOPWiIiISE1kZ2eTmpoafB+vygkfVALDPQkJCQoqIiIiJ5jDlW2omFZEREQiloKKiIiIRCwFFREREYlYJ3yNiohIpDJNk5KSErxeb103ReS4s9vtOByOWi8doqAiIhIGHo+HPXv2kJ+fX9dNEakzMTExNGnSBJfLddTnUFARETnGfD4f27Ztw26307RpU1wulxaklJOKaZp4PB727dvHtm3baN++fbWLulVHQUVE5BjzeDz4fD5SU1OJiYmp6+aI1Ino6GicTic7duzA4/EQFRV1VOdRMa2ISJgc7SdIkd+KY/Ea0KtIREREIpaCioiIHHOtWrXi2WefretmhM28efMwDIPMzMy6bspvnoKKiIgAcN1112EYBk888UTI9hkzZhxxMfDy5cu55ZZbjmXzKjV48GDsdjvLly8P+8/6rTlRwqSCioiIBEVFRfHPf/6TQ4cO1eo8DRs2DHshcVpaGosWLeLOO+/ktddeC+vPCgePx1PXTTgmwv04FFSk1vI9Jfznuy1s359X100RkVoaNGgQjRs3ZuLEidUe99FHH9GlSxfcbjetWrXi3//+d8j+sp/WTdPkkUceoUWLFrjdbpo2bcrdd98NwIQJEzj11FMrnL9Hjx489NBD1bZhypQpXHrppdx+++1MmzaNgoKCkP2ZmZnceuutpKSkEBUVxamnnspnn30W3L9w4ULOPfdcYmJiqFevHoMHDw4GNJ/Px8SJE2ndujXR0dF0796dDz/8sNr2LFiwgLPPPpvo6GhSU1O5++67ycsr/bvYqlUrHn30Ua699loSEhKCPU41eS4fe+wxrr32WuLi4mjZsiWffPIJ+/btY9iwYcTFxdGtWzd++OGHGrfn3HPPZceOHdx7770YhhHSY3a0jyNszBNcVlaWCZhZWVl13ZST1rgZP5st//aZ2Wbs53XdFJGIUFBQYK5du9YsKCgIbvP5fGZeUfFxv/l8vhq3e9SoUeawYcPMjz/+2IyKijJ37txpmqZpTp8+3Sz7dvHDDz+YNpvNnDBhgrlhwwZzypQpZnR0tDllypTgMS1btjSfeeYZ0zRN84MPPjATEhLML774wtyxY4e5dOlS8z//+Y9pmqa5c+dO02azmcuWLQved+XKlaZhGOaWLVuqbKvP5zNbtmxpfvbZZ6Zpmmbv3r3NN954I7jf6/Wa/fr1M7t06WLOnj3b3LJli/npp5+aX3zxhWmapvnjjz+abrfbvP32281Vq1aZa9asMV944QVz3759pmma5mOPPWZ27NjRnDVrlrllyxZzypQpptvtNufNm2eapml+++23JmAeOnTINE3T3Lx5sxkbG2s+88wz5saNG82FCxeaPXv2NK+77rqQ5yQhIcH817/+ZW7evNncvHlzjZ/L5ORk85VXXjE3btxo3n777WZCQoI5ZMgQ8/333zc3bNhgXnbZZWanTp2Cv+/DtefAgQNm8+bNzQkTJph79uwx9+zZU6vHUZXKXgsBNX3/NkzTNMMbhcIrOzubxMREsrKySEhIqOvmnJSGPPsd69NzANj+xCV13BqRuldYWMi2bdto3bp1cO2IfE8Jncd9ddzbsnbCYGJcNVsy67rrriMzM5MZM2bQv39/OnfuzOTJk5kxYwaXX345gbeLkSNHsm/fPmbPnh287/3338/nn3/OL7/8Alifuu+55x7uuecenn76aV599VXWrFmD0+ms8HMvvvhiWrVqxUsvvQTA3Xffzc8//8y3335bZVvnzJnDyJEj2b17Nw6Hg2effZYZM2Ywb948AGbPns1FF13EunXr6NChQ4X7/+EPfyAtLY0FCxZU2FdUVERycjJff/01/fv3D26/6aabyM/P55133mHevHmcd955HDp0iKSkJG666Sbsdjuvvvpq8PgFCxYwYMAA8vLyiIqKolWrVvTs2ZPp06cHj6npc3n22Wfz5ptvApCenk6TJk146KGHmDBhAgBLliyhf//+7Nmzh8aNG9e4PYHfUdnHeDSPoyqVvRYCavr+raEfOSYacwADX103Q0SOkX/+85+8/vrrrFu3rsK+devWceaZZ4ZsO/PMM9m0aVOl1zW68sorKSgooE2bNtx8881Mnz6dkpKS4P6bb76ZadOmUVhYiMfj4Z133uGGG26otn2vvfYaV111FQ6HFcKuueYaFi5cyJYtWwBYtWoVzZs3rzSkBPYPHDiw0n2bN28mPz+fCy64gLi4uODtjTfeCJ6/vNWrVzN16tSQ4wcPHhxcpTjgtNNOC7lfTZ/Lbt26Bb9OSUkBoGvXrhW27d2794jac6weRzhpZVqptbM9C/h71D+Z6T0DGFrXzRGJSNFOO2snDK6Tn3s0zjnnHAYPHszYsWO57rrratWG1NRUNmzYwNdff82cOXO44447eOqpp5g/fz5Op5OhQ4fidruZPn06LpeL4uJirrjiiirPd/DgQaZPn05xcTEvv/xycLvX6+W1117jH//4B9HR0dW2qbr9ubm5AHz++ec0a9YsZJ/b7a7yPrfeemuw9qasFi1aBL+OjY2ttl1VKdsTFagnqWybz+c7ovaUF+7HcTQUVKTWril8D4Bh9kV13BKRyGUYRo2HYCLFE088QY8ePTjllFNCtnfq1ImFCxeGbFu4cCEdOnTAbq88GEVHRzN06FCGDh3K6NGj6dixIz///DO9evXC4XAwatQopkyZgsvl4uqrr642SLz99ts0b96cGTNmhGyfPXs2//73v5kwYQLdunVj165dbNy4sdJelW7dujF37lzGjx9fYV/nzp1xu92kpaUxYMCAKttRVq9evVi7di3t2rWr0fEBR/NcHqv2uFyuCj1gR/s4wunEetWIiMhx07VrV0aOHMnzzz8fsv2+++6jT58+PProo1x11VUsXryYF198MVhjUt7UqVPxer307duXmJgY3nrrLaKjo2nZsmXwmJtuuolOnToBVHjjLm/y5MlcccUVFWYLpaamMnbsWGbNmsUll1zCOeecw4gRI3j66adp164d69evxzAMhgwZwtixY+natSt33HEHt912Gy6Xi2+//ZYrr7ySBg0a8Je//IV7770Xn8/HWWedRVZWFgsXLiQhIYFRo0ZVaNPf/vY3+vXrx5133slNN91EbGwsa9euZc6cObz44otVPpYjfS5rqibtadWqFd999x1XX301brebBg0aHPXjCCfVqIiISJUmTJgQHE4I6NWrF++//z7vvvsup556KuPGjWPChAlVDhElJSXx3//+lzPPPJNu3brx9ddf8+mnn1K/fv3gMe3bt+eMM86gY8eO9O3bt8r2rFixgtWrVzNixIgK+xITExk4cCCTJ08GrGm/ffr04ZprrqFz587cf//9wR6EDh06MHv2bFavXs3pp59O//79mTlzZrDm5dFHH+Whhx5i4sSJdOrUiSFDhvD555/TunXrStvVrVs35s+fz8aNGzn77LPp2bMn48aNo2nTplU/uUfxXNZUTdozYcIEtm/fTtu2bWnYsGGtHkc4hXXWzyOPPFKhW+2UU05h/fr1gFUNfN999/Huu+9SVFTE4MGDeemll4JFQTWhWT91b+uE7rTxbbe+eSSrTtsiEgmqm+kglTNNk/bt23PHHXcwZsyYum6OHCMnxKyfLl26sGfPnuCt7FSwe++9l08//ZQPPviA+fPns3v3boYPHx7uJomISATZt28fL774Iunp6Vx//fV13RyJMGGvUXE4HDRu3LjC9qysLCZPnsw777zD+eefD1irDHbq1IklS5bQr1+/cDdNREQiQKNGjWjQoAH/+c9/qFevXl03RyJM2HtUNm3aRNOmTWnTpg0jR44kLS0NsMYZi4uLGTRoUPDYjh070qJFCxYvXhzuZomISIQwTZN9+/bxhz/8oa6bIhEorD0qffv2ZerUqZxyyins2bOH8ePHc/bZZ7NmzRrS09NxuVwkJSWF3CclJYX09PQqz1lUVERRUVHw++zs7HA1X0REROpYWIPKRRddFPy6W7du9O3bl5YtW/L+++8fdjGeqkycOLHSee8iIiLy23NcpycnJSXRoUMHNm/eTOPGjfF4PGRmZoYck5GRUWlNS8DYsWPJysoK3nbu3BnmVouIiEhdOa5BJTc3ly1bttCkSRN69+6N0+lk7ty5wf0bNmwgLS0t5CJQ5bndbhISEkJuIiIi8tsU1qGfv/zlLwwdOpSWLVuye/duHn74Yex2O9dccw2JiYnceOONjBkzhuTkZBISErjrrrvo37+/ZvyIiIgIEOagsmvXLq655hoOHDhAw4YNOeuss1iyZElwBbxnnnkGm83GiBEjQhZ8ExEREYEwB5V333232v1RUVFMmjSJSZMmhbMZIiJyDBmGwfTp07nsssvquil1rlWrVtxzzz3cc889dd2U3yxd60dERILS09O56667aNOmDW63m9TUVIYOHRpSTxhppk2bht1uZ/To0XXdlBPOI488Qo8ePeq6GdVSUBEREQC2b99O7969+eabb3jqqaf4+eefmTVrFuedd15Eh4DJkydz//33M23aNAoLC+u6OUfE4/HUdROOiXA+DgUVEREB4I477sAwDJYtW8aIESPo0KEDXbp0YcyYMSxZsqTK++3cuZPf//73JCUlkZyczLBhw9i+fXtw//Lly7ngggto0KABiYmJDBgwgJUrV4acwzAM/ve//3H55ZcTExND+/bt+eSTTw7b5m3btrFo0SIeeOABOnTowMcff1zhmNdee40uXbrgdrtp0qQJd955Z3BfZmYmt956KykpKURFRXHqqafy2WefBfcvWLCAs88+m+joaFJTU7n77rvJy8ursj2ZmZncdNNNNGzYkISEBM4//3xWr14d3B/owfjf//4XcqG+tLQ0hg0bRlxcHAkJCfz+978nIyOjwv1ee+01WrRoQVxcHHfccQder5cnn3ySxo0b06hRI/7xj3/UuD1Tp05l/PjxrF69GsMwMAyDqVOn1upxhIOCiojI8WCa4Mk7/jfTrFHzDh48yKxZsxg9ejSxsbEV9pdfRTyguLiYwYMHEx8fz/fff8/ChQuJi4tjyJAhwU/ZOTk5jBo1igULFrBkyRLat2/PxRdfTE5OTsi5xo8fz+9//3t++uknLr74YkaOHMnBgwerbfeUKVO45JJLSExM5I9//COTJ08O2f/yyy8zevRobrnlFn7++Wc++eQT2rVrB4DP5+Oiiy5i4cKFvPXWW6xdu5YnnngCu90OwJYtWxgyZAgjRozgp59+4r333mPBggUhQae8K6+8kr179/Lll1+yYsUKevXqxcCBA0Mex+bNm/noo4/4+OOPWbVqFT6fj2HDhnHw4EHmz5/PnDlz2Lp1K1dddVXIubds2cKXX37JrFmzmDZtGpMnT+aSSy5h165dzJ8/n3/+8588+OCDLF26tEbtueqqq7jvvvtCLh4c+JlH8zjCxjzBZWVlmYCZlZVV1005aW0Z3800H06wbiJiFhQUmGvXrjULCgpKNxbllr5OjuetKLdGbV66dKkJmB9//PFhjwXM6dOnm6Zpmm+++aZ5yimnmD6fr/ShFhWZ0dHR5ldffVXp/b1erxkfH29++umnIed88MEHg9/n5uaagPnll19W2Q6v12umpqaaM2bMME3TNPft22e6XC5z69atwWOaNm1q/v3vf6/0/l999ZVps9nMDRs2VLr/xhtvNG+55ZaQbd9//71ps9mCv9uWLVuazzzzTHBfQkKCWVhYGHKftm3bmq+++qppmqb58MMPm06n09y7d29w/+zZs0273W6mpaUFt/3yyy8mYC5btix4v5iYGDM7Ozt4zODBg81WrVqZXq83uO2UU04xJ06ceETt6d69e4XHeDSPozKVvhb8avr+HfarJ4uISOQza9jzUt7q1avZvHkz8fHxIdsLCwvZsmULYK04/uCDDzJv3jz27t2L1+slPz8/eJHagG7dugW/jo2NJSEhgb1791b5s+fMmUNeXh4XX3wxAA0aNOCCCy7gtdde49FHH2Xv3r3s3r2bgQMHVnr/VatW0bx5czp06FDlY/vpp594++23g9tM08Tn87Ft2zY6depU4fjc3Fzq168fsr2goCD4XAC0bNkyuEwHwLp160hNTSU1NTW4rXPnziQlJbFu3Tr69OkDWDOMyj7PKSkp2O12bDZbyLbAc1bT9lT2uI/mcYSLgoqIyPHgjIH/2103P7cG2rdvj2EYrF+//ohOn5ubS+/evUPezAMCb2KjRo3iwIEDPPfcc7Rs2RK3203//v0rFGA6nc6Q7w3DwOfzVfmzJ0+ezMGDB0OuHefz+fjpp58YP378Ya8pd7j9ubm53Hrrrdx9990V9rVo0aLS45s0acK8efMq7Cs7dFbZ0FpNVPb8VPec1bQ95YX7cRwpBRURkePBMMB1fP6wH43k5GQGDx7MpEmTuPvuuyu8CWVmZlb65tarVy/ee+89GjVqVOUlTRYuXMhLL70U7PnYuXMn+/fvr1V7Dxw4wMyZM3n33Xfp0qVLcLvX6+Wss85i9uzZDBkyhFatWjF37lzOO++8Cufo1q0bu3btYuPGjZX2qvTq1Yu1a9cGa1oOp1evXqSnp+NwOGjVqlWNH0unTp3YuXMnO3fuDPaqrF27lszMTDp37lzj8xxNe1wuF16v94jvdzypmFZERACYNGkSXq+X008/nY8++ohNmzaxbt06nn/++SqvwTZy5EgaNGjAsGHD+P7779m2bRvz5s3j7rvvZteuXYDVW/Pmm2+ybt06li5dysiRIw/bm3E4b775JvXr1+f3v/89p556avDWvXt3Lr744mBR7SOPPMK///1vnn/+eTZt2sTKlSt54YUXABgwYADnnHMOI0aMYM6cOWzbti1YrArwt7/9jUWLFnHnnXeyatUqNm3axMyZM6ssph00aBD9+/fnsssuY/bs2Wzfvp1Fixbx97//nR9++KHKxzJo0CC6du3KyJEjWblyJcuWLePaa69lwIABnHbaaUf9HNWkPa1atWLbtm2sWrWK/fv3U1RUdNSPI1wUVEREBIA2bdqwcuVKzjvvPO677z5OPfVULrjgAubOncvLL79c6X1iYmL47rvvaNGiBcOHD6dTp07ceOONFBYWBntYJk+ezKFDh+jVqxd/+tOfuPvuu2nUqFGt2vraa69x+eWXYxhGhX0jRozgk08+Yf/+/YwaNYpnn32Wl156iS5dunDppZeyadOm4LEfffQRffr04ZprrqFz587cf//9wR6Gbt26MX/+fDZu3MjZZ59Nz549GTduHE2bNq20TYZh8MUXX3DOOedw/fXX06FDB66++mp27NhBSkpKlY/FMAxmzpxJvXr1OOeccxg0aBBt2rThvffeq9VzVJP2jBgxgiFDhnDeeefRsGFDpk2bdtSPI1wM82grqCJEdnY2iYmJZGVl6UrKdWTrhO608W23vnkkq07bIhIJCgsL2bZtW9jXlxCJdNW9Fmr6/q0eFREREYlYCioiIiISsRRUREREJGIpqIiIiEjEUlARERGRiKWgIiISJif4pEqRWjsWrwEFFRGRYyywrHl+fn4dt0SkbgVeA+WX+j8SWkJfROQYs9vtJCUlBS8OFxMTU+nCZCK/VaZpkp+fz969e0lKSsJutx/1uRRURETCoHHjxgDVXv1X5LcuKSkp+Fo4WgoqIiJhYBgGTZo0oVGjRhQXF9d1c0SOO6fTWauelAAFFRGRMLLb7cfkj7XIyUrFtCIiIhKxFFREREQkYimoiIiISMRSUBEREZGIpaAiIiIiEUtBRURERCKWgoqIiIhELAUVERERiVgKKiIiIhKxFFREREQkYimoiIiISMRSUBEREZGIpaAiIiIiEUtBRWrNxKjrJoiIyG+UgorUmoFZ100QEZHfKAUVERERiVgKKiIiIhKxjltQeeKJJzAMg3vuuSe4rbCwkNGjR1O/fn3i4uIYMWIEGRkZx6tJIiIiEuGOS1BZvnw5r776Kt26dQvZfu+99/Lpp5/ywQcfMH/+fHbv3s3w4cOPR5PkGFIxrYiIhEvYg0pubi4jR47kv//9L/Xq1Qtuz8rKYvLkyTz99NOcf/759O7dmylTprBo0SKWLFkS7mbJMaRiWhERCZewB5XRo0dzySWXMGjQoJDtK1asoLi4OGR7x44dadGiBYsXL67yfEVFRWRnZ4fcRERE5LfJEc6Tv/vuu6xcuZLly5dX2Jeeno7L5SIpKSlke0pKCunp6VWec+LEiYwfP/5YN1VEREQiUNh6VHbu3Mmf//xn3n77baKioo7ZeceOHUtWVlbwtnPnzmN2bhEREYksYQsqK1asYO/evfTq1QuHw4HD4WD+/Pk8//zzOBwOUlJS8Hg8ZGZmhtwvIyODxo0bV3let9tNQkJCyE3qloppRUQkXMI29DNw4EB+/vnnkG3XX389HTt25G9/+xupqak4nU7mzp3LiBEjANiwYQNpaWn0798/XM2SMFAxrYiIhEvYgkp8fDynnnpqyLbY2Fjq168f3H7jjTcyZswYkpOTSUhI4K677qJ///7069cvXM0SERGRE0hYi2kP55lnnsFmszFixAiKiooYPHgwL730Ul02SURERCKIYZrmCd1vn52dTWJiIllZWapXqSNbJ3SnjW+79c0jWXXaFhEROTHU9P1b1/qRWlMxrYiIhIuCitSaYZzQnXIiIhLBFFSk9pRTREQkTBRUREREJGIpqIiIiEjEUlCRWlMxrYiIhIuCitSaimlFRCRcFFSk9pRTREQkTBRUREREJGIpqIiIiEjEUlCRWlMxrYiIhIuCitSaimlFRCRcFFSk9pRTREQkTBRUREREJGIpqIiIiEjEUlCRWlMxrYiIhIuCitSaimlFRCRcFFSk9pRTREQkTBRUREREJGIpqIiIiEjEUlCRWlMxrYiIhIuCitSaimlFRCRcFFSk9pRTREQkTBRUREREJGIpqIiIiEjEUlCRWlMxrYiIhIuCitSaimlFRCRcFFSk9pRTREQkTBRUREREJGIpqIiIiEjEUlCRWlMxrYiIhIuCitSaimlFRCRcFFSk9pRTREQkTBRUREREJGIpqIiIiEjEUlCRWlMxrYiIhIuCitSaimlFRCRcFFSk9pRTREQkTBRUREREJGKFNai8/PLLdOvWjYSEBBISEujfvz9ffvllcH9hYSGjR4+mfv36xMXFMWLECDIyMsLZJBERETmBhDWoNG/enCeeeIIVK1bwww8/cP755zNs2DB++eUXAO69914+/fRTPvjgA+bPn8/u3bsZPnx4OJskYaBiWhERCRfDNM3jWmGQnJzMU089xRVXXEHDhg155513uOKKKwBYv349nTp1YvHixfTr169G58vOziYxMZGsrCwSEhLC2XSpwtZHu9PGu9365pGsOm2LiIicGGr6/n3calS8Xi/vvvsueXl59O/fnxUrVlBcXMygQYOCx3Ts2JEWLVqwePHiKs9TVFREdnZ2yE3qmIppRUQkTMIeVH7++Wfi4uJwu93cdtttTJ8+nc6dO5Oeno7L5SIpKSnk+JSUFNLT06s838SJE0lMTAzeUlNTw/wIREREpK6EPaiccsoprFq1iqVLl3L77bczatQo1q5de9TnGzt2LFlZWcHbzp07j2Fr5WioRkVERMLFEe4f4HK5aNeuHQC9e/dm+fLlPPfcc1x11VV4PB4yMzNDelUyMjJo3Lhxledzu9243e5wN1uOhHKKiIiEyXFfR8Xn81FUVETv3r1xOp3MnTs3uG/Dhg2kpaXRv3//490sqQVDRSoiIhImYe1RGTt2LBdddBEtWrQgJyeHd955h3nz5vHVV1+RmJjIjTfeyJgxY0hOTiYhIYG77rqL/v3713jGj0QI5RQREQmTsAaVvXv3cu2117Jnzx4SExPp1q0bX331FRdccAEAzzzzDDabjREjRlBUVMTgwYN56aWXwtkkEREROYEc93VUjjWto1L3tkzoQVvfNusbraMiIiI1EHHrqMhvmIppRUQkTBRUpNZUTCsiIuGioCK1p5wiIiJhoqAiIiIiEUtBRWpNK9OKiEi4KKhI7SmniIhImCioSK2pmFZERMJFQUVqTzlFRETCREFFREREIpaCitSaimlFRCRcFFSk9pRTREQkTBRUpNZUTCsiIuGioCK1p5wiIiJhoqAiIiIiEUtBRWpNxbQiIhIuCipSe8opIiISJgoqUmsqphURkXBRUJHaU04REZEwUVARERGRiKWgIrWmYloREQkXBRWpPeUUEREJEwUVqTUV04qISLgoqEjtKaeIiEiYKKiIiIhIxFJQkVpTMa2IiISLgorUnnKKiIiEiYKK1JqKaUVEJFwUVKT2lFNERCRMFFREREQkYimoSK2pmFZERMJFQUVqTzlFRETCREFFak3FtCIiEi4KKlJ7yikiIhImCioiIiISsRRUpNZUTCsiIuGioCK1p5wiIiJhoqAitaZiWhERCRcFFak95RQREQmTsAaViRMn0qdPH+Lj42nUqBGXXXYZGzZsCDmmsLCQ0aNHU79+feLi4hgxYgQZGRnhbJaIiIicIMIaVObPn8/o0aNZsmQJc+bMobi4mAsvvJC8vLzgMffeey+ffvopH3zwAfPnz2f37t0MHz48nM2SY0zFtCIiEi6OcJ581qxZId9PnTqVRo0asWLFCs455xyysrKYPHky77zzDueffz4AU6ZMoVOnTixZsoR+/fqFs3lyrCiniIhImBzXGpWsrCwAkpOTAVixYgXFxcUMGjQoeEzHjh1p0aIFixcvrvQcRUVFZGdnh9ykbqmYVkREwuW4BRWfz8c999zDmWeeyamnngpAeno6LpeLpKSkkGNTUlJIT0+v9DwTJ04kMTExeEtNTQ130+VwlFNERCRMjltQGT16NGvWrOHdd9+t1XnGjh1LVlZW8LZz585j1EIRERGJNGGtUQm48847+eyzz/juu+9o3rx5cHvjxo3xeDxkZmaG9KpkZGTQuHHjSs/ldrtxu93hbrIcAdNQkYqIiIRHWHtUTNPkzjvvZPr06XzzzTe0bt06ZH/v3r1xOp3MnTs3uG3Dhg2kpaXRv3//cDZNRERETgBh7VEZPXo077zzDjNnziQ+Pj5Yd5KYmEh0dDSJiYnceOONjBkzhuTkZBISErjrrrvo37+/ZvycQFRMKyIi4RLWoPLyyy8DcO6554ZsnzJlCtdddx0AzzzzDDabjREjRlBUVMTgwYN56aWXwtksOdaUU0REJEzCGlRM8/DvYFFRUUyaNIlJkyaFsykiIiJyAtK1fqTWVEwrIiLhoqAiIiIiEUtBRWpNxbQiIhIuCipSe8opIiISJgoqUmu6erKIiISLgorUnnKKiIiEiYKKiIiIRCwFFak1FdOKiEi4KKhI7SmniIhImCioSK2pmFZERMJFQUVqTzlFRETCREFFREREIpaCitSaimlFRCRcFFSk9pRTREQkTBRUpNZUTCsiIuGioCK1p5wiIiJhoqAiIiIiEUtBRWpNxbQiIhIuCipSe8opIiISJgoqUmsqphURkXBRUJHaU04REZEwUVARERGRiKWgIrWmYloREQkXBRWpPeUUEREJEwUVqTUV04qISLgoqEjtKaeIiEiYKKiIiIhIxFJQkVpTMa2IiISLgorUnnKKiIiEiYKK1JqKaUVEJFwUVKT2lFNERCRMFFREREQkYimoSK2pmFZERMJFQaUGsguLeWHuJnYcyAvZ/uaSHVz83PfsOpRfRy2LEMopIiISJgoqNfDYZ2v595yNXPnK4uC23KISHpqxhrV7srnk+QV12Lq6p2JaEREJFwWVGvh2wz4A9uYUBbftySwIfp1VUHzc2xRRlFNERCRMFFRqYF+ZgAKwbNtBLnjmu5BtE79YdzybJCIiclJQUDkK03/cVWHbq99trYOWRAYV04qISLgoqBxG+d4UAJ+vDhoiIiJyEgprUPnuu+8YOnQoTZs2xTAMZsyYEbLfNE3GjRtHkyZNiI6OZtCgQWzatCmcTTpi1pCOSQK5wW2GajJCqJhWRETCJaxBJS8vj+7duzNp0qRK9z/55JM8//zzvPLKKyxdupTY2FgGDx5MYWFhOJt1RH7NLOAO+0x+irqFc20/sje7kM17cys9ttirrhYREZFjyRHOk1900UVcdNFFle4zTZNnn32WBx98kGHDhgHwxhtvkJKSwowZM7j66qvD2bQai49ycr/zfQD+7niH0x/vCYAbD/1s68gxo1lptgcMpizcxi3ntK3D1oqIiPy2hDWoVGfbtm2kp6czaNCg4LbExET69u3L4sWLqwwqRUVFFBWV1o1kZ2eHtZ1dm8bDNuvrHGIASCCX6a6HaWvbA8BH3rO4r/h2fkzLDGtbIpWKaUVEJFzqrJg2PT0dgJSUlJDtKSkpwX2VmThxIomJicFbampqWNsZX/Rr8OscMxqAi+zLgyHFaxqMsC9gqG0xTrtqk0VERI6lE+6ddezYsWRlZQVvO3fuDOvPq5dTWtybZFi1KXFYS+bvbzWU50uGA3Cz43MKi71hbUukUjGtiIiES50FlcaNGwOQkZERsj0jIyO4rzJut5uEhISQWzjFFO4Nft3IyAQgCmsl2uR69bj5vsfxGna62baRkHvyrqUiIiISDnUWVFq3bk3jxo2ZO3ducFt2djZLly6lf//+ddWsirye4JcNyMLAR5RhbbM5o4lLbsyhlDMA6JH7XaWnEBERkaMT1mLa3NxcNm/eHPx+27ZtrFq1iuTkZFq0aME999zDY489Rvv27WndujUPPfQQTZs25bLLLgtns46MtyT4pdPwkkQuUfjDizMKgKzWF9Mg/Xt6FS7B5zOx2U6uoRAV04qISLiEtUflhx9+oGfPnvTsaU3pHTNmDD179mTcuHEA3H///dx1113ccsst9OnTh9zcXGbNmkVUVFQ4m3VkfKEXHDzXtprL3Cusb9zWsFNJywEAdPBuof+EmZRoPRUREZFjIqw9Kueeey6mWfWnbcMwmDBhAhMmTAhnM2rFKBdUnnG9DF4gqSX0+AMALdt2ZKevIam2fZziWcv2A4No1yiuDlpbN1RMKyIi4XLCzfo53soHFQDaD4Zb50NCUwCinHY2RncD4DTbBgo8J+fsHxERkWNNQeUwDG+ZoGJ3wXkPwjXvQnS9kOM2OToAcKqxnUP5HkRERKT26mxl2hOGv0dlTdubOPWaieBwVXrYFkc7ALratrHkJAsqKqYVEZFwUY/KYdgCQz82V5UhBSC/Xke8pkFDI4tH3/32OLVORETkt01B5TBspjU92XA4qz1u7LBebDGtmpXOtu3hblZEUTGtiIiEi4LKYQR7VOxV96YANK8XwyazGQBtjT3VznYSERGRmlFQOQybz+pRsdmr71EBiG/WGYC2xm7yNPNHRESk1hRUDsNmWj0qRjX1KQFn9O0HQFvb7pNqirKKaUVEJFwUVA4jWKNSgx4VR6NTAGhj7D5pr6QsIiJyLCmoHIbdX6Niq0GPCg3aA9DQyKYwe384mxVRVEwrIiLhoqByGHasnpEaBRV3PPtIBuD5978MZ7NEREROCgoqhxHoUalJjQrAQbc188fITMNToosTioiI1IaCymHYsWpU7IdZRyWgXYcuADQ39lFYojoVERGR2lBQOQyHv5jW5nDX6HhbvRaAFVROppk/IiIi4aCgchhH2qNi1GsJKKiIiIgcCwoqhxHoUbE7a9ajQpLVo9LM2E+BpiiLiIjUioLKYTj8s37szpoV0waCSnNjPwWe4nA1S0RE5KSgoFIN0zRxBId+atijktAMr2ngNorZum1bGFsnIiLy26egUo0SX2lQcdS0R8XuZA/1AXj7qwXhapqIiMhJQUGlGiVeE1egR6WmQQXIMOsB0Mg4FJZ2Ha3CYi9b9+XWdTNERERqTEGlGh6vL1ij4qhpMS2lQaVxhAWVG19fzvn/ns/CzSfP8v4iInJiU1CpRonXh9Pfo+J01bxHpWXLNgCkRFhQWbj5AABvLt5Rxy0RERGpGQWVapR4fbgMq0fFsNc8qLRpa12cMMU4xMq0yAgrh/I8wa+NSq4h+PgX6xj78U+YpnlMf+7mvbmM/N8Slmw9cEzPKyIiJwcFlWp4PKVv7thrtuAbgC2+CQApHGT4S4uOQUPyIX1NrU7x8vwtVe4rLPbyn++2Mm3ZTnYeLKjVzynvjrdXsHDzAa7+z5Jjel4RETk5KKhUw1tSJqjYah5U7ElNAUgxMmvdBk+Jjy0vjYBXzuSjl8eRW1RS5bFFJV4+Wb2bXzMrho39OUVV3m9fmX0//Zp5xG0sKi69+OKbi7cDkFNYzPs/7GRjRs2Ld1ftzOSX3Vlsyshh2baDFfaXeH189Us6B8v0DtXED9sP8sXPe/D6jry36EBuEbN/SafEqwtMRpqiEi+z1qSTVRCe9YpKvD5m/5LOgdyqXzsiEn4KKtXwFpf5A3UEQz/2xEBQqf2wz0tfLKVtptUr02HPTAY/812Vx765eAd3T/uRO95aUWFfYkxp0Movt7T/95tKi2vvfOfHI2rfxoyckO8fmvkLP6Yd4o63V3L/hz/V+DxZBcVcNmkhlzy/gAue+Y7fv7qY3eUC13+/38atb67gqlcXH9F5r3hlMXe8vZL5G/fW+H4BwyYt5JY3V/DmEtX1RJp/fbWB295awY1Tl4fl/FMXbeeWN1dw+bHoFRWRo6agUo3i4qMb+jH8Qz8JRj7RFNaqDT8u+Tb4dRPjYKW9JQFf/LwHgNW7sirs65ASH/z6UH5oj0RRLa7y/HMlP+unXVkh4acmKuslSc8Ofe4+Wb0bgE17a95Lk5Vf+ml7x4H8I2oTwK5D1vP91S/pR3xfCa8PV+wC4Icd4akD+3KN9TtPO3jk/29E5Nhx1HUDIpnXH1RKsOOorAK1KlEJ5JpRxBmFte5VSTVKewEaGNnEUnVQWZmWSWMOcIj4CvvKDl0cyA0NBbW5JlFlwykOe9XPVXZhMUNfWBAMDQ6bwebHL8ZWyV3cjtAcvW5PdvDrVTsz6ZGaBFhh6U+vLSUx2sknd55FYrQVKn0+kxGvlH4aHv/pWv7YryVOe+l5b39rRfANadW4C0iKcbEhPYdRry0jp7A05CzZWnEoqtUDnwPQsn4M8/96XqWP9/tN+7jv/dVMHN6VgZ1Sgtu/Xb+XO99ZydDuTXliRLcK9/twxS6e+HId+8v8rh697FT+1K9l8HvTNGk99gsA7h9yClMXbufxy7syqHNKhfPVRIHHy7BJCzitVTKPX961wv4Xv9nEv2ZvBGBYj6Y8d3XPSs/j85lc/Z8lZBcWk55dSGZ+MSP7tuAflZwTYMGm/Yx+ZyVZBcVcc3oLerZI4unZG5lyfR86NUkIOfZ/329l0rebOZR/ZMM9y7cfZPTbK3l4aBfaNYrjuinL+PPA9lx9eosq71O2sLzv41/z90s68+uhAt5asoMPbutP06Toan9m2d/Px3ecwcodh5iycDvv3tKP1OSYI2r/0Xh6zkZm/Pgr0+84g/pxNV9eQSTSqEelGmWDypEKrKWSQmat2tDCCB2uSDX2VXns2bafWBJ1F2+7Hodys3eKvaXfl+9RKazFVZ69lcwSctqq/m81bWlaSM9Gic+kxOvDoGJSKfFWXVNy65s/BL/+btM+MvOL2XEgP6SHZ/uBvJD6G4Af0zJL2+4zgyEFrK5+gAc+/on07ELyqnleyr6JVddTc+1ry9ibU8SNr/8Qsn3qou3keby8u3xnpff7ywerQ0IKwEMzQguqswtL65WenLWBvTlF3PRG6M85EnPWZbAxI5d3lqZVuj8QUgBmrtqNr4qan63781i2/SDr03PI9AeKt6s4J8ANry8P1plMW5bG/R9az/9fP1xd4djHPl93xCEF4K53fmRvThGj31nJAx//xJ6sQh74+Oca3z8ju4i7p/3IP2et59fMAp6ctf6w9ylbT3blK4t57PN1/JpZwBM1uO+x8PzcTaQdzOd/C3QpDzmxqUelGt4S603OexRP016zHm3ZQ4pR8ZP4kSgfVOobFYdawHrjvMRmzaw5zbaRgv3biW7YOri/2OvDjpfmxj52eFIoLPYS5bQCWNkelVhXaCj77Kfd/Hv2Rto1iqNL0wR6t6zH2e0bBvev+TWL7uXaUlWPSnpWITsq6UbPLCjGpOKb3riZa3j9htNZuzubpeWKawNv4vmeEp76akNw+x8nL+WeQe25/dy2bD+QV+Gcv391MR/e1p9WDWIZ/+nakH3Pfr2J8zs2orC4+sLZEq+PF77ZHLLtk9W7+V13qzZpztoMvvx5Dx//+GuF+3p9Jq8t2Mb8jaWB8+/Tf8ZuM2ifEh/SY1IZr8/E7u9+KqgiSG3KyKF9maG+acvS+Gb9XuaszWBAh4ZMvb4PRrkewn051htxwOItB+jftn61bbn1rRUM7d6U/TlFXH9mq+A5py2rPJQUlXhxO0r/f/l8Jq8t3IanpPLnu7ik9lPlTdNkzPurQ4YRy4bVysz48VdiXNV/OMksV8CbV1TCpG83sy+niLvOb0+L+jEcyis9pmzP48odh/jf91u54czW2Mp1JZZ4fby2cBtntG2AaVrh8ce0Q3y/aT+PXnYqTROjyCooZniv5tW2790yv4NAoJy3YS/frN/LgVwPPVskceNZrSv8P6hOvqeE1xftwOvzMf3HX3HabUy5vg9NEqvvWaqNJVsPsCkjhz/2a3lEbT1aa3dns2DzPq4/s3VIz6vULQWVavj8s36KjSN/mvZjdVnXN7IPc2T1UssFlWRyKj3u51+z6GLbHvz+20WLuXhYaVAp8Zk86XyVEfYFPFh8PYfyBwb/wJQNKp4yQ0T5npJgce22/XnMWZsBwPYnLgke8/bSNEaWqzN2VPEC7zdxbqXbD+V5gm++Za3elcVDM3/hU39tSlmBP/xPl/mUH/Ds15tw2m0hAaasK15ZzFWnpVZ63t+9uJCOjSsOnZX11pIdPDd3U8i2u6f9yMCOjYhx2bm5ml6N95bv5B9frAvZVra3oUOjOPq2qTogfLhiJ1f1sYYrcosq71m44Jnvgr+j1TszGVum52D+xn3MXbe3wvDQPe+FFlFf898lIb/nysxZmxH8P3Faq3p0a55EblEJk6v4BL9k60EGdCgNuZ//vIfHPl9X6bFApeH1SM3buI/plQTGquzNLuSe91YB0K15YpXH5ZWbfffUVxuCPXLfrN/Liocu4EBe5bOF9mQV8tjn60iKcXFF79DA8e7ynTz+ReU9LmV71Pq2qU+zKoaeft6VFdJbFHiDv25KadHx5z/voUliNJd0a1LFI6zo6dkbK/TOPP7Fel64pvIhwGMhsKxB24ZxnNGuQdh+TsDFz38PgM0wuOnsNmH/eVIziozVCExP9h5FUOnaoR0ATRyVB4uaamSzgs4OXyMAetSvfHrynqzCkN6XnL2hn2qLPCWMsFsXSbzePovcMsMGZacXF3vN4CewqqZCF3i8ZBdW3f2eX80U6sps2ZdX5dThysJEwKE8T7DAtryfdmVW+zPf+6HyIReoMGoWlFVQzN6cQhZUcQmCfTlFFFXROwDW83a4he/W7skmI7vqAuyFmw+QVVBMXlFJtUWeWQXFVf68eRv3kldUgqfER1Z+MZn5nuCqxWWV/R3nFpWQEFX16yAwxFPdVN5t5a4z9cP22vU2llXVlPVFh7lcxN6cwmCPjs9nhvT4VTelP68otDer7PN8IM/DjgN5bEiv/rW/vFwvYWGxl5U1LAzOzK96iv7Pv4b2uh7ILWJLJdf42piRQ1ZBMVkFxdW+ngO+3VBx1tynq3djmib7corYl1NEvqeErIJiir2+kBqvsrw+s8q/LdmFVlvKLzy5YPN+fD6zynMejbyikuBCmOUf/y+7rb+7pmmSXViMp8QX7MHMKdO+7MLiah9PZUq8vgpBV6qnHpVq+Eqs/7xHM/QTV78JbIEEbyYFHi/Rh+lKrsze7HzqmdlggCe5PWTuJcFXeQ/NVz9uYbBR+kc2bXvoAm9Tv/2JMVHW11GGh71lXiger4/xjik0N/Yzuvhuin0+3DZ7lUMLncbNAmCof6gjn9JCvWSyg5/mGnOAsc5ppJv1eKLkGswyudhFMW6KySGG295awfNH8ams56NzqtxXvjblSFT1Sb77+NnV3u/e91fx2qg+Ve4//R9fk3OYP1DjP11bYUiqrE9W764ynJVVXVvfWpLGW0vSiHLaqh3m6vbIbN6+qS/tU+I4/R+V94YFFBZ7+d/3W6vtIXnk07WkJscwsFMKe7MLef0wl3Ion12rqp0B6PXoHJ4Y3jWkOHbSt5v57/fV12cEHtf2Jy7htrdWMNvfQwSwO6vqwJjnqf73OOCpedXuByss3z2oPc2SovH5TM59al6FmW5VqawHEqyC8/+bHlp788GKXXzgnyFV1ttL00J6BufeN4C2DeMqPW9mvoct+yoOpQL0fXwue6t4vX09ZgDtGoWe8/qpy/lu4z4Wjz0/ZNjowxW7+MsHVl3SNaenMnF4aZH5S/O28NK8LVWe80hlFRQHXyMXdk5h9toMxlzQIbg/EEQenLEm2OMZ7bTz/q39GfriAi7snMK1/Vvxx8lLg/cp/3iq8rsXF7J2T3aweF8OTz0q1fAVH32PSr2G1pt4fSObPVlHt9rr/NWbcfqX8M+OawtArLfyGpVGvtAi2/KzjdpHlQac+mSTW+YThKPwEKMccxho/5GLbUuDnzDLf2osL9DbUWiWTt0eZl8Y/Pox52sMsy/iVsfnXGEvXf+lubGP79z3sMx9B/1s1pvyj/5LDXQ2tvNf57+52v5NhZ/Xwsjgavs3xFGxJ8GOlwRK/5CuPEwdQnXKrzNTUzmFJdXOoDpcSDneDleLA/DEl+v56peMwx5XUOytNqQEBN5EZ646fNgq3zNX/g24vPLFsVUN/VXGNM2QkHI41RV6H4npK60AkespqXFIAfBV8at7pZoVqMvbX673a8rCqkNdZb0pAVWFFLCGScv7zl+fVX5ILhBSAKYt21llL2tl5zxSZXvAAr/3p+dUHEYuOyxbUOzlgY9/Ct5n4peh/99n/Hj4/9Ng9ZoClfZiSuXUo1KNnfutUOA1ar6GSoA9zhqqaWBkH/X035hi680724zBF23VLbh9lXf3RxWGBpUkI7Srt553L4HJS1FGMZ6cfYDVxnqFpS/GVrb00qBymE+NYPWM9HNuAf8fzj62DUzxXkQ9sjnftip43JX2+XzgPReA2+2fBK8s/XfHWwz1PM6UhdtxUMIrzmdoYdvHQNtKVvvass60iksbksknrgdJMvK43L6AqzwPgX+mUEMyed81nubGfsaW3MSH3gHBn2vHy92Oj+lo7ORfJb9nkxlaE5BqZNDftpbvvN1Ix3qOA2unAERRhBc7xTV4qWzem8sf/7f0sMedSH7+NavKWoiy/vzuqhqdLyO7iMVbDlSo0wG46azWITUQu7MKg1PAa+rpORsZc0GHI+qKB2j39y+P6PhfMwuCbTu9VTLrDzPMU5V/zd7I/I37WL79yJYxuPj57/nniK6sT8+hRXIM4z9dy7NX9aDkKFZfDvhk1W66N0/ir+UWarQZFXu3amrqou0s2rI/uEL1nee1C+4LDD8Xe32Mm/lLhfu2/b8vqjzn1EXbubZ/S1amHWLNr9kM6NCQ/406Dafdhtdn0vfxucEg1iM1iVU7M7ltQFtyi4p5a0nVPXMBM1btZkYlYTowJFT+a6BCUXjagXye/XojtwxoQ3Ksi2v+s6TS53HnwXyembORm85uQ+emCXy6ejd3TfuR567uwbAezfD5TMZ/+gs9W9SjSWIUH6zYxd8v7kS92JOnN0Y9KtXIybNCgcc8iqcp1ioarE8WhbUMKvvNBIwoq7Avyld596vDkxnyfUKZXgevzyShXE9MSU7p2H39otJ6jcYcChbU1mQctZuxBYev9JNgH9sGwKS/bS02wyTXtMabehqbiaEQMDnPXlq42dW2nTbG7uB9W9iswGUzTK60zw8ed6V9HkmG9dj72tZzulFacPhnx0e0tmXgNLw84ng9pMflOvss/uyYzmD7D0x2PoWD0sfUiEN84nqIJ53/Zab7IZLKFSpfalvMavct/OC+jdOMigWOg23LecM5kVvtn4J/uGjr/tLfzzX2ubzvGs8o+1eVPndX2ufxhWssjzpew0XFsfe2xq/McD3IXNd9nGGr/FpPv7MtZJn7Dma4HiTVqLxH4FzbKr53/Zkfk/5GN6PyT9xuPDzu+B9fu/7CHfaZwccDMKvMYncNyOJN5+P86L6F+xzvhxwXyuQ2+ycsd9/OB65HaFGmbdf8t+J1n/rbfuHanQ/ykOPNSnvMyp/7d7aF/MMxmRvtX4Q8d8/7hzJmlPu03sXYznPOF3nW+SJdjO0Vzng0l1cIWFbLWpsjDSkBf/voZ6Ys3B4cKrznvVVVDtfWRHZhSYWQAkcfUgLKXkbjxW9LZ8sFwuTSrQernClWnTcW72DNr1ZYmL9xX3Cq/5dr9oT0Fq3amQlYvU01CSlHy+MNfe5vfWsFH//4K1e8vJiHZ/7Cln15bNtf8e/3fe+v5uMff+XSF6xC3rv8s+8C4X/WL+m8vngH97y3iqv+s8S/xtLxmeIeKRRUqrApI4dFm6w/0DHRRzH9LtaqUK9vZFdYYK2mYkqsP4AHScB0WzNRoqvoUXF7QoNIgpEXHGctLPaSYITeryCrNKhEF5fet7FxMDgtdPXOyoeZyurvH7rhlIspNu00NLJoxn7OtFmfkLI7XU1xfCpOw0sf2wbaGrtpahzEa3Ox1NcRgAtsK0L+JcZ67i6xL8Hwd9VcbF8W8nMvsVtvdk5KuNRe+sYXZxQyzB5Y5M3kOntprUYL2z4utZUee71jFvX8PU8pRiY3OEo/VUdTyGPO13AbxSQa+TzlfBU7pX+IehqbeMn5LOfYf2ascxp/KDdUdbbtJyY6J3O6bQPjna8Hp44HnGps5Snnf+hs28GfHF8zxvFhyH4nJbwZ+xw9bFtpa9vDy85naUToG1oy2Ux0/o9GRiY9bFv5vFFoG8EaZnvF+Qyptn3UK9zJ/1z/rjQIPOx4nT84vqGdbTf3O99jpL3ympRnnJM4276GekYudzlm8Cd75XVCV9rn84DzXRoaWfSxbeR15xO4qfx1cKbtZ95wPkGLjLnc6PiSt1yPVxrcAm6wz+J51yRGOubykPMtprvGhQTQSd9u5tXvSgPZiMZ7+SRmAsPsi7jMvojpUY/Qy6jYzV9ePbJ5xDGVHxqM52nnSyFhqyaaG3vpa6wjgZqvpFyZR4Z2pkvThMMfiDXj6ETxxuIdPD1n42GH9Grq9UXbmbUmnRfmbj78wWFwINeDp8THj2mHyPeUBBeozC0qCVmvKeBQvoc1v2YFg67PtGbplbVix6FKC6zf+2FnMPSs+TWL7zftY0N6DvtyitiYkRNSbJ2eVciOSpZqOJEoqFThgxW7cPr/6DudR9HF5u9RiTWKeHP+4cfuKxPlsf6DHjATsEdbf6hizCqGfkoyAciNtYoJE8kLdgPne7wkEvof9ZetpeO8bm/pH9LGxkE8Xi/b9+fxzNeH/2Pez+Z/bO0GssNpTYfubtsS7AHwtRqAs601FNPf9gtn26w/SsXN+zHfcRYA59t/BEwG2lZa57r4SYrssaQYmXQztpJqZHCqbTsYdrj8VQAusi/HwMfZtp9IMvLYayYxv+VdAFzmn93U29hIqm0fxfYYtna8FYA/OKw3YCclXBHosel2FQB/tH8dfDMdYf+eJCOPfWYimWYsrW0Z/M5WusrtXY7p2I3Sj5pjHB/4e4zAho+/O94OeZ7+7nwr5I36TsdMAA6YVgC90f4FLY3SP2ZDbYtoWrILopJIMxuRaORzu+OTkHPe4viMWKPICnZRiSRkrWe4/fuQY26zf0KUUQyNukB8UxoZmdzm+DTkmFbGHq6yzwNgT8q5ANzveJfEcm+wfY11nG1fg89wQq9rAfiL4/0Kx0VRxP2O96xvTrsB4pvS2pbBaMcMynNQwgTHVJyGl0ONz4DoZHrYtlYIbgFdjG383fGW9U1qP2ubbQfX22cFj3nqqw3Bq4C78fC492ns3kJoeSa0OhuX6eEF1wvV9tw04hAfux7mOsdsGuRuYLh9ATNcD1XaG1NeLAU873yBBe57eM/9KMvdd3CP48Ng6K4JO14G2FYzue0CrotZyF39kmt83xNJYFG6Y2Hz3lxue2sFGzJqN9PyaL27fCePfPoLl7+0iM7jKu9FLevBGWu49IUFIduGTVoY8v2IlxdVuWDfef+ax6w16Vz6wgL+NHkZg5/9jj7/+JoLn/mO/hNLPzj1mziXAU/NC7mcyIkmIoLKpEmTaNWqFVFRUfTt25dly5Yd/k5htnVfHk7/p7TYmKNY7todT7G/tiWJw/dMVMZVaBVbHTATaFDf6mWoKqhEl1jpvSjequlIMPIp9g/hFJVU7FFJcZapw/CWhpj6RjZFJT5W+otbU40MhtkWcGpDq0Yjjnwa+B9PPPmcZvOHmVbnkNLxDAAusi+jtS0DLzaadT8fWp8DwBllgkpUh4Fccc2NgBUouhtbaGnbi89wQPvBpNXrD8Ag+0qG2PzrP7Q6E7oMp8QZRyMjk57GZn7n7z353NuXtfUvxMSgj20jTdnP5f7AYusyjFYX3YMXG6fbNtDW+JWBtpU0NLLxxTaCoc9DQnOSjVyG2JZh4Au+8a1qfRNb2t8AwC2OzwGTjkYa59tX4TUNGL2cksRWNDCyGWn/GoALbT/Q0baTEmc8jFmPJ64ZTY2DwaGsDsZOhtiXY2KQPnw6C+mB0/Byq/0z/2/B5IFEf0/FmX/Ge8mzAFxj/yb43Dcgi2sDvRmXvQRn/wWAO+0zgr0qjThUOnx28VNw8ZMAXGf/KmSY607HTOyGyTfeHizr9wKe+p1INPK51fEZpUzGOD8AYFuL4XDps/gada7kOPiD/RsaGlmQ1AIuehIu+icAN9u/qNAr9HKnNbS17SHXnkjitdNg2IuANYW+CaHFhgY+JjinYjdMzC6Xww2z4HcvAHC369NKg8cN9lm4c9Igvglc8y5cM43ihFY0Mw4w2h8WyzPw8ZxzEq1tGXjiU+HyVyls1INkI5dXXU9Tj6rXRoqiiLdd/+B39sX4MMhxNcRtlHCP42P+5XwVWw3CSldjK1+5/sbrrn8y8NeXYOZoBs8eyNNN52Ezjuwq3nHkM8y2gL85pvFXx7tcaltcg6E1OVrVzUwLhye+rPxDcKAusuzq0ZUtgHmiqPOg8t577zFmzBgefvhhVq5cSffu3Rk8eDB799ZtF+bIvi1w+P/gu91HcZ0Mw8AbbYULZ+HRVXdn7rNqN+LqN8EeZfWoxJqVzyCKLbHewEqS/EGF/OCy+UUlvpAZMQDu4tI/tlG+0k/E9cjl27V7iHHZcVHMR67xPOd6ic9af0RzYx/fuu/jh6jbecAxjSH2ZbiNYrz1O0CD9sS37QvAUP9QjL15b4zopGBQ6WbbxsBAfUrb82nTvjNZce1wGD4eclqfkm0t+4M7ju0NrF6YQbYV3JC0yrpPp9+Bw4Wj48WA1esRGC76xHsG2a5GGC3PBGC4/fvgkJC9x9XYEpti7zAYgKvs8/hDYGijx0hwRgV7CJ5rt4oBtp9oa9tDoS2WC665l97Dx4Azlk62NM6yreE2f8/Gl76+0LAD+f3uAawejiiKgm/cjv63QUITXGf/GYCb7Z9jx8vs06wF4YzOv6NL9z6cef0TAFzp+J6GHOJc2yoaFWwBVxycdgOt+1wMzfsQZRRzk8MqMLzV8SkxRhGrfG2h/YXQ50aIaUBL216G2axPZTc7PsdtlECL/lbI63gpefU6EWcUcr3D+sTXwsjgMpsV6J4rGY7d7iCr/wMAXGufHQw0/W1r6WtbT5HpYFXrG8Fmx3b+QwCMsn8VfPN24yntsTn7Putinp2GQmpfog0Pf3Z8HPy/FksBF+ydAkDchQ9ii0mCUy6GlmfhNor5s+MjyhpuW0Bv2yZwxWEMngiGAd3/APXbEW/mMMoeOiU7mWzujfK3ZdAjEJUA7ngKB/0DgBvsX4b0YgXcYP+S/va14IzBNWoGdL+aqBs+YauvMc2N/TzjfLmK3hGT9b1m0sO2FaKTsd04h/j/2wyXvYwXGyPs3/OoYwpV1/XAANtqPnCNp51tN0TXg1OvgJSuGCUFDD/4HzZ2mlKjoSQDH3+yz2Z13J95zvUStzs+ZbTjE150vcBi913c4/iw2uuGVebBSzqRamRwm/0TXnY+wwzXQ7znmsDjjv8y1LaIKI5+SYDqtKof/usinai2V3P5jlYPfE6bMgXJo6Yso9UDn/Pmkh28tmAbrR74nFYPfM79H67m5jd+4HF/gftfPljNTa//wGWTFvLoZ1UvlXA81XlQefrpp7n55pu5/vrr6dy5M6+88goxMTG89tprddquXi3qEWdYL2TDFXtU5wgElSjP0RXbRRdb98vwxuOOs4ppY8mv9Borcf71VQx/UHEbxZR4rD8chcVeEv2FqIG1TKJKSj9RR5cp0LUZJhkZ6dgMg7NtP9HIyLR2/PQ+78Y/Z31SBm5zfMpTzv8A4Ot2tfWm0bRXaKPanm/9m9CE/IS2wc3FMSnQ2LpA3Z4UK8QEe2baDQJgZ/2zKDFtdLLtpEneWmvYp8vl1jGdhgIw0jGXWKOI3fZm/Gi2Y3jPZnDqcAD+4vyAJCMPM6EZtDrbul/vUYDVM3KO/Wd8poHttOusfb3+ZP2MtEW86n4OgNwufwB3PMQkW/uBF5wv8DvbYgCye99pPX+9/8AusyENjWzedE2kp20z2N1w+i3WuXv+EY8riZa2vfw3dQ6s8b8Bn32f9W/L/pDaDyfF3OiYxbgE/0yX3tdBdJL13PqP/aN9DqcYafzR33uzr/e91n5XLJxhtWe0YyaNOBQ8JtDbgmFgG/BXwCoyjiefexwf4TB8LLH1ZLXZjn5t6pPQ/VLW+FoRZxT6g5HJAy6rN+Ud70D69fCvb3HKRRxK7EysUcTN/gA10j6XRkYmZkJzK0T4fy6DHgHgKvu3tDb2+H8Pn0HePkhuC6ddX+bYhwGrzqWTYQ1RxlDI/c53rWMG3A8J/hVV7Q4YYAWr0e4vQgL5aMdMXN48aNIduv4+uD22y8XM93XDbZTwiON1ygaHDsZO7ne8b30z+HFo4J+lEpXIX4y/UGC6ONe+mtvsob1IABOSPoe1M8DmhKvfhlT/mjo9/sDO817AZxqMdMzlL4Hzl3OhbTn/df7LGqprdwHctRKumAy3fW/1+jmicWydywzXONoaVa+228rYw7uux3jUORV7SR5ptmZMLbmQN0ouYKuvMfFGAfc4PuYb930Mt31XoyGpTsYOrtn2d75338sDzne5yL6cHrYt9LWt5w+Ob3nB9SI/uG/n/xxvV+g1qykbPk4z1nOj/Qsed/yPF5zP87LzGd5o9A532Gdylu1n4o9Db9Ct5/w2V6QNLMr40Iw1TCgTQN7/YRdz1mbwn++2kpVfzIcrdvH1ugxW7cxk8oJtVV7T63iq06Di8XhYsWIFgwYNCm6z2WwMGjSIxYsX12HLIHHvUh6N8f9BiTm68WGfvyg0qvgog4q/RqVzu7YkJFpTZ6OMYrLzKnbhxfqDii0xNbjNW2QdV1TiC9ZPFEVbtTMOX+mnqZhyM4m27dhOYYmP7rayM0RMmnu2Yho28nvfZg17ABt9zbD1teo/aNgREstcjfaUi0t/Ro8Rwa+dp15mvSEBO5qWHoNhh65XAlDiTuR7X5mr7Z5yUbBAmXaDrE+bfinn3cqKBy+wrm/T+TJwlgZL4/Sbweafl93uAg7aSpenNzteAvVaWd8kNIVOlwLgNoswHdE0uPAvpT+/3+1g2Khn5GIzTAraXcI1w6zjnS43DS6y3iz7BAJXv9vAP0UdVyyuM24H4Px9b4Dps3qHmpS5StJZ9wBWAGxTuBYc0XDG3aX7OwyBlFOJMwr5yv0A0YYHT9PTueB3fyw9ps9N+KLq0da2h6/dfyXa8GA26w3tBgYPie52OTnxbUg08vmf619c7l/3ptd1/2LVuAtoEOfG7XTQ9ooJgDV08nTCe3RnI6Yzhsvu+lfpdGXDoN7F4wCrV6WLsZ07HdOtXQPuB0eZ2q6WZ2C2H4zD8PEXx3u0NNJL3+wHPWz1vASkng6dL8NumDzsfAMDH++dMp8UIxOzXmvoexshTh0ODTsS48sN9uY0N/YxyukPagMfhjIXyrTZbZx++38x7S7Os6/mIps11OyimOmNp+A2ijHbD7aCYhnTHrqB/IGPA3C/6wPm/d7Nd389j2/uG8CaK3O5tvAd68BLn4aWZ4Tct9WAP5J34VOANdT2w8D1fH9/6RW3/+BeyEvO53AZXj73ng5Xv1P6d8cwrJB9wyxIaE4bWzozXOM4P1DT5eekhFvsnzLL9QB9besxnbFw8b9oPPYnho19mwv/+hbeO5Zxh+dutvtSSDEyedr1Ch+7HqGHUXkBakcjjZedz/CleyyxW7/AxKCoxTnkDBhP9mWv4xv+Pwr73IkvqSVxRiG3OD7ne/efmej4L+2MiovMlfXBbf2Zc9fpzPtdIe80epPl7tv50D2Bh5xv8QfHNwy1L+Ei+3JabHuf+53v8ZZrIivdt7Kpw0v8NHgTrfyB92hNv+MM5v3lXL64+2wMfDRlPx2NNMb29DCmaxFNOBCsKxt3aeda/awTReAyEGX9fcaaOl9Jt07XUdm/fz9er5eUlNDrjqSkpLB+feXTr4qKiigqKu1izM6u3bV0qrR5Lkax/w08rvFRncLwF9TGFR/dJ4yYEut+zoRGuGJKq/4PZR4kKb50Zcbt+/NI8ncHu+s1odi04zS8lBTlAikUFfuINvzXLYpqQFRBBm5v6SeTaLOAshcvLsndR35RCW38fwg21BvAKYesWgej7+3EDHmcSxal0t74la99vVgT5W+LzQYDH4LP7rXePJr2KD1pv9thx0LrTfqc0gAQ17In//rmSv7gmEvTi/8PEpsB0Kp+LBNKrqWl8RRtUpJg8D9Kz+WKsWoTPrkbUvti73cb9R3+4bnY+jD0Ofj8Pqunou/tpfezO5jd7u8M2vAIe436dL74n6FP+JAn4OA2OLQD49KnIb7M771eK6veYs7D0Kgj0Zc9GwxbAFF9roM9K+Dn961Qce7Y0HOfcRdsnAW7f4SEZjBkYuj+9oOtYLfB31V7wQSIL/O6MAyrzuT134GvGBxRuIb+O6QNuOPxnnUftq8fJMHIxzTsGEOeCD3GZuNAv7HEz7mZvjb/a6z7H3C1OI2yJePRpw5l0QedOcO+luEea6jLOOte6qWUCaJgPdbmfYjdtZzP3f9nbWvYyRpSK8cY9DBsms0l9mWcbVuD2yiGNudaoa28Cx/F3DiLfiXr+NA1nq47rGnHxpCJ4Cg3FGuzW2Hk3Wu4wfElX3pPZ6zjHRxmsTXsGOjZK/v4mnSEM++B755kovN/5BZHc7X9G2IPrYeYBhjDXgx93gC3w4777Jtg/3KMn96j1Zyb4NJnIScdZj9oHdT/zuAwYnnxZ94MvhyYO54GCyeAo4ieRgyX2RcwyrDqjT70nsNjttu5pGzIC2jaA26ZR8m7fyR+1xL+5/w3b3sHssDXlabGfv5o/5q2Nv+bd5vzMIY+B/Va4gJc/hyYEO3gC18/vvb05uV2y+i7czI9bZuZ4R7Hx96z+MLbl2wzhta2dC62LWWA3Zqu7DMNjK7DMc65H3ejjpT9DUR1uxLMx2DzXPj+X7jTFnON41uucXzLd96ufObrxwpfB341G+DASzNjP6c5t9NnyTuw5VsozqMVgAGZZixJnc6DRp2tDyaGDfL2883ChbTzrLeWL0hbgDNtAfPcsM2Xwre+nnzj68kPvg4UUv0wfd8mNorSN9LG2E33jSuwHdwMB7awPnoTbtP/vvIq3A3c7V/Je5+ZgHtNF6LcCfxY0pIVvg5sNZtAJVd8P9FVNoFi2rI0mteLZnSZNXCON8Msf1GF42j37t00a9aMRYsW0b9//+D2+++/n/nz57N0acXFsx555BHGjx9fYXtWVhYJCTWbwlcja2fCxtngjrP+oAW6mo9Awef/R/TySfyv5CKunzCtymWvq5I1vjmJZg4/Dv2Snr3PoOCRRkRTxE8j5tOta4/gcQs27afLW92tqbZ3LCFr0kASjTx2jfye5u27MW/DXlLeHkgnWxqHmg6g3u75zHUMYOCD1hvQhnGncoqtdC2VOzx3033wdZwz9zI62dLIGf428bExcGg79PwT2J0s2LSfO95ewYOXdOb3fVJDG+7zhXyCrY5pmvz3+62c0jgh5IJ1pmnyyvytdGuWwJntGlR40/AfVPn2avYdyvPwyrzNnN8ppeqL/x3FeWu0v6QI9qyGRp2sIaXyvMWw/nOIS7FCVmV2r4JNc6xekma9Ku43TVbNfJbE/T/S+vwboc2AiscAC999kq7p00lofyZc+JhVp1POhs2biP3kJpoVbMTofT1c+Ghp71RZh3aQ/d+hJOTvwBdVD9v1n0NKl8rbP/dR+P5f1sONb479xi+totvK/Pg2zLyj9Pv+d4YG1nKPm7evgM1fl25yRGPcvhDqt638PsWFZL06hMT9ZS7IaHPCyPcrDTdBRbnwxu/g1xWh208dAcP/W/lzVLadc8bBoucr7CrsM5pJjj8xvHcLWjeoZri5xMMvr91Bl90fVNh1wEzAHDSeBmddX+X/w+k/7sLrg0u7NeGN2Uu5IvM1kjdVPBdYAWV9/YHs7fVnzj3rnKrbVMam5XNg8Yu0OzgfoyYXlkxohu+Ui5lR2IuWPQfSu01KhUN2Hcrn3WU7ub6Tj/q/fgsbZ2HuWIThK53J4jMNtpmN2Wo25ZAZR6cWKfyStpcEI59mxn7auw4QU1L1xAav4YCoJOx2B6bpw5d3oMJ0/4BM4llltmeDqzPz81pA424s2l39ENol3ZrQtmFccK2f6jjtRrDGMBL8oW8LHr+86+EPPELZ2dkkJiYe9v27ToOKx+MhJiaGDz/8kMsuuyy4fdSoUWRmZjJzZsWq/Mp6VFJTU499UDkGSr5/Fsfch5nuPZOud71Hu0bVX5U3hLcEHrXeSH8ZuZIu7duSOb4lSWYmCy+YyZlnnhs89JNVu7h0+qnYDBPu20DGv/uTwkGWXDCdfmeez1e/pNPhvXNobctgf7sRNNj8EQvsp3PWQ3PYvDcH+4u9aW3LINuRTELJQR4svp63vQNZ577eGi+/a2XVf+xFAEo8kLHG+n8SVfVVhzFN2DIXMndC52GHH1bd9r0V3lJPt2qUqguJ+Qfhnd/DruVWG0ZMhvYXVH/+/IPwxV9hw5dWr9mQx61ensPx5MG8J+CX6eCMhj43QZ+baxbQTRN+/gCW/cd6Hhp1hDP/XH04qsRrr0+m3uaPaG3soUWz5iR3GwI9/1j981+FadOnY1sxla62bXRuYMcb34wXtjRkuvcsXr/valpVF5yqcnAr/PQBbJ4De9eBx18E7E6wgmzrAXDKEGjSo/rfa1UKs2HrPNg02wqoOTUcCopvav0/bdAe6reD+u2t75NaWjVPAaYJhZnW49i7HvauhV9Xwu6VUFLxcgfbfSmsMVuz0decNLMRO82GZFCPbDOGXGK4vFcL/v377mWuiWViw2TroxeAr5huD3+BEy8OvFzbrxnvL92Gw/+9iUGWGUsmcRQR2tu2/YlLjngF56Ox9P8GkpJQ8QNNbdQ0qNTp0I/L5aJ3797MnTs3GFR8Ph9z587lzjvvrPQ+brf76Gbh1AFHvFWjUJ9sNmXkHllQybdmCnlNg+gEqzbDY4sCL3gKQmtKcrKzrJAC4I4n1+cmxQaFeVbBbFFJ6dCPGWP1WkT5F44b/+lanjSsTyXZrhQSSg7SwMiimXGAKKOYYhw4/QW6IlVyuCrv4SnPMIIF0zXS+mzrVhMxyXDDbOuNJaGpNURYk/tcMbnm7QlwxVo9TBc+euT3NQzo9nvrVgsXDL2Gs5+0hifX3zAEnEd+4dOACy+4mIvWxnNJtyY8PLQLNtNk6X+XkuQpoUXyUc66SW4D5/7NupkmFOVYtUiOqKMLJuVFJUDn31k34OG355KbtpqJ5yXgKs6C4gKW7yrgq825DDnzdE7r3g3qtbZ6yWvCMKxauGa9rVtAiQfSf4Zdy2DnUms499B2WtkyaEVG8FIl5ZkbXDDB5EZglNsXvI4b/k7Cn8pmgFUwuoq3uQLTxQES2OlrRHLz9jD/F/7TM4Z/rXKw1WxCSZje1l+Zv4WHh1bRUxpmdX6tnzFjxjBq1ChOO+00Tj/9dJ599lny8vK4/vrr67pptRdtfVpMMnLZWc1l2Svz08ZNdAMOEk9ctPU/ttgfVEqKQoPKyk1pjAR82LA5Y7BHxYEHjGLrE0xhsZfowNRBf91MlGl9IvD6TKL8BWPZrhTIX0cyOcFl7X81GtPKXuf/TURqxmYrnanzG5eaHMO2iVYxulHLN/76cW6W/t/A4HkMw+Cdm/sek3P7T2IFizAaP3Igpnl+SHv7AL185hEPu1fL4YLmva1bP38NXP5BvLtXY9uzCg5usYbJD22HvP0YJf7Zo17r76wBOKtrjs0BNgemzUlmkUkJdmz4SLblY5heog0PzdlPc/t+2LMW9szkQuBCN3hMO8X12hHTvBtb7S15ZLmDX3ytOEgC2yZeTOuxlV8/qSbqsqC2zt+BrrrqKvbt28e4ceNIT0+nR48ezJo1q0KB7QnJ361dj9zg1LCa+udHC3jbBQfMRFpEWb+mEnsUFIOvXFApyLHGXT22aKIMwwo0gFFs9ZoUlfiCYcT0z0SJ9q/HYprg9i9XHtOwFWRCspEdLKQtSjo5/uiLnIiOSYio4lzH8tzHS2VtPqYhpSoxydjbnQftzqu4r8QDRdn+4aKyhe0Oq4fJZrdqo+xOa1sgLAIPvPkDX/2Swe+6N+X5q3tYvVIFh6wC7swdcGgHZG6H/ZvISfuJeKMAV+YGyNxAW+BN/yjRHjMZ450+jHFE84uvFb+YrdhlNuRICoKP9qryx0KdBxWAO++8s8qhnhNamR6VI02j9f0LaB004znF36VbYremhfo8oWsJRPsXbjJdVpemx2Z11dr8Sd5TVGQt/AXY4hr672P1qJhmaYhp2aYDbIL65ASDSutTuh1Ru0VEpAyHCxwNjuquT13ZncFdMrigc0ppr1RUAtRrCS36hhy7fWcm+fu30zdmj1UvlvEL+Wk/EpOznSbGQdj0FXeXecfPNmNYa7a0gouvJWvNVmw2m4YMHbVuEBu8plDZyQ7HW0QEld8sf49KvFHAf+dt4P4hHWt81waGFVQOkBD8lODzBxXTU26VWX+9ic+/MJ3H36Ni90+v9npK10wJBJVYCjBNk1inGaxvMfxrsNQ3sijxL7HjSjmlxm0WEZFjJyHKyfBezWt0bNfUJEjtAfSw1p0CYsDqhUlfA+k/896nn9PFtp2Otl0kGPn0M9aVXq8NKDKdbDCb84uvFWvNlgzqOYjb53jIJ4rTWtXd9aYUVMIpKtFa/dQwg+uc1FR9/wqw+83SCn6v07/QVpngAeDyWt/7nFaPSrE/0AR6VMoOFQUKfGMoosTr45zWcRC4PEWi9YJINnKIMfw1Lcma7SMicsJyx1vLHbTsT3TUpTy8aDsvXtWFpLxtTP3oE1KLNtG6ZCunsAN3cQ7djG10s/kvhPj9VNZEGex3NqPh1nuhwU118hAUVMLJZieLWOqRSz3jyK7omey/xsoBs7QAzXRYAcQoCR36CfSoeP0rsgaCit1/nLfYPwRki8IVY808chpe8ooKcfgLvHwY2BKsxdYCvTmANX1PREROeL/r3pTfdW9qfZPcg9vv6VG60+ez6l32/GTNakr/Cfb8hC03nUbFu6yFJuuIgkqYHSLeCipH2KMSCAuJDUoXmjMd/mmCxaE9KoGgYvp7VErKBZVAj0qJLYqoqNIp0vm5mcH1AEoMF65ya1rkGzHExB7d2KqIiJxAbDZrSnlyG+hyWen23L3WOjjJreusaQoqYZZFPLCHpCPsUUmxW0HlwtPLrAboCi2SDYjyX7fH5yoXVLz+RYn8NS1eexQ2h4NCnERRTE5ONkYgqNhcuOxOawlr/wUMjQbtj816ByIicmKKa1R63bI6UudXT/6tK3EnAVjL2x+B+mQCYE8o/Q9iuEJ7SgICi7eZ/mJabzCo+GcD+XtgSvw9MkWGVWybnZWF4Q8zxYa1VsuvZpkelOTf5lVERUTkxKGgEmantLZWda1Hbs0vl22a1DczAbCVuSCizR9Egj0lflGmP7gEe1SiQo4LBBWff7vHsIJMXm42Nm9pjwqAu2npyoO2lE41a6+IiEiYKKiEWVSiNR04ycjB463+olUBP25Os66xAzjK9KjY/EM/Tm/o0E9w8TaXVX8SCCQOfwgJLPzm8xfjFvv35+dmY3it2T0lNqtHxZ3aM3heZ5uaXYRMREQkXBRUwsweW7o6bW4NF32b8tVyAHLNKFzRpdelsLmtHhWHL7RHJRBUAj0qRrlaFpu/DiUwayhQw1JcmBvcFwgqDc66gR/Mjsx1nI2t3IJCIiIix5uKacPMHmtdAbmekcuhPA8N4g5/QUVPVjpgraHS0F6aJZ3+oGJWWEclH+xg+C+2FRVj/VtYYNXFBItv/euwFNtKa11s/uEorz+oRCc2oMvfF+G0GzW7EqyIiEgY6Z0o3ILL6OdwMK9mFyZM9B4CYD+JuBylv6LoWGtoJ9ooDJ7r18wCYg2rV8QZYy0O54zy17L4e0sCRbU4rZ6WwNCPvaQAW4k19BMIKgDRLjsOu/5riIhI3dO7UbiVuTBhjYOKzwoq+8xEHGUuqNUwuR4A0XjIKrBqWPZkFhDnv9ZPYmISAG2a+q/nY1g/L1BUG5g1FFy51lsQvG6Q6Th8T4+IiMjxpqASbmUuTHighkGlnn/Gz34zMfRqoP4ekRiK8JRYhbkH8jzE+i8wGKhRcUX5h4CwektKg4p1/xL/0I+jJB+vx3/fwPL8IiIiEURBJdz8PSpJ5JJXWLMliNtGW70ch4yk0B3+oBFllAaVnMISYg3/0I6/RsXuPy7aH1Sc/uLbwKyhQI+Kw1uAzz912eaMOqKHJSIicjwoqISbv0fFYfj4fs2Wwx6+5tcsjLy9AFzSv3voTn+vRwxFeLxeAPI9JcSV61Ex3P5AgwefzwwGFbt/e0nZBeH8dSw29aiIiEgEUlAJN2cU+aZV/5H266+HPfzSFxbQwH/l5MSGzcqdyyqSjcZDUbEVVPIKCoO1KLitYlu7f3aQ0/BSXFyE2wwEldAl9h3eAigO9LYoqIiISORRUDkODmEFhHrU7Ho/DbCCSoPGqaE7/L0eNsOkpNi/UFtBmaX5/T0qDn/PCUB+Xi7RWEHGERW6xL7DWwD+WT92BRUREYlACirHQTZWT0fNrvdjBntUiG0YustZGkC8BVboKSm0Ll7oNezgn7ljd7opNu2AtfpssFbFH2C8/oXfnN6CYKGts0y4ERERiRQKKsdBSuOmgFVQezjtE0unFVe4YqXdQTFOAPLzrKDi8weWYnts8ErHDptBAda1ewoLcogKTFP2DwkFLk7o8BbiNK0QY3OpmFZERCKPgspxEJNoXZG4vi0X06z+woRdk/xDOo4Y8F+EsKxi/8Jsebn+oFLk71lxlB5rtxkUYh1XmJcb7FEJ9MgErvnj8hXgNK0QY6iYVkREIpCCynFg+JfRTyCHYm/1QSWu5CAARe4Gle4PFMLm5VlDPhRZvTTeMkHFMEp7VIoKSmtUAjUuwaEfXyFuFFRERCRyKagcB444K3TUI5ecw6ylcnCvNTPIE1W/0v2BkFGY5x9GKs4DwFeu9yXQo1JUkBcc+gkEFZ/d6lkxPXk4Tas9WkdFREQikYLKcRC4MGGykcN/vtta5XG5RSXU8y+fX1WPiumvL/H4a1NsxVZgMV1xIccVmFaPypbd+yoM/QSGlBzeAqKNQI2KimlFRCTyKKgcD4Fl9Mlhxqqq11LJyC4MzvgpcFfeoxKoLzH8V0S2+3tUcMWHHBfoUcnNya4w9HNW5xYAxFAY3Gdo1o+IiEQgBZXjIXBhQiMXe9lr95STU1hCQ/8aKvnOyoOK6Q8b9pJ8Srw+CnOt4w13aI9KXJwVXPJyc4gxQntU6tezLm4YQ1Gwt8WuHhUREYlAjrpuwEmhzIUJL+nWpMrDDuV5gj0qec7kSo/x+Yd+7N4CdmcWEmtY66DEJSSFHBeoZTEKD5ZuDAz9+P91GD4SsHpkNPQjIiKRSD0qx0OM1YNRj1y27c+v8rCDeR4aBoKKo16lx5iBkOEtoqDYSxzWEJAzOiH0OIdVHBtdnFm6MTCzp0zhbUPDmj1kL9cjIyIiEgkUVI4Hf49KjFHE9+t2VnnYoXxPcPn8+uWXzw9wlq4qW1DsJTZwQcJyQSNQdFsfK4gUGy6wWavVYndSXK4zTdf6ERGRSKSgcjxEJVJiWk91davTpmcWBId+up7SvvKD/L0hTl8B+Z4SYo0C//bQYtpAoEn295gU20ODSJHhDvneqGRxORERkbqmoHI8GAaZgQsTVnG9H9M0mbZwXXD5fKP88vmBU/mHfpy+IhZu3k9cFT0qhr/mpL4RWGI/tAbFY5RbN0ULvomISARSUDlO7IFF34zKr6BcVOKjoZEJgMcWXeny+VB6BWS7Nx+bYQSLaSm3jkqgOLa+fyipxB4aTDy2ckHFoaAiIiKRR0HlOHHFWdONW8cUVbq/xGcG61Nyq5jxAxAdaw3xOLyFFHi8xPqLacv3qNj966Ik+4NRSbkelbJDQYW4wKb/CiIiEnn07nSc+PwFtbHerEr3l3h9NPDXkzgSGld5nqgYK6hEU8SBPE/p0E+5GpXAlZLj/D0uXkdoUCkpE1QqDAOJiIhECAWV4yXamm4c76t86Mfj9QULaePrV73Wis0/JBRDUbli2tChIke5lWZt5fZ7ywz1lB8WEhERiRQKKseLf3XaeDO70t0lXjNYo1JVIS0A/tqTaKOI/KKS4DoqRIWuo+KMKlez4g4NKr4yPSwFhM4AEhERiRQKKseJ4Q8qCWYOpmlW2F/iNYPL5xNbTVDxz86JpoiiogJchtfa7g4d+omJLTcLqFxQMcsElRyvs0aPQURE5HhTUDlObDFWMW0SuTw/d3OF/fM37QsO/VBdj4qzdOhny849pdvLzfqJjw/tYQncL6BsjUqJXTN+REQkMimoHCd2/6yfekYOz3y9scL+h2asqWFQ8feoGB7i/PUpHntM6aqzfu7oytdVCSgss+Bbvr1cqBEREYkQCirHiSMQVKi8mBao2dCPvyg2mqJgfUqJo+KaK0a5oaDyK88WlJnpk2srt6qtiIhIhAhbUPnHP/7BGWecQUxMDElJSZUek5aWxiWXXEJMTAyNGjXir3/9KyUlJeFqUp2yxwYWfKtqCX2zTI9Kw6pP5F+ZNpoiEgzrAofFzkqCRnRSyLe2qHI1LAkNgl/n2NSjIiIikSlsQcXj8XDllVdy++23V7rf6/VyySWX4PF4WLRoEa+//jpTp05l3Lhx4WpS3QoU05KPDV+F3e0TjeDy+TUppnUYvmDvjFn+Oj8AUYkh39piQxeR6965c/DrXAUVERGJUGELKuPHj+fee++la9eule6fPXs2a9eu5a233qJHjx5cdNFFPProo0yaNAmPxxOuZtUd/zoqNsMksdyFCQs8XjzZ6QD4nDEVVpkNUWYIp5F/OnP5GT8A2J3kmaXDO2ZUaFCx12sR/FpDPyIiEqnqrEZl8eLFdO3alZSUlOC2wYMHk52dzS+//FLl/YqKisjOzg65nRDsTrJNqzek/PDP1v25NCQTOMwaKv7zFJrWdOLGxkEAYhPqVXqoEZMU/DohOSV0Z71WwS8Hn3feYRovIiJSN+osqKSnp4eEFCD4fXp6epX3mzhxIomJicFbampqWNt5LGWaVk9JUrkeFU9J6fL5RnXDPn45WHUqTY0DADijEys9rmwdSvmhH2Lrw4jJ+AY8QKvu59ao/SIiIsfbEQWVBx54AMMwqr2tX78+XG0FYOzYsWRlZQVvO3fuDOvPO5YKnVagKH8FZSuo1GBqsl+2GRpUKh36Kb/dv45LiK5XYDtvLBjGYX+miIhIXXAcycH33Xcf1113XbXHtGnTpkbnaty4McuWLQvZlpGREdxXFbfbjdt9Yi753qJ5c9ixmXpGLkUlXtwOa+0Tj9dHwyMJKlh1Kk0OF1TKhpMoFcyKiMiJ54iCSsOGDWnYsJqps0egf//+/OMf/2Dv3r00amS9Oc+ZM4eEhAQ6l5mR8lviTrCeu3rk8GNaJv3aWEHipW+3MNRfo1LtjB+/HH+tS7PDBZUz7oINX8JZ99aq3SIiInXliILKkUhLS+PgwYOkpaXh9XpZtWoVAO3atSMuLo4LL7yQzp0786c//Yknn3yS9PR0HnzwQUaPHn3C9pgcjhFt1YnUM3LJyC4Mbl+89QA3ODOtb+JTKrlnqI6tUyHt59INVQWVFv3gwQyw61o+IiJyYgpbMe24cePo2bMnDz/8MLm5ufTs2ZOePXvyww8/AGC32/nss8+w2+3079+fP/7xj1x77bVMmDAhXE2qe7FWj0p9spm8YFvIrhTjkPVFfJPDnqZRw3K9LpXVnwQopIiIyAksbD0qU6dOZerUqdUe07JlS7744otwNSHy+OtPGhhZ/LQrK2RXcE2UuMP3qOAuV29SXVARERE5gelaP8dTmaAS4CnxYcMXXEelJj0q5VedVVAREZHfKgWV48kfVBr6e09M0+Sxz9dSn2zshomJERweqlZ0uQXeYhtUfpyIiMgJTkHlePLP6GlAFmBSVOLjjcU7aOSvT/HFNgR7DUbjEpqWfm3YICrp2LdVREQkAiioHE/+HhWX4SWRPPZkWTN/AvUpRlzV68eESGhW+nVias3CjYiIyAlIQeV4criD9SUNjCy27LWW0g/M+DESalCfAqFBpSY1LSIiIicoBZXjzT+rp5GRycF86yrRjQIXJKzBGioAxCQD/mXvm3Q/xg0UERGJHAoqx1uZOpW/T7cWbTuSNVQA69o8186A3tfBgPuPfRtFREQihIobjrfgzJ8sir0mQLCYtkZrqAS0Ode6iYiI/IapR+V4KzP0E9DEOGh9UXY2j4iIiCioHHeJzQFoZuwLbmpm7Le+SGpRFy0SERGJWAoqx1tSKgBN/Vc+jiOfeoY1+4fE1LpqlYiISERSUDnegj0q+0P+JboeRCVUdS8REZGTkoLK8ZZoDe80IhMnJTQPDAGpN0VERKQCBZXjLbYBOKKxGSZNjAOcXi/P2q76FBERkQoUVI43wwgO/wxuWsQ17Uqs7Ukt67BRIiIikUlBpS7UbwfA30+3k5Cz2drWqGMdNkhERCQyKajUhUadrH/3/gJ711tfN+xUd+0RERGJUAoqdSGli/Xv9gWQm2593fCUumuPiIhIhFJQqQuNu1n/HvAP+zTooKnJIiIilVBQqQsN2kN8meXyWw+ou7aIiIhEMAWVumAYcNr1gW+g17V12hwREZFIpasn15Wz7rUuUJiUCk261XVrREREIpKCSl2xO6H3qLpuhYiISETT0I+IiIhELAUVERERiVgKKiIiIhKxFFREREQkYimoiIiISMRSUBEREZGIpaAiIiIiEUtBRURERCKWgoqIiIhELAUVERERiVgKKiIiIhKxFFREREQkYimoiIiISMQ64a+ebJomANnZ2XXcEhEREampwPt24H28Kid8UMnJyQEgNTW1jlsiIiIiRyonJ4fExMQq9xvm4aJMhPP5fOzevZv4+HgMwzim587OziY1NZWdO3eSkJBwTM8th6fnv27p+a9bev7rnn4H4WWaJjk5OTRt2hSbrepKlBO+R8Vms9G8efOw/oyEhAT9J61Dev7rlp7/uqXnv+7pdxA+1fWkBKiYVkRERCKWgoqIiIhELAWVarjdbh5++GHcbnddN+WkpOe/bun5r1t6/uuefgeR4YQvphUREZHfLvWoiIiISMRSUBEREZGIpaAiIiIiEUtBRURERCKWgkoVJk2aRKtWrYiKiqJv374sW7asrpt00njkkUcwDCPk1rFjx7pu1m/Wd999x9ChQ2natCmGYTBjxoyQ/aZpMm7cOJo0aUJ0dDSDBg1i06ZNddPY36DDPf/XXXddhdfDkCFD6qaxv0ETJ06kT58+xMfH06hRIy677DI2bNgQckxhYSGjR4+mfv36xMXFMWLECDIyMuqoxScfBZVKvPfee4wZM4aHH36YlStX0r17dwYPHszevXvrumknjS5durBnz57gbcGCBXXdpN+svLw8unfvzqRJkyrd/+STT/L888/zyiuvsHTpUmJjYxk8eDCFhYXHuaW/TYd7/gGGDBkS8nqYNm3acWzhb9v8+fMZPXo0S5YsYc6cORQXF3PhhReSl5cXPObee+/l008/5YMPPmD+/Pns3r2b4cOH12GrTzKmVHD66aebo0ePDn7v9XrNpk2bmhMnTqzDVp08Hn74YbN79+513YyTEmBOnz49+L3P5zMbN25sPvXUU8FtmZmZptvtNqdNm1YHLfxtK//8m6Zpjho1yhw2bFidtOdktHfvXhMw58+fb5qm9f/d6XSaH3zwQfCYdevWmYC5ePHiumrmSUU9KuV4PB5WrFjBoEGDgttsNhuDBg1i8eLFddiyk8umTZto2rQpbdq0YeTIkaSlpdV1k05K27ZtIz09PeT1kJiYSN++ffV6OI7mzZtHo0aNOOWUU7j99ts5cOBAXTfpNysrKwuA5ORkAFasWEFxcXHIa6Bjx460aNFCr4HjREGlnP379+P1eklJSQnZnpKSQnp6eh216uTSt29fpk6dyqxZs3j55ZfZtm0bZ599Njk5OXXdtJNO4P+8Xg91Z8iQIbzxxhvMnTuXf/7zn8yfP5+LLroIr9db1037zfH5fNxzzz2ceeaZnHrqqYD1GnC5XCQlJYUcq9fA8XPCXz1Zfnsuuuii4NfdunWjb9++tGzZkvfff58bb7yxDlsmcvxdffXVwa+7du1Kt27daNu2LfPmzWPgwIF12LLfntGjR7NmzRrVxEUY9aiU06BBA+x2e4WK7oyMDBo3blxHrTq5JSUl0aFDBzZv3lzXTTnpBP7P6/UQOdq0aUODBg30ejjG7rzzTj777DO+/fZbmjdvHtzeuHFjPB4PmZmZIcfrNXD8KKiU43K56N27N3Pnzg1u8/l8zJ07l/79+9dhy05eubm5bNmyhSZNmtR1U046rVu3pnHjxiGvh+zsbJYuXarXQx3ZtWsXBw4c0OvhGDFNkzvvvJPp06fzzTff0Lp165D9vXv3xul0hrwGNmzYQFpaml4Dx4mGfioxZswYRo0axWmnncbpp5/Os88+S15eHtdff31dN+2k8Je//IWhQ4fSsmVLdu/ezcMPP4zdbueaa66p66b9JuXm5oZ8Ot+2bRurVq0iOTmZFi1acM899/DYY4/Rvn17WrduzUMPPUTTpk257LLL6q7RvyHVPf/JycmMHz+eESNG0LhxY7Zs2cL9999Pu3btGDx4cB22+rdj9OjRvPPOO8ycOZP4+Phg3UliYiLR0dEkJiZy4403MmbMGJKTk0lISOCuu+6if//+9OvXr45bf5Ko62lHkeqFF14wW7RoYbpcLvP00083lyxZUtdNOmlcddVVZpMmTUyXy2U2a9bMvOqqq8zNmzfXdbN+s7799lsTqHAbNWqUaZrWFOWHHnrITElJMd1utzlw4EBzw4YNddvo35Dqnv/8/HzzwgsvNBs2bGg6nU6zZcuW5s0332ymp6fXdbN/Myp77gFzypQpwWMKCgrMO+64w6xXr54ZExNjXn755eaePXvqrtEnGcM0TfP4xyMRERGRw1ONioiIiEQsBRURERGJWAoqIiIiErEUVERERCRiKaiIiIhIxFJQERERkYiloCIiIiIRS0FFREREIpaCioiIiEQsBRURERGJWAoqIiIiErEUVERERCRi/T90oc2u81Y71AAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -523,7 +588,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -557,7 +622,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -566,13 +631,13 @@ "(0.0, 4.0)" ] }, - "execution_count": 17, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -593,12 +658,12 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -608,7 +673,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -618,7 +683,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -632,21 +697,64 @@ "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(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.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.xlim(0,4)\n", + "# plt.plot(time2, zz, label='Clean Gyroscope')\n", "plt.legend()\n", "plt.show()\n" ] }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "t,p = zip(*barometer_clean.measured_data)\n", + "plt.plot(t,p)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "test_flight.pressure()" + ] + }, { "cell_type": "code", "execution_count": null, From 1e36391b287b84b207017b98ab4dfd393f8545a7 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Wed, 22 May 2024 20:27:55 +0200 Subject: [PATCH 11/31] TST: merge tests --- rocketpy/sensors/barometer.py | 4 +- tests/test_sensors.py | 87 +++++++++----- tests/unit/test_sensors.py | 217 ++++++++++++++++++++++++++++------ 3 files changed, 241 insertions(+), 67 deletions(-) diff --git a/rocketpy/sensors/barometer.py b/rocketpy/sensors/barometer.py index 7bbc8c02a..6fac2deee 100644 --- a/rocketpy/sensors/barometer.py +++ b/rocketpy/sensors/barometer.py @@ -50,6 +50,8 @@ class Barometer(ScalarSensors): temperature drift. """ + units = "Pa" + def __init__( self, sampling_rate, @@ -173,7 +175,7 @@ def measure(self, time, **kwargs): P = self.quantize(P) self.measurement = P - self.measured_data.append((time, P)) + self._save_data((time, P)) def export_measured_data(self, filename, format="csv"): """Export the measured values to a file diff --git a/tests/test_sensors.py b/tests/test_sensors.py index 5c2e6289d..c9440f568 100644 --- a/tests/test_sensors.py +++ b/tests/test_sensors.py @@ -2,6 +2,7 @@ import os import numpy as np +import pytest from rocketpy.mathutils.vector_matrix import Vector from rocketpy.rocket.components import Components @@ -25,7 +26,24 @@ def test_sensor_on_rocket(calisto_sensors): assert isinstance(sensors[2].position, Vector) -def test_ideal_sensors(flight_calisto_accel_gyro): +@pytest.mark.parametrize( + "sensor_index, measured_data_key, sim_method, tolerance", + [ + (0, "measured_data[0]", lambda flight, time: flight.acceleration(time), 1e-12), + ( + 2, + "measured_data", + lambda flight, time: np.sqrt( + flight.w1(time) ** 2 + flight.w2(time) ** 2 + flight.w3(time) ** 2 + ), + 1e-12, + ), + (3, "measured_data", lambda flight, time: flight.pressure(time), 1e-12), + ], +) +def test_ideal_sensors( + flight_calisto_sensors, sensor_index, measured_data_key, sim_method, tolerance +): """Test the ideal sensors. All types of sensors are here to reduce testing time. @@ -34,40 +52,47 @@ def test_ideal_sensors(flight_calisto_accel_gyro): flight_calisto_sensors : Flight Pytest fixture for the flight of the calisto rocket with a set of ideal sensors. + sensor_index : int + Index of the sensor in the rocket's sensor list. + measured_data_key : str + Key to access the measured data from the sensor component. + sim_method : function + Function to compute the simulated data. + tolerance : float + Tolerance level for the comparison between measured and simulated data. """ - accelerometer = flight_calisto_sensors.rocket.sensors[0].component - time, ax, ay, az = zip(*accelerometer.measured_data[0]) - 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_sensors.acceleration(time) + sensor = flight_calisto_sensors.rocket.sensors[sensor_index].component + measured_data = eval(f"sensor.{measured_data_key}") - # 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_sensors.sensors[0].measured_data[0] - == flight_calisto_sensors.sensors[0].measured_data[1] - ) + if sensor_index == 0: # Accelerometer + time, ax, ay, az = zip(*measured_data) + ax = np.array(ax) + ay = np.array(ay) + az = np.array(az) + a = np.sqrt(ax**2 + ay**2 + az**2) + sim_data = sim_method(flight_calisto_sensors, time) + assert np.allclose(a, sim_data, atol=tolerance) + + # Check if both added accelerometer instances saved the same data + assert ( + flight_calisto_sensors.sensors[0].measured_data[0] + == flight_calisto_sensors.sensors[0].measured_data[1] + ) - gyroscope = flight_calisto_sensors.rocket.sensors[2].component - time, wx, wy, wz = zip(*gyroscope.measured_data) - 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_sensors.w1(time)) - flight_wy = np.array(flight_calisto_sensors.w2(time)) - flight_wz = np.array(flight_calisto_sensors.w3(time)) - sim_w = np.sqrt(flight_wx**2 + flight_wy**2 + flight_wz**2) - assert np.allclose(w, sim_w, atol=1e-12) + elif sensor_index == 2: # Gyroscope + time, wx, wy, wz = zip(*measured_data) + wx = np.array(wx) + wy = np.array(wy) + wz = np.array(wz) + w = np.sqrt(wx**2 + wy**2 + wz**2) + sim_data = sim_method(flight_calisto_sensors, time) + assert np.allclose(w, sim_data, atol=tolerance) - barometer = flight_calisto_sensors.rocket.sensors[3].component - time, pressure = zip(*barometer.measured_data) - pressure = np.array(pressure) - sim_pressure = np.array(flight_calisto_sensors.pressure(time)) - assert np.allclose(pressure, sim_pressure, atol=1e-12) + elif sensor_index == 3: # Barometer + time, pressure = zip(*measured_data) + pressure = np.array(pressure) + sim_data = sim_method(flight_calisto_sensors, time) + assert np.allclose(pressure, sim_data, atol=tolerance) def test_export_sensor_data(flight_calisto_sensors): diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensors.py index 9cf604bc6..6b99bee79 100644 --- a/tests/unit/test_sensors.py +++ b/tests/unit/test_sensors.py @@ -50,6 +50,8 @@ "quantized_accelerometer", "noisy_rotated_gyroscope", "quantized_gyroscope", + "noisy_barometer", + "quantized_barometer", ], ) def test_sensors_prints(sensor, request): @@ -62,7 +64,7 @@ def test_sensors_prints(sensor, request): def test_rotation_matrix(noisy_rotated_accelerometer): - """Test the rotation_matrix property of the Accelerometer class. Checks if + """Test the rotation_matrix property of the InertialSensors class. Checks if the rotation matrix is correctly calculated. """ # values from external source @@ -77,8 +79,8 @@ def test_rotation_matrix(noisy_rotated_accelerometer): assert np.allclose(expected_matrix, rotation_matrix, atol=1e-8) -def test_quantization(quantized_accelerometer): - """Test the quantize method of the Sensor class. Checks if returned values +def test_inertial_quantization(quantized_accelerometer): + """Test the quantize method of the InertialSensors class. Checks if returned values are as expected. """ # expected values calculated by hand @@ -93,6 +95,60 @@ def test_quantization(quantized_accelerometer): ) +def test_scalar_quantization(quantized_barometer): + """Test the quantize method of the ScalarSensors class. Checks if returned values + are as expected. + """ + # expected values calculated by hand + assert quantized_barometer.quantize(7e5) == 7e4 + assert quantized_barometer.quantize(-7e5) == -7e4 + assert quantized_barometer.quantize(1001) == 1000.96 + + +import pytest + + +@pytest.mark.parametrize( + "sensor, input_value, expected_output", + [ + ( + "quantized_accelerometer", + Vector([3, 3, 3]), + Vector([1.9528, 1.9528, 1.9528]), + ), + ( + "quantized_accelerometer", + Vector([-3, -3, -3]), + Vector([-1.9528, -1.9528, -1.9528]), + ), + ( + "quantized_accelerometer", + Vector([1, 1, 1]), + Vector([0.9764, 0.9764, 0.9764]), + ), + ("quantized_barometer", 7e5, 7e4), + ("quantized_barometer", -7e5, -7e4), + ("quantized_barometer", 1001, 1000.96), + ], +) +def test_quantization(sensor, input_value, expected_output, request): + """Test the quantize method of various sensor classes. Checks if returned values + are as expected. + + Parameters + ---------- + sensor : str + Fixture name of the sensor to be tested. + input_value : any + Input value to be quantized by the sensor. + expected_output : any + Expected output value after quantization. + """ + sensor = request.getfixturevalue(sensor) + result = sensor.quantize(input_value) + assert result == expected_output + + @pytest.mark.parametrize( "sensor", [ @@ -100,16 +156,28 @@ def test_quantization(quantized_accelerometer): "ideal_gyroscope", ], ) -def test_measured_data(sensor, request): +def test_inertial_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) + sensor.measure( + time=TIME, + u=U, + u_dot=U_DOT, + relative_position=Vector([0, 0, 0]), + gravity=GRAVITY, + ) assert len(sensor.measured_data) == 1 - sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY) + sensor.measure( + time=TIME, + u=U, + u_dot=U_DOT, + relative_position=Vector([0, 0, 0]), + gravity=GRAVITY, + ) assert len(sensor.measured_data) == 2 assert all(isinstance(i, tuple) for i in sensor.measured_data) @@ -119,52 +187,73 @@ def test_measured_data(sensor, request): sensor.measured_data[:], ] sensor._save_data = sensor._save_data_multiple - sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY) + sensor.measure( + time=TIME, + u=U, + u_dot=U_DOT, + relative_position=Vector([0, 0, 0]), + gravity=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) + sensor.measure( + time=TIME, + u=U, + u_dot=U_DOT, + relative_position=Vector([0, 0, 0]), + gravity=GRAVITY, + ) assert len(sensor.measured_data[0]) == 3 assert len(sensor.measured_data[1]) == 3 -def test_ideal_barometer_measure(ideal_barometer, example_plain_env): - """Test the measure method of the Barometer class. Checks if saved +def test_scalar_measured_data(ideal_barometer, example_plain_env): + """Test the measure method of ScalarSensors. Checks if saved measurement is (P) and if measured_data is [(t, P), ...] """ - 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]) - P = example_plain_env.pressure((rot @ relative_position).z + u[2]) + t = TIME + u = U ideal_barometer.measure( t, u=u, - relative_position=relative_position, + relative_position=Vector([0, 0, 0]), pressure=example_plain_env.pressure, ) - - # check last measurement - assert isinstance(ideal_barometer.measurement, (int, float)) - assert ideal_barometer.measurement == approx(P, abs=1e-10) - - # check measured values assert len(ideal_barometer.measured_data) == 1 ideal_barometer.measure( t, u=u, - relative_position=relative_position, + relative_position=Vector([0, 0, 0]), pressure=example_plain_env.pressure, ) assert len(ideal_barometer.measured_data) == 2 - assert all(isinstance(i, tuple) for i in ideal_barometer.measured_data) - assert ideal_barometer.measured_data[0][0] == t - assert ideal_barometer.measured_data[0][1] == approx(P, abs=1e-10) + + # check case when sensor is added more than once to the rocket + ideal_barometer.measured_data = [ + ideal_barometer.measured_data[:], + ideal_barometer.measured_data[:], + ] + ideal_barometer._save_data = ideal_barometer._save_data_multiple + ideal_barometer.measure( + t, + u=u, + relative_position=Vector([0, 0, 0]), + pressure=example_plain_env.pressure, + ) + assert len(ideal_barometer.measured_data) == 2 + assert len(ideal_barometer.measured_data[0]) == 3 + assert len(ideal_barometer.measured_data[1]) == 2 + ideal_barometer.measure( + t, + u=u, + relative_position=Vector([0, 0, 0]), + pressure=example_plain_env.pressure, + ) + assert len(ideal_barometer.measured_data[0]) == 3 + assert len(ideal_barometer.measured_data[1]) == 3 def test_noisy_rotated_accelerometer(noisy_rotated_accelerometer): @@ -202,7 +291,13 @@ def test_noisy_rotated_accelerometer(noisy_rotated_accelerometer): az += 0.5 # check last measurement considering noise error bounds - noisy_rotated_accelerometer.measure(TIME, U, U_DOT, relative_position, GRAVITY) + noisy_rotated_accelerometer.measure( + time=TIME, + u=U, + u_dot=U_DOT, + relative_position=relative_position, + gravity=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( @@ -237,13 +332,41 @@ def test_noisy_rotated_gyroscope(noisy_rotated_gyroscope): wz += 0.5 # check last measurement considering noise error bounds - noisy_rotated_gyroscope.measure(TIME, U, U_DOT, relative_position, GRAVITY) + noisy_rotated_gyroscope.measure( + time=TIME, + u=U, + u_dot=U_DOT, + relative_position=relative_position, + gravity=GRAVITY, + ) 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.3) assert noisy_rotated_gyroscope.measured_data[0][0] == TIME +def test_noisy_barometer(noisy_barometer, example_plain_env): + """Test the measure method of the Barometer class. Checks if saved + measurement is (P) and if measured_data is [(t, P), ...] + """ + # expected measurement without noise + relative_position = Vector([0.4, 0.4, 1]) + relative_altitude = (Matrix.transformation(U[6:10]) @ relative_position).z + P = example_plain_env.pressure(relative_altitude + U[2]) + # expected measurement with constant bias + P += 0.5 + + noisy_barometer.measure( + time=TIME, + u=U, + relative_position=relative_position, + pressure=example_plain_env.pressure, + ) + assert noisy_barometer.measurement == approx(P, rel=0.03) + assert noisy_barometer.measured_data[0][1] == approx(P, rel=0.03) + assert noisy_barometer.measured_data[0][0] == TIME + + @pytest.mark.parametrize( "sensor, expected_string", [ @@ -261,8 +384,20 @@ def test_export_data_csv(sensor, expected_string, request): Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. """ 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) + sensor.measure( + time=TIME, + u=U, + u_dot=U_DOT, + relative_position=Vector([0, 0, 0]), + gravity=GRAVITY, + ) + sensor.measure( + time=TIME, + u=U, + u_dot=U_DOT, + relative_position=Vector([0, 0, 0]), + gravity=GRAVITY, + ) file_name = "sensors.csv" @@ -314,8 +449,20 @@ def test_export_data_json(sensor, expected_string, request): accelerometer and a gyroscope. """ 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) + sensor.measure( + time=TIME, + u=U, + u_dot=U_DOT, + relative_position=Vector([0, 0, 0]), + gravity=GRAVITY, + ) + sensor.measure( + time=TIME, + u=U, + u_dot=U_DOT, + relative_position=Vector([0, 0, 0]), + gravity=GRAVITY, + ) file_name = "sensors.json" From f78e764cbc9fb8b794c987e050c35517a2220727 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Wed, 22 May 2024 21:18:03 +0200 Subject: [PATCH 12/31] ENH: inherited export method --- rocketpy/sensors/accelerometer.py | 46 ++--------------------- rocketpy/sensors/barometer.py | 40 ++------------------ rocketpy/sensors/gyroscope.py | 46 ++--------------------- rocketpy/sensors/sensors.py | 61 +++++++++++++++++++++++++++++++ 4 files changed, 70 insertions(+), 123 deletions(-) diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index f0005914d..176f6d9ef 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -267,46 +267,6 @@ def export_measured_data(self, filename, format="csv"): ------- None """ - 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=" ") - 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}") - 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): - 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}") - return + super().export_measured_data( + filename=filename, format=format, data_labels=("t", "ax", "ay", "az") + ) diff --git a/rocketpy/sensors/barometer.py b/rocketpy/sensors/barometer.py index 6fac2deee..f7f70fb70 100644 --- a/rocketpy/sensors/barometer.py +++ b/rocketpy/sensors/barometer.py @@ -192,40 +192,6 @@ def export_measured_data(self, filename, format="csv"): ------- None """ - if format == "csv": - # 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,pressure\n") - for t, pressure in data: - f.write(f"{t},{pressure}\n") - print(filename + f"_{i+1},", end=" ") - else: - with open(filename, "w") as f: - f.write("t,pressure\n") - for t, pressure in self.measured_data: - f.write(f"{t},{pressure}\n") - print(f"Data saved to {filename}") - elif format == "json": - if isinstance(self.measured_data[0], list): - print("Data saved to", end=" ") - for i, data in enumerate(self.measured_data): - dict = {"t": [], "pressure": []} - for t, pressure in data: - dict["t"].append(t) - dict["pressure"].append(pressure) - with open(filename + f"_{i+1}", "w") as f: - json.dump(dict, f) - print(filename + f"_{i+1},", end=" ") - else: - dict = {"t": [], "pressure": []} - for t, pressure in self.measured_data: - dict["t"].append(t) - dict["pressure"].append(pressure) - with open(filename, "w") as f: - json.dump(dict, f) - print(f"Data saved to {filename}") - else: - raise ValueError("Invalid format") + super().export_measured_data( + filename=filename, format=format, data_labels=("t", "pressure") + ) diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index 78503cac1..007f0a797 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -299,46 +299,6 @@ def export_measured_data(self, filename, format="csv"): ------- None """ - 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=" ") - 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}") - 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): - 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}") - return + super().export_measured_data( + filename=filename, format=format, data_labels=("t", "wx", "wy", "wz") + ) diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index 5056ded1b..610c55c8e 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -1,4 +1,5 @@ from abc import ABC, abstractmethod +import json import numpy as np @@ -203,6 +204,66 @@ def apply_temperature_drift(self, value): """Apply temperature drift to the sensor measurement""" pass + def export_measured_data(self, filename, format, data_labels): + """ + 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". + data_labels : tuple + Tuple of strings representing the labels for the data columns + + Returns + ------- + None + """ + 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=" ") + for i, data in enumerate(self.measured_data): + with open(filename + f"_{i+1}", "w") as f: + f.write(",".join(data_labels) + "\n") + for entry in data: + f.write(",".join(map(str, entry)) + "\n") + print(filename + f"_{i+1},", end=" ") + else: + with open(filename, "w") as f: + f.write(",".join(data_labels) + "\n") + for entry in self.measured_data: + f.write(",".join(map(str, entry)) + "\n") + print(f"Data saved to {filename}") + 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): + data_dict = {label: [] for label in data_labels} + for entry in data: + for label, value in zip(data_labels, entry): + data_dict[label].append(value) + with open(filename + f"_{i+1}", "w") as f: + json.dump(data_dict, f) + print(filename + f"_{i+1},", end=" ") + else: + data_dict = {label: [] for label in data_labels} + for entry in self.measured_data: + for label, value in zip(data_labels, entry): + data_dict[label].append(value) + with open(filename, "w") as f: + json.dump(data_dict, f) + print(f"Data saved to {filename}") + return + class InertialSensors(Sensors): """Abstract class for sensors From fbaac5381d2ea61d371347e4c06c5abc8a5c238b Mon Sep 17 00:00:00 2001 From: MateusStano Date: Wed, 22 May 2024 21:18:34 +0200 Subject: [PATCH 13/31] TST: improve export data tests --- tests/unit/test_sensors.py | 245 ++++++++----------------------------- 1 file changed, 53 insertions(+), 192 deletions(-) diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensors.py index 6b99bee79..8d1a20dcc 100644 --- a/tests/unit/test_sensors.py +++ b/tests/unit/test_sensors.py @@ -368,28 +368,31 @@ def test_noisy_barometer(noisy_barometer, example_plain_env): @pytest.mark.parametrize( - "sensor, expected_string", + "sensor, format, expected_header, expected_keys", [ - ("ideal_accelerometer", "t,ax,ay,az\n"), - ("ideal_gyroscope", "t,wx,wy,wz\n"), + ("ideal_accelerometer", "csv", "t,ax,ay,az\n", ("ax", "ay", "az")), + ("ideal_gyroscope", "csv", "t,wx,wy,wz\n", ("wx", "wy", "wz")), + ("ideal_accelerometer", "json", None, ("ax", "ay", "az")), + ("ideal_gyroscope", "json", None, ("wx", "wy", "wz")), + ("ideal_barometer", "csv", "t,pressure\n", ("pressure",)), + ("ideal_barometer", "json", None, ("pressure",)), ], ) -def test_export_data_csv(sensor, expected_string, request): - """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. +def test_export_data( + sensor, format, expected_header, expected_keys, request, example_plain_env +): + """Test the export_data method of the sensors. Checks if the data is + exported correctly in the specified format. """ sensor = request.getfixturevalue(sensor) + sensor.measure( time=TIME, u=U, u_dot=U_DOT, relative_position=Vector([0, 0, 0]), gravity=GRAVITY, + pressure=example_plain_env.pressure, ) sensor.measure( time=TIME, @@ -397,205 +400,63 @@ def test_export_data_csv(sensor, expected_string, request): u_dot=U_DOT, relative_position=Vector([0, 0, 0]), gravity=GRAVITY, + pressure=example_plain_env.pressure, ) - file_name = "sensors.csv" + file_name = f"sensors.{format}" - sensor.export_measured_data(file_name, format="csv") + sensor.export_measured_data(file_name, format=format) - with open(file_name, "r") as file: - contents = file.read() + if format == "csv": + with open(file_name, "r") as file: + contents = file.read() - 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 - sensor.measured_data = [ - sensor.measured_data[:], - sensor.measured_data[:], - ] - sensor.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") - - -@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. - - Parameters - ---------- - flight_calisto_accel_gyro : Flight - Pytest fixture for the flight of the calisto rocket with an ideal - accelerometer and a gyroscope. - """ - sensor = request.getfixturevalue(sensor) - sensor.measure( - time=TIME, - u=U, - u_dot=U_DOT, - relative_position=Vector([0, 0, 0]), - gravity=GRAVITY, - ) - sensor.measure( - time=TIME, - u=U, - u_dot=U_DOT, - relative_position=Vector([0, 0, 0]), - gravity=GRAVITY, - ) + expected_data = expected_header + for data in sensor.measured_data: + expected_data += ",".join(map(str, data)) + "\n" - file_name = "sensors.json" + assert contents == expected_data - sensor.export_measured_data(file_name, format="json") + elif format == "json": + with open(file_name, "r") as file: + contents = json.load(file) - contents = json.load(open(file_name, "r")) + expected_data = {"t": []} + for key in expected_keys: + expected_data[key] = [] - 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[expected_string[0]].append(x) - expected_data[expected_string[1]].append(y) - expected_data[expected_string[2]].append(z) + for data in sensor.measured_data: + expected_data["t"].append(data[0]) + for i, key in enumerate(expected_keys): + expected_data[key].append(data[i + 1]) - assert contents == expected_data + assert contents == expected_data - # check exports for accelerometers added more than once to the rocket + # check exports for sensors added more than once to the rocket sensor.measured_data = [ sensor.measured_data[:], sensor.measured_data[:], ] - sensor.export_measured_data(file_name, format="json") - contents = json.load(open(file_name + "_1", "r")) - assert contents == expected_data + sensor.export_measured_data(file_name, format=format) - contents = json.load(open(file_name + "_2", "r")) - assert contents == expected_data + if format == "csv": + with open(f"{file_name}_1", "r") as file: + contents = file.read() + assert contents == expected_data - os.remove(file_name) - os.remove(file_name + "_1") - os.remove(file_name + "_2") + with open(f"{file_name}_2", "r") as file: + contents = file.read() + assert contents == expected_data + elif format == "json": + with open(f"{file_name}_1", "r") as file: + contents = json.load(file) + assert contents == expected_data -def test_export_barometer_data_csv(ideal_barometer, example_plain_env): - """Test the export_data method of the barometer. Checks if the data is - exported correctly.""" - t = SOLUTION[0] - u = SOLUTION[1:] - relative_position = Vector([0, 0, 0]) - ideal_barometer.measure( - t, - u=u, - relative_position=relative_position, - pressure=example_plain_env.pressure, - ) - ideal_barometer.measure( - t, - u=u, - relative_position=relative_position, - pressure=example_plain_env.pressure, - ) - - file_name = "sensors.csv" - - ideal_barometer.export_measured_data(file_name, format="csv") - - with open(file_name, "r") as file: - contents = file.read() - - expected_data = "t,pressure\n" - for t, pressure in ideal_barometer.measured_data: - expected_data += f"{t},{pressure}\n" - - assert contents == expected_data - - # check exports for gyroscopes added more than once to the rocket - ideal_barometer.measured_data = [ - ideal_barometer.measured_data[:], - ideal_barometer.measured_data[:], - ] - ideal_barometer.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_barometer_data_json(ideal_barometer, example_plain_env): - """Test the export_data method of the barometer. Checks if the data is - exported correctly.""" - t = SOLUTION[0] - u = SOLUTION[1:] - relative_position = Vector([0, 0, 0]) - ideal_barometer.measure( - t, - u=u, - relative_position=relative_position, - pressure=example_plain_env.pressure, - ) - ideal_barometer.measure( - t, - u=u, - relative_position=relative_position, - pressure=example_plain_env.pressure, - ) - - file_name = "sensors.json" - - ideal_barometer.export_measured_data(file_name, format="json") - - contents = json.load(open(file_name, "r")) - - expected_data = {"t": [], "pressure": []} - for t, pressure in ideal_barometer.measured_data: - expected_data["t"].append(t) - expected_data["pressure"].append(pressure) - - assert contents == expected_data - - # check exports for gyroscopes added more than once to the rocket - ideal_barometer.measured_data = [ - ideal_barometer.measured_data[:], - ideal_barometer.measured_data[:], - ] - ideal_barometer.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 + with open(f"{file_name}_2", "r") as file: + contents = json.load(file) + assert contents == expected_data os.remove(file_name) - os.remove(file_name + "_1") - os.remove(file_name + "_2") + os.remove(f"{file_name}_1") + os.remove(f"{file_name}_2") From cdb54b1f6098d344f6463326ab365d311b6bc7bc Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 23 May 2024 20:01:07 +0200 Subject: [PATCH 14/31] TST: Refactor sensor tests and export method --- tests/test_sensors.py | 98 +++++++++++++++---------------------------- 1 file changed, 34 insertions(+), 64 deletions(-) diff --git a/tests/test_sensors.py b/tests/test_sensors.py index c9440f568..3b8caeec7 100644 --- a/tests/test_sensors.py +++ b/tests/test_sensors.py @@ -26,76 +26,51 @@ def test_sensor_on_rocket(calisto_sensors): assert isinstance(sensors[2].position, Vector) -@pytest.mark.parametrize( - "sensor_index, measured_data_key, sim_method, tolerance", - [ - (0, "measured_data[0]", lambda flight, time: flight.acceleration(time), 1e-12), - ( - 2, - "measured_data", - lambda flight, time: np.sqrt( - flight.w1(time) ** 2 + flight.w2(time) ** 2 + flight.w3(time) ** 2 - ), - 1e-12, - ), - (3, "measured_data", lambda flight, time: flight.pressure(time), 1e-12), - ], -) -def test_ideal_sensors( - flight_calisto_sensors, sensor_index, measured_data_key, sim_method, tolerance -): +def test_ideal_sensors(flight_calisto_sensors): """Test the ideal sensors. All types of sensors are here to reduce testing time. Parameters ---------- flight_calisto_sensors : Flight - Pytest fixture for the flight of the calisto rocket with a set of ideal - sensors. - sensor_index : int - Index of the sensor in the rocket's sensor list. - measured_data_key : str - Key to access the measured data from the sensor component. - sim_method : function - Function to compute the simulated data. - tolerance : float - Tolerance level for the comparison between measured and simulated data. + Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. """ - sensor = flight_calisto_sensors.rocket.sensors[sensor_index].component - measured_data = eval(f"sensor.{measured_data_key}") + accelerometer = flight_calisto_sensors.rocket.sensors[0].component + time, ax, ay, az = zip(*accelerometer.measured_data[0]) + 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_sensors.acceleration(time) - if sensor_index == 0: # Accelerometer - time, ax, ay, az = zip(*measured_data) - ax = np.array(ax) - ay = np.array(ay) - az = np.array(az) - a = np.sqrt(ax**2 + ay**2 + az**2) - sim_data = sim_method(flight_calisto_sensors, time) - assert np.allclose(a, sim_data, atol=tolerance) - - # Check if both added accelerometer instances saved the same data - assert ( - flight_calisto_sensors.sensors[0].measured_data[0] - == flight_calisto_sensors.sensors[0].measured_data[1] - ) + # 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_sensors.sensors[0].measured_data[0] + == flight_calisto_sensors.sensors[0].measured_data[1] + ) - elif sensor_index == 2: # Gyroscope - time, wx, wy, wz = zip(*measured_data) - wx = np.array(wx) - wy = np.array(wy) - wz = np.array(wz) - w = np.sqrt(wx**2 + wy**2 + wz**2) - sim_data = sim_method(flight_calisto_sensors, time) - assert np.allclose(w, sim_data, atol=tolerance) + gyroscope = flight_calisto_sensors.rocket.sensors[2].component + time, wx, wy, wz = zip(*gyroscope.measured_data) + 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_sensors.w1(time)) + flight_wy = np.array(flight_calisto_sensors.w2(time)) + flight_wz = np.array(flight_calisto_sensors.w3(time)) + sim_w = np.sqrt(flight_wx**2 + flight_wy**2 + flight_wz**2) + assert np.allclose(w, sim_w, atol=1e-12) - elif sensor_index == 3: # Barometer - time, pressure = zip(*measured_data) - pressure = np.array(pressure) - sim_data = sim_method(flight_calisto_sensors, time) - assert np.allclose(pressure, sim_data, atol=tolerance) + barometer = flight_calisto_sensors.rocket.sensors[3].component + time, pressure = zip(*barometer.measured_data) + pressure = np.array(pressure) + sim_data = flight_calisto_sensors.pressure(time) + assert np.allclose(pressure, sim_data, atol=1e-12) -def test_export_sensor_data(flight_calisto_sensors): +def test_export_all_sensors_data(flight_calisto_sensors): """Test the export of sensor data. Parameters @@ -128,12 +103,7 @@ def test_export_sensor_data(flight_calisto_sensors): for measurement in flight_calisto_sensors.sensors[3].measured_data ] assert ( - sensor_data["Accelerometer"]["1"] - == flight_calisto_sensors.sensors[0].measured_data[0] - ) - assert ( - sensor_data["Accelerometer"]["2"] - == flight_calisto_sensors.sensors[1].measured_data[1] + sensor_data["Accelerometer"] == flight_calisto_sensors.sensors[0].measured_data ) assert sensor_data["Gyroscope"] == flight_calisto_sensors.sensors[2].measured_data assert sensor_data["Barometer"] == flight_calisto_sensors.sensors[3].measured_data From 612176dd9fbfccfcfb9d53309c8ec9c9e272dc49 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 23 May 2024 22:57:46 +0200 Subject: [PATCH 15/31] TST: fix fixture names --- tests/test_sensors.py | 2 +- tests/unit/test_flight.py | 26 ++++++++++++-------------- 2 files changed, 13 insertions(+), 15 deletions(-) diff --git a/tests/test_sensors.py b/tests/test_sensors.py index 3b8caeec7..06f9b6178 100644 --- a/tests/test_sensors.py +++ b/tests/test_sensors.py @@ -15,7 +15,7 @@ def test_sensor_on_rocket(calisto_sensors): Parameters ---------- - calisto_accel_gyro : Rocket + calisto_sensors : Rocket Pytest fixture for the calisto rocket with a set of ideal sensors. """ sensors = calisto_sensors.sensors diff --git a/tests/unit/test_flight.py b/tests/unit/test_flight.py index 10ecbe4fe..d775d4175 100644 --- a/tests/unit/test_flight.py +++ b/tests/unit/test_flight.py @@ -289,42 +289,40 @@ def test_out_of_rail_stability_margin(flight_calisto_custom_wind): assert np.isclose(res, 2.14, atol=0.1) -def test_export_sensor_data(flight_calisto_accel_gyro): +def test_export_sensor_data(flight_calisto_sensors): """Test the export of sensor data. Parameters ---------- - flight_calisto_accel_gyro : Flight + flight_calisto_sensors : 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") + flight_calisto_sensors.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] = [ + flight_calisto_sensors.sensors[0].measured_data[0] = [ list(measurement) - for measurement in flight_calisto_accel_gyro.sensors[0].measured_data[0] + for measurement in flight_calisto_sensors.sensors[0].measured_data[0] ] - flight_calisto_accel_gyro.sensors[1].measured_data[1] = [ + flight_calisto_sensors.sensors[1].measured_data[1] = [ list(measurement) - for measurement in flight_calisto_accel_gyro.sensors[1].measured_data[1] + for measurement in flight_calisto_sensors.sensors[1].measured_data[1] ] - flight_calisto_accel_gyro.sensors[2].measured_data = [ + flight_calisto_sensors.sensors[2].measured_data = [ list(measurement) - for measurement in flight_calisto_accel_gyro.sensors[2].measured_data + for measurement in flight_calisto_sensors.sensors[2].measured_data ] assert ( sensor_data["Accelerometer"][0] - == flight_calisto_accel_gyro.sensors[0].measured_data[0] + == flight_calisto_sensors.sensors[0].measured_data[0] ) assert ( sensor_data["Accelerometer"][1] - == flight_calisto_accel_gyro.sensors[1].measured_data[1] - ) - assert ( - sensor_data["Gyroscope"] == flight_calisto_accel_gyro.sensors[2].measured_data + == flight_calisto_sensors.sensors[1].measured_data[1] ) + assert sensor_data["Gyroscope"] == flight_calisto_sensors.sensors[2].measured_data os.remove(filename) From 0bd0f5113f8ec7718fc5de342fa237be2d5b339a Mon Sep 17 00:00:00 2001 From: MateusStano Date: Fri, 24 May 2024 14:28:07 +0200 Subject: [PATCH 16/31] BUG: duplicate IntertialSensors --- rocketpy/sensors/sensors.py | 197 ------------------------------------ 1 file changed, 197 deletions(-) diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index 610c55c8e..99b4d2549 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -265,203 +265,6 @@ def export_measured_data(self, filename, format, data_labels): return -class InertialSensors(Sensors): - """Abstract class for sensors - - Attributes - ---------- - sampling_rate : float - Sample rate of the sensor in Hz. - 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. - 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 - 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. - name : str - The name of the sensor. - 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__( - self, - sampling_rate, - measurement_range=np.inf, - resolution=0, - noise_density=0, - noise_variance=1, - random_walk_density=0, - random_walk_variance=1, - constant_bias=0, - operating_temperature=25, - temperature_bias=0, - temperature_scale_factor=0, - name="Sensor", - ): - """ - Initialize the accelerometer sensor - - Parameters - ---------- - sampling_rate : float - Sample rate of the sensor - 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, list, optional - 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. - 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. - 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. - 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. - constant_bias : float, list, 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, 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, list, optional - The temperature scale factor of the sensor in %/°C. Default is 0, - meaning no temperature scale factor is applied. - name : str, optional - The name of the sensor. Default is "Sensor". - - Returns - ------- - None - - See Also - -------- - TODO link to documentation on noise model - """ - self.sampling_rate = sampling_rate - self.resolution = resolution - self.operating_temperature = operating_temperature - self.noise_density = noise_density - self.noise_variance = noise_variance - self.random_walk_density = random_walk_density - self.random_walk_variance = random_walk_variance - self.constant_bias = constant_bias - self.temperature_bias = temperature_bias - self.temperature_scale_factor = temperature_scale_factor - self.name = name - self.measurement = None - self.measured_data = [] - self._counter = 0 - self._save_data = self._save_data_single - self._random_walk_drift = 0 - self.normal_vector = Vector([0, 0, 0]) - - # 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") - - # 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 _reset(self, simulated_rocket): - """Reset the sensor data for a new simulation.""" - self._random_walk_drift = ( - Vector([0, 0, 0]) if isinstance(self._random_walk_drift, Vector) else 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): - """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 - - @abstractmethod - def measure(self, time, **kwargs): - pass - - @abstractmethod - def export_measured_data(self): - pass - - @abstractmethod - def quantize(self, value): - """Quantize the sensor measurement""" - pass - - @abstractmethod - def apply_noise(self, value): - """Add noise to the sensor measurement""" - pass - - @abstractmethod - def apply_temperature_drift(self, value): - """Apply temperature drift to the sensor measurement""" - pass - - class InertialSensors(Sensors): """Abstract class for sensors From 332f3a949639ff2478e3c5c512cbdaf63b8c8394 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 3 Jun 2024 21:21:38 +0200 Subject: [PATCH 17/31] TST: calisto_sensors to calisto_with_sensors --- tests/fixtures/flight/flight_fixtures.py | 6 +-- tests/fixtures/rockets/rocket_fixtures.py | 2 +- tests/test_sensors.py | 63 ++++++++++++----------- tests/unit/test_flight.py | 26 +++++----- 4 files changed, 52 insertions(+), 45 deletions(-) diff --git a/tests/fixtures/flight/flight_fixtures.py b/tests/fixtures/flight/flight_fixtures.py index 0b47707b1..c8fe437ca 100644 --- a/tests/fixtures/flight/flight_fixtures.py +++ b/tests/fixtures/flight/flight_fixtures.py @@ -161,14 +161,14 @@ def flight_calisto_air_brakes(calisto_air_brakes_clamp_on, example_plain_env): @pytest.fixture -def flight_calisto_sensors(calisto_sensors, example_plain_env): +def flight_calisto_with_sensors(calisto_with_sensors, example_plain_env): """A rocketpy.Flight object of the Calisto rocket. This uses the calisto with a set of ideal sensors. The environment is the simplest possible, with no parameters set. Parameters ---------- - calisto_sensors : rocketpy.Rocket + calisto_with_sensors : rocketpy.Rocket An object of the Rocket class. example_plain_env : rocketpy.Environment An object of the Environment class. @@ -180,7 +180,7 @@ def flight_calisto_sensors(calisto_sensors, example_plain_env): condition. """ return Flight( - rocket=calisto_sensors, + rocket=calisto_with_sensors, environment=example_plain_env, rail_length=5.2, inclination=85, diff --git a/tests/fixtures/rockets/rocket_fixtures.py b/tests/fixtures/rockets/rocket_fixtures.py index 9e971f124..a973e433b 100644 --- a/tests/fixtures/rockets/rocket_fixtures.py +++ b/tests/fixtures/rockets/rocket_fixtures.py @@ -244,7 +244,7 @@ def calisto_air_brakes_clamp_off(calisto_robust, controller_function): @pytest.fixture -def calisto_sensors( +def calisto_with_sensors( calisto, calisto_nose_cone, calisto_tail, diff --git a/tests/test_sensors.py b/tests/test_sensors.py index 06f9b6178..ba9a32b75 100644 --- a/tests/test_sensors.py +++ b/tests/test_sensors.py @@ -10,15 +10,15 @@ from rocketpy.sensors.gyroscope import Gyroscope -def test_sensor_on_rocket(calisto_sensors): +def test_sensor_on_rocket(calisto_with_sensors): """Test the sensor on the rocket. Parameters ---------- - calisto_sensors : Rocket + calisto_with_sensors : Rocket Pytest fixture for the calisto rocket with a set of ideal sensors. """ - sensors = calisto_sensors.sensors + sensors = calisto_with_sensors.sensors assert isinstance(sensors, Components) assert isinstance(sensors[0].component, Accelerometer) assert isinstance(sensors[1].position, Vector) @@ -26,85 +26,90 @@ def test_sensor_on_rocket(calisto_sensors): assert isinstance(sensors[2].position, Vector) -def test_ideal_sensors(flight_calisto_sensors): +def test_ideal_sensors(flight_calisto_with_sensors): """Test the ideal sensors. All types of sensors are here to reduce testing time. Parameters ---------- - flight_calisto_sensors : Flight + flight_calisto_with_sensors : Flight Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. """ - accelerometer = flight_calisto_sensors.rocket.sensors[0].component + accelerometer = flight_calisto_with_sensors.rocket.sensors[0].component time, ax, ay, az = zip(*accelerometer.measured_data[0]) 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_sensors.acceleration(time) + sim_accel = flight_calisto_with_sensors.acceleration(time) # 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_sensors.sensors[0].measured_data[0] - == flight_calisto_sensors.sensors[0].measured_data[1] + flight_calisto_with_sensors.sensors[0].measured_data[0] + == flight_calisto_with_sensors.sensors[0].measured_data[1] ) - gyroscope = flight_calisto_sensors.rocket.sensors[2].component + gyroscope = flight_calisto_with_sensors.rocket.sensors[2].component time, wx, wy, wz = zip(*gyroscope.measured_data) 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_sensors.w1(time)) - flight_wy = np.array(flight_calisto_sensors.w2(time)) - flight_wz = np.array(flight_calisto_sensors.w3(time)) + flight_wx = np.array(flight_calisto_with_sensors.w1(time)) + flight_wy = np.array(flight_calisto_with_sensors.w2(time)) + flight_wz = np.array(flight_calisto_with_sensors.w3(time)) sim_w = np.sqrt(flight_wx**2 + flight_wy**2 + flight_wz**2) assert np.allclose(w, sim_w, atol=1e-12) - barometer = flight_calisto_sensors.rocket.sensors[3].component + barometer = flight_calisto_with_sensors.rocket.sensors[3].component time, pressure = zip(*barometer.measured_data) pressure = np.array(pressure) - sim_data = flight_calisto_sensors.pressure(time) + sim_data = flight_calisto_with_sensors.pressure(time) assert np.allclose(pressure, sim_data, atol=1e-12) -def test_export_all_sensors_data(flight_calisto_sensors): +def test_export_all_sensors_data(flight_calisto_with_sensors): """Test the export of sensor data. Parameters ---------- - flight_calisto_sensors : Flight + flight_calisto_with_sensors : Flight Pytest fixture for the flight of the calisto rocket with a set of ideal sensors. """ - flight_calisto_sensors.export_sensor_data("test_sensor_data.json") + flight_calisto_with_sensors.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_sensors.sensors[0].measured_data[0] = [ + flight_calisto_with_sensors.sensors[0].measured_data[0] = [ list(measurement) - for measurement in flight_calisto_sensors.sensors[0].measured_data[0] + for measurement in flight_calisto_with_sensors.sensors[0].measured_data[0] ] - flight_calisto_sensors.sensors[1].measured_data[1] = [ + flight_calisto_with_sensors.sensors[1].measured_data[1] = [ list(measurement) - for measurement in flight_calisto_sensors.sensors[1].measured_data[1] + for measurement in flight_calisto_with_sensors.sensors[1].measured_data[1] ] - flight_calisto_sensors.sensors[2].measured_data = [ + flight_calisto_with_sensors.sensors[2].measured_data = [ list(measurement) - for measurement in flight_calisto_sensors.sensors[2].measured_data + for measurement in flight_calisto_with_sensors.sensors[2].measured_data ] - flight_calisto_sensors.sensors[3].measured_data = [ + flight_calisto_with_sensors.sensors[3].measured_data = [ list(measurement) - for measurement in flight_calisto_sensors.sensors[3].measured_data + for measurement in flight_calisto_with_sensors.sensors[3].measured_data ] assert ( - sensor_data["Accelerometer"] == flight_calisto_sensors.sensors[0].measured_data + sensor_data["Accelerometer"] + == flight_calisto_with_sensors.sensors[0].measured_data + ) + assert ( + sensor_data["Gyroscope"] == flight_calisto_with_sensors.sensors[2].measured_data + ) + assert ( + sensor_data["Barometer"] == flight_calisto_with_sensors.sensors[3].measured_data ) - assert sensor_data["Gyroscope"] == flight_calisto_sensors.sensors[2].measured_data - assert sensor_data["Barometer"] == flight_calisto_sensors.sensors[3].measured_data os.remove(filename) diff --git a/tests/unit/test_flight.py b/tests/unit/test_flight.py index d775d4175..e09657d82 100644 --- a/tests/unit/test_flight.py +++ b/tests/unit/test_flight.py @@ -289,40 +289,42 @@ def test_out_of_rail_stability_margin(flight_calisto_custom_wind): assert np.isclose(res, 2.14, atol=0.1) -def test_export_sensor_data(flight_calisto_sensors): +def test_export_sensor_data(flight_calisto_with_sensors): """Test the export of sensor data. Parameters ---------- - flight_calisto_sensors : Flight + flight_calisto_with_sensors : Flight Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope. """ - flight_calisto_sensors.export_sensor_data("test_sensor_data.json") + flight_calisto_with_sensors.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_sensors.sensors[0].measured_data[0] = [ + flight_calisto_with_sensors.sensors[0].measured_data[0] = [ list(measurement) - for measurement in flight_calisto_sensors.sensors[0].measured_data[0] + for measurement in flight_calisto_with_sensors.sensors[0].measured_data[0] ] - flight_calisto_sensors.sensors[1].measured_data[1] = [ + flight_calisto_with_sensors.sensors[1].measured_data[1] = [ list(measurement) - for measurement in flight_calisto_sensors.sensors[1].measured_data[1] + for measurement in flight_calisto_with_sensors.sensors[1].measured_data[1] ] - flight_calisto_sensors.sensors[2].measured_data = [ + flight_calisto_with_sensors.sensors[2].measured_data = [ list(measurement) - for measurement in flight_calisto_sensors.sensors[2].measured_data + for measurement in flight_calisto_with_sensors.sensors[2].measured_data ] assert ( sensor_data["Accelerometer"][0] - == flight_calisto_sensors.sensors[0].measured_data[0] + == flight_calisto_with_sensors.sensors[0].measured_data[0] ) assert ( sensor_data["Accelerometer"][1] - == flight_calisto_sensors.sensors[1].measured_data[1] + == flight_calisto_with_sensors.sensors[1].measured_data[1] + ) + assert ( + sensor_data["Gyroscope"] == flight_calisto_with_sensors.sensors[2].measured_data ) - assert sensor_data["Gyroscope"] == flight_calisto_sensors.sensors[2].measured_data os.remove(filename) From b88257983650a40ff82c34c9adb3a8edab5fbc5e Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 3 Jun 2024 21:21:53 +0200 Subject: [PATCH 18/31] MNT: isort --- rocketpy/__init__.py | 2 +- rocketpy/sensors/__init__.py | 4 ++-- rocketpy/sensors/sensors.py | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/rocketpy/__init__.py b/rocketpy/__init__.py index 1e0c0bef5..43a6ebc67 100644 --- a/rocketpy/__init__.py +++ b/rocketpy/__init__.py @@ -37,5 +37,5 @@ Tail, TrapezoidalFins, ) -from .sensors import Accelerometer, Gyroscope, Barometer +from .sensors import Accelerometer, Barometer, Gyroscope from .simulation import Flight diff --git a/rocketpy/sensors/__init__.py b/rocketpy/sensors/__init__.py index 754a3f704..50a105551 100644 --- a/rocketpy/sensors/__init__.py +++ b/rocketpy/sensors/__init__.py @@ -1,4 +1,4 @@ from .accelerometer import Accelerometer -from .gyroscope import Gyroscope -from .sensors import Sensors, InertialSensors, ScalarSensors from .barometer import Barometer +from .gyroscope import Gyroscope +from .sensors import InertialSensors, ScalarSensors, Sensors diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index 99b4d2549..a5efdd8e0 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -1,5 +1,5 @@ -from abc import ABC, abstractmethod import json +from abc import ABC, abstractmethod import numpy as np From 5d5f9e9b68b1961a408f3de1a0891d0d27541ee3 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 3 Jun 2024 22:08:26 +0200 Subject: [PATCH 19/31] MNT: remove type docs --- rocketpy/sensors/sensors.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index a5efdd8e0..0f0cd8f1e 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -11,8 +11,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. measurement_range : float, tuple From f913f8602ccdbaf74e2a379bd3bf8b500202e3fd Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 3 Jun 2024 22:09:59 +0200 Subject: [PATCH 20/31] ENH: move export_sensor_measured_data to tools.py --- rocketpy/sensors/accelerometer.py | 4 +- rocketpy/sensors/barometer.py | 4 +- rocketpy/sensors/gyroscope.py | 4 +- rocketpy/sensors/sensors.py | 62 ++----------------------------- rocketpy/tools.py | 62 +++++++++++++++++++++++++++++++ 5 files changed, 74 insertions(+), 62 deletions(-) diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 176f6d9ef..e1241406e 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -2,6 +2,8 @@ import numpy as np +from rocketpy.tools import export_sensors_measured_data + from ..mathutils.vector_matrix import Matrix, Vector from ..prints.sensors_prints import _AccelerometerPrints from ..sensors.sensors import InertialSensors @@ -267,6 +269,6 @@ def export_measured_data(self, filename, format="csv"): ------- None """ - super().export_measured_data( + export_sensors_measured_data( filename=filename, format=format, data_labels=("t", "ax", "ay", "az") ) diff --git a/rocketpy/sensors/barometer.py b/rocketpy/sensors/barometer.py index f7f70fb70..5eb2199c2 100644 --- a/rocketpy/sensors/barometer.py +++ b/rocketpy/sensors/barometer.py @@ -2,6 +2,8 @@ import numpy as np +from rocketpy.tools import export_sensors_measured_data + from ..mathutils.vector_matrix import Matrix from ..prints.sensors_prints import _BarometerPrints from ..sensors.sensors import ScalarSensors @@ -192,6 +194,6 @@ def export_measured_data(self, filename, format="csv"): ------- None """ - super().export_measured_data( + export_sensors_measured_data( filename=filename, format=format, data_labels=("t", "pressure") ) diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index 007f0a797..f6b6db779 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -2,6 +2,8 @@ import numpy as np +from rocketpy.tools import export_sensors_measured_data + from ..mathutils.vector_matrix import Matrix, Vector from ..prints.sensors_prints import _GyroscopePrints from ..sensors.sensors import InertialSensors @@ -299,6 +301,6 @@ def export_measured_data(self, filename, format="csv"): ------- None """ - super().export_measured_data( + export_sensors_measured_data( filename=filename, format=format, data_labels=("t", "wx", "wy", "wz") ) diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index 0f0cd8f1e..a29b932f3 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -202,65 +202,9 @@ def apply_temperature_drift(self, value): """Apply temperature drift to the sensor measurement""" pass - def export_measured_data(self, filename, format, data_labels): - """ - 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". - data_labels : tuple - Tuple of strings representing the labels for the data columns - - Returns - ------- - None - """ - 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=" ") - for i, data in enumerate(self.measured_data): - with open(filename + f"_{i+1}", "w") as f: - f.write(",".join(data_labels) + "\n") - for entry in data: - f.write(",".join(map(str, entry)) + "\n") - print(filename + f"_{i+1},", end=" ") - else: - with open(filename, "w") as f: - f.write(",".join(data_labels) + "\n") - for entry in self.measured_data: - f.write(",".join(map(str, entry)) + "\n") - print(f"Data saved to {filename}") - 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): - data_dict = {label: [] for label in data_labels} - for entry in data: - for label, value in zip(data_labels, entry): - data_dict[label].append(value) - with open(filename + f"_{i+1}", "w") as f: - json.dump(data_dict, f) - print(filename + f"_{i+1},", end=" ") - else: - data_dict = {label: [] for label in data_labels} - for entry in self.measured_data: - for label, value in zip(data_labels, entry): - data_dict[label].append(value) - with open(filename, "w") as f: - json.dump(data_dict, f) - print(f"Data saved to {filename}") - return + @abstractmethod + def export_measured_data(self, filename, format="csv"): + pass class InertialSensors(Sensors): diff --git a/rocketpy/tools.py b/rocketpy/tools.py index 0cbd16628..be70516c8 100644 --- a/rocketpy/tools.py +++ b/rocketpy/tools.py @@ -1,6 +1,7 @@ import functools import importlib import importlib.metadata +import json import math import re import time @@ -522,6 +523,67 @@ def normalize_quaternions(quaternions): return q_w / q_norm, q_x / q_norm, q_y / q_norm, q_z / q_norm +def export_sensors_measured_data(self, filename, format, data_labels): + """ + 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". + data_labels : tuple + Tuple of strings representing the labels for the data columns + + Returns + ------- + None + """ + 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=" ") + for i, data in enumerate(self.measured_data): + with open(filename + f"_{i+1}", "w") as f: + f.write(",".join(data_labels) + "\n") + for entry in data: + f.write(",".join(map(str, entry)) + "\n") + print(filename + f"_{i+1},", end=" ") + else: + with open(filename, "w") as f: + f.write(",".join(data_labels) + "\n") + for entry in self.measured_data: + f.write(",".join(map(str, entry)) + "\n") + print(f"Data saved to {filename}") + 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): + data_dict = {label: [] for label in data_labels} + for entry in data: + for label, value in zip(data_labels, entry): + data_dict[label].append(value) + with open(filename + f"_{i+1}", "w") as f: + json.dump(data_dict, f) + print(filename + f"_{i+1},", end=" ") + else: + data_dict = {label: [] for label in data_labels} + for entry in self.measured_data: + for label, value in zip(data_labels, entry): + data_dict[label].append(value) + with open(filename, "w") as f: + json.dump(data_dict, f) + print(f"Data saved to {filename}") + return + + if __name__ == "__main__": import doctest From 3558effbe477cb89871c3f0e90424708a076693a Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 3 Jun 2024 22:35:41 +0200 Subject: [PATCH 21/31] MNT: pylint fixes --- rocketpy/control/controller.py | 1 + rocketpy/prints/sensors_prints.py | 20 ++++---------------- rocketpy/sensors/accelerometer.py | 15 ++++++++------- rocketpy/sensors/barometer.py | 13 +++++++------ rocketpy/sensors/gyroscope.py | 17 +++++++++-------- rocketpy/sensors/sensors.py | 9 +++------ rocketpy/tools.py | 28 +++++++++++++++------------- 7 files changed, 47 insertions(+), 56 deletions(-) diff --git a/rocketpy/control/controller.py b/rocketpy/control/controller.py index c2617f8eb..93a13ecfd 100644 --- a/rocketpy/control/controller.py +++ b/rocketpy/control/controller.py @@ -101,6 +101,7 @@ def __init_controller_function(self, controller_function): sig = signature(controller_function) if len(sig.parameters) == 6: + # pylint: disable=unused-argument def new_controller_function( time, sampling_rate, diff --git a/rocketpy/prints/sensors_prints.py b/rocketpy/prints/sensors_prints.py index af3979e04..89c851e3c 100644 --- a/rocketpy/prints/sensors_prints.py +++ b/rocketpy/prints/sensors_prints.py @@ -1,4 +1,4 @@ -from abc import ABC, abstractmethod +from abc import ABC class _SensorsPrints(ABC): @@ -32,7 +32,8 @@ def quantization(self): print("\nQuantization:\n") self._print_aligned( "Measurement Range:", - f"{self.sensor.measurement_range[0]} to {self.sensor.measurement_range[1]} ({self.units})", + f"{self.sensor.measurement_range[0]} " + + f"to {self.sensor.measurement_range[1]} ({self.units})", ) self._print_aligned("Resolution:", f"{self.sensor.resolution} {self.units}/LSB") @@ -78,8 +79,6 @@ def all(self): class _InertialSensorsPrints(_SensorsPrints): - def __init__(self, sensor): - super().__init__(sensor) def orientation(self): """Prints the orientation of the sensor.""" @@ -109,18 +108,10 @@ def all(self): class _AccelerometerPrints(_InertialSensorsPrints): """Class that contains all accelerometer prints.""" - def __init__(self, accelerometer): - """Initialize the class.""" - super().__init__(accelerometer) - class _GyroscopePrints(_InertialSensorsPrints): """Class that contains all gyroscope prints.""" - def __init__(self, gyroscope): - """Initialize the class.""" - super().__init__(gyroscope) - def noise(self): """Prints the noise of the sensor.""" self._general_noise() @@ -130,9 +121,6 @@ def noise(self): ) +# TODO: simplify prints class _BarometerPrints(_SensorsPrints): """Class that contains all barometer prints.""" - - def __init__(self, barometer): - """Initialize the class.""" - super().__init__(barometer) diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index e1241406e..5a407f528 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -1,5 +1,3 @@ -import json - import numpy as np from rocketpy.tools import export_sensors_measured_data @@ -225,7 +223,7 @@ def measure(self, time, **kwargs): gravity = ( Vector([0, 0, -gravity]) if self.consider_gravity else Vector([0, 0, 0]) ) - a_I = Vector(u_dot[3:6]) + gravity + inertial_acceleration = Vector(u_dot[3:6]) + gravity # Vector from rocket cdm to sensor in rocket frame r = relative_position @@ -236,7 +234,7 @@ def measure(self, time, **kwargs): # Measured acceleration at sensor position in inertial frame A = ( - a_I + inertial_acceleration + Vector.cross(omega_dot, r) + Vector.cross(omega, Vector.cross(omega, r)) ) @@ -254,14 +252,14 @@ def measure(self, time, **kwargs): self.measurement = tuple([*A]) self._save_data((time, *A)) - def export_measured_data(self, filename, format="csv"): + def export_measured_data(self, filename, file_format="csv"): """Export the measured values to a file Parameters ---------- filename : str Name of the file to export the values to - format : str + file_format : str Format of the file to export the values to. Options are "csv" and "json". Default is "csv". @@ -270,5 +268,8 @@ def export_measured_data(self, filename, format="csv"): None """ export_sensors_measured_data( - filename=filename, format=format, data_labels=("t", "ax", "ay", "az") + sensor=self, + filename=filename, + file_format=file_format, + data_labels=("t", "ax", "ay", "az"), ) diff --git a/rocketpy/sensors/barometer.py b/rocketpy/sensors/barometer.py index 5eb2199c2..2c143e982 100644 --- a/rocketpy/sensors/barometer.py +++ b/rocketpy/sensors/barometer.py @@ -1,5 +1,3 @@ -import json - import numpy as np from rocketpy.tools import export_sensors_measured_data @@ -179,15 +177,15 @@ def measure(self, time, **kwargs): self.measurement = P self._save_data((time, P)) - def export_measured_data(self, filename, format="csv"): + def export_measured_data(self, filename, file_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 + file_format : str + file_format of the file to export the values to. Options are "csv" and "json". Default is "csv". Returns @@ -195,5 +193,8 @@ def export_measured_data(self, filename, format="csv"): None """ export_sensors_measured_data( - filename=filename, format=format, data_labels=("t", "pressure") + sensor=self, + filename=filename, + file_format=file_format, + data_labels=("t", "pressure"), ) diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index f6b6db779..92ba89d47 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -1,5 +1,3 @@ -import json - import numpy as np from rocketpy.tools import export_sensors_measured_data @@ -270,14 +268,14 @@ def apply_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]) + inertial_acceleration = 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 + inertial_acceleration + Vector.cross(omega_dot, relative_position) + Vector.cross(omega, Vector.cross(omega, relative_position)) ) @@ -286,15 +284,15 @@ def apply_acceleration_sensitivity( return self.acceleration_sensitivity & A - def export_measured_data(self, filename, format="csv"): + def export_measured_data(self, filename, file_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 + file_format : str + file_Format of the file to export the values to. Options are "csv" and "json". Default is "csv". Returns @@ -302,5 +300,8 @@ def export_measured_data(self, filename, format="csv"): None """ export_sensors_measured_data( - filename=filename, format=format, data_labels=("t", "wx", "wy", "wz") + sensor=self, + filename=filename, + file_format=file_format, + data_labels=("t", "wx", "wy", "wz"), ) diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index a29b932f3..8a3050d9d 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -1,4 +1,3 @@ -import json from abc import ABC, abstractmethod import numpy as np @@ -181,10 +180,7 @@ def _save_data_multiple(self, data): @abstractmethod def measure(self, time, **kwargs): - pass - - @abstractmethod - def export_measured_data(self): + """Measure the sensor data at a given time""" pass @abstractmethod @@ -203,7 +199,8 @@ def apply_temperature_drift(self, value): pass @abstractmethod - def export_measured_data(self, filename, format="csv"): + def export_measured_data(self, filename, file_format="csv"): + """Export the measured values to a file""" pass diff --git a/rocketpy/tools.py b/rocketpy/tools.py index be70516c8..e540e3fd4 100644 --- a/rocketpy/tools.py +++ b/rocketpy/tools.py @@ -523,16 +523,18 @@ def normalize_quaternions(quaternions): return q_w / q_norm, q_x / q_norm, q_y / q_norm, q_z / q_norm -def export_sensors_measured_data(self, filename, format, data_labels): +def export_sensors_measured_data(sensor, filename, file_format, data_labels): """ Export the measured values to a file Parameters ---------- + sensor : Sensor + Sensor object to export the measured values from. 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 + file_format : str + file_format of the file to export the values to. Options are "csv" and "json". Default is "csv". data_labels : tuple Tuple of strings representing the labels for the data columns @@ -541,14 +543,14 @@ def export_sensors_measured_data(self, filename, format, data_labels): ------- None """ - if format.lower() not in ["json", "csv"]: - raise ValueError("Invalid format") + if file_format.lower() not in ["json", "csv"]: + raise ValueError("Invalid file_format") - if format.lower() == "csv": + if file_format.lower() == "csv": # if sensor has been added multiple times to the simulated rocket - if isinstance(self.measured_data[0], list): + if isinstance(sensor.measured_data[0], list): print("Data saved to", end=" ") - for i, data in enumerate(self.measured_data): + for i, data in enumerate(sensor.measured_data): with open(filename + f"_{i+1}", "w") as f: f.write(",".join(data_labels) + "\n") for entry in data: @@ -557,15 +559,15 @@ def export_sensors_measured_data(self, filename, format, data_labels): else: with open(filename, "w") as f: f.write(",".join(data_labels) + "\n") - for entry in self.measured_data: + for entry in sensor.measured_data: f.write(",".join(map(str, entry)) + "\n") print(f"Data saved to {filename}") return - if format.lower() == "json": - if isinstance(self.measured_data[0], list): + if file_format.lower() == "json": + if isinstance(sensor.measured_data[0], list): print("Data saved to", end=" ") - for i, data in enumerate(self.measured_data): + for i, data in enumerate(sensor.measured_data): data_dict = {label: [] for label in data_labels} for entry in data: for label, value in zip(data_labels, entry): @@ -575,7 +577,7 @@ def export_sensors_measured_data(self, filename, format, data_labels): print(filename + f"_{i+1},", end=" ") else: data_dict = {label: [] for label in data_labels} - for entry in self.measured_data: + for entry in sensor.measured_data: for label, value in zip(data_labels, entry): data_dict[label].append(value) with open(filename, "w") as f: From 7e419b096ebb0e058cef10ff85df1d09a8cef133 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 3 Jun 2024 22:37:31 +0200 Subject: [PATCH 22/31] ENH: simplify sensors prints --- rocketpy/prints/sensors_prints.py | 9 --------- rocketpy/sensors/accelerometer.py | 6 +++--- rocketpy/sensors/barometer.py | 6 +++--- 3 files changed, 6 insertions(+), 15 deletions(-) diff --git a/rocketpy/prints/sensors_prints.py b/rocketpy/prints/sensors_prints.py index 89c851e3c..5c5f9a9b3 100644 --- a/rocketpy/prints/sensors_prints.py +++ b/rocketpy/prints/sensors_prints.py @@ -105,10 +105,6 @@ def all(self): self.noise() -class _AccelerometerPrints(_InertialSensorsPrints): - """Class that contains all accelerometer prints.""" - - class _GyroscopePrints(_InertialSensorsPrints): """Class that contains all gyroscope prints.""" @@ -119,8 +115,3 @@ def noise(self): "Acceleration Sensitivity:", f"{self.sensor.acceleration_sensitivity} rad/s/g", ) - - -# TODO: simplify prints -class _BarometerPrints(_SensorsPrints): - """Class that contains all barometer prints.""" diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 5a407f528..86d2a972f 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -3,7 +3,7 @@ from rocketpy.tools import export_sensors_measured_data from ..mathutils.vector_matrix import Matrix, Vector -from ..prints.sensors_prints import _AccelerometerPrints +from ..prints.sensors_prints import _InertialSensorsPrints from ..sensors.sensors import InertialSensors @@ -14,7 +14,7 @@ class Accelerometer(InertialSensors): ---------- consider_gravity : bool Whether the sensor considers the effect of gravity on the acceleration. - prints : _AccelerometerPrints + prints : _InertialSensorsPrints Object that contains the print functions for the sensor. sampling_rate : float Sample rate of the sensor in Hz. @@ -192,7 +192,7 @@ def __init__( name=name, ) self.consider_gravity = consider_gravity - self.prints = _AccelerometerPrints(self) + self.prints = _InertialSensorsPrints(self) def measure(self, time, **kwargs): """Measure the acceleration of the rocket diff --git a/rocketpy/sensors/barometer.py b/rocketpy/sensors/barometer.py index 2c143e982..79844a4b2 100644 --- a/rocketpy/sensors/barometer.py +++ b/rocketpy/sensors/barometer.py @@ -3,7 +3,7 @@ from rocketpy.tools import export_sensors_measured_data from ..mathutils.vector_matrix import Matrix -from ..prints.sensors_prints import _BarometerPrints +from ..prints.sensors_prints import _SensorsPrints from ..sensors.sensors import ScalarSensors @@ -14,7 +14,7 @@ class Barometer(ScalarSensors): ---------- type : str Type of the sensor, in this case "Barometer". - prints : _BarometerPrints + prints : _SensorsPrints Object that contains the print functions for the sensor. sampling_rate : float Sample rate of the sensor in Hz. @@ -137,7 +137,7 @@ def __init__( name=name, ) self.type = "Barometer" - self.prints = _BarometerPrints(self) + self.prints = _SensorsPrints(self) def measure(self, time, **kwargs): """Measures the pressure at barometer location From 4e5ad4e2ace90d62103d4aba70426cb73361c12a Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 3 Jun 2024 22:42:24 +0200 Subject: [PATCH 23/31] MNT: rename sensors classes --- rocketpy/prints/sensors_prints.py | 6 +++--- rocketpy/rocket/rocket.py | 2 +- rocketpy/sensors/__init__.py | 2 +- rocketpy/sensors/accelerometer.py | 10 +++++----- rocketpy/sensors/barometer.py | 10 +++++----- rocketpy/sensors/gyroscope.py | 4 ++-- rocketpy/sensors/sensors.py | 6 +++--- tests/unit/test_sensors.py | 10 +++++----- 8 files changed, 25 insertions(+), 25 deletions(-) diff --git a/rocketpy/prints/sensors_prints.py b/rocketpy/prints/sensors_prints.py index 5c5f9a9b3..ad9c693e9 100644 --- a/rocketpy/prints/sensors_prints.py +++ b/rocketpy/prints/sensors_prints.py @@ -1,7 +1,7 @@ from abc import ABC -class _SensorsPrints(ABC): +class _SensorPrints(ABC): def __init__(self, sensor): self.sensor = sensor self.units = sensor.units @@ -78,7 +78,7 @@ def all(self): self.noise() -class _InertialSensorsPrints(_SensorsPrints): +class _InertialSensorPrints(_SensorPrints): def orientation(self): """Prints the orientation of the sensor.""" @@ -105,7 +105,7 @@ def all(self): self.noise() -class _GyroscopePrints(_InertialSensorsPrints): +class _GyroscopePrints(_InertialSensorPrints): """Class that contains all gyroscope prints.""" def noise(self): diff --git a/rocketpy/rocket/rocket.py b/rocketpy/rocket/rocket.py index c7bbd380a..117a6d95f 100644 --- a/rocketpy/rocket/rocket.py +++ b/rocketpy/rocket/rocket.py @@ -286,7 +286,7 @@ def __init__( self.thrust_eccentricity_y = 0 self.thrust_eccentricity_x = 0 - # Parachute, Aerodynamic, Buttons, Controllers, Sensors data initialization + # Parachute, Aerodynamic, Buttons, Controllers, Sensor data initialization self.parachutes = [] self._controllers = [] self.air_brakes = [] diff --git a/rocketpy/sensors/__init__.py b/rocketpy/sensors/__init__.py index 50a105551..28d9273ec 100644 --- a/rocketpy/sensors/__init__.py +++ b/rocketpy/sensors/__init__.py @@ -1,4 +1,4 @@ from .accelerometer import Accelerometer from .barometer import Barometer from .gyroscope import Gyroscope -from .sensors import InertialSensors, ScalarSensors, Sensors +from .sensors import InertialSensor, ScalarSensor, Sensor diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 86d2a972f..ea58d65da 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -3,18 +3,18 @@ from rocketpy.tools import export_sensors_measured_data from ..mathutils.vector_matrix import Matrix, Vector -from ..prints.sensors_prints import _InertialSensorsPrints -from ..sensors.sensors import InertialSensors +from ..prints.sensors_prints import _InertialSensorPrints +from ..sensors.sensors import InertialSensor -class Accelerometer(InertialSensors): +class Accelerometer(InertialSensor): """Class for the accelerometer sensor Attributes ---------- consider_gravity : bool Whether the sensor considers the effect of gravity on the acceleration. - prints : _InertialSensorsPrints + prints : _InertialSensorPrints Object that contains the print functions for the sensor. sampling_rate : float Sample rate of the sensor in Hz. @@ -192,7 +192,7 @@ def __init__( name=name, ) self.consider_gravity = consider_gravity - self.prints = _InertialSensorsPrints(self) + self.prints = _InertialSensorPrints(self) def measure(self, time, **kwargs): """Measure the acceleration of the rocket diff --git a/rocketpy/sensors/barometer.py b/rocketpy/sensors/barometer.py index 79844a4b2..615c8bacc 100644 --- a/rocketpy/sensors/barometer.py +++ b/rocketpy/sensors/barometer.py @@ -3,18 +3,18 @@ from rocketpy.tools import export_sensors_measured_data from ..mathutils.vector_matrix import Matrix -from ..prints.sensors_prints import _SensorsPrints -from ..sensors.sensors import ScalarSensors +from ..prints.sensors_prints import _SensorPrints +from ..sensors.sensors import ScalarSensor -class Barometer(ScalarSensors): +class Barometer(ScalarSensor): """Class for the barometer sensor Attributes ---------- type : str Type of the sensor, in this case "Barometer". - prints : _SensorsPrints + prints : _SensorPrints Object that contains the print functions for the sensor. sampling_rate : float Sample rate of the sensor in Hz. @@ -137,7 +137,7 @@ def __init__( name=name, ) self.type = "Barometer" - self.prints = _SensorsPrints(self) + self.prints = _SensorPrints(self) def measure(self, time, **kwargs): """Measures the pressure at barometer location diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index 92ba89d47..09d35ccab 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -4,10 +4,10 @@ from ..mathutils.vector_matrix import Matrix, Vector from ..prints.sensors_prints import _GyroscopePrints -from ..sensors.sensors import InertialSensors +from ..sensors.sensors import InertialSensor -class Gyroscope(InertialSensors): +class Gyroscope(InertialSensor): """Class for the gyroscope sensor Attributes diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py index 8a3050d9d..f8c185a13 100644 --- a/rocketpy/sensors/sensors.py +++ b/rocketpy/sensors/sensors.py @@ -5,7 +5,7 @@ from rocketpy.mathutils.vector_matrix import Matrix, Vector -class Sensors(ABC): +class Sensor(ABC): """Abstract class for sensors Attributes @@ -204,7 +204,7 @@ def export_measured_data(self, filename, file_format="csv"): pass -class InertialSensors(Sensors): +class InertialSensor(Sensor): """Abstract class for sensors Attributes @@ -502,7 +502,7 @@ def apply_temperature_drift(self, value): return value & scale_factor -class ScalarSensors(Sensors): +class ScalarSensor(Sensor): """Abstract class for sensors Attributes diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensors.py index 8d1a20dcc..8bb506d40 100644 --- a/tests/unit/test_sensors.py +++ b/tests/unit/test_sensors.py @@ -64,7 +64,7 @@ def test_sensors_prints(sensor, request): def test_rotation_matrix(noisy_rotated_accelerometer): - """Test the rotation_matrix property of the InertialSensors class. Checks if + """Test the rotation_matrix property of the InertialSensor class. Checks if the rotation matrix is correctly calculated. """ # values from external source @@ -80,7 +80,7 @@ def test_rotation_matrix(noisy_rotated_accelerometer): def test_inertial_quantization(quantized_accelerometer): - """Test the quantize method of the InertialSensors class. Checks if returned values + """Test the quantize method of the InertialSensor class. Checks if returned values are as expected. """ # expected values calculated by hand @@ -96,7 +96,7 @@ def test_inertial_quantization(quantized_accelerometer): def test_scalar_quantization(quantized_barometer): - """Test the quantize method of the ScalarSensors class. Checks if returned values + """Test the quantize method of the ScalarSensor class. Checks if returned values are as expected. """ # expected values calculated by hand @@ -157,7 +157,7 @@ def test_quantization(sensor, input_value, expected_output, request): ], ) def test_inertial_measured_data(sensor, request): - """Test the measured_data property of the Sensors class. Checks if + """Test the measured_data property of the Sensor class. Checks if the measured data is treated properly when the sensor is added once or more than once to the rocket. """ @@ -209,7 +209,7 @@ def test_inertial_measured_data(sensor, request): def test_scalar_measured_data(ideal_barometer, example_plain_env): - """Test the measure method of ScalarSensors. Checks if saved + """Test the measure method of ScalarSensor. Checks if saved measurement is (P) and if measured_data is [(t, P), ...] """ t = TIME From 4a2eb07ecf8ef9c73a5034b2f3c253694d0792ac Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 3 Jun 2024 22:44:23 +0200 Subject: [PATCH 24/31] MNT: sensor.py rename --- rocketpy/sensors/{sensors.py => sensor.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename rocketpy/sensors/{sensors.py => sensor.py} (100%) diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensor.py similarity index 100% rename from rocketpy/sensors/sensors.py rename to rocketpy/sensors/sensor.py From 642e1b3cd8adff40219bf2b41eaf548f4cf1d027 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 3 Jun 2024 22:52:16 +0200 Subject: [PATCH 25/31] DOC: improve inertialsensor and scalar sensor doc --- rocketpy/sensors/sensor.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/rocketpy/sensors/sensor.py b/rocketpy/sensors/sensor.py index f8c185a13..f49450d4d 100644 --- a/rocketpy/sensors/sensor.py +++ b/rocketpy/sensors/sensor.py @@ -205,7 +205,9 @@ def export_measured_data(self, filename, file_format="csv"): class InertialSensor(Sensor): - """Abstract class for sensors + """Model of an inertial sensor (accelerometer, gyroscope, magnetometer). + Inertial sensors measurements are handled as vectors. The measurements are + affected by the sensor's orientation in the rocket. Attributes ---------- @@ -503,12 +505,12 @@ def apply_temperature_drift(self, value): class ScalarSensor(Sensor): - """Abstract class for sensors + """Model of a scalar sensor (barometer, GPS, etc.). Scalar sensors are used + to measure a single scalar value. The measurements are not affected by the + sensor's orientation in the rocket. Attributes ---------- - type : str - Type of the sensor (e.g. Barometer, GPS). sampling_rate : float Sample rate of the sensor in Hz. measurement_range : float, tuple From 773ec595d85993c369d77795449b18d48f5f4df0 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 3 Jun 2024 22:52:30 +0200 Subject: [PATCH 26/31] MNT: sensors to sensor rename imports --- rocketpy/sensors/__init__.py | 2 +- rocketpy/sensors/accelerometer.py | 2 +- rocketpy/sensors/barometer.py | 5 +---- rocketpy/sensors/gyroscope.py | 2 +- 4 files changed, 4 insertions(+), 7 deletions(-) diff --git a/rocketpy/sensors/__init__.py b/rocketpy/sensors/__init__.py index 28d9273ec..40bac14cc 100644 --- a/rocketpy/sensors/__init__.py +++ b/rocketpy/sensors/__init__.py @@ -1,4 +1,4 @@ from .accelerometer import Accelerometer from .barometer import Barometer from .gyroscope import Gyroscope -from .sensors import InertialSensor, ScalarSensor, Sensor +from .sensor import InertialSensor, ScalarSensor, Sensor diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index ea58d65da..45f9edc13 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -4,7 +4,7 @@ from ..mathutils.vector_matrix import Matrix, Vector from ..prints.sensors_prints import _InertialSensorPrints -from ..sensors.sensors import InertialSensor +from ..sensors.sensor import InertialSensor class Accelerometer(InertialSensor): diff --git a/rocketpy/sensors/barometer.py b/rocketpy/sensors/barometer.py index 615c8bacc..695f32b1b 100644 --- a/rocketpy/sensors/barometer.py +++ b/rocketpy/sensors/barometer.py @@ -4,7 +4,7 @@ from ..mathutils.vector_matrix import Matrix from ..prints.sensors_prints import _SensorPrints -from ..sensors.sensors import ScalarSensor +from ..sensors.sensor import ScalarSensor class Barometer(ScalarSensor): @@ -12,8 +12,6 @@ class Barometer(ScalarSensor): Attributes ---------- - type : str - Type of the sensor, in this case "Barometer". prints : _SensorPrints Object that contains the print functions for the sensor. sampling_rate : float @@ -136,7 +134,6 @@ def __init__( temperature_scale_factor=temperature_scale_factor, name=name, ) - self.type = "Barometer" self.prints = _SensorPrints(self) def measure(self, time, **kwargs): diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index 09d35ccab..8655851e7 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -4,7 +4,7 @@ from ..mathutils.vector_matrix import Matrix, Vector from ..prints.sensors_prints import _GyroscopePrints -from ..sensors.sensors import InertialSensor +from ..sensors.sensor import InertialSensor class Gyroscope(InertialSensor): From df02bb43df855168f183b0acb8c64ecf89f8b962 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Mon, 3 Jun 2024 23:01:32 +0200 Subject: [PATCH 27/31] TST: format argument --- tests/unit/test_sensors.py | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensors.py index 8bb506d40..186466ccb 100644 --- a/tests/unit/test_sensors.py +++ b/tests/unit/test_sensors.py @@ -368,7 +368,7 @@ def test_noisy_barometer(noisy_barometer, example_plain_env): @pytest.mark.parametrize( - "sensor, format, expected_header, expected_keys", + "sensor, file_format, expected_header, expected_keys", [ ("ideal_accelerometer", "csv", "t,ax,ay,az\n", ("ax", "ay", "az")), ("ideal_gyroscope", "csv", "t,wx,wy,wz\n", ("wx", "wy", "wz")), @@ -379,10 +379,10 @@ def test_noisy_barometer(noisy_barometer, example_plain_env): ], ) def test_export_data( - sensor, format, expected_header, expected_keys, request, example_plain_env + sensor, file_format, expected_header, expected_keys, request, example_plain_env ): """Test the export_data method of the sensors. Checks if the data is - exported correctly in the specified format. + exported correctly in the specified file_format. """ sensor = request.getfixturevalue(sensor) @@ -403,11 +403,11 @@ def test_export_data( pressure=example_plain_env.pressure, ) - file_name = f"sensors.{format}" + file_name = f"sensors.{file_format}" - sensor.export_measured_data(file_name, format=format) + sensor.export_measured_data(file_name, file_format=file_format) - if format == "csv": + if file_format == "csv": with open(file_name, "r") as file: contents = file.read() @@ -417,7 +417,7 @@ def test_export_data( assert contents == expected_data - elif format == "json": + elif file_format == "json": with open(file_name, "r") as file: contents = json.load(file) @@ -437,9 +437,9 @@ def test_export_data( sensor.measured_data[:], sensor.measured_data[:], ] - sensor.export_measured_data(file_name, format=format) + sensor.export_measured_data(file_name, file_format=file_format) - if format == "csv": + if file_format == "csv": with open(f"{file_name}_1", "r") as file: contents = file.read() assert contents == expected_data @@ -448,7 +448,7 @@ def test_export_data( contents = file.read() assert contents == expected_data - elif format == "json": + elif file_format == "json": with open(f"{file_name}_1", "r") as file: contents = json.load(file) assert contents == expected_data From 332b47711c3314b8d69a6fc38ab6bf01c915ab20 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 6 Jun 2024 19:37:18 +0200 Subject: [PATCH 28/31] ENH: move generic_export_data back to Sensor class --- rocketpy/sensors/accelerometer.py | 5 +-- rocketpy/sensors/barometer.py | 5 +-- rocketpy/sensors/gyroscope.py | 5 +-- rocketpy/sensors/sensor.py | 63 ++++++++++++++++++++++++++++++ rocketpy/tools.py | 64 ------------------------------- 5 files changed, 66 insertions(+), 76 deletions(-) diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index 45f9edc13..ccb9073f4 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -1,7 +1,5 @@ import numpy as np -from rocketpy.tools import export_sensors_measured_data - from ..mathutils.vector_matrix import Matrix, Vector from ..prints.sensors_prints import _InertialSensorPrints from ..sensors.sensor import InertialSensor @@ -267,8 +265,7 @@ def export_measured_data(self, filename, file_format="csv"): ------- None """ - export_sensors_measured_data( - sensor=self, + self._generic_export_measured_data( filename=filename, file_format=file_format, data_labels=("t", "ax", "ay", "az"), diff --git a/rocketpy/sensors/barometer.py b/rocketpy/sensors/barometer.py index 695f32b1b..0439f3f70 100644 --- a/rocketpy/sensors/barometer.py +++ b/rocketpy/sensors/barometer.py @@ -1,7 +1,5 @@ import numpy as np -from rocketpy.tools import export_sensors_measured_data - from ..mathutils.vector_matrix import Matrix from ..prints.sensors_prints import _SensorPrints from ..sensors.sensor import ScalarSensor @@ -189,8 +187,7 @@ def export_measured_data(self, filename, file_format="csv"): ------- None """ - export_sensors_measured_data( - sensor=self, + self._generic_export_measured_data( filename=filename, file_format=file_format, data_labels=("t", "pressure"), diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index 8655851e7..6bf6945d4 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -1,7 +1,5 @@ import numpy as np -from rocketpy.tools import export_sensors_measured_data - from ..mathutils.vector_matrix import Matrix, Vector from ..prints.sensors_prints import _GyroscopePrints from ..sensors.sensor import InertialSensor @@ -299,8 +297,7 @@ def export_measured_data(self, filename, file_format="csv"): ------- None """ - export_sensors_measured_data( - sensor=self, + self._generic_export_measured_data( filename=filename, file_format=file_format, data_labels=("t", "wx", "wy", "wz"), diff --git a/rocketpy/sensors/sensor.py b/rocketpy/sensors/sensor.py index f49450d4d..b9277dfc4 100644 --- a/rocketpy/sensors/sensor.py +++ b/rocketpy/sensors/sensor.py @@ -1,3 +1,4 @@ +import json from abc import ABC, abstractmethod import numpy as np @@ -203,6 +204,68 @@ def export_measured_data(self, filename, file_format="csv"): """Export the measured values to a file""" pass + def _generic_export_measured_data(self, filename, file_format, data_labels): + """Export the measured values to a file given the data labels of each + sensor. + + Parameters + ---------- + sensor : Sensor + Sensor object to export the measured values from. + filename : str + Name of the file to export the values to + file_format : str + file_format of the file to export the values to. Options are "csv" + and "json". Default is "csv". + data_labels : tuple + Tuple of strings representing the labels for the data columns + + Returns + ------- + None + """ + if file_format.lower() not in ["json", "csv"]: + raise ValueError("Invalid file_format") + + if file_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=" ") + for i, data in enumerate(self.measured_data): + with open(filename + f"_{i+1}", "w") as f: + f.write(",".join(data_labels) + "\n") + for entry in data: + f.write(",".join(map(str, entry)) + "\n") + print(filename + f"_{i+1},", end=" ") + else: + with open(filename, "w") as f: + f.write(",".join(data_labels) + "\n") + for entry in self.measured_data: + f.write(",".join(map(str, entry)) + "\n") + print(f"Data saved to {filename}") + return + + if file_format.lower() == "json": + if isinstance(self.measured_data[0], list): + print("Data saved to", end=" ") + for i, data in enumerate(self.measured_data): + data_dict = {label: [] for label in data_labels} + for entry in data: + for label, value in zip(data_labels, entry): + data_dict[label].append(value) + with open(filename + f"_{i+1}", "w") as f: + json.dump(data_dict, f) + print(filename + f"_{i+1},", end=" ") + else: + data_dict = {label: [] for label in data_labels} + for entry in self.measured_data: + for label, value in zip(data_labels, entry): + data_dict[label].append(value) + with open(filename, "w") as f: + json.dump(data_dict, f) + print(f"Data saved to {filename}") + return + class InertialSensor(Sensor): """Model of an inertial sensor (accelerometer, gyroscope, magnetometer). diff --git a/rocketpy/tools.py b/rocketpy/tools.py index e540e3fd4..0cbd16628 100644 --- a/rocketpy/tools.py +++ b/rocketpy/tools.py @@ -1,7 +1,6 @@ import functools import importlib import importlib.metadata -import json import math import re import time @@ -523,69 +522,6 @@ def normalize_quaternions(quaternions): return q_w / q_norm, q_x / q_norm, q_y / q_norm, q_z / q_norm -def export_sensors_measured_data(sensor, filename, file_format, data_labels): - """ - Export the measured values to a file - - Parameters - ---------- - sensor : Sensor - Sensor object to export the measured values from. - filename : str - Name of the file to export the values to - file_format : str - file_format of the file to export the values to. Options are "csv" and - "json". Default is "csv". - data_labels : tuple - Tuple of strings representing the labels for the data columns - - Returns - ------- - None - """ - if file_format.lower() not in ["json", "csv"]: - raise ValueError("Invalid file_format") - - if file_format.lower() == "csv": - # if sensor has been added multiple times to the simulated rocket - if isinstance(sensor.measured_data[0], list): - print("Data saved to", end=" ") - for i, data in enumerate(sensor.measured_data): - with open(filename + f"_{i+1}", "w") as f: - f.write(",".join(data_labels) + "\n") - for entry in data: - f.write(",".join(map(str, entry)) + "\n") - print(filename + f"_{i+1},", end=" ") - else: - with open(filename, "w") as f: - f.write(",".join(data_labels) + "\n") - for entry in sensor.measured_data: - f.write(",".join(map(str, entry)) + "\n") - print(f"Data saved to {filename}") - return - - if file_format.lower() == "json": - if isinstance(sensor.measured_data[0], list): - print("Data saved to", end=" ") - for i, data in enumerate(sensor.measured_data): - data_dict = {label: [] for label in data_labels} - for entry in data: - for label, value in zip(data_labels, entry): - data_dict[label].append(value) - with open(filename + f"_{i+1}", "w") as f: - json.dump(data_dict, f) - print(filename + f"_{i+1},", end=" ") - else: - data_dict = {label: [] for label in data_labels} - for entry in sensor.measured_data: - for label, value in zip(data_labels, entry): - data_dict[label].append(value) - with open(filename, "w") as f: - json.dump(data_dict, f) - print(f"Data saved to {filename}") - return - - if __name__ == "__main__": import doctest From 1d5e76952fa3386b99987d093708e4579affc2e9 Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 6 Jun 2024 19:38:34 +0200 Subject: [PATCH 29/31] ENH: rename test files --- tests/{test_sensors.py => test_sensor.py} | 0 tests/unit/{test_sensors.py => test_sensor.py} | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename tests/{test_sensors.py => test_sensor.py} (100%) rename tests/unit/{test_sensors.py => test_sensor.py} (100%) diff --git a/tests/test_sensors.py b/tests/test_sensor.py similarity index 100% rename from tests/test_sensors.py rename to tests/test_sensor.py diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensor.py similarity index 100% rename from tests/unit/test_sensors.py rename to tests/unit/test_sensor.py From 7f0fe70cea1e28c8f8d79f178d05f7b38451a71b Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 13 Jun 2024 15:26:57 +0200 Subject: [PATCH 30/31] ENH: change from celsius to kelvin --- rocketpy/prints/sensors_prints.py | 6 ++-- rocketpy/sensors/accelerometer.py | 15 +++++---- rocketpy/sensors/barometer.py | 15 +++++---- rocketpy/sensors/gyroscope.py | 15 +++++---- rocketpy/sensors/sensor.py | 53 +++++++++++++++++-------------- 5 files changed, 56 insertions(+), 48 deletions(-) diff --git a/rocketpy/prints/sensors_prints.py b/rocketpy/prints/sensors_prints.py index ad9c693e9..a454aa0fa 100644 --- a/rocketpy/prints/sensors_prints.py +++ b/rocketpy/prints/sensors_prints.py @@ -62,13 +62,13 @@ def _general_noise(self): "Constant Bias:", f"{self.sensor.constant_bias} {self.units}" ) self._print_aligned( - "Operating Temperature:", f"{self.sensor.operating_temperature} °C" + "Operating Temperature:", f"{self.sensor.operating_temperature} K" ) self._print_aligned( - "Temperature Bias:", f"{self.sensor.temperature_bias} {self.units}/°C" + "Temperature Bias:", f"{self.sensor.temperature_bias} {self.units}/K" ) self._print_aligned( - "Temperature Scale Factor:", f"{self.sensor.temperature_scale_factor} %/°C" + "Temperature Scale Factor:", f"{self.sensor.temperature_scale_factor} %/K" ) def all(self): diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py index ccb9073f4..bf67c88c1 100644 --- a/rocketpy/sensors/accelerometer.py +++ b/rocketpy/sensors/accelerometer.py @@ -33,11 +33,11 @@ class Accelerometer(InertialSensor): 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. + The operating temperature of the sensor in Kelvin. temperature_bias : float, list - The temperature bias of the sensor in m/s^2/°C. + The temperature bias of the sensor in m/s^2/K. temperature_scale_factor : float, list - The temperature scale factor of the sensor in %/°C. + The temperature scale factor of the sensor in %/K. cross_axis_sensitivity : float The cross axis sensitivity of the sensor in percentage. name : str @@ -143,15 +143,16 @@ def __init__( 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. + The operating temperature of the sensor in Kelvin. + At 298.15 K (25 °C), the sensor is assumed to operate ideally, no + temperature related noise is applied. Default is 298.15. temperature_bias : float, list, optional - The temperature bias of the sensor in m/s^2/°C. Default is 0, + The temperature bias of the sensor in m/s^2/K. Default is 0, 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, + The temperature scale factor of the sensor in %/K. Default is 0, 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 diff --git a/rocketpy/sensors/barometer.py b/rocketpy/sensors/barometer.py index 0439f3f70..fbed17f56 100644 --- a/rocketpy/sensors/barometer.py +++ b/rocketpy/sensors/barometer.py @@ -31,11 +31,11 @@ class Barometer(ScalarSensor): constant_bias : float The constant bias of the sensor in Pa. operating_temperature : float - The operating temperature of the sensor in degrees Celsius. + The operating temperature of the sensor in Kelvin. temperature_bias : float - The temperature bias of the sensor in Pa/°C. + The temperature bias of the sensor in Pa/K. temperature_scale_factor : float - The temperature scale factor of the sensor in %/°C. + The temperature scale factor of the sensor in %/K. name : str The name of the sensor. measurement : float @@ -99,13 +99,14 @@ def __init__( The constant bias of the sensor in Pa. 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. + The operating temperature of the sensor in Kelvin. + At 298.15 K (25 °C), the sensor is assumed to operate ideally, no + temperature related noise is applied. Default is 298.15. temperature_bias : float, optional - The temperature bias of the sensor in Pa/°C. Default is 0, meaning no + The temperature bias of the sensor in Pa/K. 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, + The temperature scale factor of the sensor in %/K. Default is 0, meaning no temperature scale factor is applied. name : str, optional The name of the sensor. Default is "Barometer". diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py index 6bf6945d4..049cde52d 100644 --- a/rocketpy/sensors/gyroscope.py +++ b/rocketpy/sensors/gyroscope.py @@ -33,11 +33,11 @@ class Gyroscope(InertialSensor): 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. + The operating temperature of the sensor in Kelvin. temperature_bias : float, list - The temperature bias of the sensor in rad/s/°C. + The temperature bias of the sensor in rad/s/K. temperature_scale_factor : float, list - The temperature scale factor of the sensor in %/°C. + The temperature scale factor of the sensor in %/K. cross_axis_sensitivity : float The cross axis sensitivity of the sensor in percentage. name : str @@ -141,15 +141,16 @@ def __init__( 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. + The operating temperature of the sensor in Kelvin. + At 298.15 K (25 °C), the sensor is assumed to operate ideally, no + temperature related noise is applied. Default is 298.15. temperature_sensitivity : float, list, optional - The temperature bias of the sensor in rad/s/°C. Default is 0, + The temperature bias of the sensor in rad/s/K. Default is 0, 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, + The temperature scale factor of the sensor in %/K. Default is 0, 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 diff --git a/rocketpy/sensors/sensor.py b/rocketpy/sensors/sensor.py index b9277dfc4..11147f7bc 100644 --- a/rocketpy/sensors/sensor.py +++ b/rocketpy/sensors/sensor.py @@ -28,11 +28,11 @@ class Sensor(ABC): 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. + The operating temperature of the sensor in Kelvin. temperature_bias : float, list - The temperature bias of the sensor in sensor units/°C. + The temperature bias of the sensor in sensor units/K. temperature_scale_factor : float, list - The temperature scale factor of the sensor in %/°C. + The temperature scale factor of the sensor in %/K. name : str The name of the sensor. measurement : float @@ -95,13 +95,14 @@ def __init__( 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. + The operating temperature of the sensor in Kelvin. + At 298.15 K (25 °C), the sensor is assumed to operate ideally, no + temperature related noise is applied. Default is 298.15. temperature_bias : float, list, optional - The temperature bias of the sensor in sensor units/°C. Default is 0, + The temperature bias of the sensor in sensor units/K. Default is 0, meaning no temperature bias is applied. temperature_scale_factor : float, list, optional - The temperature scale factor of the sensor in %/°C. Default is 0, + The temperature scale factor of the sensor in %/K. Default is 0, meaning no temperature scale factor is applied. name : str, optional The name of the sensor. Default is "Sensor". @@ -293,11 +294,11 @@ class InertialSensor(Sensor): 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. + The operating temperature of the sensor in Kelvin. temperature_bias : float, list - The temperature bias of the sensor in sensor units/°C. + The temperature bias of the sensor in sensor units/K. temperature_scale_factor : float, list - The temperature scale factor of the sensor in %/°C. + The temperature scale factor of the sensor in %/K. cross_axis_sensitivity : float The cross axis sensitivity of the sensor in percentage. name : str @@ -326,7 +327,7 @@ def __init__( random_walk_density=0, random_walk_variance=1, constant_bias=0, - operating_temperature=25, + operating_temperature=298.15, temperature_bias=0, temperature_scale_factor=0, cross_axis_sensitivity=0, @@ -400,15 +401,16 @@ def __init__( 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. + The operating temperature of the sensor in Kelvin. + At 298.15 K (25 °C), the sensor is assumed to operate ideally, no + temperature related noise is applied. Default is 298.15. temperature_bias : float, list, optional - The temperature bias of the sensor in sensor units/°C. Default is 0, + The temperature bias of the sensor in sensor units/K. Default is 0, 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, + The temperature scale factor of the sensor in %/K. Default is 0, 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 @@ -558,11 +560,13 @@ def apply_temperature_drift(self, value): The value with applied temperature drift """ # temperature drift - value += (self.operating_temperature - 25) * self.temperature_bias + value += (self.operating_temperature - 298.15) * self.temperature_bias # temperature scale factor scale_factor = ( Vector([1, 1, 1]) - + (self.operating_temperature - 25) / 100 * self.temperature_scale_factor + + (self.operating_temperature - 298.15) + / 100 + * self.temperature_scale_factor ) return value & scale_factor @@ -591,11 +595,11 @@ class ScalarSensor(Sensor): constant_bias : float The constant bias of the sensor in sensor units. operating_temperature : float - The operating temperature of the sensor in degrees Celsius. + The operating temperature of the sensor in Kelvin. temperature_bias : float - The temperature bias of the sensor in sensor units/°C. + The temperature bias of the sensor in sensor units/K. temperature_scale_factor : float - The temperature scale factor of the sensor in %/°C. + The temperature scale factor of the sensor in %/K. name : str The name of the sensor. measurement : float @@ -658,13 +662,14 @@ def __init__( 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. + The operating temperature of the sensor in Kelvin. + At 298.15 K (25 °C), the sensor is assumed to operate ideally, no + temperature related noise is applied. Default is 298.15. temperature_bias : float, list, optional - The temperature bias of the sensor in sensor units/°C. Default is 0, + The temperature bias of the sensor in sensor units/K. Default is 0, meaning no temperature bias is applied. temperature_scale_factor : float, list, optional - The temperature scale factor of the sensor in %/°C. Default is 0, + The temperature scale factor of the sensor in %/K. Default is 0, meaning no temperature scale factor is applied. name : str, optional The name of the sensor. Default is "Sensor". From 0b779f2e159ae5c245d61c25768c93f92c3a11ce Mon Sep 17 00:00:00 2001 From: MateusStano Date: Thu, 13 Jun 2024 16:50:21 +0200 Subject: [PATCH 31/31] TST: fix celsius to kelvin convertion --- rocketpy/sensors/sensor.py | 7 +++++-- tests/fixtures/sensors/sensors_fixtures.py | 6 +++--- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/rocketpy/sensors/sensor.py b/rocketpy/sensors/sensor.py index 11147f7bc..8b0de3b6e 100644 --- a/rocketpy/sensors/sensor.py +++ b/rocketpy/sensors/sensor.py @@ -765,10 +765,13 @@ def apply_temperature_drift(self, value): The value with applied temperature drift """ # temperature drift - value += (self.operating_temperature - 25) * self.temperature_bias + value += (self.operating_temperature - 298.15) * self.temperature_bias # temperature scale factor scale_factor = ( - 1 + (self.operating_temperature - 25) / 100 * self.temperature_scale_factor + 1 + + (self.operating_temperature - 298.15) + / 100 + * self.temperature_scale_factor ) value = value * scale_factor diff --git a/tests/fixtures/sensors/sensors_fixtures.py b/tests/fixtures/sensors/sensors_fixtures.py index 08982c9d4..5f148d00b 100644 --- a/tests/fixtures/sensors/sensors_fixtures.py +++ b/tests/fixtures/sensors/sensors_fixtures.py @@ -18,7 +18,7 @@ def noisy_rotated_accelerometer(): 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, + operating_temperature=25 + 273.15, temperature_bias=[0, 0.01, 0.02], temperature_scale_factor=[0, 0.01, 0.02], cross_axis_sensitivity=0.5, @@ -40,7 +40,7 @@ def noisy_rotated_gyroscope(): 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, + operating_temperature=25 + 273.15, temperature_bias=[0, 0.01, 0.02], temperature_scale_factor=[0, 0.01, 0.02], cross_axis_sensitivity=0.5, @@ -59,7 +59,7 @@ def noisy_barometer(): noise_variance=19, random_walk_density=0.01, constant_bias=1000, - operating_temperature=25, + operating_temperature=25 + 273.15, temperature_bias=0.02, temperature_scale_factor=0.02, )