From bb2f81fc200a314a4b5da288773488c853cb93f6 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 15:18:21 +0100 Subject: [PATCH 01/27] Add path generation functionality. --- src/pg_rad/__init__.py | 0 src/pg_rad/configs/logging.yml | 15 +++ src/pg_rad/dataloader.py | 26 +++++ src/pg_rad/exceptions.py | 8 ++ src/pg_rad/logger.py | 17 +++ src/pg_rad/path.py | 187 +++++++++++++++++++++++++++++++++ 6 files changed, 253 insertions(+) create mode 100644 src/pg_rad/__init__.py create mode 100644 src/pg_rad/configs/logging.yml create mode 100644 src/pg_rad/dataloader.py create mode 100644 src/pg_rad/exceptions.py create mode 100644 src/pg_rad/logger.py create mode 100644 src/pg_rad/path.py diff --git a/src/pg_rad/__init__.py b/src/pg_rad/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/pg_rad/configs/logging.yml b/src/pg_rad/configs/logging.yml new file mode 100644 index 0000000..5a8f1a5 --- /dev/null +++ b/src/pg_rad/configs/logging.yml @@ -0,0 +1,15 @@ +version: 1 +disable_existing_loggers: false +formatters: + simple: + format: '%(asctime)s - %(levelname)s: %(message)s' +handlers: + stdout: + class: logging.StreamHandler + formatter: simple + stream: ext://sys.stdout +loggers: + root: + level: INFO + handlers: + - stdout \ No newline at end of file diff --git a/src/pg_rad/dataloader.py b/src/pg_rad/dataloader.py new file mode 100644 index 0000000..029941f --- /dev/null +++ b/src/pg_rad/dataloader.py @@ -0,0 +1,26 @@ +import pandas as pd + +from pg_rad.logger import setup_logger +from pg_rad.exceptions import DataLoadError, InvalidCSVError + +logger = setup_logger(__name__) + +def load_data(filename: str) -> pd.DataFrame: + logger.debug(f"Attempting to load data from {filename}") + + try: + df = pd.read_csv(filename, delimiter=',') + + except FileNotFoundError as e: + logger.error(f"File not found: {filename}") + raise DataLoadError(f"File does not exist: {filename}") from e + + except pd.errors.ParserError as e: + logger.error(f"Invalid CSV format: {filename}") + raise InvalidCSVError(f"Invalid CSV file: {filename}") from e + + except Exception as e: + logger.exception(f"Unexpected error while loading {filename}") + raise DataLoadError("Unexpected error while loading data") from e + + return df \ No newline at end of file diff --git a/src/pg_rad/exceptions.py b/src/pg_rad/exceptions.py new file mode 100644 index 0000000..d67d3b2 --- /dev/null +++ b/src/pg_rad/exceptions.py @@ -0,0 +1,8 @@ +class ConvergenceError(Exception): + """Raised when an algorithm fails to converge.""" + +class DataLoadError(Exception): + """Base class for data loading errors.""" + +class InvalidCSVError(DataLoadError): + """Raised when a file is not a valid CSV.""" \ No newline at end of file diff --git a/src/pg_rad/logger.py b/src/pg_rad/logger.py new file mode 100644 index 0000000..d0ba6b4 --- /dev/null +++ b/src/pg_rad/logger.py @@ -0,0 +1,17 @@ +import logging +import logging.config +import pathlib + +import yaml + +def setup_logger(name): + logger = logging.getLogger(name) + + base_dir = pathlib.Path(__file__).resolve().parent + config_file = base_dir / "configs" / "logging.yml" + + with open(config_file) as f: + config = yaml.safe_load(f) + + logging.config.dictConfig(config) + return logger \ No newline at end of file diff --git a/src/pg_rad/path.py b/src/pg_rad/path.py new file mode 100644 index 0000000..2f4f873 --- /dev/null +++ b/src/pg_rad/path.py @@ -0,0 +1,187 @@ +from collections.abc import Sequence +import math + +from matplotlib import pyplot as plt +import numpy as np +import pandas as pd +import piecewise_regression + +from pg_rad.exceptions import ConvergenceError +from pg_rad.logger import setup_logger + +logger = setup_logger(__name__) + +class PathSegment: + def __init__(self, a: tuple[float, float], b: tuple[float, float]): + """_A straight Segment of a Path, from (x_a, y_a) to (x_b, y_b)._ + + Args: + a (tuple[float, float]): _The starting point (x_a, y_a)._ + b (tuple[float, float]): _The final point (x_b, y_b)._ + """ + self.a = a + self.b = b + + def get_length(self) -> float: + return math.dist(self.a, self.b) + + length = property(get_length) + + def __str__(self) -> str: + return str(f"({self.a}, {self.b})") + + def __getitem__(self, index) -> float: + if index == 0: + return self.a + elif index == 1: + return self.b + else: + raise IndexError + +class Path: + def __init__( + self, + coord_list: Sequence[tuple[float, float]], + z: float = 0, + simplify_path = False + ): + """Construct a path of sequences based on a list of coordinates. + + Args: + coord_list (Sequence[tuple[float, float]]): _description_ + z (float, optional): _description_. Defaults to 0. + + Raises: + ValueError: _description_ + """ + + if len(coord_list) < 2: + raise ValueError("Must provide at least two coordinates as a list of tuples, e.g. [(x1, y1), (x2, y2)]") + + x, y = tuple(zip(*coord_list)) + + if simplify_path: + try: + x, y = piecewise_regression_on_path(list(x), list(y)) + except ConvergenceError: + logger.warning("Continuing without simplifying path.") + + self.x_list = list(x) + self.y_list = list(y) + + coord_list = list(zip(x, y)) + + self.segments = [PathSegment(i, ip1) for i, ip1 in zip(coord_list, coord_list[1:])] + + self.z = z + + def get_length(self) -> float: + return sum([s.length for s in self.segments]) + + length = property(get_length) + + def __getitem__(self, index) -> PathSegment: + return self.segments[index] + + def __str__(self) -> str: + return str([str(s) for s in self.segments]) + + def plot(self, **kwargs): + """ + Plot the path using matplotlib. + """ + plt.plot(self.x_list, self.y_list, **kwargs) + +def piecewise_regression_on_path( + x: Sequence[float], + y: Sequence[float], + keep_endpoints_equal: bool = False, + n_breakpoints: int = 3 + ): + """_Take a Path object and return a piece-wise linear approximated Path._ + + This function uses the `piecewise_regression` package. From a full set of + coordinate pairs, the function fits linear sections, automatically finding + the number of breakpoints and their positions. + + On why the default value of n_breakpoints is 3, from the `piecewise_regression` + docs: + "If you do not have (or do not want to use) initial guesses for the number + of breakpoints, you can set it to n_breakpoints=3, and the algorithm will + randomly generate start_values. With a 50% chance, the bootstrap restarting + algorithm will either use the best currently converged breakpoints or + randomly generate new start_values, escaping the local optima in two ways in + order to find better global optima." + + Args: + x (Sequence[float]): _Full list of x coordinates._ + y (Sequence[float]): _Full list of y coordinates._ + keep_endpoints_equal (bool, optional): _Whether or not to force start + and end to be exactly equal to the original. This will worsen the linear + approximation at the beginning and end of path. Defaults to False._ + n_breakpoints (int, optional): _Number of breakpoints. Defaults to 3._ + + Returns: + x (Sequence[float]): _Reduced list of x coordinates._ + y (Sequence[float]): _Reduced list of y coordinates._ + + Reference: + Pilgrim, C., (2021). piecewise-regression (aka segmented regression) in Python. Journal of Open Source Software, 6(68), 3859, https://doi.org/10.21105/joss.03859. + """ + + logger.debug(f"Attempting piecewise regression on path.") + + pw_fit = piecewise_regression.Fit(x, y, n_breakpoints=n_breakpoints) + pw_res = pw_fit.get_results() + + if pw_res == None: + logger.error("Piecewise regression failed to converge.") + raise ConvergenceError("Piecewise regression failed to converge.") + + est = pw_res['estimates'] + + # extract and sort breakpoints + breakpoints_x = sorted( + v['estimate'] for k, v in est.items() if k.startswith('breakpoint') + ) + + x_points = [x[0]] + breakpoints_x + [x[-1]] + + y_points = pw_fit.predict(x_points) + + if keep_endpoints_equal: + logger.debug("Forcing endpoint equality.") + y_points[0] = y[0] + y_points[-1] = y[-1] + + logger.info( + f"Piecewise regression reduced path from {len(x)-1} to {len(x_points)-1} segments." + ) + + return x_points, y_points + +def path_from_RT90( + df: pd.DataFrame, + east_col: str = "East", + north_col: str = "North", + **kwargs + ) -> Path: + + """_Construct a path from East and North formatted coordinates (RT90) in a Pandas DataFrame._ + + Args: + df (pd.DataFrame): _DataFrame containing at least the two columns noted in the cols argument._ + east_col (str): _The column name for the East coordinates._ + north_col (str): _The column name for the North coordinates._ + + Returns: + Path: _A Path object built from the aquisition coordinates in the DataFrame._ + """ + + east_arr = np.array(df[east_col]) - min(df[east_col]) + north_arr = np.array(df[north_col]) - min(df[north_col]) + + coord_pairs = list(zip(east_arr, north_arr)) + + path = Path(coord_pairs, **kwargs) + return path \ No newline at end of file From b4ed2963d2230a0cb7d4426f01e507828ea4ba8d Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 15:20:05 +0100 Subject: [PATCH 02/27] Add pyproject.toml and requirements.txt --- pyproject.toml | 32 ++++++++++++++++++++++++++++++++ requirements.txt | 6 ++++++ 2 files changed, 38 insertions(+) create mode 100644 pyproject.toml create mode 100644 requirements.txt diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..00cb2eb --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,32 @@ +[build-system] +requires = ["setuptools>=64.0", "wheel"] +build-backend = "setuptools.build_meta" + +[tool.setuptools.packages.find] +where = ["src"] + +[project] +name = "pg-rad" +version = "0.1.0" +authors = [ + { name="Pim Nelissen", email="pi0274ne-s@student.lu.se" }, +] +description = "Primary Gamma RADiation Landscape" +readme = "README.md" +requires-python = ">=3.12.4" +dependencies = [ + "matplotlib>=3.9.2", + "numpy>=2", + "pandas>=2.3.1", + "piecewise_regression==1.5.0", + "pyyaml>=6.0.2" +] +license = "MIT" +license-files = ["LICEN[CS]E*"] + +[project.urls] +Homepage = "https://github.com/pim-n/pg-rad" +Issues = "https://github.com/pim-n/pg-rad/issues" + +[project.optional-dependencies] +dev = ["pytest", "notebook"] \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..274e5e8 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +matplotlib>=3.9.2 +notebook>=7.2.1 +numpy>=2 +pandas>=2.3.1 +piecewise_regression==1.5.0 +pyyaml>=6.0.2 \ No newline at end of file From 8ac244ec3bffcba990206e8267d22e2e8a8fa3ba Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 15:21:06 +0100 Subject: [PATCH 03/27] Add demo notebook --- demo/demo.ipynb | 112 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 112 insertions(+) create mode 100644 demo/demo.ipynb diff --git a/demo/demo.ipynb b/demo/demo.ipynb new file mode 100644 index 0000000..4ce90ba --- /dev/null +++ b/demo/demo.ipynb @@ -0,0 +1,112 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5e30f59a", + "metadata": {}, + "source": [ + "# Demo of PG-RAD\n", + "\n", + "This is a demo." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "415fdd25", + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import pyplot as plt\n", + "\n", + "from pg_rad.dataloader import load_data\n", + "from pg_rad.path import path_from_RT90" + ] + }, + { + "cell_type": "markdown", + "id": "8431d39b", + "metadata": {}, + "source": [ + "## Loading a file" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5a0e470a", + "metadata": {}, + "outputs": [], + "source": [ + "FILENAME = \"B10_NaIR_MGS_ROI_CPS_IPL.CSV\"\n", + "df = load_data(FILENAME)" + ] + }, + { + "cell_type": "markdown", + "id": "baa7aba8", + "metadata": {}, + "source": [ + "## Demo: Path regression" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2ec97553", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-01-27 14:50:24,540 - INFO: Piecewise regression reduced path from 105 to 4 segments.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p1 = path_from_RT90(df, east_col = \"East\", north_col = \"North\", simplify_path = False)\n", + "p2 = path_from_RT90(df, east_col = \"East\", north_col = \"North\", simplify_path = True)\n", + "\n", + "p1.plot(color='r', linestyle='-', linewidth = 10, label = \"Full path\")\n", + "p2.plot(color='b', linestyle='-', marker = 'o', label = \"Reduced path\")\n", + "\n", + "plt.xlabel(\"X [m]\")\n", + "plt.ylabel(\"Y [m]\")\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 0d3723879410d2d43a6c98cf8700b8352dc3e514 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 15:27:35 +0100 Subject: [PATCH 04/27] Add test for path simplification accuracy. --- tests/data/coordinates.csv | 107 +++++++++++++++++++++++++++++++ tests/test_path_functionality.py | 47 ++++++++++++++ 2 files changed, 154 insertions(+) create mode 100644 tests/data/coordinates.csv create mode 100644 tests/test_path_functionality.py diff --git a/tests/data/coordinates.csv b/tests/data/coordinates.csv new file mode 100644 index 0000000..46a113b --- /dev/null +++ b/tests/data/coordinates.csv @@ -0,0 +1,107 @@ +,East,North +0,1324671.2,6187244.9 +1,1324671.8,6187239.9 +2,1324672.7,6187235.0 +3,1324673.5,6187230.1 +4,1324675.1,6187225.4 +5,1324677.4,6187220.9 +6,1324679.2,6187216.3 +7,1324681.5,6187211.8 +8,1324683.9,6187207.4 +9,1324686.5,6187203.2 +10,1324689.0,6187198.9 +11,1324692.3,6187195.1 +12,1324695.6,6187191.5 +13,1324698.1,6187187.1 +14,1324701.9,6187184.1 +15,1324704.2,6187179.6 +16,1324707.7,6187176.0 +17,1324710.2,6187171.7 +18,1324712.8,6187167.4 +19,1324715.1,6187163.0 +20,1324718.3,6187159.2 +21,1324721.3,6187155.3 +22,1324725.0,6187151.9 +23,1324728.0,6187147.9 +24,1324732.0,6187145.0 +25,1324736.5,6187142.8 +26,1324741.0,6187140.7 +27,1324745.9,6187140.1 +28,1324750.6,6187138.6 +29,1324755.2,6187136.8 +30,1324760.1,6187136.4 +31,1324765.1,6187136.1 +32,1324770.1,6187135.9 +33,1324774.8,6187134.2 +34,1324779.8,6187133.7 +35,1324784.8,6187133.5 +36,1324789.8,6187133.3 +37,1324794.5,6187132.1 +38,1324799.3,6187131.1 +39,1324804.0,6187129.8 +40,1324808.0,6187126.7 +41,1324811.7,6187123.3 +42,1324815.2,6187119.8 +43,1324819.1,6187116.6 +44,1324822.3,6187112.9 +45,1324825.5,6187109.0 +46,1324828.6,6187105.1 +47,1324832.3,6187101.8 +48,1324836.6,6187099.3 +49,1324840.3,6187095.9 +50,1324843.9,6187092.4 +51,1324847.2,6187088.7 +52,1324851.6,6187086.5 +53,1324856.3,6187084.6 +54,1324860.1,6187081.4 +55,1324864.8,6187079.7 +56,1324868.9,6187076.9 +57,1324872.9,6187073.9 +58,1324876.6,6187070.4 +59,1324880.4,6187067.3 +60,1324884.3,6187064.1 +61,1324887.6,6187060.4 +62,1324891.1,6187056.8 +63,1324894.8,6187053.5 +64,1324898.1,6187049.8 +65,1324901.7,6187046.3 +66,1324905.5,6187043.1 +67,1324909.3,6187039.9 +68,1324913.0,6187036.4 +69,1324916.4,6187032.8 +70,1324919.6,6187029.0 +71,1324923.3,6187025.6 +72,1324926.3,6187021.6 +73,1324929.4,6187017.7 +74,1324933.0,6187014.2 +75,1324936.6,6187010.8 +76,1324939.8,6187007.0 +77,1324942.7,6187002.9 +78,1324945.9,6186999.1 +79,1324948.4,6186994.8 +80,1324951.9,6186991.2 +81,1324954.9,6186987.2 +82,1324957.4,6186982.8 +83,1324960.4,6186978.9 +84,1324962.7,6186974.4 +85,1324965.8,6186970.5 +86,1324968.2,6186966.1 +87,1324971.1,6186962.0 +88,1324973.7,6186957.8 +89,1324976.4,6186953.6 +90,1324978.8,6186949.2 +91,1324981.8,6186945.2 +92,1324984.3,6186940.9 +93,1324987.0,6186936.8 +94,1324989.3,6186932.3 +95,1324992.1,6186928.1 +96,1324994.2,6186923.6 +97,1324996.7,6186919.3 +98,1324998.5,6186914.8 +99,1325001.4,6186910.7 +100,1325003.7,6186906.2 +101,1325006.8,6186902.3 +102,1325009.9,6186898.4 +103,1325012.9,6186894.4 +104,1325015.3,6186890.0 +105,1325018.9,6186886.5 diff --git a/tests/test_path_functionality.py b/tests/test_path_functionality.py new file mode 100644 index 0000000..b9ac943 --- /dev/null +++ b/tests/test_path_functionality.py @@ -0,0 +1,47 @@ +import pathlib + +import numpy as np +import pytest + +from pg_rad.dataloader import load_data +from pg_rad.path import Path, path_from_RT90 + +@pytest.fixture +def test_df(): + csv_path = pathlib.Path(__file__).parent / "data/coordinates.csv" + return load_data(csv_path) + +def test_piecewise_regression(test_df): + """_Verify whether the intermediate points deviate less than 0.1 SD._""" + + p_full = path_from_RT90( + test_df, + east_col="East", + north_col="North", + simplify_path=False + ) + + p_simpl = path_from_RT90( + test_df, + east_col="East", + north_col="North", + simplify_path=True + ) + + x_f = np.array(p_full.x_list) + y_f = np.array(p_full.y_list) + + x_s = np.array(p_simpl.x_list) + y_s = np.array(p_simpl.y_list) + + sd = np.std(y_f) + + for xb, yb in zip(x_s[1:-1], y_s[1:-1]): + # find nearest original x index + idx = np.argmin(np.abs(x_f - xb)) + deviation = abs(yb - y_f[idx]) + + assert deviation < 0.1 * sd, ( + f"Breakpoint deviation too large: {deviation:.4f} " + f"(threshold {0.1 * sd:.4f}) at x={xb:.2f}" + ) \ No newline at end of file From 623f610c8f2c503389b0b79c9f375167856f2a28 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 15:37:07 +0100 Subject: [PATCH 05/27] update README --- README.md | 35 ++++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 1cb3cf5..60041f5 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,35 @@ # pg-rad -Primary Gamma RADiation landscape +Primary Gamma RADiation landscape - Development + +## Clone +``` +git clone https://github.com/pim-n/pg-rad +cd pg-rad +git checkout dev +``` + +or + +``` +git@github.com:pim-n/pg-rad.git +cd pg-rad +git checkout dev +``` + +## Dependencies / venv + +With Python verion `>=3.12.4`, create a virtual environment and install pg-rad. + +``` +python3 -m venv .venv +source .venv/bin/activate +(venv) pip install -e .[dev] +``` + +## Tests + +Tests can be run with `pytest` from the root directory of the repository. + +``` +(venv) pytest +``` \ No newline at end of file From 07c3fc18a9f45508dd6e960e98bd7c7964f31ab8 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 15:50:32 +0100 Subject: [PATCH 06/27] Restrict python version to exclude 3.13 --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 00cb2eb..7ca4f86 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -13,7 +13,7 @@ authors = [ ] description = "Primary Gamma RADiation Landscape" readme = "README.md" -requires-python = ">=3.12.4" +requires-python = ">=3.12.4,<3.13" dependencies = [ "matplotlib>=3.9.2", "numpy>=2", From 6187a38783db6b7bc3996d8b58dc02a0a56305c9 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 15:51:26 +0100 Subject: [PATCH 07/27] Update README --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 60041f5..ad53715 100644 --- a/README.md +++ b/README.md @@ -18,7 +18,7 @@ git checkout dev ## Dependencies / venv -With Python verion `>=3.12.4`, create a virtual environment and install pg-rad. +With Python verion `>=3.12.4` and `<3.13`, create a virtual environment and install pg-rad. ``` python3 -m venv .venv From 0c30678427e17a8972e8d28e6094e442930cf059 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 19:22:43 +0100 Subject: [PATCH 08/27] Add blank Landscape to which to add Sources and Path --- demo/demo.ipynb | 148 ++++++++++++++++++++++++++++++++++++++-- pyproject.toml | 2 +- src/pg_rad/landscape.py | 103 ++++++++++++++++++++++++++++ src/pg_rad/objects.py | 38 +++++++++++ 4 files changed, 285 insertions(+), 6 deletions(-) create mode 100644 src/pg_rad/landscape.py create mode 100644 src/pg_rad/objects.py diff --git a/demo/demo.ipynb b/demo/demo.ipynb index 4ce90ba..accea10 100644 --- a/demo/demo.ipynb +++ b/demo/demo.ipynb @@ -20,7 +20,9 @@ "from matplotlib import pyplot as plt\n", "\n", "from pg_rad.dataloader import load_data\n", - "from pg_rad.path import path_from_RT90" + "from pg_rad.path import path_from_RT90\n", + "from pg_rad.landscape import Landscape\n", + "from pg_rad.objects import Source" ] }, { @@ -33,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "5a0e470a", "metadata": {}, "outputs": [], @@ -52,7 +54,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "2ec97553", "metadata": {}, "outputs": [ @@ -60,12 +62,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-01-27 14:50:24,540 - INFO: Piecewise regression reduced path from 105 to 4 segments.\n" + "2026-01-27 19:21:09,113 - INFO: Piecewise regression reduced path from 105 to 4 segments.\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGwCAYAAABPSaTdAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAcMhJREFUeJzt3XdcVfUfx/HXZSoi4AYSV06cZWlUlqblzllp5sqsTC3NzGyoLTVbWpq2TBvqT00rd+YucZHknjkTpFRARFDg/P44efMKFwG53Au8n4/HeSDn+z3f8zmnm/fjOd9hMQzDQERERKSAcnN2ACIiIiKOpGRHRERECjQlOyIiIlKgKdkRERGRAk3JjoiIiBRoSnZERESkQFOyIyIiIgWah7MDcAVpaWmcOnWK4sWLY7FYnB2OiIiIZIFhGJw/f57g4GDc3Ow/v1GyA5w6dYqQkBBnhyEiIiI5cOLECcqXL2+3XMkOULx4ccC8WX5+fk6ORkRERLIiPj6ekJAQ6/e4PUp2wPrqys/PT8mOiIhIPnO9LijqoCwiIiIFmpIdERERKdCU7IiIiEiBpj47IiLiUKmpqVy+fNnZYUg+5Onpibu7+w23o2RHREQcwjAMoqOjiY2NdXYoko8FBAQQGBh4Q/PgKdlxhpQU8NCtF5GC7UqiU7ZsWXx8fDRpq2SLYRgkJiYSExMDQFBQUI7b0jeuI126BAcOwO7dsGeP+XP3bjh2DGJjwcvL2RGKiDhEamqqNdEpVaqUs8ORfKpo0aIAxMTEULZs2Ry/0lKykxvsJTUHD0JqasbHHDwItWvnbZwiInnkSh8dHx8fJ0ci+d2Vz9Dly5eV7DhNnz7w3Xfmq6ns2LNHyY6IFHh6dSU3Kjc+Q0p2blSxYtlPdMB88vPQQ7kfj4iIC/CuUoXq8fGZLs7odMWLw19/OTsKyQNKdm5UTp/O7N6du3GIiLiShATcL1xwdhQigCYVvHGhoTk7bs+e3I1DRERcQtOmTRkyZIj190qVKjFx4kSnxNKnTx86duzolHO7EiU7NyqnT3YOHDA7NouIiEvp06cPFosl3Xbo0CFnh2bX0aNHsVgsREZGOjsUl6Rk50aVKWNu2ZWSYo7IEhERl9OqVSuioqJstsqVKzs7LMkhJTu5Qa+yREQKFG9vbwIDA202d3f3DF8LDRkyhKZNm+b4XFfafP311ylTpgx+fn48/fTTXLrq6f/y5cu5++67CQgIoFSpUrRr147Dhw9by68kYrfccgsWiyVdPO+99x5BQUGUKlWKgQMHFrrlO5Ts5AZ1UhYRkRuwatUq9u7dy9q1a5k9ezYLFizg9ddft5ZfuHCB559/nm3btrFq1Src3Nzo1KkTaWlpAGzZsgWAX375haioKBYsWGA9ds2aNRw+fJg1a9Ywc+ZMZsyYwYwZM/L0+pxNo7Fyg5IdEZECZfHixfj6+lp/b926NfPmzXPY+by8vJg+fTo+Pj7Url2bN954g+HDh/Pmm2/i5uZGly5dbOpPnz6dMmXKsGfPHurUqUOZf7tTlCpVisDAQJu6JUqUYPLkybi7u1OzZk3atm3LqlWr6N+/v8Oux9Uo2ckNOX2NFRGRu3GIiEiuaNasGVOnTrX+XqxYMYeer379+jazTYeFhZGQkMCJEyeoWLEiBw8eZNSoUWzevJl//vnH+kTn+PHj1KlTJ9O2a9eubTPzcFBQEDt37nTMhbgop77Gmjp1KvXq1cPPzw8/Pz/CwsJYtmyZtbxp06bpesM//fTTNm0cP36ctm3b4uPjQ9myZRk+fDgpOZnk70bk9MnOkSPmOlkiIuJSihUrRtWqVa3blUUo3dzcMAzDpm5e9H9p3749Z8+e5fPPP2fz5s1s3rwZwKZfjz2enp42v1ssFmuyVFg49clO+fLlGT9+PNWqVcMwDGbOnEmHDh3Yvn07tf9NIPr3788bb7xhPebqzDc1NZW2bdsSGBjIxo0biYqKolevXnh6ejJ27Ni8u5ArI7L+/jv7x65ZYy45ISIiLq9MmTLs2rXLZl9kZGS6hCK7/vjjDy5evGhd+HLTpk34+voSEhLCmTNn2L9/P59//jlNmjQB4Ndff7U53uvfhaVT7a3HWMg59clO+/btadOmDdWqVaN69eq8/fbb+Pr6smnTJmsdHx8fm97wfn5+1rKff/6ZPXv28O2339KgQQNat27Nm2++yZQpU7KU7eaq22+3+TUVN9ZyL7PpxlruJdXerV6zJg+CExGR3HDfffexbds2vv76aw4ePMjo0aPTJT85cenSJfr168eePXtYunQpo0ePZtCgQbi5uVGiRAlKlSrFZ599xqFDh1i9ejXPP/+8zfFly5alaNGiLF++nNOnTxMXF3fDMRUkLjMaKzU1lTlz5nDhwgXCwsKs+7/77jtKly5NnTp1GDlyJImJiday8PBw6tatS7ly5az7WrZsSXx8PLsz6fybnJxMfHy8zXbDmjWz/nEBnajEUZqxlkeZTTPWUomjLKBT+uOU7IiI5BstW7bktdde48UXX+T222/n/Pnz9OrV64bbbd68OdWqVeOee+7hkUce4cEHH2TMmDGA+epszpw5REREUKdOHYYOHcq7775rc7yHhwcfffQRn376KcHBwXTo0OGGYypILMa1Lx/z2M6dOwkLCyMpKQlfX19mzZpFmzZtAPjss8+oWLEiwcHB7NixgxEjRtCoUSPrkLonn3ySY8eOsWLFCmt7iYmJFCtWjKVLl9K6desMzzlmzBibIX1XxMXF2Tw5ypbff4eGDVlAJ7oyH/Om/pdLWjDfj86nK51ZaHvs8eMQEpKz84qIuCAjOJi0fxcCddl1z11kIdA+ffoQGxvLDz/84OxQXFJSUhJHjhyhcuXKFClSxKYsPj4ef3//635/O300Vo0aNYiMjCQuLo758+fTu3dv1q1bR2hoKE8++aS1Xt26dQkKCqJ58+YcPnyYm2++OcfnHDlypM0jwPj4eEJuNNmoX59U/5I8FzcpXaIDYOCGhTSGMJEO/Ig7V3UOCw9XsiMiBUryn3/a/YISyWtOf43l5eVF1apVadiwIePGjaN+/fpMmjQpw7qNGzcGsK5PEhgYyOnTp23qXPn92nkGrubt7W0dAXZlu2Hu7myoM4CThGDvthq4cYIKbKCJbcHGjTd+fhEREcmQ05Oda6WlpZGcnJxh2ZUFzq4MAQwLC2Pnzp3ExMRY66xcuRI/Pz9Cczr3zQ2IqhR2/UpAFEG2O375BZz7NlFERJxkxowZeoXlYE59jTVy5Ehat25NhQoVOH/+PLNmzWLt2rWsWLGCw4cPW/vvlCpVih07djB06FDuuece6tWrB8ADDzxAaGgoPXv2ZMKECURHR/Pqq68ycOBAvL298/x6gsIqwXdZqEeU7Y7du2HlSnjgAYfEJSIiUpg59clOTEwMvXr1okaNGjRv3pytW7eyYsUK7r//fry8vPjll1944IEHqFmzJsOGDaNLly4sWrTIery7uzuLFy/G3d2dsLAwHnvsMXr16mUzL09eatK3KuU5ae2MnJ5BCMdpwob0RePGOTQ2ERGRwsqpT3a+/PJLu2UhISGsW7fuum1UrFiRpUuX5mZYOebu482kGp/Qdf9bWEjDSJdLWmjBL7adk69YuxY2bIAmTdKXiYiISI65XJ+d/K7zQ+7Mpys3YTuc0Z9zAMygT8bz7QA8/jgkJDg6RBERkUJFyU5u69aNzizkKJVYQ1Nm0Z01NOUfSvMMUzBwowffsYnG6Y89dAiGDMnzkEVERAoyJTu5rXZtaNECd9Joyjq6M4emrMODNCbxHO1YRBJFac8iDpHBXEFffgn/TpooIiIFx9q1a7FYLMTGxjo1jjFjxtCgQQOnnNtZ90DJjiOMHJnhbg9SmUM3GrKNfyhDG5byD6XSV+zfH64aTi8iUpilpprdGmfPNn86eq3LPn36YLFYsFgseHp6UrlyZV588UWSkpIce+ICpmnTpgxxkbcVSnYcoVkzaNQow6JiJLKYdlTkKAepTkd+IIlrhsmfPQuvvZYHgYqIuLYFC6BSJfOv1UcfNX9WquT4B+CtWrUiKiqKP//8kw8//JBPP/2U0aNHO/ak4jBKdhzBYrH7dAcgkNMspQ3+xPIbd9OLr0m7dvWYL7+EvXsdHKiIiOtasAC6doWTJ233//WXud+RCY+3tzeBgYGEhITQsWNHWrRowcqVK63laWlpjBs3jsqVK1O0aFHq16/P/PnzbdpYunQp1atXp2jRojRr1oyjR4/alGf0OmnixIlUqlTJZt/06dOpXbs23t7eBAUFMWjQIGtZbGwsTzzxBGXKlMHPz4/77ruPP/74w+b48ePHU65cOYoXL06/fv2u+4TqyqumJUuWUK9ePYoUKcIdd9xhs7r7mTNn6N69OzfddBM+Pj7UrVuX2bNnW8v79OnDunXrmDRpkvUp2dXXHxERwW233YaPjw933nkn+/fvzzSmG6Vkx1EefNDu0x2AUPbyAx3x5BLzeJiXGG9bITU104RJRCS/MQy4cCFrW3w8PPtsxpPLX9n33HNmvay0dyOT1O/atYuNGzfi5eVl3Tdu3Di+/vprpk2bxu7duxk6dCiPPfaYdcqUEydO0LlzZ9q3b09kZCRPPPEEL730UrbPPXXqVAYOHMiTTz7Jzp07+emnn6hataq1/KGHHiImJoZly5YRERHBrbfeSvPmzTl79iwAc+fOZcyYMYwdO5Zt27YRFBTEJ598kqVzDx8+nPfff5+tW7dSpkwZ2rdvz+XLlwFzcc6GDRuyZMkSdu3axZNPPknPnj3ZsmULAJMmTSIsLIz+/fsTFRVFVFSUzRqUr7zyCu+//z7btm3Dw8ODxx9/PNv3JlsMMeLi4gzAiIuLy92Gt283DE9PwzD/P8tw+5ZHrb9OYUD6Ohs25G5MIiJ54OLFi8aePXuMixcvWvclJGT616FDt4SErMfeu3dvw93d3ShWrJjh7e1tAIabm5sxf/58wzAMIykpyfDx8TE2btxoc1y/fv2M7t27G4ZhGCNHjjRCQ0NtykeMGGEAxrlz5wzDMIzRo0cb9evXt6nz4YcfGhUrVrT+HhwcbLzyyisZxrlhwwbDz8/PSEpKstl/8803G59++qlhGIYRFhZmPPPMMzbljRs3Tnfeq61Zs8YAjDlz5lj3nTlzxihatKjxv//9z+5xbdu2NYYNG2b9/d577zWee+65DNv+5ZdfrPuWLFliADaflatl9Fm6Iqvf33qy40gNGsDYsZlW6cEs3uIVAAbzMYtoZ1vhqafg4kUHBSgiIhlp1qwZkZGRbN68md69e9O3b1+6dOkCmItRJyYmcv/99+Pr62vdvv76aw4fPgzA3r17rYtXXxEWlrX1E6+IiYnh1KlTNG/ePMPyP/74g4SEBEqVKmUTx5EjR3IljqvrlSxZkho1arD33+4VqampvPnmm9StW5eSJUvi6+vLihUrOH78eJbavrLsE/y33mWMAwfmOHUG5ULh+edh2TJYvdpulZcZy1Eq8QX96cYc1nEvtxFhFu7ZAy++CB9/nEcBi4g4ho9P1udNXb8e2rS5fr2lS+Gee7J27uwoVqyY9XXR9OnTqV+/Pl9++SX9+vUj4d+LWLJkCTfddJPNcdlZl9HNzQ3jmvdrV14TARQtWjTT4xMSEggKCmLt2rXpygICArIcR068++67TJo0iYkTJ1K3bl2KFSvGkCFDuHTpUpaO9/T0tP7ZYjH7rKal2Vtq6cbpyY6jubnBzJlQooTdKhbgE56hJctJpBjtWMxRKv5XYfJk8/9oEZF8zGKBYsWytj3wAJQvbx5jr62QELNeVtqz105WuLm58fLLL/Pqq69y8eJFQkND8fb25vjx41StWtVmu9IvpVatWtb+K1ds2rTJ5vcyZcoQHR1tk/BERkZa/1y8eHEqVarEqlWrMozr1ltvJTo6Gg8Pj3RxlC5d2hrH5s2bM43DnqvrnTt3jgMHDlCrVi0AfvvtNzp06MBjjz1G/fr1qVKlCgcOHLA53svLi1RHzxOQRUp28kL58td9neVJCnN5mPpEcppA2rCUcwT8V6FvXzh92rFxioi4CHd3mDTJ/PO1icqV3ydONOvlhYceegh3d3emTJlC8eLFeeGFFxg6dCgzZ87k8OHD/P7773z88cfMnDkTgKeffpqDBw8yfPhw9u/fz6xZs5gxY4ZNm02bNuXvv/9mwoQJHD58mClTprBs2TKbOmPGjOH999/no48+4uDBg9bzALRo0YKwsDA6duzIzz//zNGjR9m4cSOvvPIK27ZtA+C5555j+vTpfPXVVxw4cIDRo0eze/fuLF3zG2+8wapVq9i1axd9+vShdOnSdOzYEYBq1aqxcuVKNm7cyN69e3nqqac4fc13VKVKldi8eTNHjx7ln3/+ceiTm+vKtEdPIeGwDspXu3TJMKpXv24vupMEG+U5boBh3MsaIwmv/8pbtDCMlBTHxSgikksy61SaHd9/bxjly9v+VRkSYu53lN69exsdOnRIt3/cuHFGmTJljISEBCMtLc2YOHGiUaNGDcPT09MoU6aM0bJlS2PdunXW+osWLTKqVq1qeHt7G02aNDGmT59u00HZMAxj6tSpRkhIiFGsWDGjV69exttvv23TQdkwDGPatGnW8wQFBRmDBw+2lsXHxxuDBw82goODDU9PTyMkJMTo0aOHcfz4cWudt99+2yhdurTh6+tr9O7d23jxxRez1EF50aJFRu3atQ0vLy+jUaNGxh9//GGtc+bMGaNDhw6Gr6+vUbZsWePVV181evXqZXPf9u/fb9xxxx1G0aJFDcA4cuSIte2r78H27dut5RnJjQ7KFsO4kQF5BUN8fDz+/v7ExcXh5+fnuBMtWAD/dnDLzA7qcje/ch4/evAt39Dzv1l4xowBTWwlIi4uKSmJI0eOULlyZYoUKXJDbaWmwoYNEBUFQUHQpEnePdEpjNauXUuzZs04d+6cw/v+ZEVmn6Wsfn/rNVZe6tQJstALvh47+Z4ueHCZ73iM13jzv8LXX4dffnFgkCIirsXdHZo2he7dzZ9KdCS7lOzkJYvFHFWVhf9T7+cXPuNJAN7mVb6gn1lgGOac6ddOKSoiIiIZUrKT1xo2hFGjslS1LzN4jTcAeJpprOABs+Dvv6FdOzh/3lFRiohIIdW0aVMMw3CJV1i5RcmOM7z8Mtx5Z5aqvs5oevI1qXjQlflEUt8s+OMP6NYNUlIcGKiIiEj+p2THGTw84NtvoXjx61a1AF/wBPexigSK05YlnKC8Wbh0qbk4jPqYi4iL0hgYuVG58RlSsuMslSubkwVmgReX+Z4u1GYXp7iJtiwhjn97nX/yiWZXFhGXc2WG3MTERCdHIvndlc/Q1bMuZ5eGnpOHQ8+vZRjQpw98/XWWqh+jAnewiWiCuJ+fWUJbPEkxOzyvWAF21k8REXGGqKgoYmNjKVu2LD4+PtZlAUSywjAMEhMTiYmJISAgwLqG1tWy+v2tZAcnJjsAFy5Ao0bmGlhZ8Du3cA/ruYAvfZnOl/Qz5+ApWRK2bTOfGImIuADDMIiOjiY2NtbZoUg+FhAQQGBgYIbJspKdbHBqsgOwdy/cdhtk8XHvUlrTnkWk4c7rjGLUlXl46tWD334DX18HBisikj2pqak2C1yKZJWnpyfumUzXomQnG5ye7IDZYblnzyxX/5QneZpPAZhJL3rxjVnQuDH88AMEBjogSBEREdehGZTzm8ceg0GDslz9KT5jBOMB6MeXrKaZWbB5M9x+O/z+uyOiFBERyXeU7LiSDz+ENm2yXH0sL9ON2aTgSWcWsJtQs+DkSbj7bpg/30GBioiI5B9KdlyJhwfMmQP162epuhsGX9GXu9lAHAG0Zhmn+Le3+sWL8NBD8Mor5ip6IiIihZSSHVdTvDgsXgzBwVmqXoRkfqQDNdjHCSrQjsUkUOy/CmPHmk+LzpxxUMAiIiKuTcmOKypfHhYtgqJFs1S9JOdYShvKEMN2buUR/kcKV/Ve//lnc00u9eMREZFCSMmOq7r1VvjyyyxXr8IRFtOOoiSylLYMYjI2w+yOHTPX41q4MNdDFRERcWVKdlxZ9+4wfHiWqzdiK7PpjoU0PuVpJvCibYXkZHj4YViyJJcDFRERcV1KdlzduHHQsmWWq3fgJyYyBICXeIc5PGJbISUFHn0UDh7MxSBFRERcl5IdV+fuDrNnQ4MGWT7kWT5mKB8A0JuZrKeJbYX4eOjQARIScjFQERER16RkJz8oUQJ++QXuuSfLh7zHC3Tmey7hTUd+YB81bCvs3QshIRqlJSIiBZ6SnfyiVClYuRKeeCJL1d0w+JbHuINwzlGSNizlNGVtK8XGQtmyMHEiXLqU6yGLiIi4AiU7+YmXF3z2GUyaBG7X/09XlCR+4kFu5hBHqMKD/EQi1wxnT0uDoUOhbl1YscJBgYuIiDiPU5OdqVOnUq9ePfz8/PDz8yMsLIxly5ZZy5OSkhg4cCClSpXC19eXLl26cPr0aZs2jh8/Ttu2bfHx8aFs2bIMHz6clJSUvL6UvGOxwLPPwtKl4O9/3epl+IeltKEkZ9hCYx5lFqkZ/Wc/cABatTJHf2ltWBERKUCcmuyUL1+e8ePHExERwbZt27jvvvvo0KEDu3fvBmDo0KEsWrSIefPmsW7dOk6dOkXnzp2tx6emptK2bVsuXbrExo0bmTlzJjNmzGDUqFHOuqS807IlbNsGdepct2p1DvITD+JNEj/SkaF8iN105r334PXXczVUERERpzJcTIkSJYwvvvjCiI2NNTw9PY158+ZZy/bu3WsARnh4uGEYhrF06VLDzc3NiI6OttaZOnWq4efnZyQnJ9s9R1JSkhEXF2fdTpw4YQBGXFyc4y7MURISDKN7d8Mwn8dkus2lq/XXDxhiv67FYhirVjn7ykRERDIVFxeXpe9vl+mzk5qaypw5c7hw4QJhYWFERERw+fJlWrRoYa1Ts2ZNKlSoQHh4OADh4eHUrVuXcuXKWeu0bNmS+Ph469OhjIwbNw5/f3/rFhIS4rgLc7RixeC778xOxtfxEPN5lxcAGMb7fE/njCsaBvTqBWfP5mKgIiIizuH0ZGfnzp34+vri7e3N008/zcKFCwkNDSU6OhovLy8CAgJs6pcrV47o6GgAoqOjbRKdK+VXyuwZOXIkcXFx1u3EiRO5e1F5zWKB556DLLy+G8b7PMMUDNx4jG8J546MK/71F3TqpP47IiKS7zk92alRowaRkZFs3ryZAQMG0Lt3b/bs2ePQc3p7e1s7RV/ZCoTRo80VzjNhASbxHO1YRBJFeZCfOMTNGVdevx7uv9+chFBERCSfcnqy4+XlRdWqVWnYsCHjxo2jfv36TJo0icDAQC5dukRsbKxN/dOnTxMYGAhAYGBgutFZV36/UqdQcXODb7+FKlUyreZBKnPoRkO28Q9laM0y/qFUxpVXrTIXJY2IcEDAIiIijuf0ZOdaaWlpJCcn07BhQzw9PVm1apW1bP/+/Rw/fpywsDAAwsLC2LlzJzExMdY6K1euxM/Pj9DQ0DyP3SWUKAGLFpmTEGaiGIksph0VOcohqtGBH7lIkYwrHz4MYWEwZYoDAhYREXEspyY7I0eOZP369Rw9epSdO3cycuRI1q5dS48ePfD396dfv348//zzrFmzhoiICPr27UtYWBh33GH2M3nggQcIDQ2lZ8+e/PHHH6xYsYJXX32VgQMH4u3t7cxLc67QUPMVVP36mVYL5DTLaE0A59jIXfRmJmlYMq58+TIMGmT2C1I/HhERyUecmuzExMTQq1cvatSoQfPmzdm6dSsrVqzg/vvvB+DDDz+kXbt2dOnShXvuuYfAwEAWLFhgPd7d3Z3Fixfj7u5OWFgYjz32GL169eKNN95w1iW5jtBQ2LoVPvrIfNpjRy328QMd8eQS83iYEbyTebtvvgnTpuVysCIiIo5jMQz9Mz0+Ph5/f3/i4uIKTmflq509CwMGwNy5dqt8x6M8xncATGYgA/nEfnseHmZfnmwsTCoiIpLbsvr97XJ9dsQBSpaE//0PXn7ZbpUezOItXgHgWT5iEe3st5eSAl27wvHjuR2piIhIrlOyU5i89RZ07Gi3+GXG8gSfk4Y73ZjDNhrab+vvv815eBITcz9OERGRXKRkpzCxWODzzyEoKONi4BOeoSXLSaQY7VjMUSrab+/33+Hxx9VhWUREXJqSncKmdGlzxXQ7nZY9SWEeD1GfSE4TSBuWco4A++39739aOFRERFyakp3CqEEDWLkSbropw+LiJLCEtpTnBHsJpRMLScbLfnuvvw5z5jgmVhERkRukZKewatgQIiOhbdsMi2/iFEtoS3HiWUdTHme6/Tl4APr2hS1bHBOriIjIDVCyU5iVLg0//QTvvWcOJ79GPXbyPV3w4DKz6MFrvGm/raQk6NwZzpxxYMAiIiLZp2SnsHNzg2HDYPVqyGDW6fv5hc/pD8BYXuFznrDf1l9/Qb9+6rAsIiIuRcmOmJo0gU8/zbCoDzMZhdkJeQBTWU5L++38+CNMneqICEVERHJEyY78p3dveO65DIvGMIZezCQVDx5iHpFksu7W889rlXQREXEZSnbE1nvvwX33pdttAT6nP/exigSK05YlnKB8xm0kJ0PTpuYQdxERESdTsiO2PDxg3jyoVi1dkReX+Z4u1GYXp7iJNiwlDjtrkSQkQPv2MGWKgwMWERHJnJIdSa9kSVi8GAIC0hUFEMdS2hDEKXZRl67M5zLpR3IBkJYGgwbBkCGQmurQkEVEROxRsiMZq14d5s8Hd/d0RRU4wRLaUowEfuF+nuQzMh1/NWkS9OwJly87LFwRERF7lOyIfc2bw0cfZVh0C5HM5WHcSWEGfXmT1zJva/Zsc+HQixcdEKiIiIh9SnYkcwMGQNeuGRa1YRlTGAjAaN5gJr0yb2vJEmjVCuLjcztKERERu5TsSOYsFvjsM6hQIcPip/iMEYwH4Am+YBXpR3LZWL8ewsJg69bcjlRERCRDSnbk+kqUgFmzzNmWMzCWl+nGbFLwpDML2EXtzNvbswfuuANeeslcZkJERMSBlOxI1tx1F7z9doZFbhjMoA9NWE88/rRhKacIyry9tDR45x245RYID3dAwCIiIiYlO5J1I0bA0KEZFnlziR/oSA32cYIKtGMxCRS7fpv79sHdd8MHH2hNLRERcQglO5J1Fgu8/745y7LFkq64JOdYShvKEMN2buVh5pJC+qHr6aSlmYuRjhyphEdERHKdkh3JHovFTEy+/x6KFk1XXIUjLKYdRUlkGW0YyJTM5+C52jvvmGtzpaXlasgiIlK4KdmRnOnUyRxZFRiYrqgRW5lNdyyk8RlP8Q4jst7uxx+bbavjsoiI5BIlO5Jzt90GmzZluI5WB35iEuYK6iMZz2y6Zb3dn34yh7rPnKllJkRE5IYp2ZEbU7EibNgA9eqlKxrMZIbyAQB9mMF6mmS93b//hj59oG5dc9mKlJRcClhERAobJTty48qVg7VrzckCr/EeL9CZ77mENx35gX3UyF7be/fCQw9B+fJmf57Nm9WJWUREskXJjuSOEiVg5Upo2dJmtxsG3/IYdxDOOUrSmmWcpmz22z992lyn6447oGpVeO012L07l4IXEZGCzGIY+mdyfHw8/v7+xMXF4efn5+xw8rfUVHjzTXMCwqtePf1NacII5zBVuZ0t/EJzfqchUQQRRBRN2IA7ORiFVbs2PPywudWsmYsXIiIiri6r399KdlCy4xDbt0PfvvDHH9ZdB6lKGOGcoTRFuEgS/w1dL88JJvEcnVmY83PWrQv33mu+Vitb9r+fgYEQEgIeHjdyRSIi4mKU7GSDkh0HuXQJxo83n/T8+5RnLC/xCmMB20kJLf8+1ZlP1xtLeOzx9jZHj911l7ndeSeULp375xERkTyjZCcblOw42LZt0Lo1qf+cpRJHOUl5rk12wEx4ynOSI1TO2Sut7KpRw0x6WrSA+++HMmUcf04REck1SnayQclOHti9m7VNXqPZuQXXrXorETRiC9U4aN2q8CdeXHZcfBaL+eSnVStza9RIr71ERFyckp1sULKTN2Z/GMWjz19nNXQ73EilIsdsEqArWyWO4kkuz8Pj5gZ+fuDvb7v5+ppbsWK2m4+P+aqsSBHz55U/Fy1qTpAYGJjhemIiIpJzWf3+1j9dJc8E3ZK1RGcE4/EgxSalSaA4R6jCEarwM7bD291JoTJHqMqhdIlQRY7hQQ5mYU5Lg9hYc8sNZcpAs2bQvLm5Vami5EdEJI/oyQ56spNXUlOhUiX46y8Dw8h6nx0DOE25DJ7pVOMQVUmkmN1zenKJyhzJ8IlQCCfypm9QRipUMJOfkBAoVQpKlvzvZ0CA+UTo2idF7llYQV5EpBDRa6xsULKTdxYsgK5dzT9f/cnL6WgsAzhFcIaJ0GFuthnefi0vkrmZw1TjYLqnQuU5iVvW12vPGx4eGb8q8/Y2X7lVqmQu21G/vrmpw7WIFHD5ItkZN24cCxYsYN++fRQtWpQ777yTd955hxo1/ltSoGnTpqxbt87muKeeeopp06ZZfz9+/DgDBgxgzZo1+Pr60rt3b8aNG4dHFjuYKtnJWwsWmCs/nDz5376Qon8z8eJTuTrsPA0Lf3GT3UToEt52jy3CRWsidO0WzKkMxpK5oKAgM+mpW9cceVa9uvmzTBm9QhORAiFfJDutWrWiW7du3H777aSkpPDyyy+za9cu9uzZQ7Fi5quJpk2bUr16dd544w3rcT4+PtaLSk1NpUGDBgQGBvLuu+8SFRVFr1696N+/P2PHjs1SHEp28l5qqrl+aFSU+Z3cpAm4R2yBCRPMVc8vO3DkFZCKGycIyTAR+pMqpOBp91gfLtg8Cbr6z4FEu34i5O9vJj41a8Itt0DDhubP4sWdHZmISLbki2TnWn///Tdly5Zl3bp13HPPPYCZ7DRo0ICJEydmeMyyZcto164dp06doly5cgBMmzaNESNG8Pfff+Pl5ZXumOTkZJKTk62/x8fHExISomTHVZw5A99/D7NmwTVP9fJCCu4co6K1T9DVidARKpOaSb9+X85n2FG6Ggcpw9+umwhZLGYC1LChOQS/UyfztZiIiAvLl8nOoUOHqFatGjt37qROnTqAmezs3r0bwzAIDAykffv2vPbaa/j4+AAwatQofvrpJyIjI63tHDlyhCpVqvD7779zyy23pDvPmDFjeP3119PtV7Ljgk6cgDlzzMTnqv/GznIZD45SKcMnQseoSBr2OxH7EZfuqCuJUSnOuF4i1LQpjB5t/hQRcUH5LtlJS0vjwQcfJDY2ll9//dW6/7PPPqNixYoEBwezY8cORowYQaNGjViwwJyc7sknn+TYsWOsWLHCekxiYiLFihVj6dKltG7dOt259GQnnzpwAObNg7lzYccOZ0eTTjJeHKFyhonQCUIwcLN7bADnMnwaVI2DlCA27y4iIw8+aL5evKovnYiIK8h3yc6AAQNYtmwZv/76K+XLl7dbb/Xq1TRv3pxDhw5x88035yjZuZb67ORD+/aZic/335uJj2t8jO1Kwps/qZJhOnOSkEyPLcU/GSZBVTmEP/G5El8qbmygif1V6D084OmnzSc9WlNMRFxEvppUcNCgQSxevJj169dnmugANG7cGMCa7AQGBrJlyxabOqdPnwYgMDDQMQGL89WsCa+9Zm7nz5tPfWJizO306f9+7t1rvv5KzcHEgrmoCMmEspdQ9qYrS6Qoh7k5w0QoimDOUJozlGYTYemOLUOM3SdCvlzIUmwL6MRzTLJJutKtQp+SApMnw9dfw1tvwcCB5izTIiL5gFOTHcMwGDx4MAsXLmTt2rVUrlz5usdc6ZsTFGTOxhsWFsbbb79NTEwMZcuWBWDlypX4+fkRGhrqsNjFhRQvbnastSchAbZsgd9+M7eNG80EyUX4cJG67KIuu9KVJVDM2kn62s7Spwnkb8ryN2XZyF3pjg0kyu4TIR8uAmai05X56WYU+oub6Mr89PMexcfDs8+arxKnT4dq1XLzVoiIOIRTX2M988wzzJo1ix9//NFmbh1/f3+KFi3K4cOHmTVrFm3atKFUqVLs2LGDoUOHUr58eevcO1eGngcHBzNhwgSio6Pp2bMnTzzxhIaeS8YuX4bNm2H5cnOLiHB2RDkST/F0CdCV7R8yn1AwmL+oykEiuI0LFCNHq9AXKQJvv21OmqTZnUXECfJFnx2LnYnNvvrqK/r06cOJEyd47LHH2LVrFxcuXCAkJIROnTrx6quv2lzUsWPHGDBgAGvXrqVYsWL07t2b8ePHa1JByZqYGPj5Z1i7FnbvNl9/xcWZm5Nff+VULP52Xm5V4xwls9XWGprSlEymAAgLg6++UgdmEclz+SLZcRVKdiRDhgGJif8lPufPw4UL6beEBEhKguRk25+xseZrs7//dvaV2DhLCQ5Sja/pxScMvG79WXSnO3Myr+TjA5MmQb9+mp1ZRPJMvuqgLOKSLBYoVszcgoNz1oZhwK5dsGoVrF5tPj1ycn+hkpyjMVu4SNEsJTveJF2/0cRE6N/ffC342WfmgqYiIi5CT3bQkx3JQykp8OefcPQonD1rzhZ99c+zZ83E4dqnRFf/TE6GS5duOJRU3KjEUf7iJjtzABmABX/O8Q4v0Z/Ps7Y4avny8O23cO+9NxyjiEhm9BorG5TsSL6TlmYmPMnJZqK0cyf88Ye5RUaaCVUWXBmNBdgkPBbSMIDKHOUIVQBozCam8TQN+CNrMfbrB2PHwr+jJEVEcpuSnWxQsiMFTny8OfHigQPmtn//f39OTLSpmtE8OyEcZyJDeJCf+IRneJW3OI8fbqTyHJN4ndEUJ+H6cfj7w5tvwoAB5sSEIiK5SMlONijZkUIjLQ2OHTOH21/ZVq687gzKpwhiKB8yl0cAuImT/046uCBra3rVrQtTppjL24uI5BIlO9mgZEcKNcOAb74x58w5cCDTqit4gGf4hD+5GYA2LGEyg6jM0eufx2KBESPMGZg1L4+I5IKsfn9rvneRws5igV69zFFjH30EpUrZrdqSn9lFHV7jDTy5xFLaEsoexjKSS3hmfh7DgPHjoVMnp49IE5HCRcmOiJg8PWHwYDh0CJ56ym61oiTxBqPZSV3uYxVJFOUVxtKASNaShRFYixbBnXeaI9JERPKAkh0RsRUQANOmwS+/QKVKdqvV4AC/0IJv6UFZTrOXUJqxlt7MIOY6y1Wwaxfcfjv8+muuhi4ikhElOyKSsebNzSHtA+1PPGgBejCLfdTkaaZiIY2v6U1N9vEZ/UnLrPvyP/+Y55hzndmZRURukJIdEbHP1xcmTzZngL7pJrvVShDLVJ4hnDAasJ1zlOQpPuNufuUP6tlv/9Il6N4dJkww+/SIiDiAkh0Rub777jMnLOzYMdNqjdnCVm7nQ4bgy3nCuZOGRDCM90igmP0DR4yAQYPy7cKrIuLalOyISNaUKgULFsDUqVCkiN1qHqQyhEnsoyZdmUcqHnzAMGqxl4V0tL/gxCefQOfO6SY9FBG5UUp2RCTrLBZ4+mlzMsJGjTKtehOnmMfDLKU1lfmTk4TQmYW0ZxFHqJTxQT/9BC1amGuEiYjkEiU7IpJ9oaEQHg5ffAGlS2datTXL2UUdXuEtPLnEEtpRm92MZ0TGc/OEh8Pdd8OJEw4KXkQKGyU7IpIzbm7mYp8HDpjz87jZ/+vEh4u8xWv8QX2asoaL+DCS8dzCdtaTwRISe/eac/Hs2ePACxCRwkLJjojcmBIlzJmXt2+H2rUzrVqLfazmPr6mJ2WIYQ+1uZf19GU6f3PNE6KTJ81XZZMmqeOyiNwQJTsikjvq1YONG6Ft20yrWYCefMs+avIU0wCYQV9qso8v6Gc7N8+FCzBkCNx1lzkRoYhIDijZEZHc4+cHP/4IL7xw3aolOcc0BhDOHdQnkrOUoj9f0IQN7KSObeXNm+HWW2HYMDhyxEHBi0hBpWRHRHKXuzu8+y5Mnw4eHtetfgeb2cZtfMBQipHARu7iFrYznAm2c/NcvgwffAA33wzt28Py5ZCW5sALEZGCQsmOiDhG376wdCkUL37dqh6kMpSJ7KUWnfmeVDx4j+GEsocfedC2smHA4sXQujXUqGHO8Jyc7KCLEJGCQMmOiDjO/ffDhg0QHJyl6iGc5Hu6spi2VOIIJ6hAR37kQX7kGBXSH3DokDkSrE4dWL8+l4MXkYJCyY6IOFb9+rBpk5mQZFFblrKb2oxkLJ5cYhEPEsoeJjCcy2TwauzQIbj3XjPxSUjIxeBFpCBQsiMijhcSYj7hueeeLB/iw0XG8gqRNOAe1pFIMUYwgVvYzgbuzvigyZPNUWGrV+dS4CJSECjZEZG8ERAAK1ZAp07ZOiyUvaylKTPoTWn+Zjd1uIcNPM6X/EOp9AccOQLNm8PAgVpnS0QAJTsikpeKFIF58+DJJ7N1mAXozdfsoyb9+QyAr3icGuxnOn1t5+a54pNP4JZbYOvWXAhcRPIzJTsikrfc3WHaNHj99WwfWoqzfMZT/Mad1GUHZylFP6ZzL+vYRQazNx84YC478dZbkJKSC8GLSH6kZEdE8p7FAqNGmUPTy5fP9uF3Ek4EDXmPYRQjgV9pwi1sZwTjuYCPbeWUFHjtNbO/0J9/5tIFiEh+omRHRJyndWvYvRueeSbbh3qSwjA+YA+hdGQhKXgygRGEsoefaJ/+gPBwuO02WLkyFwIXkfxEyY6IOJefH0yZYo7WqlEj24dX4AQL6cxPtKciRzlORTrwEx1ZyHFCbCufOwetWsF775mTE4pIoaBkR0Rcw913Q2QkvPFGlmZdvlZ7FrOb2rzEODy4zI90pBZ7eZcXbOfmSUuD4cPhjjtg//7ci19EXJaSHRFxHUWKmP1rTpyASZOgevVsHV6MRMbxMpE0oAnrSaQYL/Iut/I7v3GnbeUtW6BmTWjaFL78EmJjc+0yRMS1WAxDz3Lj4+Px9/cnLi4OPz8/Z4cjIlekpcGqVeZrrkWLsrXwpwHMpDcv8B5nKA1AP77gHUZQirPpD/D2NvsQtW0LbdpkeYkLEXGerH5/K9lByY5IvrBnDzz+OGzenK3DzlCSEbzDlzwBQCn+4T1eoDczM5qd5z8NGvyX+DRubA6ZFxGXktXvb73GEpH8ITQUfvvN7FxcpEiWDyvFWb6gP79yF3XYyRlK05cZ3Ms6dhNq/8DISHj7bbjrLrj5Znj/fbh48cavQ0TynFOTnXHjxnH77bdTvHhxypYtS8eOHdl/TYfBpKQkBg4cSKlSpfD19aVLly6cPn3aps7x48dp27YtPj4+lC1bluHDh5OiCcRECh53dxg2DP74w0xCsuEuNvI7tzKB4fhwgQ3cQwMiGclYEima+cHHjsELL0Dt2rB48Q1cgIg4g1OTnXXr1jFw4EA2bdrEypUruXz5Mg888AAXLlyw1hk6dCiLFi1i3rx5rFu3jlOnTtG5c2dreWpqKm3btuXSpUts3LiRmTNnMmPGDEaNGuWMSxKRvFC9OqxbB+PGgadnlg/zJIXhvMceQunAD6TgyXhGEsoeFtP2+g0cOQLt20PHjuafRSR/MFxITEyMARjr1q0zDMMwYmNjDU9PT2PevHnWOnv37jUAIzw83DAMw1i6dKnh5uZmREdHW+tMnTrV8PPzM5KTk7N03ri4OAMw4uLicvFqRCRPREQYRq1ahmHOnJOt7UfaGxU4at3Vie+N45TPehvNmxvGxx8bxp49hpGW5uw7IVLoZPX726X67MTFxQFQsmRJACIiIrh8+TItWrSw1qlZsyYVKlQgPDwcgPDwcOrWrUu5cuWsdVq2bEl8fDy7d+/O8DzJycnEx8fbbCKST916K0REwODB2T70QRaxh1Be5B08uMxCOlOLvbzP87Zz89izapV53tBQc9mLnj3h++8hOTkHFyIijuIyyU5aWhpDhgzhrrvuok6dOgBER0fj5eVFQECATd1y5coRHR1trXN1onOl/EpZRsaNG4e/v791CwkJybCeiOQTRYvCRx/B3Lng43P9+lcpRiLv8BK/cyt38SsX8OUF3uc2thHOHVlv6NQp+PZb6NoVKleGiRMhMTF71yEiDuEyyc7AgQPZtWsXc+bMcfi5Ro4cSVxcnHU7ceKEw88pInngoYdg40aoVCnbh9ZlF+u5hy95nJKcYQf1uZNwnuRTzlIie41FRcHQoWbS8+67kJCQ7XhEJPe4RLIzaNAgFi9ezJo1ayh/1QrIgYGBXLp0idhrZjY9ffo0gYGB1jrXjs668vuVOtfy9vbGz8/PZhORAqJ+fdi2De67L9uHumHwOF+xnxo8zpcAfM6T1GA/X9OTbE9KFhMDL75oJl/jxsFVgy9EJO9kKdm5tn9LVrasMAyDQYMGsXDhQlavXk3lypVtyhs2bIinpyerVq2y7tu/fz/Hjx8nLCwMgLCwMHbu3ElMTIy1zsqVK/Hz8yM0NJM5NESk4CpVClasMJ+q5OAfM6U5w5c8wXqaUJtd/EMZevM1zVjDXmpmP54zZ+Dll6FqVfj0U7h8OfttiEiOZWkGZTc3NyyWTOcatW3UYuHAgQNUqVIl03rPPPMMs2bN4scff6TGVasd+/v7U7SoOe/FgAEDWLp0KTNmzMDPz4/B/3ZC3LhxI2AOPW/QoAHBwcFMmDCB6OhoevbsyRNPPMHYsWOzFK9mUBYpwP7+Gz75xOxPc+hQtg+/hCcfMpTXGc1FfPDkEi/wHq/yFj7kcJLB6tVh7Fjo3Bmy8XeriNjK1eUi3Nzc+P77762jpDJjGAZt2rRh165d10127CVQX331FX369AHMSQWHDRvG7NmzSU5OpmXLlnzyySc2r6iOHTvGgAEDWLt2LcWKFaN3796MHz8eD48sjKZAyY5IoWAY5uKf334Lc+bAP/9k6/CjVGQwH7OY9gBU4ghTGEgbluU8psaNzY7Md2SjI7SIWOVqslO5cmW2bdtGqVKlsnTyOnXqsGzZsnwzyknJjkghc/kyLF8OCxbA0qVm35osMIAf6cCzfMQJKgDQhflMZAjl+StnsVgs8Pzz8NZb2VoGQ0S0EGi2KNkRKcTS0uD332HJEjPx2brVfAqUiQSK8Tqj+ZChpOKBL+d5g1EM5mM8SM1ZHLVqwddfw2235ex4kUJIC4GKiGSFm5uZYIweba6ofuCAudJ5Jny5wLu8yO/cShgbSaA4z/Mht7GNTTTOWRx795qvs8aMUQdmkVyWoyc7W7duZc2aNcTExJCWlmZT9sEHH+RacHlFT3ZExIZhwA8/wHPPwXXm4UrDwnQe50UmcI6SWEjjST5jHCMpQWzOzl+7Nnz8MTRrlrPjRQoJh73GGjt2LK+++io1atSgXLlyNp2MLRYLq1evznnUTqJkR0QydOECjB8PU6bAuXOZVv2b0rzIBGbQF4AyxPABz9OD78jxeKuHHoL33oMKFXLagkiB5rBkp1y5crzzzjvW0VIFgZIdEclUYqLZmfnnn831sE6dslt1HfcwgKnsxZznqxmr+YRnqMn+nJ27aFF46SUYPtz8s4hYOazPjpubG3fdddcNBScikq/4+MBjj5kdiE+ehH37zKc9nTqBp6dN1XtZTyQNGMdLFCWRNdxHPXbwKm9ykRyMtrp40exPFBoKP/543c7TIpJetpOdoUOHMmXKFEfEIiLi+iwWqFEDnnnGfNpz6JD5Zy8vaxUvLvMS77Cb2rRhCZfx4m1epQ67WE7LnJ336FHo2BFat4b9OXxKJFJIZfs1VlpaGm3btuXAgQOEhobiec2/ahYsWJCrAeYFvcYSkRv2118wYQJ89hkkJVl3G8BCOvEckziJOfdYV+YxkSHchP3XYZny9DQXGn3tNfD1zYXgRfInh73GevbZZ1mzZg3Vq1enVKlS+Pv722wiIoXSTTfBpEnmk57+/c0h7YAF6MxC9hDK87yPOynM5yFqso9JPEsK7tk/1+XLZmLVoAFERubmVYgUSNl+slO8eHHmzJlD27ZtHRVTntOTHRHJdXv3mot//vCDze4/qMfTTGMT5mLGDdjOpzxFI7bm7DxFi8JXX8Ejj9xgwCL5j8Oe7JQsWZKbb775hoITESnwatWChQvht9/g1lutu+uzg9+4i095khKcJZJbuINNPMMUYsnB0/GLF6FbN3PEVmoOZ28WKeCyneyMGTOG0aNHk5iY6Ih4REQKljvvhE2b4PXX4d/Fid0weJLP2UdNejETAzem8gw12M93PEqOxlu98w60b3/d+YBECqNsv8a65ZZbOHz4MIZhUKlSpXQdlH///fdcDTAv6DWWiOSJ33+HXr1g926b3WtoyjN8wj5qAXAfq/iEZ6jBgeyfo2JFc1V3raQuhUBWv789sttwx44dbyQuEZHC69ZbISICRo2C99+3vnZqxlr+oD7v8QJv8hqraU49djCCdxjJOIqSdJ2Gr3LsGDRpAm+/DS+8YO0oLVKYadVz9GRHRJxg50549llYu9Zm959UZhCTWYa5GOnNHGIKA2nJz9k/R6tWMHMmlC2bCwGLuB6tei4i4srq1oXVq2HuXAgJse6uwhGW0Jb5dCGYvzhMVVqxgkeYwymCsneO5cvNRUVnzdLMy1KoZSnZKVmyJP/880+WG61QoQLHjh3LcVAiIoWCxWIu9rl3L7z6Knh7m7uBLixgHzUZwoe4kcpcHqEm+/iIwaRm59+p//wDPXpAu3Zw/LhjrkPExWXpNZabmxszZ87M8qSB3bt3Z+fOnVSpUuWGA8wLeo0lIi7hzz/NmZF/+slm93Ya8DTT2EJjAG4lgmk8ze1sy177xYrBuHEwcKD68kiBkKurnrvl4H+KQ4cOKdkREcmJ5cvhuefgwH+jsVJx43P6M5JxxFICC2k8wye8xasEEJe99h94AGbPhpIlczlwkbyVq3120tLSsr3ll0RHRMTltGpldmB+6y3rExh30niaT9lHTR7jGwzcmMIgarKP2XTL3tw8P/8Mt99unkOkENBzTBERV+TlBa+8AitWQIkS1t3liOEberGK+6jOfk4TyKPM5gF+5iBVs97+n39CWBh8/70DghdxLUp2RERcWYsWsG0b1Kljs/s+1rCDerzJq3iTxC/cTx12MYbRJOGdtbYvXICuXc2kKiXFAcGLuAYlOyIirq5KFQgPNxOTq3hziVd5m93UpiXLuYQ3rzOGuuxkJS2y3v7YsXDXXXDwYC4HLuIaspzsnDp1ypFxiIhIZnx9zTl5Jk82X3Fd5Wb+ZBmtmctDBHGKQ1TjAVbSnVlEEZi19rdsgQYN4LPPNCePFDhZTnZq167NrFmzHBmLiIhkxmIxh41v2gTVqtkWAQ8xn33U5Dkm4kYqc+hOTfYxmYFZm5snMRGeego6dIC//nLMNYg4QZaTnbfffpunnnqKhx56iLNnzzoyJhERycwtt5hrbPXoka7Ij/NMZChbuZ3b2UI8/gxmMo3ZTAS3Zq39RYugZk344AO4fDmXgxfJe1lOdp555hl27NjBmTNnCA0NZdGiRY6MS0REMlO8OHzzDXz9tc1orStuZTvhhDGFZ/AnlghuoxFbGMxHxJGF+cQSEmDYMHPx0g0bHHABInknRwuBTp48maFDh1KrVi08PGwXTv/9999zLbi8okkFRSRfO33anITwf//LsDiacgzjfWZhPgkKJIqJDOFh5mLJ6jl69YJ339WiouJScnUG5asdO3aMvn37smvXLp566ql0yc7o0aNzFrETKdkRkQLhp5/gmWfs9rdZxX0MYCoHqQ7A/fzMJzxDVQ5nrf2AAHj7bbNfj7t7LgUtknMOSXY+//xzhg0bRosWLfj0008pU6ZMrgTrbEp2RKTAiI83k5E5czIsTsKbCbzIWF4mmSJ4k8TLjGUE7+DNpaydo2FDmDrVnIVZxIlydbkIgFatWjFixAgmT57MggULCkyiIyJSoPj5waxZ8M475uitaxQhmVG8yS7qcD8/k0wRRvMGddnJLzTP2jkiIqBxYxgwwEyuRFxclpOd1NRUduzYQa9evRwZj4iI3CiLBV58EZYuNV89ZaAqh1lBS+bwCIFEcZDq3M8v9OBboil3/XMYBkybBvXqwZo1uRu/SC7LcrKzcuVKypcv78hYREQkN7VqZU4WeM1SE1dYgEeYyz5qMpiPcCOVWfSgJvv4hAFZm5vn2DG47z6zg3RiYu7GL5JLtFyEiEhBVq0abN0KQ4bYreJPPB/xHJtpTEO2EUcAA/mEMML5nVuydp6PPjLn/9m0KXfiFslFSnZERAq6IkXgww9h5UoIDrZb7TYi2ExjJjMQP+LYSiNuZyvPMZF4il//PAcOmGtsjR8PaWm5eAEiN0bJjohIYdGiBezcCQ8/bLeKO2kM5BP2UZNuzCYNdz7iOWqyj7k8xHWH76alwciR5pITmm1fXIRTk53169fTvn17goODsVgs/PDDDzblffr0wWKx2GytWrWyqXP27Fl69OiBn58fAQEB9OvXj4SEhDy8ChGRfKRkSXNY+pw5EBRkt1oQ0czmUX7mfqpykCiCeYS5tGYZh6ly/fMsXmzOvrx1ay4GL5IzTk12Lly4QP369ZkyZYrdOq1atSIqKsq6zZ4926a8R48e7N69m5UrV7J48WLWr1/Pk08+6ejQRUTyL4sFHnkE9u2DoUMznSDwfn5hJ3UZzRi8SGYFrajDLt7iFZLxsnscYHZevvtuc9SWiBPlaLkIR7BYLCxcuJCOHTta9/Xp04fY2Nh0T3yu2Lt3L6GhoWzdupXbbrsNgOXLl9OmTRtOnjxJcCbvpq+mSQVFpFDbscOcefm33zKtdoBqDGQKv3A/ADXYxyc8w31kYej5s8+aC4tq5mXJRbk+qaCzrF27lrJly1KjRg0GDBjAmTNnrGXh4eEEBARYEx2AFi1a4ObmxubNm+22mZycTHx8vM0mIlJo1asH69fDV19BJhPGVucgP/MAs+lGOaLZT02as5qefM1prrNm1kcfQceO5gKjInnMpZOdVq1a8fXXX7Nq1Sreeecd1q1bR+vWrUlNTQUgOjqastcsSufh4UHJkiWJjo622+64cePw9/e3biEhIQ69DhERl+fmBn36wP795szIGcy+DObcPN34H/uoyUAmYyGNb+lJTfYxjadIy2xp0cWLoUkTOHnSIZcgYo9LJzvdunXjwQcfpG7dunTs2JHFixezdetW1q5de0Ptjhw5kri4OOt24sSJ3AlYRCS/K1ECPvkENm+Gq56aXyuAOCYzmM005lYiiKUEA5hGGOFsp4H99iMjzfl45s41Z2EWyQMunexcq0qVKpQuXZpDhw4BEBgYSExMjE2dlJQUzp49S2BgoN12vL298fPzs9lEROQqt99uThA4caI5T4+9amxjC434iMEUJ54tNOY2tjGUDziPb8YH/fOP2UG6a1c4fdox8YtcJV8lOydPnuTMmTME/TtcMiwsjNjYWCIiIqx1Vq9eTVpaGo0bN3ZWmCIiBYO7u7kMRGSkufCnvWqkMZjJ7KMmjzCHNNyZyFBqsZf5dLE/N8+CBRAaai5cqqc84kBOTXYSEhKIjIwkMjISgCNHjhAZGcnx48dJSEhg+PDhbNq0iaNHj7Jq1So6dOhA1apVadmyJQC1atWiVatW9O/fny1btvDbb78xaNAgunXrluWRWCIich01asCvv8LYseDpabdaMFHMoTvLacnNHOIvyvMQ82nLEv6kcsYHnT0LPXrAE0/ApUsOugAp9AwnWrNmjQGk23r37m0kJiYaDzzwgFGmTBnD09PTqFixotG/f38jOjrapo0zZ84Y3bt3N3x9fQ0/Pz+jb9++xvnz57MVR1xcnAEYcXFxuXl5IiIFT2SkYVSvbhjmsxi7WyJFjNd43fAiyQDDKEKi8RYvG0l42T+ubVvDuHjR2Vco+UhWv79dZp4dZ9I8OyIi2RAfD/37m52Mr2M/1XmGT1hNcwBqspepDKAp6zI+oHlz+PFHKFYsNyOWAqrAzLMjIiIuxs/PXG7i448zfa0FUIMD/EILvuNRynKafdSiGWvpxUxiyGBOn1WroFUrM6ESySVKdkREJPssFhg0CDZsgExGv4I5N8+jzGYfNRnAJ1hI4xt6UZN9fEb/9HPz/PqruWjpP/84Ln4pVJTsiIhIzjVubM7JU7fudauWIJZPGMgm7uAWfuccJXmKz7iL3/iDeraVt24119U6dsxBgUthomRHRERuTIUK5tOYVq2yVL0RW9lCIybyHMWJZxNhNCSCYbxnOzfP/v1w552wc6eDApfCQsmOiIjcOD8/WLTIXFA0CzxI5Tk+Yi+1eIi5pOLBBwwjlD0soNN/c/OcOmUuMbEmC4uNitihZEdERHKHhwdMmQLffmsuO5EFN3GKuTzCUlpTmT85SQhdWEB7FnGESmaluDhzlNbIkZqLR3JEyY6IiOSuHj1g927o0CHLh7RmObupzau8iSeXWEI7arObcbzEJTzBMEgdP4G1tQcy+92TrF0L/64JLXJdmmcHzbMjIuIQhmEOUR80yJwpOYv2UYMBTGUtzQCoxR66M4vPeIqThFjrlS9vMGmShc6dcz1yySey+v2tZAclOyIiDhUVBS1bZqujsQF8Rw+e5wP+puxVe/8bpm4hDSwW5s9XwlNYaVJBERFxDUFBZgfjhg2zfIgFeIzv2EMtipHAtYkOgIEbGAZDnkggNaXQ/7tdMqFkR0REHK9UKXN25DvvzNZhu6jLBXy5NtG5wsCNE+d82XD3SPMJkkgGlOyIiEje8PeHFSvMkVVZFEVQ1uptPgYNGkB4eA6Dk4JMyY6IiOQdX19YsgQefjhL1YPI2tOaIKIgJgaaNcvSAqVSuCjZERGRvOXtDbNnm6O0rqMJGyjPCbMzcoYMyhFFEzaYvyYnwyOPwNix5mgwEZTsiIiIM7i5wUcfwdtvZ1rNnTQm8RxABgmP2Wn5Mp6cIti26JVX4PHHNQmhAEp2RETEWSwWePllmDkTihSxW60zC5lPV27iL5v9N/EX5TnOWUrTmmXE4m974IwZ0LmzEh5RsiMiIk7WqxdERJgdjO3ozEKOUok1NGUW3VlDU45Rkd+4myBOsZs6dGIhyXjZHnilf9Dly469BnFpSnZERMT5QkNh82Z46SXziU8G3EmjKevozhyasg530qjACZbShuLEs5Zm9GEGadcOU//xR+jeXQlPIaZkR0REXIOXF4wbB+vWQcWKWT6sAX/wPV3w4DJz6M5IxqWv9P338NhjkJKSiwFLfqFkR0REXEuTJrBjh9nBOIvu5xemY9afwAgmMzB9pblzoV07iI/PrUgln1CyIyIirsfPD778EhYtgsDALB3Sk295m5cBeJaPWEjH9JVWrIC77oJjx3IxWHF1SnZERMR1tWsHu3ZBt25Zqj6ScTzFNAzceJRZbCQsfaVdu6BxY9i6NZeDFVelZEdERFxbqVLmJISffQbu7plWtQCTGUQ7FpFEUdqziP1UT1/x9Gm4915zvS4p8JTsiIhI/tC/PyxbZr7iyoQHqcyhG7ezhbOUojXLOE3Z9BUvXoQHH4Q//nBQwOIqlOyIiEj+cf/9sHHjdUdrFSORxbSjCoc5QhXasoQEiqWvmJgIHTvCmTOOiVdcgpIdERHJX2rXhk2boGbNTKuV5W+W04rS/E0Et/EI/yOFDF6DHT1qTjyoYekFlpIdERHJfwIDYfVqqJ5Bf5yrVOMQi2lHURJZSlue4RMyXB509Wp46iktLVFAKdkREZH8KSjITFJuvjnTao3Zwhy64UYqn/Mkb/NKxhWnTzeHpR8+7IBgxZmU7IiISP51002wZg1UrpxptQdZxGQGAfAabzGD3hlX3LYNbr3VnIBQCgwlOyIikr+FhMCGDXDLLZlWG8A0Xvp3KYn+fM4KHsi4Ynw8PPIIDB6sfjwFhJIdERHJ/266Cdavh/btM632Nq/Qg29JwZOuzGc7DexXnjzZnMxQ/XjyPSU7IiJSMPj6wsKFMGSI3SpuGEznce5jFQkUpw1LOUYF+21+/z107gxJSbkfr+QZJTsiIlJwuLvDhx/C22/breLFZRbQmbrsIJogWrOMs5Sw3+aSJeYTowsXHBCw5AUlOyIiUvCMHAmPPmq32J94ltKG8pxgL6F05AeS8Lbf3i+/QOvWSnjyKSU7IiJS8Fgs8PnnmXZaLs9fLKM1/sSygXvoxdekYbHf5oYNZh+etDQHBCyOpGRHREQKJh8f+OEHKFPGbpU67GYhnfDkEvN4mBd4L/M2Fy+GN9/M3TjF4Zya7Kxfv5727dsTHByMxWLhhx9+sCk3DINRo0YRFBRE0aJFadGiBQcPHrSpc/bsWXr06IGfnx8BAQH069ePhISEPLwKERFxWRUqmBMPlitnt0oz1jKDPgB8yPN8yJDM2xwzxkx6JN9warJz4cIF6tevz5QpUzIsnzBhAh999BHTpk1j8+bNFCtWjJYtW5J0Va/4Hj16sHv3blauXMnixYtZv349Tz75ZF5dgoiIuLo6dcy1tBo1slvlUWbzDi8CMIz3mUfXzNt87DE4dCg3oxRHMlwEYCxcuND6e1pamhEYGGi8++671n2xsbGGt7e3MXv2bMMwDGPPnj0GYGzdutVaZ9myZYbFYjH++usvu+dKSkoy4uLirNuJEycMwIiLi8v9CxMREdeQnGwYL7xgGJDhlgbGQD42wDC8uWis5267dQ0wjEqVDOPQIWdfVaEWFxeXpe9vl+2zc+TIEaKjo2nRooV1n7+/P40bNyY8PByA8PBwAgICuO2226x1WrRogZubG5s3b7bb9rhx4/D397duISEhjrsQERFxDV5e8O675lDyUqXSFVuASTxHRxaSTBE68CN7yWRl9aNH4e67Ydcuh4UsucNlk53o6GgAyl3znrVcuXLWsujoaMqWLWtT7uHhQcmSJa11MjJy5Eji4uKs24kTJ3I5ehERcVlt2sDvv2e4Yro7acziUcLYyDlK0pplRBFov63oaLjnHtiyxYEBy41y2WTHkby9vfHz87PZRESkEKlQwVxeok6ddEVFSeInHqQaBzhGJdqyhPP42m/r3Dlo3lwJjwtz2WQnMNDMpE+fPm2z//Tp09aywMBAYmJibMpTUlI4e/astY6IiEiGypWDtWvNVc6vUZozLKcVZTnNdm7lIeZxGQ/7bSUkmLMsR0U5Ll7JMZdNdipXrkxgYCCrVq2y7ouPj2fz5s2EhYUBEBYWRmxsLBEREdY6q1evJi0tjcaNG+d5zCIiks+UKgWrVkGtWumKqnCExbTDhwusoBVP8hlGZm3FxEDfvpp00AU5NdlJSEggMjKSyMhIwOyUHBkZyfHjx7FYLAwZMoS33nqLn376iZ07d9KrVy+Cg4Pp2LEjALVq1aJVq1b079+fLVu28NtvvzFo0CC6detGcHCw8y5MRETyj4AAcwHR4sXTFd3ONubyMG6kMoO+jGFM5m2tWGGuli6uJY9Gh2VozZo1BpBu6927t2EY5vDz1157zShXrpzh7e1tNG/e3Ni/f79NG2fOnDG6d+9u+Pr6Gn5+fkbfvn2N8+fPZyuOrA5dExGRAmzhQrvDzD+lv/XXz+mX+ZB0b2/D2LHD2VdTKGT1+9tiGEamT+UKg/j4ePz9/YmLi1NnZRGRwuzVV+2umP4ab/AWr+FOCj/xIG1YZr+doCBYvhzq1XNQoAJZ//522T47IiIiee71183FPjPwBqPozQxS8eAh5rGNhvbbiYoyh6SvW+egQCU7lOyIiIhc4e4O33wDvXqlK7IAn9Of+/mZRIrRliX8SWX7bcXFQcuWsGCB4+KVLFGyIyIicjUPD/jqKxg8OF2RJynMpysN2E4M5WjNMv4h/WzMVsnJ8NBDSnicTMmOiIjItdzcYNIkGDUqXZEf51lCWypwjAPU4EF+4iJF7LeVlgY9esAffzgwYMmMkh0REZGMWCxmH56ePdMVBRPFMloTwDnCuZMefEdqZl+pSUnmE574eAcGLPYo2REREcnM5MlQOX3fnFD28iMd8CKZhXRmCBMzn3Tw4EF44glzgLrkKSU7IiIimfHzMzstu6X/yryHDXyD+eRnMoN5n2GZtzVvniYddAIlOyIiItdz110wZkyGRQ8zjw8YCsBw3mMOj2Te1pAhMGtW7sYnmVKyIyIikhWvvmqufZWBoUxkCB8C0JuZrOVe++2kpZn9gObOdUSUkgElOyIiIllhscAXX8Czz2ZY/D7D6Mo8LuFNR35gF7Xtt5WWBo8+Ct9/76Bg5WpKdkRERLLKzQ0mToRx49IXYfANPbmbDcQRQGuW8ReZLEqdmmrO1rx0qePiFUDJjoiISPZYLPDSS/Dll+k6LRchmR/pQE32cpIQ2rCUODJZczElBR5+GCIjHRtzIadkR0REJCcefxzGjk23uyTnWEZrAoliB/XpwvdcwtN+OxcuQNu2cPKkA4Mt3JTsiIiI5NTw4Waico1KHGMJbfHlPKtoQT++zHwOnlOnoH17OH/eYaEWZkp2REREcsrNDWbOhAoV0hXdynbm0xV3UviWnrzKW5m3FRlp9uFJSXFMrIWYkh0REZEbUaqUOYzc2ztdUUt+5nP6AzCWV5jGU5m3tXQpPP20ZlnOZUp2REREblTjxjBnjrli+jX6MoPXMRcUHcgUfqJ95m19+aW5JpfkGiU7IiIiuaFjR5g9G9zd0xW9xpv04wvScKcbc9hMo8zbev11+Owzx8RZCCnZERERyS1du8J336Ubkm4BpjKA1izlIj60YzGHuDnztgYMgCVLHBdrIaJkR0REJDc98gh8/bU5H89VPElhLg9zKxH8QxlasZy/KW2/nbQ0eOwxOHrUsfEWAkp2REREcluPHvD+++l2+3KBJbSlEkc4TFXasZhEitpvJzbWnHTw0iXHxVoIKNkRERFxhCFD4Jln0u0O5DTLaUVJzrCFxnRjDimk7+djtXWrOZ+P5JiSHREREUewWGDSJGjdOl1RDQ6wiPYU4SKLeJDBfJz5pIMffWS+GpMcUbIjIiLiKB4e8L//Qf366YruJJzv6IGFNKYxgPG8lHlbffqYw9Il25TsiIiIOFLx4uZkgRnMstyZhUziOQBeZhzf8Jj9dgwDnngCPv7YUZEWWEp2REREHC04GJYvhxIl0hUNZjIv8C4AjzOdX2ieeVvPPgsTJjgiygJLyY6IiEheqFULFi+GIkXSFb3DCB5hDil40pkF/EG9zNsaMQKmTXNQoAWPkh0REZG8cued8O236Xa7YTCT3tzLWs7jRxuWcoLymbc1eDCsX++gQAsWJTsiIiJ5qUsXeP75dLu9ucQPdKQ2uzjFTbRmGbH4228nJcWcsfn4cQcGWzAo2REREclr48fDHXek2x1AHEtpQzB/sZs6dOQHkvGy387ff5trciUmOi7WAkDJjoiISF7z9DSHpJcsma6oAidYShuKE886mtKHGaRhyaCRf23fbg5LT011XLz5nJIdERERZ6hQAebMMefiuUZ9drCAznhwmTl05yXGZ97WvHnw3HPm8HRJR8mOiIiIs9x/P8yenWHC04JVTOdxAN7lRT5mUOZtTZkCb77piCjzPSU7IiIiztS1KyxcCF7p++b05Fve5mUAnmMSC+mYeVujR8PUqQ4IMn9TsiMiIuJs7dqZc/AUTb8C+kjG8RTTMHDjUWaxkbDM2xo4EH7+2UGB5k8uneyMGTMGi8Vis9WsWdNanpSUxMCBAylVqhS+vr506dKF06dPOzFiERGRHLr/fnOWZW9vm90WYDKDaM9PJFGU9ixiP9Xtt2MY0LMnxMQ4Nt58xKWTHYDatWsTFRVl3X799Vdr2dChQ1m0aBHz5s1j3bp1nDp1is6dOzsxWhERkRtwzz3w2WfpdnuQymy604jNnKUUrVlGNOXstxMTA48/rg7L/3L5ZMfDw4PAwEDrVrp0aQDi4uL48ssv+eCDD7jvvvto2LAhX331FRs3bmTTpk1OjlpERCSHevWCIUPS7S5GIotoz80c4ghVaMdiEihmv50lS7SkxL9cPtk5ePAgwcHBVKlShR49enD835kiIyIiuHz5Mi1atLDWrVmzJhUqVCA8PDzTNpOTk4mPj7fZREREXMa770Lz9AuCluVvltOK0vxNBLfxMHNJwd1+O88/D5GRjoszn3DpZKdx48bMmDGD5cuXM3XqVI4cOUKTJk04f/480dHReHl5ERAQYHNMuXLliI6OzrTdcePG4e/vb91CQkIceBUiIiLZ5OFhTjpYPX3fnKocZjHtKEoiy2jDAKZi92VVUhK0agWHDjk0XFfn0slO69ateeihh6hXrx4tW7Zk6dKlxMbGMnfu3Btqd+TIkcTFxVm3EydO5FLEIiIiuaRUKVixAoKD0xU1Zgtz6IYbqXxBf97iVfvtnD5tdn7+6y8HBuvaXDrZuVZAQADVq1fn0KFDBAYGcunSJWJjY23qnD59msDAwEzb8fb2xs/Pz2YTERFxOZUqmQlPiRLpih5kEZP/nWhwFG8yg9722zl6FFq2hLNnHROni8tXyU5CQgKHDx8mKCiIhg0b4unpyapVq6zl+/fv5/jx44SFXWcOAhERkfyiTh27c/AMYBojGQtAfz5nBQ/Yb2f3bujc2VwtvZBx6WTnhRdeYN26dRw9epSNGzfSqVMn3N3d6d69O/7+/vTr14/nn3+eNWvWEBERQd++fQkLC+OODFaSFRERybfuvBM+/TTDord5hcf4hhQ86cp8fucW++2sWwfvvOOgIF2XSyc7J0+epHv37tSoUYOHH36YUqVKsWnTJsqUKQPAhx9+SLt27ejSpQv33HMPgYGBLFiwwMlRi4iIOMBjj0G3bul2W4Av6UdzfiGB4rRlCUepaL+dN96AffscF6cLshiGZhyKj4/H39+fuLg49d8RERHXFRsL9epBBgNr4vCjCRvYST1qspffuIuSnMu4nTvvhA0bwM2ln3lcV1a/v/P3VYqIiBQmAQHwzTdgsaQr8ieepbShPCfYRy068CNJeKdvA2DjRnOV9EJCyY6IiEh+cu+9dvvdlOcvltEaf2L5lSb05BvSSJ8YAfDiixAR4cBAXYeSHRERkfzmhRdg6NAMi+qwm4V0wotk5vMQL/Bexm0kJUGnToViwVAlOyIiIvmNxQLvvQe9M55bpxlrmUEfAD7keT5kSMbtnDgBXbvCpUuOidNFKNkRERHJj9zc4IsvoEOHDIu7M4cJDAdgGO8zj64Zt7Nhg7mGVgGmZEdERCS/8vCAWbOgatUMi1/gPQbxMQZuPMa3rKdJxu1MmWLO1FxAKdkRERHJz3x84PPPMyyyABMZQkcWcglvOvAje6iVcTtDhhTY2ZWV7IiIiOR3TZvCU09lWOROGrN4lDA2EksJWrOMUwSlr7hvn92kKb9TsiMiIlIQvPMO3HRThkVFSeInHqQaBzhORdqyhPP4pq84ejTExzs40LynZEdERKQg8PeH774Dd/cMi0tzhuW0oiynieQWujKfy3jYVvr7b+jRo8CNzlKyIyIiUlDcey98+KHd4iocYQlt8eECP9OSJ/mMdGtGLV5srsF1+bJDQ81LSnZEREQKkkGDoG9fu8W3EcE8HsKdFGbQl9G8nr7SwoXmE54C0mFZyY6IiEhBYrHAJ59A48Z2q7RhGVMZAMCbjOJznkhfad48s9NzAVgvXMmOiIhIQVOkCHz1ld3+OwD9+YLXeAOAAUxlCW3SV5o+vUCM0FKyIyIiUhDVqgX9+2da5XVG05sZpOLBw8xlGw3TVxo6FPbvd1CQeUPJjoiISEE1Zgz4ZjDE/F8W4HP6cz8/k0gx2rKEP6lsWykxMd+P0FKyIyIiUlCVKwevvpppFU9S+J4uNGA7MZSjFcv5h1K2lSIiYMSIfNt/R8mOiIhIQfbCC9CsWaZVipPAUtpQgWMcpDoP8hOJFLWtNHEiPPsspKU5LlYHUbIjIiJSkLm7w//+B6GhmVYLIprltCKAc4RzJz34jtRr04TJk6F7d0hOdmDAuU/JjoiISEFXpgysXg01a2ZarRb7+IkH8SKZH+jEc0xKP+ng3LnQtm2+WlZCyY6IiEhhUK6cmfBUq5ZptSb8yrc8BsAUBvEeL6SvtGqV+Wrs9GlHRJrrlOyIiIgUFkFBsGaN3QVDr3iI+XzAUABe5F1m0y19pd9/h7vugsOHHRFprlKyIyIiUpjcdBN8840503ImhjKRIZjrbPVmJmtomr7S4cNw552wfbsDAs09SnZEREQKm2bNzFFa1/E+w+jKPC7jRScWsova6SvFxJgLkK5dm/tx5hIlOyIiIoXRm2/CLbdkWsUNg2/oyd1sII4AWrOMk2TwCuz8eWjdGpYvd1CwN0bJjoiISGHk7Q1z5kDJkplWK0IyP9KBmuzlJCG0YSlx+KWvmJQEDz4IP/zgmHhvgJIdERGRwqp6dViyBPz9M61WknMsozWBRLGTenRmAZfwTF/x8mXo2tVMolyIkh0REZHC7I47YMMGCA7OtFoljrGUNvhyntU053Gmp5+DByA1FR591JzI0EUo2RERESns6taFjRuhRo1Mq91CJPPpijspfMdjvMLbGVc0DOjVy1xTywUo2RERERGoWBF+/RUaNcq0Wkt+5nP6AzCOl5nK0xlXvHQJHnoIYmNzOdDsU7IjIiIiptKlzVmWW7XKtFpfZvA6owAYxGR+on3GFY8cMZ/wOHm1dCU7IiIi8p9ixeCnn+CxxzKt9hpv8gSfk4Y73ZjDJhpnXHHRIujQwamLhyrZEREREVuenjBzJgwbZreKBZjKANqwhIv40J5FHKRqxpUXLYLGjWH3bsfEex1KdkRERCQ9Nzd47z2YMMFuFQ9S+R+P0JBt/EMZWrOMGMpkXPmPP6BhQ5g4EdLSHBOzHUp2RERExL7hw+GTT+wW+3KBJbSlMn9ymKq0YzEX8Mm4cnIyDB0KLVvCX385KOD0lOyIiIhI5gYMgBkzzKc9GShHDMtoTUnOsJVGdGMOKbjbb++XX8zh7nPnOibeaxSYZGfKlClUqlSJIkWK0LhxY7Zs2eLskERERAqO3r1h9mxwzziJqcEBFtGeIlxkMe0ZxGRScGMt9zKbbqzlXlKvTjvOnYNHHoGePSEuzqGhF4hk53//+x/PP/88o0eP5vfff6d+/fq0bNmSmJgYZ4cmIiJScDz8MLz7rt3iOwlnFo9iIY1PeZpSnKEZa3mU2TRjLZU4ygI62R707bdQrx6sW+ewsAtEsvPBBx/Qv39/+vbtS2hoKNOmTcPHx4fp06c7OzQREZGCZcgQ6NjRbnEnfuBxvgQgngCbsr+4ia7MT5/wHD8O+/fnbpxXyffJzqVLl4iIiKBFixbWfW5ubrRo0YLw8PAMj0lOTiY+Pt5mExERkSywWOCrr6By5QyLU3FjBa0gg5WzjH/TjiFMtH2l1a4d9O/viGiBApDs/PPPP6SmplKuXDmb/eXKlSM6OjrDY8aNG4e/v791CwkJyYtQRURECoaAAJg/H3x90xVtoAknCcGciSc9AzdOUIENNDF3lCkDX3xhJlEOku+TnZwYOXIkcXFx1u3EiRPODklERCR/ufVWWLkS/P1tdkcRlKXDrfW+/BKueWCR2/J9slO6dGnc3d05ffq0zf7Tp08TGBiY4THe3t74+fnZbCIiIpJNd9wBmzaZkwX+K4ioLB0aRJT56qq9nXW1clG+T3a8vLxo2LAhq1atsu5LS0tj1apVhIWFOTEyERGRQqBmTdi4EV55BdzcaMIGynMCCxnPkmwhjRCO0+TmKPjggzwJMd8nOwDPP/88n3/+OTNnzmTv3r0MGDCACxcu0LdvX2eHJiIiUvB5ecFbb8H69bhXrsgkngNIl/Bc+X2i2/O4f/d1hn1+HKFAJDuPPPII7733HqNGjaJBgwZERkayfPnydJ2WRURExIHuugsiI+ncx5/5dOUmbJeEKM9J5tOVzq/VMRcGzSMWwzDSjw0rZOLj4/H39ycuLk79d0RERHLDggWkPvEUG87VJooggoiiCRtwb3Qb/PqrubL6Dcrq97fHDZ9JRERE5FqdO+N+xx00ffxxWDHH3OfjY86YnAuJTnYUiNdYIiIi4oKCg2HZMvj4YyhSBD78EKpVy/Mw9GRHREREHMdigUGDzCHmFSo4JQQlOyIiIuJ4FSs67dR6jSUiIiIFmpIdERERKdCU7IiIiEiBpmRHRERECjQlOyIiIlKgKdkRERGRAk1Dz4ErK2bEx8c7ORIRERHJqivf29db+UrJDnD+/HkAQkJCnByJiIiIZNf58+fx9/e3W66FQIG0tDROnTpF8eLFsVgsudZufHw8ISEhnDhxotAuMKp7oHsAugege1DYrx90DyD374FhGJw/f57g4GDc3Oz3zNGTHcDNzY3y5cs7rH0/P79C+8G+QvdA9wB0D0D3oLBfP+geQO7eg8ye6FyhDsoiIiJSoCnZERERkQJNyY4DeXt7M3r0aLy9vZ0ditPoHugegO4B6B4U9usH3QNw3j1QB2UREREp0PRkR0RERAo0JTsiIiJSoCnZERERkQJNyY6IiIgUaEp2HGjKlClUqlSJIkWK0LhxY7Zs2eLskBxizJgxWCwWm61mzZrW8qSkJAYOHEipUqXw9fWlS5cunD592okR37j169fTvn17goODsVgs/PDDDzblhmEwatQogoKCKFq0KC1atODgwYM2dc6ePUuPHj3w8/MjICCAfv36kZCQkIdXcWOudw/69OmT7nPRqlUrmzr5+R6MGzeO22+/neLFi1O2bFk6duzI/v37bepk5bN//Phx2rZti4+PD2XLlmX48OGkpKTk5aXkWFbuQdOmTdN9Dp5++mmbOvn5HkydOpV69epZJ8kLCwtj2bJl1vKC/hmA698DV/gMKNlxkP/97388//zzjB49mt9//5369evTsmVLYmJinB2aQ9SuXZuoqCjr9uuvv1rLhg4dyqJFi5g3bx7r1q3j1KlTdO7c2YnR3rgLFy5Qv359pkyZkmH5hAkT+Oijj5g2bRqbN2+mWLFitGzZkqSkJGudHj16sHv3blauXMnixYtZv349Tz75ZF5dwg273j0AaNWqlc3nYvbs2Tbl+fkerFu3joEDB7Jp0yZWrlzJ5cuXeeCBB7hw4YK1zvU++6mpqbRt25ZLly6xceNGZs6cyYwZMxg1apQzLinbsnIPAPr372/zOZgwYYK1LL/fg/LlyzN+/HgiIiLYtm0b9913Hx06dGD37t1Awf8MwPXvAbjAZ8AQh2jUqJExcOBA6++pqalGcHCwMW7cOCdG5RijR4826tevn2FZbGys4enpacybN8+6b+/evQZghIeH51GEjgUYCxcutP6elpZmBAYGGu+++651X2xsrOHt7W3Mnj3bMAzD2LNnjwEYW7dutdZZtmyZYbFYjL/++ivPYs8t194DwzCM3r17Gx06dLB7TEG7BzExMQZgrFu3zjCMrH32ly5dari5uRnR0dHWOlOnTjX8/PyM5OTkvL2AXHDtPTAMw7j33nuN5557zu4xBe0eGIZhlChRwvjiiy8K5Wfgiiv3wDBc4zOgJzsOcOnSJSIiImjRooV1n5ubGy1atCA8PNyJkTnOwYMHCQ4OpkqVKvTo0YPjx48DEBERweXLl23uRc2aNalQoUKBvRdHjhwhOjra5pr9/f1p3Lix9ZrDw8MJCAjgtttus9Zp0aIFbm5ubN68Oc9jdpS1a9dStmxZatSowYABAzhz5oy1rKDdg7i4OABKliwJZO2zHx4eTt26dSlXrpy1TsuWLYmPj7f5V3F+ce09uOK7776jdOnS1KlTh5EjR5KYmGgtK0j3IDU1lTlz5nDhwgXCwsIK5Wfg2ntwhbM/A1oI1AH++ecfUlNTbf7DAZQrV459+/Y5KSrHady4MTNmzKBGjRpERUXx+uuv06RJE3bt2kV0dDReXl4EBATYHFOuXDmio6OdE7CDXbmujP77XymLjo6mbNmyNuUeHh6ULFmywNyXVq1a0blzZypXrszhw4d5+eWXad26NeHh4bi7uxeoe5CWlsaQIUO46667qFOnDkCWPvvR0dEZfk6ulOUnGd0DgEcffZSKFSsSHBzMjh07GDFiBPv372fBggVAwbgHO3fuJCwsjKSkJHx9fVm4cCGhoaFERkYWms+AvXsArvEZULIjN6x169bWP9erV4/GjRtTsWJF5s6dS9GiRZ0YmThTt27drH+uW7cu9erV4+abb2bt2rU0b97ciZHlvoEDB7Jr1y6bvmqFjb17cHUfrLp16xIUFETz5s05fPgwN998c16H6RA1atQgMjKSuLg45s+fT+/evVm3bp2zw8pT9u5BaGioS3wG9BrLAUqXLo27u3u6HvenT58mMDDQSVHlnYCAAKpXr86hQ4cIDAzk0qVLxMbG2tQpyPfiynVl9t8/MDAwXWf1lJQUzp49W2DvS5UqVShdujSHDh0CCs49GDRoEIsXL2bNmjWUL1/euj8rn/3AwMAMPydXyvILe/cgI40bNwaw+Rzk93vg5eVF1apVadiwIePGjaN+/fpMmjSpUH0G7N2DjDjjM6BkxwG8vLxo2LAhq1atsu5LS0tj1apVNu8wC6qEhAQOHz5MUFAQDRs2xNPT0+Ze7N+/n+PHjxfYe1G5cmUCAwNtrjk+Pp7NmzdbrzksLIzY2FgiIiKsdVavXk1aWpr1L4KC5uTJk5w5c4agoCAg/98DwzAYNGgQCxcuZPXq1VSuXNmmPCuf/bCwMHbu3GmT9K1cuRI/Pz/rKwBXdr17kJHIyEgAm89Bfr4HGUlLSyM5OblQfAbsuXIPMuKUz0CudHOWdObMmWN4e3sbM2bMMPbs2WM8+eSTRkBAgE1v84Ji2LBhxtq1a40jR44Yv/32m9GiRQujdOnSRkxMjGEYhvH0008bFSpUMFavXm1s27bNCAsLM8LCwpwc9Y05f/68sX37dmP79u0GYHzwwQfG9u3bjWPHjhmGYRjjx483AgICjB9//NHYsWOH0aFDB6Ny5crGxYsXrW20atXKuOWWW4zNmzcbv/76q1GtWjWje/fuzrqkbMvsHpw/f9544YUXjPDwcOPIkSPGL7/8Ytx6661GtWrVjKSkJGsb+fkeDBgwwPD39zfWrl1rREVFWbfExERrnet99lNSUow6deoYDzzwgBEZGWksX77cKFOmjDFy5EhnXFK2Xe8eHDp0yHjjjTeMbdu2GUeOHDF+/PFHo0qVKsY999xjbSO/34OXXnrJWLdunXHkyBFjx44dxksvvWRYLBbj559/Ngyj4H8GDCPze+AqnwElOw708ccfGxUqVDC8vLyMRo0aGZs2bXJ2SA7xyCOPGEFBQYaXl5dx0003GY888ohx6NAha/nFixeNZ555xihRooTh4+NjdOrUyYiKinJixDduzZo1BpBu6927t2EY5vDz1157zShXrpzh7e1tNG/e3Ni/f79NG2fOnDG6d+9u+Pr6Gn5+fkbfvn2N8+fPO+Fqciaze5CYmGg88MADRpkyZQxPT0+jYsWKRv/+/dMl+/n5HmR07YDx1VdfWetk5bN/9OhRo3Xr1kbRokWN0qVLG8OGDTMuX76cx1eTM9e7B8ePHzfuueceo2TJkoa3t7dRtWpVY/jw4UZcXJxNO/n5Hjz++ONGxYoVDS8vL6NMmTJG8+bNrYmOYRT8z4BhZH4PXOUzYDEMw8idZ0QiIiIirkd9dkRERKRAU7IjIiIiBZqSHRERESnQlOyIiIhIgaZkR0RERAo0JTsiIiJSoCnZERERkQJNyY6IiIgUaEp2RKRAqVSpEhaLBYvFkm4Bxuxq2rSpta0r6/mISP6jZEdEXE5qaip33nknnTt3ttkfFxdHSEgIr7zySqbHv/HGG0RFReHv739DcSxYsIAtW7bcUBsi4nxKdkTE5bi7uzNjxgyWL1/Od999Z90/ePBgSpYsyejRozM9vnjx4gQGBmKxWG4ojpIlS1KmTJkbakNEnE/Jjoi4pOrVqzN+/HgGDx5MVFQUP/74I3PmzOHrr7/Gy8srW23NmDGDgIAAFi9eTI0aNfDx8aFr164kJiYyc+ZMKlWqRIkSJXj22WdJTU110BWJiLN4ODsAERF7Bg8ezMKFC+nZsyc7d+5k1KhR1K9fP0dtJSYm8tFHHzFnzhzOnz9P586d6dSpEwEBASxdupQ///yTLl26cNddd/HII4/k8pWIiDMp2RERl2WxWJg6dSq1atWibt26vPTSSzlu6/Lly0ydOpWbb74ZgK5du/LNN99w+vRpfH19CQ0NpVmzZqxZs0bJjkgBo9dYIuLSpk+fjo+PD0eOHOHkyZM5bsfHx8ea6ACUK1eOSpUq4evra7MvJibmhuIVEdejZEdEXNbGjRv58MMPWbx4MY0aNaJfv34YhpGjtjw9PW1+t1gsGe5LS0vLcbwi4pqU7IiIS0pMTKRPnz4MGDCAZs2a8eWXX7JlyxamTZvm7NBEJJ9RsiMiLmnkyJEYhsH48eMBc7LA9957jxdffJGjR486NzgRyVeU7IiIy1m3bh1Tpkzhq6++wsfHx7r/qaee4s4777yh11kiUvhYDP2NISIFSKVKlRgyZAhDhgzJlfaOHj1K5cqV2b59Ow0aNMiVNkUkb+nJjogUOCNGjMDX15e4uLgbaqd169bUrl07l6ISEWfRkx0RKVCOHTvG5cuXAahSpQpubjn/N91ff/3FxYsXAahQoUK2Z24WEdegZEdEREQKNL3GEhERkQJNyY6IiIgUaEp2REREpEBTsiMiIiIFmpIdERERKdCU7IiIiEiBpmRHRERECjQlOyIiIlKg/R9gBbWQG6TkkwAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -86,6 +88,142 @@ "plt.legend()\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "id": "da8620fa", + "metadata": {}, + "source": [ + "## Making a landscape\n", + "\n", + "You can make a landscape with or without a path. Let's make an empty landscape." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "24f1159d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "landscape = Landscape()\n", + "fig, ax = landscape.plot()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "035b4f42", + "metadata": {}, + "source": [ + "## Adding a source" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "91019da5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_source = Source(x = 100, y = 100, z = 0, strength = 100)\n", + "landscape.add_sources(my_source)\n", + "\n", + "landscape.sources" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7913fe1e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "landscape.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "df4715c1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "landscape.set_path(p2)\n", + "landscape.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "17fec32f", + "metadata": {}, + "source": [] } ], "metadata": { diff --git a/pyproject.toml b/pyproject.toml index 7ca4f86..1b0ad50 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -7,7 +7,7 @@ where = ["src"] [project] name = "pg-rad" -version = "0.1.0" +version = "0.2.0" authors = [ { name="Pim Nelissen", email="pi0274ne-s@student.lu.se" }, ] diff --git a/src/pg_rad/landscape.py b/src/pg_rad/landscape.py new file mode 100644 index 0000000..601b360 --- /dev/null +++ b/src/pg_rad/landscape.py @@ -0,0 +1,103 @@ +from matplotlib import pyplot as plt +from matplotlib.patches import Circle +import numpy as np + +from pg_rad.path import Path +from pg_rad.objects import Source + +class Landscape: + def __init__(self, size: int | tuple[int, int, int] = 500, unit = 'meters'): + if isinstance(size, int): + self.world = np.zeros((size, size, size)) + elif isinstance(size, tuple) and len(size) == 3: + self.world = np.zeros(size) + else: + raise TypeError("size must be an integer or a tuple of 3 integers.") + + self.unit = unit + + self.path: Path = None + self.sources: list[Source] = [] + + def plot(self, z = 0): + """_Plot a slice of the world at a height z._ + + Args: + z (int, optional): Height of slice. Defaults to 0. + + Returns: + fig, ax: Matplotlib figure objects. + """ + x_lim, y_lim, _ = self.world.shape + + fig, ax = plt.subplots() + ax.set_xlim(right=x_lim) + ax.set_ylim(top=y_lim) + ax.set_xlabel(f"X [{self.unit}]") + ax.set_ylabel(f"Y [{self.unit}]") + + if not self.path == None: + ax.plot(self.path.x_list, self.path.y_list, 'bo-') + + for s in self.sources: + if np.isclose(s.z, z): + dot = Circle( + (s.x, s.y), + radius=5, + color=s.color, + zorder=5 + ) + + ax.text( + s.x + 0.06, + s.y + 0.06, + s.name, + color=s.color, + fontsize=10, + ha="left", + va="bottom", + zorder=6 + ) + + ax.add_patch(dot) + + return fig, ax + + def add_sources(self, *sources: Source): + """Add one or more point sources to the world.""" + + max_x, max_y, max_z = self.world.shape[:3] + + if any( + not (0 <= source.x < max_x and + 0 <= source.y < max_y and + 0 <= source.z < max_z) + for source in sources + ): + raise ValueError("One or more sources are outside the world boundaries.") + + self.sources.extend(sources) + + def set_path(self, path: Path): + self.path = path + +def create_landscape_from_path(path: Path, max_z = 500): + """_Generate a Landscape from a path, using its dimensions to determine + the size of the Landscape._ + + Args: + path (Path): _A Path object describing the trajectory._ + max_z (int, optional): _Height of the world_. Defaults to 500 meters. + + Returns: + _type_: _A Landscape with dimensions based on the provided Path._ + """ + max_x = np.ceil(max(path.x_list)) + max_y = np.ceil(max(path.y_list)) + + landscape = Landscape( + size = (max_x, max_y, max_z) + ) + + landscape.path = path + return landscape \ No newline at end of file diff --git a/src/pg_rad/objects.py b/src/pg_rad/objects.py new file mode 100644 index 0000000..27c7a08 --- /dev/null +++ b/src/pg_rad/objects.py @@ -0,0 +1,38 @@ +import math +from typing import Self + +class Object: + def __init__( + self, + x: float, + y: float, + z: float, + name: str = "Unnamed object", + color: str = 'grey'): + + self.x = x + self.y = y + self.z = z + self.name = name + self.color = color + + def distance_to(self, other: Self) -> float: + return math.dist( + (self.x, self.y, self.z), + (other.x, other.y, other.z), + ) + +class Source(Object): + def __init__( + self, + x: float, + y: float, + z: float, + strength: int, + name: str = "Unnamed source", + color: str = "red"): + + super().__init__(x, y, z, name, color) + + self.strength = strength + self.color = color \ No newline at end of file From c6c92e8f0d78f0c48b90df65cd50c4884bd4ccda Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 19:38:18 +0100 Subject: [PATCH 09/27] add tests for distance between objects --- tests/test_objects.py | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 tests/test_objects.py diff --git a/tests/test_objects.py b/tests/test_objects.py new file mode 100644 index 0000000..bde3dd3 --- /dev/null +++ b/tests/test_objects.py @@ -0,0 +1,36 @@ +import numpy as np +import pytest + +from pg_rad.objects import Source + +@pytest.fixture +def test_sources(): + pos_a = np.random.rand(3) + pos_b = np.random.rand(3) + + a = Source(*tuple(pos_a), strength = None) + b = Source(*tuple(pos_b), strength = None) + + return pos_a, pos_b, a, b + +def test_if_distances_equal(test_sources): + """_Verify whether from object A to object B is the same as B to A._""" + + _, _, a, b = test_sources + + assert a.distance_to(b) == b.distance_to(a) + +def test_distance_calculation(test_sources): + """_Verify whether distance between two static objects (e.g. sources) + is calculated correctly._""" + + pos_a, pos_b, a, b = test_sources + + dx = pos_b[0] - pos_a[0] + dy = pos_b[1] - pos_a[1] + dz = pos_b[2] - pos_a[2] + + assert np.isclose( + a.distance_to(b), + np.sqrt(dx**2 + dy**2 + dz**2), + rtol = 1e-12) \ No newline at end of file From 8d8826a649428638c580719fcacd6ae66d84b719 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 19:46:03 +0100 Subject: [PATCH 10/27] add representation for Source object --- src/pg_rad/objects.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/pg_rad/objects.py b/src/pg_rad/objects.py index 27c7a08..8e2cea2 100644 --- a/src/pg_rad/objects.py +++ b/src/pg_rad/objects.py @@ -35,4 +35,7 @@ class Source(Object): super().__init__(x, y, z, name, color) self.strength = strength - self.color = color \ No newline at end of file + self.color = color + + def __repr__(self): + return f"Source(name={self.name}, strength={self.strength}, pos={(self.x, self.y, self.z)})" \ No newline at end of file From af31770c6f69f8dcad99376c367b1196501008a8 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 19:46:49 +0100 Subject: [PATCH 11/27] re-render notebook --- demo/demo.ipynb | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/demo/demo.ipynb b/demo/demo.ipynb index accea10..3f32067 100644 --- a/demo/demo.ipynb +++ b/demo/demo.ipynb @@ -62,12 +62,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-01-27 19:21:09,113 - INFO: Piecewise regression reduced path from 105 to 4 segments.\n" + "2026-01-27 19:45:14,264 - INFO: Piecewise regression reduced path from 105 to 4 segments.\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -139,7 +139,7 @@ { "data": { "text/plain": [ - "[]" + "[Source(name=Unnamed source, strength=100, pos=(100, 100, 0))]" ] }, "execution_count": 5, @@ -188,7 +188,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "df4715c1", "metadata": {}, "outputs": [ @@ -199,7 +199,7 @@ " )" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, From 6fe6fe744ff207466003ac9a2149398f8cb8565c Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 20:23:33 +0100 Subject: [PATCH 12/27] Add Isotope object --- src/pg_rad/isotopes.py | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 src/pg_rad/isotopes.py diff --git a/src/pg_rad/isotopes.py b/src/pg_rad/isotopes.py new file mode 100644 index 0000000..1d62d70 --- /dev/null +++ b/src/pg_rad/isotopes.py @@ -0,0 +1,25 @@ +class Isotope: + def __init__( + self, + name: str, + E: float, + b: float + ): + """_Represents the essential information of an isotope._ + + Args: + name (str): _Full name (e.g. Caesium-137)._ + symbol (str): _Shorthand symbol (e.g. 137Cs or Cs-137)_ + E (float): _Energy of the primary gamma in keV._ + b (float): _Branching ratio for the gamma at energy E._ + """ + + if E <= 0: + raise ValueError("primary_gamma must be a positive energy (keV).") + + if not (0 <= b <= 1): + raise ValueError("branching_ratio_pg must be a ratio (0 <= b <= 1)") + + self.name = name + self.E = E + self.b = b \ No newline at end of file From 8de5fe33512031cbd75305b28d315fd21be721d0 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 20:23:54 +0100 Subject: [PATCH 13/27] Update Source object to work with Isotope --- src/pg_rad/objects.py | 34 +++++++++++++++++++++++++++++----- 1 file changed, 29 insertions(+), 5 deletions(-) diff --git a/src/pg_rad/objects.py b/src/pg_rad/objects.py index 8e2cea2..64b5665 100644 --- a/src/pg_rad/objects.py +++ b/src/pg_rad/objects.py @@ -1,6 +1,8 @@ import math from typing import Self +from pg_rad.isotopes import Isotope + class Object: def __init__( self, @@ -23,19 +25,41 @@ class Object: ) class Source(Object): + _id_counter = 1 def __init__( self, x: float, y: float, z: float, - strength: int, - name: str = "Unnamed source", + activity: int, + isotope: Isotope, + name: str | None = None, color: str = "red"): - + """_A point source._ + + Args: + x (float): _X coordinate._ + y (float): _Y coordinate._ + z (float): _Z coordinate._ + activity (int): _Activity A in MBq._ + isotope (Isotope): _The isotope._ + name (str | None, optional): _Can give the source a unique name_. + Defaults to None, making the name sequential + (Source-1, Source-2, etc.). + color (str, optional): _Matplotlib compatible color string_. Defaults to "red". + """ + self.id = Source._id_counter + Source._id_counter += 1 + + # default name derived from ID if not provided + if name is None: + name = f"Source {self.id}" + super().__init__(x, y, z, name, color) - self.strength = strength + self.activity = activity + self.isotope = isotope self.color = color def __repr__(self): - return f"Source(name={self.name}, strength={self.strength}, pos={(self.x, self.y, self.z)})" \ No newline at end of file + return f"Source(name={self.name}, A={self.activity} MBq, pos={(self.x, self.y, self.z)})" \ No newline at end of file From 3b92abc426dc003de4fbbff76ca550c64d3dfeb3 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 20:30:27 +0100 Subject: [PATCH 14/27] fix docstring --- src/pg_rad/isotopes.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/pg_rad/isotopes.py b/src/pg_rad/isotopes.py index 1d62d70..b9e3469 100644 --- a/src/pg_rad/isotopes.py +++ b/src/pg_rad/isotopes.py @@ -9,7 +9,6 @@ class Isotope: Args: name (str): _Full name (e.g. Caesium-137)._ - symbol (str): _Shorthand symbol (e.g. 137Cs or Cs-137)_ E (float): _Energy of the primary gamma in keV._ b (float): _Branching ratio for the gamma at energy E._ """ From ae0187e0f6901bf732a7245670bd046de00d11e3 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 20:39:52 +0100 Subject: [PATCH 15/27] update Source representation --- src/pg_rad/objects.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pg_rad/objects.py b/src/pg_rad/objects.py index 64b5665..3a6a1b1 100644 --- a/src/pg_rad/objects.py +++ b/src/pg_rad/objects.py @@ -62,4 +62,4 @@ class Source(Object): self.color = color def __repr__(self): - return f"Source(name={self.name}, A={self.activity} MBq, pos={(self.x, self.y, self.z)})" \ No newline at end of file + return f"Source(name={self.name}, pos={(self.x, self.y, self.z)}, isotope={self.isotope.name}, A={self.activity} MBq)" \ No newline at end of file From e53fd65088798b7ece42cdb8c245ba6b8f3efb80 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 20:40:50 +0100 Subject: [PATCH 16/27] update demo notebook --- demo/demo.ipynb | 133 +++++++++++++----------------------------------- 1 file changed, 34 insertions(+), 99 deletions(-) diff --git a/demo/demo.ipynb b/demo/demo.ipynb index 3f32067..6a8f701 100644 --- a/demo/demo.ipynb +++ b/demo/demo.ipynb @@ -12,17 +12,35 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "415fdd25", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "super(): no arguments", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mRuntimeError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 5\u001b[39m\n\u001b[32m 3\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpg_rad\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mdataloader\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m load_data\n\u001b[32m 4\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpg_rad\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mpath\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m path_from_RT90\n\u001b[32m----> \u001b[39m\u001b[32m5\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpg_rad\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mlandscape\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Landscape\n\u001b[32m 6\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpg_rad\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mobjects\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Source\n\u001b[32m 8\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpg_rad\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01misotopes\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Cs137\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/pg-rad/src/pg_rad/landscape.py:6\u001b[39m\n\u001b[32m 3\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnumpy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnp\u001b[39;00m\n\u001b[32m 5\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpg_rad\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mpath\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Path\n\u001b[32m----> \u001b[39m\u001b[32m6\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpg_rad\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mobjects\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Source\n\u001b[32m 8\u001b[39m \u001b[38;5;28;01mclass\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mLandscape\u001b[39;00m:\n\u001b[32m 9\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, size: \u001b[38;5;28mint\u001b[39m | \u001b[38;5;28mtuple\u001b[39m[\u001b[38;5;28mint\u001b[39m, \u001b[38;5;28mint\u001b[39m, \u001b[38;5;28mint\u001b[39m] = \u001b[32m500\u001b[39m, unit = \u001b[33m'\u001b[39m\u001b[33mmeters\u001b[39m\u001b[33m'\u001b[39m):\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/pg-rad/src/pg_rad/objects.py:4\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mmath\u001b[39;00m\n\u001b[32m 2\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtyping\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Self\n\u001b[32m----> \u001b[39m\u001b[32m4\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpg_rad\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01misotopes\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Isotope\n\u001b[32m 6\u001b[39m \u001b[38;5;28;01mclass\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mObject\u001b[39;00m:\n\u001b[32m 7\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__init__\u001b[39m(\n\u001b[32m 8\u001b[39m \u001b[38;5;28mself\u001b[39m,\n\u001b[32m 9\u001b[39m x: \u001b[38;5;28mfloat\u001b[39m,\n\u001b[32m (...)\u001b[39m\u001b[32m 12\u001b[39m name: \u001b[38;5;28mstr\u001b[39m = \u001b[33m\"\u001b[39m\u001b[33mUnnamed object\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 13\u001b[39m color: \u001b[38;5;28mstr\u001b[39m = \u001b[33m'\u001b[39m\u001b[33mgrey\u001b[39m\u001b[33m'\u001b[39m):\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/pg-rad/src/pg_rad/isotopes.py:29\u001b[39m\n\u001b[32m 26\u001b[39m \u001b[38;5;28mself\u001b[39m.E = E\n\u001b[32m 27\u001b[39m \u001b[38;5;28mself\u001b[39m.b = b\n\u001b[32m---> \u001b[39m\u001b[32m29\u001b[39m \u001b[38;5;28;43;01mclass\u001b[39;49;00m\u001b[38;5;250;43m \u001b[39;49m\u001b[34;43;01mCs137\u001b[39;49;00m\u001b[43m(\u001b[49m\u001b[43mIsotope\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\n\u001b[32m 30\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[34;43m__init__\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[32m 31\u001b[39m \u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m \u001b[49m\u001b[43m=\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mCaesium-137\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 32\u001b[39m \u001b[43m \u001b[49m\u001b[43msymbol\u001b[49m\u001b[43m \u001b[49m\u001b[43m=\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mCs137\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 33\u001b[39m \u001b[43m \u001b[49m\u001b[43mE\u001b[49m\u001b[43m \u001b[49m\u001b[43m=\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m662.66\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 34\u001b[39m \u001b[43m \u001b[49m\u001b[43mb\u001b[49m\u001b[43m \u001b[49m\u001b[43m=\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m0.851\u001b[39;49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/pg-rad/src/pg_rad/isotopes.py:30\u001b[39m, in \u001b[36mCs137\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 29\u001b[39m \u001b[38;5;28;01mclass\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mCs137\u001b[39;00m(Isotope):\n\u001b[32m---> \u001b[39m\u001b[32m30\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m.\u001b[34m__init__\u001b[39m(\n\u001b[32m 31\u001b[39m name = \u001b[33m\"\u001b[39m\u001b[33mCaesium-137\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 32\u001b[39m symbol = \u001b[33m\"\u001b[39m\u001b[33mCs137\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 33\u001b[39m E = \u001b[32m662.66\u001b[39m,\n\u001b[32m 34\u001b[39m b = \u001b[32m0.851\u001b[39m)\n", + "\u001b[31mRuntimeError\u001b[39m: super(): no arguments" + ] + } + ], "source": [ "from matplotlib import pyplot as plt\n", "\n", "from pg_rad.dataloader import load_data\n", "from pg_rad.path import path_from_RT90\n", "from pg_rad.landscape import Landscape\n", - "from pg_rad.objects import Source" + "from pg_rad.objects import Source\n", + "\n", + "from pg_rad.isotopes import Isotope" ] }, { @@ -35,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "5a0e470a", "metadata": {}, "outputs": [], @@ -54,28 +72,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "2ec97553", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-01-27 19:45:14,264 - INFO: Piecewise regression reduced path from 105 to 4 segments.\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGwCAYAAABPSaTdAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAcMhJREFUeJzt3XdcVfUfx/HXZSoi4AYSV06cZWlUlqblzllp5sqsTC3NzGyoLTVbWpq2TBvqT00rd+YucZHknjkTpFRARFDg/P44efMKFwG53Au8n4/HeSDn+z3f8zmnm/fjOd9hMQzDQERERKSAcnN2ACIiIiKOpGRHRERECjQlOyIiIlKgKdkRERGRAk3JjoiIiBRoSnZERESkQFOyIyIiIgWah7MDcAVpaWmcOnWK4sWLY7FYnB2OiIiIZIFhGJw/f57g4GDc3Ow/v1GyA5w6dYqQkBBnhyEiIiI5cOLECcqXL2+3XMkOULx4ccC8WX5+fk6ORkRERLIiPj6ekJAQ6/e4PUp2wPrqys/PT8mOiIhIPnO9LijqoCwiIiIFmpIdERERKdCU7IiIiEiBpj47IiLiUKmpqVy+fNnZYUg+5Onpibu7+w23o2RHREQcwjAMoqOjiY2NdXYoko8FBAQQGBh4Q/PgKdlxhpQU8NCtF5GC7UqiU7ZsWXx8fDRpq2SLYRgkJiYSExMDQFBQUI7b0jeuI126BAcOwO7dsGeP+XP3bjh2DGJjwcvL2RGKiDhEamqqNdEpVaqUs8ORfKpo0aIAxMTEULZs2Ry/0lKykxvsJTUHD0JqasbHHDwItWvnbZwiInnkSh8dHx8fJ0ci+d2Vz9Dly5eV7DhNnz7w3Xfmq6ns2LNHyY6IFHh6dSU3Kjc+Q0p2blSxYtlPdMB88vPQQ7kfj4iIC/CuUoXq8fGZLs7odMWLw19/OTsKyQNKdm5UTp/O7N6du3GIiLiShATcL1xwdhQigCYVvHGhoTk7bs+e3I1DRERcQtOmTRkyZIj190qVKjFx4kSnxNKnTx86duzolHO7EiU7NyqnT3YOHDA7NouIiEvp06cPFosl3Xbo0CFnh2bX0aNHsVgsREZGOjsUl6Rk50aVKWNu2ZWSYo7IEhERl9OqVSuioqJstsqVKzs7LMkhJTu5Qa+yREQKFG9vbwIDA202d3f3DF8LDRkyhKZNm+b4XFfafP311ylTpgx+fn48/fTTXLrq6f/y5cu5++67CQgIoFSpUrRr147Dhw9by68kYrfccgsWiyVdPO+99x5BQUGUKlWKgQMHFrrlO5Ts5AZ1UhYRkRuwatUq9u7dy9q1a5k9ezYLFizg9ddft5ZfuHCB559/nm3btrFq1Src3Nzo1KkTaWlpAGzZsgWAX375haioKBYsWGA9ds2aNRw+fJg1a9Ywc+ZMZsyYwYwZM/L0+pxNo7Fyg5IdEZECZfHixfj6+lp/b926NfPmzXPY+by8vJg+fTo+Pj7Url2bN954g+HDh/Pmm2/i5uZGly5dbOpPnz6dMmXKsGfPHurUqUOZf7tTlCpVisDAQJu6JUqUYPLkybi7u1OzZk3atm3LqlWr6N+/v8Oux9Uo2ckNOX2NFRGRu3GIiEiuaNasGVOnTrX+XqxYMYeer379+jazTYeFhZGQkMCJEyeoWLEiBw8eZNSoUWzevJl//vnH+kTn+PHj1KlTJ9O2a9eubTPzcFBQEDt37nTMhbgop77Gmjp1KvXq1cPPzw8/Pz/CwsJYtmyZtbxp06bpesM//fTTNm0cP36ctm3b4uPjQ9myZRk+fDgpOZnk70bk9MnOkSPmOlkiIuJSihUrRtWqVa3blUUo3dzcMAzDpm5e9H9p3749Z8+e5fPPP2fz5s1s3rwZwKZfjz2enp42v1ssFmuyVFg49clO+fLlGT9+PNWqVcMwDGbOnEmHDh3Yvn07tf9NIPr3788bb7xhPebqzDc1NZW2bdsSGBjIxo0biYqKolevXnh6ejJ27Ni8u5ArI7L+/jv7x65ZYy45ISIiLq9MmTLs2rXLZl9kZGS6hCK7/vjjDy5evGhd+HLTpk34+voSEhLCmTNn2L9/P59//jlNmjQB4Ndff7U53uvfhaVT7a3HWMg59clO+/btadOmDdWqVaN69eq8/fbb+Pr6smnTJmsdHx8fm97wfn5+1rKff/6ZPXv28O2339KgQQNat27Nm2++yZQpU7KU7eaq22+3+TUVN9ZyL7PpxlruJdXerV6zJg+CExGR3HDfffexbds2vv76aw4ePMjo0aPTJT85cenSJfr168eePXtYunQpo0ePZtCgQbi5uVGiRAlKlSrFZ599xqFDh1i9ejXPP/+8zfFly5alaNGiLF++nNOnTxMXF3fDMRUkLjMaKzU1lTlz5nDhwgXCwsKs+7/77jtKly5NnTp1GDlyJImJiday8PBw6tatS7ly5az7WrZsSXx8PLsz6fybnJxMfHy8zXbDmjWz/nEBnajEUZqxlkeZTTPWUomjLKBT+uOU7IiI5BstW7bktdde48UXX+T222/n/Pnz9OrV64bbbd68OdWqVeOee+7hkUce4cEHH2TMmDGA+epszpw5REREUKdOHYYOHcq7775rc7yHhwcfffQRn376KcHBwXTo0OGGYypILMa1Lx/z2M6dOwkLCyMpKQlfX19mzZpFmzZtAPjss8+oWLEiwcHB7NixgxEjRtCoUSPrkLonn3ySY8eOsWLFCmt7iYmJFCtWjKVLl9K6desMzzlmzBibIX1XxMXF2Tw5ypbff4eGDVlAJ7oyH/Om/pdLWjDfj86nK51ZaHvs8eMQEpKz84qIuCAjOJi0fxcCddl1z11kIdA+ffoQGxvLDz/84OxQXFJSUhJHjhyhcuXKFClSxKYsPj4ef3//635/O300Vo0aNYiMjCQuLo758+fTu3dv1q1bR2hoKE8++aS1Xt26dQkKCqJ58+YcPnyYm2++OcfnHDlypM0jwPj4eEJuNNmoX59U/5I8FzcpXaIDYOCGhTSGMJEO/Ig7V3UOCw9XsiMiBUryn3/a/YISyWtOf43l5eVF1apVadiwIePGjaN+/fpMmjQpw7qNGzcGsK5PEhgYyOnTp23qXPn92nkGrubt7W0dAXZlu2Hu7myoM4CThGDvthq4cYIKbKCJbcHGjTd+fhEREcmQ05Oda6WlpZGcnJxh2ZUFzq4MAQwLC2Pnzp3ExMRY66xcuRI/Pz9Cczr3zQ2IqhR2/UpAFEG2O375BZz7NlFERJxkxowZeoXlYE59jTVy5Ehat25NhQoVOH/+PLNmzWLt2rWsWLGCw4cPW/vvlCpVih07djB06FDuuece6tWrB8ADDzxAaGgoPXv2ZMKECURHR/Pqq68ycOBAvL298/x6gsIqwXdZqEeU7Y7du2HlSnjgAYfEJSIiUpg59clOTEwMvXr1okaNGjRv3pytW7eyYsUK7r//fry8vPjll1944IEHqFmzJsOGDaNLly4sWrTIery7uzuLFy/G3d2dsLAwHnvsMXr16mUzL09eatK3KuU5ae2MnJ5BCMdpwob0RePGOTQ2ERGRwsqpT3a+/PJLu2UhISGsW7fuum1UrFiRpUuX5mZYOebu482kGp/Qdf9bWEjDSJdLWmjBL7adk69YuxY2bIAmTdKXiYiISI65XJ+d/K7zQ+7Mpys3YTuc0Z9zAMygT8bz7QA8/jgkJDg6RBERkUJFyU5u69aNzizkKJVYQ1Nm0Z01NOUfSvMMUzBwowffsYnG6Y89dAiGDMnzkEVERAoyJTu5rXZtaNECd9Joyjq6M4emrMODNCbxHO1YRBJFac8iDpHBXEFffgn/TpooIiIFx9q1a7FYLMTGxjo1jjFjxtCgQQOnnNtZ90DJjiOMHJnhbg9SmUM3GrKNfyhDG5byD6XSV+zfH64aTi8iUpilpprdGmfPNn86eq3LPn36YLFYsFgseHp6UrlyZV588UWSkpIce+ICpmnTpgxxkbcVSnYcoVkzaNQow6JiJLKYdlTkKAepTkd+IIlrhsmfPQuvvZYHgYqIuLYFC6BSJfOv1UcfNX9WquT4B+CtWrUiKiqKP//8kw8//JBPP/2U0aNHO/ak4jBKdhzBYrH7dAcgkNMspQ3+xPIbd9OLr0m7dvWYL7+EvXsdHKiIiOtasAC6doWTJ233//WXud+RCY+3tzeBgYGEhITQsWNHWrRowcqVK63laWlpjBs3jsqVK1O0aFHq16/P/PnzbdpYunQp1atXp2jRojRr1oyjR4/alGf0OmnixIlUqlTJZt/06dOpXbs23t7eBAUFMWjQIGtZbGwsTzzxBGXKlMHPz4/77ruPP/74w+b48ePHU65cOYoXL06/fv2u+4TqyqumJUuWUK9ePYoUKcIdd9xhs7r7mTNn6N69OzfddBM+Pj7UrVuX2bNnW8v79OnDunXrmDRpkvUp2dXXHxERwW233YaPjw933nkn+/fvzzSmG6Vkx1EefNDu0x2AUPbyAx3x5BLzeJiXGG9bITU104RJRCS/MQy4cCFrW3w8PPtsxpPLX9n33HNmvay0dyOT1O/atYuNGzfi5eVl3Tdu3Di+/vprpk2bxu7duxk6dCiPPfaYdcqUEydO0LlzZ9q3b09kZCRPPPEEL730UrbPPXXqVAYOHMiTTz7Jzp07+emnn6hataq1/KGHHiImJoZly5YRERHBrbfeSvPmzTl79iwAc+fOZcyYMYwdO5Zt27YRFBTEJ598kqVzDx8+nPfff5+tW7dSpkwZ2rdvz+XLlwFzcc6GDRuyZMkSdu3axZNPPknPnj3ZsmULAJMmTSIsLIz+/fsTFRVFVFSUzRqUr7zyCu+//z7btm3Dw8ODxx9/PNv3JlsMMeLi4gzAiIuLy92Gt283DE9PwzD/P8tw+5ZHrb9OYUD6Ohs25G5MIiJ54OLFi8aePXuMixcvWvclJGT616FDt4SErMfeu3dvw93d3ShWrJjh7e1tAIabm5sxf/58wzAMIykpyfDx8TE2btxoc1y/fv2M7t27G4ZhGCNHjjRCQ0NtykeMGGEAxrlz5wzDMIzRo0cb9evXt6nz4YcfGhUrVrT+HhwcbLzyyisZxrlhwwbDz8/PSEpKstl/8803G59++qlhGIYRFhZmPPPMMzbljRs3Tnfeq61Zs8YAjDlz5lj3nTlzxihatKjxv//9z+5xbdu2NYYNG2b9/d577zWee+65DNv+5ZdfrPuWLFliADaflatl9Fm6Iqvf33qy40gNGsDYsZlW6cEs3uIVAAbzMYtoZ1vhqafg4kUHBSgiIhlp1qwZkZGRbN68md69e9O3b1+6dOkCmItRJyYmcv/99+Pr62vdvv76aw4fPgzA3r17rYtXXxEWlrX1E6+IiYnh1KlTNG/ePMPyP/74g4SEBEqVKmUTx5EjR3IljqvrlSxZkho1arD33+4VqampvPnmm9StW5eSJUvi6+vLihUrOH78eJbavrLsE/y33mWMAwfmOHUG5ULh+edh2TJYvdpulZcZy1Eq8QX96cYc1nEvtxFhFu7ZAy++CB9/nEcBi4g4ho9P1udNXb8e2rS5fr2lS+Gee7J27uwoVqyY9XXR9OnTqV+/Pl9++SX9+vUj4d+LWLJkCTfddJPNcdlZl9HNzQ3jmvdrV14TARQtWjTT4xMSEggKCmLt2rXpygICArIcR068++67TJo0iYkTJ1K3bl2KFSvGkCFDuHTpUpaO9/T0tP7ZYjH7rKal2Vtq6cbpyY6jubnBzJlQooTdKhbgE56hJctJpBjtWMxRKv5XYfJk8/9oEZF8zGKBYsWytj3wAJQvbx5jr62QELNeVtqz105WuLm58fLLL/Pqq69y8eJFQkND8fb25vjx41StWtVmu9IvpVatWtb+K1ds2rTJ5vcyZcoQHR1tk/BERkZa/1y8eHEqVarEqlWrMozr1ltvJTo6Gg8Pj3RxlC5d2hrH5s2bM43DnqvrnTt3jgMHDlCrVi0AfvvtNzp06MBjjz1G/fr1qVKlCgcOHLA53svLi1RHzxOQRUp28kL58td9neVJCnN5mPpEcppA2rCUcwT8V6FvXzh92rFxioi4CHd3mDTJ/PO1icqV3ydONOvlhYceegh3d3emTJlC8eLFeeGFFxg6dCgzZ87k8OHD/P7773z88cfMnDkTgKeffpqDBw8yfPhw9u/fz6xZs5gxY4ZNm02bNuXvv/9mwoQJHD58mClTprBs2TKbOmPGjOH999/no48+4uDBg9bzALRo0YKwsDA6duzIzz//zNGjR9m4cSOvvPIK27ZtA+C5555j+vTpfPXVVxw4cIDRo0eze/fuLF3zG2+8wapVq9i1axd9+vShdOnSdOzYEYBq1aqxcuVKNm7cyN69e3nqqac4fc13VKVKldi8eTNHjx7ln3/+ceiTm+vKtEdPIeGwDspXu3TJMKpXv24vupMEG+U5boBh3MsaIwmv/8pbtDCMlBTHxSgikksy61SaHd9/bxjly9v+VRkSYu53lN69exsdOnRIt3/cuHFGmTJljISEBCMtLc2YOHGiUaNGDcPT09MoU6aM0bJlS2PdunXW+osWLTKqVq1qeHt7G02aNDGmT59u00HZMAxj6tSpRkhIiFGsWDGjV69exttvv23TQdkwDGPatGnW8wQFBRmDBw+2lsXHxxuDBw82goODDU9PTyMkJMTo0aOHcfz4cWudt99+2yhdurTh6+tr9O7d23jxxRez1EF50aJFRu3atQ0vLy+jUaNGxh9//GGtc+bMGaNDhw6Gr6+vUbZsWePVV181evXqZXPf9u/fb9xxxx1G0aJFDcA4cuSIte2r78H27dut5RnJjQ7KFsO4kQF5BUN8fDz+/v7ExcXh5+fnuBMtWAD/dnDLzA7qcje/ch4/evAt39Dzv1l4xowBTWwlIi4uKSmJI0eOULlyZYoUKXJDbaWmwoYNEBUFQUHQpEnePdEpjNauXUuzZs04d+6cw/v+ZEVmn6Wsfn/rNVZe6tQJstALvh47+Z4ueHCZ73iM13jzv8LXX4dffnFgkCIirsXdHZo2he7dzZ9KdCS7lOzkJYvFHFWVhf9T7+cXPuNJAN7mVb6gn1lgGOac6ddOKSoiIiIZUrKT1xo2hFGjslS1LzN4jTcAeJpprOABs+Dvv6FdOzh/3lFRiohIIdW0aVMMw3CJV1i5RcmOM7z8Mtx5Z5aqvs5oevI1qXjQlflEUt8s+OMP6NYNUlIcGKiIiEj+p2THGTw84NtvoXjx61a1AF/wBPexigSK05YlnKC8Wbh0qbk4jPqYi4iL0hgYuVG58RlSsuMslSubkwVmgReX+Z4u1GYXp7iJtiwhjn97nX/yiWZXFhGXc2WG3MTERCdHIvndlc/Q1bMuZ5eGnpOHQ8+vZRjQpw98/XWWqh+jAnewiWiCuJ+fWUJbPEkxOzyvWAF21k8REXGGqKgoYmNjKVu2LD4+PtZlAUSywjAMEhMTiYmJISAgwLqG1tWy+v2tZAcnJjsAFy5Ao0bmGlhZ8Du3cA/ruYAvfZnOl/Qz5+ApWRK2bTOfGImIuADDMIiOjiY2NtbZoUg+FhAQQGBgYIbJspKdbHBqsgOwdy/cdhtk8XHvUlrTnkWk4c7rjGLUlXl46tWD334DX18HBisikj2pqak2C1yKZJWnpyfumUzXomQnG5ye7IDZYblnzyxX/5QneZpPAZhJL3rxjVnQuDH88AMEBjogSBEREdehGZTzm8ceg0GDslz9KT5jBOMB6MeXrKaZWbB5M9x+O/z+uyOiFBERyXeU7LiSDz+ENm2yXH0sL9ON2aTgSWcWsJtQs+DkSbj7bpg/30GBioiI5B9KdlyJhwfMmQP162epuhsGX9GXu9lAHAG0Zhmn+Le3+sWL8NBD8Mor5ip6IiIihZSSHVdTvDgsXgzBwVmqXoRkfqQDNdjHCSrQjsUkUOy/CmPHmk+LzpxxUMAiIiKuTcmOKypfHhYtgqJFs1S9JOdYShvKEMN2buUR/kcKV/Ve//lnc00u9eMREZFCSMmOq7r1VvjyyyxXr8IRFtOOoiSylLYMYjI2w+yOHTPX41q4MNdDFRERcWVKdlxZ9+4wfHiWqzdiK7PpjoU0PuVpJvCibYXkZHj4YViyJJcDFRERcV1KdlzduHHQsmWWq3fgJyYyBICXeIc5PGJbISUFHn0UDh7MxSBFRERcl5IdV+fuDrNnQ4MGWT7kWT5mKB8A0JuZrKeJbYX4eOjQARIScjFQERER16RkJz8oUQJ++QXuuSfLh7zHC3Tmey7hTUd+YB81bCvs3QshIRqlJSIiBZ6SnfyiVClYuRKeeCJL1d0w+JbHuINwzlGSNizlNGVtK8XGQtmyMHEiXLqU6yGLiIi4AiU7+YmXF3z2GUyaBG7X/09XlCR+4kFu5hBHqMKD/EQi1wxnT0uDoUOhbl1YscJBgYuIiDiPU5OdqVOnUq9ePfz8/PDz8yMsLIxly5ZZy5OSkhg4cCClSpXC19eXLl26cPr0aZs2jh8/Ttu2bfHx8aFs2bIMHz6clJSUvL6UvGOxwLPPwtKl4O9/3epl+IeltKEkZ9hCYx5lFqkZ/Wc/cABatTJHf2ltWBERKUCcmuyUL1+e8ePHExERwbZt27jvvvvo0KEDu3fvBmDo0KEsWrSIefPmsW7dOk6dOkXnzp2tx6emptK2bVsuXbrExo0bmTlzJjNmzGDUqFHOuqS807IlbNsGdepct2p1DvITD+JNEj/SkaF8iN105r334PXXczVUERERpzJcTIkSJYwvvvjCiI2NNTw9PY158+ZZy/bu3WsARnh4uGEYhrF06VLDzc3NiI6OttaZOnWq4efnZyQnJ9s9R1JSkhEXF2fdTpw4YQBGXFyc4y7MURISDKN7d8Mwn8dkus2lq/XXDxhiv67FYhirVjn7ykRERDIVFxeXpe9vl+mzk5qaypw5c7hw4QJhYWFERERw+fJlWrRoYa1Ts2ZNKlSoQHh4OADh4eHUrVuXcuXKWeu0bNmS+Ph469OhjIwbNw5/f3/rFhIS4rgLc7RixeC778xOxtfxEPN5lxcAGMb7fE/njCsaBvTqBWfP5mKgIiIizuH0ZGfnzp34+vri7e3N008/zcKFCwkNDSU6OhovLy8CAgJs6pcrV47o6GgAoqOjbRKdK+VXyuwZOXIkcXFx1u3EiRO5e1F5zWKB556DLLy+G8b7PMMUDNx4jG8J546MK/71F3TqpP47IiKS7zk92alRowaRkZFs3ryZAQMG0Lt3b/bs2ePQc3p7e1s7RV/ZCoTRo80VzjNhASbxHO1YRBJFeZCfOMTNGVdevx7uv9+chFBERCSfcnqy4+XlRdWqVWnYsCHjxo2jfv36TJo0icDAQC5dukRsbKxN/dOnTxMYGAhAYGBgutFZV36/UqdQcXODb7+FKlUyreZBKnPoRkO28Q9laM0y/qFUxpVXrTIXJY2IcEDAIiIijuf0ZOdaaWlpJCcn07BhQzw9PVm1apW1bP/+/Rw/fpywsDAAwsLC2LlzJzExMdY6K1euxM/Pj9DQ0DyP3SWUKAGLFpmTEGaiGIksph0VOcohqtGBH7lIkYwrHz4MYWEwZYoDAhYREXEspyY7I0eOZP369Rw9epSdO3cycuRI1q5dS48ePfD396dfv348//zzrFmzhoiICPr27UtYWBh33GH2M3nggQcIDQ2lZ8+e/PHHH6xYsYJXX32VgQMH4u3t7cxLc67QUPMVVP36mVYL5DTLaE0A59jIXfRmJmlYMq58+TIMGmT2C1I/HhERyUecmuzExMTQq1cvatSoQfPmzdm6dSsrVqzg/vvvB+DDDz+kXbt2dOnShXvuuYfAwEAWLFhgPd7d3Z3Fixfj7u5OWFgYjz32GL169eKNN95w1iW5jtBQ2LoVPvrIfNpjRy328QMd8eQS83iYEbyTebtvvgnTpuVysCIiIo5jMQz9Mz0+Ph5/f3/i4uIKTmflq509CwMGwNy5dqt8x6M8xncATGYgA/nEfnseHmZfnmwsTCoiIpLbsvr97XJ9dsQBSpaE//0PXn7ZbpUezOItXgHgWT5iEe3st5eSAl27wvHjuR2piIhIrlOyU5i89RZ07Gi3+GXG8gSfk4Y73ZjDNhrab+vvv815eBITcz9OERGRXKRkpzCxWODzzyEoKONi4BOeoSXLSaQY7VjMUSrab+/33+Hxx9VhWUREXJqSncKmdGlzxXQ7nZY9SWEeD1GfSE4TSBuWco4A++39739aOFRERFyakp3CqEEDWLkSbropw+LiJLCEtpTnBHsJpRMLScbLfnuvvw5z5jgmVhERkRukZKewatgQIiOhbdsMi2/iFEtoS3HiWUdTHme6/Tl4APr2hS1bHBOriIjIDVCyU5iVLg0//QTvvWcOJ79GPXbyPV3w4DKz6MFrvGm/raQk6NwZzpxxYMAiIiLZp2SnsHNzg2HDYPVqyGDW6fv5hc/pD8BYXuFznrDf1l9/Qb9+6rAsIiIuRcmOmJo0gU8/zbCoDzMZhdkJeQBTWU5L++38+CNMneqICEVERHJEyY78p3dveO65DIvGMIZezCQVDx5iHpFksu7W889rlXQREXEZSnbE1nvvwX33pdttAT6nP/exigSK05YlnKB8xm0kJ0PTpuYQdxERESdTsiO2PDxg3jyoVi1dkReX+Z4u1GYXp7iJNiwlDjtrkSQkQPv2MGWKgwMWERHJnJIdSa9kSVi8GAIC0hUFEMdS2hDEKXZRl67M5zLpR3IBkJYGgwbBkCGQmurQkEVEROxRsiMZq14d5s8Hd/d0RRU4wRLaUowEfuF+nuQzMh1/NWkS9OwJly87LFwRERF7lOyIfc2bw0cfZVh0C5HM5WHcSWEGfXmT1zJva/Zsc+HQixcdEKiIiIh9SnYkcwMGQNeuGRa1YRlTGAjAaN5gJr0yb2vJEmjVCuLjcztKERERu5TsSOYsFvjsM6hQIcPip/iMEYwH4Am+YBXpR3LZWL8ewsJg69bcjlRERCRDSnbk+kqUgFmzzNmWMzCWl+nGbFLwpDML2EXtzNvbswfuuANeeslcZkJERMSBlOxI1tx1F7z9doZFbhjMoA9NWE88/rRhKacIyry9tDR45x245RYID3dAwCIiIiYlO5J1I0bA0KEZFnlziR/oSA32cYIKtGMxCRS7fpv79sHdd8MHH2hNLRERcQglO5J1Fgu8/745y7LFkq64JOdYShvKEMN2buVh5pJC+qHr6aSlmYuRjhyphEdERHKdkh3JHovFTEy+/x6KFk1XXIUjLKYdRUlkGW0YyJTM5+C52jvvmGtzpaXlasgiIlK4KdmRnOnUyRxZFRiYrqgRW5lNdyyk8RlP8Q4jst7uxx+bbavjsoiI5BIlO5Jzt90GmzZluI5WB35iEuYK6iMZz2y6Zb3dn34yh7rPnKllJkRE5IYp2ZEbU7EibNgA9eqlKxrMZIbyAQB9mMF6mmS93b//hj59oG5dc9mKlJRcClhERAobJTty48qVg7VrzckCr/EeL9CZ77mENx35gX3UyF7be/fCQw9B+fJmf57Nm9WJWUREskXJjuSOEiVg5Upo2dJmtxsG3/IYdxDOOUrSmmWcpmz22z992lyn6447oGpVeO012L07l4IXEZGCzGIY+mdyfHw8/v7+xMXF4efn5+xw8rfUVHjzTXMCwqtePf1NacII5zBVuZ0t/EJzfqchUQQRRBRN2IA7ORiFVbs2PPywudWsmYsXIiIiri6r399KdlCy4xDbt0PfvvDHH9ZdB6lKGOGcoTRFuEgS/w1dL88JJvEcnVmY83PWrQv33mu+Vitb9r+fgYEQEgIeHjdyRSIi4mKU7GSDkh0HuXQJxo83n/T8+5RnLC/xCmMB20kJLf8+1ZlP1xtLeOzx9jZHj911l7ndeSeULp375xERkTyjZCcblOw42LZt0Lo1qf+cpRJHOUl5rk12wEx4ynOSI1TO2Sut7KpRw0x6WrSA+++HMmUcf04REck1SnayQclOHti9m7VNXqPZuQXXrXorETRiC9U4aN2q8CdeXHZcfBaL+eSnVStza9RIr71ERFyckp1sULKTN2Z/GMWjz19nNXQ73EilIsdsEqArWyWO4kkuz8Pj5gZ+fuDvb7v5+ppbsWK2m4+P+aqsSBHz55U/Fy1qTpAYGJjhemIiIpJzWf3+1j9dJc8E3ZK1RGcE4/EgxSalSaA4R6jCEarwM7bD291JoTJHqMqhdIlQRY7hQQ5mYU5Lg9hYc8sNZcpAs2bQvLm5Vami5EdEJI/oyQ56spNXUlOhUiX46y8Dw8h6nx0DOE25DJ7pVOMQVUmkmN1zenKJyhzJ8IlQCCfypm9QRipUMJOfkBAoVQpKlvzvZ0CA+UTo2idF7llYQV5EpBDRa6xsULKTdxYsgK5dzT9f/cnL6WgsAzhFcIaJ0GFuthnefi0vkrmZw1TjYLqnQuU5iVvW12vPGx4eGb8q8/Y2X7lVqmQu21G/vrmpw7WIFHD5ItkZN24cCxYsYN++fRQtWpQ777yTd955hxo1/ltSoGnTpqxbt87muKeeeopp06ZZfz9+/DgDBgxgzZo1+Pr60rt3b8aNG4dHFjuYKtnJWwsWmCs/nDz5376Qon8z8eJTuTrsPA0Lf3GT3UToEt52jy3CRWsidO0WzKkMxpK5oKAgM+mpW9cceVa9uvmzTBm9QhORAiFfJDutWrWiW7du3H777aSkpPDyyy+za9cu9uzZQ7Fi5quJpk2bUr16dd544w3rcT4+PtaLSk1NpUGDBgQGBvLuu+8SFRVFr1696N+/P2PHjs1SHEp28l5qqrl+aFSU+Z3cpAm4R2yBCRPMVc8vO3DkFZCKGycIyTAR+pMqpOBp91gfLtg8Cbr6z4FEu34i5O9vJj41a8Itt0DDhubP4sWdHZmISLbki2TnWn///Tdly5Zl3bp13HPPPYCZ7DRo0ICJEydmeMyyZcto164dp06doly5cgBMmzaNESNG8Pfff+Pl5ZXumOTkZJKTk62/x8fHExISomTHVZw5A99/D7NmwTVP9fJCCu4co6K1T9DVidARKpOaSb9+X85n2FG6Ggcpw9+umwhZLGYC1LChOQS/UyfztZiIiAvLl8nOoUOHqFatGjt37qROnTqAmezs3r0bwzAIDAykffv2vPbaa/j4+AAwatQofvrpJyIjI63tHDlyhCpVqvD7779zyy23pDvPmDFjeP3119PtV7Ljgk6cgDlzzMTnqv/GznIZD45SKcMnQseoSBr2OxH7EZfuqCuJUSnOuF4i1LQpjB5t/hQRcUH5LtlJS0vjwQcfJDY2ll9//dW6/7PPPqNixYoEBwezY8cORowYQaNGjViwwJyc7sknn+TYsWOsWLHCekxiYiLFihVj6dKltG7dOt259GQnnzpwAObNg7lzYccOZ0eTTjJeHKFyhonQCUIwcLN7bADnMnwaVI2DlCA27y4iIw8+aL5evKovnYiIK8h3yc6AAQNYtmwZv/76K+XLl7dbb/Xq1TRv3pxDhw5x88035yjZuZb67ORD+/aZic/335uJj2t8jO1Kwps/qZJhOnOSkEyPLcU/GSZBVTmEP/G5El8qbmygif1V6D084OmnzSc9WlNMRFxEvppUcNCgQSxevJj169dnmugANG7cGMCa7AQGBrJlyxabOqdPnwYgMDDQMQGL89WsCa+9Zm7nz5tPfWJizO306f9+7t1rvv5KzcHEgrmoCMmEspdQ9qYrS6Qoh7k5w0QoimDOUJozlGYTYemOLUOM3SdCvlzIUmwL6MRzTLJJutKtQp+SApMnw9dfw1tvwcCB5izTIiL5gFOTHcMwGDx4MAsXLmTt2rVUrlz5usdc6ZsTFGTOxhsWFsbbb79NTEwMZcuWBWDlypX4+fkRGhrqsNjFhRQvbnastSchAbZsgd9+M7eNG80EyUX4cJG67KIuu9KVJVDM2kn62s7Spwnkb8ryN2XZyF3pjg0kyu4TIR8uAmai05X56WYU+oub6Mr89PMexcfDs8+arxKnT4dq1XLzVoiIOIRTX2M988wzzJo1ix9//NFmbh1/f3+KFi3K4cOHmTVrFm3atKFUqVLs2LGDoUOHUr58eevcO1eGngcHBzNhwgSio6Pp2bMnTzzxhIaeS8YuX4bNm2H5cnOLiHB2RDkST/F0CdCV7R8yn1AwmL+oykEiuI0LFCNHq9AXKQJvv21OmqTZnUXECfJFnx2LnYnNvvrqK/r06cOJEyd47LHH2LVrFxcuXCAkJIROnTrx6quv2lzUsWPHGDBgAGvXrqVYsWL07t2b8ePHa1JByZqYGPj5Z1i7FnbvNl9/xcWZm5Nff+VULP52Xm5V4xwls9XWGprSlEymAAgLg6++UgdmEclz+SLZcRVKdiRDhgGJif8lPufPw4UL6beEBEhKguRk25+xseZrs7//dvaV2DhLCQ5Sja/pxScMvG79WXSnO3Myr+TjA5MmQb9+mp1ZRPJMvuqgLOKSLBYoVszcgoNz1oZhwK5dsGoVrF5tPj1ycn+hkpyjMVu4SNEsJTveJF2/0cRE6N/ffC342WfmgqYiIi5CT3bQkx3JQykp8OefcPQonD1rzhZ99c+zZ83E4dqnRFf/TE6GS5duOJRU3KjEUf7iJjtzABmABX/O8Q4v0Z/Ps7Y4avny8O23cO+9NxyjiEhm9BorG5TsSL6TlmYmPMnJZqK0cyf88Ye5RUaaCVUWXBmNBdgkPBbSMIDKHOUIVQBozCam8TQN+CNrMfbrB2PHwr+jJEVEcpuSnWxQsiMFTny8OfHigQPmtn//f39OTLSpmtE8OyEcZyJDeJCf+IRneJW3OI8fbqTyHJN4ndEUJ+H6cfj7w5tvwoAB5sSEIiK5SMlONijZkUIjLQ2OHTOH21/ZVq687gzKpwhiKB8yl0cAuImT/046uCBra3rVrQtTppjL24uI5BIlO9mgZEcKNcOAb74x58w5cCDTqit4gGf4hD+5GYA2LGEyg6jM0eufx2KBESPMGZg1L4+I5IKsfn9rvneRws5igV69zFFjH30EpUrZrdqSn9lFHV7jDTy5xFLaEsoexjKSS3hmfh7DgPHjoVMnp49IE5HCRcmOiJg8PWHwYDh0CJ56ym61oiTxBqPZSV3uYxVJFOUVxtKASNaShRFYixbBnXeaI9JERPKAkh0RsRUQANOmwS+/QKVKdqvV4AC/0IJv6UFZTrOXUJqxlt7MIOY6y1Wwaxfcfjv8+muuhi4ikhElOyKSsebNzSHtA+1PPGgBejCLfdTkaaZiIY2v6U1N9vEZ/UnLrPvyP/+Y55hzndmZRURukJIdEbHP1xcmTzZngL7pJrvVShDLVJ4hnDAasJ1zlOQpPuNufuUP6tlv/9Il6N4dJkww+/SIiDiAkh0Rub777jMnLOzYMdNqjdnCVm7nQ4bgy3nCuZOGRDCM90igmP0DR4yAQYPy7cKrIuLalOyISNaUKgULFsDUqVCkiN1qHqQyhEnsoyZdmUcqHnzAMGqxl4V0tL/gxCefQOfO6SY9FBG5UUp2RCTrLBZ4+mlzMsJGjTKtehOnmMfDLKU1lfmTk4TQmYW0ZxFHqJTxQT/9BC1amGuEiYjkEiU7IpJ9oaEQHg5ffAGlS2datTXL2UUdXuEtPLnEEtpRm92MZ0TGc/OEh8Pdd8OJEw4KXkQKGyU7IpIzbm7mYp8HDpjz87jZ/+vEh4u8xWv8QX2asoaL+DCS8dzCdtaTwRISe/eac/Hs2ePACxCRwkLJjojcmBIlzJmXt2+H2rUzrVqLfazmPr6mJ2WIYQ+1uZf19GU6f3PNE6KTJ81XZZMmqeOyiNwQJTsikjvq1YONG6Ft20yrWYCefMs+avIU0wCYQV9qso8v6Gc7N8+FCzBkCNx1lzkRoYhIDijZEZHc4+cHP/4IL7xw3aolOcc0BhDOHdQnkrOUoj9f0IQN7KSObeXNm+HWW2HYMDhyxEHBi0hBpWRHRHKXuzu8+y5Mnw4eHtetfgeb2cZtfMBQipHARu7iFrYznAm2c/NcvgwffAA33wzt28Py5ZCW5sALEZGCQsmOiDhG376wdCkUL37dqh6kMpSJ7KUWnfmeVDx4j+GEsocfedC2smHA4sXQujXUqGHO8Jyc7KCLEJGCQMmOiDjO/ffDhg0QHJyl6iGc5Hu6spi2VOIIJ6hAR37kQX7kGBXSH3DokDkSrE4dWL8+l4MXkYJCyY6IOFb9+rBpk5mQZFFblrKb2oxkLJ5cYhEPEsoeJjCcy2TwauzQIbj3XjPxSUjIxeBFpCBQsiMijhcSYj7hueeeLB/iw0XG8gqRNOAe1pFIMUYwgVvYzgbuzvigyZPNUWGrV+dS4CJSECjZEZG8ERAAK1ZAp07ZOiyUvaylKTPoTWn+Zjd1uIcNPM6X/EOp9AccOQLNm8PAgVpnS0QAJTsikpeKFIF58+DJJ7N1mAXozdfsoyb9+QyAr3icGuxnOn1t5+a54pNP4JZbYOvWXAhcRPIzJTsikrfc3WHaNHj99WwfWoqzfMZT/Mad1GUHZylFP6ZzL+vYRQazNx84YC478dZbkJKSC8GLSH6kZEdE8p7FAqNGmUPTy5fP9uF3Ek4EDXmPYRQjgV9pwi1sZwTjuYCPbeWUFHjtNbO/0J9/5tIFiEh+omRHRJyndWvYvRueeSbbh3qSwjA+YA+hdGQhKXgygRGEsoefaJ/+gPBwuO02WLkyFwIXkfxEyY6IOJefH0yZYo7WqlEj24dX4AQL6cxPtKciRzlORTrwEx1ZyHFCbCufOwetWsF775mTE4pIoaBkR0Rcw913Q2QkvPFGlmZdvlZ7FrOb2rzEODy4zI90pBZ7eZcXbOfmSUuD4cPhjjtg//7ci19EXJaSHRFxHUWKmP1rTpyASZOgevVsHV6MRMbxMpE0oAnrSaQYL/Iut/I7v3GnbeUtW6BmTWjaFL78EmJjc+0yRMS1WAxDz3Lj4+Px9/cnLi4OPz8/Z4cjIlekpcGqVeZrrkWLsrXwpwHMpDcv8B5nKA1AP77gHUZQirPpD/D2NvsQtW0LbdpkeYkLEXGerH5/K9lByY5IvrBnDzz+OGzenK3DzlCSEbzDlzwBQCn+4T1eoDczM5qd5z8NGvyX+DRubA6ZFxGXktXvb73GEpH8ITQUfvvN7FxcpEiWDyvFWb6gP79yF3XYyRlK05cZ3Ms6dhNq/8DISHj7bbjrLrj5Znj/fbh48cavQ0TynFOTnXHjxnH77bdTvHhxypYtS8eOHdl/TYfBpKQkBg4cSKlSpfD19aVLly6cPn3aps7x48dp27YtPj4+lC1bluHDh5OiCcRECh53dxg2DP74w0xCsuEuNvI7tzKB4fhwgQ3cQwMiGclYEima+cHHjsELL0Dt2rB48Q1cgIg4g1OTnXXr1jFw4EA2bdrEypUruXz5Mg888AAXLlyw1hk6dCiLFi1i3rx5rFu3jlOnTtG5c2dreWpqKm3btuXSpUts3LiRmTNnMmPGDEaNGuWMSxKRvFC9OqxbB+PGgadnlg/zJIXhvMceQunAD6TgyXhGEsoeFtP2+g0cOQLt20PHjuafRSR/MFxITEyMARjr1q0zDMMwYmNjDU9PT2PevHnWOnv37jUAIzw83DAMw1i6dKnh5uZmREdHW+tMnTrV8PPzM5KTk7N03ri4OAMw4uLicvFqRCRPREQYRq1ahmHOnJOt7UfaGxU4at3Vie+N45TPehvNmxvGxx8bxp49hpGW5uw7IVLoZPX726X67MTFxQFQsmRJACIiIrh8+TItWrSw1qlZsyYVKlQgPDwcgPDwcOrWrUu5cuWsdVq2bEl8fDy7d+/O8DzJycnEx8fbbCKST916K0REwODB2T70QRaxh1Be5B08uMxCOlOLvbzP87Zz89izapV53tBQc9mLnj3h++8hOTkHFyIijuIyyU5aWhpDhgzhrrvuok6dOgBER0fj5eVFQECATd1y5coRHR1trXN1onOl/EpZRsaNG4e/v791CwkJybCeiOQTRYvCRx/B3Lng43P9+lcpRiLv8BK/cyt38SsX8OUF3uc2thHOHVlv6NQp+PZb6NoVKleGiRMhMTF71yEiDuEyyc7AgQPZtWsXc+bMcfi5Ro4cSVxcnHU7ceKEw88pInngoYdg40aoVCnbh9ZlF+u5hy95nJKcYQf1uZNwnuRTzlIie41FRcHQoWbS8+67kJCQ7XhEJPe4RLIzaNAgFi9ezJo1ayh/1QrIgYGBXLp0idhrZjY9ffo0gYGB1jrXjs668vuVOtfy9vbGz8/PZhORAqJ+fdi2De67L9uHumHwOF+xnxo8zpcAfM6T1GA/X9OTbE9KFhMDL75oJl/jxsFVgy9EJO9kKdm5tn9LVrasMAyDQYMGsXDhQlavXk3lypVtyhs2bIinpyerVq2y7tu/fz/Hjx8nLCwMgLCwMHbu3ElMTIy1zsqVK/Hz8yM0NJM5NESk4CpVClasMJ+q5OAfM6U5w5c8wXqaUJtd/EMZevM1zVjDXmpmP54zZ+Dll6FqVfj0U7h8OfttiEiOZWkGZTc3NyyWTOcatW3UYuHAgQNUqVIl03rPPPMMs2bN4scff6TGVasd+/v7U7SoOe/FgAEDWLp0KTNmzMDPz4/B/3ZC3LhxI2AOPW/QoAHBwcFMmDCB6OhoevbsyRNPPMHYsWOzFK9mUBYpwP7+Gz75xOxPc+hQtg+/hCcfMpTXGc1FfPDkEi/wHq/yFj7kcJLB6tVh7Fjo3Bmy8XeriNjK1eUi3Nzc+P77762jpDJjGAZt2rRh165d10127CVQX331FX369AHMSQWHDRvG7NmzSU5OpmXLlnzyySc2r6iOHTvGgAEDWLt2LcWKFaN3796MHz8eD48sjKZAyY5IoWAY5uKf334Lc+bAP/9k6/CjVGQwH7OY9gBU4ghTGEgbluU8psaNzY7Md2SjI7SIWOVqslO5cmW2bdtGqVKlsnTyOnXqsGzZsnwzyknJjkghc/kyLF8OCxbA0qVm35osMIAf6cCzfMQJKgDQhflMZAjl+StnsVgs8Pzz8NZb2VoGQ0S0EGi2KNkRKcTS0uD332HJEjPx2brVfAqUiQSK8Tqj+ZChpOKBL+d5g1EM5mM8SM1ZHLVqwddfw2235ex4kUJIC4GKiGSFm5uZYIweba6ofuCAudJ5Jny5wLu8yO/cShgbSaA4z/Mht7GNTTTOWRx795qvs8aMUQdmkVyWoyc7W7duZc2aNcTExJCWlmZT9sEHH+RacHlFT3ZExIZhwA8/wHPPwXXm4UrDwnQe50UmcI6SWEjjST5jHCMpQWzOzl+7Nnz8MTRrlrPjRQoJh73GGjt2LK+++io1atSgXLlyNp2MLRYLq1evznnUTqJkR0QydOECjB8PU6bAuXOZVv2b0rzIBGbQF4AyxPABz9OD78jxeKuHHoL33oMKFXLagkiB5rBkp1y5crzzzjvW0VIFgZIdEclUYqLZmfnnn831sE6dslt1HfcwgKnsxZznqxmr+YRnqMn+nJ27aFF46SUYPtz8s4hYOazPjpubG3fdddcNBScikq/4+MBjj5kdiE+ehH37zKc9nTqBp6dN1XtZTyQNGMdLFCWRNdxHPXbwKm9ykRyMtrp40exPFBoKP/543c7TIpJetpOdoUOHMmXKFEfEIiLi+iwWqFEDnnnGfNpz6JD5Zy8vaxUvLvMS77Cb2rRhCZfx4m1epQ67WE7LnJ336FHo2BFat4b9OXxKJFJIZfs1VlpaGm3btuXAgQOEhobiec2/ahYsWJCrAeYFvcYSkRv2118wYQJ89hkkJVl3G8BCOvEckziJOfdYV+YxkSHchP3XYZny9DQXGn3tNfD1zYXgRfInh73GevbZZ1mzZg3Vq1enVKlS+Pv722wiIoXSTTfBpEnmk57+/c0h7YAF6MxC9hDK87yPOynM5yFqso9JPEsK7tk/1+XLZmLVoAFERubmVYgUSNl+slO8eHHmzJlD27ZtHRVTntOTHRHJdXv3mot//vCDze4/qMfTTGMT5mLGDdjOpzxFI7bm7DxFi8JXX8Ejj9xgwCL5j8Oe7JQsWZKbb775hoITESnwatWChQvht9/g1lutu+uzg9+4i095khKcJZJbuINNPMMUYsnB0/GLF6FbN3PEVmoOZ28WKeCyneyMGTOG0aNHk5iY6Ih4REQKljvvhE2b4PXX4d/Fid0weJLP2UdNejETAzem8gw12M93PEqOxlu98w60b3/d+YBECqNsv8a65ZZbOHz4MIZhUKlSpXQdlH///fdcDTAv6DWWiOSJ33+HXr1g926b3WtoyjN8wj5qAXAfq/iEZ6jBgeyfo2JFc1V3raQuhUBWv789sttwx44dbyQuEZHC69ZbISICRo2C99+3vnZqxlr+oD7v8QJv8hqraU49djCCdxjJOIqSdJ2Gr3LsGDRpAm+/DS+8YO0oLVKYadVz9GRHRJxg50549llYu9Zm959UZhCTWYa5GOnNHGIKA2nJz9k/R6tWMHMmlC2bCwGLuB6tei4i4srq1oXVq2HuXAgJse6uwhGW0Jb5dCGYvzhMVVqxgkeYwymCsneO5cvNRUVnzdLMy1KoZSnZKVmyJP/880+WG61QoQLHjh3LcVAiIoWCxWIu9rl3L7z6Knh7m7uBLixgHzUZwoe4kcpcHqEm+/iIwaRm59+p//wDPXpAu3Zw/LhjrkPExWXpNZabmxszZ87M8qSB3bt3Z+fOnVSpUuWGA8wLeo0lIi7hzz/NmZF/+slm93Ya8DTT2EJjAG4lgmk8ze1sy177xYrBuHEwcKD68kiBkKurnrvl4H+KQ4cOKdkREcmJ5cvhuefgwH+jsVJx43P6M5JxxFICC2k8wye8xasEEJe99h94AGbPhpIlczlwkbyVq3120tLSsr3ll0RHRMTltGpldmB+6y3rExh30niaT9lHTR7jGwzcmMIgarKP2XTL3tw8P/8Mt99unkOkENBzTBERV+TlBa+8AitWQIkS1t3liOEberGK+6jOfk4TyKPM5gF+5iBVs97+n39CWBh8/70DghdxLUp2RERcWYsWsG0b1Kljs/s+1rCDerzJq3iTxC/cTx12MYbRJOGdtbYvXICuXc2kKiXFAcGLuAYlOyIirq5KFQgPNxOTq3hziVd5m93UpiXLuYQ3rzOGuuxkJS2y3v7YsXDXXXDwYC4HLuIaspzsnDp1ypFxiIhIZnx9zTl5Jk82X3Fd5Wb+ZBmtmctDBHGKQ1TjAVbSnVlEEZi19rdsgQYN4LPPNCePFDhZTnZq167NrFmzHBmLiIhkxmIxh41v2gTVqtkWAQ8xn33U5Dkm4kYqc+hOTfYxmYFZm5snMRGeego6dIC//nLMNYg4QZaTnbfffpunnnqKhx56iLNnzzoyJhERycwtt5hrbPXoka7Ij/NMZChbuZ3b2UI8/gxmMo3ZTAS3Zq39RYugZk344AO4fDmXgxfJe1lOdp555hl27NjBmTNnCA0NZdGiRY6MS0REMlO8OHzzDXz9tc1orStuZTvhhDGFZ/AnlghuoxFbGMxHxJGF+cQSEmDYMHPx0g0bHHABInknRwuBTp48maFDh1KrVi08PGwXTv/9999zLbi8okkFRSRfO33anITwf//LsDiacgzjfWZhPgkKJIqJDOFh5mLJ6jl69YJ339WiouJScnUG5asdO3aMvn37smvXLp566ql0yc7o0aNzFrETKdkRkQLhp5/gmWfs9rdZxX0MYCoHqQ7A/fzMJzxDVQ5nrf2AAHj7bbNfj7t7LgUtknMOSXY+//xzhg0bRosWLfj0008pU6ZMrgTrbEp2RKTAiI83k5E5czIsTsKbCbzIWF4mmSJ4k8TLjGUE7+DNpaydo2FDmDrVnIVZxIlydbkIgFatWjFixAgmT57MggULCkyiIyJSoPj5waxZ8M475uitaxQhmVG8yS7qcD8/k0wRRvMGddnJLzTP2jkiIqBxYxgwwEyuRFxclpOd1NRUduzYQa9evRwZj4iI3CiLBV58EZYuNV89ZaAqh1lBS+bwCIFEcZDq3M8v9OBboil3/XMYBkybBvXqwZo1uRu/SC7LcrKzcuVKypcv78hYREQkN7VqZU4WeM1SE1dYgEeYyz5qMpiPcCOVWfSgJvv4hAFZm5vn2DG47z6zg3RiYu7GL5JLtFyEiEhBVq0abN0KQ4bYreJPPB/xHJtpTEO2EUcAA/mEMML5nVuydp6PPjLn/9m0KXfiFslFSnZERAq6IkXgww9h5UoIDrZb7TYi2ExjJjMQP+LYSiNuZyvPMZF4il//PAcOmGtsjR8PaWm5eAEiN0bJjohIYdGiBezcCQ8/bLeKO2kM5BP2UZNuzCYNdz7iOWqyj7k8xHWH76alwciR5pITmm1fXIRTk53169fTvn17goODsVgs/PDDDzblffr0wWKx2GytWrWyqXP27Fl69OiBn58fAQEB9OvXj4SEhDy8ChGRfKRkSXNY+pw5EBRkt1oQ0czmUX7mfqpykCiCeYS5tGYZh6ly/fMsXmzOvrx1ay4GL5IzTk12Lly4QP369ZkyZYrdOq1atSIqKsq6zZ4926a8R48e7N69m5UrV7J48WLWr1/Pk08+6ejQRUTyL4sFHnkE9u2DoUMznSDwfn5hJ3UZzRi8SGYFrajDLt7iFZLxsnscYHZevvtuc9SWiBPlaLkIR7BYLCxcuJCOHTta9/Xp04fY2Nh0T3yu2Lt3L6GhoWzdupXbbrsNgOXLl9OmTRtOnjxJcCbvpq+mSQVFpFDbscOcefm33zKtdoBqDGQKv3A/ADXYxyc8w31kYej5s8+aC4tq5mXJRbk+qaCzrF27lrJly1KjRg0GDBjAmTNnrGXh4eEEBARYEx2AFi1a4ObmxubNm+22mZycTHx8vM0mIlJo1asH69fDV19BJhPGVucgP/MAs+lGOaLZT02as5qefM1prrNm1kcfQceO5gKjInnMpZOdVq1a8fXXX7Nq1Sreeecd1q1bR+vWrUlNTQUgOjqastcsSufh4UHJkiWJjo622+64cePw9/e3biEhIQ69DhERl+fmBn36wP795szIGcy+DObcPN34H/uoyUAmYyGNb+lJTfYxjadIy2xp0cWLoUkTOHnSIZcgYo9LJzvdunXjwQcfpG7dunTs2JHFixezdetW1q5de0Ptjhw5kri4OOt24sSJ3AlYRCS/K1ECPvkENm+Gq56aXyuAOCYzmM005lYiiKUEA5hGGOFsp4H99iMjzfl45s41Z2EWyQMunexcq0qVKpQuXZpDhw4BEBgYSExMjE2dlJQUzp49S2BgoN12vL298fPzs9lEROQqt99uThA4caI5T4+9amxjC434iMEUJ54tNOY2tjGUDziPb8YH/fOP2UG6a1c4fdox8YtcJV8lOydPnuTMmTME/TtcMiwsjNjYWCIiIqx1Vq9eTVpaGo0bN3ZWmCIiBYO7u7kMRGSkufCnvWqkMZjJ7KMmjzCHNNyZyFBqsZf5dLE/N8+CBRAaai5cqqc84kBOTXYSEhKIjIwkMjISgCNHjhAZGcnx48dJSEhg+PDhbNq0iaNHj7Jq1So6dOhA1apVadmyJQC1atWiVatW9O/fny1btvDbb78xaNAgunXrluWRWCIich01asCvv8LYseDpabdaMFHMoTvLacnNHOIvyvMQ82nLEv6kcsYHnT0LPXrAE0/ApUsOugAp9AwnWrNmjQGk23r37m0kJiYaDzzwgFGmTBnD09PTqFixotG/f38jOjrapo0zZ84Y3bt3N3x9fQ0/Pz+jb9++xvnz57MVR1xcnAEYcXFxuXl5IiIFT2SkYVSvbhjmsxi7WyJFjNd43fAiyQDDKEKi8RYvG0l42T+ubVvDuHjR2Vco+UhWv79dZp4dZ9I8OyIi2RAfD/37m52Mr2M/1XmGT1hNcwBqspepDKAp6zI+oHlz+PFHKFYsNyOWAqrAzLMjIiIuxs/PXG7i448zfa0FUIMD/EILvuNRynKafdSiGWvpxUxiyGBOn1WroFUrM6ESySVKdkREJPssFhg0CDZsgExGv4I5N8+jzGYfNRnAJ1hI4xt6UZN9fEb/9HPz/PqruWjpP/84Ln4pVJTsiIhIzjVubM7JU7fudauWIJZPGMgm7uAWfuccJXmKz7iL3/iDeraVt24119U6dsxBgUthomRHRERuTIUK5tOYVq2yVL0RW9lCIybyHMWJZxNhNCSCYbxnOzfP/v1w552wc6eDApfCQsmOiIjcOD8/WLTIXFA0CzxI5Tk+Yi+1eIi5pOLBBwwjlD0soNN/c/OcOmUuMbEmC4uNitihZEdERHKHhwdMmQLffmsuO5EFN3GKuTzCUlpTmT85SQhdWEB7FnGESmaluDhzlNbIkZqLR3JEyY6IiOSuHj1g927o0CHLh7RmObupzau8iSeXWEI7arObcbzEJTzBMEgdP4G1tQcy+92TrF0L/64JLXJdmmcHzbMjIuIQhmEOUR80yJwpOYv2UYMBTGUtzQCoxR66M4vPeIqThFjrlS9vMGmShc6dcz1yySey+v2tZAclOyIiDhUVBS1bZqujsQF8Rw+e5wP+puxVe/8bpm4hDSwW5s9XwlNYaVJBERFxDUFBZgfjhg2zfIgFeIzv2EMtipHAtYkOgIEbGAZDnkggNaXQ/7tdMqFkR0REHK9UKXN25DvvzNZhu6jLBXy5NtG5wsCNE+d82XD3SPMJkkgGlOyIiEje8PeHFSvMkVVZFEVQ1uptPgYNGkB4eA6Dk4JMyY6IiOQdX19YsgQefjhL1YPI2tOaIKIgJgaaNcvSAqVSuCjZERGRvOXtDbNnm6O0rqMJGyjPCbMzcoYMyhFFEzaYvyYnwyOPwNix5mgwEZTsiIiIM7i5wUcfwdtvZ1rNnTQm8RxABgmP2Wn5Mp6cIti26JVX4PHHNQmhAEp2RETEWSwWePllmDkTihSxW60zC5lPV27iL5v9N/EX5TnOWUrTmmXE4m974IwZ0LmzEh5RsiMiIk7WqxdERJgdjO3ozEKOUok1NGUW3VlDU45Rkd+4myBOsZs6dGIhyXjZHnilf9Dly469BnFpSnZERMT5QkNh82Z46SXziU8G3EmjKevozhyasg530qjACZbShuLEs5Zm9GEGadcOU//xR+jeXQlPIaZkR0REXIOXF4wbB+vWQcWKWT6sAX/wPV3w4DJz6M5IxqWv9P338NhjkJKSiwFLfqFkR0REXEuTJrBjh9nBOIvu5xemY9afwAgmMzB9pblzoV07iI/PrUgln1CyIyIirsfPD778EhYtgsDALB3Sk295m5cBeJaPWEjH9JVWrIC77oJjx3IxWHF1SnZERMR1tWsHu3ZBt25Zqj6ScTzFNAzceJRZbCQsfaVdu6BxY9i6NZeDFVelZEdERFxbqVLmJISffQbu7plWtQCTGUQ7FpFEUdqziP1UT1/x9Gm4915zvS4p8JTsiIhI/tC/PyxbZr7iyoQHqcyhG7ezhbOUojXLOE3Z9BUvXoQHH4Q//nBQwOIqlOyIiEj+cf/9sHHjdUdrFSORxbSjCoc5QhXasoQEiqWvmJgIHTvCmTOOiVdcgpIdERHJX2rXhk2boGbNTKuV5W+W04rS/E0Et/EI/yOFDF6DHT1qTjyoYekFlpIdERHJfwIDYfVqqJ5Bf5yrVOMQi2lHURJZSlue4RMyXB509Wp46iktLVFAKdkREZH8KSjITFJuvjnTao3Zwhy64UYqn/Mkb/NKxhWnTzeHpR8+7IBgxZmU7IiISP51002wZg1UrpxptQdZxGQGAfAabzGD3hlX3LYNbr3VnIBQCgwlOyIikr+FhMCGDXDLLZlWG8A0Xvp3KYn+fM4KHsi4Ynw8PPIIDB6sfjwFhJIdERHJ/266Cdavh/btM632Nq/Qg29JwZOuzGc7DexXnjzZnMxQ/XjyPSU7IiJSMPj6wsKFMGSI3SpuGEznce5jFQkUpw1LOUYF+21+/z107gxJSbkfr+QZJTsiIlJwuLvDhx/C22/breLFZRbQmbrsIJogWrOMs5Sw3+aSJeYTowsXHBCw5AUlOyIiUvCMHAmPPmq32J94ltKG8pxgL6F05AeS8Lbf3i+/QOvWSnjyKSU7IiJS8Fgs8PnnmXZaLs9fLKM1/sSygXvoxdekYbHf5oYNZh+etDQHBCyOpGRHREQKJh8f+OEHKFPGbpU67GYhnfDkEvN4mBd4L/M2Fy+GN9/M3TjF4Zya7Kxfv5727dsTHByMxWLhhx9+sCk3DINRo0YRFBRE0aJFadGiBQcPHrSpc/bsWXr06IGfnx8BAQH069ePhISEPLwKERFxWRUqmBMPlitnt0oz1jKDPgB8yPN8yJDM2xwzxkx6JN9warJz4cIF6tevz5QpUzIsnzBhAh999BHTpk1j8+bNFCtWjJYtW5J0Va/4Hj16sHv3blauXMnixYtZv349Tz75ZF5dgoiIuLo6dcy1tBo1slvlUWbzDi8CMIz3mUfXzNt87DE4dCg3oxRHMlwEYCxcuND6e1pamhEYGGi8++671n2xsbGGt7e3MXv2bMMwDGPPnj0GYGzdutVaZ9myZYbFYjH++usvu+dKSkoy4uLirNuJEycMwIiLi8v9CxMREdeQnGwYL7xgGJDhlgbGQD42wDC8uWis5267dQ0wjEqVDOPQIWdfVaEWFxeXpe9vl+2zc+TIEaKjo2nRooV1n7+/P40bNyY8PByA8PBwAgICuO2226x1WrRogZubG5s3b7bb9rhx4/D397duISEhjrsQERFxDV5e8O675lDyUqXSFVuASTxHRxaSTBE68CN7yWRl9aNH4e67Ydcuh4UsucNlk53o6GgAyl3znrVcuXLWsujoaMqWLWtT7uHhQcmSJa11MjJy5Eji4uKs24kTJ3I5ehERcVlt2sDvv2e4Yro7acziUcLYyDlK0pplRBFov63oaLjnHtiyxYEBy41y2WTHkby9vfHz87PZRESkEKlQwVxeok6ddEVFSeInHqQaBzhGJdqyhPP42m/r3Dlo3lwJjwtz2WQnMNDMpE+fPm2z//Tp09aywMBAYmJibMpTUlI4e/astY6IiEiGypWDtWvNVc6vUZozLKcVZTnNdm7lIeZxGQ/7bSUkmLMsR0U5Ll7JMZdNdipXrkxgYCCrVq2y7ouPj2fz5s2EhYUBEBYWRmxsLBEREdY6q1evJi0tjcaNG+d5zCIiks+UKgWrVkGtWumKqnCExbTDhwusoBVP8hlGZm3FxEDfvpp00AU5NdlJSEggMjKSyMhIwOyUHBkZyfHjx7FYLAwZMoS33nqLn376iZ07d9KrVy+Cg4Pp2LEjALVq1aJVq1b079+fLVu28NtvvzFo0CC6detGcHCw8y5MRETyj4AAcwHR4sXTFd3ONubyMG6kMoO+jGFM5m2tWGGuli6uJY9Gh2VozZo1BpBu6927t2EY5vDz1157zShXrpzh7e1tNG/e3Ni/f79NG2fOnDG6d+9u+Pr6Gn5+fkbfvn2N8+fPZyuOrA5dExGRAmzhQrvDzD+lv/XXz+mX+ZB0b2/D2LHD2VdTKGT1+9tiGEamT+UKg/j4ePz9/YmLi1NnZRGRwuzVV+2umP4ab/AWr+FOCj/xIG1YZr+doCBYvhzq1XNQoAJZ//522T47IiIiee71183FPjPwBqPozQxS8eAh5rGNhvbbiYoyh6SvW+egQCU7lOyIiIhc4e4O33wDvXqlK7IAn9Of+/mZRIrRliX8SWX7bcXFQcuWsGCB4+KVLFGyIyIicjUPD/jqKxg8OF2RJynMpysN2E4M5WjNMv4h/WzMVsnJ8NBDSnicTMmOiIjItdzcYNIkGDUqXZEf51lCWypwjAPU4EF+4iJF7LeVlgY9esAffzgwYMmMkh0REZGMWCxmH56ePdMVBRPFMloTwDnCuZMefEdqZl+pSUnmE574eAcGLPYo2REREcnM5MlQOX3fnFD28iMd8CKZhXRmCBMzn3Tw4EF44glzgLrkKSU7IiIimfHzMzstu6X/yryHDXyD+eRnMoN5n2GZtzVvniYddAIlOyIiItdz110wZkyGRQ8zjw8YCsBw3mMOj2Te1pAhMGtW7sYnmVKyIyIikhWvvmqufZWBoUxkCB8C0JuZrOVe++2kpZn9gObOdUSUkgElOyIiIllhscAXX8Czz2ZY/D7D6Mo8LuFNR35gF7Xtt5WWBo8+Ct9/76Bg5WpKdkRERLLKzQ0mToRx49IXYfANPbmbDcQRQGuW8ReZLEqdmmrO1rx0qePiFUDJjoiISPZYLPDSS/Dll+k6LRchmR/pQE32cpIQ2rCUODJZczElBR5+GCIjHRtzIadkR0REJCcefxzGjk23uyTnWEZrAoliB/XpwvdcwtN+OxcuQNu2cPKkA4Mt3JTsiIiI5NTw4Waico1KHGMJbfHlPKtoQT++zHwOnlOnoH17OH/eYaEWZkp2REREcsrNDWbOhAoV0hXdynbm0xV3UviWnrzKW5m3FRlp9uFJSXFMrIWYkh0REZEbUaqUOYzc2ztdUUt+5nP6AzCWV5jGU5m3tXQpPP20ZlnOZUp2REREblTjxjBnjrli+jX6MoPXMRcUHcgUfqJ95m19+aW5JpfkGiU7IiIiuaFjR5g9G9zd0xW9xpv04wvScKcbc9hMo8zbev11+Owzx8RZCCnZERERyS1du8J336Ubkm4BpjKA1izlIj60YzGHuDnztgYMgCVLHBdrIaJkR0REJDc98gh8/bU5H89VPElhLg9zKxH8QxlasZy/KW2/nbQ0eOwxOHrUsfEWAkp2REREcluPHvD+++l2+3KBJbSlEkc4TFXasZhEitpvJzbWnHTw0iXHxVoIKNkRERFxhCFD4Jln0u0O5DTLaUVJzrCFxnRjDimk7+djtXWrOZ+P5JiSHREREUewWGDSJGjdOl1RDQ6wiPYU4SKLeJDBfJz5pIMffWS+GpMcUbIjIiLiKB4e8L//Qf366YruJJzv6IGFNKYxgPG8lHlbffqYw9Il25TsiIiIOFLx4uZkgRnMstyZhUziOQBeZhzf8Jj9dgwDnngCPv7YUZEWWEp2REREHC04GJYvhxIl0hUNZjIv8C4AjzOdX2ieeVvPPgsTJjgiygJLyY6IiEheqFULFi+GIkXSFb3DCB5hDil40pkF/EG9zNsaMQKmTXNQoAWPkh0REZG8cued8O236Xa7YTCT3tzLWs7jRxuWcoLymbc1eDCsX++gQAsWJTsiIiJ5qUsXeP75dLu9ucQPdKQ2uzjFTbRmGbH4228nJcWcsfn4cQcGWzAo2REREclr48fDHXek2x1AHEtpQzB/sZs6dOQHkvGy387ff5trciUmOi7WAkDJjoiISF7z9DSHpJcsma6oAidYShuKE886mtKHGaRhyaCRf23fbg5LT011XLz5nJIdERERZ6hQAebMMefiuUZ9drCAznhwmTl05yXGZ97WvHnw3HPm8HRJR8mOiIiIs9x/P8yenWHC04JVTOdxAN7lRT5mUOZtTZkCb77piCjzPSU7IiIiztS1KyxcCF7p++b05Fve5mUAnmMSC+mYeVujR8PUqQ4IMn9TsiMiIuJs7dqZc/AUTb8C+kjG8RTTMHDjUWaxkbDM2xo4EH7+2UGB5k8uneyMGTMGi8Vis9WsWdNanpSUxMCBAylVqhS+vr506dKF06dPOzFiERGRHLr/fnOWZW9vm90WYDKDaM9PJFGU9ixiP9Xtt2MY0LMnxMQ4Nt58xKWTHYDatWsTFRVl3X799Vdr2dChQ1m0aBHz5s1j3bp1nDp1is6dOzsxWhERkRtwzz3w2WfpdnuQymy604jNnKUUrVlGNOXstxMTA48/rg7L/3L5ZMfDw4PAwEDrVrp0aQDi4uL48ssv+eCDD7jvvvto2LAhX331FRs3bmTTpk1OjlpERCSHevWCIUPS7S5GIotoz80c4ghVaMdiEihmv50lS7SkxL9cPtk5ePAgwcHBVKlShR49enD835kiIyIiuHz5Mi1atLDWrVmzJhUqVCA8PDzTNpOTk4mPj7fZREREXMa770Lz9AuCluVvltOK0vxNBLfxMHNJwd1+O88/D5GRjoszn3DpZKdx48bMmDGD5cuXM3XqVI4cOUKTJk04f/480dHReHl5ERAQYHNMuXLliI6OzrTdcePG4e/vb91CQkIceBUiIiLZ5OFhTjpYPX3fnKocZjHtKEoiy2jDAKZi92VVUhK0agWHDjk0XFfn0slO69ateeihh6hXrx4tW7Zk6dKlxMbGMnfu3Btqd+TIkcTFxVm3EydO5FLEIiIiuaRUKVixAoKD0xU1Zgtz6IYbqXxBf97iVfvtnD5tdn7+6y8HBuvaXDrZuVZAQADVq1fn0KFDBAYGcunSJWJjY23qnD59msDAwEzb8fb2xs/Pz2YTERFxOZUqmQlPiRLpih5kEZP/nWhwFG8yg9722zl6FFq2hLNnHROni8tXyU5CQgKHDx8mKCiIhg0b4unpyapVq6zl+/fv5/jx44SFXWcOAhERkfyiTh27c/AMYBojGQtAfz5nBQ/Yb2f3bujc2VwtvZBx6WTnhRdeYN26dRw9epSNGzfSqVMn3N3d6d69O/7+/vTr14/nn3+eNWvWEBERQd++fQkLC+OODFaSFRERybfuvBM+/TTDord5hcf4hhQ86cp8fucW++2sWwfvvOOgIF2XSyc7J0+epHv37tSoUYOHH36YUqVKsWnTJsqUKQPAhx9+SLt27ejSpQv33HMPgYGBLFiwwMlRi4iIOMBjj0G3bul2W4Av6UdzfiGB4rRlCUepaL+dN96AffscF6cLshiGZhyKj4/H39+fuLg49d8RERHXFRsL9epBBgNr4vCjCRvYST1qspffuIuSnMu4nTvvhA0bwM2ln3lcV1a/v/P3VYqIiBQmAQHwzTdgsaQr8ieepbShPCfYRy068CNJeKdvA2DjRnOV9EJCyY6IiEh+cu+9dvvdlOcvltEaf2L5lSb05BvSSJ8YAfDiixAR4cBAXYeSHRERkfzmhRdg6NAMi+qwm4V0wotk5vMQL/Bexm0kJUGnToViwVAlOyIiIvmNxQLvvQe9M55bpxlrmUEfAD7keT5kSMbtnDgBXbvCpUuOidNFKNkRERHJj9zc4IsvoEOHDIu7M4cJDAdgGO8zj64Zt7Nhg7mGVgGmZEdERCS/8vCAWbOgatUMi1/gPQbxMQZuPMa3rKdJxu1MmWLO1FxAKdkRERHJz3x84PPPMyyyABMZQkcWcglvOvAje6iVcTtDhhTY2ZWV7IiIiOR3TZvCU09lWOROGrN4lDA2EksJWrOMUwSlr7hvn92kKb9TsiMiIlIQvPMO3HRThkVFSeInHqQaBzhORdqyhPP4pq84ejTExzs40LynZEdERKQg8PeH774Dd/cMi0tzhuW0oiynieQWujKfy3jYVvr7b+jRo8CNzlKyIyIiUlDcey98+KHd4iocYQlt8eECP9OSJ/mMdGtGLV5srsF1+bJDQ81LSnZEREQKkkGDoG9fu8W3EcE8HsKdFGbQl9G8nr7SwoXmE54C0mFZyY6IiEhBYrHAJ59A48Z2q7RhGVMZAMCbjOJznkhfad48s9NzAVgvXMmOiIhIQVOkCHz1ld3+OwD9+YLXeAOAAUxlCW3SV5o+vUCM0FKyIyIiUhDVqgX9+2da5XVG05sZpOLBw8xlGw3TVxo6FPbvd1CQeUPJjoiISEE1Zgz4ZjDE/F8W4HP6cz8/k0gx2rKEP6lsWykxMd+P0FKyIyIiUlCVKwevvpppFU9S+J4uNGA7MZSjFcv5h1K2lSIiYMSIfNt/R8mOiIhIQfbCC9CsWaZVipPAUtpQgWMcpDoP8hOJFLWtNHEiPPsspKU5LlYHUbIjIiJSkLm7w//+B6GhmVYLIprltCKAc4RzJz34jtRr04TJk6F7d0hOdmDAuU/JjoiISEFXpgysXg01a2ZarRb7+IkH8SKZH+jEc0xKP+ng3LnQtm2+WlZCyY6IiEhhUK6cmfBUq5ZptSb8yrc8BsAUBvEeL6SvtGqV+Wrs9GlHRJrrlOyIiIgUFkFBsGaN3QVDr3iI+XzAUABe5F1m0y19pd9/h7vugsOHHRFprlKyIyIiUpjcdBN8840503ImhjKRIZjrbPVmJmtomr7S4cNw552wfbsDAs09SnZEREQKm2bNzFFa1/E+w+jKPC7jRScWsova6SvFxJgLkK5dm/tx5hIlOyIiIoXRm2/CLbdkWsUNg2/oyd1sII4AWrOMk2TwCuz8eWjdGpYvd1CwN0bJjoiISGHk7Q1z5kDJkplWK0IyP9KBmuzlJCG0YSlx+KWvmJQEDz4IP/zgmHhvgJIdERGRwqp6dViyBPz9M61WknMsozWBRLGTenRmAZfwTF/x8mXo2tVMolyIkh0REZHC7I47YMMGCA7OtFoljrGUNvhyntU053Gmp5+DByA1FR591JzI0EUo2RERESns6taFjRuhRo1Mq91CJPPpijspfMdjvMLbGVc0DOjVy1xTywUo2RERERGoWBF+/RUaNcq0Wkt+5nP6AzCOl5nK0xlXvHQJHnoIYmNzOdDsU7IjIiIiptKlzVmWW7XKtFpfZvA6owAYxGR+on3GFY8cMZ/wOHm1dCU7IiIi8p9ixeCnn+CxxzKt9hpv8gSfk4Y73ZjDJhpnXHHRIujQwamLhyrZEREREVuenjBzJgwbZreKBZjKANqwhIv40J5FHKRqxpUXLYLGjWH3bsfEex1KdkRERCQ9Nzd47z2YMMFuFQ9S+R+P0JBt/EMZWrOMGMpkXPmPP6BhQ5g4EdLSHBOzHUp2RERExL7hw+GTT+wW+3KBJbSlMn9ymKq0YzEX8Mm4cnIyDB0KLVvCX385KOD0lOyIiIhI5gYMgBkzzKc9GShHDMtoTUnOsJVGdGMOKbjbb++XX8zh7nPnOibeaxSYZGfKlClUqlSJIkWK0LhxY7Zs2eLskERERAqO3r1h9mxwzziJqcEBFtGeIlxkMe0ZxGRScGMt9zKbbqzlXlKvTjvOnYNHHoGePSEuzqGhF4hk53//+x/PP/88o0eP5vfff6d+/fq0bNmSmJgYZ4cmIiJScDz8MLz7rt3iOwlnFo9iIY1PeZpSnKEZa3mU2TRjLZU4ygI62R707bdQrx6sW+ewsAtEsvPBBx/Qv39/+vbtS2hoKNOmTcPHx4fp06c7OzQREZGCZcgQ6NjRbnEnfuBxvgQgngCbsr+4ia7MT5/wHD8O+/fnbpxXyffJzqVLl4iIiKBFixbWfW5ubrRo0YLw8PAMj0lOTiY+Pt5mExERkSywWOCrr6By5QyLU3FjBa0gg5WzjH/TjiFMtH2l1a4d9O/viGiBApDs/PPPP6SmplKuXDmb/eXKlSM6OjrDY8aNG4e/v791CwkJyYtQRURECoaAAJg/H3x90xVtoAknCcGciSc9AzdOUIENNDF3lCkDX3xhJlEOku+TnZwYOXIkcXFx1u3EiRPODklERCR/ufVWWLkS/P1tdkcRlKXDrfW+/BKueWCR2/J9slO6dGnc3d05ffq0zf7Tp08TGBiY4THe3t74+fnZbCIiIpJNd9wBmzaZkwX+K4ioLB0aRJT56qq9nXW1clG+T3a8vLxo2LAhq1atsu5LS0tj1apVhIWFOTEyERGRQqBmTdi4EV55BdzcaMIGynMCCxnPkmwhjRCO0+TmKPjggzwJMd8nOwDPP/88n3/+OTNnzmTv3r0MGDCACxcu0LdvX2eHJiIiUvB5ecFbb8H69bhXrsgkngNIl/Bc+X2i2/O4f/d1hn1+HKFAJDuPPPII7733HqNGjaJBgwZERkayfPnydJ2WRURExIHuugsiI+ncx5/5dOUmbJeEKM9J5tOVzq/VMRcGzSMWwzDSjw0rZOLj4/H39ycuLk79d0RERHLDggWkPvEUG87VJooggoiiCRtwb3Qb/PqrubL6Dcrq97fHDZ9JRERE5FqdO+N+xx00ffxxWDHH3OfjY86YnAuJTnYUiNdYIiIi4oKCg2HZMvj4YyhSBD78EKpVy/Mw9GRHREREHMdigUGDzCHmFSo4JQQlOyIiIuJ4FSs67dR6jSUiIiIFmpIdERERKdCU7IiIiEiBpmRHRERECjQlOyIiIlKgKdkRERGRAk1Dz4ErK2bEx8c7ORIRERHJqivf29db+UrJDnD+/HkAQkJCnByJiIiIZNf58+fx9/e3W66FQIG0tDROnTpF8eLFsVgsudZufHw8ISEhnDhxotAuMKp7oHsAugege1DYrx90DyD374FhGJw/f57g4GDc3Oz3zNGTHcDNzY3y5cs7rH0/P79C+8G+QvdA9wB0D0D3oLBfP+geQO7eg8ye6FyhDsoiIiJSoCnZERERkQJNyY4DeXt7M3r0aLy9vZ0ditPoHugegO4B6B4U9usH3QNw3j1QB2UREREp0PRkR0RERAo0JTsiIiJSoCnZERERkQJNyY6IiIgUaEp2HGjKlClUqlSJIkWK0LhxY7Zs2eLskBxizJgxWCwWm61mzZrW8qSkJAYOHEipUqXw9fWlS5cunD592okR37j169fTvn17goODsVgs/PDDDzblhmEwatQogoKCKFq0KC1atODgwYM2dc6ePUuPHj3w8/MjICCAfv36kZCQkIdXcWOudw/69OmT7nPRqlUrmzr5+R6MGzeO22+/neLFi1O2bFk6duzI/v37bepk5bN//Phx2rZti4+PD2XLlmX48OGkpKTk5aXkWFbuQdOmTdN9Dp5++mmbOvn5HkydOpV69epZJ8kLCwtj2bJl1vKC/hmA698DV/gMKNlxkP/97388//zzjB49mt9//5369evTsmVLYmJinB2aQ9SuXZuoqCjr9uuvv1rLhg4dyqJFi5g3bx7r1q3j1KlTdO7c2YnR3rgLFy5Qv359pkyZkmH5hAkT+Oijj5g2bRqbN2+mWLFitGzZkqSkJGudHj16sHv3blauXMnixYtZv349Tz75ZF5dwg273j0AaNWqlc3nYvbs2Tbl+fkerFu3joEDB7Jp0yZWrlzJ5cuXeeCBB7hw4YK1zvU++6mpqbRt25ZLly6xceNGZs6cyYwZMxg1apQzLinbsnIPAPr372/zOZgwYYK1LL/fg/LlyzN+/HgiIiLYtm0b9913Hx06dGD37t1Awf8MwPXvAbjAZ8AQh2jUqJExcOBA6++pqalGcHCwMW7cOCdG5RijR4826tevn2FZbGys4enpacybN8+6b+/evQZghIeH51GEjgUYCxcutP6elpZmBAYGGu+++651X2xsrOHt7W3Mnj3bMAzD2LNnjwEYW7dutdZZtmyZYbFYjL/++ivPYs8t194DwzCM3r17Gx06dLB7TEG7BzExMQZgrFu3zjCMrH32ly5dari5uRnR0dHWOlOnTjX8/PyM5OTkvL2AXHDtPTAMw7j33nuN5557zu4xBe0eGIZhlChRwvjiiy8K5Wfgiiv3wDBc4zOgJzsOcOnSJSIiImjRooV1n5ubGy1atCA8PNyJkTnOwYMHCQ4OpkqVKvTo0YPjx48DEBERweXLl23uRc2aNalQoUKBvRdHjhwhOjra5pr9/f1p3Lix9ZrDw8MJCAjgtttus9Zp0aIFbm5ubN68Oc9jdpS1a9dStmxZatSowYABAzhz5oy1rKDdg7i4OABKliwJZO2zHx4eTt26dSlXrpy1TsuWLYmPj7f5V3F+ce09uOK7776jdOnS1KlTh5EjR5KYmGgtK0j3IDU1lTlz5nDhwgXCwsIK5Wfg2ntwhbM/A1oI1AH++ecfUlNTbf7DAZQrV459+/Y5KSrHady4MTNmzKBGjRpERUXx+uuv06RJE3bt2kV0dDReXl4EBATYHFOuXDmio6OdE7CDXbmujP77XymLjo6mbNmyNuUeHh6ULFmywNyXVq1a0blzZypXrszhw4d5+eWXad26NeHh4bi7uxeoe5CWlsaQIUO46667qFOnDkCWPvvR0dEZfk6ulOUnGd0DgEcffZSKFSsSHBzMjh07GDFiBPv372fBggVAwbgHO3fuJCwsjKSkJHx9fVm4cCGhoaFERkYWms+AvXsArvEZULIjN6x169bWP9erV4/GjRtTsWJF5s6dS9GiRZ0YmThTt27drH+uW7cu9erV4+abb2bt2rU0b97ciZHlvoEDB7Jr1y6bvmqFjb17cHUfrLp16xIUFETz5s05fPgwN998c16H6RA1atQgMjKSuLg45s+fT+/evVm3bp2zw8pT9u5BaGioS3wG9BrLAUqXLo27u3u6HvenT58mMDDQSVHlnYCAAKpXr86hQ4cIDAzk0qVLxMbG2tQpyPfiynVl9t8/MDAwXWf1lJQUzp49W2DvS5UqVShdujSHDh0CCs49GDRoEIsXL2bNmjWUL1/euj8rn/3AwMAMPydXyvILe/cgI40bNwaw+Rzk93vg5eVF1apVadiwIePGjaN+/fpMmjSpUH0G7N2DjDjjM6BkxwG8vLxo2LAhq1atsu5LS0tj1apVNu8wC6qEhAQOHz5MUFAQDRs2xNPT0+Ze7N+/n+PHjxfYe1G5cmUCAwNtrjk+Pp7NmzdbrzksLIzY2FgiIiKsdVavXk1aWpr1L4KC5uTJk5w5c4agoCAg/98DwzAYNGgQCxcuZPXq1VSuXNmmPCuf/bCwMHbu3GmT9K1cuRI/Pz/rKwBXdr17kJHIyEgAm89Bfr4HGUlLSyM5OblQfAbsuXIPMuKUz0CudHOWdObMmWN4e3sbM2bMMPbs2WM8+eSTRkBAgE1v84Ji2LBhxtq1a40jR44Yv/32m9GiRQujdOnSRkxMjGEYhvH0008bFSpUMFavXm1s27bNCAsLM8LCwpwc9Y05f/68sX37dmP79u0GYHzwwQfG9u3bjWPHjhmGYRjjx483AgICjB9//NHYsWOH0aFDB6Ny5crGxYsXrW20atXKuOWWW4zNmzcbv/76q1GtWjWje/fuzrqkbMvsHpw/f9544YUXjPDwcOPIkSPGL7/8Ytx6661GtWrVjKSkJGsb+fkeDBgwwPD39zfWrl1rREVFWbfExERrnet99lNSUow6deoYDzzwgBEZGWksX77cKFOmjDFy5EhnXFK2Xe8eHDp0yHjjjTeMbdu2GUeOHDF+/PFHo0qVKsY999xjbSO/34OXXnrJWLdunXHkyBFjx44dxksvvWRYLBbj559/Ngyj4H8GDCPze+AqnwElOw708ccfGxUqVDC8vLyMRo0aGZs2bXJ2SA7xyCOPGEFBQYaXl5dx0003GY888ohx6NAha/nFixeNZ555xihRooTh4+NjdOrUyYiKinJixDduzZo1BpBu6927t2EY5vDz1157zShXrpzh7e1tNG/e3Ni/f79NG2fOnDG6d+9u+Pr6Gn5+fkbfvn2N8+fPO+Fqciaze5CYmGg88MADRpkyZQxPT0+jYsWKRv/+/dMl+/n5HmR07YDx1VdfWetk5bN/9OhRo3Xr1kbRokWN0qVLG8OGDTMuX76cx1eTM9e7B8ePHzfuueceo2TJkoa3t7dRtWpVY/jw4UZcXJxNO/n5Hjz++ONGxYoVDS8vL6NMmTJG8+bNrYmOYRT8z4BhZH4PXOUzYDEMw8idZ0QiIiIirkd9dkRERKRAU7IjIiIiBZqSHRERESnQlOyIiIhIgaZkR0RERAo0JTsiIiJSoCnZERERkQJNyY6IiIgUaEp2RKRAqVSpEhaLBYvFkm4Bxuxq2rSpta0r6/mISP6jZEdEXE5qaip33nknnTt3ttkfFxdHSEgIr7zySqbHv/HGG0RFReHv739DcSxYsIAtW7bcUBsi4nxKdkTE5bi7uzNjxgyWL1/Od999Z90/ePBgSpYsyejRozM9vnjx4gQGBmKxWG4ojpIlS1KmTJkbakNEnE/Jjoi4pOrVqzN+/HgGDx5MVFQUP/74I3PmzOHrr7/Gy8srW23NmDGDgIAAFi9eTI0aNfDx8aFr164kJiYyc+ZMKlWqRIkSJXj22WdJTU110BWJiLN4ODsAERF7Bg8ezMKFC+nZsyc7d+5k1KhR1K9fP0dtJSYm8tFHHzFnzhzOnz9P586d6dSpEwEBASxdupQ///yTLl26cNddd/HII4/k8pWIiDMp2RERl2WxWJg6dSq1atWibt26vPTSSzlu6/Lly0ydOpWbb74ZgK5du/LNN99w+vRpfH19CQ0NpVmzZqxZs0bJjkgBo9dYIuLSpk+fjo+PD0eOHOHkyZM5bsfHx8ea6ACUK1eOSpUq4evra7MvJibmhuIVEdejZEdEXNbGjRv58MMPWbx4MY0aNaJfv34YhpGjtjw9PW1+t1gsGe5LS0vLcbwi4pqU7IiIS0pMTKRPnz4MGDCAZs2a8eWXX7JlyxamTZvm7NBEJJ9RsiMiLmnkyJEYhsH48eMBc7LA9957jxdffJGjR486NzgRyVeU7IiIy1m3bh1Tpkzhq6++wsfHx7r/qaee4s4777yh11kiUvhYDP2NISIFSKVKlRgyZAhDhgzJlfaOHj1K5cqV2b59Ow0aNMiVNkUkb+nJjogUOCNGjMDX15e4uLgbaqd169bUrl07l6ISEWfRkx0RKVCOHTvG5cuXAahSpQpubjn/N91ff/3FxYsXAahQoUK2Z24WEdegZEdEREQKNL3GEhERkQJNyY6IiIgUaEp2REREpEBTsiMiIiIFmpIdERERKdCU7IiIiEiBpmRHRERECjQlOyIiIlKg/R9gBbWQG6TkkwAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "p1 = path_from_RT90(df, east_col = \"East\", north_col = \"North\", simplify_path = False)\n", "p2 = path_from_RT90(df, east_col = \"East\", north_col = \"North\", simplify_path = True)\n", @@ -101,21 +101,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "24f1159d", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAG2CAYAAACEbnlbAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAK65JREFUeJzt3X90VPWd//HX5CckYSYGkxkihFCRH1FARA0jdV0lEjFaKHGXejgSXI4iDSgEKU1LQdhqWLr+YovSrSvRsyKWruiKBUlBwiqRH8EsEYSCi0mUTKJwMiEgSUju9w9P5tv5gDXRzEwSno9z5hzm8/nce9+ffJrm5Z1779gsy7IEAAAAn7BQFwAAANDVEJAAAAAMBCQAAAADAQkAAMBAQAIAADAQkAAAAAwEJAAAAAMBCQAAwEBAAgAAMBCQAAAADCENSI899phsNpvfa9iwYb7+c+fOKTc3V3379lVcXJyys7NVU1Pjt4/KykplZWUpJiZGSUlJWrhwoc6fPx/sqQAAgB4kItQFXH311frzn//sex8R8f9Lmj9/vt5++21t2LBBDodDc+bM0ZQpU/T+++9LklpaWpSVlSWXy6Vdu3apurpa06dPV2RkpJ544omgzwUAAPQMtlB+We1jjz2mN954Q2VlZRf0eb1eJSYmat26dbrnnnskSYcPH9bw4cNVUlKisWPHavPmzbrrrrt04sQJOZ1OSdKaNWu0aNEiffHFF4qKigrmdAAAQA8R8jNIR48eVXJysnr16iW3262CggKlpKSotLRUzc3NysjI8I0dNmyYUlJSfAGppKREI0aM8IUjScrMzNTs2bN18OBBjR49+qLHbGxsVGNjo+99a2urTp06pb59+8pmswVusgAAoNNYlqXTp08rOTlZYWGde9VQSANSenq6CgsLNXToUFVXV2vZsmW6+eab9dFHH8nj8SgqKkrx8fF+2zidTnk8HkmSx+PxC0dt/W1936SgoEDLli3r3MkAAICQqKqqUv/+/Tt1nyENSBMnTvT9e+TIkUpPT9fAgQP1hz/8Qb179w7YcfPz85WXl+d77/V6lZKSoqqqKtnt9oAdFwAAdJ76+noNGDBAffr06fR9h/wjtr8WHx+vIUOG6NixY7r99tvV1NSkuro6v7NINTU1crlckiSXy6U9e/b47aPtLre2MRcTHR2t6OjoC9rtdjsBCQCAbiYQl8d0qecgNTQ06JNPPlG/fv00ZswYRUZGatu2bb7+I0eOqLKyUm63W5LkdrtVXl6u2tpa35iioiLZ7XalpaUFvX4AANAzhPQM0qOPPqq7775bAwcO1IkTJ7R06VKFh4fr3nvvlcPh0MyZM5WXl6eEhATZ7XbNnTtXbrdbY8eOlSRNmDBBaWlpuu+++7Ry5Up5PB4tXrxYubm5Fz1DBAAA0B4hDUifffaZ7r33Xp08eVKJiYn64Q9/qA8++ECJiYmSpKefflphYWHKzs5WY2OjMjMz9dxzz/m2Dw8P16ZNmzR79my53W7FxsYqJydHy5cvD9WUAABADxDS5yB1FfX19XI4HPJ6vVyDBABANxHIv99d6hokAACAroCABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGLpMQFqxYoVsNpvmzZvnazt37pxyc3PVt29fxcXFKTs7WzU1NX7bVVZWKisrSzExMUpKStLChQt1/vz5IFcPAAB6ki4RkPbu3avf/e53GjlypF/7/Pnz9dZbb2nDhg0qLi7WiRMnNGXKFF9/S0uLsrKy1NTUpF27dumll15SYWGhlixZEuwpAACAHiTkAamhoUHTpk3T73//e1122WW+dq/Xq//4j//QU089pdtuu01jxozR2rVrtWvXLn3wwQeSpK1bt+rQoUP6z//8T1177bWaOHGi/vmf/1mrV69WU1NTqKYEAAC6uZAHpNzcXGVlZSkjI8OvvbS0VM3NzX7tw4YNU0pKikpKSiRJJSUlGjFihJxOp29MZmam6uvrdfDgwW88ZmNjo+rr6/1eAAAAbSJCefD169dr//792rt37wV9Ho9HUVFRio+P92t3Op3yeDy+MX8djtr62/q+SUFBgZYtW/Y9qwcAAD1VyM4gVVVV6ZFHHtErr7yiXr16BfXY+fn58nq9vldVVVVQjw8AALq2kAWk0tJS1dbW6rrrrlNERIQiIiJUXFysVatWKSIiQk6nU01NTaqrq/PbrqamRi6XS5LkcrkuuKut7X3bmIuJjo6W3W73ewEAALQJWUAaP368ysvLVVZW5ntdf/31mjZtmu/fkZGR2rZtm2+bI0eOqLKyUm63W5LkdrtVXl6u2tpa35iioiLZ7XalpaUFfU4AAKBnCNk1SH369NE111zj1xYbG6u+ffv62mfOnKm8vDwlJCTIbrdr7ty5crvdGjt2rCRpwoQJSktL03333aeVK1fK4/Fo8eLFys3NVXR0dNDnBAAAeoaQXqT9bZ5++mmFhYUpOztbjY2NyszM1HPPPefrDw8P16ZNmzR79my53W7FxsYqJydHy5cvD2HVAACgu7NZlmWFuohQq6+vl8PhkNfr5XokAAC6iUD+/Q75c5AAAAC6GgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgCGlAev755zVy5EjZ7XbZ7Xa53W5t3rzZ13/u3Dnl5uaqb9++iouLU3Z2tmpqavz2UVlZqaysLMXExCgpKUkLFy7U+fPngz0VAADQg4Q0IPXv318rVqxQaWmp9u3bp9tuu02TJk3SwYMHJUnz58/XW2+9pQ0bNqi4uFgnTpzQlClTfNu3tLQoKytLTU1N2rVrl1566SUVFhZqyZIloZoSAADoAWyWZVmhLuKvJSQk6De/+Y3uueceJSYmat26dbrnnnskSYcPH9bw4cNVUlKisWPHavPmzbrrrrt04sQJOZ1OSdKaNWu0aNEiffHFF4qKimrXMevr6+VwOOT1emW32wM2NwAA0HkC+fe7y1yD1NLSovXr1+vMmTNyu90qLS1Vc3OzMjIyfGOGDRumlJQUlZSUSJJKSko0YsQIXziSpMzMTNXX1/vOQl1MY2Oj6uvr/V4AAABtQh6QysvLFRcXp+joaD300EPauHGj0tLS5PF4FBUVpfj4eL/xTqdTHo9HkuTxePzCUVt/W983KSgokMPh8L0GDBjQuZMCAADdWsgD0tChQ1VWVqbdu3dr9uzZysnJ0aFDhwJ6zPz8fHm9Xt+rqqoqoMcDAADdS0SoC4iKitLgwYMlSWPGjNHevXv17LPPaurUqWpqalJdXZ3fWaSamhq5XC5Jksvl0p49e/z213aXW9uYi4mOjlZ0dHQnzwQAAPQU7QpIq1at6vCO77//fvXp06fD27W2tqqxsVFjxoxRZGSktm3bpuzsbEnSkSNHVFlZKbfbLUlyu916/PHHVVtbq6SkJElSUVGR7Ha70tLSOnxsAAAAqZ0Bad68eerfv7/Cw8PbtdOqqirddddd3xqQ8vPzNXHiRKWkpOj06dNat26dduzYoXfeeUcOh0MzZ85UXl6eEhISZLfbNXfuXLndbo0dO1aSNGHCBKWlpem+++7TypUr5fF4tHjxYuXm5nKGCAAAfGft/oht3759vrM036a9Z45qa2s1ffp0VVdXy+FwaOTIkXrnnXd0++23S5KefvpphYWFKTs7W42NjcrMzNRzzz3n2z48PFybNm3S7Nmz5Xa7FRsbq5ycHC1fvry90wIAALhAu56DtGzZMi1cuFAxMTHt2mlBQYFmz559wR1oXRXPQQIAoPsJ5N/vLvegyFAgIAEA0P10qQdFfvXVVzp79qzvfUVFhZ555hlt3bq1UwsDAAAIlQ4HpEmTJunll1+WJNXV1Sk9PV1PPvmkJk2apOeff77TCwQAAAi2Dgek/fv36+abb5Yk/fGPf5TT6VRFRYVefvnl7/Q4AAAAgK6mwwHp7NmzvrvUtm7dqilTpigsLExjx45VRUVFpxcIAAAQbB0OSIMHD9Ybb7yhqqoqvfPOO5owYYKkr2/Z5wJnAADQE3Q4IC1ZskSPPvqoUlNTlZ6e7nuq9datWzV69OhOLxAAACDYvtNt/h6PR9XV1Ro1apTCwr7OWHv27JHdbtewYcM6vchA4zZ/AAC6n0D+/e7Ql9U2Nzerd+/eKisru+Bs0Y033tiphQEAAIRKhz5ii4yMVEpKilpaWgJVDwAAQMh1+BqkX/7yl/rFL36hU6dOBaIeAACAkOvQR2yS9Nvf/lbHjh1TcnKyBg4cqNjYWL/+/fv3d1pxAAAAodDhgDR58uQAlAEAANB18GW14i42AAC6oy71ZbXS19/B9sILLyg/P993LdL+/fv1+eefd2pxAAAAodDhj9gOHDigjIwMORwOffrpp3rggQeUkJCg119/XZWVlb4vsgUAAOiuOnwGKS8vTzNmzNDRo0fVq1cvX/udd96pnTt3dmpxAAAAodDhgLR3717NmjXrgvYrrrhCHo+nU4oCAAAIpQ4HpOjoaNXX11/Q/pe//EWJiYmdUhQAAEAodTgg/ehHP9Ly5cvV3NwsSbLZbKqsrNSiRYuUnZ3d6QUCAAAEW4cD0pNPPqmGhgYlJSXpq6++0i233KLBgwerT58+evzxxwNRIwAAQFB1+C42h8OhoqIivf/++/rf//1fNTQ06LrrrlNGRkYg6gMAAAi6Dgekl19+WVOnTtW4ceM0btw4X3tTU5PWr1+v6dOnd2qBAAAAwdbhJ2mHh4erurpaSUlJfu0nT55UUlKSWlpaOrXAYOBJ2gAAdD9d6knalmXJZrNd0P7ZZ5/J4XB0SlEAAACh1O6P2EaPHi2bzSabzabx48crIuL/b9rS0qLjx4/rjjvuCEiRAAAAwdTugDR58mRJUllZmTIzMxUXF+fri4qKUmpqKrf5AwCAHqHdAWnp0qWSpNTUVE2dOtXva0YAAAB6kg5fg5STk6Nz587phRdeUH5+vk6dOiVJ2r9/vz7//PNOLxAAACDYOnyb/4EDB5SRkSGHw6FPP/1UDzzwgBISEvT666+rsrJSL7/8ciDqBAAACJoOn0GaP3++ZsyYoaNHj/p9zHbnnXdq586dnVocAABAKHT4DNK+ffv07//+7xe0X3HFFfJ4PJ1SFAAAQCh1+AxSdHS06uvrL2j/y1/+osTExE4pCgAAIJQ6HJB+9KMfafny5WpubpYk2Ww2VVZWatGiRdzmDwAAeoQOB6Qnn3xSDQ0NSkpK0ldffaVbbrlFgwcPVp8+ffT4448HokYAAICg6vA1SA6HQ0VFRXrvvfd04MABNTQ06LrrrlNGRkYg6gMAAAi6Dn9ZbU/El9UCAND9BPLvd4fPIEnS3r179e6776q2tlatra1+fU899VSnFAYAABAqHQ5ITzzxhBYvXqyhQ4fK6XTKZrP5+v763wAAAN1VhwPSs88+qxdffFEzZswIQDkAAACh1+G72MLCwjRu3LhA1AIAANAlfKevGlm9enUgagEAAOgSOvwR26OPPqqsrCxdeeWVSktLU2RkpF//66+/3mnFAQAAhEKHA9LDDz+sd999V7feeqv69u3LhdkAAKDH6XBAeumll/Rf//VfysrKCkQ9AAAAIdfha5ASEhJ05ZVXBqIWAACALqHDAemxxx7T0qVLdfbs2UDUAwAAEHId/oht1apV+uSTT+R0OpWamnrBRdr79+/vtOIAAABCocMBafLkyQEoAwAAoOvgy2rFl9UCANAdBfLvd4evQQIAAOjp2hWQEhIS9OWXX7Z7pykpKaqoqPjORQEAAIRSu65Bqqur0+bNm+VwONq105MnT6qlpeV7FQYAABAq7b5IOycnJ5B1AAAAdBntCkitra2BrgMAAKDL4CJtAAAAAwEJAADAQEACAAAwtDsgnThxIpB1AAAAdBntDkhXX3211q1bF8haAAAAuoR2B6THH39cs2bN0j/8wz/o1KlTgawJAAAgpNodkH7605/qwIEDOnnypNLS0vTWW28Fsi4AAICQafeDIiVp0KBB2r59u377299qypQpGj58uCIi/Hexf//+Ti0QAAAg2Dp8F1tFRYVef/11XXbZZZo0adIFr44oKCjQDTfcoD59+igpKUmTJ0/WkSNH/MacO3dOubm56tu3r+Li4pSdna2amhq/MZWVlcrKylJMTIySkpK0cOFCnT9/vqNTAwAAkNTBM0i///3vtWDBAmVkZOjgwYNKTEz8XgcvLi5Wbm6ubrjhBp0/f16/+MUvNGHCBB06dEixsbGSpPnz5+vtt9/Whg0b5HA4NGfOHE2ZMkXvv/++JKmlpUVZWVlyuVzatWuXqqurNX36dEVGRuqJJ574XvUBAIBLk82yLKs9A++44w7t2bNHzzzzjKZPnx6QYr744gslJSWpuLhYf/d3fyev16vExEStW7dO99xzjyTp8OHDGj58uEpKSjR27Fht3rxZd911l06cOCGn0ylJWrNmjRYtWqQvvvhCUVFR33rc+vp6ORwOeb1e2e32gMwNAAB0rkD+/W73R2wtLS06cOBAwMKRJHm9XklSQkKCJKm0tFTNzc3KyMjwjRk2bJhSUlJUUlIiSSopKdGIESN84UiSMjMzVV9fr4MHD170OI2Njaqvr/d7AQAAtGl3QCoqKlL//v0DVkhra6vmzZuncePG6ZprrpEkeTweRUVFKT4+3m+s0+mUx+PxjfnrcNTW39Z3MQUFBXI4HL7XgAEDOnk2AACgO+syXzWSm5urjz76SOvXrw/4sfLz8+X1en2vqqqqgB8TAAB0Hx26SDtQ5syZo02bNmnnzp1+Z6lcLpeamppUV1fndxappqZGLpfLN2bPnj1++2u7y61tjCk6OlrR0dGdPAsAANBThPQMkmVZmjNnjjZu3Kjt27dr0KBBfv1jxoxRZGSktm3b5ms7cuSIKisr5Xa7JUlut1vl5eWqra31jSkqKpLdbldaWlpwJgIAAHqUkJ5Bys3N1bp16/Tmm2+qT58+vmuGHA6HevfuLYfDoZkzZyovL08JCQmy2+2aO3eu3G63xo4dK0maMGGC0tLSdN9992nlypXyeDxavHixcnNzOUsEAAC+k3bf5h+Qg9tsF21fu3atZsyYIenrB0UuWLBAr776qhobG5WZmannnnvO7+OziooKzZ49Wzt27FBsbKxycnK0YsWKC57y/U24zR8AgO4nkH+/QxqQugoCEgAA3U+XeA4SAADApYKABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGEIakHbu3Km7775bycnJstlseuONN/z6LcvSkiVL1K9fP/Xu3VsZGRk6evSo35hTp05p2rRpstvtio+P18yZM9XQ0BDEWQAAgJ4mpAHpzJkzGjVqlFavXn3R/pUrV2rVqlVas2aNdu/erdjYWGVmZurcuXO+MdOmTdPBgwdVVFSkTZs2aefOnXrwwQeDNQUAANAD2SzLskJdhCTZbDZt3LhRkydPlvT12aPk5GQtWLBAjz76qCTJ6/XK6XSqsLBQP/nJT/Txxx8rLS1Ne/fu1fXXXy9J2rJli+6880599tlnSk5Obtex6+vr5XA45PV6ZbfbAzI/AADQuQL597vLXoN0/PhxeTweZWRk+NocDofS09NVUlIiSSopKVF8fLwvHElSRkaGwsLCtHv37m/cd2Njo+rr6/1eAAAAbbpsQPJ4PJIkp9Pp1+50On19Ho9HSUlJfv0RERFKSEjwjbmYgoICORwO32vAgAGdXD0AAOjOumxACqT8/Hx5vV7fq6qqKtQlAQCALqTLBiSXyyVJqqmp8Wuvqanx9blcLtXW1vr1nz9/XqdOnfKNuZjo6GjZ7Xa/FwAAQJsuG5AGDRokl8ulbdu2+drq6+u1e/duud1uSZLb7VZdXZ1KS0t9Y7Zv367W1lalp6cHvWYAANAzRITy4A0NDTp27Jjv/fHjx1VWVqaEhASlpKRo3rx5+vWvf62rrrpKgwYN0q9+9SslJyf77nQbPny47rjjDj3wwANas2aNmpubNWfOHP3kJz9p9x1sAAAAppAGpH379unWW2/1vc/Ly5Mk5eTkqLCwUD/72c905swZPfjgg6qrq9MPf/hDbdmyRb169fJt88orr2jOnDkaP368wsLClJ2drVWrVgV9LgAAoOfoMs9BCiWegwQAQPdzST4HCQAAIFQISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAQAAGAhIAAAABgISAACAgYAEAABgICABAAAYCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgKHHBKTVq1crNTVVvXr1Unp6uvbs2RPqkgAAQDfVIwLSa6+9pry8PC1dulT79+/XqFGjlJmZqdra2lCXBgAAuqEeEZCeeuopPfDAA7r//vuVlpamNWvWKCYmRi+++GKoSwMAAN1QRKgL+L6amppUWlqq/Px8X1tYWJgyMjJUUlJy0W0aGxvV2Njoe+/1eiVJ9fX1gS0WAAB0mra/25Zldfq+u31A+vLLL9XS0iKn0+nX7nQ6dfjw4YtuU1BQoGXLll3QPmDAgIDUCAAAAufkyZNyOBydus9uH5C+i/z8fOXl5fne19XVaeDAgaqsrOz0HzA6pr6+XgMGDFBVVZXsdnuoy7mksRZdB2vRdbAWXYvX61VKSooSEhI6fd/dPiBdfvnlCg8PV01NjV97TU2NXC7XRbeJjo5WdHT0Be0Oh4P/wXcRdrudtegiWIuug7XoOliLriUsrPMvqe72F2lHRUVpzJgx2rZtm6+ttbVV27Ztk9vtDmFlAACgu+r2Z5AkKS8vTzk5Obr++ut144036plnntGZM2d0//33h7o0AADQDfWIgDR16lR98cUXWrJkiTwej6699lpt2bLlggu3v0l0dLSWLl160Y/dEFysRdfBWnQdrEXXwVp0LYFcD5sViHvjAAAAurFufw0SAABAZyMgAQAAGAhIAAAABgISAACA4ZIPSKtXr1Zqaqp69eql9PR07dmzJ9Ql9Tg7d+7U3XffreTkZNlsNr3xxht+/ZZlacmSJerXr5969+6tjIwMHT161G/MqVOnNG3aNNntdsXHx2vmzJlqaGgI4ix6hoKCAt1www3q06ePkpKSNHnyZB05csRvzLlz55Sbm6u+ffsqLi5O2dnZFzyItbKyUllZWYqJiVFSUpIWLlyo8+fPB3Mq3d7zzz+vkSNH+h446Ha7tXnzZl8/6xA6K1askM1m07x583xtrEfwPPbYY7LZbH6vYcOG+fqDtRaXdEB67bXXlJeXp6VLl2r//v0aNWqUMjMzVVtbG+rSepQzZ85o1KhRWr169UX7V65cqVWrVmnNmjXavXu3YmNjlZmZqXPnzvnGTJs2TQcPHlRRUZE2bdqknTt36sEHHwzWFHqM4uJi5ebm6oMPPlBRUZGam5s1YcIEnTlzxjdm/vz5euutt7RhwwYVFxfrxIkTmjJliq+/paVFWVlZampq0q5du/TSSy+psLBQS5YsCcWUuq3+/ftrxYoVKi0t1b59+3Tbbbdp0qRJOnjwoCTWIVT27t2r3/3udxo5cqRfO+sRXFdffbWqq6t9r/fee8/XF7S1sC5hN954o5Wbm+t739LSYiUnJ1sFBQUhrKpnk2Rt3LjR9761tdVyuVzWb37zG19bXV2dFR0dbb366quWZVnWoUOHLEnW3r17fWM2b95s2Ww26/PPPw9a7T1RbW2tJckqLi62LOvrn31kZKS1YcMG35iPP/7YkmSVlJRYlmVZf/rTn6ywsDDL4/H4xjz//POW3W63GhsbgzuBHuayyy6zXnjhBdYhRE6fPm1dddVVVlFRkXXLLbdYjzzyiGVZ/F4E29KlS61Ro0ZdtC+Ya3HJnkFqampSaWmpMjIyfG1hYWHKyMhQSUlJCCu7tBw/flwej8dvHRwOh9LT033rUFJSovj4eF1//fW+MRkZGQoLC9Pu3buDXnNP4vV6Jcn3RY+lpaVqbm72W49hw4YpJSXFbz1GjBjh9yDWzMxM1dfX+85+oGNaWlq0fv16nTlzRm63m3UIkdzcXGVlZfn93CV+L0Lh6NGjSk5O1g9+8ANNmzZNlZWVkoK7Fj3iSdrfxZdffqmWlpYLnrbtdDp1+PDhEFV16fF4PJJ00XVo6/N4PEpKSvLrj4iIUEJCgm8MOq61tVXz5s3TuHHjdM0110j6+mcdFRWl+Ph4v7Hmelxsvdr60H7l5eVyu906d+6c4uLitHHjRqWlpamsrIx1CLL169dr//792rt37wV9/F4EV3p6ugoLCzV06FBVV1dr2bJluvnmm/XRRx8FdS0u2YAEXOpyc3P10Ucf+X22j+AaOnSoysrK5PV69cc//lE5OTkqLi4OdVmXnKqqKj3yyCMqKipSr169Ql3OJW/ixIm+f48cOVLp6ekaOHCg/vCHP6h3795Bq+OS/Yjt8ssvV3h4+AVXvtfU1MjlcoWoqktP28/6b62Dy+W64ML58+fP69SpU6zVdzRnzhxt2rRJ7777rvr37+9rd7lcampqUl1dnd94cz0utl5tfWi/qKgoDR48WGPGjFFBQYFGjRqlZ599lnUIstLSUtXW1uq6665TRESEIiIiVFxcrFWrVikiIkJOp5P1CKH4+HgNGTJEx44dC+rvxiUbkKKiojRmzBht27bN19ba2qpt27bJ7XaHsLJLy6BBg+RyufzWob6+Xrt37/atg9vtVl1dnUpLS31jtm/frtbWVqWnpwe95u7MsizNmTNHGzdu1Pbt2zVo0CC//jFjxigyMtJvPY4cOaLKykq/9SgvL/cLrUVFRbLb7UpLSwvORHqo1tZWNTY2sg5BNn78eJWXl6usrMz3uv766zVt2jTfv1mP0GloaNAnn3yifv36Bfd34ztdYt5DrF+/3oqOjrYKCwutQ4cOWQ8++KAVHx/vd+U7vr/Tp09bH374ofXhhx9akqynnnrK+vDDD62KigrLsixrxYoVVnx8vPXmm29aBw4csCZNmmQNGjTI+uqrr3z7uOOOO6zRo0dbu3fvtt577z3rqquusu69995QTanbmj17tuVwOKwdO3ZY1dXVvtfZs2d9Yx566CErJSXF2r59u7Vv3z7L7XZbbrfb13/+/HnrmmuusSZMmGCVlZVZW7ZssRITE638/PxQTKnb+vnPf24VFxdbx48ftw4cOGD9/Oc/t2w2m7V161bLsliHUPvru9gsi/UIpgULFlg7duywjh8/br3//vtWRkaGdfnll1u1tbWWZQVvLS7pgGRZlvVv//ZvVkpKihUVFWXdeOON1gcffBDqknqcd99915J0wSsnJ8eyrK9v9f/Vr35lOZ1OKzo62ho/frx15MgRv32cPHnSuvfee624uDjLbrdb999/v3X69OkQzKZ7u9g6SLLWrl3rG/PVV19ZP/3pT63LLrvMiomJsX784x9b1dXVfvv59NNPrYkTJ1q9e/e2Lr/8cmvBggVWc3NzkGfTvf3TP/2TNXDgQCsqKspKTEy0xo8f7wtHlsU6hJoZkFiP4Jk6darVr18/KyoqyrriiiusqVOnWseOHfP1B2stbJZlWd/r3BcAAEAPc8legwQAAPBNCEgAAAAGAhIAAICBgAQAAGAgIAEAABgISAAAAAYCEgAAgIGABAAAYCAgAegyUlNTZbPZZLPZLvgyyu6ssLDQN6958+aFuhwA7UBAAtCpWlpadNNNN2nKlCl+7V6vVwMGDNAvf/nLv7n98uXLVV1dLYfDEcgyVVhYqPj4+IAeo83UqVNVXV3NF2ED3QgBCUCnCg8PV2FhobZs2aJXXnnF1z537lwlJCRo6dKlf3P7Pn36yOVyyWazBbrUTtHS0qLW1ta/OaZ3795yuVyKiooKUlUAvi8CEoBON2TIEK1YsUJz585VdXW13nzzTa1fv14vv/xyh0NC25meTZs2aejQoYqJidE999yjs2fP6qWXXlJqaqouu+wyPfzww2ppafFt19jYqEcffVRXXHGFYmNjlZ6erh07dkiSduzYofvvv19er9f30ddjjz32rdv9dT3//d//rbS0NEVHR6uyslI7duzQjTfeqNjYWMXHx2vcuHGqqKj4vj9KACESEeoCAPRMc+fO1caNG3XfffepvLxcS5Ys0ahRo77Tvs6ePatVq1Zp/fr1On36tKZMmaIf//jHio+P15/+9Cf93//9n7KzszVu3DhNnTpVkjRnzhwdOnRI69evV3JysjZu3Kg77rhD5eXluummm/TMM89oyZIlOnLkiCQpLi7uW7e76qqrfPX8y7/8i1544QX17dtXCQkJuvbaa/XAAw/o1VdfVVNTk/bs2dNtzoIBuAgLAALk448/tiRZI0aMsJqbm791/MCBA62nn37ar23t2rWWJOvYsWO+tlmzZlkxMTHW6dOnfW2ZmZnWrFmzLMuyrIqKCis8PNz6/PPP/fY1fvx4Kz8/37dfh8Ph19/e7SRZZWVlvv6TJ09akqwdO3b8zfndcsst1iOPPPI3xwDoGjiDBCBgXnzxRcXExOj48eP67LPPlJqa+p32ExMToyuvvNL33ul0KjU11XfWp62ttrZWklReXq6WlhYNGTLEbz+NjY3q27fvNx6nvdtFRUVp5MiRvvcJCQmaMWOGMjMzdfvttysjI0P/+I//qH79+n2n+QIIPQISgIDYtWuXnn76aW3dulW//vWvNXPmTP35z3/+Th87RUZG+r232WwXbWu7WLqhoUHh4eEqLS1VeHi437i/DlWm9m7Xu3fvC+axdu1aPfzww9qyZYtee+01LV68WEVFRRo7dmz7JwqgyyAgAeh0Z8+e1YwZMzR79mzdeuutGjRokEaMGKE1a9Zo9uzZAT/+6NGj1dLSotraWt18880XHRMVFeV3UXd7t/u2444ePVr5+flyu91at24dAQnopriLDUCny8/Pl2VZWrFihaSvHwD5r//6r/rZz36mTz/9NODHHzJkiKZNm6bp06fr9ddf1/Hjx7Vnzx4VFBTo7bff9tXU0NCgbdu26csvv9TZs2fbtd3FHD9+XPn5+SopKVFFRYW2bt2qo0ePavjw4QGfK4DAICAB6FTFxcVavXq11q5dq5iYGF/7rFmzdNNNN2nmzJmyLCvgdaxdu1bTp0/XggULNHToUE2ePFl79+5VSkqKJOmmm27SQw89pKlTpyoxMVErV65s13YXExMTo8OHDys7O1tDhgzRgw8+qNzcXM2aNSvg8wQQGDYrGP9PBQDtkJqaqnnz5vXYr+P4+7//e1177bV65plnQl0KgG/BGSQAXcqiRYsUFxcnr9cb6lI6zSuvvKK4uDj9z//8T6hLAdBOnEEC0GVUVFSoublZkvSDH/xAYWE947/hTp8+rZqaGklSfHy8Lr/88hBXBODbEJAAAAAMPeM/zwAAADoRAQkAAMBAQAIAADAQkAAAAAwEJAAAAAMBCQAAwEBAAgAAMBCQAAAADP8PsN1mgrT5m78AAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "landscape = Landscape()\n", "fig, ax = landscape.plot()\n", @@ -132,23 +121,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "91019da5", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[Source(name=Unnamed source, strength=100, pos=(100, 100, 0))]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "my_source = Source(x = 100, y = 100, z = 0, strength = 100)\n", + "cs137 = Isotope(name = \"Cs137\", E = 662.66, b = 0.851)\n", + "my_source = Source(x = 100, y = 100, z = 0, activity = 100, isotope = cs137)\n", "landscape.add_sources(my_source)\n", "\n", "landscape.sources" @@ -156,64 +135,20 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "7913fe1e", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(
,\n", - " )" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "landscape.plot()" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "df4715c1", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(
,\n", - " )" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "landscape.set_path(p2)\n", "landscape.plot()" From 4d7fb541c32af58d101c0dff1f36b78ec4e3b0c5 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 20:42:21 +0100 Subject: [PATCH 17/27] fix notebook --- demo/demo.ipynb | 126 +++++++++++++++++++++++++++++++++++++----------- 1 file changed, 97 insertions(+), 29 deletions(-) diff --git a/demo/demo.ipynb b/demo/demo.ipynb index 6a8f701..1c7e654 100644 --- a/demo/demo.ipynb +++ b/demo/demo.ipynb @@ -12,26 +12,10 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "415fdd25", "metadata": {}, - "outputs": [ - { - "ename": "RuntimeError", - "evalue": "super(): no arguments", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mRuntimeError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 5\u001b[39m\n\u001b[32m 3\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpg_rad\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mdataloader\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m load_data\n\u001b[32m 4\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpg_rad\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mpath\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m path_from_RT90\n\u001b[32m----> \u001b[39m\u001b[32m5\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpg_rad\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mlandscape\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Landscape\n\u001b[32m 6\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpg_rad\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mobjects\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Source\n\u001b[32m 8\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpg_rad\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01misotopes\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Cs137\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/pg-rad/src/pg_rad/landscape.py:6\u001b[39m\n\u001b[32m 3\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnumpy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnp\u001b[39;00m\n\u001b[32m 5\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpg_rad\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mpath\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Path\n\u001b[32m----> \u001b[39m\u001b[32m6\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpg_rad\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mobjects\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Source\n\u001b[32m 8\u001b[39m \u001b[38;5;28;01mclass\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mLandscape\u001b[39;00m:\n\u001b[32m 9\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, size: \u001b[38;5;28mint\u001b[39m | \u001b[38;5;28mtuple\u001b[39m[\u001b[38;5;28mint\u001b[39m, \u001b[38;5;28mint\u001b[39m, \u001b[38;5;28mint\u001b[39m] = \u001b[32m500\u001b[39m, unit = \u001b[33m'\u001b[39m\u001b[33mmeters\u001b[39m\u001b[33m'\u001b[39m):\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/pg-rad/src/pg_rad/objects.py:4\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mmath\u001b[39;00m\n\u001b[32m 2\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtyping\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Self\n\u001b[32m----> \u001b[39m\u001b[32m4\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpg_rad\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01misotopes\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Isotope\n\u001b[32m 6\u001b[39m \u001b[38;5;28;01mclass\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mObject\u001b[39;00m:\n\u001b[32m 7\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__init__\u001b[39m(\n\u001b[32m 8\u001b[39m \u001b[38;5;28mself\u001b[39m,\n\u001b[32m 9\u001b[39m x: \u001b[38;5;28mfloat\u001b[39m,\n\u001b[32m (...)\u001b[39m\u001b[32m 12\u001b[39m name: \u001b[38;5;28mstr\u001b[39m = \u001b[33m\"\u001b[39m\u001b[33mUnnamed object\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 13\u001b[39m color: \u001b[38;5;28mstr\u001b[39m = \u001b[33m'\u001b[39m\u001b[33mgrey\u001b[39m\u001b[33m'\u001b[39m):\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/pg-rad/src/pg_rad/isotopes.py:29\u001b[39m\n\u001b[32m 26\u001b[39m \u001b[38;5;28mself\u001b[39m.E = E\n\u001b[32m 27\u001b[39m \u001b[38;5;28mself\u001b[39m.b = b\n\u001b[32m---> \u001b[39m\u001b[32m29\u001b[39m \u001b[38;5;28;43;01mclass\u001b[39;49;00m\u001b[38;5;250;43m \u001b[39;49m\u001b[34;43;01mCs137\u001b[39;49;00m\u001b[43m(\u001b[49m\u001b[43mIsotope\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\n\u001b[32m 30\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[34;43m__init__\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[32m 31\u001b[39m \u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m \u001b[49m\u001b[43m=\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mCaesium-137\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 32\u001b[39m \u001b[43m \u001b[49m\u001b[43msymbol\u001b[49m\u001b[43m \u001b[49m\u001b[43m=\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mCs137\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 33\u001b[39m \u001b[43m \u001b[49m\u001b[43mE\u001b[49m\u001b[43m \u001b[49m\u001b[43m=\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m662.66\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 34\u001b[39m \u001b[43m \u001b[49m\u001b[43mb\u001b[49m\u001b[43m \u001b[49m\u001b[43m=\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m0.851\u001b[39;49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/pg-rad/src/pg_rad/isotopes.py:30\u001b[39m, in \u001b[36mCs137\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m 29\u001b[39m \u001b[38;5;28;01mclass\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mCs137\u001b[39;00m(Isotope):\n\u001b[32m---> \u001b[39m\u001b[32m30\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m.\u001b[34m__init__\u001b[39m(\n\u001b[32m 31\u001b[39m name = \u001b[33m\"\u001b[39m\u001b[33mCaesium-137\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 32\u001b[39m symbol = \u001b[33m\"\u001b[39m\u001b[33mCs137\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 33\u001b[39m E = \u001b[32m662.66\u001b[39m,\n\u001b[32m 34\u001b[39m b = \u001b[32m0.851\u001b[39m)\n", - "\u001b[31mRuntimeError\u001b[39m: super(): no arguments" - ] - } - ], + "outputs": [], "source": [ "from matplotlib import pyplot as plt\n", "\n", @@ -53,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "5a0e470a", "metadata": {}, "outputs": [], @@ -72,10 +56,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "2ec97553", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-01-27 20:41:53,431 - INFO: Piecewise regression reduced path from 105 to 4 segments.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "p1 = path_from_RT90(df, east_col = \"East\", north_col = \"North\", simplify_path = False)\n", "p2 = path_from_RT90(df, east_col = \"East\", north_col = \"North\", simplify_path = True)\n", @@ -101,10 +103,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "24f1159d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "landscape = Landscape()\n", "fig, ax = landscape.plot()\n", @@ -121,10 +134,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "91019da5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[Source(name=Source 1, pos=(100, 100, 0), isotope=Cs137, A=100 MBq)]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "cs137 = Isotope(name = \"Cs137\", E = 662.66, b = 0.851)\n", "my_source = Source(x = 100, y = 100, z = 0, activity = 100, isotope = cs137)\n", @@ -135,20 +159,64 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "7913fe1e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "landscape.plot()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "df4715c1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "landscape.set_path(p2)\n", "landscape.plot()" From 7a03251c6fb38240cb405371d855b3bc32c018ae Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 20:49:35 +0100 Subject: [PATCH 18/27] rename isotopes.py to isotope.py and update the references --- demo/demo.ipynb | 6 +++--- src/pg_rad/{isotopes.py => isotope.py} | 0 src/pg_rad/objects.py | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) rename src/pg_rad/{isotopes.py => isotope.py} (100%) diff --git a/demo/demo.ipynb b/demo/demo.ipynb index 1c7e654..9daeef0 100644 --- a/demo/demo.ipynb +++ b/demo/demo.ipynb @@ -24,7 +24,7 @@ "from pg_rad.landscape import Landscape\n", "from pg_rad.objects import Source\n", "\n", - "from pg_rad.isotopes import Isotope" + "from pg_rad.isotope import Isotope" ] }, { @@ -64,12 +64,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-01-27 20:41:53,431 - INFO: Piecewise regression reduced path from 105 to 4 segments.\n" + "2026-01-27 20:48:51,754 - INFO: Piecewise regression reduced path from 105 to 4 segments.\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/src/pg_rad/isotopes.py b/src/pg_rad/isotope.py similarity index 100% rename from src/pg_rad/isotopes.py rename to src/pg_rad/isotope.py diff --git a/src/pg_rad/objects.py b/src/pg_rad/objects.py index 3a6a1b1..f0e9c49 100644 --- a/src/pg_rad/objects.py +++ b/src/pg_rad/objects.py @@ -1,7 +1,7 @@ import math from typing import Self -from pg_rad.isotopes import Isotope +from pg_rad.isotope import Isotope class Object: def __init__( From 5a7c2338f38747b02b9325af0941ca7ac48afcb3 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 21:09:13 +0100 Subject: [PATCH 19/27] rename units to scale for the size of the world --- src/pg_rad/landscape.py | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/src/pg_rad/landscape.py b/src/pg_rad/landscape.py index 601b360..3644cba 100644 --- a/src/pg_rad/landscape.py +++ b/src/pg_rad/landscape.py @@ -6,7 +6,12 @@ from pg_rad.path import Path from pg_rad.objects import Source class Landscape: - def __init__(self, size: int | tuple[int, int, int] = 500, unit = 'meters'): + def __init__( + self, + size: int | tuple[int, int, int] = 500, + scale = 'meters', + ): + if isinstance(size, int): self.world = np.zeros((size, size, size)) elif isinstance(size, tuple) and len(size) == 3: @@ -14,7 +19,7 @@ class Landscape: else: raise TypeError("size must be an integer or a tuple of 3 integers.") - self.unit = unit + self.scale = scale self.path: Path = None self.sources: list[Source] = [] @@ -33,8 +38,8 @@ class Landscape: fig, ax = plt.subplots() ax.set_xlim(right=x_lim) ax.set_ylim(top=y_lim) - ax.set_xlabel(f"X [{self.unit}]") - ax.set_ylabel(f"Y [{self.unit}]") + ax.set_xlabel(f"X [{self.scale}]") + ax.set_ylabel(f"Y [{self.scale}]") if not self.path == None: ax.plot(self.path.x_list, self.path.y_list, 'bo-') From 470bf79b698929cafd60e3689737d422d3e8bdd2 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 21:12:04 +0100 Subject: [PATCH 20/27] Add air density. Add docstring for Landscape --- src/pg_rad/landscape.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/pg_rad/landscape.py b/src/pg_rad/landscape.py index 3644cba..85df544 100644 --- a/src/pg_rad/landscape.py +++ b/src/pg_rad/landscape.py @@ -8,9 +8,20 @@ from pg_rad.objects import Source class Landscape: def __init__( self, + air_density: float = 1.243, size: int | tuple[int, int, int] = 500, scale = 'meters', ): + """_A generic Landscape that can contain a Path and sources._ + + Args: + air_density (float, optional): _Air density in kg / m^3_. Defaults to 1.243. + size (int | tuple[int, int, int], optional): _Size of the world_. Defaults to 500. + scale (str, optional): _The scale of the size argument passed_. Defaults to 'meters'. + + Raises: + TypeError: _description_ + """ if isinstance(size, int): self.world = np.zeros((size, size, size)) @@ -19,6 +30,7 @@ class Landscape: else: raise TypeError("size must be an integer or a tuple of 3 integers.") + self.air_density = air_density self.scale = scale self.path: Path = None From f9ff50f4ef5d606ffcbaf1bd32b09cdefe2f6fdf Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Tue, 27 Jan 2026 21:17:02 +0100 Subject: [PATCH 21/27] Clean up all docstrings. --- src/pg_rad/isotope.py | 6 +++--- src/pg_rad/landscape.py | 15 ++++++--------- src/pg_rad/objects.py | 16 ++++++++-------- src/pg_rad/path.py | 27 ++++++++++++--------------- 4 files changed, 29 insertions(+), 35 deletions(-) diff --git a/src/pg_rad/isotope.py b/src/pg_rad/isotope.py index b9e3469..77cb60d 100644 --- a/src/pg_rad/isotope.py +++ b/src/pg_rad/isotope.py @@ -8,9 +8,9 @@ class Isotope: """_Represents the essential information of an isotope._ Args: - name (str): _Full name (e.g. Caesium-137)._ - E (float): _Energy of the primary gamma in keV._ - b (float): _Branching ratio for the gamma at energy E._ + name (str): Full name (e.g. Caesium-137). + E (float): Energy of the primary gamma in keV. + b (float): Branching ratio for the gamma at energy E. """ if E <= 0: diff --git a/src/pg_rad/landscape.py b/src/pg_rad/landscape.py index 85df544..88ac625 100644 --- a/src/pg_rad/landscape.py +++ b/src/pg_rad/landscape.py @@ -15,12 +15,9 @@ class Landscape: """_A generic Landscape that can contain a Path and sources._ Args: - air_density (float, optional): _Air density in kg / m^3_. Defaults to 1.243. - size (int | tuple[int, int, int], optional): _Size of the world_. Defaults to 500. - scale (str, optional): _The scale of the size argument passed_. Defaults to 'meters'. - - Raises: - TypeError: _description_ + air_density (float, optional): Air density in kg / m^3. Defaults to 1.243. + size (int | tuple[int, int, int], optional): Size of the world. Defaults to 500. + scale (str, optional): The scale of the size argument passed. Defaults to 'meters'. """ if isinstance(size, int): @@ -103,11 +100,11 @@ def create_landscape_from_path(path: Path, max_z = 500): the size of the Landscape._ Args: - path (Path): _A Path object describing the trajectory._ - max_z (int, optional): _Height of the world_. Defaults to 500 meters. + path (Path): A Path object describing the trajectory. + max_z (int, optional): Height of the world. Defaults to 500 meters. Returns: - _type_: _A Landscape with dimensions based on the provided Path._ + Landscape: A Landscape with dimensions based on the provided Path. """ max_x = np.ceil(max(path.x_list)) max_y = np.ceil(max(path.y_list)) diff --git a/src/pg_rad/objects.py b/src/pg_rad/objects.py index f0e9c49..752c814 100644 --- a/src/pg_rad/objects.py +++ b/src/pg_rad/objects.py @@ -38,15 +38,15 @@ class Source(Object): """_A point source._ Args: - x (float): _X coordinate._ - y (float): _Y coordinate._ - z (float): _Z coordinate._ - activity (int): _Activity A in MBq._ - isotope (Isotope): _The isotope._ - name (str | None, optional): _Can give the source a unique name_. - Defaults to None, making the name sequential + x (float): X coordinate. + y (float): Y coordinate. + z (float): Z coordinate. + activity (int): Activity A in MBq. + isotope (Isotope): The isotope. + name (str | None, optional): Can give the source a unique name. + Defaults to None, making the name sequential. (Source-1, Source-2, etc.). - color (str, optional): _Matplotlib compatible color string_. Defaults to "red". + color (str, optional): Matplotlib compatible color string. Defaults to "red". """ self.id = Source._id_counter Source._id_counter += 1 diff --git a/src/pg_rad/path.py b/src/pg_rad/path.py index 2f4f873..62122cc 100644 --- a/src/pg_rad/path.py +++ b/src/pg_rad/path.py @@ -45,14 +45,11 @@ class Path: z: float = 0, simplify_path = False ): - """Construct a path of sequences based on a list of coordinates. + """_Construct a path of sequences based on a list of coordinates._ Args: - coord_list (Sequence[tuple[float, float]]): _description_ - z (float, optional): _description_. Defaults to 0. - - Raises: - ValueError: _description_ + coord_list (Sequence[tuple[float, float]]): List of x,y coordinates. + z (float, optional): Height of the path. Defaults to 0. """ if len(coord_list) < 2: @@ -114,12 +111,12 @@ def piecewise_regression_on_path( order to find better global optima." Args: - x (Sequence[float]): _Full list of x coordinates._ - y (Sequence[float]): _Full list of y coordinates._ - keep_endpoints_equal (bool, optional): _Whether or not to force start + x (Sequence[float]): Full list of x coordinates. + y (Sequence[float]): Full list of y coordinates. + keep_endpoints_equal (bool, optional): Whether or not to force start and end to be exactly equal to the original. This will worsen the linear - approximation at the beginning and end of path. Defaults to False._ - n_breakpoints (int, optional): _Number of breakpoints. Defaults to 3._ + approximation at the beginning and end of path. Defaults to False. + n_breakpoints (int, optional): Number of breakpoints. Defaults to 3. Returns: x (Sequence[float]): _Reduced list of x coordinates._ @@ -170,12 +167,12 @@ def path_from_RT90( """_Construct a path from East and North formatted coordinates (RT90) in a Pandas DataFrame._ Args: - df (pd.DataFrame): _DataFrame containing at least the two columns noted in the cols argument._ - east_col (str): _The column name for the East coordinates._ - north_col (str): _The column name for the North coordinates._ + df (pd.DataFrame): DataFrame containing at least the two columns noted in the cols argument. + east_col (str): The column name for the East coordinates. + north_col (str): The column name for the North coordinates. Returns: - Path: _A Path object built from the aquisition coordinates in the DataFrame._ + Path: A Path object built from the aquisition coordinates in the DataFrame. """ east_arr = np.array(df[east_col]) - min(df[east_col]) From d162f9fee3c5bc74247fbdd24e427eb4cf5f1371 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Wed, 28 Jan 2026 08:43:07 +0100 Subject: [PATCH 22/27] improve docstrings for future comptability with mkdocs --- src/pg_rad/isotope.py | 17 ++++++++--------- src/pg_rad/landscape.py | 39 ++++++++++++++++++++++++--------------- src/pg_rad/objects.py | 15 +++++++++++++-- src/pg_rad/path.py | 22 ++++++++++++---------- 4 files changed, 57 insertions(+), 36 deletions(-) diff --git a/src/pg_rad/isotope.py b/src/pg_rad/isotope.py index 77cb60d..ea8be9d 100644 --- a/src/pg_rad/isotope.py +++ b/src/pg_rad/isotope.py @@ -1,18 +1,17 @@ class Isotope: + """Represents the essential information of an isotope. + + Args: + name (str): Full name (e.g. Caesium-137). + E (float): Energy of the primary gamma in keV. + b (float): Branching ratio for the gamma at energy E. + """ def __init__( self, name: str, E: float, b: float - ): - """_Represents the essential information of an isotope._ - - Args: - name (str): Full name (e.g. Caesium-137). - E (float): Energy of the primary gamma in keV. - b (float): Branching ratio for the gamma at energy E. - """ - + ): if E <= 0: raise ValueError("primary_gamma must be a positive energy (keV).") diff --git a/src/pg_rad/landscape.py b/src/pg_rad/landscape.py index 88ac625..e3ebb07 100644 --- a/src/pg_rad/landscape.py +++ b/src/pg_rad/landscape.py @@ -6,20 +6,19 @@ from pg_rad.path import Path from pg_rad.objects import Source class Landscape: + """A generic Landscape that can contain a Path and sources. + + Args: + air_density (float, optional): Air density in kg / m^3. Defaults to 1.243. + size (int | tuple[int, int, int], optional): Size of the world. Defaults to 500. + scale (str, optional): The scale of the size argument passed. Defaults to 'meters'. + """ def __init__( self, air_density: float = 1.243, size: int | tuple[int, int, int] = 500, scale = 'meters', - ): - """_A generic Landscape that can contain a Path and sources._ - - Args: - air_density (float, optional): Air density in kg / m^3. Defaults to 1.243. - size (int | tuple[int, int, int], optional): Size of the world. Defaults to 500. - scale (str, optional): The scale of the size argument passed. Defaults to 'meters'. - """ - + ): if isinstance(size, int): self.world = np.zeros((size, size, size)) elif isinstance(size, tuple) and len(size) == 3: @@ -34,7 +33,7 @@ class Landscape: self.sources: list[Source] = [] def plot(self, z = 0): - """_Plot a slice of the world at a height z._ + """Plot a slice of the world at a height `z`. Args: z (int, optional): Height of slice. Defaults to 0. @@ -78,7 +77,14 @@ class Landscape: return fig, ax def add_sources(self, *sources: Source): - """Add one or more point sources to the world.""" + """Add one or more point sources to the world. + + Args: + *sources (pg_rad.objects.Source): One or more sources, passed as + Source1, Source2, ... + Raises: + ValueError: If the source is outside the boundaries of the landscape. + """ max_x, max_y, max_z = self.world.shape[:3] @@ -88,23 +94,26 @@ class Landscape: 0 <= source.z < max_z) for source in sources ): - raise ValueError("One or more sources are outside the world boundaries.") + raise ValueError("One or more sources are outside the landscape!") self.sources.extend(sources) def set_path(self, path: Path): + """ + Set the path in the landscape. + """ self.path = path def create_landscape_from_path(path: Path, max_z = 500): - """_Generate a Landscape from a path, using its dimensions to determine - the size of the Landscape._ + """Generate a landscape from a path, using its dimensions to determine + the size of the landscape. Args: path (Path): A Path object describing the trajectory. max_z (int, optional): Height of the world. Defaults to 500 meters. Returns: - Landscape: A Landscape with dimensions based on the provided Path. + landscape (pg_rad.landscape.Landscape): A landscape with dimensions based on the provided Path. """ max_x = np.ceil(max(path.x_list)) max_y = np.ceil(max(path.y_list)) diff --git a/src/pg_rad/objects.py b/src/pg_rad/objects.py index 752c814..9e544c8 100644 --- a/src/pg_rad/objects.py +++ b/src/pg_rad/objects.py @@ -11,6 +11,16 @@ class Object: z: float, name: str = "Unnamed object", color: str = 'grey'): + """ + A generic object. + + Args: + x (float): X coordinate. + y (float): Y coordinate. + z (float): Z coordinate. + name (str, optional): Name for the object. Defaults to "Unnamed object". + color (str, optional): Matplotlib compatible color string. Defaults to "red". + """ self.x = x self.y = y @@ -35,7 +45,7 @@ class Source(Object): isotope: Isotope, name: str | None = None, color: str = "red"): - """_A point source._ + """A point source. Args: x (float): X coordinate. @@ -47,7 +57,8 @@ class Source(Object): Defaults to None, making the name sequential. (Source-1, Source-2, etc.). color (str, optional): Matplotlib compatible color string. Defaults to "red". - """ + """ + self.id = Source._id_counter Source._id_counter += 1 diff --git a/src/pg_rad/path.py b/src/pg_rad/path.py index 62122cc..3093153 100644 --- a/src/pg_rad/path.py +++ b/src/pg_rad/path.py @@ -13,11 +13,11 @@ logger = setup_logger(__name__) class PathSegment: def __init__(self, a: tuple[float, float], b: tuple[float, float]): - """_A straight Segment of a Path, from (x_a, y_a) to (x_b, y_b)._ + """A straight Segment of a Path, from (x_a, y_a) to (x_b, y_b). Args: - a (tuple[float, float]): _The starting point (x_a, y_a)._ - b (tuple[float, float]): _The final point (x_b, y_b)._ + a (tuple[float, float]): The starting point (x_a, y_a). + b (tuple[float, float]): The final point (x_b, y_b). """ self.a = a self.b = b @@ -45,7 +45,7 @@ class Path: z: float = 0, simplify_path = False ): - """_Construct a path of sequences based on a list of coordinates._ + """Construct a path of sequences based on a list of coordinates. Args: coord_list (Sequence[tuple[float, float]]): List of x,y coordinates. @@ -95,7 +95,7 @@ def piecewise_regression_on_path( keep_endpoints_equal: bool = False, n_breakpoints: int = 3 ): - """_Take a Path object and return a piece-wise linear approximated Path._ + """From full resolution x and y arrays, return a piecewise linearly approximated/simplified pair of x and y arrays. This function uses the `piecewise_regression` package. From a full set of coordinate pairs, the function fits linear sections, automatically finding @@ -119,8 +119,11 @@ def piecewise_regression_on_path( n_breakpoints (int, optional): Number of breakpoints. Defaults to 3. Returns: - x (Sequence[float]): _Reduced list of x coordinates._ - y (Sequence[float]): _Reduced list of y coordinates._ + x (list[float]): Reduced list of x coordinates. + y (list[float]): Reduced list of y coordinates. + + Raises: + ConvergenceError: If the fitting algorithm failed to simplify the path. Reference: Pilgrim, C., (2021). piecewise-regression (aka segmented regression) in Python. Journal of Open Source Software, 6(68), 3859, https://doi.org/10.21105/joss.03859. @@ -163,11 +166,10 @@ def path_from_RT90( north_col: str = "North", **kwargs ) -> Path: - - """_Construct a path from East and North formatted coordinates (RT90) in a Pandas DataFrame._ + """Construct a path from East and North formatted coordinates (RT90) in a Pandas DataFrame. Args: - df (pd.DataFrame): DataFrame containing at least the two columns noted in the cols argument. + df (pandas.DataFrame): DataFrame containing at least the two columns noted in the cols argument. east_col (str): The column name for the East coordinates. north_col (str): The column name for the North coordinates. From ffb7aa0541e2ecef4a48e87d4b0b805df8e29b6c Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Wed, 28 Jan 2026 08:59:05 +0100 Subject: [PATCH 23/27] rename piecewise_regression_on_path to simplify_path --- src/pg_rad/path.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/pg_rad/path.py b/src/pg_rad/path.py index 3093153..82215d5 100644 --- a/src/pg_rad/path.py +++ b/src/pg_rad/path.py @@ -43,13 +43,14 @@ class Path: self, coord_list: Sequence[tuple[float, float]], z: float = 0, - simplify_path = False + path_simplify = False ): """Construct a path of sequences based on a list of coordinates. Args: coord_list (Sequence[tuple[float, float]]): List of x,y coordinates. z (float, optional): Height of the path. Defaults to 0. + path_simplify (bool, optional): Whether to pg_rad.path.simplify_path(). Defaults to False. """ if len(coord_list) < 2: @@ -57,9 +58,9 @@ class Path: x, y = tuple(zip(*coord_list)) - if simplify_path: + if path_simplify: try: - x, y = piecewise_regression_on_path(list(x), list(y)) + x, y = simplify_path(list(x), list(y)) except ConvergenceError: logger.warning("Continuing without simplifying path.") @@ -89,7 +90,7 @@ class Path: """ plt.plot(self.x_list, self.y_list, **kwargs) -def piecewise_regression_on_path( +def simplify_path( x: Sequence[float], y: Sequence[float], keep_endpoints_equal: bool = False, From b2120fa9917f4195b35257ff32652e8cc8338de3 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Wed, 28 Jan 2026 09:14:55 +0100 Subject: [PATCH 24/27] rename Source to PointSource and move to sources.py --- src/pg_rad/objects.py | 45 +------------------------------------------ src/pg_rad/sources.py | 43 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+), 44 deletions(-) create mode 100644 src/pg_rad/sources.py diff --git a/src/pg_rad/objects.py b/src/pg_rad/objects.py index 9e544c8..39ab185 100644 --- a/src/pg_rad/objects.py +++ b/src/pg_rad/objects.py @@ -1,8 +1,6 @@ import math from typing import Self -from pg_rad.isotope import Isotope - class Object: def __init__( self, @@ -32,45 +30,4 @@ class Object: return math.dist( (self.x, self.y, self.z), (other.x, other.y, other.z), - ) - -class Source(Object): - _id_counter = 1 - def __init__( - self, - x: float, - y: float, - z: float, - activity: int, - isotope: Isotope, - name: str | None = None, - color: str = "red"): - """A point source. - - Args: - x (float): X coordinate. - y (float): Y coordinate. - z (float): Z coordinate. - activity (int): Activity A in MBq. - isotope (Isotope): The isotope. - name (str | None, optional): Can give the source a unique name. - Defaults to None, making the name sequential. - (Source-1, Source-2, etc.). - color (str, optional): Matplotlib compatible color string. Defaults to "red". - """ - - self.id = Source._id_counter - Source._id_counter += 1 - - # default name derived from ID if not provided - if name is None: - name = f"Source {self.id}" - - super().__init__(x, y, z, name, color) - - self.activity = activity - self.isotope = isotope - self.color = color - - def __repr__(self): - return f"Source(name={self.name}, pos={(self.x, self.y, self.z)}, isotope={self.isotope.name}, A={self.activity} MBq)" \ No newline at end of file + ) \ No newline at end of file diff --git a/src/pg_rad/sources.py b/src/pg_rad/sources.py new file mode 100644 index 0000000..9c85353 --- /dev/null +++ b/src/pg_rad/sources.py @@ -0,0 +1,43 @@ +from pg_rad.objects import Object +from pg_rad.isotope import Isotope + +class PointSource(Object): + _id_counter = 1 + def __init__( + self, + x: float, + y: float, + z: float, + activity: int, + isotope: Isotope, + name: str | None = None, + color: str = "red"): + """A point source. + + Args: + x (float): X coordinate. + y (float): Y coordinate. + z (float): Z coordinate. + activity (int): Activity A in MBq. + isotope (Isotope): The isotope. + name (str | None, optional): Can give the source a unique name. + Defaults to None, making the name sequential. + (Source-1, Source-2, etc.). + color (str, optional): Matplotlib compatible color string. Defaults to "red". + """ + + self.id = PointSource._id_counter + PointSource._id_counter += 1 + + # default name derived from ID if not provided + if name is None: + name = f"Source {self.id}" + + super().__init__(x, y, z, name, color) + + self.activity = activity + self.isotope = isotope + self.color = color + + def __repr__(self): + return f"PointSource(name={self.name}, pos={(self.x, self.y, self.z)}, isotope={self.isotope.name}, A={self.activity} MBq)" \ No newline at end of file From 47197e5e110f3f48ad416c82888276640a8975b6 Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Wed, 28 Jan 2026 09:16:26 +0100 Subject: [PATCH 25/27] refactor to change Source to PointSource --- src/pg_rad/landscape.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/pg_rad/landscape.py b/src/pg_rad/landscape.py index e3ebb07..cd9e4f8 100644 --- a/src/pg_rad/landscape.py +++ b/src/pg_rad/landscape.py @@ -3,7 +3,7 @@ from matplotlib.patches import Circle import numpy as np from pg_rad.path import Path -from pg_rad.objects import Source +from pg_rad.sources import PointSource class Landscape: """A generic Landscape that can contain a Path and sources. @@ -30,7 +30,7 @@ class Landscape: self.scale = scale self.path: Path = None - self.sources: list[Source] = [] + self.sources: list[PointSource] = [] def plot(self, z = 0): """Plot a slice of the world at a height `z`. @@ -76,11 +76,11 @@ class Landscape: return fig, ax - def add_sources(self, *sources: Source): + def add_sources(self, *sources: PointSource): """Add one or more point sources to the world. Args: - *sources (pg_rad.objects.Source): One or more sources, passed as + *sources (pg_rad.sources.PointSource): One or more sources, passed as Source1, Source2, ... Raises: ValueError: If the source is outside the boundaries of the landscape. From 56caeb9e3a66d79d7082f3d3ec0cb190386c0a1d Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Wed, 28 Jan 2026 09:38:04 +0100 Subject: [PATCH 26/27] add CI for mkdocs --- .github/workflows/ci.yml | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 .github/workflows/ci.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..3ff578e --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,29 @@ +name: ci +on: + push: + branches: + - master + - main +permissions: + contents: write +jobs: + deploy: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Configure Git Credentials + run: | + git config user.name github-actions[bot] + git config user.email 41898282+github-actions[bot]@users.noreply.github.com + - uses: actions/setup-python@v5 + with: + python-version: 3.x + - run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV + - uses: actions/cache@v4 + with: + key: mkdocs-material-${{ env.cache_id }} + path: .cache + restore-keys: | + mkdocs-material- + - run: pip install mkdocs-material + - run: mkdocs gh-deploy --force \ No newline at end of file From 9302af4624ca07e1ff520ecafa0690b1a8959a1c Mon Sep 17 00:00:00 2001 From: Pim Nelissen Date: Wed, 28 Jan 2026 09:39:55 +0100 Subject: [PATCH 27/27] Add mkdocs backbone and minimal content --- .../landscape/create_landscape_from_path.md | 4 ++ docs/API/landscape/landscape.md | 4 ++ docs/API/objects/object.md | 5 +++ docs/API/path/path.md | 4 ++ docs/API/path/path_from_RT90.md | 5 +++ docs/API/path/simplify_path.md | 4 ++ docs/API/sources/point_source.md | 5 +++ docs/index.md | 45 +++++++++++++++++++ docs/pg-rad-in-cli.md | 4 ++ docs/pg-rad-in-python.md | 5 +++ mkdocs.yml | 41 +++++++++++++++++ pyproject.toml | 2 +- 12 files changed, 127 insertions(+), 1 deletion(-) create mode 100644 docs/API/landscape/create_landscape_from_path.md create mode 100644 docs/API/landscape/landscape.md create mode 100644 docs/API/objects/object.md create mode 100644 docs/API/path/path.md create mode 100644 docs/API/path/path_from_RT90.md create mode 100644 docs/API/path/simplify_path.md create mode 100644 docs/API/sources/point_source.md create mode 100644 docs/index.md create mode 100644 docs/pg-rad-in-cli.md create mode 100644 docs/pg-rad-in-python.md create mode 100644 mkdocs.yml diff --git a/docs/API/landscape/create_landscape_from_path.md b/docs/API/landscape/create_landscape_from_path.md new file mode 100644 index 0000000..75c3b28 --- /dev/null +++ b/docs/API/landscape/create_landscape_from_path.md @@ -0,0 +1,4 @@ +--- +title: pg_rad.landscape.create_landscape_from_path +--- +::: pg_rad.landscape.create_landscape_from_path \ No newline at end of file diff --git a/docs/API/landscape/landscape.md b/docs/API/landscape/landscape.md new file mode 100644 index 0000000..dc4c9a6 --- /dev/null +++ b/docs/API/landscape/landscape.md @@ -0,0 +1,4 @@ +--- +title: pg_rad.landscape.Landscape +--- +::: pg_rad.landscape.Landscape \ No newline at end of file diff --git a/docs/API/objects/object.md b/docs/API/objects/object.md new file mode 100644 index 0000000..188c8aa --- /dev/null +++ b/docs/API/objects/object.md @@ -0,0 +1,5 @@ +--- +title: pg_rad.objects.Object +--- + +::: pg_rad.objects.Object \ No newline at end of file diff --git a/docs/API/path/path.md b/docs/API/path/path.md new file mode 100644 index 0000000..302b51b --- /dev/null +++ b/docs/API/path/path.md @@ -0,0 +1,4 @@ +--- +title: pg_rad.path.Path +--- +::: pg_rad.path.Path \ No newline at end of file diff --git a/docs/API/path/path_from_RT90.md b/docs/API/path/path_from_RT90.md new file mode 100644 index 0000000..76f34ea --- /dev/null +++ b/docs/API/path/path_from_RT90.md @@ -0,0 +1,5 @@ +--- +title: pg_rad.path.path_from_RT90 +--- +::: pg_rad.path.path_from_RT90 + diff --git a/docs/API/path/simplify_path.md b/docs/API/path/simplify_path.md new file mode 100644 index 0000000..23294fb --- /dev/null +++ b/docs/API/path/simplify_path.md @@ -0,0 +1,4 @@ +--- +title: pg_rad.path.simplify_path +--- +::: pg_rad.path.simplify_path \ No newline at end of file diff --git a/docs/API/sources/point_source.md b/docs/API/sources/point_source.md new file mode 100644 index 0000000..5d7732e --- /dev/null +++ b/docs/API/sources/point_source.md @@ -0,0 +1,5 @@ +--- +title: pg_rad.sources.PointSource +--- + +::: pg_rad.sources.PointSource \ No newline at end of file diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000..ca4d696 --- /dev/null +++ b/docs/index.md @@ -0,0 +1,45 @@ +# Welcome! + +Primary Gamma RADiation Landscapes (PG-RAD) is a Python package for research in source localization. It can simulate mobile gamma spectrometry data acquired from vehicle-borne detectors along a predefined path (e.g. a road). + +## Requirements + +PG-RAD requires Python `3.12`. The guides below assume a unix-like system. + +## Installation (CLI) + + + +Lorem ipsum + +## Installation (Python module) + +If you are interested in using PG-RAD in another Python project, create a virtual environment first: + +``` +python3 -m venv .venv +``` + +Then install PG-RAD in it: + +``` +source .venv/bin/activate +(.venv) pip install git+https://github.com/pim-n/pg-rad +``` + +See how to get started with PG-RAD with your own Python code [here](pg-rad-in-python). + +## For developers +``` +git clone https://github.com/pim-n/pg-rad +cd pg-rad +git checkout dev +``` + +or + +``` +git@github.com:pim-n/pg-rad.git +cd pg-rad +git checkout dev +``` \ No newline at end of file diff --git a/docs/pg-rad-in-cli.md b/docs/pg-rad-in-cli.md new file mode 100644 index 0000000..fedb76c --- /dev/null +++ b/docs/pg-rad-in-cli.md @@ -0,0 +1,4 @@ +--- +title: Using PG-RAD in CLI +--- +Lorem ipsum. \ No newline at end of file diff --git a/docs/pg-rad-in-python.md b/docs/pg-rad-in-python.md new file mode 100644 index 0000000..8332390 --- /dev/null +++ b/docs/pg-rad-in-python.md @@ -0,0 +1,5 @@ +--- +title: Using PG-RAD as a module +--- + +Consult the API documentation in the side bar. \ No newline at end of file diff --git a/mkdocs.yml b/mkdocs.yml new file mode 100644 index 0000000..659692d --- /dev/null +++ b/mkdocs.yml @@ -0,0 +1,41 @@ +site_name: PG-RAD Documentation +theme: + name: material + palette: + # Dark Mode + - scheme: slate + toggle: + icon: material/weather-sunny + name: Dark mode + primary: blue + accent: deep purple + + # Light Mode + - scheme: default + toggle: + icon: material/weather-night + name: Light mode + primary: light blue + accent: blue + features: + - content.code.copy + +markdown_extensions: + - pymdownx.highlight: + anchor_linenums: true + line_spans: __span + pygments_lang_class: true + - pymdownx.inlinehilite + - pymdownx.snippets + - pymdownx.superfences + +plugins: +- mkdocstrings: + enabled: !ENV [ENABLE_MKDOCSTRINGS, true] + default_handler: python + locale: en + handlers: + python: + options: + show_source: false + show_root_heading: false \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 1b0ad50..033bb38 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -29,4 +29,4 @@ Homepage = "https://github.com/pim-n/pg-rad" Issues = "https://github.com/pim-n/pg-rad/issues" [project.optional-dependencies] -dev = ["pytest", "notebook"] \ No newline at end of file +dev = ["pytest", "notebook", "mkdocs-material", "mkdocstrings-python"] \ No newline at end of file