diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index b2abebb3..4091082e 100644 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -16,7 +16,7 @@ jobs: strategy: fail-fast: false matrix: - python-version: ["3.7", "3.8", "3.9", "3.10"] + python-version: ["3.8", "3.9", "3.10"] steps: - uses: actions/checkout@v3 diff --git a/.gitignore b/.gitignore index 2ae8dbdb..7587e5c4 100644 --- a/.gitignore +++ b/.gitignore @@ -16,9 +16,9 @@ __pycache__/* # Log folders **/lightning_logs/** -**/fluid_logs/** -**/Multiscale/** **/bosch/** +**/experiments/** +**/fluid_logs/** # Project files .ropeproject .project @@ -57,3 +57,4 @@ MANIFEST .venv*/ .conda*/ _venv/ +.env/ diff --git a/2.0.0 b/2.0.0 new file mode 100644 index 00000000..4d477a87 --- /dev/null +++ b/2.0.0 @@ -0,0 +1,108 @@ +Collecting package metadata (current_repodata.json): ...working... done +Solving environment: ...working... done + +## Package Plan ## + + environment location: C:\python\torchphysics\_venv + + added / updated specs: + - pytorch-lightning + + +The following packages will be downloaded: + + package | build + ---------------------------|----------------- + comm-0.2.1 | py310haa95532_0 15 KB defaults + debugpy-1.6.7 | py310hd77b12b_0 2.9 MB defaults + exceptiongroup-1.2.0 | py310haa95532_0 31 KB defaults + filelock-3.13.1 | py310haa95532_0 22 KB defaults + fsspec-2024.3.1 | py310haa95532_0 278 KB defaults + gmpy2-2.1.2 | py310h7f96b67_0 160 KB defaults + ipykernel-6.28.0 | py310haa95532_0 199 KB defaults + ipython-8.25.0 | py310haa95532_0 1.2 MB defaults + jupyter_client-7.1.2 | pyhd3eb1b0_0 93 KB defaults + jupyter_core-5.7.2 | py310haa95532_0 110 KB defaults + libuv-1.48.0 | h827c3e9_0 322 KB defaults + lightning-utilities-0.9.0 | py310haa95532_0 38 KB defaults + mpc-1.1.0 | h7edee0f_1 260 KB defaults + mpfr-4.0.2 | h62dcd97_1 1.5 MB defaults + mpir-3.0.0 | hec2e145_1 1.3 MB defaults + mpmath-1.3.0 | py310haa95532_0 834 KB defaults + networkx-3.3 | py310haa95532_0 2.5 MB defaults + numpy-1.26.4 | py310h055cbcc_0 11 KB defaults + numpy-base-1.26.4 | py310h65a83cf_0 8.6 MB defaults + openssl-1.1.1w | h2bbff1b_0 5.5 MB defaults + platformdirs-3.10.0 | py310haa95532_0 36 KB defaults + prompt-toolkit-3.0.43 | py310haa95532_0 592 KB defaults + prompt_toolkit-3.0.43 | hd3eb1b0_0 5 KB defaults + pytorch-2.3.0 |cpu_py310h9432977_0 111.3 MB defaults + pytorch-lightning-2.3.0 | py310haa95532_0 874 KB defaults + pyyaml-6.0.1 | py310h2bbff1b_0 155 KB defaults + pyzmq-25.1.2 | py310hd77b12b_0 412 KB defaults + qtpy-2.4.1 | py310haa95532_0 127 KB defaults + sympy-1.12 | py310haa95532_0 10.5 MB defaults + torchmetrics-1.4.0.post0 | py310haa95532_0 698 KB defaults + tqdm-4.66.4 | py310h9909e9c_0 162 KB defaults + traitlets-5.14.3 | py310haa95532_0 182 KB defaults + typing-extensions-4.11.0 | py310haa95532_0 10 KB defaults + typing_extensions-4.11.0 | py310haa95532_0 62 KB defaults + ------------------------------------------------------------ + Total: 150.9 MB + +The following NEW packages will be INSTALLED: + + blas artifactory/anaconda-pkgs-remote/main/win-64::blas-1.0-mkl + comm artifactory/anaconda-pkgs-remote/main/win-64::comm-0.2.1-py310haa95532_0 + exceptiongroup artifactory/anaconda-pkgs-remote/main/win-64::exceptiongroup-1.2.0-py310haa95532_0 + filelock artifactory/anaconda-pkgs-remote/main/win-64::filelock-3.13.1-py310haa95532_0 + fsspec artifactory/anaconda-pkgs-remote/main/win-64::fsspec-2024.3.1-py310haa95532_0 + gmpy2 artifactory/anaconda-pkgs-remote/main/win-64::gmpy2-2.1.2-py310h7f96b67_0 + intel-openmp artifactory/anaconda-pkgs-remote/main/win-64::intel-openmp-2023.1.0-h59b6b97_46320 + ipykernel artifactory/anaconda-pkgs-remote/main/win-64::ipykernel-6.28.0-py310haa95532_0 + ipython artifactory/anaconda-pkgs-remote/main/win-64::ipython-8.25.0-py310haa95532_0 + jupyter_client artifactory/anaconda-pkgs-remote/main/noarch::jupyter_client-7.1.2-pyhd3eb1b0_0 + libsodium artifactory/anaconda-pkgs-remote/main/win-64::libsodium-1.0.18-h62dcd97_0 + libuv artifactory/anaconda-pkgs-remote/main/win-64::libuv-1.48.0-h827c3e9_0 + lightning-utiliti~ artifactory/anaconda-pkgs-remote/main/win-64::lightning-utilities-0.9.0-py310haa95532_0 + mkl artifactory/anaconda-pkgs-remote/main/win-64::mkl-2023.1.0-h6b88ed4_46358 + mkl-service artifactory/anaconda-pkgs-remote/main/win-64::mkl-service-2.4.0-py310h2bbff1b_1 + mkl_fft artifactory/anaconda-pkgs-remote/main/win-64::mkl_fft-1.3.8-py310h2bbff1b_0 + mkl_random artifactory/anaconda-pkgs-remote/main/win-64::mkl_random-1.2.4-py310h59b6b97_0 + mpc artifactory/anaconda-pkgs-remote/main/win-64::mpc-1.1.0-h7edee0f_1 + mpfr artifactory/anaconda-pkgs-remote/main/win-64::mpfr-4.0.2-h62dcd97_1 + mpir artifactory/anaconda-pkgs-remote/main/win-64::mpir-3.0.0-hec2e145_1 + mpmath artifactory/anaconda-pkgs-remote/main/win-64::mpmath-1.3.0-py310haa95532_0 + networkx artifactory/anaconda-pkgs-remote/main/win-64::networkx-3.3-py310haa95532_0 + numpy artifactory/anaconda-pkgs-remote/main/win-64::numpy-1.26.4-py310h055cbcc_0 + numpy-base artifactory/anaconda-pkgs-remote/main/win-64::numpy-base-1.26.4-py310h65a83cf_0 + platformdirs artifactory/anaconda-pkgs-remote/main/win-64::platformdirs-3.10.0-py310haa95532_0 + psutil artifactory/anaconda-pkgs-remote/main/win-64::psutil-5.9.0-py310h2bbff1b_0 + pytorch artifactory/anaconda-pkgs-remote/main/win-64::pytorch-2.3.0-cpu_py310h9432977_0 + pytorch-lightning artifactory/anaconda-pkgs-remote/main/win-64::pytorch-lightning-2.3.0-py310haa95532_0 + pyyaml artifactory/anaconda-pkgs-remote/main/win-64::pyyaml-6.0.1-py310h2bbff1b_0 + pyzmq artifactory/anaconda-pkgs-remote/main/win-64::pyzmq-25.1.2-py310hd77b12b_0 + qtpy artifactory/anaconda-pkgs-remote/main/win-64::qtpy-2.4.1-py310haa95532_0 + sympy artifactory/anaconda-pkgs-remote/main/win-64::sympy-1.12-py310haa95532_0 + tbb artifactory/anaconda-pkgs-remote/main/win-64::tbb-2021.8.0-h59b6b97_0 + torchmetrics artifactory/anaconda-pkgs-remote/main/win-64::torchmetrics-1.4.0.post0-py310haa95532_0 + tqdm artifactory/anaconda-pkgs-remote/main/win-64::tqdm-4.66.4-py310h9909e9c_0 + yaml artifactory/anaconda-pkgs-remote/main/win-64::yaml-0.2.5-he774522_0 + zeromq artifactory/anaconda-pkgs-remote/main/win-64::zeromq-4.3.5-hd77b12b_0 + +The following packages will be UPDATED: + + ca-certificates 2022.6.15-boschca_h5b45459_0 --> 2024.7.4-boschca_h56e8100_0 + certifi bosch-ca-injected/win-64::certifi-202~ --> bosch-ca-injected/noarch::certifi-2024.7.4-boschca_pyhd8ed1ab_0 + debugpy 1.5.1-py310hd77b12b_0 --> 1.6.7-py310hd77b12b_0 + jupyter_core 4.10.0-py310haa95532_0 --> 5.7.2-py310haa95532_0 + openssl 1.1.1p-h2bbff1b_0 --> 1.1.1w-h2bbff1b_0 + prompt-toolkit artifactory/anaconda-pkgs-remote/main~ --> artifactory/anaconda-pkgs-remote/main/win-64::prompt-toolkit-3.0.43-py310haa95532_0 + prompt_toolkit 3.0.20-hd3eb1b0_0 --> 3.0.43-hd3eb1b0_0 + traitlets artifactory/anaconda-pkgs-remote/main~ --> artifactory/anaconda-pkgs-remote/main/win-64::traitlets-5.14.3-py310haa95532_0 + typing-extensions artifactory/anaconda-pkgs-remote/main~ --> artifactory/anaconda-pkgs-remote/main/win-64::typing-extensions-4.11.0-py310haa95532_0 + typing_extensions artifactory/anaconda-pkgs-remote/main~ --> artifactory/anaconda-pkgs-remote/main/win-64::typing_extensions-4.11.0-py310haa95532_0 + vs2015_runtime 14.27.29016-h5e58377_2 --> 14.29.30133-h43f2093_4 + + +Proceed ([y]/n)? \ No newline at end of file diff --git a/AUTHORS.rst b/AUTHORS.rst index 4b9da0e4..af934369 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -4,3 +4,4 @@ Contributors * Nick Heilenkötter, nheilenkoetter * Tom Freudenberg, TomF98 +* Daniel Kreuter, dkreuter diff --git a/README.rst b/README.rst index 28a0044e..d5640d1f 100644 --- a/README.rst +++ b/README.rst @@ -80,28 +80,20 @@ Installation ============ TorchPhysics reqiueres the follwing dependencies to be installed: -- PyTorch_ >= 1.7.1, < 2.0.0 -- `PyTorch Lightning`_ >= 1.3.4, < 2.0.0 -- Numpy_ >= 1.20.2 +- Python >= 3.8 +- PyTorch_ >= 2.0.0 +- `PyTorch Lightning`_ >= 2.0.0 +- Numpy_ >= 1.20.2, < 2.0 - Matplotlib_ >= 3.0.0 - Scipy_ >= 1.6.3 -Installing TorchPhysics with ``pip``, automatically downloads everything that is needed: +To install TorchPhysics you can run the following code in any Python environment where ``pip`` is installed .. code-block:: python pip install torchphysics -Additionally, to use the ``Shapely`` and ``Trimesh`` functionalities, install the library -with the option ``all``: - -.. code-block:: python - - pip install torchphysics[all] - - -If you want to add functionalities or modify the code. We recommend copying the -repository and installing it locally: +Or by .. code-block:: python @@ -109,6 +101,8 @@ repository and installing it locally: cd path_to_torchphysics_folder pip install .[all] +if you want to modify the code. + .. _Numpy: https://numpy.org/ .. _Matplotlib: https://matplotlib.org/ .. _Scipy: https://scipy.org/ diff --git a/docs/requirements.txt b/docs/requirements.txt index 8d9bbe5d..23c52afd 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -5,8 +5,8 @@ protobuf~=3.19.0 # fix github test and docu creation sphinx>=3.2.1 sphinx_rtd_theme -torch>=1.7.1 -pytorch-lightning>=1.3.4 +torch>=2.0.0 +pytorch-lightning>=2.0.0 numpy>=1.20.2 matplotlib>=3.4.2 trimesh>=3.9.19 diff --git a/docs/tutorial/solve_pde.rst b/docs/tutorial/solve_pde.rst index f8df86cb..f0cdb937 100644 --- a/docs/tutorial/solve_pde.rst +++ b/docs/tutorial/solve_pde.rst @@ -169,11 +169,12 @@ Afterwards we switch to LBFGS: solver = tp.solver.Solver(train_conditions=[bound_cond, pde_cond], optimizer_setting=optim) - trainer = pl.Trainer(gpus=1, - max_steps=3000, # number of training steps - logger=False, - benchmark=True, - checkpoint_callback=False) + trainer = pl.Trainer(devices=1, accelerator="gpu", + num_sanity_val_steps=0, + benchmark=True, + max_steps=3000, + logger=False, + enable_checkpointing=False) trainer.fit(solver) diff --git a/docs/tutorial/solver_info.rst b/docs/tutorial/solver_info.rst index c2fdfd04..41907b28 100644 --- a/docs/tutorial/solver_info.rst +++ b/docs/tutorial/solver_info.rst @@ -22,15 +22,20 @@ the basic trainer is defined as follows: import pytorch_lightning as pl - trainer = pl.Trainer(gpus=1, max_steps=4000, check_val_every_n_epoch=10) + trainer = pl.Trainer(devices=1, accelerator="gpu", + max_steps=4000, check_val_every_n_epoch=10) trainer.fit(solver) # start training Some important keywords are: -- **gpus**: The number of GPUs that should be used. If only one or more CPUs are available - set ```gpus=None``. Depending on the operating system, the GPUs may have to be further - specified beforehand via ``os.environ`` or other ways. There are more different possiblities to - specify the used device, see the above mentionde documentation. +- **devices**: The number of devices that should be used. +- **accelerator**: On what kind of device the network will be trained. + Usually, one needs at least one GPU to train a neural network sufficiently well. If only + CPUs are available set ``"cpu"``. + Depending on the operating system, the GPUs may have to be further + specified beforehand via ``os.environ`` or other ways. + There are more different possibilities to specify the used device, + see the above-mentioned documentation. - **max_steps**: The maximum number of training iterations. In each iteration all defined training conditions will be evaluated (e.g. points sampled, model output computed, residuals evaluated, etc.) and a diff --git a/examples/deeponet/inverse_ode.ipynb b/examples/deeponet/inverse_ode.ipynb index 86e32b34..025df2da 100644 --- a/examples/deeponet/inverse_ode.ipynb +++ b/examples/deeponet/inverse_ode.ipynb @@ -258,13 +258,12 @@ "\n", "solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus='-1' if torch.cuda.is_available() else None,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " max_steps=10000,\n", - " logger=False,\n", - " checkpoint_callback=False\n", - " )\n", + " max_steps=10000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "\n", "trainer.fit(solver)" ] @@ -327,13 +326,12 @@ "\n", "solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus='-1' if torch.cuda.is_available() else None,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " max_steps=1000,\n", - " logger=False,\n", - " checkpoint_callback=False\n", - " )\n", + " max_steps=1000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "\n", "trainer.fit(solver)" ] diff --git a/examples/deeponet/ode.ipynb b/examples/deeponet/ode.ipynb index 49e5f684..217392e9 100644 --- a/examples/deeponet/ode.ipynb +++ b/examples/deeponet/ode.ipynb @@ -191,13 +191,12 @@ "\n", "solver = tp.solver.Solver([ode_cond, initial_cond], optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus='-1' if torch.cuda.is_available() else None,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " max_steps=5000,\n", - " logger=False,\n", - " checkpoint_callback=False\n", - " )\n", + " max_steps=5000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "\n", "trainer.fit(solver)" ] @@ -284,11 +283,12 @@ "\n", "solver = tp.solver.Solver(train_conditions=[ode_cond, initial_cond], optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=3000, \n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=3000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", " \n", "trainer.fit(solver)" ] diff --git a/examples/deeponet/oscillator.ipynb b/examples/deeponet/oscillator.ipynb index ce72b9c6..c0687033 100644 --- a/examples/deeponet/oscillator.ipynb +++ b/examples/deeponet/oscillator.ipynb @@ -8,8 +8,8 @@ "source": [ "import os\n", "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"3\"\n", - "import torch\n", "import torchphysics as tp\n", + "import torch\n", "import pytorch_lightning as pl" ] }, @@ -219,13 +219,12 @@ "source": [ "solver = tp.solver.Solver([ode_cond])\n", "\n", - "trainer = pl.Trainer(gpus='-1' if torch.cuda.is_available() else None,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " max_steps=2000,\n", - " logger=False,\n", - " checkpoint_callback=False\n", - " )\n", + " max_steps=30000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "\n", "trainer.fit(solver)" ] @@ -311,12 +310,12 @@ "\n", "solver = tp.solver.Solver(train_conditions=[ode_cond], optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=2500, \n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", - " \n", + " max_steps=2500, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "trainer.fit(solver)" ] }, @@ -454,10 +453,10 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.15" + "version": "3.11.7" }, "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2 -} \ No newline at end of file +} diff --git a/examples/deepritz/corner_pde.ipynb b/examples/deepritz/corner_pde.ipynb index 0bbadad5..f2197ab3 100644 --- a/examples/deepritz/corner_pde.ipynb +++ b/examples/deepritz/corner_pde.ipynb @@ -161,12 +161,12 @@ "source": [ "import pytorch_lightning as pl\n", "\n", - "trainer = pl.Trainer(gpus=1, # or None if CPU is used\n", - " max_steps=5000, # number of training steps\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", - " \n", + " max_steps=5000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "trainer.fit(solver)" ] }, @@ -245,11 +245,12 @@ "bound_cond.sampler = bound_cond.sampler.make_static() \n", "solver = tp.solver.Solver(train_conditions=[bound_cond, pde_cond], optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=3000, # number of training steps\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=3000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", " \n", "trainer.fit(solver)" ] diff --git a/examples/deepritz/poisson-equation.ipynb b/examples/deepritz/poisson-equation.ipynb index 8b797e84..c1a0da31 100644 --- a/examples/deepritz/poisson-equation.ipynb +++ b/examples/deepritz/poisson-equation.ipynb @@ -14,8 +14,11 @@ "metadata": {}, "outputs": [], "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n", "import torch\n", - "import torchphysics as tp" + "import torchphysics as tp\n", + "import pytorch_lightning as pl" ] }, { @@ -238,15 +241,12 @@ "solver = tp.solver.Solver([pde_condition,\n", " boundary_condition])\n", "\n", - "import pytorch_lightning as pl\n", - "import os\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n", - "\n", - "trainer = pl.Trainer(gpus=None, # or None for CPU\n", - " max_steps=2000,\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=2000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "trainer.fit(solver)" ] }, diff --git a/examples/oscillation/duffing_nonlinear.ipynb b/examples/oscillation/duffing_nonlinear.ipynb index 894182d0..7bb98e35 100644 --- a/examples/oscillation/duffing_nonlinear.ipynb +++ b/examples/oscillation/duffing_nonlinear.ipynb @@ -164,7 +164,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -200,7 +200,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3kAAAIZCAYAAAAbc/Y7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAADcbUlEQVR4nOzdd3gUVRfH8e+kAwkBEnroEHoPvSqgiBRREcECdkXE3nv3tQJ2mqAigopSBJQmvSWUAKH3QAghgVRSd94/JigqICWb2d38Ps+zz7YpJ5lkd87ce881TNNEREREREREPIOX3QGIiIiIiIhIwVGSJyIiIiIi4kGU5ImIiIiIiHgQJXkiIiIiIiIeREmeiIiIiIiIB1GSJyIiIiIi4kGU5ImIiIiIiHgQJXkiIlKoDMPYbxjGKcMw0gzDOGoYxkTDMALtjutMhmG8YhjGt2c8r2wYxnbDMEYbhmH8x7p/GIZx9z9eMw3DqO2seEVERM6kJE9EROzQxzTNQKAZ0Bx41t5wzs0wjGrAUmCmaZojTNM07Y5JRETkfJTkiYiIbUzTPAr8BjQzDKOrYRixZ76f3+rXPf/xK4ZhTDMM42vDMFINw9hqGEbEGcu2MAxjQ/57PxiGMdUwjDfOeL+3YRgbDcM4aRjGSsMwmvxXfIZh1MJK8CabpvnUGXGc2cpXPb+lzscwjDeBTsAn+S2VnxiGsTR/0U35rw00DKO0YRizDcNIMAzjRP7jsEv+RYqIiJxBSZ6IiNgmP7G5Bth9gav0Bb4HSgEzgU/yt+MH/AxMBMoAU4D+Z+ynOTABuA8IAb4EZhqG4X+efdXESvC+NE3zpQsJzjTN54FlwHDTNANN0xxummbn/Leb5r82Fev79yugGlAVOHX6ZxEREblcSvJERMQOvxiGkQocAo4BL1/gestN05xjmmYe8A3QNP/1toAPMNo0zRzTNKcDa89Y716sZG2NaZp5pmlOArLy1zuXRkAJYOoF/1QXyDTNRNM0fzJNM8M0zVTgTaBLQe9HRESKJiV5IiJih+tM0wwCugL1gNALXO/oGY8zgADDMHyASsDhf4yXO3TG42rA4/ldNU8ahnESqAJUMgzjlvxulGmGYcw9Y52ZWK1/i/LH5RUYwzCKG4bxpWEYBwzDSMFqMSxlGIZ3Qe5HRESKJiV5IiJiG9M0l2B1sXwfSAeKn34vP+Epe4GbigMq/6PyZZUzHh8C3jRNs9QZt+KmaU4xTXNyfjfKQNM0r/lHfI8Bs7ESvcr5L/8tTqDCP3+sC4j3caAu0MY0zZLA6S6d563cKSIiciGU5ImIiN1GAj2AbKyWuWsNw/AFXgDON2buTKuAPGB4fgGUfkDrM94fC9xvGEYbw1Iifz9BF7Dt4cBiYKFhGOWBjUBnwzCqGoYRzL8rg8Zjjec732tBWOPwThqGUYYL764qIiLyn5TkiYiIrUzTTAC+Bl4ChgHjgMNYLWax51n1zG1kA9cDdwEngVuxWuCy8t+PBO7BKm5yAqvQy9AL3LaJNaZvLbAA2IA1Ti8aiMrfz5lGATfmV80cnf/aK8Ck/K6iN2EltsWA48BqYN6FxCIiInIhDE33IyIinsgwjDXAF6ZpfmV3LCIiIoVJLXkiIuIRDMPoYhhGhfzumkOAJqiFTEREiiAfuwMQEREpIHWBaVjTHuwFbjRNM87ekERERAqfumuKiIiIiIh4EHXXFBERERER8SBK8kRERERERDyIkjwREREREREPoiRPRERERETEgyjJExERERER8SBK8kRERERERDyIkjwREREREREPoiRPRERERETEgyjJExERERER8SBK8kRERERERDyIkjwREREREREPoiRPRERERETEgyjJExERERER8SBK8kRERERERDyIkjwREREREREPoiRPRERERETEgyjJExERERER8SBK8kRERERERDyIkjwREREREREPoiRPRERERETEgyjJExERERER8SBK8kRERERERDyIkjwREREREREPoiRPRERERETEgyjJExERERER8SBK8kRERERERDyIkjwREREREREPoiRPRERERETEgyjJExERERER8SBK8kRERERERDyIkjwREREREREPoiRPRERERETEgyjJExERERER8SBK8kRERERERDyIkjwREREREREPoiRPRERERETEgyjJExERERER8SBK8kRERERERDyIkjwREREREREPoiRPRERERETEgyjJExERERER8SBK8kRERERERDyIkjwREREREREP4mN3AJciNDTUrF69ut1hiIiIiIiI2CIqKuq4aZplz/aeWyZ51atXJzIy0u4wREREREREbGEYxoFzvafumiIiIiIiIh7ELVvyRERERETEdZimyZbDKWw9ksyx1Cxy8hzULhdIx9qhhAT62x1ekeP0JM8wjJ7AKMAbGGea5jv/eH8o8B5wOP+lT0zTHOfsuERERETcgcNhsmLPcebHxBMdm0xCahZpWbnUqxBE/+aVuSmiCl5eht1hShHlcJjM3HSE0Yt2sTch/c/XDQNME/x8vLi5VRWevLouQQG+NkZatDg1yTMMwxv4FOgBxALrDMOYaZpmzD8WnWqa5nBnxiIiIiLiTrJzHUxfH8sXS/awPzGD4n7eNA0rRduaIQT4ehF14ATPTN/Mou3H+HBgMwL91UFLCld8SiaPTdvIit2JNKhYkv/d0Jj2tUKpEByAAWyLS+W7tQf5dvUBFm0/xrghEdSrULLQ4svJySE2NpbMzMxC26czBAQEEBYWhq/vhSfJhmmaTgvIMIx2wCumaV6d//xZANM03z5jmaFAxMUkeREREaYKr4iIiIgnSs/KZeq6Q4xdtpe45EwaVw7m7k416NmoAv4+3n8uZ5omX63Yz5tztlGrbAnG3h5BtZASNkYuRcmehDRuGbuG5FM5vNSnAQPP06IcdSCJYZPXk5Xr4Js729A4LLhQYty3bx9BQUGEhIRgGO7Z2m2aJomJiaSmplKjRo2/vWcYRpRpmhFnW8/ZhVcqA4fOeB6b/9o/3WAYRrRhGD8ahlHlbBsyDONewzAiDcOITEhIcEasIiIiIrbIyXOw/uAJXp8dQ9u3F/La7BiqlCnO13e2ZubwDvRrVvlvCR6AYRjc2bEGk+5oTXxKFn0/WcHyXcdt+gmkKDmQmM7AL1eT63Dw0wPtGdS66nm7DLesVoYf7mtPCT8fbh2/hi2HkwslzszMTLdO8MD6Pw8JCbno1khXaNefBUwxTTPLMIz7gEnAlf9cyDTNMcAYsFryCjdEERERkYJhmiYr9yQyPyae/YnpHEjM4FBSBrkOE28vg2saVeDOjjVoUbX0BW2vY51QZg7vwD1fRzLkq7W8cG197uhQ479XFLkEJzOyuWPiOnIdDn68vx21ywVd0HpVQ4rz/b1tGfjlKm4bv4Yp97YtlK6b7pzgnXYpP4Ozk7zDwJktc2H8VWAFANM0E894Og5418kxiYiIiBS6zJw8Zmw8zITl+9kRn0pxP29qhJagQcWS9GpcgXoVStKpTiilivtd9LarhZRg+rAOPDZ1I6/OiuHwiVM816u+CrJIgcrMyeP+b6OITTrFt3e3ueAE77QqZYoz5d623PTlKm4Zu4bv721LnfIXtw25MM5O8tYBdQzDqIGV3N0MDD5zAcMwKpqmGZf/tC+wzckxeZTcPAfLdh1n3pajJJ/KoUW1UgxuU02Dr0VERFyEaVrVB9+es52jKZnUqxDEuzc2oW/TSgT4ev/3Bi5QoL8Pn9/aktdmbWXc8n0kpWfz/oCmSvSkQOTmORgxZQOr9yYxcmAzWtcoc0nbqRZSgin3tGXgmNUMGruGb+5qTf2KhVeMpahwaiZgmmauYRjDgd+wplCYYJrmVsMwXgMiTdOcCYwwDKMvkAskAUOdGZOnSMvKZfLqA4xfvo9jqVkEF/MlpIQf87YeZcLy/bxzQ2O61i1nd5giIiJFWmZOHi/+soUfomJpXDmYD25qSvtazhsj5O1l8ErfhoQE+vPh/J2U8PfhtX4NPaLLmtjH4TB56sdofo+J5+U+Dbiu+dlKbFy4mmUDmXJPW24dt4aBX67iqzta07LahXVPlgvj1OqazlKUq2vmOUzGLtvL53/sIflUDh1rh3Jr22pcWa8cfj5WOeXnpm9m57FUnulZj3s719QHu4iIiA0OnzzF/d9EsflwMiOurM3D3cPxLsRWtbfnbOPLpXsZ0a0Oj/UIL7T9imcxTZOXZ27l61UHeKxHOCO61SmwbR9KyuC28WuIT8nii9ta0iW8bIFtG2Dbtm3Ur18fgFdnbSXmSEqBbr9BpZK83KfheZd577338Pf3Z8SIETz66KNs2rSJRYsWsWjRIsaPH8+MGTN4+OGHmT17NsWKFWPGjBmUL1/+vD/LaXZW15QCFHsig5vHrOKdudtpWa00vzzYgW/vbkPPRhXw87EO5enXezWuyNtzt/PYtE1k5uTZHLmIiPvLznXw+9ajvPfbdl74ZTNjlu5hfkw8exLSyM1z2B2euBDTNJm27hA9P1rK/uPpjL09gseuqluoCR7AM9fU46aIMEYv3MVXK/YV6r7Fc3zw+06+XnWAezrV4KEraxfotquUKc60+9tRPbQEd05cxzerDxTo9l1Bp06dWLZsGQCRkZGkpaWRk5PDsmXL6Ny5M+np6bRt25ZNmzbRuXNnxo4dWyD71cAtN2CaJtPXH+aVmVsxgY8GNuW6ZpXP2UJXzM+bTwY1p36FIN7/fSd7j6cz5raWlC8ZULiBi4h4gMycPD5ZtJtv1xzgZEYO3l4GJfy8ScnM/XMZfx8v6lUIolfjitwUUYXSJS6+cIZ4hrjkUzzz02aW7EygdY0yvHdjE9vmrjMMg7f6Nyb5VA6vzoqhVHFf+jcPsyUWcU9fLtnDJ4t3MzCiCs/1qu+U3mHlggL44f52PDxlAy/+soXYpAyeuaZege/rv1rcnKVly5ZERUWRkpKCv78/LVq0IDIykmXLljF69Gj8/Pzo3bv3n8vOnz+/QParJM/FxZ7I4OmfolmxO5FW1Uvz4U3NqFKm+H+uZxgGw6+sQ53yQTw6dSN9Pl7OmNsjaFallPODFhHxENGxJ3n4+43sO55Or8YVGBBRhY61Q/H19iI5I4d9iensOZbG9qMpRB44wdtzt/Pxot3c06kmD3St9WcvC/F8pmnyQ2Qsr8+OIddh8mrfhtzWtprtRU98vL0YdXNz7vhqHU/9GE2l4GK0qRlia0ziHqZFHuLtudu5tklF3rq+sVOH/wT6+zDm9ghembmVL5fuJTMnj5f7NLT9/6cg+Pr6UqNGDSZOnEj79u1p0qQJixcvZvfu3dSvXx9fX98/f7fe3t7k5ub+xxYvjJI8F7bx0EnunrSOrBwHr/VryC1tql10V4+rG1Zg+rD23D0pksFjVzPlnrY0VaInInJepmkyYcV+3pm7jbKB/nx3dxva1w792zLBxX1pVrzU3y6ebT+awsj5u/howU5+23qUkTc3I1zlwT1eXPIpnp2+mT92JNCmRhneu7EpVUP++4JsYQnw9eaL21rS/7MV3PdtFL8M60D1UHtaF8U9LNmZwLPTN9OpTigf3dSsULoae3sZvNavIQG+Xoxdtg9vLy9e6tPA6fstDJ06deL9999nwoQJNG7cmMcee4yWLVs6NXHWJUYXteNoKreNX0MxP29+frADt7erfsn/YPUqlGT6A+0pU8KPOyeuY9/x9AKOVkTEcxxPy+Ker6N4fXYMXcLLMefhTv9K8M6lXoWSfHFbS8bc1pL4lEx6f7ycCcv34XC4X5EzuTDzthzlqo+WsmZvEq/2bciUe9q6VIJ3WnAxXyYMaQXAnRPXkZiWZXNE4qq2HE5m2LdRhJcP4rNbWhRqjwTDMHiuV33u6FCdCSv2MWnl/kLbtzN16tSJuLg42rVrR/ny5QkICKBTp05O3aeqa7qgo8mZ9P9sBXkOk+nD2hNWumC+LPYmpHHjF6sI9PdhxoMdNGZEROQMpmnyQ1Qsb8yO4VROHs/1qs/Q9tUv+UprQmoWz/wUzcLtx+hQO4T3BzSlYnCxAo5a7OJwmIxauItRC3fRtEopRt/czLaxdxcjcn8St4xbQ72KJZlyTxuK+6lTl/zleFoW145ehrdh8PODHWyr55DnMLnvmygWbY9n7O0RdKv/72qTF+JsFSndlaprurmUzByGfrWW1MxcvrqjVYEleGDNSTJuSARHkzMZPmW9qsGJiOTLyXPw5I/RPPVjNPUrlmTuw525o0ONy+pKUzbIn3FDInirf2PWHzhJr1HLWLIzoQCjFrukZeVy/7dRjFq4ixtahDH13rZukeABRFQvwyeDW7A59iQPfLueHJ0LSD6Hw+SJHzZxIiOHcUNa2Vqwz9vLYPSgZjSoVJKHpmxgy+Fk22JxV0ryXIhpmjw+bRO7j6Xx+a0taFgpuMD30aJqad66vjErdify5pxtBb59ERF3k+cweXTqRn6MimVEtzp8d09bapcLLJBtG4bB4DZVmT2iI+WCAhj61Vo+nL+TPHXfdFuHkjK4/rMVLNgWz4u9G/D+gCYE+HrbHdZF6dGgPG/1b8ySnQk8/WO0uhMLAOOX7+OPHQm8eG19GlQqaXc4FPfzYcKQVpQu7scdE9cReyLD7pDcipI8FzJ22V7mx8TzbK/6dKpTsJNBnunGlmEMbV+dr1bsZ35MvNP2I+LpTNNk+9EUvltzkOd+3swrM7eyem8i7tgNvqhyOEye/HETs6PjePaaejzWwzmTVdcqG8gvD3bg+ubWnGV3TVpHVq7mMHU30bEn6f/ZCo4mZ/L1nW24q+Pltfba6ebWVXm8RzjTNxzmf/O22x2O2Cw69iTv/radqxuW59a21ewO50/lSgYw8Y5WZObkMWLKhkvqheYJ38mX8jNoTJ6LWLM3kcHj1nBVg/J8dksLp39pZOXm0f/TlcQln2LeI501h57IRdh+NIWfomKZtSmOoymZAAQF+JDnMMnIzqNltdK82b8R9SrYfyVUzs3hMHnu5818v+4Qj/cI56FudZy+T9M0mbzmIC/8soVrG1fk40HNPaJEeFGwcFs8w7/bQEigHxPvaEXtcu5fNdU0TV6euZWvVx3g5T4NuKNDDbtDEhukZubQ++Pl5OQ6mPNwJ0oVd72aDTM3HWHElA080r0Oj3QPv+D19u3bR1BQECEhIW57QcY0TRITE0lNTaVGjb//j55vTJ5G27qAIydPMWzyeqqVKc67NzYplD9Cfx9vRg9qTu+Pl/H4tE18fWdrnWiI/Ic1exN597cdRB04ga+3Qde65Xisfjita5ShWkhxMnMcTN8Qywe/76TvJyt4u39jbmipiYdd0emT2+/XHeKhK2sXSoIHVvfNW9tW41R2Hm/O2UbZIH9e7tPAbU8+iopvVu3n5ZlbaVgpmPFDIygX5BkXRg3D4OU+DYlPyeS12TGElS5OjwaXVuBC3JNpmrz4yxYOJWXw/b3tXDLBA+jbtBKLtx/j40W7uaJuuQueDiwsLIzY2FgSEtx7PHRAQABhYRd3PqGWPJulZ+Vy05erOJCYwS8PdiiwcSAX6nQ3s+d71eeezjULdd8i7sLhMPl08W4+WrCTSqWKMbR9da5vEUaZc1SoTUzLYvh3G1i1N5FhXWvxxFV1dRHFxXw4fyejF+7i3s41efaaerYkWW/MjmHc8n083bMeD3StVej7l/9mmibvzNvOl0v20q1eOUYPak4Jf8+7Pn4qO4+bx6xiZ3wa39zVmojqZewOSQrJj1GxPPHDJh7tHs7D3QvnYtelSj6VQ8+RSynu582vIzq53VhYZ1B1TReVm+dg+Hfr2X40lY8HNy/0BA9gUOsqXN2wPO/+tp2d8amFvn8RV3fk5CmGfLWWD+bvpE/TSvz2SGfu7lTznAkeQEigP1/f1ZpBravy2R97eGTqRo2/ciGr9yby8SKrKqJdCR7Ac73q07dpJf43bzszNh62JQY5tzMTvFvbVmXM7REemeABFPPzZuyQCCoEB3Dr+DUs0Hj9ImFvQhovzdhCmxplGH5lbbvD+U/BxXx598Ym7ElI5915O+wOx+UpybPJ6a5Ci3ck8Fq/hlxRt5wtcRiGwVv9G1Pcz4dXZm71iMGpIgUhO9fB53/sodsHS1i3P4k3+zdi5MBmF3yS5+vtxVv9G/F0z3rM3HSE28at5WRGtpOjlv+SnJHDY1M3Uj2kBK/1a2hrN0kvL4P3BjShTY0yPPlDNKv3JtoWi/zbJ4t28+WSvdzWthqv92vklII8rqRcUAA/3N+O8PJB3PdtFFPXHbQ7JHGiU9l5DP9uA/4+Xoy6ubnb/H13qlOW29tVY8KKfazcc9zucFyakjybjFm6l8lrDnJ/l1rc0sbeKkYhgf48cVU4K/ckMnfLUVtjEXEFK/ccp9foZfxv3nY61Qll/qNduKVNtYtOCAzD4IGutfh4UHM2HjrJ9Z+v5GCiSkDbxTRNnvtlM8dSsy4qYXcmfx9vxtwWQdWQ4tz7dSS7j6lHhSuYuGIfH8zfyfUtKvNqX3svBhSm0EB/ptzTlva1Qnj6p82MXrhLF389kGmaPDs9mm1HU/jgpqZUCHavMabPXlOfmqElePKHaFIyc+wOx2UpybPBr9FxvD13O9c2qchTV9e1OxwABrepRv2KJXljdgynstWtTIqmYymZjJiygcFj15CVm8eEoRGMuT2CKmWKX9Z2+zStxOR72pCUnk3/z1awRi02tpi+/jC/RsfxaI/wCx60XxiCi/vy1dBW+Pl4M2TCOo6lZtodUpH2U1Qsr8yK4aoG5Xn3hiZFbjxtCX8fxg9pxfXNK/Ph/J288MsWzaPnYcYv38cvG4/weI9wrqznfoV2ivl588FNTTmaksmrM2PsDsdlKckrZFEHknh02kYiqpXmgwFNXebLw9vL4NW+DTmSnMmEFfvsDkekUOXmORi/fB9XfrCEeVuOMqJbHeY/2qVAv/xaVS/D9AfaU7KYLzePXc0bs2NIztAVyMJyIDGdl2ZsoXWNMtzfxfWKnFQpU5yvhrYiKT2bOyeuIz0r1+6QiqTZ0Ud46qdoOtQOYfSg5vh4F83TJD8fLz64qSn3danJ5DUHeV6JnsdYvus4b83ZxjWNKvDgFa4/Du9cmlctzYNda/HT+lh+36peaGdTND+9bBJzJIW7JkVSuVQxxtwe4XJVgVrXKEP3+uX54o89JKVr7FBBcThMthxOZt6WOOZujmNbXIq6v7iQlXuO0/vj5bw+O4aW1Urz+6OdeaxHuFP+P2uWDWT2Qx25uVUVxq/YR+f3FvPp4t06oXey3DwHj0zdiJeXwUcDm7ns2JPGYcF8ektzYo6k8NAlTvorl27Syv08NGUDzauUYsxtrvcdXdgMw+CZnvUY1rUWU9Ye5JVZGrfv7mJPZPDQlPXUKRfE+wOaun035OFX1qFhpZI89/NmEtOy7A7H5WgKhUIScySFweNWU9zXm+/vbUfVkMvr/uUsu+JTuXrkUoa2r8FLfRrYHY7bMk2TTbHJfLfmAAu2HftX0lw9pDgPXlGbG1uGuf2HrLvafzydN+dsY35MPJVLFeOFa+vTs1GFQjseMUdS+OD3HSzcfozQQD9e79eIaxpXLJR9FzUfzd/JqIW7+HhQc/o0rWR3OP9p8poDPP/zFm5pU5U3rmukzwgnczhM/vebVUWzR4PyfDyoeZFP8M5kmiZvzdnG2GX7GNq+Oi/1buAyvZDkwmXm5HHjFys5kJjBzOEdqRFawu6QCsSOo6n0+Xg5V9Yrx+e3tihyn5eaDN1mZyZ4U+5t67IJHkCd8kEMaFmFb1bv544O1S97LFJRcyAxndnRcczadITtR1Mp7ufNVQ3K06VuWeqWL4nDNIk5ksLktQd58sdolu06zgc3NcW3iHYJskN2roMxS/cwetFu/Ly9eKpnXe7sUKPQT+oaVCrJ+KGt2HDwBC/N2MoDk9dzXbNKvH19E4r56QSzoEQdSOLjRbu4vkVlt0jwAG5pU41DSaf4YskeaoSW4O5OmsPUWTJz8nh82iZ+3RzHrW2r8mpfz6+iebEMw+C5XvVxmNZYrrSsXN65vnGR7crqjk5PeL7lcArjh0R4TIIHULdCEI9dFc47c7czY+MRrmte2e6QXIZa8pzsnwletRDX/8c6mpxJ1/cX07NhBUbe3NzucFxensNk4bZ4vlqxn1X5BTVaVC1F/+aVua55ZYICfM+6zmeLd/PB/J3c2DKM925sUuSuPhW2PIfJ6r2JvDJzK7uOpdGrcQVe6dOQciXtryqWk+fg08W7GbVwF62qlWHc0AhKnuXvRi5OamYO14xahmHAnBGdzvq/6KocDpPhU9Yzd8tRJgxpxRX17Jlmx5MdSsrggclRbD2SwnPX1OfuTjX0OXwepmkyauEuRi7YRc+GFRg1qBn+Prog5Q5O9w4YcWVtHrvKNQr+FaQ8h8nAL1exMz6V3x/t4nbVQi/H+VrylOQ50a74VG76chXF3CjBO+3dedv57I89zH6oI40qB9sdjktKzcxhWmQsk1bu52BSBhWDA7i1bTX6NatEWOkLawEduWAnIxfs4tHu4TzcvY6TIy5asnMd7IxPZe2+JFbtTWTN3kRSMnOpXKoYr1/X0CUris3adIRHp26kboUgvrunLcHF3CcpcUWPTdvIjI1HmHZfO1pWK213OBftVHYe13++kviUTOY90olyQUXnxMXZluxM4OHvN5DnMPnopmZ0b+B6nweuasLyfbw2O4ZOdUL58raWFPdTpzBXtuHgCW76chXta4UyYWgrj22p3n88nWtGLaNVjTJMuqNVkblgoyTPBoeSMhjwxSryTJMf7mtHdTdrGk/JzKHzu4tpXDmYb+5qY3c4LiU718HXq/YzauEuUjNzaVmtNHd2qMHVDctfdPcV0zR54odoflofyyeDm9O7iXt0J3MVGdm5zI+JZ8vhZHYdS+NERg5ZOXlk5TqIPZFBTp71+VYtpDhta4TQrlYIVzUs79InJYt3HOPeryNpXrU0X9/ZWmODLtHMTUcYMWUDj3SvwyPdw+0O55LtPpZK74+X07pGCBOHttJYqMvkcJh8ung3Hy7YSd3yQXxxa0u3+352BT9EHuLpn6JpVqUUE+9srZ4HLiohNYs+Hy/H18dg1vCOlCruZ3dITvXNqv28OGMrr1/XiNva2jsHdWFRklfIUjJzuO6TFRxPy2Lqfe2oX7Gk3SFdknHL9vLGr9v49q42dKwTanc4LuGPHcd4bXYMexPS6RxelscLYL6trNw8bhm7hs2Hk5lyb1taVHW/FofCZpom36w+wEfzd3IiIwc/Hy9qlQ2kbJA/xXy98PX2okqZ4tSvWJKW1UpTuVQxu0O+KDM2Hubh7zdyR4fqvNynod3huJ3DJ0/Rc+RS6pQLZNp97dx+7NC3qw/wwi9beLlPA+7oUMPucNxWVq41/m52dBz9mlXi7esbu/QFH1c3b0ucVY1UF6RcUm6eg1vHr2HDwZNMH9aehpU8v1eWaZoM+Woda/clMvuhTtQuF2h3SE6nJK8QORwm930bxeLtx5h8dxva1AyxO6RLlpWbR7cPlhBczJdZwzsW6SvI2+JSeHfedhbvSKBGaAle7F2fK+qWK7DuAIlpWVz/+UpSTuXw0wPtqVnW8z+YLlVWbh6PTdvEr9FxdKwdykNX1qZFtdIeV7zm5RlbmLTqAN/f25a2bvw5UtjyHCaDxq4m5kgKc0Z0culCVxfKNE3umhTJit3HmfNwJ2rp8+GipWbmcP+3UazYncgz19Tjvs41i0x3LmeauekID3+/gW71yvHFrS3d/oKKJ3nz1xjGLtvHhzc15foWYXaHU2jiUzLpOXIplUsXY/oDHfDz8ey/yfMleZ79k9vg8yV7mB8Tz3O96rt1ggfg7+PNE1fVZeuRFGZFH7E7HFvsO57OiCkbuGbUMqIOnOC5XvX47ZHOXFmvfIGeIIQE+jPpjtZ4GQZDvlqreQrPITMnj3u/juLX6Die7lmPb+5qTZuaIR6X4AE8fU09qoUU58kfN2kevYvwxZI9rN2XxGv9GnpEggdWdcN3rm9MMT9vHpu2SfPnXaSE1CxuHrOa1XuT+GBAU+7vUksJXgHp27QSr/VtyIJtx3jqp2hNmO4iZkcfYeyyfdzerlqRSvAAypcM4O3rm7DlcAqjFu60OxxbOf3MyDCMnoZh7DAMY7dhGM+c5X1/wzCm5r+/xjCM6s6OyVlijqTw4fyd9G5SkTs6VLc7nALRt2klGlQsyfu/7yA7t+icWBw5eYpnp0fT/cMlLNgWz/ArarPs6Su5t3Mtp10Vqh5agglDWxGfnMWLM7Y4ZR/uLCM7lzsnrmPprgTeub4xD3T17BO14n4+vD+gKbEnTjFyQdH+orpQmw6d5KP5O+nTtBL9PayMdrmSAbzerxGbDp3ky6V77Q7HbRxITOfGL1ayNyGdcUMiuKFl0TrhLQy3tavOo93Dmb7+ME/8uInMnDy7QyrSdsan8tSP0bSsVpoXri2a8x33bFSBgRFV+OyPPazbn2R3OLZxapJnGIY38ClwDdAAGGQYxj//4u4CTpimWRv4CPifM2Nyltw8B0//FE3p4n4eNXmtl5fBUz3rcijpFNPXx9odjtOZpsnEFfvo+v4f/BR1mNvbVWPJk1fwxNV1C6XSYdMqpXi4ex1+jY7j1+g4p+/PXaRl5TJ0wjpW703kgwFNubl1VbtDKhStqpdhYEQVvlqxn53xqXaH49LSs3J5ZOpGygX5e9Rn8Jn6NK1E7yYVGblgJxsPnbQ7HJe35XAyN+R3g//unjZcUVfTUDjLiG61ebhbHaavP8x1n65gy+Fku0MqklIyc7jvmyiK+/nw2S0tPL6r4vm82KcBVUoX59GpG0nNzLE7HFs4++i3BnabprnXNM1s4Hug3z+W6QdMyn/8I9DNcMNv569W7Gfz4WRe7dvQ46oXdQkvS5OwYD77Y49HdxMyTZMXftnCK7Ni6FQ7lMVPduXlPg0pG+RfqHHc17kmTcKCeXHGFhLTsgp1364o+VQOt41fQ9TBE4y6uXmR63ryVM96lPD34bVZMXaH4tJenx3D/sR0PhzYzKOnnnjjukaULxnAg5PXc0Ldus9pxe7jDPxyFf4+3vz4QHuaq6CVUxmGwaM9wvlqaCsS07Pp9+kK3v9tB1m5atUrLA6HyePTNnEwKYNPBzenvAvMAWunQH8fPhrYjCMnT/HKzKL5/ensJK8ycOiM57H5r511GdM0c4Fk4F+D2QzDuNcwjEjDMCITEhKcFO6lyczJY8yyvXSvX55ejSvYHU6BMwyD4VfU5mBShkePzfto/k4mrznIfZ1rMvb2CNsqMvp4e/H+gKakZubw5q/bbInBVZzMyObWcWvYcjiZTwe3oE/TojfFRJkSfozoVoflu4+zbJdrffa5ij92HOP7dYe4v0stjy9SU6q4H5/d0oKE1CwembpRY6DOYtamIwz9ai1hpYvz0wPtVaimEF1RrxwLHu3Cdc0q88ni3Vwzahmr9iTaHVaRMHLBTubHxPO8B9SEKCgtq5XmwStq89P6WOZuLnq9o9ymHdc0zTGmaUaYphlRtmxZu8P5mwBfb2YN78hb/T2zixBA9/rlqVchiE8W7SbPA08q5sfEM3rRbm6KCOOZa+rZXkk0vHwQ93epxfQNh1m+67itsdglMS2LQWPXsONoKl/c2pKejTzvAsqFurVtVSqXKsb/5m3XSf0/ZObk8eKMLdQqW4JHutexO5xC0SSsFC/1acCSnQl8sni33eG4jNNz4I34fgPNq5Rm2v3tqBBctFsz7BBc3JcPbmrKpDtbk5PnYNDY1Tw2baN6pjjR7Ogjf57DeEpNiIIyolsdmoQF8+zPm4lPybQ7nELl7CTvMFDljOdh+a+ddRnDMHyAYMDtLvtUCA6gnAc3jXt5GQy/sjZ7EtKZu8WzroYcOXmKJ3/cRMNKJXndhcbyPHhFbaqHFOf5XzYXuYHs24+mcN1nK9ibkMa4IRF0q1/e7pBs5e/jzRNXh7PlcAqzi+DVyPP5ZNFuDiWd4o3rGuPvU3Tm6bqlTVX6N6/MRwt2snSnWnj3HU9nyFdree+3HfRpUomv72rt0d123UGX8LL8/kgXHryiFrM2HaHbh0uYuu6gLlQVsAUx8Tw2dRMtq5V2qXMYV+Hr7cVHA5uRmZPHkz9G445Tx10qZyd564A6hmHUMAzDD7gZmPmPZWYCQ/If3wgsMovSEXAj1zSqSO1ygYxeuMtjPqRz8xyMmLKBnFwHnwxu4VIniQG+3rzZvzEHEjP4eNEuu8MpFFsOJ/PkD5u4dvRysnIcfH9vWzqHu1bLvV36Na1M/Yolef+3olXp9nx2H0vly6V7uL5FZdrVKlrdkwzD4M3+jahbPoiHpmzgQGK63SHZIjfPweiFu7j6o6VsOHiS1/s1ZNTNzTQxt4so5ufNk1fXY86IToSXC+LpnzYzcMwqdhxVIanLZZom36w+wP3fRlG/YhAThrRyqXMYV1KrbCDPX9uApTsT+HrVAbvDKTROTfLyx9gNB34DtgHTTNPcahjGa4Zh9M1fbDwQYhjGbuAx4F/TLIhr8PYyeOjK2uyMT+O3rUftDqdAjFq4i8gDJ3jr+sbUCC1hdzj/0qF2KNe3qMyXS/Z67JdinsPk1+g4+n26gt4fL2dW9BFub1eNX0d0UrGEM3h5GTzdsy4HkzKYsvag3eHYzjRNnvt5C8X9fHi+V327w7FFcT8fxtxmzYF73zdRRW4+xYzsXG4dv4YP5+/kqoblWfR4F25rV10tGS6oTvkgpt7XlndvbMLuY2n0Gr2MV2ZuJTmjaFY9vFxbjyRz+4S1vPjLFjrVCeWbu9sQXFwt1+dza5uqdK1blnfmbi8yF8UMd2w0i4iIMCMjI+0Oo0jKc5j0+HAJfj5ezH24k1t/mUYdSGLAF6vo3zyMD25qanc455SUnk33D5cQGujHz8M6UMLfx+6QCoRpmizYdoy352xj7/F0aoaW4PZ21ejfIkzdrM7BNE0Gj13DjvhUFj/etUh/qf8YFcsTP2zinesbF5kpNc5l2a4EhkxYS89GFfh0cAu3/ly+UHkOkwe+jWLBtnj+d0MTBkRU+e+VxCWcSM/mg/k7+G7NQYKL+XJfl1rc0qYqQQFF9/PsQpmmyeQ1B3ltVgwl/L158Ira3Nmhhu11BNxFXPIprvpwKQ0qlWTKPW094vdmGEaUaZoRZ3vPbQqviGvw9jIYdkVtth9N5Q83HgeSlpXLo1M3UalUMV7p69qThZYp4ceom5ux+1gaj0/b5BGFb/YdT+eOieu45+tIvLwMPrulBfMf68LQDjWU4J2HYRi80Ls+JzOyefe37XaHY5sT6dm8NWcbLauV5iad3NOpTlmeuaYeczYfZcKK/XaHUyj+N287v8fE82LvBkrw3EzpEn68cV1jZj3UkcZhpXhn7nbavLWQZ6dHa36988jMyeOJH6J54ZcttKsVwuInunJ3p5oekagUlorBxXixdwPW7Evi2zWe321TSZ5ctL5NK1GhZABjluy1O5RL9tqsrcSeyOCjgc3c4uphpzplea5XfeZtPcqTP7hvopeRncu787Zz9UdLidx/gheurc/chzvRq3FFvPVFdUEaVgrmjg41+G7tQTYcPGF3OLZ4Z+52kk/l8Gb/RjrByXdPp5r0aFCed+Zu8/iJ0r9bc5AxS/cypF017uhQw+5w5BI1rBTM13e2ZubwDvRuUpGfNxym98fLuenLVUX2s+1cDiZmcP1nK5m+IZaHu9Xhq6GtPG5O5sIyICKMTnVCeW/eDo55eLVNJXly0fx8vLijQ3VW7U1kc6z7XXWbt+Uo0yJjeaBrLVpVL2N3OBfs7k41ebxHONM3HOaZn6LdrvjNjqOpXDNqGZ/9sYfeTSuy6Iku3N2pJr7e+hi6WI/2CKd8UADP/byFnLyiVYRl+a7jTI08xN2dalCvQkm7w3EZhmHw/o1NKRdkTZSefMozxzot2ZnAizO2cEXdsrzY27V7YciFaRJWindvbMqa57rzYu8G7E1Ip/9nK3nwu/VFZuzU+SzaHk/vj5cReyKDCUNa8WiPcF3cugyGYfBav0Zk5Tl4bbZnT5Kusyu5JIPaVCXQ34cxy9yrNe9YSibPTo+mceVgHu4Wbnc4F+2hbnV4uFsdfoiK5amfot2mRW929BGu+3QFGdl5fH9vWz68qRnlgjx3yhFnC/T34ZW+DdkWl8K4ZfvsDqfQpGXl8vRP0dQMLcGj3d3v/9fZgov78sng5sSnZPLcz5s9rlT4trgUHpy8nvDyQXw8uAU+ukDkUYKL+XJXxxr88WRXRnSrw6Jtx+j+4RJenbWVpPRsu8MrdHkOkw/n7+TOiZGElS7O7Ic6cUW9cnaH5RFqhJZg+BW1mR0dx/T1sXaH4zT6hJRLUjLAl0GtqzBncxyHkjLsDueCmKbJkz9Gcyonj48GNsPPxz3//B/tEc4j3evwY1Ssy7foHUvJ5PFpmxj+3QYaVCrJrw91pG3NolXq3ll6NqrANY0q8NGCnexNSLM7nELx5q/bOJJ8ivcGNFGJ/HNoXrU0j/YI59foOH6M8pyTl/iUTO6cuI4S/t5MGBpBoIcUoJJ/C/T34bEe4fzxZFdubBnGpJX7af/OQu75OpIfIg+5bMKX5zBJzsgpkIuvSenZDP1qLaMX7uLGlmFMH9aeqiHFCyBKOW1Y11q0qVGG53/ewq54z6xeruqacsmOnDxF53cXc1u7arzcp6Hd4fynr1ft56UZW3m9X0Nua1fd7nAu24fzdzJ64S56Na7Aezc2dZmqm6ZpsiM+lW9WHeCHqFgw4e5ONXike7jbJtau6lhqJt0/WEK9iiX53kMqhZ3L6f/f+7vU4plr6tkdjkvLc5jcMm410bHJ/Dqik0tOD3Mx0rNyGThmFXsT0pl2XzsaVQ62OyQpRDvjU5m8+gDzY+I5kpyJlwHNqpSia91yNKxUkpbVShfa+LQ8h8mWw8lEHTjBptiTxBxJIflUDhnZeaRn52KaVoG6OuUCaV8rlA61Q2hdo8xFjf1fujOBZ36K5nh6Nq/0acig1lWKRMVcO8SnZNJr1DLKlPBjxvAOFPdzjfOoi3G+6ppK8uSyPDp1I79tPcqqZ7q5dDn3/cfT6TlqKW1rhvDV0FYe8YFpmiZjl+3lnbnbCS8fxJjbImy70peRncuyXcf5Y0cCf+w4RlxyJn7eXtzQsjL3d6lFtRD3Psl0ZdMiD/HUj9G8cV0jbm1bze5wnOKPHce4c+I6rqxXni9va6kiPRcgLvkUPUcuo1pIcX68v73bXmDJc5jc900ki7YfY9yQCK6sV97ukMQmpmmy9UgK82Pi+WPHMTbl1wTw8/Gid5OK3N+lFuHlg5yy3+W7j/P92kMs3338z/GuFUoG0KhyMKGBfpTw9yHQ34egAB+S0rPZFHuSdftPkJ3rwNvLoElYMB1qhdK+VgiNwoIp7uuNt5fByYwcDiRlcCAxnT3H0li9L4m1+5KoEVqC0Tc3p3GYLmg42/Jdx7ltwhr6NKnEqJubud35oZI8cZqYIyn0Gr2MJ6+uy4NX1LY7nLNyOExuHruabXEpzH+0CxWCPWss2NKdCTw0ZQOmafJUz3oMal210E6Cd8Wn8u3qA0xff5jUrFwC/X3oWDuUrnXL0q1+ecoG+RdKHEWZaZrcNn4tGw+dZP5jnakYXMzukArUrvhUrv9sJVXKFOeH+9u5TIu1O5i35Sj3fxvFrW2r8sZ1je0O55K8OmsrX63Yz2v9GnK7B/TAkIKTnJHDzmOpzNp0hB+jYsnIzqNHg/IM61qL5lVLX9a28xwm24+msHj7MeZuOcrWIymEBvrTtW5ZOtUJpU2NkP88l8jMyWP9wROs3J3Iyj3H2RSb/LeunN5ext+eexlQp1wQ17eozNAO1fH3UZf0wvLp4t2899sOHusRzohudewO56IoyROnum38GrYfTWX501e45IfSpJX7eXnmVt670XMnzD2QmM7TP0Wzem8SDSqW5IGutejRoLzTxi1tPHSSjxfuYuH2Y/h5e9GrcQVuiqhCRPUybtti4M4OJmZw9ciltKsVwvghEW53JfJcktKz/yzYM3N4ByqV8qwEtjC8PWcbXy7d65YtvRNX7OOVWTHc2aEGL/VRJU05txPp2UxcuZ+JK/eTfCqHDrVDeKBLbdrVCvnPi577j6ez/uAJtsWlsP1oKnsT0jmelkVWrlW5uHnVUlzfIoybIsIu6xwnNTOHtfuS2JOQRmaOg8ycPMqU8KNaSAmqhRSnapniGmtsE9M0eXzaJqZvOMyom5vRr1llu0O6YEryxKmW7UrgtvFrefeGJtzUyrWSqNMnv21qlvGYbprnYpoms6Lj+PD3HexPzCDA14s2NULoVCeUzuFlqVMu8LJ+/sycPH6NjmPymgOsP3iSUsV9uaN9DW5pW5XQQLXY2W3csr288es2t/uCOpfsXAe3jV/DhkMn+f7etrS4zCvzRVWew+SuSetYvus4397dxm0KHy3aHs/dkyLpVr88X9yqLrpyYdKycpm8+gDjlu8jITWLUsV9aV8rhMaVS1G7XCDF/axukknp2aw/cIJFO46xN8GapsHPx4vw8oHUKRdEaKAfDSqVpF3NUI/r/SNnl5Wbx23j1xJ14AQf3tTUbb5HleSJU5mmSa/Ry8nJc/D7I51dpviDw2EyeNxqthxO4fdHOxeZVoA8hzV+YPH2YyzblcCe/C+wCiUDaF61FFVDilPc14eMnFxOpueQmJ5FQlo2iWlZZOc68Pf1IqSEP6GBfoQG+lOmhB9HTp5i8Y4Ekk/lULNsCQa3rsrNrauqwp0LyXOYXP/5Sg4lZbDgsS6UKeHeE+W+PGMLk1YdYOTAZlzX3D2+bF1VSmYO1326ghPp2cwc3pEqZVy7St/2oync8NlKqoeW4If727llMQSxV2ZOHr9tPcqyXcdZtSeRwydP/WsZP28v2tYK4cq6ZWlfO5SaoSU0LUcRl56Vy50T17FufxJvXNeYwW2q2h3Sf1KSJ07384ZYHp26iQlDXWdg/DerD/DiL1t45/rG3Nza9f9RneXwyVMs25nAsl3H2XY0hUNJGeTkmfh5exFc3JfQwL8SugBfL05l55GYnk1CahaJ6dkkpWdTNtCfNjXLcHOrqrStWcajW0Td2Y6jqfT+eBnXNq7IyJub2x3OJftlw2EembqRuzvW4AVNeF0g9iakcd2nK6hUqhg/PdDeZcc2Hk/Lot8nK8jJczBzeEe1okiBSD6Vw77j6WTnOsjNcxAU4Et4hUCXHGIi9srIzuWBb9ezZGcCg1pX5ZW+DVz670RJnjhdTp6Dzu8upmqZ4ky9r53d4XAoKYOeI5fSolppvr6ztZKSM+Q5TEzTvOArlqZp6vfnRk5PrfHV0FZuOXHu7mOp9Pl4BY0rBzP5njb46sp6gVm6M4GhX62lR4PyfH5LS5fpdXFaZk4et4xbw9YjyUy7rx1NwkrZHZKIFEF5DpMPft/BZ3/soVmVUnx+awuXLWp2viRP355SIHy9vbirYw3W7Etixe7jtsZimibPTt8MwNvXN1aC8g/eXsZFdUnR78+9PHhFLWqXC+T5nzeTlpVrdzgXxTRNXvxlK/6+XnwyuLkSvALWObwsz1/bgN+2xjNy4S67w/mb05/b1niYZkrwRMQ23l4GT/Wsxxe3tmBXfCp9Pl7Oqj2Jdod10fQNKgXm1rbVqFyqGG/N2YbDYV8L8bdrDrJ893Ge6VWfsNKuPfZEpKD5+3jzvxuaEJeSybvzttsdzkX5bWs8q/Ym8niPcMqVVDc9Z7izQ3UGtAxj9MJd/BodZ3c4f/rsjz38vOEwj/cIp1fjinaHIyJCz0YVmTG8A8HFfNl46KTd4Vw0JXlSYAJ8vXny6rpsPZLCLxsP2xLDvuPpvPXrNjrVCeVWNxgwK+IMLauVZki76ny96gBr9yXZHc4FyczJ4805MdQtH8SgIjyG1tkMw+CN/o1oUbUUj07byMJt8XaHxK/Rcbz32w6ua1aJ4Ve65nyrIlI01S4XxKyHOnJ/l5p2h3LRlORJgerbtBKNKwfz3m87SC/krmJ5DpPHp23E19vg3RubqJuhFGlPXl2XsNLFeGzaRpJP5dgdzn8av3wfh5JO8VKfBqpw52T+Pt6MH9KKuuWDuO+bKL5fe9C2WJbsTOCRqRuIqFaad27Q57aIuJ7ifj5u+dmkb1IpUF5eBi/3aUBccibv/76jUPf9xZI9rD94kteva+SyA2RFCksJfx9G3dycuORMnvt5M65cZOtociafLt7N1Q3L06F2qN3hFAmlS/gx+Z42tKsVwjPTN/PCL5vJzp/8ubCs25/Efd9EUqdcEOOHttJE0CIiBUhJnhS4iOpluK1tNSau3M/6gycKZZ/LdiXwwe876N2kIn2bViqUfYq4upbVSvNYj3B+jY5jWuQhu8M5p3fnbSc3z+T5XpouoTCVDPBl4h2tua9LTb5dfZBbxq0mITWrUPa9bFcCd361jkqlivH1Xa0JLuZbKPsVESkqlOSJUzzVsy4VSgbwzE/RTr86vP94OsO/20CdckH8T919RP7m/i61aF8rhJdnbmVPQprd4fzL+oMnmL7hMHd3qkHVEBVKKmzeXgbPXlOf0YOas/lwstOryJ1Iz+bNX2MYMmEtlUoV49u72hAa6O+0/YmIFFVK8sQpggJ8ebN/I3bGp/Hp4t1O209aVi73fB2JYcDY2yNcdoJfEbt4exl8NLAZ/j7ePD5tE7l5hdsl73wcDpNXZ8VQLsifB69QwQ079W1aiZ8eaE+ArxeDxq7m9dkxZObkFdj2M7Jz+XTxbjq/u5hxy/dxY8swpg9rT6VS6lovIuIMSvLEaa6sV57+zSvzyeLdRMeeLPDtOxwmj07dyN7j6Xw2uIVaAUTOoXzJAF6/rhEbD53ky6V77Q7nTz9vOMymQyd55pp6ukDjAhpWCmbOw524rW01xi/fx9UjlzIt8hAn0rMveZs5eQ6+WX2ALu/9wXu/7aBNzRDmPdyZd29sqmMuIuJEhisPxj+XiIgIMzIy0u4w5AIkn8rh6o+WUtzPm58f7FCg4y4+/H0Hoxft5pU+DRjaoUaBbVfEUz343Xp+33qUGQ92pEGlkrbGkpaVy5Xv/0GlUsWY/kB7vLzUzdqVLNuVwNtzthMTlwJAnXKBRFQvTde65egSXvY/i6RkZOcyY+MRvlyyh/2JGbSqXpqne9YjonqZwghfRKRIMAwjyjTNiLO+pyRPnG313kRuHbeGtjVD+OqOVvgWQHn0OZvjGDZ5PTdFhGkcnsgFSkrP5qqPlhIa6MeM4R3w97GvmuHIBTsZuWAXPw9rT/OqpW2LQ87NNE2iDpxg9d5EIg+cIOrACVIzcwny96FZ1VI0qFiSBpVKUr5kALl5JunZuaRn5bJu/wl+jT5CSmYuDSuV5PGrwrmibjl9TouIFDAleWK7aZGHeOrHaK5pVIHRg5pfVqK3Zm8iQ79aR/2KQUy5t62tJ6oi7mZBTDx3fx3Jg1fU4smr69kSw8mMbDr9bzHta4fw5W1n/W4SF5ST52DlnkTmbYlj06Fkdh1LJSfv3+cQxf28uapBeW5tW42W1UoruRMRcZLzJXnqEC+F4qaIKqRm5vL67BhGTNnAyJubXVJytnZfEndMXEelUgF8eVuEEjyRi9S9QXkGtAzj8z/20K1+eVrY0Io2Zule0rJzebRHeKHvWy6dr7cXXcLL0iW8LADZuQ72JKSRlJ6Nr7cXxf28KeHvQ8XgAM15JyJiMyV5Umju6lgDA3htdgxHvlzNJ4OaU6XMhRdLWbsviaFfraVicABT7m1L2SCV3Ra5FC/1acDKPYk8MW0Tv47oRDG/wjshP56WxcSV++ndpBL1Ktg7LlAuj5+PF/Ur6hiKiLgip1XXNAyjjGEY8w3D2JV/f9bLxYZh5BmGsTH/NtNZ8YhruLNjDb64tQV7j6XR46MlfDR/J8kZOeddxzRNftt6lKFfraVCcABT7mlLuaCAQopYxPMEBfjy3o1N2Hs8nf/N216o+/7ijz1k5uTxSPc6hbpfERGRosSZUyg8Ayw0TbMOsDD/+dmcMk2zWf6trxPjERfRs1FFfnu0M93qlWfUwl20f2chz/+8mZgjKX9bLjfPwYKYeAaNXc1930RRPaQE39/TlnIlleCJXK72tUMZ2r46E1fuZ+We44Wyz/iUTL5ZfYD+zcOoVTawUPYpIiJSFDmt8IphGDuArqZpxhmGURH4wzTNumdZLs00zYv6tlfhFc+xLS6F8cv3MWvTEbJyHdQtH0TdCkEkpGYRHXuS9Ow8ygb582DXWgxqU1Vj8EQK0KnsPK4dvYzMnDzmPtK5QKc4OZuXZmzhuzUHWfR4V81rKSIicplsqa5pGMZJ0zRL5T82gBOnn/9juVxgI5ALvGOa5i/n2N69wL0AVatWbXngwAGnxC32SM7I4af1sSzecYx9x9MJDfSnceVgOoeXpWvdsgUy7YKI/NvGQye54fOV9GpckdE3N3NaJcTYExlc8f4fDIiowlv9GztlHyIiIkWJ06prGoaxAKhwlreeP/OJaZqmYRjnyiarmaZ52DCMmsAiwzA2m6a5558LmaY5BhgDVkve5cQtrie4uC93dqzBnR01qblIYWpWpRSPdq/D+7/vpGlYMHd3qumU/Xz4+04Mw2D4FbWdsn0RERH5y2UleaZpdj/Xe4ZhxBuGUfGM7prHzrGNw/n3ew3D+ANoDvwryRMREecY1rU2MXEpvDlnGxWDi3Ftk4oFuv2tR5L5eeNh7u1ck0qlihXotkVEROTfnNkHbiYwJP/xEGDGPxcwDKO0YRj++Y9DgQ5AjBNjEhGRf/DyMvjwpmZEVCvNw99vYEFMfIFu/5252ykZ4MuwLmrFExERKQzOTPLeAXoYhrEL6J7/HMMwIgzDGJe/TH0g0jCMTcBirDF5SvJERApZgK83E4a2omGlkgybvJ6Vuwum4uaCmHiW7TrOQ1fWJri4cwu7iIiIiMVphVecSdU1RUSc42RGNjd9uYr4lCx+ebADNUJLXPK2TqRnc9XIpYSU8GPG8A6qjisiIlKAzld4RSULRUTkT6WK+zHu9lZ4exncOm4N+4+nX9J28hwmj/+wiZMZ2Xx4UzMleCIiIoVISZ6IiPxN1ZDiTLqjNRnZudz4xSo2HDxxUeubpslbc7axaPsxXurTkAaVSjopUhERETkbJXkiIvIvjcOC+eH+dhTz82LgmNX8suHwBa13OsEbv3wfQ9tX57a21ZwcqYiIiPyTkjwRETmr2uWCmPFgR5pVKcUjUzcyYsoGktKzz7l8ckYO93wdxdhlVoL3Uu8GhRitiIiInHZZ8+SJiIhnK1PCj8l3t+GzxXv4ZPEuVu45zvPX1qdf08p4eRkA5OQ5mLM5jjd/3UZSejYv9W7AHR2qYxiGzdGLiIgUTaquKSIiF2RbXApP/RjN5sPJ1CxbgsaVg0nPymP9wRMkpWdTv2JJ3r2hCY3Dgu0OVURExOOdr7qmWvJEROSC1K9YkhkPdmBW9BG+X3uIjYdO4uvtRZfwsvRpWpEu4eXw9lLrnYiIiN2U5ImIyAXz8jLo16wy/ZpVtjsUEREROQcVXhEREREREfEgSvJEREREREQ8iFsWXjEMIwE4YHccZxEKHLc7CPlPOk6uT8fIPeg4uQcdJ9enY+QedJzcQ1E6TtVM0yx7tjfcMslzVYZhRJ6rwo24Dh0n16dj5B50nNyDjpPr0zFyDzpO7kHHyaLumiIiIiIiIh5ESZ6IiIiIiIgHUZJXsMbYHYBcEB0n16dj5B50nNyDjpPr0zFyDzpO7kHHCY3JExERERER8ShqyRMREREREfEgSvJEREREREQ8iJI8ERERERERD6IkT0RERERExIMoyRMREREREfEgSvJEREREREQ8iJI8ERERERERD6IkT0RERERExIMoyRMREREREfEgSvJEREREREQ8iJI8ERERERERD6IkT0RERERExIMoyRMREREREfEgPnYHcClCQ0PN6tWr2x2GiIiIiIiILaKioo6bpln2bO+5ZZJXvXp1IiMj7Q5DRERERETEFoZhHDjXe+quKSIiIiIi4kGU5Hm6UychN8vuKEREREREpJC4ZXdN+Q9pCbBiJGz5CVLjwMsHwntC5yehUjO7oxMRERERESdSkudpdi+En+6CzGSo1xvCIiDtGGz4FnbOg2s/gJZD7Y5SRERERNxcTk4OsbGxZGZm2h2KRwsICCAsLAxfX98LXkdJnifZ9D38fD+UawB3zINy9f56r/OT8OOdMOthMB0Qcad9cYqIiIiI24uNjSUoKIjq1atjGIbd4Xgk0zRJTEwkNjaWGjVqXPB6GpPnKbb+Ar88ADU6wd3z/57gARQrBYOnQe0eMOdJ2LfMjihFRERExENkZmYSEhKiBM+JDMMgJCTkoltLleR5giMb4Of7IKwVDJoKfiXOvpy3D9w4HkrXsBLCrNTCjVNEREREPIoSPOe7lN+xkjx3d+oEfH8rlCgHAyeDX/HzLx8QDNd9BsmxsODVwolRREREREQKjZI8d2aa1hi7tKNw00QIPOuE9/9WpTW0vhcix8OxbU4NUURERETEmd58800aNmxIkyZNaNasGWvWrOHuu+8mJibmkrYXHx9P7969adq0KQ0aNKBXr14FHLHzqfCKO9vwLcTMgO6vQOWWF7du12dg0xRY8AoMnuqM6EREREREnGrVqlXMnj2b9evX4+/vz/Hjx8nOzmbcuHGXvM2XXnqJHj168PDDDwMQHR1dUOEWGrXkuauUIzDvWajeCdo/fPHrFy8DHR+xplU4tLbAwxMRERERcba4uDhCQ0Px9/cHIDQ0lEqVKtG1a1ciIyMBCAwM5Pnnn6dp06a0bduW+Ph4ABISErjhhhto1aoVrVq1YsWKFX9uMyws7M99NGnSBIAHH3yQmTNnAtC/f3/uvNOqVj9hwgSef/55AL799ltat25Ns2bNuO+++8jLywPg999/p127drRo0YIBAwaQlpYGQPXq1Xnqqado3LgxrVu3Zvfu3QXye1FLnrua+xQ4cqDvx+B1ibl66/tgxWhYMQpunlyw8YmIiIhI0TH3GTi6uWC3WaExXPPOeRe56qqreO211wgPD6d79+4MHDiQLl26/G2Z9PR02rZty5tvvslTTz3F2LFjeeGFF3j44Yd59NFH6dixIwcPHuTqq69m27ZtPPjggwwcOJBPPvmE7t27c8cdd1CpUiU6derEsmXL6Nu3L4cPHyYuLg6AZcuWcfPNN7Nt2zamTp3KihUr8PX1ZdiwYUyePJlevXrxxhtvsGDBAkqUKMH//vc/PvzwQ1566SUAgoOD2bx5M19//TWPPPIIs2fPvuxfnZI8d7R9DmybBd1ehjIXPl/Gv/gHQut7YOn7kLATyoYXXIwiIiIiIk4WGBhIVFQUy5YtY/HixQwcOJB33vl7Yujn50fv3r0BaNmyJfPnzwdgwYIFfxu3l5KSQlpaGldffTV79+5l3rx5zJ07l+bNm7NlyxY6derEyJEjiYmJoUGDBpw4cYK4uDhWrVrF6NGjmTRpElFRUbRq1QqAU6dOUa5cOVavXk1MTAwdOnQAIDs7m3bt2v2530GDBv15/+ijjxbI70VJnrvJSoU5T0C5htD+ocvfXuv7YOXHsOpjq1VQRERERORi/UeLmzN5e3vTtWtXunbtSuPGjZk0adLf3vf19f1zGgJvb29yc3MBcDgcrF69moCAgH9ts0yZMgwePJjBgwfTu3dvli5dyg033MDJkyeZN28enTt3JikpiWnTphEYGEhQUBCmaTJkyBDefvvtv21r1qxZ9OjRgylTppw1/jOnSCioKSk0Js/dLH7LGo/XZyR4+17+9gLLQrNbYNP3kBp/+dsTERERESkkO3bsYNeuXX8+37hxI9WqVbugda+66io+/vivRo6NGzcCsGjRIjIyMgBITU1lz549VK1aFYC2bdsycuRIOnfuTKdOnXj//ffp1KkTAN26dePHH3/k2LFjACQlJXHgwAHatm3LihUr/hxvl56ezs6dO//c79SpU/+8P7OF73IoyXMnRzbAmi8g4k5rGoSC0nYY5GXDhq8LbpsiIiIiIk6WlpbGkCFDaNCgAU2aNCEmJoZXXnnlgtYdPXo0kZGRNGnShAYNGvDFF18AEBUVRUREBE2aNKFdu3bcfffdf3bB7NSpE7m5udSuXZsWLVqQlJT0Z5LXoEED3njjDa666iqaNGlCjx49iIuLo2zZskycOJFBgwb9uc3t27f/GceJEydo0qQJo0aN4qOPPiqQ34thmmaBbKgwRUREmKer5RQZebkw9gpIOwbD11qTmhekSX0gaT88vBG8vAt22yIiIiLicbZt20b9+vXtDsOtVa9encjISEJDQ8+73Nl+14ZhRJmmGXG25dWS5y7WfglHo+Ga/xV8ggfQ8g5IPgh7FhX8tkVEREREpNAoyXMHJw/BojehztXQoJ9z9lGvN5QoC5ETnLN9ERERERH5m/379/9nK96lUJLn6kzTqqaJCde+DwVUcedffPyg+a3W5OjJh52zDxERERHxKO449MvdXMrvWEmeq9v6s5V4XfE8lKrq3H21GGIlletVgMVlZKdDfAzERUNWmt3RiIiIiPwpICCAxMREJXpOZJomiYmJZ53m4XycPk+eYRg9gVGANzDONM13/vH+UOA94HTz0SemaY5zdlxu4dQJmPs0VGwGbe53/v7K1IBaV1pJXpenVIDFLqYJB1bC+kkQMwNyM63XDS+o0RmaDoL6fcGvuL1xioiISJEWFhZGbGwsCQkJdofi0QICAggLC7uodZya5BmG4Q18CvQAYoF1hmHMNE0z5h+LTjVNc7gzY3FLv78IGYlw60/gXUjz1rccAtNuh90LIfyqwtmnWNISYNN3VpKduBv8S1pzGFbvYCV4cdFWy+7P98GcJ6HxAGhxO1RqZnfkIiIiUgT5+vpSo0YNu8OQs3B25tAa2G2a5l4AwzC+B/oB/0zy5J/2LYMN30CHh6Fik8Lbb/g1VgGW9ZOU5BWWAyut+Q+3zwFHDlRpC50ehwbX/b21rmF/6PYSHFhhJYIbJ0PkeKjY1Opq23SQWvdERERExOlj8ioDh854Hpv/2j/dYBhGtGEYPxqGUeVsGzIM417DMCINw4j0+CbhnFMw62EoXR26PFO4+/bxs5KFHXMh9Wjh7ruoOXEAvu4HX11jJfWt74Vha+Cu36DZ4LMnbIYB1TvC9WPg8e1wzXvgyINfH4PP2sCuBYX/c4iIiIiIS3GFwiuzgOqmaTYB5gOTzraQaZpjTNOMME0zomzZsoUaYKFb8i4k7YHeH9nTMtNiCJh5sPG7wt93UbFnEXzeAWKj4Oq34dGt0PMtKFfvwrdRrDS0uRfuXw5DZoFvcZh8Iyz70BrXJyIiIiJFkrOTvMPAmS1zYfxVYAUA0zQTTdPMyn86Dmjp5Jhc26F1sGIkNB1sFUGxQ2htqNbB6hLocNgTgyfbMRcm32S11A5bCe2GXV4ybxhWQZZ7FltdOhe+CvNfUqInIiIiUkQ5O8lbB9QxDKOGYRh+wM3AzDMXMAyj4hlP+wLbnByT68rOsIpqBFWCa9757+WdqcUQOLEPDiy3Nw5PE7cJfrwTKjSCobMLdloMv+Jww3hodTesHA3znlWiJyIiIlIEOTXJM00zFxgO/IaVvE0zTXOrYRivGYbRN3+xEYZhbDUMYxMwAhjqzJhc2oKXrW6a130GAcH2xtKgrxVD1Fl7z8qlSI2HKYOsbpaDvodipQp+H15e0Ot9aPMArPkcfn1crbEiIiIiRYzT6/KbpjkHmPOP11464/GzwLPOjsPl7VkEa8dA22FQs4vd0YBvMWgyEKImQkYSFC9jd0TuLScTvh9szX145zwIquC8fRkG9HzbmnZj5cdWxc7eo6wEUEREREQ8ns76XEFGEvzyIISGWyXyXUWL2yEvG6Kn2h2JezNNmPEgHI6E/l9aUx44m2FAj9etqRjWfw0zh1tVOEVERETE4ynJs5tpwi8PQMZxqyy+bzG7I/pLhcZQqYWVJGhs16Vb9Dps+dFK4Bv0/e/lC4phwJUvQtdnrTn1fr4P8nILb/8iIiIiYgsleXZb9SnsnAdXvQGVmtsdzb+1uB2OxUBspN2RuKeoibDsA+v32PGxwt+/YUDXZ6xkb/MPMP1uyMsp/DhEREREpNA4fUyenEdspFVspX4fayJsV9T4RvjteVg/Caq0sjsa97JrAcx+DGp3h2s/tBIuu3R+Arx9rakVHLlwwwRr4ntxPQ4HJO2FzGTrmPmVsOZANAzrsX+Q3RGKiIiIi1OSZ5dTJ+CHO6BkJej7ib0JwPn4B0Gj/rBlOlz9pv1VP91FXDT8MATKN4ABE62Tdbt1eBi8/WDeM/DL/dZ0C676d1dUOPIgfiscjoKjmyF+CxzdAjnp516nVFWo2g6qd7TmsyxTU8dRRERE/kZJnh0cefDT3ZAaB3f+5pxS+gUp4i7Y8K11a/eg3dG4vtSj8N1ACCgFg39wrZaXtg9ATgYsfA2qtIE299kdUdGUnmi1jq8bDymx1mv+JaF8I2h+C1RoAoHlITfTOl45Gda42MyT1gWEPYv/KohUoizU6GLNj1i1rRI+ERERUZJni0Wvw+4F0HskhLW0O5r/VrkFVG0Pq7+A1vdZpfnl7HJOWVMlZCbDXb9ByYp2R/RvHR6FQ2utbriVI9zjb9ATmCYcXAWREyBmhlW5tkYXuPIFqNoGSte48ATNNOH4LjiwAg6tgR1zreI+FZpY4z8bD3D9i0ciIiLiNIbphlUTIyIizMhINy0EsmU6/HgHtLwD+oy0O5oLt202TL3F6nrYsL/d0biunx+ATd/BwMlQv7fd0ZxbRhJ82QUw4b6lmgfRmUwTtv8KS96xumT6B0PTgdZnQPkGBbOP7HTY9D1EfWXtwyfA+j/t/CSE1CqYfYiIiIhLMQwjyjTNiLO+pySvEB3dDOOvsq62D5nlXoUvHHnwcUsoEQp3L7A7Gte0+Uf46S7o8jRc8Zzd0fy3w1Ewoac1ruuWH9VC6wwnD8Kcp2DnXAipA+2HW61sfiWct88jG61pTzZ9b7UWtrnPmi9RibyIiIhHOV+SpykUCktGktWNLyAYbvravRI8AC9vaDsMYtdZXf3k79KOwa+PQVgr6PyU3dFcmMot4doPYO9iWPiq3dF4lrwcWD4SPm0D+5ZYE9MPWwUthzo3wQOo1Ax6fwgjNkDTm61pWkY1hSXvQVaqc/ctIiIiLkFJXmHIy4UfhloFOQZOhqDydkd0aZrlJ6krRtkdietZ9LrVZa7fZ+7VItbidqtgx8rRsPE7u6PxDAdXwxedrOlRal0JD66FDiMKv8JqUHno9wk8sAKqd4LFb8DIJlaxF4ejcGMRERGRQuVGZ6NubMHL1tX8fp+6d5EL/0Cr8MrSd62upxUa2x2Ra4jbBOu/sVo6y4bbHc3Fu/ptq4jHzIcgqCLUusLuiNyTwwHL3ofFb0FwGNw8Ber1sjsqKN8QBn0HsVHWZ9Gvj8HWn6HvaGv6BXENeTmQuAeO74DkWOuiYNoxyDgOOZngyLHmuMSwPouLlbYq+AYEW39vZWpAcBUoVQ18A+z+aURExGYak+dsm76Hn++zkqNe79odzeU7dQJGNoUaneDmyXZHYz/ThK96WSdmD61334qGmckw4RprDNmd86BCI7sjci8ZSTD9Xtg9HxrdCH1GWSfirsY0rakbfnvBSho6PWG1Mvr42x1Z0XNiP+xbZlVcjYu2PkPysv9639vfmkajRAj4lrB6CBjegGl1u81IgqwUOHXSOpaneflCxSYQ1hqqtLLug8M0tYaIiAdS4RW7xEbBV9dAldZw28+uMSF2QfjjHfjjbbh3iTX+pyg7XS2190iIuMPuaC5P8mEY1916fPcCCK5sbzzu4vB6mDbEmvey59tW91dXP6FOOQLznrGmcgipA9e+DzW72h2VZ8vLsXp0xMy05jlMPmi9XqyMNT62fEPrVrauNeF9QKkL+ztyOCDtqJU0JsdC/BY4tA6ObIDcU9YyQRWt8cJVWkONzlbxL1f/GxURkf+kJM8OKXEwpqt1hfyexdbVWE+RmQwjG1tz5w3+3u5o7JNzCj5pZZ2M3bfEKk7j7o5usS5MBIfBnb9BQEm7I3JdpgmR42Hes1aLy4BJ7tcde9cCmPMEnNgHzW+Dnu+4Zguku8rLgV2/W8n0zt+syez9Aq2EukYXq0dE2XrOSbjycqxu9aeLZcWug5MHrPeCq0D41VDnKivp8y1W8PsXERGnU5JX2HIyYWIvOLYd7p5vXZ31NEveswo53LPIugpdFC15Fxa/CUNmWydrnmLPYvj2Bqh3rVUJVlf8/y07HWY/CtFToXZ3uH6s+05RkJMJS/4Hyz+yxujdMLbo/k8XlIQdsHEybJwC6ces8XPhPaF+H6jVzb4xc6lHYdd82DEH9v4BORlWV9Dwq6FBXys2Xdixn2lCRqLVMptyBFIOQ/pxyMuC3Oz8+yyre29eNpj5hZT8gqzPoeJloHiI1Up85uNipd2rMJiI/CcleYXJNOHn+yH6exj4rfWl7okyU6yy7BWbwO0z7I6m8CUfhk8irBP8gd/YHU3BWzEa5r8IV78F7R60OxrXkpEEkwdY8wxe8Zw1rs3LAwoV718O0++zup22Hw5dngG/4nZH5T7ycmDbTFjzJRxaY42fC7/aqmBbu4frnVznZMKB5bBtlnXLSLTGAdbtac3lWOcqjdV0puwMOLYNjm3N72p72ErmTid2eVn/XsfL1zom3n5/3Xv7Wb1ITAdkpVnH8WzrnhYQDCXKQunqULqGVbCnTC2raFipap7RI0WkCFGSV5hWfgy/vwBXPA9d3GS+tEu16lP47Tm47ZeiV5Hxxzth22wYvtb6svQ0pglTb4Wd82Dor1C1rd0RuYbUo/BNf0jcDQMmWq2dnuTUCfj9RdjwjXXC12dU0fvfvlhpCRA1ESInQOoR68S51V3QZCAElrM7uguTl2slpjEzYMtPVkXPgFLQ6AZoOgjCItSifzlOnYTYSDgabXWhPboZkvb81QJneEPJSlCysnUfXBlKhv39cYnQC0vATNNqoc1IshK+U0n5j5PyHydCWryVWCbth6zkv9b1CbDG6JatC+XqQ7kGVhVtFe6xT16uNUTmVJL1+ZyVag0VycmwepTkZIAjDwwv6+/D8LaOlZe39Zrh/Y/HXuDlY3Ub9y9ptdyfvvctruPshmxN8gzD6AmMAryBcaZpvvOP9/2Br4GWQCIw0DTN/efbpssmebsWwHcDrNa7AZM8/58lJ9NqzSoRao079PSf97Qdc2HKzdD1Wej6jN3ROM+pk9a40twsuG8pBJa1OyJ7Je6xurGmHbOmJPDkQiX7V8CshyFxlzU1SLeXVZb/n04egmUfWN0y87KtORFb3wt1rnbvlt28XKsr56YpsH025GZa3XibDLRa+EJq2R2h68tMhgOrYP8y6xYXDeSfa5WqZiVOFRr/VWzHrhY007QSh8TdVhfjhO1/3Scf+mu5gFL5MTexKi9XaAyhdcHHr/Bj9gSmaY3PTTnyV3fclDirF0XqUUhP+Cupy0z+z80VGMP7r6SvWKn86r7lrO/+EuWsi1Ylylr3geWt7r9F5bzPhdmW5BmG4Q3sBHoAscA6YJBpmjFnLDMMaGKa5v2GYdwM9DdNc+D5tuuSSd7xXTC2m1UV7a7fwK+E3REVjg2TYcYwK6lteJ3d0ThfZjJ82tb6ALx3ied/ycVFWxU3q7WDW6cX3a48+5ZZLZuGF9zyg9Wy4elyTsH8l2DtGCjXEK77TNV0wSpOtOZziJ5mnay1uA3aPOCec2T+l8xkqytn9FTrfwDTqtLZ8Hpo0E8VeE/LTLGmwti/zPo9HY22Wum8/a2KptU7QrX2VpLkLtPsZKZY3Unj81sej26B+K1/VWz18oVy9fITv8ZQvpGVABYrbW/criI320qUT+yDpH1Wy+mZt+y0f6xgWAlUUH5iVbzMX+Mo/3xcCvyDrEJJviWs7vS+xa2WOTPPatEzTeux6ch/fuZjh3XLy7H2n5liTcOSmWzdZ6X+9VpGkjWeOC3BSjrPnKblNC9fK9kLKg+BFaz7oIoQVAGCKln3geWt+IvquUMhsDPJawe8Yprm1fnPnwUwTfPtM5b5LX+ZVYZh+ABHgbLmeQJzuSQv5xR80cm66nLvYivRKyocefB5e2uS3mFrXG/cSUGb9TCs/xruWuB+lRQv1fqvrYnSOz8FVz5vdzSFL2qSNYF4mVoweKo1hqUo2fk7zHjQ6sLXdpjVgl0UK3Ae3QyL3oSdc8GnGDS/BTo8AqWq2B1Z4Ug+DFt+hOgfrBN/DCt5aTzAKtpSlE7us1LPaKlbDnEb85M6PysJrt7J+t2EtfKsFnBHntWj4XS30/gt1n1a/F/LBFWC0Pwun6Hh1q1sXetk39NafU6dOCOBy79P2gcnDkBK7F/dccHqCnt6HGTpatZ54plddAPLu+40W6dbfNMTrJ4safH5j+MhNd6awiU13mqJPJV0lg0Y1udDibJWz6/iIfn3ofmvheQ/zn9erIznn0sWIDuTvBuBnqZp3p3//DagjWmaw89YZkv+MrH5z/fkL3P8H9u6F7gXoGrVqi0PHDjgtLgvybpxULY+VO9gdySFb/uv8P1ga/xOy6F2R+M8+5bCpD7Qbjhc/abd0RQe07RO8jdOhsHTrGISRYFpwuK3YOm7Vle8AROtogVF0amTsPBVa9xZcBWrVa9GZ7ujKhyxkVbl0e2zwT/YKkrT6m73raZaEI7vtsbuRU+1xpZ5+Vr/I/X7QN1rrJM1T5KVCgfX/NX98shGq4XEyzc/qetoVVgOa1U0p6NIjf+rxS9hh3U7vguyU/9axj/Yau0+M/ELzS/24qon9Hm5VlfKE2e0xJ2Z1P2zK2WJcvmJXHXrYuCfSV11K4lz527cFyo3y+pymhpndUVNT7Aqw2Ycz79P/Ou1Uyf4sxvzPxUrfUbil58Ynh476BdkJcRnjjX8c0yi11+3f71/+rFhtWbmnLLizc3Mv2VZLdU5mdb/fFbK31s7mw2Gtg8U6q/zQnhEkncml2vJK+pME8ZfZXVNeGi9Z1bky86wWiwBHljpmT/j+WRnwISrrKu4Q2Z5fndF04QFr8CKkdD8Vug9ynVPRArTwTVW9+zE3VYXxSue89yS+4ejrJa7PQutMUmt74V2w4pWi9V/MU1r0vWt02HrjPwJ3g1rCo46Pazqw5Wau19XrewMOLTa6nq5fxkcXn9GUhdhJXXVO0JY66L3XXChTNM60U/YAcd3WrfTj89s+fP2g5DaVutfaPhfY70CSln3xUpZjwOCC+Yz2OGAnHSrEml6Qv44uLi/EpMz79OO8bckxMvXaoH7ZwJXpoaVrBbFHg6XIy/XSvROJ4DpCflJ4FmSwoxEK/HKzXR+XIaX1S3WP/ivMYr+QdDoemh6s/P3f5HUXVOcb/8Ka27A7q9Cx0fsjqbg/fY8rPrE8+bEuxip8Vail5kMd8yzxmN4ItO0jvfqTyHiLuj1ftG4AnuhsjNgwcvWWL0S5aD7K1YFRk/4HZkmHFhpVUneOdfqNtTxEevvQCdw52eaVje+HXOtufgORwGm9Tus3c2aRqLWla5ZwCn9OBxcbY2rO7ja6n7pyLXGOlVu+Vf3yyqti854e2c6ddJq6Tt+Rqvf8R1WC9mZXRz/6XRBkDMTQP+gv1eQzM6wxptlp59xS/vrtZyMc2+/RNn88WQV/7ovWfmvpK5kZfe7YOFpcrOtZM+Rc5Zxh/ljDv8cn+g4+3unx8v6+Fst7z7+Vhf808+9fNyqa7GdSZ4PVuGVbsBhrMIrg03T3HrGMg8Cjc8ovHK9aZo3nW+7SvJc1OQBVhnuhzd51tXu2CgY3x1aDIE+I+2Oxl5Je2H81VZXiTt/87zxSI48mPuU1f269X1wzf/c6sO+UB2OgrlPQ+w6qNQCrn3ffSdRN03Y9Tv88bbVMlWstDX+sO0D1kmkXLz0RNi72Er4di+wrsxjWMV7ane3/lbKN7S6/xbW/5hpWt3v4rf+NabsyAYruQDrxK9yS2vKmGodrHsl94UnN9uqOnnqZH5lyQt4nJ3214m+I89Kwv+8Bebf/vGaf6BVsKREWWs8XFAF64KVpxdSE49k9xQKvYCRWFMoTDBN803DMF4DIk3TnGkYRgDwDdAcSAJuNk1z7/m2qSTPRR3dbBWg6fiIdXXfE+Rmw5edrdarB1cX3TFZZzq6Gb661qqkddd896kW91+yUuHHu2DXb9B+BPR4TQnef3E4YPM0qwpn2jFoOcQqzBJUwe7ILkxerjWB+apPrKS1VDXr86vJzeqGV5AcDji6yZpmaPd868LA6RabgGCrMmP5hlC2ntV1r0xNawyOb7FL+x/MzbYKX5w8+Nf0APExVlKXefKv5UpVg4pNrbF0VVpbXUs1AbyIuBFNhi6F56d7rJLbIzZAyYp2R3P5lrwLi98sWgVHLsS+ZfDNdVCji/W7cffxaicPWXMfHtsGvd6zJrOWC5eZAkv+B6s/t1p5Ww6FDg9bV8ldUVaaVTV21adWMlC6hhVv81tdt8KdJ8lK/Svpit9ilec/FvPvsvLeflYSeHpMVrH8e8Pb6k7pyLVab3Iz/5oA/PQcY2fyC7QSyAqN8hPK/KTSU8eTikiRoSRPCk/SPviklXWy5O5dG1OOwOgWVnJ30yS7o3E9UZNg1girAMc179gdzaU7ugW+vd6qtDVgojV+SC5N0l5Y9qE1kbbhDa3vgU6Pu04lyvgY2PQdrP/GatGp2h7aP2T9j2usjb0cDkg9YrW8Je37q1teZrJ1O3XGY9NhjZvx8rGOm0+A1epXrLRViS+wgnWBoXQ1q1WwZGW1youIR1KSJ4VrzpOwbjw8uBZCa9sdzaX7ZRhs/gGGr7MGXcu/zXsWVn8GvUdCxB12R3PxYiPh2xus8Rm3TYdy9e2OyDOc2G+1gm+aYrXG1O9jlZ+u0aXwk6nsDIj5xRpneTjKSgzCe1otd1VaF24sIiIiBUhJnhSutGMwqpk1X9KN4+2O5tLERVtj8doPh6vesDsa15WXa3Vz3LsYbvvZveZO27fMir1EWbh9hnXVXwrWsW1WcrX5B6sFpmRlqwR108HOvQCUmWIVUomZYRX9yMmwyrO3vMOavNsVKzyKiIhcJCV5Uvh+f8Ea7zJig/u1gpkmfN3PKgc+YoNnVQp1hszk/HkSY2Hgt1DrCrsj+m87f4Npt1tjsW7/xX0KhbirnExrSoKN31lJl+mwKnLWuQrCr4KKzS9vCobcbGtsV9xG2Pm7NbddXrY151b9PtCwv1UtUV32RETEgyjJk8KXcgRGNrEKMFz7vt3RXJydv8F3N0HP/0Hb++2Oxj2kxFndHo/vhP5fQOMb7Y7o7BwOWDkKFr4OFRpbrY+uMl6sqEg9CtHTrAJNsesA06qkGFr3r0mFS1W1biUrWmXtvf3AN8Cazyz5EJw4ACcPWPdJe62Kr3lZ1vZLhkGDvtCgnzVZtSfM3yciInIWSvLEHjMehM0/waNbrMHw7iAvFz5vb1VtG7Za8+ZcjFMn4ftb4MBya/qB9iNcq+UkLQF+vs9q5WlwHfT9WNX17JaeaLXs7VtiJWtJ+yDt6IWta3hZ3T9LV7fK4FduCZVbWEmiK/3diYiIOMn5kjw3r3suLq39w7DhW1jzJVz5vN3RXJj1k+D4DqvboRK8i1OsFNz6E/xyvzVvWnIs9HzHNaoWHtkI3w+2WoJ6f2SNzVIiYL8SIdB0oHU7LSfTmrD65AGrhdiRY3XHzD0FxUMhuLLVyhdcRdMdiIiInIOSPHGesuFQ91pYO8aqZOcfaHdE55eZAovfssqq1+ttdzTuyTcAbpgAwWGw8mOrCM/1Y+1NmLdMtyqlFg+Bu+dbrT7iunwDIKSWdRMREZFLosEK4lwdH7HmOtrwjd2R/LcVIyHjOFz9hlp5LoeXl1WR9Ko3rdL13w+yytgXNocDFr4GP95hJXb3/qEET0RERIoEJXniXFVaQ9V2sOoza7ybq0qOtaqBNh5gje2Ry9d+OPQZDbsXwjf9rYIbhSU+Br7uC8s+gBa3w5BZKpsvIiIiRYaSPHG+9iMg+aDVquOqFr5mTZ3Q7SW7I/EsLYfAgK8gbhN81g6iJkJejvP2d+oEzHkKvuhoTYHRZ5SVaGp8pYiIiBQhSvLE+cJ7WhMRrxhlJVKu5nAURE+FdsOsgg5SsBr2h/uWQkhtmPUwfNIKNk21ulMWFEceRH4Fo1vAurHW1B0PbbDu1fVWREREihgleeJ8Xl7QbrjVsrJvid3R/J0jD2Y/Zk2a3PFRu6PxXGXD4a7fYdBU8AuEn++FMZ1hz6LL265pwt4lMKYrzH4EytW3EsreH1qVG0VERESKICV5UjiaDLQSqRWj7I7k76K+griNcPVbEBBsdzSezTCgbk8rCbthPGQmW2P1vulvtaZeaCtvbhbsXw6L3oAxXayxdxmJcOMEGPqrNcm5iIiISBGmKRSkcPgGQJv7rLFvRze7xol4arwVT43O0OgGu6MpOry8oPGNUL8PrBsHS9+DsVdCYAUoW9fqMluqGpSqYj0OLG8lcYfWwN4/4MBKyMmwJsOu1AJ6vQ/Nb7P+xkREREQEw3TFMVL/ISIiwoyMjLQ7DLlYp07Ahw2hfm+4foy9sTgc8G1/OLga7ltmdScUe5w6CTEzrNa5E/vg5EFIiz/7sqF1oWYXqNkVqnWwJmAXERERKYIMw4gyTTPibO+pJU8KT7HSVrXFtWPgyhetlhq7LP/QahXqM1oJnt2KlbL+LloO+eu1nExrWouTB6ypF4qHQMUmULKSbWGKiIiIuAunjckzDKOMYRjzDcPYlX9f+hzL5RmGsTH/NtNZ8YiLaPeg1c1uyf/si2HPIlj8ltVFs8Xt9sUh5+YbAKG1oXY3aH6LNZZPCZ6IiIjIBXFm4ZVngIWmadYBFuY/P5tTpmk2y7/1dWI84gqCw6DV3bBxMiTsLPz9H90MU2+HsvWg90iV1xcRERERj+PMJK8fMCn/8STgOifuS9xJp8fBtzgsfqNw93vyEEweAP5BcMsPEFCycPcvIiIiIlIInJnklTdNMy7/8VGg/DmWCzAMI9IwjNWGYVx3ro0ZhnFv/nKRCQkJBR2rFKYSoda8eTEz4NDawtnnqZNWgpedDrf+CMGVC2e/IiIiIiKF7LKSPMMwFhiGseUst35nLmdaJTzPVcazWn5VmMHASMMwap1tIdM0x5imGWGaZkTZsmUvJ2xxBe2HQ8nKMOthyMtx7r7ycuCHIZC4GwZ+C+UbOnd/IiIiIiI2uqwkzzTN7qZpNjrLbQYQbxhGRYD8+2Pn2Mbh/Pu9wB9A88uJSdyEf5A1v9mxGFj2oXP3Ne/Z/EqaI63y+yIiIiIiHsyZ3TVnAqdrog8BZvxzAcMwShuG4Z//OBToAMQ4MSZxJfV6QeObYMk7sHeJc/axdiysGwvtH4LmtzpnHyIiIiIiLsSZSd47QA/DMHYB3fOfYxhGhGEY4/KXqQ9EGoaxCVgMvGOappK8oqT3RxBSB34YCvEFfOj3LIa5T0N4T+j+asFuW0RERETERRnWcDn3EhERYUZGRtodhhSUpL3wVS9w5MHgqVC5xeVv8/huGHclBFWCu35XJU0RERER8SiGYUTl1zb5F2e25IlcmDI14faZ4OMPE3rCmi+thO9SZSTBdzeBlw8M/l4JnoiIiIgUKUryxDWUDYd7/4AanWDuU/BlZ9gy/eKTvdxsmHorJB+Cm7+D0tWdEa2IiIiIiMtSkieuo0Qo3PIj3PgV5GbBj3fAp60hcoI1v91/yc221jmwAvp9BlXbOj9mEREREREXoyRPXIthQKPr4cE1MGAS+JWA2Y/Chw3g9xfhxIGzr5eWYHXR3D4bev4Pmgwo3LhFRERERFyECq+IazNNOLga1nwB22YBplUts15vKFcfHLmwb4k1ji8zBa59H1rcbnfUIiIiIiJOdb7CKz6FHYzIRTEMqNbOuiXHwrpxsHEK7Jjz9+VqXgFXvQEVGtkTp4iIiIiIi1BLnrgf04RjMXBiv1VBs1x9KFXV7qhERERERAqNWvLEsxgGlG9o3URERERE5G9UeEVERERERMSDKMkTERERERHxIG45Js8wjATgHLX0bRUKHLc7CPlPOk6uT8fIPeg4uQcdJ9enY+QedJzcQ1E6TtVM0yx7tjfcMslzVYZhRJ5r8KO4Dh0n16dj5B50nNyDjpPr0zFyDzpO7kHHyaLumiIiIiIiIh5ESZ6IiIiIiIgHUZJXsMbYHYBcEB0n16dj5B50nNyDjpPr0zFyDzpO7kHHCY3JExERERER8ShqyRMREREREfEgSvJEREREREQ8iJI8ERERERERD6IkT0RERERExIMoyRMREREREfEgSvJEREREREQ8iJI8ERERERERD6IkT0RERERExIMoyRMREREREfEgSvJEREREREQ8iJI8ERERERERD+LUJM8wjAmGYRwzDGPLOd43DMMYbRjGbsMwog3DaOHMeERERERERDyds1vyJgI9z/P+NUCd/Nu9wOdOjkdERERERMSj+Thz46ZpLjUMo/p5FukHfG2apgmsNgyjlGEYFU3TjDvfdkNDQ83q1c+3WREREREREc8VFRV13DTNsmd7z6lJ3gWoDBw643ls/mv/SvIMw7gXq7WPqlWrEhkZWSgBioiIiIiIuBrDMA6c6z23KbximuYY0zQjTNOMKFv2rAmriIiIiIhIkWd3S95hoMoZz8PyX5PLYJoma46uYdWRVZzIPEHlwMpcUfUKwkuH2x2aiIiIiIg4md1J3kxguGEY3wNtgOT/Go8n53cw5SBPLX2KrYlb8fHyIdgvmMTMRD7Z+Al9avbhxXYvUsynmN1hioiIiIiIkzg1yTMMYwrQFQg1DCMWeBnwBTBN8wtgDtAL2A1kAHc4Mx5Pt/HYRh5Y8ABehhevtX+NXjV74e/tz8nMk0zcOpEJWyZwIPUAX3T/giC/ILvDFREREREpMDk5OcTGxpKZmWl3KAUqICCAsLAwfH19L3gdwyps6V4iIiJMFV75ux1JO7hj3h2UDijNmKvGUDmw8r+WWXBgAU8ueZK2ldryyZWf4O3lbUOkIiIiIiIFb9++fQQFBRESEoJhGHaHUyBM0yQxMZHU1FRq1Kjxt/cMw4gyTTPibOu5TeEVObfU7FQeXvwwxX2LM+6qcWdN8AC6V+vOc22fY/nh5Xy+SVMSioiIiIjnyMzM9KgED8AwDEJCQi66dVJJngd4fdXrHE0/yvtd3qdiYMXzLjsgfAB9a/Vl3OZxbE/aXkgRioiIiIg4nycleKddys+kJM/N/XHoD+bun8v9Te+nWblmF7TOU62eopR/KV5e+TIO0+HU+EREREREpHApyXNjGTkZvLnmTWqXqs1dje664PWC/YN5POJxYhJj+H3/706MUERERESk6HjzzTdp2LAhTZo0oVmzZqxZs+acy3bt2pW6devStGlTWrVqxcaNGwssDiV5buyTjZ9wNP0oL7d7GV/vC6+2A9CrRi/qlK7Dxxs+JseR46QIRURERESKhlWrVjF79mzWr19PdHQ0CxYsoEqVKuddZ/LkyWzatIlhw4bx5JNPFlgsds+TJ5doa+JWJm+bzIDwARfcTfNM3l7ejGg+gocWPcS8ffPoU6tPwQcpIiIiImKD/639X4HXn6hXph5Pt376nO/HxcURGhqKv78/AKGhoQAsXLiQJ554gtzcXFq1asXnn3/+5zKntWvXjvfee6/AYlVLnhvKdeTy6spXKRNQhkdaPnLJ2+kS1oVawbWYtHUS7jiVhoiIiIiIq7jqqqs4dOgQ4eHhDBs2jCVLlpCZmcnQoUOZOnUqmzdvJjc3l88//3eV+3nz5nHdddcVWCxqyXNDU7ZPYVvSNt7r8h4l/Upe8nYMw+D2hrfz8sqXWXN0DW0rti3AKEVERERE7HG+FjdnCQwMJCoqimXLlrF48WIGDhzIs88+S40aNQgPDwdgyJAhfPrppzzyyCMA3HLLLWRnZ5OWlqYxeUXZ0fSjfLzhYzpV7sTV1a6+7O1dW/NaygSUYeLWiZcfnIiIiIhIEebt7U3Xrl159dVX+eSTT/jll1/Ou/zkyZPZu3cvQ4YM4aGHHiqwOJTkuZm31rwFwPNtny+QeUD8vf0ZVG8QKw6vYO/JvZe9PRERERGRomjHjh3s2rXrz+cbN26kVq1a7N+/n927dwPwzTff0KVLl7+tZxgGr7/+OqtXr2b79oIZR6gkz40sOriIxYcW80DTB6gcWLnAtntj+I34GD5M3zW9wLYpIiIiIlKUpKWlMWTIEBo0aECTJk2IiYnhnXfe4auvvmLAgAE0btwYLy8v7r///n+tW6xYMR5//PECK75iuGPBjYiICDMyMtLuMApVRk4G/Wb0I8gviKm9p+LrdXFTJvyXRxY/woZjG1hw44KLno5BRERERMRu27Zto379+naH4RRn+9kMw4gyTTPibMur8Iqb+HTjpxxNP8p7nd8r8AQP4Po617Pw4EL+iP2DHtV6FPj25eLFp8cTGR/JwdSDlPQrSUT5CMJLhxdIN10RERER8VxK8tzA9qTtTN42mRvDb7ykOfEuRIdKHShXvBzTd01XkmejXEcuiw4uYuqOqaw7ug6Tv7e0h5cO58bwG+lVoxfB/sE2RSkiIiIirkxJnovLc+Tx2qrXCPYP5pEWjzhtP95e3lxX+zrGRo/laPpRKpSo4LR9yb8lnkrkp10/MW3HNOIz4qkcWJkHmj3AFVWuoFZwLRIzE1kau5Qfd/7IW2ve4t1179IlrAvdq3Wnc1jny5pKQ0RERMRTmKbpcb2eLmV4nZI8F/fDzh/YfHwzb3d62+ktN/1r92dM9Bh+3v0zDzR9wKn7EsuBlAOMiR7D3H1zyXHk0LZiW55v8zydwzrj7eX953IVSlTgpro3cVPdm9ietJ0Zu2cwb/88Fh5ciI+XD60rtObW+rfSsXJHj/tgExEREbkQAQEBJCYmEhIS4jHnQ6ZpkpiYSEBAwEWt5/TCK4Zh9ARGAd7AONM03/nH+0OB94DD+S99YprmuPNts6gUXjl+6jh9fu5Do9BGjOkxplD+WO/5/R4Ophxk7g1z8TJUfNVZ8hx5fBH9BeOix+Hr7Uu/Wv0YVG8QNUvVvOBtOEwH0QnRLDy4kN/2/0Zcehxdw7ryeofXKRVQynnBi4iIiLignJwcYmNjyczMtDuUAhUQEEBYWBi+vn+vy3G+witOTfIMw/AGdgI9gFhgHTDINM2YM5YZCkSYpjn8QrdbVJK8p5Y8xcKDC5nebzrVSlYrlH3O3TeXp5Y+xZgeY2hXqV2h7LOoyXXk8vgfj7Po0CL61OzDYxGPEVos9LK2mZOXw3fbv2PU+lGULVaWT7t9Su3StQsoYhERERFxNedL8pzdVNMa2G2a5l7TNLOB74F+Tt6nR1h5eCVz98/l7sZ3F1qCB3Bl1Ssp6VdSc+Y5iWmavLH6DRYdWsRTrZ7izY5vXnaCB+Dr7cuQhkP4+pqvyXZkc/u824mKjyqAiEVERETE3Tg7yasMHDrjeWz+a/90g2EY0YZh/GgYRpWzbcgwjHsNw4g0DCMyISHBGbG6jMzcTF5f/TrVS1bnrsZ3Feq+/b396V2zNwsPLuRk5slC3XdRMG7zOH7a9RP3NL6H2xrcVuBdcBuFNuLbXt8SEhDCvb/fy/wD8wt0+yIiIiLi+lxh0NUsoLppmk2A+cCksy1kmuYY0zQjTNOMKFu2bKEGWNjGRI8hNi2WF9u+iJ+3X6Hv//o615PjyOHXfb8W+r492aw9sxi9YTS9a/bmoeYPOW0/lQMr880131A/pD6P//E43237zmn7EhERERHX4+wk7zBwZstcGH8VWAHANM1E0zSz8p+OA1o6OSaXtufkHr7a+hV9avahdcXWtsRQt0xdGoY05KddP11SyVb5t7Vxa3lp5Uu0rtCa19q/5vQiOqUCSjH2qrF0qdKFt9e+zciokTqWIiIiIkWEs5O8dUAdwzBqGIbhB9wMzDxzAcMwKp7xtC+wzckxuaw8Rx4vrXiJEr4leDzicVtjub7O9ew6sYutiVttjcMT7D6xm0cWP0K1oGp8dMVH+Hr7/vdKBaCYTzE+6voRA8IHMH7LeJ5f/jw5eTmFsm8RERERsY9TkzzTNHOB4cBvWMnbNNM0txqG8ZphGH3zFxthGMZWwzA2ASOAoc6MyZVNiplE9PFonmv9HCHFQmyN5Zoa1xDgHaACLJcpISOBYQuHEeATwOfdPy/0Sct9vHx4se2LPNT8IWbtncXwRcNJz0kv1BhEREREpHA5fZ48Z/DEKRR2n9jNwNkD6RTWiY+6fuQSEzg+v/x5Fh5cyKIBiyjuW9zucNxORk4GQ+cNZX/Kfib1nET9kPq2xvPL7l94ZeUrhJcO56ueX1HCt4St8YiIiIjIpbNzCgW5ABk5GTy+5HEC/QJ5oe0LLpHgAfSv3Z/0nHRVaLwEuY5cHl/yODtP7OSDLh/YnuABXFf7OkZdMYqdJ3by3LLncJgOu0MSERERESfwsTuAos40TV5Z+Qr7U/YztsfYApkzraC0LN+SaiWrMX3XdPrV1vSGF+r0XHjLDy/npXYv0Smsk90h/alLlS48HvE47657lwlbJnB347vtDkmcJNeRy/FTx0nNTiU9J530nHTSctLIceRQrlg5KgZWpELxCoU2RlREREQKj5I8m32/43vm7p/LiOYjbKumeS6GYVitP+tHsS95HzWCa9gdkluYtHXSn3PhDQgfYHc4/3Jr/VuJTojmkw2f0LJ8S5qXa253SFJAsvKyWHRwETP2zGB9/HpO5Z467/IGBmWLlSW8TDjdqnaja5WuLnWhSURERC6NxuTZKDohmiHzhtChUgdGXzkaL8P1es8mZCRw1Y9XcXO9m3m69dN2h+PyVh5ZyQMLHqBb1W580OUDl+l6+09p2WncNPsmchw5/ND7B0oFlLI7JLkMO5J28MPOH5izbw6p2alULFGRrlW6UrtUbUr6lyTQN5BA30CK+xbHx8uHYxnHiEuLIy49jiNpR4iKjyI2LRaA6iWrE146nNqlatO0bFNaVWil1j4REREXdL4xeUrybBKXFsfgOYPx9/Znau+pBPsH2x3SOT299GmWxC5hwY0LCPQLtDscl3U47TADZw+kbLGyTO412eWL1WxN3Mptc2778yKDqyakcm5H0o7w3rr3WHBwAf7e/nSr2o3+dfrTukLri7poZJomO0/sZMWRFWw4toE9J/cQmxqLiUmQXxBdw7rSrWo32lduTzGfYk78iURERORCnS/JU3dNG6RkpzBs4TCycrMY22OsSyd4ALc3uJ05++Ywfdd0bm94u93huCTTNHl55cvkOfIYdcUol0/wABqGNOTxiMd5Z+07fBPzjY6tG3GYDn7Y8QMfRn2IicmwpsMYXH/wJX+WGIZB3TJ1qVum7p+vnco9xdq4tSw4uIDFhxYza+8sArwD6BzWmVvq30Lzcs11YaAIyMzNZO3RtSw5tITdJ3eTkZtBek46mbmZAJiY5DnyKBVQioolKlKhRAUqlKhA/TL1aVq2KaUDStv8E4iIFE1K8gpZTl4Ojy1+jP0p+/mi+xfULl3b7pD+U8PQhrQo14Lvtn/H4PqD8fHSn80/zdwzkzVxa3ix7YtULVnV7nAu2OB6g1kbt5aP1n9E83LNaVy2sd0hyX/Yl7yPV1a+wvpj62lXsR0vt3+ZyoGVC3w/xXyK0aVKF7pU6UKuI5eo+CgWHFjA3P1z+f3A7zQObcydje6kW9VuSvY8TGp2KvP2z2PJoSWsiVtDZl4mxXyKUb9MfcoXL09x3+IU8ymGgXXcvQ1vkjKTOJp+lJ0ndnL81PE/t1UzuCY9a/Skd83eVAmqYtePJCJS5Ki7ZiEyTZMXVrzAzD0zebPjm/St1fe/V3IRCw8s5JE/HuGDLh9wVfWr7A7HpSRlJtH3l77UDK7JxJ4TXXJs5fkkZyVz06ybAPi+9/e68u7Cft37Ky+teAl/H3+eavUU/Wr1K/QEKyMng5l7ZvJNzDccTD1I/TL1ebTlo7Sr1K5Q45CCdyTtCN9u+5bpu6aTnpNO5cDKdAnrQpewLkRUiMDP2++CtnMq9xQxiTFsPLaRFUdWsO7oOgBaVWjF7Q1up3NYZ7f7nBQRcUUak+ciPt/0OZ9t/IxhTYfxQLMH7A7nouQ58uj9c29Ci4XyTa9v7A7Hpby+6nWm75rOj31/pFapWnaHc0k2J2xm6LyhNCvXjC96fIGvlwptuBKH6eCzjZ/xZfSXRJSP4L0u79leBTPXkcucfXP4fOPnxKbF0qdmH55o9QRlAsrYGpdcvL3Je/l84+d/zol6dfWrub3B7TQIaVAgFxHi0uL4dd+vTN0xlaPpR6ldqjYPt3iYLmFd1AosInIZlOS5gJl7ZvL88ufpW6svb3R4wy2/2CZvm8w7a99hUs9JtCjfwu5wXMKBlAP0+6UfA8IH8Hzb5+0O57Kc/hsdVG8Qz7V5zu5wJF9mbiYvrHiB3/b/Rv/a/Xmx7YsuVe0yKy+LsdFjGb9lPIG+gTwR8QR9a/V1y8+4oiYpM4nPN37ODzt/wN/bn5vq3sQt9W+hQokKTtlfjiOH+fvn89mmzziQcoDm5ZrzWMvHaFaumVP2JyLi6ZTk2WxN3Brun38/Lcu35PPun7vUCdrFOJV7ip4/9aR+mfp80eMLu8NxCU8seYKlsUuZc/0c21tWCsK7697lm5hveK39a/Sv09/ucIq846eOM2LRCLYc38JjLR9jSMMhLps87Tm5h1dXvcqGYxtoU6ENL7V7ya3GpxYlWXlZfBvzLeM2j+NU7iluDL+RB5o+QEixkELZf44jh593/cwXm74g4VQCtze4nREtRuDv7V8o+xcRz2GaJiYmBobLfj86k5I8G+05uYfb5txG+RLlmXTNJEr6lbQ7pMsyfvN4Rq4fyZRrp9AotJHd4dhq6/Gt3PzrzdzX5D6GNx9udzgFIteRy/0L7mfTsU183/t7t+1+6gl2JO1g+P/bu+/4psr2j+Ofu+nee0ApLSB7UxAXOEDABS5UXDhwgIogIm5c4F6P4sKBihMUQQVlKaIMy94CpS0t3TtNR8b9+yOFHyKiQtuTpNf7efrKOsn51tOQXOdey+6gvLacp894mrOTzjY60j9yaAdz/pjDS+tewuqwcluP27i+y/XS/ddFOLSDhfsW8sr6V8itymVg4kAm9plIm/A2huSxWC28tO4lPtv1Ge3C2/H0GU//aYZXIUTzVGWtIqsii8zKTOdlhfMyqzKL8tpyHNqB5q/1i0JhUiZMXibnZf11by9v/Ex+hPqG0jK4Ja1CWpEYkkhiSCKtglsRHxzvtp9TUuQZpLi6mKu/v5oaWw2fnP8JLYJbGB3phJnrzAyZO4Tecb3539n/MzqOoW7+8Wb+KPmD7y/53qPWDyy0FHLZgsuI9I/k0/M/xd/b3+hIzc6a3DXctewugn2Dee3s1+gU1cnoSP9JgaWAp9c+zeLMxbQNa8uEPhMYkDigWZ5ldRUZ5Rk89OtDbCrcRKfITtyTeg8nJ5xsdCwAVuas5OFfH6a8tpw7e93JdZ2vw+RlMjqWEKKRVdRVsC5vHXvK9pBVmXWooCuuKf7TdrEBsSSFJtE6tDWR/pEopQ613B38n0Zj13Yc2oHdYceunT82hw2bw0aNvYby2nJyzDnkVOZQ56g79PomZSI+KJ6WwS1pEdziUCHYOrQ1SaFJLt1AI0WeAWrttdz0w03sLNnJ+0Pe96ip6Q9OINOcW/N+y/mNW5fcyuS+k7m287VGx2lwv2T/wtilY7miwxU81P8ho+M0KyuyVzBh+QSSQpN4a/BbxAbGGh3puC3PWs4L614gsyKT3rG9mdJvitsVrO7OoR18suMTXln/Cr4mXyalTmJ4u+EuN7tlaU0pj696nCVZS+gT14enTn+qUZYGEUIYp7SmlK1FW0nLT2NN7hp2lOzAoR0ARAdEkxSSdKiwah3amqSQJFqFtGrwtYcd2kGBpYDsymyyzdnsr9x/qPg7YD5AQXXBn7aP8ItgdNfR3Nj1xgbN0RCkyGtiWmvuW3EfCzMWeuSSA+Y6M+d9dR7tItrx7rnvNruz8w7tYOSCkZitZuaPmP+vpxV3N8/9/hwfbv+Ql898mXNan2N0nGbhx4wfuW/FfXSI7MCbg94k3D/c6EgnzOqw8tUfXzFj0wwqaisY23MsN3S9QdbbbAL7yvfx6G+PsqFgA2e0PIOpp0516ZMGWmvm753P9LXTAXjg5Ae4sM2Fze4zxhWV15azsWAju8t2k1GeQV5VHgXVBVRZq7A5bNi1HT+TH4Hegfh7+xPkE0RCUAItg1vSMrgliSGJtAxuSUxAjNvOSyD+vTp7HTnmHPZX7mdv2V62Fm1lW/E2csw5AHgrb7rHdOfkhJPpG9+XzlGdCfIJMjj1/6u115JdmU1mReahn1NanMKQ5CFGR/sLKfKa2OsbX+fNTW8yvvd4bu52s9FxGsUnOz5h+trpvH7O6wxIHGB0nCa1YO8CHlj5AM8OeJZhKcOMjtNorHYr1yy8huzKbOZcOIeE4ASjI3m0BXsX8NCvD9Ejpgevn/M6Ib4hRkdqUOW15Tyx+gl+yPiBHjE9eLj/wzL+qpHYHDZmbZvFjI0z8Pf2Z0q/KVzQ5gK3KZZyzDk88MsDrC9Yz+DWg3mk/yMeccLDneSYc1ifv54NBRvYULCBPWV7Dj0WExBDi+AWxAbGEuwTjI+XD17Ki1p7LdW2ampsNVTUVZBblUu+Jf9QS81BIb4hxAbEEh8UT3xQPHFBccQH1l8GxRMfGN/gLTei4dkcNg6YD5BRkUFWRRYZFRmHxs7lVuX+acxcy+CWdInqQtfornSN7kqXqC5yjBuIFHlN6GABMKLdCB4/9XG3+VD9r6x2K8O/GY6fyY85F85pNuMnLFYLI74ZQaR/JJ+c/4nLdXlqaFkVWVy+4HI6Rnbk3SHvSutLI3BoB29teosZm2ZwcvzJvHr2qx774ae15vt93zN97XQq6yq5vP3l3NHzDvkC34D+KP2Dh399mO3F2xmUNIgH+z/oljP/2h12Zm2fxf82/I8IvwimnzHdZcYQeqr9Ffv5IfMHfsz4kR0lOwAI9gmmR2wPesf2pldsLzpFdvpPY9Ctdit5VXlkm7PJMedQVF1ESU0JBZYC8qryyKvK+8v4K4C4wDjaRbTjpPCTSA5NpmWIs0UwIShBPocMUlRdxObCzc6fos1sLdpKta360OMhPiEkhyWTFJp0qJtlq5BWJIcmy7/xjcjQIk8pNRR4BTABM7XWTx/xuB/wIdAHKAau0FpnHOs1XbXIW5+/npt/vJmesT15a9BbHt8lYVHGIu79+d5mNd3+i2kv8v629/lg6Af0ietjdJwmcfDEhSfNIuoqzHVmHlj5AMv3L+eithfxyCmPNItp5Mtry3l94+t8sesLgnyCGNvTOf5TvrwdP7vDzswtM3lz85uE+oby4MkPesRQgZ0lO5m8YjKZFZnc3uN2xnQb02xOKjaFouoi5u+dzw8ZP7C9eDsA3WO6c27rc+mf0J924e0a/b93nb2OfEv+oaIvryqP9PJ0dpfuJr08HavDemhbb+VNQnACLYJbEOUfRaR/JFEBUYT5hRHhF0GkfyQJQQnEBMbIvycnqKi6iF+yf2FV7io2F27+U1fLjpEd6R7TnY6RHUkOS6Z1aGsi/CI8tmHDlRlW5CmlTMAfwGAgG/gduEprvf2wbcYC3bXWtymlrgQu1lpfcazXdcUib3/FfkZ9P4pwv3A+Pu9jwvzCjI7U6LTWXP391eRb8vn24m8J8A4wOlKj2lmykyu/vZIR7UYw9dSpRsdpUg+ufJD5e+fzcP+HGdlhpNFxPEJGeQbjl48nsyKTSamTuLrT1c3uA3J36W6e+f0Z1uSuoV14Oyb3ncwpLU4xOpbbyavK46FfH2JN7hqGJQ/j/pPvJ8I/wuhYDcZitfDE6if4Nv1bTkk4helnTG+yNf081a6SXXy4/UMW7luI1WGlW3Q3hiQPYXDrwS41E7jNYSPfkk9OZQ7Z5myyK52TZByoOkBJdQklNSVYbJa/PM9LeRETEENCUAIJQQnEB8cfut4xsiPxQfEG/DauzaEdbC/ezorsFazIXsG24m2As3tuz9ie9IjpQY+YHnSM7CizbrsQI4u8U4CpWush9bfvB9BaTz9smx/qt1mllPIG8oAYfYxgrlbkVduqGblgJKW1pcw+bzatQ1sbHanJrM9fz/WLrmdcz3Hc1uM2o+M0GrvDzjXfX8OBqgPMHzG/WRTxh7Pardz9092syF7RrFpuG8uK7BVMWTEFk5eJFwa+QL+EfkZHMozWmmX7l/Hc78+RY87h7FZnM6XfFBkD+i9orZm3Zx7P/v4sdm3n/n73M6LdCI88WaC15qvdXzF97XRCfUN5dsCzpMYf9XuN+BsO7WBlzko+3PYha/LWEOAdwIh2I7i609Vu/b2lxlZDWW0Z5bXlFFUXkVeVR25VLrlVuYeu51Xl/alFMDE4kdT4VFLjUkmNT222M7ma68z8duA3VmSvYGXOSoprilEousd0Z0DiAAYmDqR9RHuP/DfFUxhZ5F0GDNVa31x/+1rgZK31HYdts7V+m+z623vrtyk64rVuAW4BSEpK6pOZmdlouY/Hpzs/5aTwk5rlh86E5RP49cCvfH/J92459uPfmL1jNk+vfdrjJ1s5llp7LXcuvZM1eWt4bsBzHtEVrKlZrBZmbJzBh9s/pENkB14+6+Vm++XiSLX2Wj7a/hFvb34bkzLxYP8HOT/lfPly8Tfyq/J5fPXjrMheQZ+4Pjxx2hO0CmlldKxGt6tkF/f8fA/7K/dzZ687uaHLDdJ98x/YHDZ+yPiBdza/w97yvcQFxjGq0yguPenSZnPC0qEdlNSUkGPOYXPhZtLy0lhXsI7y2nIAEoIS6BPX59CkIB0iO3hk7ySbw8aesj2syV3DiuwVrM9fj03bCPEN4fQWp3NG4hmc3vJ0j+oJ4Ok8osg7nKu15DV3WRVZDJ83nOHthntkN8a8qjyGzxtOr7hevHHOG836S6fFauHWxbeytXgrr539Gqe1PM3oSG5jde5qpv42lRxzDpe1v4zJfSd75JeIE7W/cj8PrnyQDQUbOL3l6UxKnUTb8LZGx3IZDu1g7u65vJj2IjaHjbv73M1VHa/y+EmgDldlreKx3x5jYcZCesT04InTniAlLMXoWC5Ha80vOb/wQtoLpJen0y68HTd3u5lzk8/Fx8uz5wz4NxzawZ6yPc6CL38dGwo2UFhdCDgXx24b3pbuMd3pFNmJ9hHtaRfe7j9NOuMKiqqL2FS46dCEKduKtx2aLKVdeDsGJA5gQOIAesT0kDGMbkq6a4pG98zaZ/hk5yfMuXAOJ0WcZHScBjV+2Xh+O/AbXw//msSQRKPjGK6iroIbF93I/sr9fHbBZ/Ll6h9UWat4Ie0FvvzjS5JDk3n0lEebZYv/f2F32Pl4x8e8tektLDYLl7W/jLE9xxLpH2l0NEPlmHN45NdHWJu3ln7x/Zh6ylRahXp+693RaK35bt93TF8znRpbDXf0uoPrOl8nrXr1dpbs5Pm051mTu4bWoa0Z33s85ySd06xOBhyPAkvBoTXdthZtZUvhFiqtlYceTw5Npldsr0PFX7uIdoZNlqW1ptZei9lqZn/lfjIrMskxOxfzzq3KZX/lfvKq8gDw9vKmU2Qnusd0p3t0d3rF9pIu8R7CyCLPG+fEK+cAOTgnXhmltd522DbjgG6HTbxyidb6mDM7SJHnespryxn21TC6x3TnzUFvGh2nwSzPWs5dy+/i7t53c1O3m4yO4zLyqvIYuWDkoaUkPHXK/xO1tWgr9624j/2V+7m+i3PsqgxY//dKa0p5Y9MbfLHrCwK8A7i5281c1fGqZvf3prXm6z1f88zaZ1BKMSl1EpeedGmz7lVwUFF1EU+seoJl+5fRLbobT5z2RLNt+dVasy5/He9tfY9fcn4h3C+c23rcxsgOI6Xl7jhprTlQdYDdpbv5o/QPthRuYX3BeirqKoD/b/HrFduLPnF96B3bm9jA2ON+b1qsFrIqsyiwFFBcXUxRdRHFNfWX1cWU1pRitpqx2CxYrBbs2v6n5ysUsYGxtAhuQUJQAp2jOtMjpgedojo1i5mbmyOjl1A4D3gZ5xIK72mtn1JKPQ6kaa3nK6X8gY+AXkAJcKXWOv1YrylFnmuatW0Wz6c9z1uD3uLUlqcaHeeEWawWhn8znGCfYL648Av5kDzCqgOruHXxrQxNGcozZzwjXzgPk1eVx8wtM5n7x1yiA6OZfvp0ab07Aell6byw7gVWZK8g3C+c67tcz9Wdrm4W3V2zK7N5fNXjrMpdRd/4vjx52pMuNfuhK9BasyhjEdPWTKPKWsXYnmMZ3WV0s+l+drBb5swtM9lQsIEIvwhGdRrFqE6jCPUNNTqex3FoBzmVOews3cmO4h1sLdrKxsKNh7pBhvuF0za8Le3C25ESlkJUQBQmZcJqt2LTNmwO54/VYaWstoyi6iL2V+4nozyDfEv+X/YX7BNMdEA0UQFRRPhFEOQTdOgn0CeQIJ8gWga3pHVoa1oEtfD45bvEn8li6KJJ1NnrGD5vOCG+IXx+wedu/6X/+d+fZ9b2WXw07CN6xvY0Oo5LemfzO7y64VUmpU7i+i7XGx3HcGU1Zby+8XXm7J4DwMXtLmZ87/HNZnKDxraxYCNvbX6LlTkriQuMY3zv8Zzf5nyP7IJmc9j4ePvHvL7xdZRSTOwzkZEdRnrk79pQiquLmbZmGj9m/kjnqM48cdoTtI9ob3SsRmN32FmcuZiZW2ayq3QXCUEJjO4ymotPurhZnABxJTaHjV0lu9hYuJHdpbvZW7aXvWV7/9TV82gUinC/cBJDEkkOTT605lxCUAJRAVFE+UdJ7w9xTFLkiSYzb888Hv71YV47+zUGthpodJzj5umTyTQUrTUTf5rIsv3LeGvwW/RP6G90JEPYHXbm7p7LqxtexVxn5pKTLmFMtzEy5qGRpOWl8Vzac2wv3k6nyE6M7TmWgYkD3f7E0kEbCjYwbc00dpbs5MzEM3ng5Afkb+k/+DHjR55a8xQVdRXc2v1Wbup2k0f1xNBaszhzMa9ueJXMikxSwlK4qetNnNfmPI/6Pd2d1primmLKaspw4MDbyxsf5YOPyQdvL2+8lTfBvsHNpsVZNA4p8kSTsTqsXPj1hUT4RfDJ+Z+47ZeuKb9MYWnmUhZeutBjl4VoKFXWKq7+7moKLAW8fe7bdI3uanSkJqO1Zk3eGp7//Xl2le6ib3xf7u93v8dNPuSKHNrBd+nf8camN9hfuZ/u0d25t++9bt3qnleVx8vrX+a79O+IC4zjvn73MShpkNv+O2qk0ppSpq+ZzsKMhXSI6MDkvpM9Yj3KbcXbeHbts6wvWE+78HaM6zmOs5POlhZeIZopKfJEk5r7x1ymrprKjHNmcEbiGUbH+c92l+7m0vmXMrrraCb2mWh0HLeQa87lhh9uoKK2olkUelprfsz8kfe2vsf24u20CGrBPan3MLj1YPlC3sSsDisL9i7g9Q2vU1BdwGktTuPiky7mrFZn4WvyNTrev1JSU8KnOz9l1rZZ2B12ru9yPTd3u7nZTTDTGJZmLeWZtc+QW5XLgMQBTOwz0S0nZimwFPDq+leZv3c+Ef4R3NHrDi5pd4nMJipEMydFnmhSVruV878+n4SgBGYNm2V0nP9s/LLxrM1by8JLFhLuH250HLdxsNArry3njUFvuHWLyrGkl6czbfU01uStITk0mWs7X8tFbS+ScRMGs1gtfLT9I77840vyLfmE+YVxQZsLuLjdxXSI7GB0vL9waAfr8tcxb888Fu1bRJ2jjsGtBzOxz0RZqqWB1dprmb1jNjM3z6TKVsXF7S5mTPcxtAxuaXS0f1Rtq2bWtlm8t/U9bA4b13S+hjHdxhDiG2J0NCGEC5AiTzS5D7d9yHNpz/Hp+Z+6VavO1qKtXPXdVYztOZbbe9xudBy3k1eVx00/3ERRdRGvn/O6R80oWW2r5p3N7/D+tvcJ8A7g7t53c+lJl8qZdBdjd9hZnbuar/d8zbKsZVgdVjpFduLCthcyNHkoMYExhubbX7mfBXsXMH/vfHLMOQT5BHFBmwsY1XEUbcLbGJrN05XWlPL25rf5fNfnaK25oO0FjOk2hqTQJKOj/YXVYeXbvd8yY9MM8qryGNx6MBP6TKBVSPNcF1EIcXRS5IkmZ64zM3jOYM5oeQbPDnzW6Dj/2q2Lb2VH8Q4WXrqQIJ8go+O4pQJLATf/eDN5VXm8NfgtesX2MjrSCam11/L17q+ZuWUm+ZZ8LmxzIRNTJ8pYTTdQXlvOd+nfMW/PPHaU7MBLedE3ri9nJZ3FwMSBTdJiZrFa2FLkXFtr9YHVrC9Yj0LRP6E/w9sN5+yks2UmxCaWV5XH+1vfZ+7uuVgdVs5LOY8x3cfQJsz4Ivtg9+O3N79NjjmHzlGdmZQ6ib7xfY2OJoRwQVLkCUM8//vzfLzjYxZestAtZob7Pe93bvzhRlkOoAEUVRdxw6IbKKwu5J3B79AtppvRkf4zh3bwzZ5veG3DaxRUF9Arthd39rpTvmy5qfTydBbuW8gPGT+wr3wfAG3D2jKg1QAGJg6kR0yPE57lrtZey4aCDewu3U1mRSbbiraxo2QHdm1HoWgf0Z6hKUO5oM0FxAfFN8SvJU5AUXURs7bN4vNdn1Njq+Hc5HMZ022MId17i6qLmPvHXObsnkNeVR5dorpwe4/bGZA4QMb5CiH+lhR5whC55lyGfTWMazpdw6S+k4yOc0xaa0YvGk12ZTbfXfKdjK9qAPlV+YxeNJryunLePfddOkV1MjrSv7arZBdPrXmKDQUb6BHTgzt73Um/+H7yZctDZFVk8XP2z/yc/TPr8tZh0zZCfUPpE9eHU1ucysDEgcc8MWV32CmwFJBenk5GRQYHzAfYXbqb9QXrqbXXAhDiE0L7yPb0ju1N77je9IjpIeOoXFRpTSkfbf+IT3Z+QpW1iv4J/RndZTSntji1Ud/zWmvS8tP4fNfnLM1cik3bOCXhFK7pfA1ntDxD/r0RQvwjKfKEYSb/PJlfcn5h8WWLCfYNNjrO3/o151duW3IbD538EFd0vMLoOB7jgPkAoxeNptpWzbtD3nX5hYmLq4t5Z8s7fLbzM0J9Q5mYOpHhbYfLly0PVllXyaoDq1iZs5K1eWvJMecAEO4XTovgFkQHRBPqG4rZaqbQUkihpZCimiIc2nHoNfxMfiSFJnFy/Mmc0uIUukV3I9wvXP5u3ExFXQVz/pjD7O2zKaguoF14O67vcj3npZzXoDO1VtZVMn/vfL7c9SV7y/cS6hvKiHYjGNlhJK1DWzfYfoQQnk+KPGGYbUXbuPK7K7k39V6u63Kd0XGOSmvNVd9dRWlNKd9e/C0+JllMtiHtr9jP6B9GU2WtYuopUxmaMtToSH9RWVfJ+1vf5+MdH1Nrr+XSky5lfO/xhPmFGR1NNCGtNRkVGazMWcm+8n0cMB+gpKaE8tpygn2DiQmMITYglpjAGOIC40gJSyElLIUo/ygp6DyI1W5lYcZCPtj2AbtLdxMTEMNVHa/ivDbnHfeMnBV1FWws2MiyrGV8v+97qm3VdI3qyhUdr2Bo8lDpPSKEOC5S5AlDXb/wevKq8vjuku9OeMxLY1iatZS7l9/N46c+zsUnXWx0HI+Ua85l0opJbC7czJmJZ3Jfv/tcYpp4rTXz9szjpXUvUVpbytDkoYztOZaUsBSjowkhDKa1ZtWBVXyw7QNW5a4CoFNkJ85KOov+Cf1pF96OYJ/goxb4+VX5rC9Yz7r8dYfGaWo0/iZ/hqUM44oOV9AluktT/0pCCA8jRZ4w1LKsZYxfPp7nBjzncq04NoeNyxdcjs1h4+vhX7tkEeoprA4rs7fPZsamGTi0g5u63cSNXW/Ez+RnSJ7y2nKm/jaVJVlL6B3bm/v63UfnqM6GZBFCuLasiiyWZS1j2f5lbCzYiMb53cnP5EeUfxRRAVH4ePlQaa2krKaMwupCAAK8A+gZ05Pecb3pE9eHrtFdZTZVIUSDkSJPGMrusHPRvIsI8wtj9nmzXapb08H1/F4+82XOaX2O0XGahbyqPF5Ie4FFGYtIDE7k/pPvZ0DigCbbv9aa5fuX8+TqJymtLeXu3ndzbedr8VJeTZZBCOG+SmpK2FSwiYyKDIqriymuKaa4upg6Rx2hvqGE+obSPqI9feL60CGyg5w8FEI0GinyhOE+3fkp09ZM46NhH9EztqfRcQBnd5qL5l1En7g+vH7O6y5VfDYHq3NXM23NNPaV72NA4gCu63wdfeP7NlqxVVRdxIK9C/hq91dkVGRwUsRJPHXaU24166cQQgghxEFS5AnDWawWBs8ZzMkJJ/PimS8aHQetNRN/msgvOb/w9fCvaRXSyuhIzZLVbuWjHR/x3tb3KK8tJz4oniGthzAsZRidozo3SOFdYCngrU1v8dWer7A5bPSO7c2l7S9lWPIwmWRHCCGEEG7rWEWe9CEQTSLQJ5DL2l/GB9s+ILsy2/BJNz7c/iFLspZwd++7pcAzkI/Jhxu73siojqNYmrWURfsWMXvnbGZtn0WrkFac2/pchiQPoWNkx/9U8GmtyTZn8/nOz/l81+fYHDYubX8pozqOok14m0b8jYQQQgghjNdoLXlKqUjgcyAZyABGaq1Lj7KdHdhSfzNLa33RP722tOS5p7yqPIbNHcaVHa/kvn73GZZjZc5Kxi0dxzlJ5/DCwBekm6aLKa8tZ1nWMhbuW8javLXYtZ34oHi6RHWhfUR7WoW0oktUF5LDkg917dRak1WZRVpeGmn5zp+8qjy8lBfnp5zP7T1vl2JeCCGEEB7FkO6aSqlngRKt9dNKqSlAhNb6L9/slVJmrfV/WiVbijz3NeWXKfy0/ycWX7aYEN+QJt//vvJ9XP3d1bQIbsGHwz4k0CewyTOIf6+0ppRlWctYnbuanSU7yazIPDSrXZBPEF2iuuClvNhbtvfQbHaR/pGkxqXSJ64PZySeIcWdEEIIITySUUXeLuBMrXWuUioB+Elr3eEo20mR14zsKN7ByG9HMrbHWG7veXuT7ruiroKrv7uairoKPj3/U1oEt2jS/YsTV2evI6sii23F29hStIXtxdtRSpEYnEifuD6kxqeSEpoirbNCCCGE8HhGFXllWuvw+usKKD14+4jtbMBGwAY8rbWe9zevdwtwC0BSUlKfzMzMRsktGt/Enyby24Hf+P6S74n0j2ySfdoddsYtG8eaA2uYOWQmfeL6NMl+hRBCCCGEaAzHKvJOaK5ypdQSpdTWo/wMP3w77awk/66abF0fbhTwslKq7dE20lq/rbVO1VqnxsTEnEhsYbA7et5Bta2amVtmNtk+X17/Mr/m/MoD/R+QAk8IIYQQQni0E5pdU2s96O8eU0rlK6USDuuuWfA3r5FTf5mulPoJ6AXsPZFcwrW1CW/D8LbD+WznZ4zqOKrRZ9pcsHcBH2z7gCs7XMnl7S9v1H0JIYQQQghhtMZZddhpPnB9/fXrgW+O3EApFaGU8qu/Hg2cBmxvxEzCRYztORYfLx8eX/U4jblW4/bi7Uz9bSp94/syud/kRtuPEEIIIYQQrqIxi7yngcFKqd3AoPrbKKVSlVIH++l1AtKUUpuA5TjH5EmR1wzEB8Uzoc8EVuWuYu7uuY2yj/Lacib+NJEI/wieH/g8Pl6y8LUQQgghhPB8jbYYuta6GDjnKPenATfXX/8N6NZYGYRrG9lhJEsyl/DM2mfoEdODkyJOarDXdmgHU36ZQr4ln1lDZzXZBC9CCCGEEEIYrTFb8oQ4Ji/lxfQzphPkE8TEnyZSUlPSYK/9xqY3WJmzkil9p9A9pnuDva4QQgghhBCuToo8YaiYwBhePPNFcqtyGbtkLBV1FSf8moszF/PmpjcZ3nY4IzuMbICUQgghhBBCuA8p8oThesf15oWBL7CrdBfXfX8d+yv3H/dr7SrZxYMrH6R7THceOeURWRRbCCGEEEI0O1LkCZcwsNVA3h78NgXVBVw6/1Le2/oeFqvlP71GVkUWty6+lRDfEF468yV8Tb6NlFYIIYQQQgjXJUWecBl94/vy1UVf0Te+Ly+te4mhc4fyxsY3yDXn/uNzNxduZvSi0Ti0g3cGv0NsYGwTJBZCCCGEEML1qMZco6yxpKam6rS0NKNjiEa0Pn89b295m19zfkWhSI1P5Zykczir1Vm0CG5xaLtCSyEfbf+Ij3Z8RFxgHK+d/RrtItoZmFwIIYQQQojGp5Rap7VOPepjUuQJV7a/cj/z985nccZi9pbvBaBNWBtiA2MpqSlhd+luAIa3G87EPs418YQQQgghhPB0UuQJj5BZkcnyrOWk5adRUlNChH8EXaO6MixlGMlhyUbHE0IIIYQQoslIkSeEEEIIIYQQHuRYRZ5MvCKEEEIIIYQQHkSKPCGEEEIIIYTwIG7ZXVMpVQhkGp3jKKKBIqNDiH8kx8n1yTFyD3Kc3IMcJ9cnx8g9yHFyD83pOLXWWscc7QG3LPJclVIq7e/6xQrXIcfJ9ckxcg9ynNyDHCfXJ8fIPchxcg9ynJyku6YQQgghhBBCeBAp8oQQQgghhBDCg0iR17DeNjqA+FfkOLk+OUbuQY6Te5Dj5PrkGLkHOU7uQY4TMiZPCCGEEEIIITyKtOQJIYQQQgghhAeRIk8IIYQQQgghPIgUeUIIIYQQQgjhQaTIE0IIIYQQQggPIkWeEEIIIYQQQngQKfKEEEIIIYQQwoNIkSeEEEIIIYQQHkSKPCGEEEIIIYTwIFLkCSGEEEIIIYQHkSJPCCGEEEIIITyIFHlCCCGEEEII4UGkyBNCCCGEEEIIDyJFnhBCCCGEEEJ4EG+jAxyP6OhonZycbHQMIYQQQgghhDDEunXrirTWMUd7zC2LvOTkZNLS0oyOIYQQQgghhBCGUEpl/t1j0l1TCCGEEEIIITyIW7bkCdBaYyssxFFejvL3xychAeUth1MIIYQQQojmTqoCN1Oz6w9KP/2EyiVLsRcVHbpf+foSeEp/wi++mJDBg1Emk4EphRBCCCGEEEaRIs9N2MvLyZ82nfL581H+/oScdSYBPXvhHRONw2KhZtcuzEuXkXP3BHzbtiX+0UcI6tfP6NhCCCGEEEI0CKvVSnZ2NjU1NUZHaVL+/v4kJibi4+Pzr5+jtNaNGKlxpKam6uY08Ur1li1kj7sDW0kJUTeMJuqmmzCFh/9lO223U7l4CQXPP481O5uoMTcTM368dOMUQgghhBBub9++fYSEhBAVFYVSyug4TUJrTXFxMZWVlaSkpPzpMaXUOq116tGeJxOvuLjK5cvJvPY6lI8PyZ99Ruw99xy1wANQJhOhQ4fQZsF8wkeOpPidmWSPuwNHbW3ThhZCCCGEEKKB1dTUNKsCD0ApRVRU1H9uvZQiz4WZf/6Z7LvG49euHclffkFA1y7/6nleAQEkPP4Y8Y8+gnnFCvbfehuOqqpGTiuEEEIIIUTjak4F3kHH8ztLkeeianbsIPvuCfi3b0/Se+/iHRn5n18j4qqraPH0dCxr15J9551oq7URkgohhBBCCCFciRR5LshWWMj+seMwhYXR6s03MIWGHvdrhQ0fTsKTT1L12ypyp07FHcdgCiGEEEII4QpMJhM9e/akS5cu9OjRgxdeeAGHwwFAWload911l8EJnWRGDhej7XZyJkzEXlZG8uyP8Y6JOeHXDL/kYqzZ2RTNmIFvcjLRY8Y0QFIhhBBCCCGal4CAADZu3AhAQUEBo0aNoqKigscee4zU1FRSU/86D4rNZsO7iSdClJY8F1PywQdY0tKIf+QR/Dt3brDXjb7zDkLPG0bhSy9jaUYzkwohhBBCCNEYYmNjefvtt3nttdfQWvPTTz9xwQUXADB16lSuvfZaTjvtNK699loyMjI444wz6N27N7179+a333479DrPPPMM3bp1o0ePHkyZMqVBsklLngup2bmTgpdfIeTccwkbMbxBX1spRfzjj1O9bRs5E+8hZd7XxzXOTwghhBBCCKPlTZtG7Y6dDfqafp06Ev/AA//pOW3atMFut1NQUPCXx7Zv387KlSsJCAjAYrGwePFi/P392b17N1dddRVpaWksXLiQb775hjVr1hAYGEhJSUmD/C7SkucitN3OgQcewBQeRvxjUxtl5iBTcDCJL7+MvayM3IcfkfF5QgghhBBCNJKLLrqIgIAAwLmQ+5gxY+jWrRuXX34527dvB2DJkiXccMMNBAYGAhDZQI0w0pLnIko/+4za7Tto+fJLeEdENNp+/Dt1Imb8eAqee46Kb78l7MILG21fQgghhBBCNIb/2uLWWNLT0zGZTMTGxrJjx44/PRYUFHTo+ksvvURcXBybNm3C4XDg7+/fqLmkJc8F2IqKKHz5FYJOPYWQIUMafX+Ro68noGdP8p58CutRmpaFEEIIIYQQx1ZYWMhtt93GHXfc8Y+98MrLy0lISMDLy4uPPvoIu90OwODBg3n//fexWCwA0l3TkxS8+BKOmhriHnq4SRZ4VCYTCdOmoWtqyJ82vdH3J4QQQgghhCeorq4+tITCoEGDOPfcc3n00Uf/8Xljx45l1qxZ9OjRg507dx5q5Rs6dCgXXXQRqamp9OzZk+eff75Bcip3HJeVmpqq0zxkhsiaXX+wb8QIIq+/nrgp9zXpvgtnzKDo1f+R9N67BJ16apPuWwghhBBCiP9ix44ddOrUyegYhjja766UWqe1/uuaDUhLnuEKX3oJr+Bgom69pcn3HXXTTfgkJZH3xJPourom378QQgghhBCi4UmRZyBLWhrmn34i6uabG3Wylb/j5edH/EMPUrdvH8WzZjX5/oUQQgghhBANT4o8AxW+/AreMTFEXnetYRmCBwwgeNA5FM14A2tenmE5hBBCCCGE+CfuONTsRB3P79wgRZ5SaqhSapdSao9S6i/LtCulJiqltiulNiulliqlWh/2mF0ptbH+Z35D5HEHlnXrsKSlETXmZrzq188wStyUKWCzUfjq/wzNIYQQQgghxN/x9/enuLi4WRV6WmuKi4v/85ILJ7xOnlLKBLwODAaygd+VUvO11tsP22wDkKq1tiilbgeeBa6of6xaa93zRHO4m6I338IUGUn45ZcbHQXfxEQirrmGkg8+IPL66/Dv0MHoSEIIIYQQQvxJYmIi2dnZFBYWGh2lSfn7+5OYmPifntMQi6H3A/ZordMBlFKfAcOBQ0We1nr5YduvBq5pgP26reqt26j65RdiJkwwvBXvoOhbb6Fs7lwKnnuepJnvGB1HCCGEEEKIP/Hx8SElJcXoGG6hIbprtgT2H3Y7u/6+v3MTsPCw2/5KqTSl1Gql1Ii/e5JS6pb67dLcvXovfustvEJCiBh1ldFRDjGFhxN9221UrVyJ+ddfjY4j/oPm1GVBCCGEEEL8s4ZoyfvXlFLXAKnAwMPubq21zlFKtQGWKaW2aK33HvlcrfXbwNvgXCevSQI3gto9e6hcvJio22/DFBJidJw/ibjmakpnz6bghRcIOuUUlJfMy+NqbCUlmJf/hGX9Omq2bceWn4+9tBRMJrwCAvBp1Qq/Nm0I7NePoNNOwzfxWOdbhBBCCCGEJ2qIIi8HaHXY7cT6+/5EKTUIeBAYqLWuPXi/1jqn/jJdKfUT0Av4S5HnKUpmfYjy8yPyuuuMjvIXXr6+RN95B7lT7qdy8RJCh5xrdCSBs6XOsno1JR/Mcray2myYwsLw796dgJ49MEVEgEPjMJup25+F5fffqfjuOwAC+vQh/LLLCDv/PJSvr8G/iRBCCCGEaArqRLt6KaW8gT+Ac3AWd78Do7TW2w7bphcwBxiqtd592P0RgEVrXauUigZWAcOPmLTlL1JTU3VaWtoJ5TaCrbSUPWeeRdhFF5HwxONGxzkqbbeTfsGFKG8TKfPmoUwmoyM1a5YNGyh4+hmqN23CFBNN+PDhhJ5/Pn4dOvxtS6vWmrp9+6hcspTyr76iLiMD7xYJRN9yC+GXXYbybtIGfCGEEEII0QiUUuu01qlHe+yE++NprW3AHcAPwA7gC631NqXU40qpi+o3ew4IBr48YqmETkCaUmoTsBx4+p8KPHdW9sWX6NpaIq513XlnlMlE9B3jqN29h4qFi4yO02zZKyo48NBDZF41CmteHvFTH6XdkiXETpqEf6dOx+xKq5TCr00bom8ZQ5uF39PqnbfxiYsnb+pj7Lv4EqrWrG3C30QIIYQQQjS1E27JM4I7tuRpq5U9gwbj17YNSe+9Z3ScY9IOB/uGj0BbrbT5doG0/DQxy/oNHJg0CWt+PpGjrydm7Fi8goJO6DW11piXLiV/+tNYc3KIuOYaYifdg9d/XHNFCCGEEEK4hkZtyRP/TuXixdjy84m49lqjo/wj5eVF9F13UpeRQfn8BUbHaVZKZs8m89prwcuL5E9mE3fvvSdc4IGzdS9k0CDafPctEdddS+nHH7Pv0suo2bGjAVILIYQQQghXIkVeEymZ9SE+rZMIHjjwnzd2ASGDBuHfuTNFM2agrVaj43g8bbOR98ST5D/xJMEDBpDy9VcE9OjR4Pvx8vcn/oEHaPXuTByVlWRcNYry+klahBBCCCGEZ5AirwnU7NhB9aZNRF59tdssS6CUIvquO7FmZ0trXiPTVisHJk+mdPZsIm+4gcTX/tfoy2sEn3YaKV9/hX+XLhy4ZxIFzz+PttsbdZ9CCCGEEKJpuEfF4eZKv/gC5edH2PDhRkf5T4IHDsSvcyeK3n4LbbMZHccjOerqyJ4wgYrvFxJ77yTi7pvcZDOaekdF0fr99wi/8gqKZ75Lzj2TcNTVNcm+hRBCCCFE45Eir5E5LBYq5i8gdOhQTGFhRsf5T5RSRN92G9bMLJlpsxFoq5Wcu8ZjXrKUuAcfJOqmm5o8g/L1JWHqVGInT6Zy0SL233ordnNVk+cQQgghhBANR4q8RlaxcCGOqirCrxhpdJTjEjJoEH4ntaPorTfRDofRcTyG1prchx7G/NNPxD/6CJEGL6sRdeMNJEyfjmXt72SNHo2tpMTQPEIIIYQQ4vhJkdfISj//At92bQno1cvoKMdFeXkRdett1O3ZS+XiJUbH8RiFL7xA+TffEH3XnURcdZXRcQAIv3gEif/7H7W7d5N1/fVS6AkhhBBCuClZAK0R1ezYQc3mzcQ9cD9KKaPjHLfQYUMp+t//KHrzTULOHezWv4srKPnoY4pnvkvEqKuIvv12o+P8ScjZZ9HqrTfZf9vtZI2+gaQP3sc7MtLoWOJvaK2xFRRSty8dW2ER9opyHOYq8FIobx+8AgPxjo3BJy4O39atG2Q5DiGEEEK4PinyGlHZl1+ifH0Ju+gio6OcEGUyEXXLLeQ++CDmn38m5MwzjY7ktsy//kr+9OkEn302cQ8+6JIFc1D//rR6Y4az0LvhRmehFxFhdCyBc6mN6o0bqVqzBsvvadRs3YrDbP53T1YK39at8e/cicC+fQns3x/f5GSX/BsUQgghxIlRWmujM/xnqampOi0tzegYx+SwWNg9YCDBZ59Fy2efNTrOCdNWK3uHDMUUE03yZ5/JF8PjUJeRwb4rrsQnNpbWn36KKdi1W1XMv/5K9u1j8W3bltazPsAUGmp0pGZJa011Whrl335H5eLF2EtKQCn8OnQgoFdP/Nq2w69NCt7x8ZhCQ/EKCQGHA22z4TCbseXnY83Lp3bvHmp37qR6y1ZseXkA+CQmEjpsKKHDhuHXqZO8r4UQQgg3opRap7VOPdpj0pLXSCp++BGH2UzESPeccOVIyseHqFvGkDf1MSyrVhF06qlGR3IrdnMV+8fdgQISZ7zu8gUeONfSS3z9NfaPHcf+28eSNPMdvAICjI7VbDgsFsrmzaPs00+p3b0HFRBA8JkDCR0ylKBT+v+r2XpNISH4JCTgPGpDAGfRaM3MpGr1aiqXLKX4vfcpfmcmvikphF8xkvCLL3a7mYCFEEII8WfSktdIMq8fjTU3l7Y/LPKYs+OOujr2DhqMb1ISrT/+yOg4bkNrzYFJ91KxcCFJ771LUP/+Rkf6Tyq+/56ceyYRPGAAia/9D+XjY3Qkj+awWCj99FOK330Pe0kJ/l26EDFqFKHnDWuUIttWWkrlj4sp//prqjduRPn7E3bhBUSOHo1f27YNvj8hhBBCNIxjteTJ7JqNwJqTg2XNGsKGX+QxBR6Al68vUTffhCUtDcvvvxsdx22UffElFd99R8xdd7pdgQcQet55xD/6KOaff+bAAw/KUhqNRFutlHz4IXsGn0vBc8/j36kTrT/5hJS5cwi/9JJGa0X1jogg4oqRJH/2KSlfzSXswgsoX/At6RdcSPbdE6jZtatR9iuEEEKIxiNFXiMonz8fgLDhI4wN0gjCL78cU1QURW++ZXQUt1Czcyf5Tz1F0KmnEnXLLUbHOW4RV15BzN13U7FgAfnTpuOOPQBcWdXqNaRffDH506bjd9JJtP7kE5LenUlg76ZdesW/c2cSnniCdsuXEXXLLVT98gv7ho9g/9hx1Ozc2aRZhBBCCHH8ZExeA9NaUz7vGwL79sU3saXRcRqcV0AAUTeMpuD5F6jevJmA7t2NjuSy7OYqcu6egCksjBbPPYvycu9zKlG33oK9rIySDz7AFBFOzLhxRkdye7aiIvKnTaPi+4X4JCaSOON1gs86y/AeAN4REcROuJuoG2+g5OOPKfnwI/ZdfAlhw4cTM/4ufBISDM0n/kxbrVgPHKAuKwtrXh72klLsJcXYyyvQdXVoqxVts6F8fFB+fnj5++EVGop3dAze0VF4R0fj07IlPi1bokwmo38dIYQQDUCKvAZWvXEjdZmZbt1q80/Cr7yK4ndmUvTGm7R6Y4bRcVxW/tPTqcvKci5BEBVldJwTppQidvK92MvKKPrfa3hHRRFx5ZVGx3JLWmsqFy4k7/EncFgsRN95B1E33YSXv7/R0f7EFBZGzLhxRF5zDcXvvEPJhx9RsXAhkdddS9SYMTLjqgHs5ipqtm+jZus2arZupWbbNuqys8Fu/9N2XoGBeIWF4eXri/L1AW8ftLUOXVuHrqnBXl6Orqv703OUjw++ya3xTU7Br2MHArp3x79rV1lCRQgh3JAUeQ2sfN43KH9/Qoaca3SURmMKDiLi+usoevV/1OzYgX+nTkZHcjnmFSsonzOXqDFjCOrXz+g4DUZ5eZHwxOPYS0vJe+xxTOERhA4dYnQst2IrLSXv0alU/vgj/t2702L6NJef4MQUFkbspElEjBpF4SuvUjzzXcq+nEPMhAmEX3aptP40Im21Ur1pE1W/raLqt9+o3rLlUEHn3SKBgC5dCBk2FN+k1vi2TsInPh5TVNQ/njDQWuOorMRWVIytsBBr9n7q9u2jNn0ftbt3U7lkCdR3y/ZJTCSge3cC+/Uj6JT++CQlGd7aLIQQ4thkds0G5KitZfcZAwgeOJCWz7n/2njHYq+oYM/Z5xB06qkkvvqK0XFcir2igvQLL8IrJJiUr77Cy9fX6EgNzlFdTdaNN1GzdSut3nnbLSeUMULVmrUcuPde7KWlRN91J1E33IDydr9zbTXbt5M/bTqWtDT8O3cm7uGHCOzVtOMHPZnDYsH8y0oqFy/G/NNPzgXvvbzw79aVoFNOIbB3b/y7dGnUHgJ2s5mabdup2bKZ6i1bqd6wAVtBAeAsLoNO7k/QKf0JOv10vCMjGy2HaFjabkfX1v7lfuXtjfLAzyohPN2xZteUIq8BVSxcSM6EibR6dybBp51mdJxGV/DyyxS/+RZtFszH76STjI7jMg7c/wDl8+eT/NmnBHTrZnScRmMvLyfzmmuwHsgl6cNZBHTpYnQkl6XtdopmvEHRG2/gm5REy5dedPsWcK01Fd9/T8Gzz2HLzyds+HBiJ92Dd0yM0dHckrZaMf+ykvJ58zCvWIGuqcEUHk7woHMIHjiQoJNPNrR7rNaaun0ZVK1ehWXVaqrWrsVRXg5KEdCjB8FnnUXwWWfid9JJ0srXhLTDga2gwDkeM+cAtqJC7EXF2IqLsRUXYS8qxl5lRluqcVRXH7XAO8TbG6+AAGdX34AAvIKDMUVF4h0ZhXdUJKb6S++EBHxatMQnPs4tT1IJ4UmkyGsiWbfeSu3OXbRbtrRZdF+ylZay55xBhJx9Ni2ff87oOC6h8qefyL7tdqJuvZXYCXcbHafRWfPzybjqKnRtHcmfzMa3dWujI7kca0EBBybegyUtjbDhw4l/5GG8goKMjtVgHFVVFL39DiXvvYfy9SV63Dgir7laWgX+pZpdf1D+9deUL1iAvbgYU2QkoUOHEnLuuQSm9nHZL9Habqdm+w7MP/+MeflyarZtA8CnZUuCzzyT4LPOIqhfX/k7aCCOujrq9u6l9o8/qNn1B3V791KXnY01O/svhZsKDMQ7KgrvqChMUVGYgoPxCgpEBQTgFRCIl78fHFGIa6sVR30h6LBUoaursVeasZeUYCspwV5UhLZa/xzKZMI7LhbfFs5Je3xTkvFNTsG3TQq+rVvj5efX2P9ZxHHSDodzQqa6OnRtrXN8rtbOvwulwMsLUM7/m0z1Ezb5u+y/R81Zoxd5SqmhwCuACZiptX76iMf9gA+BPkAxcIXWOqP+sfuBmwA7cJfW+od/2p8rFnm2wkJ2n3kWUTfeSOw9E42O02Tyn32Okg8+oO333+GbnGx0HEPZy8tJv/AiTGFhJM+d45HdNI+mNn0fmVdfjVdQEK0/mY1PbKzRkVyGZcMGcu4aj91sJv7RRwgfMcLoSI2mLjOT/OlPY/7pJ3zbtCHugQcIPt3zezQcD0d1NeXffkvZp59Rs307eHsTctaZhF18McFnnIHy8TE64n9mzS/A/NNPmJcvp2rVKnRtLV7BwQQPOIPgs84meOAAmajnX3LU1lKzbRvVGzZSs20rNX/8Qd2+jENjMZWvL74pKfgmtcKnVVL9ZSt8ExPxjonBKzCwwTNprXFUVWErLMSWm0tdTg7WAwewHrzcn40tP///n6CUs/Brk4JfSgq+KW2c19u2xRQZKa29DUTbbM4xtXl52PLzsebmYS8txV5ZgaOi8v8vzZU4KipxVFXhqKuDIwv2f8vbGy8/P+cJAz8/VIA/puAQvEJDMIWGYQoNwSs09M/Xw8KdLcFRUZjCwtx+pnFX06hFnlLKBPwBDAaygd+Bq7TW2w/bZizQXWt9m1LqSuBirfUVSqnOwKdAP6AFsARor7W2H7mfw7likVf8/gcUPPMMbb7/Dr82bYyO02RshYXsGTSY0PPPp8W0p4yOY6gD902h/NtvSf78cwK6Nq+ui9VbtpB5/Wh8W7Wi9Ucfypc5oPTzL8h78kl84uNJfO01/Du0NzpSkzD//DN506Zhzcwi+KyziLtvcrM/AXRQ3f79lH76GWVz5+IoL8evfXvCL7uM0AvO96hxbY7qaqpWraJy2TLMy3/CXlwM3t4EpqYScvbZBJ99tkcuMXQ8tNbYDhzAsnEj1Rs3Ub1xo3NNyvov4T4tWuDXsSN+7U/Cv0MH/Nq3x7d1a5dsUXFUVVGbkUHdvgzq0tOpy3BO5FOXkYGuqTm0nSksDN+2bfFr2wbfNgcv2+DTooUUAIf5UwGXl4c1L7/+Mu//LwsLweH48xO9vTGF1BdeBwuwkFDnZVAQytcP5ev7/z9+vs6T0kqB1s51cLUGhwZ0/TjOOhw11eiaWnRtDY6aWnRNNY7qGhzmSuwVldgrKnCUl2OvrPxrpoNMJkwREXhHRjq7AkdF/6kr8KHLqCi8IyJQgYFyQuAfNHaRdwowVWs9pP72/QBa6+mHbfND/TarlFLeQB4QA0w5fNvDtzvWPl2xyEsfPgLl50fKF58bHaXJ5T35FKWffUbbRYua7Qd35bLlZI8dS9TttxE7frzRcQxh/vVX9t92O4E9etBq5jsutxxAU3HU1ZH/5FOUffEFQaefTsvnn8MUHm50rCblqKuj9KOPKJrxBo66OiKvvZbo22/DFBJidLQmpx0Oqn5bRenHH2P++Wfw8iJk8GAirx5FQGqqx3+B0Q4H1Zs2YV62nMply6jbuxcAvw4dCDnnbILPOhv/rl08/r/DQY6aGmcr3WFFna2wEADl709A164E9OpJQM+eBPTogXd0tMGJT5x2OLDl5lKbnk5dejq1e9OpTd9L3d507KWlh7ZT/v74pqTg16YNvm3b4NemrbPrZ3Kyx/WMOXoBl4s1Lx9rXi62vPyjFnAqIACf+Hi84+PwiU84dOkTH4d3fDw+cXF4hYUZ+n462Op7sOCzl5VhKy7GXlyCreTgZQn24uJDl46qqqO+lvL1xRQZiSkyAu+ISEwREc7rkZGYIiIxRYQ7r0fWPxYS4pInQBpTYxd5lwFDtdY319++FjhZa33HYdtsrd8mu/72XuBkYCqwWmv9cf397wILtdZzjrKfW4BbAJKSkvpkZmaeUO6GpG02ime+i2/rJEKHDTM6TpOz5uWxZ/C5hF96CQlTpxodp8nZy8rYe+GFeEdGkfLlF816DErF99+Tc88kgs8+m8RXXm52/9haCwrIuWs81Rs3EjVmDDF3j28W43P/jq2wkIKXX6b8q68xRUYSc/d4wi+5pFn8N7GbzZR/PY/S2bOpy8jAFBVFxBUjCb/iCnzi4oyOZ5i6jAwqly3HvGwZlvXrweHAOy6O4LPOJOSccwg8+WSP+UL/j610rVo5i7mePQjo2RP/9u3dsqvuibCVltYXfs6irzY9nbq9e7EeOPD/G5lM+CYmHmr980lKwiehBT4tEvCJj2+U7qknwlFdja2gAFtBAdZ856UtP+9fF3A+CfF4x8UfUcA5L71CQz3yhIijpsY5/rO4BHtJsfOytL4YLCnFXlqKrbT+eknJ3xaF4Pzv6BUchCkoGK+QEOf14GC8goLxCgo6rBXTx9nl9OBtH1+Uj/cR41X//7pfu7YuOWGaRxR5h3PFlrzmLveRRyn/+mvaLlnc7L7A5EyeTMX3C0n54nP8O3c2Oo7hSj6eTf6TTxJ22aUkPPGER34gHc3h4+9aTJ9G6NChRkdyGdVbt5E/bRrV69fj16kTcZPvJeiUU4yO1Shq09Mp/Xg25fPm4bBYCOjRg4hrriZkyBCPKV4aiq201Dlxy9JlmH/9FW2xoAICCOzTh6D+JxN4cn/8O3dym5MCdnMVNVu3UL1pM9WbNlG9eTP2oiLA+cUzoGvX/y/qPKSVrrE4qqud6zYe1upXty+d2ozMv4wnM4WH490iAZ+EFvUtPIe39kRgCo/AKyjQOXFIQABeAQEoP79jfjZprdG1tYdmJHVOSGPBXlbm/Ckv///rZWXYi4qxFuRjKyjEUVHxl9c7soD7y6UHF3CNwVFb6/zvXnJ4IViC3WzGUWnGYTbjqDJjP3jdbMZeZcZRZXFONlNXd2iM678VNWaMS865cawiryFOs+cArQ67nVh/39G2ya7vrhmGcwKWf/Nc4QaibhlD2dy5FL/7LvEPPGB0nCZTuXQpFfMXED1unBR49SKvuRpbcRHFb7yJd2QUsRMnGB2p0ZV+8QV5TzjH3yXPnNlsxt/9WwFdu9B69sdULlxI/nPPk3XDjQT270/s3eMJ6NnT6HgnTNvtmH9eQenHH1P1228oHx9CzzuPiGuuIaBbV6PjuSzviAjCR4wgfMQIHLW1WFavxvzLSixrVlPw/AsAeIWEENi3r7M46t4N/65dMQUHG5zc2VJb+8cf1O7aRfXWrdRs3kztnr2HFpD3TU4m+LRT8e/e3dlK16FDs+vZcCK8AgLw79z5L5+r2mZztpDl5jonfDmQizX3gPP2/v1Ub9rk7AL6T1/glUL5+dXPInkEh8M5Y+m/aATxCgrCFBaGKToav5QUgvqdjHdcHN6xsfjExeId6/zxCgmRAq4Befn54RUXd0KNCtpmO1TwOerq0HVWsP3/CYQjG8FMYWHHvS+jNERLnjfOiVfOwVmg/Q6M0lpvO2ybcUC3wyZeuURrPVIp1QX4hP+feGUpcJI7Trwi4MCU+6lYtIh2SxY3izOUttJS0i+8CO/oaFK++LxZd9M8ktaavEenUvbFF8ROuY+o0aONjtQodF0dedOmUfbZ5812/N1/5aitpezzzyl68y3sJSUEn3UWMePvwr9jR6Oj/Wf28nLK5n5F6SefYM3OxjsujoirriT88ssbdaHy5sBWWEjV2rVYVq/BsnYtdQeHaCiFb9s2+Hfu7Byz1baNcwxXUlKDd3XUWmMvKqJu/37qMrOoy8ygdvceanftwpqdfWg7U3g4/j26E9C9OwHdexDQvZtbfiH0FNrhwFFZ6WzhKS3FXlaGw1LtnCjEUo2jpubQpCFHpZSz1c/fv771zx8v/wC8AgMwhYc7i7rwcEyhofK5LwzXFEsonAe8jHMJhfe01k8ppR4H0rTW85VS/sBHQC+gBLhSa51e/9wHgRsBG3C31nrhP+1PijzXVLtvH+nnnU/kjTcQd++9RsdpdDmT7qVi0SJS5nzpll9QG5u228mZMJHKH38k7oH7ibzuOqMjNShbYSHZ4++mev16osbcTMzdd7tNtzJX4KiqouSjjyh+9z0clZUEDxxI5E03Eti3r0uf8dZaU71uHWVfzqHihx/QNTUEpPYh8pprCDnnnGY3pqqp2MvKqN66jZotm6netJmaXbuw5eb+/wbe3vjExjpbUeLi8ImLxSsszDm7YHAwXsFB9S1p6tAwG11bW782nAVHlcU5EURRkXOZgKIibHl5OCyW/9+HyYRv69b4d+yAX/sO+HXsgH+HDnjHx7v036wQwnPJYuiiyeTcO5nKxYtpt/hHvGNijI7TaCoWLybnzruIvvMOYsaNMzqOy9JWKzkT76Fy8WKPatGr3ryZ7Dvvwl5RQYtpTzXLCZcair28nJKPPqZ09mzspaX4d+tG1I03OAsmFzpLbi0ooGL+fMrmzKUuIwOvoCBCzz+fiKuudMnB+M2Bo6rKOUV/+l5q0/dhzT2ALb/AuV5YQQH68ALtX/AKDMQUE413dAze0dF4x8bim5SEb+skfFu3dk7xL0W8EMKFSJEnmkxdZiZ7z7+AiCuuIP7hh4yO0yhspaWkX3Ah3nGxpHz+uXzo/wNttZIz6V4qf/iB2MmTibrxBqMjnZCyuV+RN3Uq3rGxJL7+mrTiNhBHdTXl33xD8fvvY83MwhQVRdjw4YRfdqlha4/aSkqo/PFHKr5fiOX330FrAvr0ca5tN+Rcl5vVT/yZtlqdEzFUVeEwm9E2e/04K+f3HuXnh1dgIF4BAYcuhRDCnUiRJ5pU7iOPUvb117RduNAj183LmTiRisVLnN00O3QwOo5b0FYrOZMnU7lwETETJhB1yxi3696k6+rIf+ZZSmfPJvCU/rR88UW8IyKMjuVxtN2O+ZdfKJ87l8rlP4HNhl/nToQOHkzI4MH4tm3baH87Wmtqd+3C/MsvVP2yEsu6dWC345uSQuiwYYRecAF+bVIaZd9CCCHEfyVFnmhS1rw89p47hNDzz6fF9GlGx2lQFT/8SM748cSMv4vo2283Oo5b0Tabc3Keb78l4tpribt/CupoM5u5IGtODtkTJ1KzaTORo0cTO+kemSmvCdiKiiifv4DKH3+keuNGAHxatiSwb18C+6YS0Lu3c8KN4xwL6aitpWb7dmo2O8d5Vf2+Fnuhc8p7vw4dCB44kNDzhuHXoYPbnZQQQgjh+aTIE00u/+lnKPnwQ9osmI9f27ZGx2kQtpIS0i+4EJ+EBJI/+1S6aR4H7XBQ8MyzlMyaRcjQobR45mm8/PyMjnVMlcuWc+D++8FuJ+HJJwkdOsToSM2SNb8A87KlVP22CktamnOadED5+uLbxjnDondsLKaoSLwjI1H+/s7CTCm0zYa9zLmula2kGGtmFnWZmc4Fl+s/A73j4wns3Yug088g6LTT8ImLNfLXFUIIIf6RFHmiydlKStg7aDBBZ5xB4isvGx2nQWTfPQHz0qUkz52Df3tZB+1EFL//AQXPPENgaiotX30F78hIoyP9haOujsKXXqbk/ffx79yZli+/hG9SktGxBM5ulXXp6VRv3ERt+l5q9+yhLn0ftqIidHX1MZ/rFRaGb6tW+CYnO2dK7NQR/27dpagTQgjhdhp7MXQh/sI7MpLI0aMpmjGD6m3bCOjSxehIJ6Ri0SIqFznHk0mBd+KibhiNd2wMufc/wL7LLiPx1f8R0NV1/kZqdu7kwH1TqN21i4hRo4idch9eLjTTY3OnlMKvbduj9hJwWCzYSkrRtTXOVjqtweSNKSIcU0iIdLMVQgjRLEhLnmg09spK9g4ajF/nTiS9957bjmmxFRaSfuFF+LRqRfKnn8iXxAZUvXUb2Xfdib2omLiHHyL8sssM/TvRNhvF775H4WuvYQoPI+Hxxwk56yzD8gghhBBC/J1jteS5x6wHwi2ZQkKIHjcOy6rVmJf/ZHSc46K1JvfRqTgsFlo8PV0KvAYW0LULKXPmENCnN3kPP0L2nXdiKykxJItl/Qb2XT6SwpdeImTQObSZP18KPCGEEEK4JSnyRKOKuOpKfNu0oeCZZ9B1dUbH+c/Kv56HedkyYiZO8JgJZFyNd2QkSe++S+x991H18wrSLxpO+bff0VS9DGzFxRy4/wEyR43CXlpKy1deIfGll2R5BCGEEEK4LSnyRKNSPj7ETbmPusxMSj75xOg4/4n1wAHyp00jMDWVyOuuMzqOR1NeXkTdMJrkOXPwiYvjwKRJZF17HTU7dzbaPu1lZRS8+BJ7Bp9L+bffEjVmDG2//47QIec22j6FEEIIIZqCjMkTTSJrzC1Ub9xI2x8WueRMikfSDgdZN95E9ebNtPlmHr6tWhkdqdnQdjtlc+dS+OJL2MvKCB50DtG33kpAt24N8vp1WVmUfvoZZV9+iaOqitBhQ4m+405Z5FoIIYQQbkVm1xSGi7tvMunDR1D46qskTJ1qdJx/VDr7EyyrVxP/2GNS4DUxZTIRMXIkoUOGUDLrQ0o+/piMJUsJ6NmT0IsuJHTYsP/cldJWWop52TIqFv1A1cqVYDIRMngQ0bfdjn8HmS1VCCGEEJ5FWvJEk8l7ahqls2eT/PlnDdYq0xhqdu4kY+QVBPY/mVZvveW2s4J6Cru5irIvv6T8q7nU7t4DJhP+XbsQmJqKf4cO+KakYIqIxBQchLbbcVTXYCsowLo/i+otW6nevJmarVvB4cCnRQvCLr6Y8JEjZV00IYQQQrg1WQxduAR7ZSXp51+AKTKSlC+/QPn4GB3pLxwWC/suuxx7ZQVt5s3DOyrK6Eiintaa2l27qPjhByxr1lK9ZQtYrcd8jgoMJKBLFwJS+xA6eDB+nTpJ0S6EEEIIjyDdNYVLMIWEEPfwQ+TceRcls2YRdfPNRkf6i7xp06jbt4+k996VAs/FKKXw79gR/44dAdB1ddRlZVGXlYW9tAxHlRlMJrz8/PCOi8OnRQt8k5NRJpPByYUQQgghmpYUeaJJhQ4eTPmgcyh87XVCzj0X36QkoyMdUv7dd5TPmUvUrbcSdMopRscR/0D5+uLXrh1+7doZHUUIIYQQwqXIEgqiycU//DDKZOLAAw+g7Xaj4wBQm55O3iOPEtCzJzF3jDM6jhBCCCGEEMdNijzR5Hzi4oh7+CGq09ZR/M5Mo+Ngr6wke+w4lJ8fLV960SXHCgohhBBCCPFvSZEnDBE2fDih5w2j8LXXqN682bAc2uHgwL2TqcvOJvGVl/FJSDAsixBCCCGEEA3hhIo8pVSkUmqxUmp3/eVfFq9SSvVUSq1SSm1TSm1WSl1x2GMfKKX2KaU21v/0PJE8wn0opYifOhXv2BhyJt2L3VxlSI7CV17F/NNPxN13H4F9+xqSQQghhBBCiIZ0oi15U4ClWuuTgKX1t49kAa7TWncBhgIvK6XCD3v8Xq11z/qfjSeYR7gRU2goLZ95BmtODgem3Id2OJp0/6WffUbxW28RfvllRFxzdZPuWwghhBBCiMZyokXecGBW/fVZwIgjN9Ba/6G13l1//QBQAMSc4H6Fhwjs25e4yfdiXrKUotdnNNl+K5csIe/xJwg+80ziH31U1k4TQgghhBAe40SLvDitdW799Twg7lgbK6X6Ab7A3sPufqq+G+dLSim/Yzz3FqVUmlIqrbCw8ARjC1cScd11hI0YQdHrr1M+f36j769q9Wpy7pmEf7eutHzxBZS3rCQihBBCCCE8xz8WeUqpJUqprUf5GX74dlprDehjvE4C8BFwg9b6YL+8+4GOQF8gErjv756vtX5ba52qtU6NiZGGQE+ilCL+sakEnnwyB+5/gMrlyxttX+aVv7L/1tvwTUqi1Ztv4hUY2Gj7EkIIIYQQwgj/WORprQdprbse5ecbIL++eDtYxBUc7TWUUqHAd8CDWuvVh712rnaqBd4H+jXELyXcj5efH4mvv4Z/x47k3D0B888/N/g+Kn74keyxY/FNTibpw1l4R/xlniAhhBBCCCHc3ol215wPXF9//XrgmyM3UEr5Al8DH2qt5xzx2MECUeEcz7f1BPMIN2YKDqbVzHfwa9uW/ePuoHzBggZ5Xa01xe++S8748fh37kzSB+9LgSeEEEIIITzWiRZ5TwODlVK7gUH1t1FKpSqlDq5yPRIYAIw+ylIJs5VSW4AtQDTw5AnmEW7OOyKCpA9nEdinDwfunUz+c8+hrdbjfj17WRk5d91FwXPPEzJsqBR4QgghhBDC4ynnUDr3kpqaqtPS0oyOIRqRo7aW/KefpuzTzwjo0YP4xx/Dv0OHf/18rTWVCxeS/8yz2EpKiJ0wgcjR16O8TvS8hhBCCCGEEMZTSq3TWqce7TGZVlC4JC8/PxIefZSgfv3Im/oY+y6+hPBLLyXyumvxO+mkv32ettmoXL6ckvfep3rDBvw6dSJxxusEdOnShOmFEEIIIYQwjrTkCZdnLy+naMYMSj75FKxW/Lt3J+i0U/Fr2w5TeDjaZsWWm4tlwwaqVq3CXliEd0IC0WNvJ/ySS1Amk9G/ghBCCCGEEA3qWC15UuQJt2ErKaF83jdULFxIzfbtYLf/6XFTVBSB/foSduGFBA8YIOvfCSGEEEIIjyVFnvA4jupq6vbvx2E2o7y88I6Lwzs+HudErUIIIYQQQng2GZMnPI5XQAD+7dsbHUMIIYQQQgiXI1MNCiGEEEIIIYQHkSJPCCGEEEIIITyIW47JU0oVAplG5ziKaKDI6BDiH8lxcn1yjNyDHCf3IMfJ9ckxcg9ynNxDczpOrbXWMUd7wC2LPFellEr7u8GPwnXIcXJ9cozcgxwn9yDHyfXJMXIPcpzcgxwnJ+muKYQQQgghhBAeRIo8IYQQQgghhPAgUuQ1rLeNDiD+FTlOrk+OkXuQ4+Qe5Di5PjlG7kGOk3uQ44SMyRNCCCGEEEIIjyIteUIIIYQQQgjhQaTIE0IIIYQQQggPIkVeA1BKDVVK7VJK7VFKTTE6jzg6pVSGUmqLUmqjUirN6DzCSSn1nlKqQCm19bD7IpVSi5VSu+svI4zMKP72OE1VSuXUv6c2KqXOMzJjc6eUaqWUWq6U2q6U2qaUGl9/v7yfXMgxjpO8n1yEUspfKbVWKbWp/hg9Vn9/ilJqTf33vc+VUr5GZ23OjnGcPlBK7TvsvdTT4KiGkDF5J0gpZQL+AAYD2cDvwFVa6+2GBhN/oZTKAFK11s1lgUy3oJQaAJiBD7XWXevvexYo0Vo/XX/iJEJrfZ+ROZu7vzlOUwGz1vp5I7MJJ6VUApCgtV6vlAoB1gEjgNHI+8llHOM4jUTeTy5BKaWAIK21WSnlA6wExgMTga+01p8ppd4ENmmt3zAya3N2jON0G/Ct1nqOoQENJi15J64fsEdrna61rgM+A4YbnEkIt6G1XgGUHHH3cGBW/fVZOL8ACQP9zXESLkRrnau1Xl9/vRLYAbRE3k8u5RjHSbgI7WSuv+lT/6OBs4GDhYO8lwx2jOMkkCKvIbQE9h92Oxv5x9pVaeBHpdQ6pdQtRocRxxSntc6tv54HxBkZRhzTHUqpzfXdOaUboItQSiUDvYA1yPvJZR1xnEDeTy5DKWVSSm0ECoDFwF6gTGttq99Evu+5gCOPk9b64Hvpqfr30ktKKT/jEhpHijzRnJyute4NDAPG1Xc/Ey5OO/uUy5k51/QG0BboCeQCLxiaRgCglAoG5gJ3a60rDn9M3k+u4yjHSd5PLkRrbdda9wQScfba6mhsInE0Rx4npVRX4H6cx6svEAk0y+7pUuSduByg1WG3E+vvEy5Ga51Tf1kAfI3zH23hmvLrx60cHL9SYHAecRRa6/z6D1gH8A7ynjJc/biUucBsrfVX9XfL+8nFHO04yfvJNWmty4DlwClAuFLKu/4h+b7nQg47TkPru0RrrXUt8D7N9L0kRd6J+x04qX7GJV/gSmC+wZnEEZRSQfUD3FFKBQHnAluP/SxhoPnA9fXXrwe+MTCL+BsHC4d6FyPvKUPVT0LwLrBDa/3iYQ/J+8mF/N1xkveT61BKxSilwuuvB+CcXG8HziLisvrN5L1ksL85TjsPO6mlcI6bbJbvJZldswHUT3P8MmAC3tNaP2VsInEkpVQbnK13AN7AJ3KcXINS6lPgTCAayAceBeYBXwBJQCYwUmstk34Y6G+O05k4u5ZpIAO49bCxX6KJKaVOB34BtgCO+rsfwDneS95PLuIYx+kq5P3kEpRS3XFOrGLC2SDyhdb68frvEp/h7AK4AbimvrVIGOAYx2kZEAMoYCNw22ETtDQbUuQJIYQQQgghhAeR7ppCCCGEEEII4UGkyBNCCCGEEEIIDyJFnhBCCCGEEEJ4ECnyhBBCCCGEEMKDSJEnhBBCCCGEEB5EijwhhBACUEqFK6XG1l9voZSaY3QmIYQQ4njIEgpCCCEEoJRKBr7VWnc1OosQQghxIryNDiCEEEK4iKeBtkqpjcBuoJPWuqtSajQwAggCTgKeB3yBa4Fa4DytdYlSqi3wOs5FeC3AGK31zqb+JYQQQgjprimEEEI4TQH2aq17Avce8VhX4BKgL/AUYNFa9wJWAdfVb/M2cKfWug8wCZjRFKGFEEKII0lLnhBCCPHPlmutK4FKpVQ5sKD+/i1Ad6VUMHAq8KVS6uBz/Jo+phBCCCFFnhBCCPFv1B523XHYbQfOz1IvoKy+FVAIIYQwlHTXFEIIIZwqgZDjeaLWugLYp5S6HEA59WjIcEIIIcS/JUWeEEIIAWiti4FflVJbgeeO4yWuBm5SSm0CtgHDGzKfEEII8W/JEgpCCCGEEEII4UGkJU8IIYQQQgghPIgUeUIIIYQQQgjhQaTIE0IIIYQQQggPIkWeEEIIIYQQQngQKfKEEEIIIYQQwoNIkSeEEEIIIYQQHkSKPCGEEEIIIYTwIP8HnLSvV22zCTwAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -287,7 +287,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -586,12 +586,12 @@ " rhs_condition\n", " ], optimizer_setting = opt_setting)\n", " \n", - " trainer = pl.Trainer(gpus=gpus_switch,\n", - " max_steps = steps,\n", - " logger=True, \n", - " benchmark=False,\n", - " log_every_n_steps=10,\n", - " )\n", + " trainer = pl.Trainer(devices=gpus_switch, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=steps, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", " trainer.fit(solver)" ] }, @@ -613,7 +613,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -718,7 +718,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -787,7 +787,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEQCAYAAAC9VHPBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAAReElEQVR4nO3de6ykdX3H8ffH3bqKtrALy0UWWBQSXXrRZAIxvaEgl1pdgrRFTV1bDEkrMZWYuoamIJIGaBXTQtts1WSjVbA0xk1JgwuKvaRFziKtUF33uGDZFXC5lHSLgui3f8yzdTidZc85M+cMh9/7lUzmeX6/78z5/vYk+5nneebMpKqQJLXrBZNuQJI0WQaBJDXOIJCkxhkEktQ4g0CSGrd80g3Mx2GHHVZr166ddBuStKRs27bt4apaPXN8SQbB2rVrmZqamnQbkrSkJPn2sHFPDUlS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS48YSBEnOSrI9yXSSjUPmVyS5oZu/PcnaGfPHJtmb5H3j6EeSNHsjB0GSZcB1wNnAOuCtSdbNKLsAeKyqTgCuAa6aMf8R4O9H7UWSNHfjOCI4GZiuqp1V9RRwPbB+Rs16YHO3fSNwWpIAJDkHuBe4Zwy9SJLmaBxBcDRw/8D+rm5saE1VPQ08Dhya5KXA+4EPHuiHJLkwyVSSqT179oyhbUkSTP5i8WXANVW190CFVbWpqnpV1Vu9evXCdyZJjVg+hufYDRwzsL+mGxtWsyvJcuBg4BHgFOC8JFcDhwA/SvL9qrp2DH1JkmZhHEFwB3BikuPp/4d/PvC2GTVbgA3AvwDnAV+sqgJ+cV9BksuAvYaAJC2ukYOgqp5OchFwM7AM+ERV3ZPkcmCqqrYAHwc+mWQaeJR+WEiSngPSf2G+tPR6vZqampp0G5K0pCTZVlW9meOTvlgsSZowg0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXFjCYIkZyXZnmQ6ycYh8yuS3NDN355kbTf+hiTbknytu3/9OPqRJM3eyEGQZBlwHXA2sA54a5J1M8ouAB6rqhOAa4CruvGHgTdV1c8AG4BPjtqPJGluxnFEcDIwXVU7q+op4Hpg/Yya9cDmbvtG4LQkqaqvVtV3uvF7gBcnWTGGniRJszSOIDgauH9gf1c3NrSmqp4GHgcOnVHzFuDOqnpyDD1JkmZp+aQbAEhyEv3TRWc8S82FwIUAxx577CJ1JknPf+M4ItgNHDOwv6YbG1qTZDlwMPBIt78G+Bzwjqr61v5+SFVtqqpeVfVWr149hrYlSTCeILgDODHJ8UleCJwPbJlRs4X+xWCA84AvVlUlOQS4CdhYVf88hl4kSXM0chB05/wvAm4Gvg58tqruSXJ5kjd3ZR8HDk0yDVwM7HuL6UXACcAfJrmrux0+ak+SpNlLVU26hznr9Xo1NTU16TYkaUlJsq2qejPH/ctiSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaN5YgSHJWku1JppNsHDK/IskN3fztSdYOzH2gG9+e5Mxx9CNJmr2RgyDJMuA64GxgHfDWJOtmlF0APFZVJwDXAFd1j10HnA+cBJwF/Hn3fJKkRTKOI4KTgemq2llVTwHXA+tn1KwHNnfbNwKnJUk3fn1VPVlV9wLT3fNJkhbJOILgaOD+gf1d3djQmqp6GngcOHSWjwUgyYVJppJM7dmzZwxtS5JgCV0srqpNVdWrqt7q1asn3Y4kPW+MIwh2A8cM7K/pxobWJFkOHAw8MsvHSpIW0DiC4A7gxCTHJ3kh/Yu/W2bUbAE2dNvnAV+squrGz+/eVXQ8cCLwlTH0JEmapeWjPkFVPZ3kIuBmYBnwiaq6J8nlwFRVbQE+DnwyyTTwKP2woKv7LPAfwNPAu6vqh6P2JEmavfRfmC8tvV6vpqamJt2GJC0pSbZVVW/m+JK5WCxJWhgGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS40YKgiSrkmxNsqO7X7mfug1dzY4kG7qxg5LclOQbSe5JcuUovUiS5mfUI4KNwK1VdSJwa7f/DElWAZcCpwAnA5cOBMafVNUrgdcAP5/k7BH7kSTN0ahBsB7Y3G1vBs4ZUnMmsLWqHq2qx4CtwFlV9URVfQmgqp4C7gTWjNiPJGmORg2CI6rqgW77QeCIITVHA/cP7O/qxv5PkkOAN9E/qpAkLaLlBypIcgtw5JCpSwZ3qqqS1FwbSLIc+Azwp1W181nqLgQuBDj22GPn+mMkSftxwCCoqtP3N5fkoSRHVdUDSY4CvjukbDdw6sD+GuC2gf1NwI6q+ugB+tjU1dLr9eYcOJKk4UY9NbQF2NBtbwA+P6TmZuCMJCu7i8RndGMkuQI4GPi9EfuQJM3TqEFwJfCGJDuA07t9kvSSfAygqh4FPgTc0d0ur6pHk6yhf3ppHXBnkruSvGvEfiRJc5SqpXeWpdfr1dTU1KTbkKQlJcm2qurNHPcviyWpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJatxIQZBkVZKtSXZ09yv3U7ehq9mRZMOQ+S1J7h6lF0nS/Ix6RLARuLWqTgRu7fafIckq4FLgFOBk4NLBwEhyLrB3xD4kSfM0ahCsBzZ325uBc4bUnAlsrapHq+oxYCtwFkCSlwIXA1eM2IckaZ5GDYIjquqBbvtB4IghNUcD9w/s7+rGAD4EfBh44kA/KMmFSaaSTO3Zs2eEliVJg5YfqCDJLcCRQ6YuGdypqkpSs/3BSV4NvKKq3ptk7YHqq2oTsAmg1+vN+udIkp7dAYOgqk7f31ySh5IcVVUPJDkK+O6Qst3AqQP7a4DbgNcCvST3dX0cnuS2qjoVSdKiGfXU0BZg37uANgCfH1JzM3BGkpXdReIzgJur6i+q6mVVtRb4BeCbhoAkLb5Rg+BK4A1JdgCnd/sk6SX5GEBVPUr/WsAd3e3ybkyS9ByQqqV3ur3X69XU1NSk25CkJSXJtqrqzRz3L4slqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNS1VNuoc5S7IH+Pak+5ijw4CHJ93EInPNbXDNS8dxVbV65uCSDIKlKMlUVfUm3cdics1tcM1Ln6eGJKlxBoEkNc4gWDybJt3ABLjmNrjmJc5rBJLUOI8IJKlxBoEkNc4gGKMkq5JsTbKju1+5n7oNXc2OJBuGzG9JcvfCdzy6Udac5KAkNyX5RpJ7kly5uN3PTZKzkmxPMp1k45D5FUlu6OZvT7J2YO4D3fj2JGcuauMjmO+ak7whybYkX+vuX7/ozc/DKL/jbv7YJHuTvG/Rmh6HqvI2phtwNbCx294IXDWkZhWws7tf2W2vHJg/F/g0cPek17PQawYOAl7X1bwQ+Efg7EmvaT/rXAZ8C3h51+u/Aetm1Pwu8Jfd9vnADd32uq5+BXB89zzLJr2mBV7za4CXdds/Deye9HoWcr0D8zcCfwO8b9LrmcvNI4LxWg9s7rY3A+cMqTkT2FpVj1bVY8BW4CyAJC8FLgauWPhWx2bea66qJ6rqSwBV9RRwJ7Bm4Vuel5OB6ara2fV6Pf21Dxr8t7gROC1JuvHrq+rJqroXmO6e77lu3muuqq9W1Xe68XuAFydZsShdz98ov2OSnAPcS3+9S4pBMF5HVNUD3faDwBFDao4G7h/Y39WNAXwI+DDwxIJ1OH6jrhmAJIcAbwJuXYAex+GAaxisqaqngceBQ2f52OeiUdY86C3AnVX15AL1OS7zXm/3Iu79wAcXoc+xWz7pBpaaJLcARw6ZumRwp6oqyazfm5vk1cArquq9M887TtpCrXng+ZcDnwH+tKp2zq9LPRclOQm4Cjhj0r0ssMuAa6pqb3eAsKQYBHNUVafvby7JQ0mOqqoHkhwFfHdI2W7g1IH9NcBtwGuBXpL76P9eDk9yW1WdyoQt4Jr32QTsqKqPjt7tgtkNHDOwv6YbG1azqwu3g4FHZvnY56JR1kySNcDngHdU1bcWvt2RjbLeU4DzklwNHAL8KMn3q+raBe96HCZ9keL5dAP+mGdeOL16SM0q+ucRV3a3e4FVM2rWsnQuFo+0ZvrXQ/4WeMGk13KAdS6nf5H7eH58IfGkGTXv5pkXEj/bbZ/EMy8W72RpXCweZc2HdPXnTnodi7HeGTWXscQuFk+8gefTjf650VuBHcAtA//Z9YCPDdT9Nv0LhtPAbw15nqUUBPNeM/1XXAV8Hbiru71r0mt6lrX+CvBN+u8suaQbuxx4c7f9IvrvGJkGvgK8fOCxl3SP285z9J1R41wz8AfA/wz8Xu8CDp/0ehbydzzwHEsuCPyICUlqnO8akqTGGQSS1DiDQJIaZxBIUuMMAklqnEEgzZDk1CSV5LZJ9yItBoNATUpyX/ef/dpJ9yJNmh8xIf1/XwFexdL68D9p3gwCaYaqegL4xqT7kBaLp4bUlCTv7D4h9bhu6N7uFNG+29r9XSPo5qo7rfSCJBd336z2vSS7knwkyUFd7cokH+1qn+y+me3iZ+krSc5P8oUkD3eP+c8kf+XpKy00jwjUmmn6XyxyHvAS+h94t3dgfu+wBw3xaeBX6X+K6jTwS8B7gVcleTvwr8BPAv9E/4P2fhn4cJIXVdUfDT5Rkp+g/yUo5wLfA6aAh+h/s9e7gLckOaOqpua6WGk2/KwhNan7uO/jgOOr6r4Zc6cCXwK+XAMfA969Mr+3290OvL66b+FKcgzwVfofwnc3/VNLv1lV3+/m3wj8HfDfwJHd6ad9z3sl/S81+Qfg7VW1a2DuIuDP6H8I2iur/2Uo0lh5akian/fUj7+Kkaq6H/hUt3sc8Dv7QqCbvwn4d/pHCb1940lWAe+hfyTya4Mh0D3uWuAm4BXA2QuzFLXOIJDm7gcM/0rN6e5+qqoeHjK/o7t/2cDY64AX0z/6GPalPgBf7u5fO9dGpdnwGoE0dw9W1Q+HjO+7vrBryNzg/IsGxl7e3b9xFl/zuXqW/UlzYhBIc/ejEecHLevut9O/wPxsbp/D80qzZhBIk3V/d/+1qnrnJBtRu7xGoFY91d1P+sXQLfSvOZye5JAJ96JGGQRq1e7u/lWTbKKqHgKuo/9l71uSvHJmTZKXJHlbkiMWuz+1YdKvhqRJ+RxwKvDXSb4A/Fc3/v4J9PL79N9J9OvA3UnuAnYCBawFfg5YQT+0HppAf3qeMwjUqmuBnwLeTv8vhFd041csdiNV9QPgN5J8CrgAOBn4Wfp/fPYA8Bng8/T/qEwaO/+yWJIa5zUCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklq3P8CZvjBKaHdlgEAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -802,16 +802,6 @@ "pinn_eval.plot()" ] }, - { - "cell_type": "code", - "execution_count": 21, - "id": "421dfbcc", - "metadata": {}, - "outputs": [], - "source": [ - "from scipy.signal import convolve" - ] - }, { "cell_type": "code", "execution_count": 22, @@ -819,182 +809,7 @@ "metadata": {}, "outputs": [], "source": [ - "# len(time_val)\n", - "u_val = Fval.transform(lambda x: np.convolve(x, pinn_eval, 'same'))\n", - "# convolve(pinn_eval, Fval.iloc[:, 0],\n", - "# mode=\"same\",\n", - "# # mode=\"full\",\n", - "# )" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "cb8fe4ae", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "u_val.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "c39ab52d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
012
time
0.00000NaNNaNNaN
0.03125NaNNaNNaN
0.06250NaNNaNNaN
0.09375NaNNaNNaN
0.12500NaNNaNNaN
............
17.87500NaNNaNNaN
17.90625NaNNaNNaN
17.93750NaNNaNNaN
17.96875NaNNaNNaN
18.00000NaNNaNNaN
\n", - "

577 rows × 3 columns

\n", - "
" - ], - "text/plain": [ - " 0 1 2\n", - "time \n", - "0.00000 NaN NaN NaN\n", - "0.03125 NaN NaN NaN\n", - "0.06250 NaN NaN NaN\n", - "0.09375 NaN NaN NaN\n", - "0.12500 NaN NaN NaN\n", - "... .. .. ..\n", - "17.87500 NaN NaN NaN\n", - "17.90625 NaN NaN NaN\n", - "17.93750 NaN NaN NaN\n", - "17.96875 NaN NaN NaN\n", - "18.00000 NaN NaN NaN\n", - "\n", - "[577 rows x 3 columns]" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pd.DataFrame(u_val)" + "u_val = Fval.transform(lambda x: np.convolve(x, pinn_eval, 'same'))" ] }, { @@ -1015,7 +830,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1029,56 +844,6 @@ "source": [ "rk_solu_val.plot()" ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "c4059df7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(577, 3)" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "rk_solu_val.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "9bb5cefe", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "577" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(time_val)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "84556192", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/examples/pinn/exp-function-with-param.ipynb b/examples/pinn/exp-function-with-param.ipynb index 9f4667a5..38d09ccb 100644 --- a/examples/pinn/exp-function-with-param.ipynb +++ b/examples/pinn/exp-function-with-param.ipynb @@ -125,8 +125,11 @@ "name": "stderr", "output_type": "stream", "text": [ - "GPU available: True, used: True\n", + "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "You are using a CUDA device ('GeForce RTX 3090') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [2]\n", "\n", " | Name | Type | Params\n", @@ -137,46 +140,31 @@ "921 Trainable params\n", "0 Non-trainable params\n", "921 Total params\n", - "0.004 Total estimated model params size (MB)\n" + "0.004 Total estimated model params size (MB)\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n" ] }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "76f41c1b246e40f3997c338ed620e778", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation sanity check: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 8000/8000 [01:13<00:00, 108.16it/s]" + ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " warnings.warn(*args, **kwargs)\n", - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " warnings.warn(*args, **kwargs)\n" + "`Trainer.fit` stopped: `max_steps=8000` reached.\n" ] }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a9a42b15a5674c28af89ef107a0e6c31", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 8000/8000 [01:13<00:00, 108.16it/s]\n" + ] } ], "source": [ @@ -184,30 +172,29 @@ "\n", "solver = tp.solver.Solver([pde_condition, boundary_condition], optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=8000,\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=8000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", " \n", "trainer.fit(solver)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -226,7 +213,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -241,14 +228,12 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAovUlEQVR4nO3de5zcdX3v8ddnZy/ZJJALgUA2ISQaoqEgMREULN1YMalWkqNY8ULBg0V7pDc1ClKRYj1QOW3VSk/NQWrRlggBY6rRFIGtPWIkxJAEIoGwAcxukGySXTKbvc58+sf8JszO/mZ3Znd/c9l9Px+PfWTmd/3sbye/z3yvP3N3REREslWVOgARESlPShAiIhJKCUJEREIpQYiISCglCBERCVVd6gDGyqxZs/yss84a8f6dnZ1MmTJl7AIaI4qrMIqrMIqrMOMxru3bt7e5+6mhK919XPwsW7bMR+ORRx4Z1f5RUVyFUVyFUVyFGY9xAY97jvtqpFVMZrbKzPaa2T4zuz5k/SfNbI+Z7TKzh8xsfsa6hJk9EfxsijJOEREZLLIqJjOLAXcAlwIHgG1mtsnd92RstgNY7u7HzeyPgS8D7w/Wdbn7+VHFJyIiQ4uyBHEBsM/dm929F1gPrM7cwN0fcffjwdutwNwI4xERkQKYRzTVhpldDqxy948G768ELnT363Js/3XgJXf/6+B9P/AE0A/c5u4bQ/a5FrgWYPbs2cvWr18/4njj8ThTp04d8f5RUVyFUVyFUVyFGY9xrVixYru7Lw9dmatxYrQ/wOXAnRnvrwS+nmPbD5MqQdRlLGsI/l0IPA+8ZqjzqZG6uBRXYRRXYRRXYSqxkboFmJfxfm6wbAAzeztwI3CZu/ekl7t7S/BvM9AELI0wVhGRirNxRwsX3/YwV/+4k4tve5iNOwbdYkclygSxDVhkZgvMrBa4AhjQG8nMlgLfIJUcXs5YPsPM6oLXs4CLgczGbRGRCW3jjhZueGA3Le1dALS0d3HDA7vHNElEliDcvR+4DtgC/Aq4192fMrNbzOyyYLPbganAfVndWV8PPG5mO4FHSLVBKEGIiARu37KXrr7EgGVdfQlu37J3zM4R6Uhqd98MbM5adlPG67fn2O9R4NwoYxMRqWStQckh3+UjobmYREQq0Jzp9QUtHwklCBGRCrR25WLqa2IDltXXxFi7cvGYnWPcTNYnIjKRrFnaQH8iyac37AKgYXo9a1cuZs3ShjE7hxKEiEiFunjRLACuWlLLX/3h28b8+KpiEhGpUG3HegE4uc4iOb4ShIhIhWqLp8YWT6tVghARkQyHggShEoSIiAygEoSIiIRqO9bLlNoYddVKECIikqEt3sOsk+oiO74ShIhIhTp0rIdZU5UgREQkS1u8h1lTayM7vhKEiEiFSiUIlSBERCRDXyLJ0eN9ShAiIjLQkc7UKGo1UouIyACHjqXGQJyqNggREcmUHiSnKiYRERmgLR5UMSlBiIhIphMlCLVBiIhIprZjPdTXxJhSGxt+4xFSghARqUCpaTZqMYtmHiZQghARqUht8d5I2x9ACUJEpCJFPQ8TKEGIiFSkqKfZACUIEZGK059IcuR4b6SD5EAJQkSk4hw53ot7tF1cQQlCRKTitB2LfpAcKEGIiFScYkyzAUoQIiIV59UEoTYIERHJUIxpNkAJQkSk4rTFe6mrruKkuupIz6MEISJSYdqCQXJRTrMBEScIM1tlZnvNbJ+ZXR+y/pNmtsfMdpnZQ2Y2P2PdVWb2bPBzVZRxiohUkkPxnsirlyDCBGFmMeAO4PeAJcAHzGxJ1mY7gOXufh6wAfhysO9M4AvAhcAFwBfMbEZUsYqIVJK2ePSD5CDaEsQFwD53b3b3XmA9sDpzA3d/xN2PB2+3AnOD1yuBB939iLsfBR4EVkUYq4hIxSjGPEwAUbZwNAC/znh/gFSJIJdrgB8NsW9D9g5mdi1wLcDs2bNpamoacbDxeHxU+0dFcRVGcRVGcRWmHOJKunM43kPn4ZdoajoSaVzRNoHnycw+DCwHfqeQ/dx9HbAOYPny5d7Y2DjiGJqamhjN/lFRXIVRXIVRXIUph7ja4j34lp+w7JxFNF68INK4oqxiagHmZbyfGywbwMzeDtwIXObuPYXsKyIy0RRrDAREmyC2AYvMbIGZ1QJXAJsyNzCzpcA3SCWHlzNWbQHeYWYzgsbpdwTLREQmtGLNwwQRVjG5e7+ZXUfqxh4D7nL3p8zsFuBxd98E3A5MBe4L+vO+6O6XufsRM/siqSQDcIu7H4kqVhGRSlGseZgg4jYId98MbM5adlPG67cPse9dwF3RRSciUnnSCeLUIiQIjaQWEakgh+I91MaqOLk++j5GShAiIhWk7Vgvs6bWRj7NBihBiIhUlLYiTbMBShAiIhWlLV6cUdSgBCEiUlFS02xEPw8TKEGIiFSMZNI53NmrEoSIiAzU3tVHIulKECIiMlAxp9kAJQgRkYrRdiw9ilptECIikuFQEUdRgxKEiEjFaIsXb6I+UIIQEakYbfEeamLGtPqaopxPCUJEpEK0HevhlCl1VFVFP80GKEGIiFSM1DQbxWmgBiUIEZGK0RYv3iA5UIIQEakYxZyHCZQgREQqgrsrQYiIyGAdXX30Jbxog+RACUJEpCKceNRokabZACUIEZGKcOhYcQfJgRKEiEhFODFRnxKEiIhkejVBqA1CREQytMV7iFUZMyYrQYiISIa2Y72cMqW2aNNsgBKEiEjZ27ijhe8/0cLLx3q4+LaH2bijpSjnVYIQESljG3e0cMMDu+nuTwLQ0t7FDQ/sLkqSUIIQESljt2/ZS1dfYsCyrr4Et2/ZG/m5lSBERMpYa3tXQcvHkhKEiEgZmzO9vqDlY0kJQkSkjK1duZi66oG36vqaGGtXLo783EoQIiJlbM3SBj5wwTwADGiYXs+t7zmXNUsbIj93dZQHN7NVwFeBGHCnu9+Wtf4S4CvAecAV7r4hY10C2B28fdHdL4syVhGRcjV3xmQAnrjpHUybXJznUUOECcLMYsAdwKXAAWCbmW1y9z0Zm70IXA18OuQQXe5+flTxiYhUitb2bibXxji5PtLv9INEebYLgH3u3gxgZuuB1cCJBOHuzwfrkhHGISJS0Vrbu5gzvR6z4o2ihmHaIMwsZmaPjPDYDcCvM94fCJbla5KZPW5mW81szQhjEBGpeAc7ujhj2qSin3fIEoS7J8wsaWbT3L2jWEEF5rt7i5ktBB42s93u/lzmBmZ2LXAtwOzZs2lqahrxyeLx+Kj2j4riKoziKoziKkyp4tr/8nHOPy2W89xRxZVPFVMc2G1mDwKd6YXu/qfD7NcCzMt4PzdYlhd3bwn+bTazJmAp8FzWNuuAdQDLly/3xsbGfA8/SFNTE6PZPyqKqzCKqzCKqzCliKunP8ErP/4xy163kMbGRUWNK58E8UDwU6htwCIzW0AqMVwBfDCfHc1sBnDc3XvMbBZwMfDlEcQgIlLRXuroBmDO9DKrYgJw938xs1rg7GDRXnfvy2O/fjO7DthCqpvrXe7+lJndAjzu7pvM7E3A94AZwLvN7K/c/Rzg9cA3gsbrKuC2rN5PIiITQmt7KkE0FGHkdLZhE4SZNQL/AjxPapzGPDO7yt1/Oty+7r4Z2Jy17KaM19tIVT1l7/cocO5wxxcRGe/Scy6dUY4JAvhb4B3uvhfAzM4G7gGWRRmYiIhkJIgS9GLKZ6qNmnRyAHD3Z4DiDeUTEZnAWju6OWVKLZNqYkU/dz4liO1mdifwneD9h4DHowtJRETS0oPkSiGfBPFx4BNAulvrfwH/GFlEIiJywsGOLhbMmlKScw+ZIIL5lHa6++uAvytOSCIiktba3s1Fr5lVknMP2Qbh7glgr5mdWaR4REQk8Ep3H/Ge/pJ0cYX8qphmAE+Z2WMMHEmt6bdFRCL0ahfX4vdggvwSxOcjj0JERAZJJ4iybKQO2iC+EbRBiIhIEaVHUc+ZVpoEoTYIEZEy1dreRXWVcepJdSU5v9ogRETK1MGObk6fNolYVXEfFJSmNggRkTLV0t5VsuolyGOqDXf/T1IT9dUEr7cBv4w4LhGRCe9gR1dJpvlOGzZBmNkfARuAbwSLGoCNEcYkIjLhJZLOSx3dJZnFNS2fyfo+QeqBPa8AuPuzwGlRBiUiMtG1xXvoS3jJurhCfgmix91702/MrBrw6EISEZH0GIiGcq5iAv7TzD4H1JvZpcB9wL9HG5aIyMSWHgNxRjk3UgPXA4eA3cDHSD0h7i+jDEpEZKI72FHaUdSQ3zOpk8D/C35ERKQIWtq7mFIb4+RJ+YxGiEY+JQgRESmyg+3dzJlej1lpBsmBEoSISFlq7egqaRdXyG8cxKAmdDMrzdMrREQmiNb2rpL2YIL8ShDbzOzN6Tdm9l7g0ehCEhGZ2Lr7ErTFe0s6zQbkNxfTB4G7zKwJmAOcArwtyqBERCaylzqCLq4lrmLKpxfTbjP7EvBt4BhwibsfiDwyEZEJqvVEF9fSVjENmyDM7JvAa4DzgLOBH5jZP7j7HVEHJyIyEZX6QUFp+bRB7AZWuPt+d98CXAi8MdqwREQmroPBNBunTyvzEoS7fyXrfQdwTVQBiYhMdK0dXcyaWsekmlhJ48inimkRcCuwBDiRztx9YYRxiYhMWC3t3SVvf4D8qpj+Gfi/QD+wArgb+E6UQYmITGQHS/wkubR8EkS9uz8EmLu/4O43A++KNiwRkYnJ3Wlt7+KMMihB5DMOosfMqoBnzew6oAWYGm1YIiIT0yvd/XT2Jmgo8RgIyK8E8WfAZOBPgWXAlcBV+RzczFaZ2V4z22dm14esv8TMfmlm/WZ2eda6q8zs2eAnr/OJiFS69IOCSjnNd1o+vZi2BS/jwEfyPbCZxYA7gEuBA6Sm7Njk7nsyNnsRuBr4dNa+M4EvAMtJPb1ue7Dv0XzPLyJSidLPgTijxF1cIb9eTMuBG4H5mdu7+3nD7HoBsM/dm4PjrAdWAycShLs/H6xLZu27EnjQ3Y8E6x8EVgH3DBeviEglawkGyZVDFVM+bRD/CqwlNWAu+0Y+lAbg1xnvD5AaZDfSfRuyNzKza4FrAWbPnk1TU1MB4Q0Uj8dHtX9UFFdhFFdhFFdhihHX1r29xAye3P5zqvJ8FkRUceWTIA65+6YxP/MYcPd1wDqA5cuXe2Nj44iP1dTUxGj2j4riKoziKoziKkwx4tr40g7mzDjK21asyHufqOLKJ0F8wczuBB4CetIL3f2BYfZrAeZlvJ8bLMtHC9CYtW9TnvuKiFSs1vZuziiDMRCQXy+mjwDnk2oDeHfw8/t57LcNWGRmC8ysFrgCyLcksgV4h5nNMLMZwDuCZSIi49bGHS1sf/Eoj+0/wsW3PczGHfl+p45GPiWIN7n74kIP7O79wbiJLUAMuMvdnzKzW4DH3X2Tmb0J+B4wA3i3mf2Vu5/j7kfM7IukkgzALekGaxGR8WjjjhZueGAXiaQD0NLexQ0P7AZgzdJBTbBFkU+CeNTMlmR1T82Lu28GNmctuynj9TZS1Udh+94F3FXoOUVEKtHtW/bS1TewH1BXX4Lbt+wt6wTxZuAJM9tPqg3CAM+jm6uIiOQpPUAu3+XFkE+CWBV5FCIiE9yc6fW0hCSDUo6oHraROpigb9BPMYITEZko1q5cTHXVwHEP9TUx1q4suAl4zOTTi0lERCK2ZmkDZ8+eSnWVYaRGUt/6nnNL1v4A+VUxiYhIEXT1JVl5zunc8aHyeKqzShAiImWgtz/Ji0eOs2DWlFKHcoIShIhIGXjxyHESSWfhqUoQIiKSYX9bJwALTy2f57EpQYiIlIHmQ3EAlSBERGSg5kOdzJpax8mTakodyglKECIiZaC5Lc7CMmqgBiUIEZGy0Hyos6yql0AJQkSk5DqO93G4s1cJQkREBmpuCxqoZ5VPDyZQghARKbnmQ6kurgtUghARkUzNbXGqq4wzZ04udSgDKEGIiJRY86FOzpw5mZpYed2SyysaEZEJaH9b+fVgAiUIEZGSSiY9SBDl1UANShAiIiXV0t5FT3+yrGZxTVOCEBEpoeb0JH1KECIikunVSfpUxSQiIhn2t3Vy0qRqZk2tLXUogyhBiIiUUGoOpqmYWalDGUQJQkSkhJoPld8srmlKECIiJXK8t5/Wjm4lCBERGagcHzOaSQlCRKRE0pP0leMoalCCEBEpmXQJohwHyYEShIhIyTQfitMwvZ5JNbFShxJKCUJEpESay3SSvrTqUgcgIlJsG3e0cPuWvbS2dzFnej1rVy5mzdKGosbg7jQf6uS9byzueQsRaYIws1XAV4EYcKe735a1vg64G1gGHAbe7+7Pm9lZwK+AvcGmW93941HGKiLjT1giALjhgd109SWA1GR5NzywG6CoSeLQsR7iPf1l24MJIkwQZhYD7gAuBQ4A28xsk7vvydjsGuCou7/WzK4A/gZ4f7DuOXc/P6r4RGR827ijZVAiWLthJ9VVRldfcsC2XX0Jbt+yt6gJornMG6gh2hLEBcA+d28GMLP1wGogM0GsBm4OXm8Avm7lON5cRCrO7Vv2nkgOaX0Jpy/hodu3tHfR259k8+6DRal+KvcurgDmHn6xRn1gs8uBVe7+0eD9lcCF7n5dxjZPBtscCN4/B1wITAWeAp4BXgH+0t3/K+Qc1wLXAsyePXvZ+vXrRxxvPB5n6tTyK+oprsIorsKMl7gebe3j/mf6ONztnDLJeMdZ1dzzdF/B551SDd0JyMwhtVVw9W/VctGcmjG9Xvc83cMjL/bzT5dOpmqU34tHE9eKFSu2u/vysHXl2kh9EDjT3Q+b2TJgo5md4+6vZG7k7uuAdQDLly/3xsbGEZ+wqamJ0ewfFcVVGMVVmPEQ18YdLXz7od109aXu6oe7fcjkML2+hp7+5IDSRX1NFVe+ZT7f+tkLJHxg9VNvEn74YozPfbBxTK/X3c9vY+FpXbxtxSWjPlZUf8cou7m2APMy3s8NloVuY2bVwDTgsLv3uPthAHffDjwHnB1hrCJSocKqkgBOnhSjPmt8QX1NjJsvO4db33MuDdPrMaBhej23vuc8PvfOJfQlkoOOA9Da3jXmcTcfivOaMm6ghmhLENuARWa2gFQiuAL4YNY2m4CrgJ8DlwMPu7ub2anAEXdPmNlCYBHQHGGsIlKhct28j3Un+Pv3n5+zPSGsXWHO9HpaQo43Z3r9mMW7cUcLX/7x07R2dHM43svGHS1F72Kbr8gShLv3m9l1wBZS3VzvcvenzOwW4HF33wR8E/i2me0DjpBKIgCXALeYWR+QBD7u7keiilVEKlNPf4JJNbHQEsSc6fWsWdpQ0M137crFA3o+AcSq7ET32NHK7ll1rKe/JF1s8xVpG4S7bwY2Zy27KeN1N/C+kP3uB+6PMjYRqWxHO3v52Le309WXoLrK6E++2rJcXxMb0U09fZNOlzom18bo7E1QVTU2nSvDqsNK0cU2X+XaSC0iMkjmwLeqKgN3/uEDS0kkfcy6pmaWOnr7k3zozq18dsMuFp02+vaCXNVhUbRxjAUlCBGpCNnVM4mkU1tdRSLpBVcl5au2uoo7PvRGfv9r/58P37mVZKKf9h//cMRJqBhtHGNJk/WJSEUIq57p7U9y+5a9OfYYG6edNIkPXHAmhzv7ONrtOK9Oz7FxR3bHzKGtXbmY+pqBt92RVocVgxKEiFSEUlbPbNh+YNCydNtBIdYsbeAzq1534n2qi+25Zdn+AKpiEpEKsPPX7TnXFaN6ZiyT0+knTwJg4ycu5vx500cTVuRUghCRsran9RX+8K7HmDGlhknVpameyZWERpKcdrV0UBMzXn/GSaMNK3IqQYhIWdm4o4UvNh3nyI9/yKkn1dHZ08/J9TXc+7G3sP2FoyV5jkPY+Ij6mqoRJaddB9p53eknU1ddnk+Ry6QEISJl49WeSqkxDS8f6wHgz99+NvNmTmbezMklqa9Pn/OL39/J4e5UbNe8dUHBsSSTzq4DHbz7DXPGPMYoqIpJRMpGrnmVvvXo88UPJsuapQ38beNknv7iKmZOqeXpl+IFH+OFI8c51t3PG+ZOiyDCsacEISJloxIGkk2qifHhN8/noad/Q/OhwpLErgPtAJzbMH3sA4uAEoSIlI3Tp00KXV5uA8mufPN8aqqquOtn+wvab+evO5hUU8XZs8t7Ftc0JQgRKQt9iSTT6msGLS/HgWSnnlTHmqVz2LD9AEc7e/Peb3dLO+fMmUZ1rDJuvZURpYiMa8mk85kNu3j6pWP8wfK5nDLJMp7VUJ4Dya5560K6+5L822Mv5rV9fyLJky2vcG5DZbQ/gHoxiUiJZE68N6UuRrwnwacuPZs/+d1FNM06WpZPusu0+PSTuOTsU/nWo8/z0d9eMGy31ecOddLVl+AN8yonQagEISJFl+7O2tLehQPxngSxKmPujPJqaxjOR9+6gEPHevjBzoPDbruzwhqoQQlCREogrDtrIun8n/94pkQRjcxvL5rF6SfX8dn7d7Hg+h9y8W0P55zAb9eBdk6qq2bhrClFjnLkVMUkIkVXCd1Z8/H9J1o53Nl74mFF6VleYfAT4nYf6OC3GqaN2cOHikElCBEpulOm1oYuL7furMO5fcte+hI+YFnYLK+9/Ul+dfAY51XIALk0lSBESiyzsTZzfqFcy4fapxI81drBsa4+DMi8tZZjd9bh5FsSevqlV+hNJDlv7vQiRDV2lCBEiiTspg4MmAQuXUXxi/2H+d6OFrr7kieWX3//Lrr6+qmLVXHjxqcG7ZNWzoljf1snV931GKdMreOPLlnInf+1v2xjzUe+T4jbdaADQCUIkYkuLBHsae3j2w8NTASf2bCTWJXRFSSBtK6+BPc89utBx+3uT3LDA0+GnrOrL8GN39tNf9Lp6X81qeSqDy+m7OdIT6quYv11b+G1p03lIxcvKFlcYyFslte66sGzvO460M6MyTUV10tLCUJkDGU/N7mlvYvP3L8Lkkl6B+YBehMOWfXXo9HZO3iSu1R9+NNAaUoWYc+R7k86T7Z08NrTKmO6iaGkr2H62prBWbOmDLq2uw50cN7c6ZhVTgM1KEGIjFhYSeHWH/0q9LnJhYqZkfDByaMhqLoIq9bIpaW9m0/dt5NESE+b6QVHVpiw7qw9wXOkK606KZc1SxtO/C7/9J/PcduPnmb7C0dZNn8GAF29CZ59Oc6lS2aXMswRUS8mkSFs3NHCxbc9PKiPe/ZAr5b2Lv7iu0/wm1d6Cjr+9Poa6msGjsCtr4nxgQvnhS5fu3Jx8OD7wetmTB48j1FaOjmkpXvaPNraF/r7jZXx0p01X3/4lvnMnFLLV37y6niOp1o7SCS94hqoQSUIkZzCqouuf2AXz/zmGHf//PlB34wdMIOQL/5MqYakxbKeSBbj5svOAcKrf5bPnzlktdBwDd7pc4Q9XyH9+/zzK5BuAhnrNotj3X1Ux2xQN1CovO6s+ZpcW83HLlnIrT96mu0vHGHZ/JkV20ANShAnqgla2rto2PpwRfakkNELqy4Kqx7p7kvyj03P5TyO++Cbcn1NjA+9PsaS1y/JecMP+8xlVl0Usi7s98hVJZXVPn6iZDHa/wPxnn6u/udt9Cec2pil2lsCldidtRBXvmU+637azFd+8izfvuZCdh1oZ/bJdcw+OXwq83I2oRNE2DfEcuj1UQyF9r3PXv6uMxM0DnGcShL2Ofjs/btO9AYKc8a0SRzs6B60vCHjppx5TaZ3PEvjEDf1sZIrcRRSshhp9U/mZ6EmVkVfIsk/fuiNJ9ocKvkzUojJtdV87HcW8r83p0oR6QbqSjShE0TYN8TMUZCV8qEudEAVhPe9f/yFI9y/vSWv5d96BY5v3B26PTDsQK9SybekMFRySCeBsJtu+nfM/j2bmp4d21+kANk9bYYrWUypq+bebS/y1Yf25f23y06yvYkkNTGjpz85ZGlnvPrwm+fztYee5Yp1W+lLOIfiPWzc0VJx12FCJ4hc35Ra2rtYu2HnibrTchmIVMjNHiCZTHLD954c0C/+0/el+t5n3wC7+hJ8Z+vgee1zLe9NknP7L/5gD60dXXztoWcHDPQq9TUMKylk/p3DhFUXZcZbbgkwl1w36c/c98SA7rcxM+I9/Xzm/lf/VvmUrMOSbF/Cx1VvpUL8x1O/obsveWKOpmPd/RVZOzGhE0SuUZBA6Pwqn9+4m76kh970xvKPnpkIZk4yPj8t1bMkLBHUVVeFloI+de/O0G6S/UE/9Cgd7uzlyz/eO2h5V1+CGx7YRdIJHcwFY3fDzbekMFRyyFVdlNluUEn/2bOtWdrAnl/t4Ycvxgb8fn/9wz20xQc+JW24tomJ1ltpOLdv2Tvo/9lYte8U04ROELmqCXLVzR7ryTUQaWRVUvmUCA53+5CJIFesYclhOLn63he6fNbU2kE3mLTsUcOpZQlu/N4u+pNjkzjCSgqfvm/nkIlxqJJCJf2HLtRFc2r43AcbByz7i+8+Ebpt2M3e3Vn302ZyXdnx2ltpOOMlYUaaIMxsFfBVIAbc6e63Za2vA+4GlgGHgfe7+/PBuhuAa4AE8KfuvmWs48usJmhp7xrwjbGwgUhdOQci5aqLh7ASwS7qqgcnqKESQS5DDaiaXl9DT39y0A3xvcsaBrQpDLW8tgr+4IJ5odv/5buWFHwNO7OHGZP6vb+w6Ul6+z3veYemuYcOVhsqOQxXUphocpasDb71s/2cNKmav3vwWVrbu6irrqK7P8kb5p7M3t/ET5SuYfz3VhpKvnM0lbvIEoSZxYA7gEuBA8A2M9vk7nsyNrsGOOrurzWzK4C/Ad5vZkuAK4BzgDnAT8zsbHcv7C6Zh/Q3xKampgGPOAwrWUyqqeLo8b7Q44QNRPr8959kz8EO7v75CwOqpT57/y6qYxaSCJKh37CHkutmP1S/+JH0vc9e/q4zE3xuzblD9tUv9BqG6ejqH7QsPe9QX9JPjFJuae/ik/c+QW0VdA/xKZmoJYVC5Jpf6MyZ9dz873sGzMLa3Z9qjL76ogWYmZJsYKhODJUkyhLEBcA+d28GMLP1wGogM0GsBm4OXm8Avm6pyUpWA+vdvQfYb2b7guP9PMJ4T8jVAAmFdRc81t3Pup/uH7S8pz9Jz+D73pByJYKhbvZpY9H3Pnt5U1PTsNuHnRvGJnGEzTuU9NSNa3p9De1dg4+lkkJ+cv3tVp8/h2V//ROOdA6sPuxLpJ4E97Pr36ZrGai0Tgy5RJkgGoDMKSkPABfm2sbd+82sAzglWL41a9+iXtmxGIiUq6/8UEaaCEYyoCpqhVxDGJvE0ZOAv7nsnIK6oMpgua7T0c7wtqVKq1svhvHwWTMfQWNmXgc2uxxY5e4fDd5fCVzo7tdlbPNksM2B4P1zpJLIzcBWd/9OsPybwI/cfUPWOa4FrgWYPXv2svXr14843ng8ztSpI5td8tHWPr71ZO+A7oK1VXD1b9Vy/zN9HO4efI2nVKdGsYbtA5zYb0ad877FdVw0J/c8O6UwmuuVy6OtfSd+71MmGe89O/U7h13b2hjEQ/LGjDrn71dMDT1WKa9hFNdrLBQa16eajod+nk+ZZPxt4+SSxVUs4zGuFStWbHf35WHroixBtADzMt7PDZaFbXPAzKqBaaQaq/PZF3dfB6wDWL58uWe2IRQquw2iEI3AkhyDwpZk9aiB1LfZL73nXCB3ieBzYxBXlKKIq5FXf+9MYdcWwksc71sco7GxMeexSmW8/B0/Py388/z51efSOIbflsfL9SqWqOKKMkFsAxaZ2QJSN/crgA9mbbMJuIpU28LlwMPu7ma2Cfg3M/s7Uo3Ui4DHIox11Aqtix+uakheVUhV1fSO0o1YngjGS9265CeyBBG0KVwHbCHVzfUud3/KzG4BHnf3TcA3gW8HjdBHSCURgu3uJdWg3Q98IooeTMUyHuoiy1G5TWkxUejzPHFEOg7C3TcDm7OW3ZTxuht4X459vwR8Kcr4REQkNz0wSEREQilBiIhIKCUIEREJpQQhIiKhIhsoV2xmdgh4YRSHmAW0jVE4Y0lxFUZxFUZxFWY8xjXf3U8NWzFuEsRomdnjuUYTlpLiKoziKoziKsxEi0tVTCIiEkoJQkREQilBvGpdqQPIQXEVRnEVRnEVZkLFpTYIEREJpRKEiIiEUoIQEZFQ4z5BmNkqM9trZvvM7PqQ9XVm9t1g/S/M7KyMdTcEy/ea2coix/VJM9tjZrvM7CEzm5+xLmFmTwQ/m4oc19Vmdijj/B/NWHeVmT0b/FxV5Lj+PiOmZ8ysPWNdlNfrLjN7OXj4Vdh6M7OvBXHvMrM3ZqyL8noNF9eHgnh2m9mjZvaGjHXPB8ufMLPHixxXo5l1ZPy9bspYN+RnIOK41mbE9GTwmZoZrIvyes0zs0eCe8FTZvZnIdtE9xlz93H7Q2qa8eeAhUAtsBNYkrXN/wL+KXh9BfDd4PWSYPs6YEFwnFgR41oBTA5e/3E6ruB9vITX62rg6yH7zgSag39nBK9nFCuurO3/hNT08pFer+DYlwBvBJ7Msf6dwI8AA94M/CLq65VnXBelzwf8Xjqu4P3zwKwSXa9G4Aej/QyMdVxZ276b1LNrinG9zgDeGLw+CXgm5P9kZJ+x8V6CuADY5+7N7t4LrAdWZ22zGviX4PUG4HfNzILl6929x933A/uC4xUlLnd/xN2PB2+3knqqXtTyuV65rAQedPcj7n4UeBBYVaK4PgDcM0bnHpK7/5TUs0xyWQ3c7SlbgelmdgbRXq9h43L3R4PzQvE+X/lcr1xG89kc67iK+fk66O6/DF4fA34FZD+MI7LP2HhPEA3ArzPeH2DwxT2xjbv3Ax3AKXnuG2Vcma4h9Q0hbZKZPW5mW81szRjFVEhc7w2KshvMLP1o2LK4XkFV3ALg4YzFUV2vfOSKPcrrVajsz5cD/2Fm2y313Pdie4uZ7TSzH5nZOcGysrheZjaZ1E32/ozFRblelqr+Xgr8ImtVZJ+xSB8YJKNnZh8GlgO/k7F4vru3mNlC4GEz2+3uzxUppH8H7nH3HjP7GKnS19uKdO58XAFs8IFPICzl9SprZraCVIJ4a8bitwbX6zTgQTN7OviGXQy/JPX3ipvZO4GNpB45XC7eDfzM3TNLG5FfLzObSiop/bm7vzKWxx7KeC9BtADzMt7PDZaFbmNm1cA04HCe+0YZF2b2duBG4DJ370kvd/eW4N9moInUt4qixOXuhzNiuRNYlu++UcaV4Qqyiv8RXq985Io9yuuVFzM7j9TfcLW7H04vz7heLwPfY+yqVofl7q+4ezx4vRmoMbNZlMH1Cgz1+YrkeplZDank8K/u/kDIJtF9xqJoWCmXH1IlpGZSVQ7phq1zsrb5BAMbqe8NXp/DwEbqZsaukTqfuJaSapRblLV8BlAXvJ4FPMsYNdblGdcZGa//B7DVX20Q2x/ENyN4PbNYcQXbvY5Ug6EV43plnOMscje6vouBDYiPRX298ozrTFLtahdlLZ8CnJTx+lFgVRHjOj399yN1o30xuHZ5fQaiiitYP41UO8WUYl2v4He/G/jKENtE9hkbs4tbrj+kWvifIXWzvTFYdgupb+UAk4D7gv8sjwELM/a9MdhvL/B7RY7rJ8BvgCeCn03B8ouA3cF/kN3ANUWO61bgqeD8jwCvy9j3fwbXcR/wkWLGFby/Gbgta7+or9c9wEGgj1Qd7zXAx4GPB+sNuCOIezewvEjXa7i47gSOZny+Hg+WLwyu1c7g73xjkeO6LuPztZWMBBb2GShWXME2V5PquJK5X9TX662k2jh2Zfyt3lmsz5im2hARkVDjvQ1CRERGSAlCRERCKUGIiEgoJQgREQmlBCEiIqGUIEQiZGZn5ZohVKTcKUGIiEgoJQiRIjGzhWa2w8zeVOpYRPKhyfpEisDMFpOaovpqd99Z6nhE8qEEIRK9U4HvA+9x9z2lDkYkX6piEoleB6lJ59463IYi5UQlCJHo9ZKa+XaLmcXd/d9KHZBIPpQgRIrA3TvN7PdJPVAm7u6bSh2TyHA0m6uIiIRSG4SIiIRSghARkVBKECIiEkoJQkREQilBiIhIKCUIEREJpQQhIiKh/hvTjpsP/YceuwAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -288,7 +273,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.4" + "version": "3.11.7" }, "orig_nbformat": 4 }, diff --git a/examples/pinn/hard-constrains.ipynb b/examples/pinn/hard-constrains.ipynb index 31d88ac3..117bd874 100644 --- a/examples/pinn/hard-constrains.ipynb +++ b/examples/pinn/hard-constrains.ipynb @@ -206,11 +206,12 @@ "\n", "solver = tp.solver.Solver([pde_condition, dirichlet_condition, neumann_condition], optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=5000,\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=8000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", " \n", "trainer.fit(solver)" ] diff --git a/examples/pinn/heat-equation.ipynb b/examples/pinn/heat-equation.ipynb index 9a5c3e06..1460a41f 100644 --- a/examples/pinn/heat-equation.ipynb +++ b/examples/pinn/heat-equation.ipynb @@ -14,6 +14,8 @@ "metadata": {}, "outputs": [], "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n", "import torch\n", "import torchphysics as tp\n", "import math" @@ -104,7 +106,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -115,7 +117,7 @@ } ], "source": [ - "tp.utils.scatter(X*T, inner_sampler, initial_v_sampler, boundary_v_sampler)" + "fig = tp.utils.scatter(X*T, inner_sampler, initial_v_sampler, boundary_v_sampler)" ] }, { @@ -393,15 +395,12 @@ "\n", "import pytorch_lightning as pl\n", "\n", - "import os\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n", - "\n", - "trainer = pl.Trainer(gpus=0, # or None for CPU\n", - " max_steps=2000,\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " val_check_interval=400,\n", - " checkpoint_callback=False)\n", + " max_steps=2500, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "trainer.fit(solver)" ] }, @@ -439,9 +438,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.6" + "version": "3.11.7" } }, "nbformat": 4, "nbformat_minor": 2 -} \ No newline at end of file +} diff --git a/examples/pinn/heat-equation.py b/examples/pinn/heat-equation.py deleted file mode 100644 index be70a13c..00000000 --- a/examples/pinn/heat-equation.py +++ /dev/null @@ -1,179 +0,0 @@ -#!/usr/bin/env python -# coding: utf-8 - -# # PINN: Heat equation with variable diffusion -# Solving the heat equation in 2D for variable diffusion D using the PINN-concept. - -# In[1]: - - -import torch -import torchphysics as tp -import math - - -# First, we create the spaces for our problem. These define the variable names which will be used in the remaining part of this code. -# -# In this example, x is the space variable, t corresponds to the time, D is an interval of diffusions and u is the variable for the (1D-)solution. - -# In[2]: - - -X = tp.spaces.R2('x') -T = tp.spaces.R1('t') -D = tp.spaces.R1('D') - -U = tp.spaces.R1('u') - - -# As a next step, we build the domain of the problem. There are multiple options to build multi-dimensional domains - in this case, we simply create a rectangle in space and intervals in time and diffusion which will later be multiplied to obtain the cartesian product. - -# In[3]: - - -h, w = 20, 20 - - -# In[4]: - - -A_x = tp.domains.Parallelogram(X, [0, 0], [w, 0], [0, h]) -A_t = tp.domains.Interval(T, 0, 40) -A_D = tp.domains.Interval(D, 0.1, 1.0) - - -# Before we visualize the created domain, we create Sampler objects which are iterators that sample points from the domain during the optimization task. There are again various options to sample from the domains, an easy way would be to sample uniformly distributed random points. In this example, we choose an adaptive sampler to sample points in the inner of the domain. It will sample more points in points where the loss is large. -# -# The amount of sampled points is defined by their density in the 3/2-dim subset, it could be increased to achieve better training results. - -# In[5]: - - -inner_sampler = tp.samplers.AdaptiveRejectionSampler(A_x*A_t*A_D, density=1) -# initial values should be sampled on the left boundary of the time interval and for every x and D -initial_v_sampler = tp.samplers.RandomUniformSampler(A_x*A_t.boundary_left*A_D, density=1) - -boundary_v_sampler = tp.samplers.RandomUniformSampler(A_x.boundary*A_t*A_D, density=1) - - -# We visualize the domain through the points created by the samplers using matplotlib: - -# In[6]: - - -tp.utils.scatter(X*T, inner_sampler, initial_v_sampler, boundary_v_sampler) - - -# In the next step we define the NN-model we want to fit to the PDE. A normalization can improve convergence for large or small domains. - -# In[7]: - - -model = tp.models.Sequential( - tp.models.NormalizationLayer(A_x*A_t*A_D), - tp.models.FCN(input_space=X*T*D, output_space=U, hidden=(50,50,50)) -) - - -# Now, we define a condition which aims to minimze the mean squared error of the residual of the poisson equation. - -# In[8]: - - -def heat_residual(u, x, t, D): - return D*tp.utils.laplacian(u, x) - tp.utils.grad(u, t) - -pde_condition = tp.conditions.PINNCondition(module=model, - sampler=inner_sampler, - residual_fn=heat_residual, - name='pde_condition') - - -# Additionally, we add a boundary condition at the boundary of the domain: - -# In[9]: - - -def boundary_v_residual(u): - return u - -boundary_v_condition = tp.conditions.PINNCondition(module=model, - sampler=boundary_v_sampler, - residual_fn=boundary_v_residual, - name='boundary_condition') - - -# The initial condition can be defined via a data function. Again, we minimize the mean squared error over the sampled points. - -# In[10]: - - -def f(x): - return torch.sin(math.pi/w*x[:, :1])*torch.sin(math.pi/h*x[:,1:]) - -def initial_v_residual(u, f): - return u-f - -initial_v_condition = tp.conditions.PINNCondition(module=model, - sampler=initial_v_sampler, - residual_fn=initial_v_residual, - data_functions={'f': f}, - name='initial_condition') - - -# For comparison, we compute the solution via a finite difference scheme. - -# In[11]: - - -import sys -sys.path.append('..') - -from fdm_heat_equation import FDM, transform_to_points - -fdm_domain, fdm_time_domains, fdm_solution = FDM([0, w, 0, h], 2*[2e-1], [0,5], [1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0], f) -fdm_inp, fdm_out = transform_to_points(fdm_domain, fdm_time_domains, fdm_solution, [1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0], True) - - -# Comparsion to measured or computed data can be performed via a DataCondition using data supplied via a PointsDataLoader. - -# In[12]: - - -val_condition = tp.conditions.DataCondition(module=model, - dataloader=tp.utils.PointsDataLoader((fdm_inp, fdm_out), batch_size=80000), - norm='inf') - - -# Finally, we optimize the conditions using a pytorch-lightning.LightningModule Solver and running the training. In the Solver, the training and validation conditions, as well as all optimizer options can be specified. - -# In[14]: - - -solver = tp.solver.Solver([pde_condition, - boundary_v_condition, - initial_v_condition], [val_condition]) - -import pytorch_lightning as pl - -import os -os.environ["CUDA_VISIBLE_DEVICES"] = "0" - -trainer = pl.Trainer(gpus=1, # or None for CPU - max_steps=2000, - logger=False, - benchmark=True, - val_check_interval=400, - checkpoint_callback=False) -trainer.fit(solver) - - -# Finally, we plot the obtained solution: - -# In[ ]: - - -anim_sampler = tp.samplers.AnimationSampler(A_x, A_t, 100, n_points=400, data_for_other_variables={'D': 1.0}) -anim = tp.utils.animate(model, lambda u: u[:, 0], anim_sampler, ani_speed=10) -print("ready with all") - diff --git a/examples/pinn/interface-jump.ipynb b/examples/pinn/interface-jump.ipynb index 16876dc5..af74a537 100644 --- a/examples/pinn/interface-jump.ipynb +++ b/examples/pinn/interface-jump.ipynb @@ -30,12 +30,12 @@ "metadata": {}, "outputs": [], "source": [ - "import torchphysics as tp\n", - "import torch\n", - "\n", "# set GPU:\n", "import os\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"2\"" + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"2\"\n", + "\n", + "import torchphysics as tp\n", + "import torch" ] }, { @@ -269,30 +269,17 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAADgFUlEQVR4nOydeXwU9f3/X7ObZHOQO+QAwo1HCnIHQVGOkEQUeni1/FSUlopKVaISsCqgLXIoahVFaakoX1vPtlhjCOGwtCAJZ0EsNwHJRUg2GxJy7czvj81s9pjjM+fOJvP8Pr6Pmt3PzHzmYD/veR+vN8UwDAMTExMTExMTky6CJdATMDExMTExMTFRE9O4MTExMTExMelSmMaNiYmJiYmJSZfCNG5MTExMTExMuhSmcWNiYmJiYmLSpTCNGxMTExMTE5MuhWncmJiYmJiYmHQpQgI9Ab2haRrl5eWIjo4GRVGBno6JiYmJiYkJAQzDoKGhAb169YLFIuyb6XbGTXl5OdLT0wM9DRMTExMTExMZXLhwAX369BEc0+2Mm+joaACuixMTE6Pqvtva2lBUVITs7GyEhoaqum+TTszrrA/mddYH8zrrh3mt9UGr6+xwOJCenu5ex4XodsYNG4qKiYnRxLiJjIxETEyM+Q9HQ8zrrA/mddYH8zrrh3mt9UHr60ySUmImFJuYmJiYmJh0KUzjxsTExMTExKRLYRo3JiYmJiYmJl0K07gxMTExMTEx6VKYxo2JiYmJiYlJl8I0bkxMTExMTEy6FKZxY2JiYmJiYtKlMI0bExMTExMTky6FadyYmJiYmJiYdCm6nUKxXtC0Exe//w5X7HXoEReP3tf/CBaL1ZDH8NxPZEwsQAFN9fW8+9TiuOx+AIjum6adAIDj3/4HsQkJosfX417IQYt5ke6Tpp24cOwIzh85jIbLNYhJSkL60OFIzxgGi8Xq2s//vgMAXPzfd+j7o2GS5ibn3Ng5/fDdETAA+lz3I1BWi+CzqPSYvjA0g5az9aAbWmGJDoNtQCwoC0X8vXvMGTtaTtcDAMIGxiJ8UBwAoOVsPZyOVjivtMIaFQprrA2WPpGS5qjW+Xh91yMUDAMwjW2C53X1ZB2uHqwG0+pEWP8Y9JjQG5YQ6e/IdDuNK3vK4axthjUhHD3G9yLaj+/5hPWLQWuZQ/B++G4PAI5t5xFCWd33hvMeitxnUvj2RfKsNZ+2o/WM6zmyDYqFbWAcAJDdU8LrofR5NyoBNW7+9a9/YfXq1di/fz8qKirwt7/9DT/5yU8Et9m5cyfy8vLw3XffIT09Hc899xwefPBBXeZLyul9e/HNB3/Eldoa92c9EpIw5cFfY8i4Caoc4+Te3dj+/nuKj8G1H09896nlccN7uPqFNF9pEDz+jg83IGXaDBStewNMe5vg8dWar9poMS/SfZ7cuxtF773pdZ0BYO/fPkV4j2gMnTwN//vPv9DoqMegex7EFyuWISomlnhucs6Na057fcZofZ+vHq2B/cvTcNa3uj+zxoYhbsYgRAxNEv2e3UfdFydBN7V37njHBVBhFlAhFu/PWeJDgOuIpigJofkC8PvOE67zqv3kOJhW2j2m+VgtHF+fQ4+JvRE3fSDxvOwFZ3Bl10WA6fzMUXBWdD9c5wMKXvuxxIQh4joalrBahPTsicgxo0FZre7ta/5+HBgGXNl1EVYnBey4AEtkCOJ/NsTrXMXuMyl8+4oY3hNXD18SfNZ8n6MGnudI6J4KzVuN593IUAzDMOLDtOHrr7/Gf/7zH4wePRo/+9nPRI2bs2fPYujQoZg3bx5+9atfYdu2bXjyySfx1VdfIScnh+iYDocDsbGxqK+v16S3VEFBAU5/8j6Y9jbOMTPznlW8qJ7cuxub1yzn/Z70GGL78d0nAN2Py3V8KiQUg+550O86+x5freukNlrMi3SfUq4913UWm5ucc5P6PGhxn68ercHlTd/zft/jlt648q+LvN8n3nc9AAjugw+nlcGhzDpMGTAO0TekSt6eC7HzIYX0vHrcQmbg2AvOCF5Hvv2Qng+7nDWXrEN7xUGEpKYi5dnFCO01Cpc3fe++1iNK4l3GjQck55p43/XEC7vceyD2rMnBd95qPO9C14FdC6dPn65640zS9TugOTe33XYbfve73+GnP/0p0fh169ZhwIABePXVV3H99ddj/vz5uOuuu/Daa69pPFMy2HCJEDs2vkc0TugY299/T/ExSPbjyfb338X299/V/bhyj6/kOjlpJ0orS1FwpgCllaVwKrhfvqh1/+Tss729VfQaiiE0Nznn5tpG2pzUus8sDM3A/uVpwX1c2SW82Ni/PI3af5wSHCNG/dfn3GETJZCcDyn2L0/j8t9PiI67susi6HZacAzdToteR679SDkftqGibdi9ACi0V1Xh4hMLUPvpd6Lb1v7jFOo2Cx/H/uUZonuk5B6obdgA3vNW53kXuA60Eyjb4/rvsj2uvwNAUOXc7NmzB1lZWV6f5eTk4Mknn+TdpqWlBS0tLe6/HQ4HAJdl2dbG7V2Ryw//OwbA9cbLx5X6epz/7gh6X/cjWce4+L/v0OioV3wMkv140thx3fQ+Ltfx2W199+F5fLnXaeeFnVizfw0uNV1yf9YzsifyRudhUvokSXPm4vz3R1S5f56QnuvBwgI0OhzE157rOl+pr0fxv79AW1okkiKSMLzncFg78lrkXHPXNuRz8pzDLeNmoPLE/xRfz5az9Wi90gIoSHdyXun4jZGxD6fFtUi0XmlB46nLsA2IlT8RAC2n6xSfj3tuEs7LvvsCosf34v2+YU+5+1yl7EfW/YmOB3plwHn5FKyJQ9DeTgFWxn18znk0dYRfBI7jvNJMdI/UeKbUxHPe6jzvPNfhfwVA8RK0NdYBw/6Atr/eD0TFA1nLgOumKzsJQNKaHdCwlCcURYmGpa655ho89NBDWLx4sfuzgoIC3H777WhqakJERITfNkuXLsWyZcv8Pv/oo48QGaldIp+JiYmJiYmJejQ1NWHWrFlEYamg8tzIYfHixcjLy3P/7XA4kJ6ejuzsbNVzbs4fO4Kj5y7gzBf/x5tzAwA/W7REkefmixX+xpov+25qxUO5T/J6G0j3IxWxc1PjuFRIKAb+7P9xXmf2+KTHYcc7aSd+uvmnXh4br2OCQs/Invhi5hduT4UUdl7YiWd3PYuetaHI2pdCPC8SSM914i9mY9dfNhLtE+C/zsVjqlCd4HrLpeAKAyyfuBxDGntKuuZS5u5L8ZgqXEpoQ8/aMGTtS5Z0TF9aztbj8sZjkuegFk4LgyNj7Bi2Lw7J9/9ItuemYft2lOcvgjVhECLHP67yLMWJzukn6rlp2FImeT9y70/Tnj90eG4Gu6+H57W20vKqfhJnZxB5bgL5THHBzlutuXldB9oJvH0j0FABAGizhGPrsD9g2pHHEUo3A6CA6DTg0T2AgopQNvJCQlAZN6mpqaiqqvL6rKqqCjExMZxeGwCw2Wyw2Wx+n4eGhqqa6OSkGVTY0gBcANPexmvcRCcmSS6r9aTvj4YhKiaWt7qJAYPGcCe+iyzHU7uewppJa5DVL8tvnNh+fIlKSETN1RqEX+1c0HyP2xwB9L4+A6ECIQKpx2XpkZAIALhSe7nzmD7X2fPakhzHc/yhykP4oekHwTlcaLqAI3VHMDZ1rKS5O2knVu5fiWY044f4ZlwJiUFks5XzOvrOiwTScx2ZOx0Hvvqb1zUkgb3O7LP1Q3yDZ4EKKFBYtX8VCn76laRr3jn3GOI5+c7hYnwLWixJCGvlj+tHRCcIXs+QwYlo6GHjrRzqOEmvqhxfrLFhoGkGTIP8UHdYjzCg9jSaTtT4VfqIwTiduPzyClibm4HyY6Cu1IEKj3fnoPiMBsOA5ztvrLFhcDqdwBWRvAkKiJuQLljOHTchHU1fnxe8jlz7Ibo/HjAMA+ZqHVB+DFYw7uthiUjoPC+a8ksopqJDQVEUaAf/cayxNkQNThQth5Y6Z63xnLc6z7vPdTj7LVB/1m9cKN3cYdwAqD8DlJcCAybKPg8pa3ZQifiNHz8e27Zt8/ps69atGD9+fIBm5KLwaAVuXrkdv/xwv/szvudi8uxfK9IysVismPLgrzm/YzqOWpJRC5py/ffKkpWcCbFC++HaZ7+fTMWe6y95feY7Zs/1l3Co5rDs+Qsx5cGHMeXBhwXHeF5bkuN4jufz2PhCOs6TA9UHUNXkMsoZCtibUev6b56nROozQnquISFhoteQD89ni6H8v6tsqsShmsOSrnnn3MnmxDUHBoA14hbB7UIiJ0Hop46yUO5SWj56TOwt+H3cjEFI+PFgwTFiNO3/CBcefBDlTz+N87Nn49TULDiKisi23bcf7ZWVHX8xaPnvx67/4sg6YD8iyUiImzEIiT+5RnRcj4niejeWEIvodeTaD8n9YWHPqeXIx3D/ClNA2/ktotsm/Hgw4mcKHyduxkAinRcpc/alxy3C10gOnvNW53n3uQ5XqvgHe0I6TgUCatxcuXIFhw4dwqFDhwC4Sr0PHTqE8+fPA3CFlB544AH3+Hnz5uHMmTNYuHAh/ve//+Htt9/GJ598ggULFgRi+gBchs0jmw6gor7Z/dnWnlNxxRrlNS46MUm10uMh4yZgZt6zCIvzDqs1hjuxY9QlnE+9CqBz0TlQfUBwPz0S+Ev6mjr2eSS+EudTr2LHqEtoCvc2ljyPS7L48x03PDrGrXXD4nnd3NvFJ/KOITkO1/iekT1F5y1lnCe+14TvOobE9pD9jJCeKzvO9zqzhEfHYMyMn/ntx/fZ4uJS0yVJ19x37nxzEppDmmMQoiwjERo1A6B6eG9ARSM0agbaWvuj4qRdcN8RQ5OQeN/1sMaGeX1ujbUh8b7rETd9oOD3EUOT3PuwRPo7xKkwC+fnru9c1UGtx3d5fe6q9HmSyMBpv+T9jLVXHERzyTowzXXeAy2taC5Zx/2d55wi4HdeVBjHckGRl4EDQNz0ga7F29c+ENkP3/3x3Q9ztc5dBu763jWg5yM/cd2bCP+XBktkiN+5Ct1nUoT21eOW3qLPGulzxG4nZd5qPO9e9BAPtUsapwIBTSjeuXMnJk+e7Pf57Nmz8f777+PBBx/EuXPnsHPnTq9tFixYgGPHjqFPnz54/vnnJYn4qalz46QZ3Lxyu9uwsVkZrMp0YmGJFa3tDHo3V6CXrQ2rHpiIvhnqq+J+deqfeH3zUkS0WHHV5kRVQovfWzUArJy4EtMH8meqt7W34v+9eweaHfW4GuZacCNaO/cJikJ8eDxqm10eB4oBUmptnMfdkLOBOGwjV6G4paUZhYVbMCghVjWFYiftRM7nOahuqub0qFCgkBKZgsI7CyXn3JRWlmLOljn++/S5jr//+Vpk9honad++qKlQfP67Izh8pgwR8a14+syLnM+WJ573Xi2F4hP1J/HWf9bwPt+Da0Yh6+RsAADD0KDbLwJMI0BFwRLSGxTlWpCn/TID14wV15DRXaE4OhTnHpuF4489gkEvLIHVo7ITAEBRCElJweBtxYIhqsa9JTg/ezbHNxSsSUNA2WLBtNQj9s4pqH13Hcd3HdWIthgwLfVIzv814mbc7ndeRlYobj7+X1x+ZznaKyvc41mdm5jsbABAa0srvi78GjfbhpoKxQTjifdHO4HXhwKOCgAM2izhKBj+HqYf/nVnzk1ML+DJI4pzbkjX74Dm3EyaNEnQNfr+++9zbnPw4EENZ0VOydlaL4+NJwxlwQ8RvfEDgIqI3uivgdx/co8UVCa2iI4T8zYcqjmM73tUAD34RjCoba5FvC0e9hY7GIrxOy67+I9KHkU4e1dIIv1HN/h9zvWZ73YAcO2NNxHFYPmO44nVYsWizEXI25kHCpSXgcPmxuRn5stKJh6VPAopkSl+hhNDAZWJLe5rNzp1jOR9+0Jyruy4fkNHoN/QEbzfp15zHQ6fKUNLajjiyuNR18L/pp8amep170nnITandHo4VlWt77h2/jSFdioaU5QF1tB0zn1Hxfjn3XFBWSi3ISLne/eYwfEIHxzv953vto17S9BeVek3zg3DoL2yEk379iNqXCbvsMgxoxGSmor2qqrOuJNrB3DWnHAbSVE3jvMwbjq+4yA02f83g7JQiLw2AZHXJnBsIQ1LiAUxE/tI3o7r+rN/R47IQvxdk10hukuXOPOW2IU5Zmpfwd8OkvusZM4kx6AsFCKGxCNiiPhzRLpPOXMg2p/FCuSuBD55AJxuOQDIXaHIsJFKUOXcGI3qBm7DRu44qbCLJl9iKgXKb9HhgjSP5I6Bd7j363scQP7ibxSy+mVhzaQ1SI70rr5JiUzhTcwmgTWcgOC5dsVlxfjpZpe45rI9ywQNGwC4bcBtmsxf7NpVxpxGSLSw87lHvA1pQ+JUn5saNGzfTjTON+zkC2W1IuXZDokM30Thjr9Tnl2MqMyxCElN9R/jMTYkNRWRY0YTzctoUFYrosZlIvaO2xE1LpM4IdtEBTJmAvd8AMSkeX8e08v1ecZMXadjGjcKSI4OV3WcVNRaNEnzSCb3nSx58ddS7VcLsvplYcudW7AhZwNWTlyJDTkbUHhnoWzDxnO/WhhOWlBcVoy8nXmSkqff/+59FJcVazIfoWv36uRXkTVrmOD2N98zBBYDNvtjnE44Nm8mGhvSU/zfaEx2Nnq/8TpCUrzzGkJSUtD7jdcRk51NbAQFm1HAOJ1o3FuC+n9+hca9JWCcxv6d6bJkzASePArM+tT196xPXaEonQ0bIMhKwY1G5oAEpMWGo7K+mdNlTgFIjQ1H5gDlblw+2B/+FSUr3BU5gOuHPz8zn2jR5AubsHiGnKwWKyanT8aB6gO41HQJPSN7uj/3pbismHNeizIXGWox98VqsUou9yYhq18W8bULFE7aiRUlK3gruYRYWbISk9Mna3I+QtfuP/tOCm5beaYeg0aKa+HoTdO+/XDW1QEcUhWeWOLjiT0pMdnZiJ46VTA0E5OdDbzxOqqWv+xRYeUygjzzU4IFR1GR/7n45NqY6IjFCvQbD3xX4PrfAP2+mcaNAqwWCktmZOCRTQf4ooxYMiMDVo3fGpUumlLzTUgW/6JzRXjqm6f8Pq9uqkbezjzDeSv0wvfasZ4toxg7nmXrUvCszNPCMAS4n7v2dhqHiy8Ibne4+ALG/XgQQmQkvmqJWKiJJXbmDEmeFDY0IwSJERQMOIqKcPGJJ33yjDorzdDhsTLpfpjGjUJyh6bhnftGYdmXx1B7pbNENTU2HEtmZCB3aJrA1urh+cPvpJ2SDR01PEAsReeK8My/nuH8jgEDCpSmb/nBghE9W3J0fDz5tuJbXQ20ozt/8F3X/GAY17gRWX11mRMpJKEmAIieMlX2MRink9eAITGCjAzjdKJq+ct+ho3rSwagKFQtfxnRU6cGndFmohzTuFGB3KFpmJaRim9PVaPm+2+xYfZY3Dg4WTOPjZDxomTBVCNsUlxWzOmx8USPt3yjw+a1+IZ/Au3ZkqPj48l7/30P/zj1D90MtPoaft0dOeP0hK1wctrt3AM6KpzkJvd29XCNt3AhB4SVZiZdE9O4UQmrhULmgAQUfO/KxdHKsBEyXgAoXjCV5Js4aSeW7l5KPF6plyBYEcprCbRnyzP/Si56GmgxiWTJ+qTj9IRN7j2/MJ/jS2XJvd0hXEMa1uMa17RvP3D5ctCG40zEMVYQ2kQQ9m3fNyeCXUyW7l7Ku2AC/K0Y1GL9kfWob60nHq/USxCsiOW1iClLa4lQBR4pej1vAJCYGiU+SMI4vYnJzkavlSv8PvescJKKaLgGQNXyl4O+oog0rOc5ji29vzBvnqw2FybBg2ncBAlib/sMGEHDQusF00k7senYJuLxJPo7XRUt+1ipAZt/lRTpLbGeGpmKh370EFIixSXU9TLQys+SGdOk4wJB9JQpAID0devQ65VX0HfjRgzeVizbsyIlXBPMsGE9Us0eR1ERyvMX+Q2T0ubCJHgww1JBgtwqFl+0WjAPVB+Q5LUxmmidL3KSsknRso+VWmT1y8LNqTdjS+EWLJuwDMnRye5r8MSoJ/D2obfx3pH3RPejtYFGEVask44LJJFjRkvqesyHknBNsMAmSkfn5KBu40aXgePpqfIJ65nJx90P07hRCSfNoOSsq/dSydla1ROK1VoktFowSedHgcIrt75i6DJwrauYpOgKBRLWmMvun+216FotVtzY60Yi40ZrA63XtfHA12Vk4yBcPdRVkBOuCSa4EqV9jRtfzR63N4tPU8hMPu5ymMaNChQerXCXgq/KBOZsLEVCjwhVS8GVLhJaL5ik85s3fB6y+xs3kVGPKiYt+1jphVEMtN7XxMMWFYKWxnbeMeFRoeh9TXyXrx5i4e8z1YHCKqxAwpcoDdrVWT1+9gOInjLVz2jtDt4sE2/MnBuFFB6twCObDvg10Kysb8Yjmw6g8GgFz5bieLYucNJOJEckC/aRirPFuf/b9ztA2wVTrM8VAMTZ4vDwDQ9rcnw1EMtrAtRLkg2mdgxckCQe62GgWSwUJt93neCYSfddiyvFW3HxiSf9clG0yrcIZDuArtxigTe0BAAUhYYtRZzeuK7uzVKDrtbCwvTcKMBJM1j25TFOoXoGLpXiZV8ew7SMVMkhKq7QSKwt1l0qzPW2v2T8EgBQRYhPKkLeCHaOS8YvIVrstMx3EUJKFZMa+jzB0I5BCNZAW7pnKepbvPOtYsJidJvHoJHJyH14KHZ9fBKN9s5u9T3ibbj5niEYeEMiTk3VL9/CCB6irtZiAVCma6O1plCwo+ozSzuBsj2u/y7bAwy8KSAtGEzjRgElZ2v9PDaeMAAq6ptRcrYW4wclEu+XLzTiaHEAcC0cnsm7vsZLoBZMPpXj1MhUQePK05g57ziPT098iuqrnToreqn2BqKKSas+Vnria9gAgKPVoasY4aCRyRgwvCcqTtrR6GhBVIyrE7jFQqFxb4luYm8k+jLRU6eisaQETXtLAABhY7W5/12lxQKLktCSlppCwY6qmkjHNgOF+cCVWmD4e8BHdwM9EoDclbo3zzSNGwVUN/AbNnLGAWQCb+Eh4Xh10qu4fPUyp/ESyAVTqjeCy0Pli16icMFQxWQk2GeVi0CIEVosFHp3JA57ole+BUlFTuULS1D+/Atg6jsNQuef/wy8uAwN27cjISdH0Rx8CfYWC54oDS3FZGejF8PgdLP373Ewe7OUomoV2bHNwCcPAGAAi4dopqPC9fk9H+hq4JjGjQKSo8lUT0nHAWShkaqmKlgoC6YPnE68Xz0hNa74PFS++C6UWmGUJNlgQe8wnlxIF8WWU6fQuLdEtneDJGzCGxYBUL4wHyEU1S0XWRLUSJSOnjIFKChA+rp1hlMoDkQln2otLGiny2MjlKRRuAi47nbdQlRmQrECMgckIC5SWJciPjIUmQMSiPdpdIE3tRDyUHGhhyicUJJssFQx6Ylaz6pn4nxpZanqqsaiYm8dXF63TpFirRqVNpW/Xx70iZxaoWaidOSY0Yi943ZEjcs0hGHjKCrCqalZOD97tq7Kyap5Nct2A45ygQEM4LjoGqcTpnGjMVK1w7pLaESuKKHWRp2UKiatF2Wjo8azWlxWjJzPczBnyxzk78rHnC1zkPN5DorLitWapvCiyIHcCio1Km2cVVVBrxysJTHZ2ej9xusISfFWyVbSriLQsDkvelXyeaJaFdkVwt9y0nEqYIalFFBythb2pjbBMfamNkkJxd0lNCLXSNHDqCPJG9Ja6C8YUPqs6tkZna96iBOZFVSiYRNCTK0VYbpSonSglZNV00TyadWieJwKmJ4bBWiRUNxdQiNSjRQKlK79qNi8oekDp2Ns6lg/w0aogamaXgcjo+RZ1UJTiKYZXDxehxOllbh4vA407b3vmOxsDN5WjL4bNyJx3jzhncnovyTVQ8RHd9ZaIYVNlDZSaEkOge4DJhrqYxhE5+Sgad9+4XAp6fOu4N+FVEzjRgFaJBQDwS/wRgKJ6B+LkYw6PYX+ggG5z6randFPH6zGB8/uxt9fO4itfzqGv792EB88uxunD1Z7jWMXRfpqE9F+pXpReMMmqamwxMaKbm/txlor3REjKCfzPbOsIVK3caN4DpAZlupaZA5IQFpsOCrrmzlzaygAqbHhkhKKWYJd4E0MMdE/T/QQISQlWCqE9ETOs6pm4vzpg9UofPeo3+eN9hYUvnsEkydH4Pq7xrnf7hmnE/WbvyQ6vpwKKr6wScO2bbj4+BOC26b+9tmg9UKYSMcoysmez2zD9m2o2/iBu6UFi6DuTSOh8UU6TgVM40YBVguFJTMy8MimA37+B/bvJTMyZDfQ7AoCb0Lwif6lRKbgrmvuQt/ovoYz6rpLNZtUpD6raiXO0zSDXR+f5B/AALu/Lofl9VsQN/MORE+ZCoamQdfVER3/8rp1uLxunWS1Vi59mZjsbOAPb6DihSWgOUrCe61aGZQJscECW2oNuMJBMZljA25IGqkPGGW1InLMaJTncwgdAsI5QFGExhfpOBUwjRuF5A5Nwzv3jXI3zmRJjQ1XtXFmV0VvD5XS1g7dpZpNa9RKnK84afdqueC/Iwot4QmoZRLBbPwAdRs/IAoP+SJLrZUD9g3ZV6H4dM0llwaLiSaw7QVa6uqAF5fhwrx5sMXHB1y8j815ufjEk36dzQOhnCxb9yaacJ0jHacCpnGjArlD0zAtIxXfnqpGzfffYsPssbhxcLJsj013Qy8PlRoVTt2lmk1r1OqM3lB7VfB7lqthcWC1i2kPdWBiVKxcoaxW9Bg/Hj3GjwcAtLW1AQUFsvdnIoxXewGbzf25WgarUozUB0x2DlC/CUBEAnC1ln+jiATXOJ0wE4pVwmqh3Lk1mQMSTMPGYKhV4dRdqtn0QI3E+aqzDqJjOWIHyJqjFxpXrpioj2ipNYCq5S8HXDjRs5Kv1yuvoO/GjRi8rVh3o0tRDpBTwIMKAM5WGTOSj+m5UQknzaDkrMtqLTlbK+q5CVTn6+4IaYUTaQ8koVwhKYnPXfUZkHJeisOShKWllALdGV9MHZrgQW6YJRCtEIzQB0x2DtDZXUBro/DOW6+4xg2apNp8hTCNGxUoPFrhzrlZlQnM2ViKhB4RvDk3pgCcvpCoIUutcFK6KHfVZ0DOeSkJS8b2jCAaF9Fcw/m5JTZWcpjK1KEJHuSEWdj8HK8QkcSEcrkEwqjyRHYOUNm/yQ5Q9m/djBszLKWQwqMVeGTTAVTUewv1VdY345FNB1B4tMLrc1MATn+qGsm0FUjHsQgJ/QnRVZ8Btc5LSluLoZP6CDtvGAZgnOjzwzecX/d+/TV3KCD9z392aX3w7ZCiEJKaaurQBBFSwyyBbIUQqP5SvshqcUHqGFXPgSqK6blRgJNmsOzLY0J9ULHsy2OYlpEKq4USDY94dr7uCuEJo1DXQlb2SzpOCV31GVDrvKR6fkJCLBielY5DWy/476zjrTP9wjZY4K3ZwbrXozK91W1Tfvus662VC4ZBzO3TA14+zBLot/xgQEqYJZCtELySnj0IVNKz5BYXAyYCu1aL73jARHUnKoDpuVFAydlaP4+NJwyAivpmdy6O2qqsJv5wvfXH2+LFNwSIxymhqz4DapyXXM/PTXcOwYhp6RwOFxrpF7ZiyJl/cG7H5V6Pyc5GwpyHeOdYu+HPur9Jc2GUt3yjI6WTeKBaIRg16VlSi4u+48l2SjpOBUzPjQKk9pYyBeDU5UDVAVxuvezOd9lxYQe3IOCQu4j2lxKVIj5IIV31GVB6Xko9PzfdOQTjfjwIR3f+gPqaq4hNDMeAyApc/Vcc6qt7gL5yxWs8n9YN43TC8ZVwWbaWjQxJMNpbvtHxLLV2eog3+pZaB6oVgmxtmQDB6TEs2022cdluM6E4GJDaW8oUgFOHnRd2AgAe2/YYWuAqP4wNi0V9q39iaHVTNdYeXotYWyzqW/gTR4WacqpZ1dRVnwGl56VGW4uQEAtGZPX1+KQfqEYH6jZu9BtL19dzGgJGWmi4FhEAAe0iHaywYRZHSSlOV1chfd06P4XiQLVCMEJ/KVJ4k61nDEEMyQ50TCg2jRsFSO0tZQrAKae4rBjP7noWz8U95/U5l2EDdL71UwzF28OKAsWrTaN2VVNXfQaUnteO8zuIjiPFo+V293N+yW0IGGWh4VtE4u6+2zDGl9aonVPEthdAQQHnvgLVCsEo/aXEEPQYrq8EbgpHTLpINEPHhGIz50YBbG8pAPAN93P1ljIF4JQhFLoQggEDe6sdj454FCmR3qGn1MhUXsE4LaqauuozoOS8isuK8eH3HxIdR4pHS04OhREWGqGKnZo33yTahxHe8pUQiJwiKfk5asIaVUau0iPKCzoYA4b2/9oLM6E4eGB7S6XGeoeoUmPD8c59o/x0btRQZe2ukOjVCNE3ui+23LkFG3I2YOXEldiQswGFdxZyXnOxHBAGDJbuXopvy78VLFXmoqs+A3LOi73OYlCgBEOHXMjxwgR6oSFZREgI9Fu+EgJZji2lDJpxOtG4twT1//wKjXtLZCf8BsqokoLoiwKA9qYQNF0K4x8QkQD0v1nlmfFjhqVUQGpvKb2bRXYVlCbZ9ozsSSwYR2JI1bfWY+7WubLCVF31GeA6r+FJw3G45jAKzhT4nSepwcqAkezRkuOFCXQjQ5JFRBAdu0hrQSDLsVlIyqDVFvozUn8pLohfFJoF7smMNwAdf99M40Yl2N5SBd+T9ZbSq1lkV0Jukq2cPBYphhQbppLqdemqz4DneRWXFWP636bz5iyRXuf7r79fskdLbg5FIBcaSeEkA3SRVhujJHQLtULQqlpNsraMjhC/KNyWD1x4F2j00AyL7gXcthLImKnR7HjmouvRTEwUwCat1jeRy+XLzWORYkgFs/ielrA5S76hPU9jkPQ6T+47WfLxlXhhArXQkC4iSb+ZD/unnxnyLV8JRkno5kNrz5IR+ktxQfyicP0A4Aff0Jo+c/TFzLkxCRo8k1Z9YY2YWJu3foncPBbWkPJNjuUjWMX3tIK0WenwpOGC11lKrg1NM7h4vA4nSitx8XgdaJqRJyXPHluKiJlKkOb8JM2bZ4gu0mpjhIRuIQIl9BdoiPKCHpgG6vMHAUe59/eOCuCTB4Bjm7WfqAem58YkqMjqlwVmIoOmI01en7MdudXKY2ENqbydebwl5FwEm/ieVpDq1hyuOcx7naV43U4frMauj0+i0d7i/iwqzoaJ9w7BIAO7+32R6m0y4lu+EgJVjk1KIDxLRmmzIRiuXZyPmO8WgLvWu6MZUeEi4Lrbdcu7MY0blWhtp7FpzzkkAvhwzzncN2EQwkJMx5gWTEqfhIIjBVg7da2XQjG7AKqVx8JW//jq3AgRbOJ7WiFFsXj6wOmc15k1WMW8bqcPVqPw3aN+nzfaW1D47lHkPjwUA29IlHYCAcToyaVaEuiEbjH09iyJJS7rbfjwhmvP7wb2lAtsyQCOiy6FYp3KwU3jRgVeLjiG9bvOItTCYFUmsHLLcfzu6xOYO3EAFk/PCPT0uiyjUkYhNDRU02Ow1T/7qvbhqZ1P8YoFBqv4nlZIVSyWWz1G0wx2fXxScMy/PjgC58Hfw1lZ4f4sJDUVyYvyERKfEPA3Yi6MnFyqNUY27vT0LIklLl+d8xAcXxWoVrFFCmde0BVCiQ7ScSpgGjcKebngGN7911m/z2kG7s9NAye4sVqsGJc2DksnLEXezjwAkB0+0RI120QoRY5isZzqsYqTdq9QFBdNVynUNPeAZ1vU9spKlD+5wGuclguD5xu2NTERAAPn5VqE9OyJ0OE3cG5j1ORSPTCqcaeXZ4lE76j2Txv8vgpYf7EehH35SMepgGncKKC1ncb6Xf6GjSfrd53FU9nXmSGqLgBfmIo0fKIlareJUIpQzpKaxmCjQ9iwYWkJE+98o9XCwBVa8ITq2xd47FHVjtdVEDPuApWLoodnSbbeUaD6i/WbAMT0ciUP8zUjiunlGqcTpnGjgA/3nAMtkmdKM65xv5w4UJ9JGQQjeRFIIJ2vGuJ7al8bkpLrQBg4ehiDUTE2onG2Vof4IA0WBr7Qgift1dUAgIbt25GQk6P4mN0BtUX0pKK1Z0lRQnIg+otZrEDuSldVFF8zotwVpohfsFBW2yQ+SMK4roLRvAhiSJ2vEvE9ta8NScn10t1L0SO0B8amjtXdwNRaiTltSByi4mz8oSmGga2lDnH2U2Q7VHFhEAwt+BwTAKpfXYP4rKyAh16MjlYielLRMmyoRkKy7lpAGTOBez4ACvOBK7Wdn8f0chk2Oov4mbESBfRLiCQe56SdKK0sRcGZApRWlkruRxQsaNFsUkvkzFfuvdTi2khpE5HzeU5Arj9rDE4fOF11A8tioTDx3iGCY4ac+gyUxGaraiwMUkML7VVVXU4fRW2IGjguf1l2nyejIKp3REBAtIAyZgJPHgVmfer6e9anwJNHdDdsANO4UcT94/tDpMsCLBTQu/cp5Hyegzlb5iB/Vz7mbJkTsIVGS0iF24xi2MmZb3FZsax7qdW1kdMmIpifO1mGpYwFQo2FoWH7dsnbKDGq1GrkGAhI595dRPQERfNENw5wF3GLFeg33vXf/cbrGoryxAxLKSAsxIK5EwdwVkux5GZWY+Gu11TJhzB6HgupcNuB6gOG6Kkkdb5Kclu0ujZS20QAwIt7XkRzezNSolIM9wwJwRnSi0jF3aWLwKvxTgEnB92JnjX/BcXQ4gdRqZTXUVSEuo0bJW8n16gKdA6KEqTM3ejtGdSEN3E5NRUxt09H7YY/uz4wmBaQUTCNG4WwZd6+VVMWCvjlzf2wo8nfsAGk9yMKhjwWKcJtRkDKfMU8L2L3UqtrI1ZyzUVdSx0W/9v1VmiUZ0jMcOczLK2V0WhvEHqzpdASnoCGAWMRc2av8CRUWhjcoROJyDWqjJKDIgepczd6ewa1EUpcjhg+3JBaQKCdQNke13+X7QEG3hQQ741p3KjA4ukZeDLrWqwoOArgHH4+Nh2Lpg/F0doD+OsW5W/rRq2G8UWqcFugkTJfqZ4X38U6MYJMIVfqtZHbJoLFCM+QmOEuZFhGtkUTHSN+ycvojQvuBcJZV4uqFSs1WRjklvHG/uQnko0qrRs5aomcuRu9PYMW8CUuG1IL6NjmzoTi4e8BH90N9EhwVVKZXcGDj8KjFVj25THUXrmKUZnAX0svoOj7Gsy8iUyNsaqRf5xSj4GeyBFuCyRS5rvl3BaifV5qusS7WMeGxcLR6lD92shpE8ES6GeIxHCPtcXynldTSAPRcSJjbIi63nuBiJ42jXNhUKqfIjckEpaeLnkbKTkoRhMElDN3o7dn0BtDCT0e29xRCs4AlvDOz9nGmfd8oKuBYyYUK6TwaAUe2XQAFfXNXp9X1jfjTztriPaxqnQVb5KnFI9BoPHs2u3b5dkoKr6eSJkvqUflfMN53oqo+tZ6tzEhdCw5ZPXLwpY7t+CP2X9EbFis+AYeBOoZIk2yFjL+SWE4IldcXb8dRUU4NTUL52fPRvnTT+P87Nk4NTULjqIi4mPJDYmEJCVJ3iaYc1Dkzl1Jp3cTjaCdLo8Nb+NMuBpn6lhMYho3CnDSDJZ9eYz3djqbBoByxvktZr7UtdTxVrEEWx4L60VIjkz2+jwlMsUw4TNPSOfLenn47iUFCikRKfjsxGeCXrY4Wxx6RngvfmpdG882EVTH/0lB72eI1HCva6njHRPZThaWutrQKjqGzf/w9Saw+R+kBo7kMt6OcREjR5CN9yCYc1CUzD0mOxuDtxWj78aN6PXKK+i7cSMGbys2DZtAUbYbcBA2ztQJMyylgJKztX4eG08YWNBUcQci+mwiyofgCg0EWx4LIE24zQgVYCTzJWkncNc1d2Ht4bW8x2HAwN5ix/pp62G1WDU7Z7lhKr2fIVJjKt4Wzxs+bAolUB6GuJKxmrkrgqETv8GU13ZSEc1BAWBNSJBlOGmN0vwZQ4VkujsGbJwZcM/N2rVr0b9/f4SHh2PcuHEoKSkRHP/666/j2muvRUREBNLT07FgwQI0N/MbGFpS3SB+3PaGofhFv+cQZ4sTHMcXGiDxGKRGprpzNYwiFkgi3CZXMyZQ8xXz8vSN6Ut0rNrmWs1E7TznuuXOLdiQswEv3/wy4m3xxM+QXpAaUylRKbzhw6ros6BBg9sd3gEFpAwSDtWprZ/CFzqBxfsnNyQlBb1WriDaJxckeijO2lqczs6RFFrTA8G5d8P8maDGbJzpzccff4y8vDysW7cO48aNw+uvv46cnBwcP34cycnJfuM/+ugjLFq0CBs2bMCECRNw4sQJPPjgg6AoCmvWrNF9/snR4eKDAExOz8IN6VHu8lshfN9mpTQgDIZycZZgqQDzRcjLU1pZSrQPvTwknm0iwkPCNW9iKRUpCd1Wi5XTG3V96xhYxN7RGKDypB19rk/gHaJF7gpXNUvEyBG4evCQV7JyO00DBQXE++U6Dpceite8DVoWrkcTShMdcDfOFAhNxfTuPo0z16xZg7lz5+Khhx4CAKxbtw5fffUVNmzYgEWLFvmN3717N2666SbMmjULANC/f3/84he/wN69/PoVLS0taGnp7DvjcLjc2G1tbWhra1M0/5F9otEv3oYqRzMYADaL6wea/V8KQEpMOEb2icbhSz1hg3iTv8SwRL953drrVrw68VWs2b/Gy/hJjkzGgtELcGuvW7H1zFY8u+tZMGC8jlPfVI/FOxeDmchgUvokReerFk7aiVdLXkUYwji/p0BhTcka3Jx6M+eCy14fpfdPCSMSRwAd1d20kwbtpDEsfhj6RPZBTVMN72KdFJGEtrY2fHXyKyRFJGF4z+GqGhVO2onDlw6j5mqN1/5JniHf66nHdc4fnY9ndz0LAJxG18LRC93X99Zet+LmmTd7nV/7vjgcDvlB9DjnT9QgZbBAfk5iIpw2giacif7/PsUIGzXS/aQ7ff5up2lVrnPE5Mnoe9NNOD39dtB2O/cgikL5K68i/JZbDOUNiZg8Gf1uucVl9NXUICQpCREjR4CyWlV/9ozw29Fl+dE9wN51AIC2jmqpNs+qqR/dDThp1//LRMp9oxhGrKubNrS2tiIyMhKfffYZfvKTn7g/nz17Nux2O/7xj3/4bfPRRx/h0UcfRVFRETIzM3HmzBncfvvtuP/++/Hss89yHmfp0qVYtmwZ574iI8l6Q5mYmJiYmJgElqamJsyaNQv19fWIiYkRHBswz01NTQ2cTidSfGLSKSkp+N///se5zaxZs1BTU4Obb74ZDMOgvb0d8+bN4zVsAGDx4sXIy8tz/+1wOJCeno7s7GzRi0NK8fdVWP7V96hvasZLY2g8v8+CuKhwLJ5+PbKu7zy/nRd2Cr6lLp+4XJZ35UDVATy27THRcWunrsWolMBrzBSdK8KS3UtExy2bsAzZ/b3d0k7aiYOVB1F9qBrJI5IxMnVkwEvLfb0l9hY7Xj/wupeHJDYsFvWt9X7bKr33LDsv7MTiXfxhz5cnvky0/50Xdrq9O2EIQ35cPt5sfBMj00bip4N/qlnCN5/HSYyLJ+pQ8M4R0XEjLvwVMec6w4YhKSlIfioP0VOmuD9r2L4d5fkdHmMO/ZReK1d4jVeLtrY2bN26FdOmTUNoaKjs/TgKt6DiuedEx6X97neIyc2RfRy1YJxOTm+Nlqh1rU18KNvjEuzroM0Sjq3D/oBpRx5HKO2Rmzrr086+UzJgIy8kBFW11M6dO7F8+XK8/fbbGDduHE6dOoUnnngCL730Ep5//nnObWw2G2wc7ubQ0FDVHu5DPzhw0dGK0I4umi00hR/qW3HoBwduu6GPe9y0gdNAWSm/vIHUyFTkZ+bLzjG53HoZLWghGmeEf9DJ0clE802OTvaaL5tTZG+y4/m45/Gbnb9BXGRcQHOK+PKcFo5diPjweFxquoTEiET89t+/RUsr9zlToLBq/ypM6T9FluHgpJ1YVrJM8Jq+WPKi6P6Ly4rx1K6n/EJq9jY7Cs8XovB8IWJtsVg6fqkq19u3Um5MrzGSz7/PtUlgnJRAPjEDMAxij++GBZ3ucObCBVQ9uQAhHjkoCTk5COmoigpEjyalv0nhycmwtoj/uwpPTg7470Cge2Gp+fsfrCgVq/TiajVA+xfYhNLN3sbN1WpAwXWXcs8CZtwkJSXBarWiqsq7NKyqqgqpqamc2zz//PO4//778atf/QoAMGzYMDQ2NuLXv/41fvvb38Ji0b/46+WCY5yNM2kG7s/Z/lOAtDJpUoKtXFyOkrFnArJnTlEgE5CFkqKf/uZprJm0BtMHTkdpZammDUVLK0tR3+LvFfLE3mJHaWUpbux1I+f3QoJ6ntS31GPBzgV4bdJriq63WsnvVafrBQulAAqgKNTHDUK8/WTnxzzl3YaUtCckWFoTaN0LS9VFu4uiunEZSShASTpOBQJWCh4WFobRo0dj27Zt7s9omsa2bdswfjy326qpqcnPgLF2PLSBSB1qbaf9Gmb6sn7XWbS2eydQkZQdS0FquXigkapkTKpkq2fZu5Q5aS3EWFpFVqUlNE5MUM+XFSUrZF9v1ijkUnHmE7Pko9Eh7qkAgJYwjhA0T3k3l3JxMBAMpdWiekIAqpa/DMYp79lSQ2G6q6OWWKUXEgUr9SCgOjd5eXlYv349Nm7ciO+//x6PPPIIGhsb3dVTDzzwABYv7swjmDFjBt555x389a9/xdmzZ7F161Y8//zzmDFjhtvI0ZMP95wDLWJT0YxrnJYEW9sDQJqSsRFbUEiZk+aeNVK7XmCcVMOqqqlK1vVW21AVE+djsbXyx+qN2JpALkZvTaC2npAnmizaXQzNjMuGCnXHqUBAc27uvfdeXLp0CS+88AIqKysxYsQIFBYWupOMz58/7+Wpee6550BRFJ577jlcvHgRPXv2xIwZM/D73/8+IPMvq21SdZwS+FRpUyJTFOXzeKK2mjBpiM6ILSikzCmnf46mDUUz0zLx3pH3iMbxIcewknO9pXZXFyNtSByi4mxotPN4cBgGtpY6xNlP8e7DiK0JlMCG1hpLStC01yWKGjluHKIypYc81UarXlikCtP9brlF0n67Gpo1Wv2BzHuMH0qB4T8n368CAp5QPH/+fMyfP5/zu507d3r9HRISgiVLlmDJEvFKGz3ol0BWSk46Tila5POwaCUQ6Ck0x4cRc4qkzEmKEKMcxqSM4a3GYokLi8OYlDG837OhTa3bNahtqFosFCbeOwSF7x7lHTPk9OeguNxWBslBkYtQbknDtm1eORWX163TNWGXD616YZEu2lcPHpK0365GMDdalUrA2y8EM/eP7w+LSAjRQrnG6YXa+TyAujkScjBiTpHUOWnZUNRqsWLphKWCY5ZMWCL4LLAGGGmzTbmeJi0M1UEjk5H78FBExXmHqHrE23DrjTSSaw4bNgdFLkK5JUYOz4g2FaUohKSmSjY4iRftmhpJ++1qaNZoNWGguuNUwDRuFBAWYsHciQMEx8ydOABhIcF7mY2QzGvEnCI5c/Ls97Ry4kpsyNmAwjsLVQkZZvXLwmuTXkNyhI/xFJFCXNnEGmCxNuE+TACwKHORrOutlaE6aGQyHlg+AT9ZMBLTfpmBnywYift/PwFDH5qmag4K43SicW8J6v/5FRr3lshOfFWCmPFS8cISzRJ2laJV0jPxop2kX7WOEdHKuMTYuQAlss5RVtc4nQh4WCrYYcu8faumLJTLsPEsAw9G1M6RkItnTpG9ye7+XM2cIiVzIs1zIgnDKZnP5PTJ2Fe1DyUVJQAFjE0ZK+l47D7W/3c9Nh3d5Pd9nC0OS8YvkX29tQzRWSwUel8b7/e5WuXdgdZmAcgSQnnbL3SMkZVToSJa9JMiLYOPGDkC2LJFweyDG8GO9Uq8mSFhwPj5wO4/8I8Z/5hrnE4ErP1CoHA4HIiNjSWSb5ZCazuNTbtPI7HuGC7HZ+C+CYOC2mPDUnCmAPm78kXHrZy4EtMHTtd8Pk7aiX3l+1C5vxKpo1NlCb9pMSct8pzkoGZuVHNLM7YUbsGF3hfAWBm3oaRVDpdSMUst4dNmYUn6zXwkzZsnK8TV1taGgoICTJ8+XVSkrHFvCc7Pni35GL70euUVxN5xu+L9KEFtPRr3PQI4F+3eb7yOiMmTia91V0YzQ73oeWDPW2ijwlAw/D1MP/xrhDJtLsMm+yXl85awfpueG5WwWihcmxqDmjrg2tQYWMWScYIEoyXzWi1WjEoZhQIUYFRK4IwI3zlp6bUiRe1O6+y1fXj4w6ovBFomv6uNoLekg5o334L9k0+R8ttnNfXiqJXoqXeFGJ8ho6b3iMQj1B0bZnJde83EKrNfAqY8D+z9I1ADYOoSYNyvdPXYsJjGjQoUHq3Asi+PofbKVazKBOZsLEVCjwgsmZGB3KFpgZ6eIuSoCZvoj1huFAUKK0tWYnL6ZMMYEEYxCsUQrcTpQC2FXSEUGyUBqBDTM5wXzArTWiB27TUJTYaEAZlzgYIC1/+GBMZDFvxxkwBTeLQCj2w6gIp6774alfXNeGTTARQe1U+0SAuMmMxr4o8RhQ71hqYZXDxehxOllbh4vA60mMImIVK9JZVLl8G++UtNEo5JEkKtcXH8O2AYWTkVchOpA1G5FawK02pj5Ko5PTA9Nwpw0gyWfXmMU/iVAUABWPblMUzLSA3qMJUeAoEmyjCi0KGenD5YjV0fn/QS84uKs2HivUMwaGSywJbiWBMTyQczDJy1tahYuBCA+h4KkoTQ2Dt/hto/bVDleIB8zwupsJ5nb69gxkg9rbrbtefCNG4UUHK21s9j4wkDoKK+GSVnazF+kIQfSAMSTDkS3RGj5EYFIrn69MFqThG/RnsLCt89ityHh8o2cBxFRaj6/XLZc9MiVCWYW7IoH1UrVvJvLHFRU9LkUjM1XANihEo6T7rTtefDNG4UUN3Ab9jIGacEPRaVYMmR6G44aSdohhZUKdYjN0orFWshaJrBro9PCo759ycnMWB4T1gkek/FKqSI0OgtmS+3RM1FTenbf3dRw9W6y7kcusu1F8I0bhSQHB2u6ji5BGJRMTEGXPfeFz1yo9Su1CKl4qSdv69UB1fqWlBx0s6pgcMHSYUU+c60eUvmqjaSs6jxhVOUGkqaqeEaCKOGf7rDtRfDNG4UMLpfPCwUBDuDWyjXOK0I1KJiEnj47r0vWudGBbJSq9EhbNhIHcdCWiElBaVvySQ5HVIXNaFwCtNKVjbNd16kwnrB2tsLMG74pztcezHMaikF7C+rEzRsAJfhs7+sTpPjG6E1gklgELr3LLFhsVg/bb1qLR74ULNSy0k7UVpZioIzBSitLBV9diN7kOlnkI5j0cJdr+QtmauX1ImbJ6K+sNBrnBR5fbFqmtayMqK58Z2XVq0WjIRRwz/d4dqLYRo3Cgh0zo1Z/suP1EUy2BC79wBQ31oPq8WqeUKvWpVaxWXFyPk8B3O2zEH+rnzM2TIHOZ/nCDZmZQjTaEjHsajqrpfbr6cDPiOErqtD+ZMLULV6deehCBc1AMLhFIaB/dNPYU1JUdSHKCY7m7O3lyUuDvEP3A9rbFzA+lypgZHDP3zXXm5ftWDDDEspINA5N929/JeP7pCDZKR7r0alltzw6tWGVqJjk45jEXXrk6LwLZkk96f2TxsQMWwYYnJzAZAp9TbuLRENu7VXViLpN/NR89ZaRX2IPJOfG7Zvh2PzZjjr6lC38QPUbfwgoFVFSjF6+Kc7ixqanhsFZA5IQFpsOE9/Y5fOTVpsODIHJGhyfKOU/xoJdpH09Wqwi6SQFyCYMNK9V9rpW0l4NSrGRjRH0nEsgh4Qzg1cYyw+AnpK35JJc38qX3zJywMSk52NwduK0XfjRvR65RX03bgRg7cVu+fRXiXs9WMJS++ryts/ZbXCWW9H3QcfwFnnHaY3qqgciXAhyXMS6PBPdxU1ND03CrBaKCyZkYFHNh3w+1ln/14yI0MzAT+zNYI3wdiCQC5GuvdKO30r6TyfMijWz6ngC0W5xkmFzwNijYsDA+/u26xXRO23ZNJcDWdtrV/SqlDvpvbaWrLj19Yi8cHZis/LqFVFfEjRrWGfk4oXlvh1ZLfESn/uTNTBNG4Ukjs0De/cN8rdW4olNTZc895SSheVroaSRTLYMNq9V6JirSTEVnW6XjRqxDCucVJKwVn43PoAeBd7NatipORqSElatSaQeZPZcUqbXBq1qogLubo1voYNAND19QHTuunumMaNCuQOTcO0jFR8e6oaNd9/i8U/sSEpoRmJUT/ASSdrusCYrRE6MVIeilb4ijW+cusrWFW6yhD3Xq6KtZIQ2xURjRup47jgW9j1WIQjx4yGJT4edJ14xaUUQyjUJ8zER9uFC8T7FMKoVUW+yPEwubfh3KHxvFLdBdO4UZHDl3ejNyx469hitMD1Y6pHIqvZGsGFkfJQtIAvUXrh2IWID483xL2Xo2KtJMSmVUKxUaCsVqQueQHlTy4QHCe1GsudCCuSz1Pz1luwDRks2+vAavO0nDpFND7QonJyPEzB5JUiRVGfLNoJlO1x/XfZHmDgTUAAfo/MhGIVKDxagXGvv4Y/Hf+933d6JbKyi8r0gdMxNnVstzNsAKCuuQ4Wiv+RFktsNTJCidJPf/M06lvqg/beK+k8HxEdSnQM0nFGJDY3Fwm/nCM4JnlRviSvgFcirAhVy1+WVa7tqc1zed06kQkpK5dXCzkepmDxSpHCpal0amoWWcL3sc3A60OBj+52/f3R3a6/j23WdtIcmMaNQgqPVmDepn24GvMF5/emmJ4+FJcV4+lvngbN0ILjgjEHqTuINbLh1eRI7waXKZEpgirbPeLIZBZIxxmVlGeeQe/XX4M1njtvqHrFSsnVRjHZ2Uj6zXzhQR5eBynwafNwYiBROTm6NUbWupGKmLCj4DN2bDPwyQOAo9xnpxWuz3U2cMywlAKcNINFXxyBNfIsLKH1oMBdbtqVElmNCIlar4WyYPUtqzVtQaBVWLC7JErLCa+mDYlDVJxNsL9Uj3gb0obEaTBjfWF1bC5yhKjkNmkM69efaJwUr4PUvlye+juBRo5ujdG1bkhRVNFGO4HCfIDzN5gBQAGFi4DrbtctRGUaNwr49vRl2JvaEBLTQDQ+mBNZjQyJWi/N0IgP16bHl9aigd0hUZpFas6OxUJhyNhkHNrKn/g6eEyy5I7gUlCUnyDxOFUrVvJ8KS9xVQuvA6k2T+K8eYgaP95QonJsuO7iE08SCxfK2caIKModKtvt77Hx3hhwXHSNGzBRlfmKYYalFLDnTA0AgGmPJhofrImsRieQi78eooFdPVFaCTTN4GRpteCYU/uqQYs1gZOJovwEiUhZfEiR0ouKFFIvj23wYEOKyslpW9AVWh0oyh26QiYKSTxOBUzPjQJYA93ZNAB0WyyYEP4eUsGayKoVaoZx9F782blXNVZhVekqzUUDjSTYZzQqTtoFQ1IAcKWuBRUn7bJ0boSQq4ciFy0SV7XwOgRjDoqv9y166lTJwoXB3upA0X2LIryXpONUwDRuFBAdzl4+C1qqZiC896d+Yzq8xUGZyKoVaodx9Fz8uebOh1q5MEYT7DMSjQ4y/RrScaQEQnFXK6OBpBeVFIItB0WKGrEYSsUOA4mi++ZsJzsI6TgVMMNSCvi+wuH+7/aGoWiuuNdvDNMei6Ehv+lWYnpCaBHGUVJK7IlYJ3G+uYuhRjhMbjVRV0er3lJiaBEiEkOLEBKLWC8qKZB2JjeCR0NRdVAXQ9F9u7CH7CCk41TA9Nwo4Gqbd9lx+5XrATjRdGE2Wi0OMO3RcDYNQHSGdi0YtEbN8JGWvZ+UKjWLeZNIKrL4UCscZoo1+hOoaqlAaJtonbiqptdBbW+QFgRbvys9iMnOBl5bg8plL3o1OBW9b6Q/i9qkvnFiGjcKGNs/AUXH/N/inVcHoN1JeY0LRtQOH2ld0ix38Wc9Mr6GC+tNWjNpDWJtsZI9NlrkwshRAO7K6F0tFWjF3WAwGliMnoPSFZWFleIoKkLVipVeho0lPh7Ji/KFn60BE4Fdq8UPoFOlFGAaN4qYPaE/ln/9vWhH4tkT+us2J7UgWfClGjh6VDVJXfxJvUlPjHpC0jy6ey6MXpBWS43/6WDFBg5XbgYvGuaVGN1o8MTIOShdTVlYKXwJ8rTdjvIFeaAsFn4Dp+94ABSEXTNUxzh9MHNuFBAWYsGvJw4QHPPriQMQFhJcl1krRVwjljSTepPqWsQbF3rClwsjltdjIg0p1VJKMJriLms0xN5xuyHLqdWCcTrRuLcE9f/8Co17S2S1geAjGKu6tEI0RAeRNhwX9kI85sR0jNMH03OjkMXTMwAA63ed9frcQgFzJw5wfx9MaBU+MmJJM6mXKN4WLzh3dszCsQuREpXCGQ7TWuxPD7RUYpaDVtVSnqXB1sREVP1+eVAq7gYzjsJC/9wPmVVMXARbVZeWKA7RmTo3XZPF0zPwVPZ12LT7NFB3DPk51+K+CYOCzmPDolX4yIglzaReopSoFN65s7ww/gVeI0WLMJ/eGNE4i4gOU3UcIDH85IERFXeDlarVq1H7pw1+n7dXVqqmIdRVlIXVQHGIrkcK9+dyx6lAcK6+BiQsxIL7x/cHANw/vn/QGjaAtuEjo5U0s94k3xJyFs9O4uzcY8Ji/MbF2mJ5jxGMjS+dtBMHqg4AAA5UHUDRuSLNlZhl4SQsvyAcJyn85INRFXeDjfrCQk7Dxg3DyO5U7ktXUBZWA8Uhun4TgJheAM/vKEABMb1d43TC9NyohJNmUHK2FgBQcrYWNw5OhlXDfjbex1Y3VCAWPgJcjSjrmqXlobAYqaRZjjfJ0erw24+jxcHrgQm2xpesh8beZMfzcc/jsW2PoY1qEzTOlu5ZiuiwaIxJGUN8H9V4bi+ethOPS/9RouAYqQ0ffekOuRlawzidqFz2oug4NauYgilBWysUh+gsViB3pav7t5+B0/F37grdmmYCpnGjCoVHK7B08zHUNV7FqkxgzsZSxEdFYOnMDOQOladxQ/rDr0WowGqxYuHYhXjqm6d4x9AMjae/eRprKHneFiOVNJNq5MjV6Qmmxpee4TObR5d7mqEFtgLqW+rxq6JfET97aj23FKEdQjKOtOGj/867T26G1jTt2w+6juylSW0NIaNWdemBKiG6jJnAtbcBxwt8vmCAa6e7vteR4I2dGITCoxWYt+kAKh3efaUqHc2Yt+kACo9WSN5ncVkxcj7PwZwtc5C/Kx9ztsxBzuc5fq5/rZo2FpcVY1XpKqKxRgunyCWrXxa23LkFG3I2YOXEldiQswGFdxZ6LbRSPDCeGLFKjAslQoUsJM+ems8tqTgfyThZi2U3y81Qilj1k5R7YHrK1EVxiK7oeQ7DpoPjBa7vdcT03CjASTNY9MURwTGLvziCaRmpxCEq0sRTrdR++Y7PhdHCKUoR8ybJ9cAYsUqMCzHjjQSxZ0/t55Yi/HdFMk7OYmmJiUHCA/cjeupUydtqiW8jSCOEWUh6OJHeA2tCgukp0wDZIbr2VmDPW8Jj9qwFpjwPhJAn9yvB9Nwo4Nszl2FvahMcU9fUhm/PXCbaH0ni6UvfvoR/nv4nPvrfR7K8CHKPL4SScEow6b7I9cCo1ftKa9QKiwk9e3K9X3xcbWhVbZxo7yYAsFjQIzcXllhXAjldX4+aN9/CiQk34dLat1XVYZGLo6gIp6Zm4fzs2Sh/+mmcnz0bp6ZmBbRPEmkPJ/c9ECH1hedVN9bo1lZcfn8jKl76HS6/vxF0K9mz1dWQpaFUuh4QCV2DcbrG6YRp3Chgz2kyo4V0HMkPf21zLRb/ezFx2EjKgiX3zV1uOIU0/GYUpFRW+WK0KjEu1A6LcT17aucfqdk406txIB80jSuFhaDr670/rq9HzZtv4sRNNweFEaEnUgTi3PdAwMBM+OUcxOTmypoH28i0ad9+L0O0avVqHB8xEtUrVsD+f/+H6hUrcHzESFStFm4poKXIYFBRd07dcSpgGjeKULdbmBYJpT0jexJ7R6QeX2gxF0OrfCEtUeqBIcnrCSRixhvgqpIjhctYUjv/iG2cKYSUxpkx2dno9doawCLvp5G223Hx8ScMb0ToidQO6u7cDx8PjiU+Hr1efw0pzzwjeQ6sN+vCvHkAgAvz5rm9WW5NHdrH80DTqP3TBl4Dx4gesoAR31/dcSpg5twoYPzAJLy14zTROBLUfHNm8zjqmuuQ83mOlxERb4vHHQPvwOS+k72qsKQcX0k4Rcvu4FqjtPu4karEfPEti/eE/Xv1LasRExaDp755irMknh3Ll0NU11wHC2Xhrb6Smn+kRePMkPgE/4VOIoHoJm3URpByBOLk5n5w5Ro1bNvW2TPJ1mkIs94sMWr//D56PvEELGGduSJ8fZjc++xGGjkAgLFzgaLnhENTlNU1TidM40YBNw5KRGSYFU2t/G9CUWFW3DhIWF+DhURfhgR2IbptwG14+pun/fZV11KHD7//EB9+/yFSIlOwcOxCxIfHo6qxCvG2eNhb7KLHJ13MuQg23Rdf+HR6AKC0sjTg2j1K8DTe7E129+e+93vZhGXI25kHACDRBgJc3jqu59EXKQazFo0z1SgxDhYjQg3EkpflCsRJLc/mTFhOSQHd0iLozRKFplH30V+Q+OBs12ZiHjKKCohxqwXEiekhYcD4+cDuP/DvbPxjuiUTA6Zxo5iwEIugcRMqQalYSFBOCimRKXhm7DNYVbpKdB9VTVWCejYs7Hzuv/5+P4+PVIJJ94UPXw+MEVsTyIU13vaV70Pl/kqsnboWY3p5i/NJ9WCRJKtbKAtW37Ja0vWS0jiz97XxRPtUq8RY727SgWgESVIBpUcPJyFPihq0Xuj0DBrVQ6Y2JPfWi+yXXP/rWzVFWV2GDfu9TpjGjQJKztaKVkvZm9pQcrYW4wm9N3yLhhgLxy5EYnii22OgRlmvJ0o8Nb4Ei+4LKXr2jdKrcaXVYsWolFEoQAFGpXAfQ4rSNMnzSDM04sPjJZ3jFXsz5+dyxwEEizEheuuw6N0IkjQ0o3UPJ6XK0iSEpae7/ztQHjI9kR12y37JVe69949ADYCpS4Bxv9LVY8NiGjcKqG4g+8EkHcfiuWhUNVZhVekq1LVwq3ayOQqzrpslSxVXCLEu13IJFt0XEvTMHzKid4g0h4j0edxxfgcW71pMfI5XG4RfLqSOA0TUWol2EBjFYj0bQUoNzcRkZwNvvM4ZNlLa5Vu2sjQpFAXbkMGo/+dXCOnZE9ZEshfVYBUZVBx2CwkDMucCBQWu/w0J1X7SHJjVUgpIjg5XdZwn7KJxx6A78ML4F0B1/J8nQvkNang96lrqkBKVgrGpY1X1DgSL7gsJauu28BGM1WWekD6PH37/oaRz1KIrOMCv1mqJi0P0bbfBEsfTKDXAisV6NYKUWgHFzm3wtmL03bgRvV55BX03bsTgbcWK56TIQ0JRoKKihIdERuDCL3/lroiqWLQIlrg4/nJ1ikJIamrQigzKubdGxDRuFJA5IAFxkcJWaVxkKDIHJCg6jhyNFJKyXhK0ynsJBt0XEnac30E0TqnQYbB1FfeFRCOIr8xc6Bx7iJSBSx3nCbsYJ/1mfqdon92Ohq+/BmULR/T029yfsxihm7RWRoQnckMzsgTiRJDtIekwTnq9vBwJv5zjX/7f8T3T2OT1cXt1NWi73e3F4NrGaO04pOjxdJWwmxmW0hi1+oJL7aTtmZysBC3zXozUHVwOTtqJf575J9FYJdcx2KvLAPHu6wwYMALhH75zZHVuhJKKpejc+NKwbRtq3lrr56J3Vlej4etC9HptDULiEwzV5gDQvhFkIJKX+SDJNbLGxgI2G5x2e+fcPEJiMdnZ6PnEE6j76C9ovXABob17o27jRu6E5A6jxr1PjzFqhNnURmpisJHurRJM40YBJAnFdRITiln4kiqlLF5yk5MB/fJejKz7IsaB6gO8uVCexNviFV3HrlBdBghXWE3rNw0ffv+h6D58z9FioTDx3iEofPco7zajBjpwtbRUsuFBkntQvWIlBm8rNoRBoyd6Jy8LQZJrlPriMkRPnQpHSSlOV1chfd06xGSO9bpvlrAwd7l3494SXBKqtGIYOO12pP95AyiL1XDGLYucxGAj3VslmMaNArRKKFYzcdTTO7Lj/A7888w/RRdkpQJ9weqJkQqpMXHHwDsUXQO1q8sCeY/4vHUHqg8QGTdc5zhoZDJyHx6KXR+f9PLg2NrqMeT4xwjZeRjnIVLGykF3KfmVg57JyySQJixHjhkNFBSIGiGkIRfn5VrE3nG7sslrhNzEYKPdW7mYxo0CtEgo1qKsmPWOjE0di6fGPOW1sNQ112FV6SpZartcczdaNY+WkBoTk/tOVnQcNavLjHCPuLx1Ss9x0MhkDBjeExUn7aj59z40rn8LcfaToDz2JVU9tqvkHmiFlhVQcucjq6M1B10hNKPEOFd0b2knULbH9d9le4CBNwEBeME1jRsFZA5IQFpsOCrrmzmlySgAqbHhxAnFepQVcy0sU/tOVfwmT2KUBXN+DRd6lbSL5asAZF42JYaz1t4eNc7RYqHQa3AMmh5ejjA7x4+6RPXYrrDAaY2aBoUaqJVr1BVCM0qNc1n39thmoDAfuFILDH8P+OhuoEcCkLsSyJgp5zRkYxo3CrBaKCyZkYFHNh3wSxxm/14yIwNWQtn3QCWOKs17ITHKlu1ehhUhXcuro5bRQYLSnlZKDOedF3Zi5f6Vmt87pecIqBtK6goLnB5onbwcCLpCaEYN41zSvT22GfjkAQAMYPGIVjgqXJ/f84GuBo5p3Cgkd2ga3rlvFJZu/g51jZ25NSkxNiyd+SPkDk0j3lewJo6SGGX2VjvQ6v25Fgq+eqPGgizlWHK9X0oM52d3PYtmeOeNaXXvlFbQqRlK6goLnIl8jBZ2k4quxjntdHlsOGMYDAAKKFwEXHe7biGqgBs3a9euxerVq1FZWYnhw4fjzTffRGYmv6Vot9vx29/+Fl988QVqa2vRr18/vP7665g+fbqOs+aCz3dDTrC2JZBrbJGG2nxDIsPih4mOMUKSrFZtEeR42eQYzqymjN7d25V4EtUOJQX7AmeiDD3CbsTNKSWiq3FethtwlAsMYADHRde4AROVH4+AgBo3H3/8MfLy8rBu3TqMGzcOr7/+OnJycnD8+HEkJyf7jW9tbcW0adOQnJyMzz77DL1790ZZWRni4uL0n3wHhUcr8MimA2AA2DyekSpHMx7ZdADv3DeK2HsTrG0JlBhbYqE2rgTYPpF9MC9snuAYIyTJGgk5hvPhS4cFxxpRX0eLt1Wj5ZWY6IuWYTfJzSkloptxfoVQaoR0nAoE1LhZs2YN5s6di4ceeggAsG7dOnz11VfYsGEDFi1a5Dd+w4YNqK2txe7duxEa6lIG7t+/v+AxWlpa0NLSWR7qcDgAAG1tbWhrI+83w4WTZvDyV98hzOr6EbVZvP+XAvDyV99h0pBE4ryb/NH5eHbXswDAmcOxcPRC0E4atJNWNHc1GRY/DH0i+6CmqUZ2J/Pqhmq0JXrfj50XduLZXc+CAQMbOhVmHU0OIAzYcW4HKCvFOaa+qR6Ldy4GM5HBpPRJsubUlRC7RxQot1eM/Xdx6YrLixMG4dYFXPcukCQuXoTy/I7fD6631cWL0E7TAC3t31DYqJHuKyF1e8bpxNWDh9BeU4OQpCREjBzhNo7Y663098hEHCNd64bt213PKcMAts7fLqfdjvML89GLYRA9ZYri40RMnox+t9zC+fxxXQehZ5UXW6JXnk1bx3+3WcL9xym49lLuG8UIyYJqSGtrKyIjI/HZZ5/hJz/5ifvz2bNnw2634x//+IffNtOnT0dCQgIiIyPxj3/8Az179sSsWbOQn58PK8/FX7p0KZYtW+b3+UcffYTIyEjVzsfExMTExMREO5qamjBr1izU19cjJiZGcGzAPDc1NTVwOp1I8WnwlpKSgv/973+c25w5cwbbt2/H//t//w8FBQU4deoUHn30UbS1tWHJkiWc2yxevBh5eZ0tCBwOB9LT05GdnS16ccQoOFKBhZ//1/23zcLgpTE0nt9nQQvd6alZdecNmD6MPLEYcOU7HL50GDVXa5AUkYThPYfrkkOy88JOrNm/xiv3omdkT+SNzhP1gHBuG9ETLXQLGloaBD0GX8z8wuv8DlQdwGPbHuM8ThjCkB+Xj5X2lWj1zVLmYO3UtRiVYqxQXqDgukfJkclYMHqB3/1taW3BtuJtWGVfhRb4tzfgu3eB4Ox/L2H3F6fRVN/5PETGhmL0DRb0irSTv4HC9UZd/eoaL+n9kJQUJD+VJ/lN2uvt3BO2r9HKFQifOBFbt27FtGnT3B5pE/kI3T8511qWJ0OEpn37cWHePNFx6evW6VaNR/Ks8j7/O1cCe950/9lmCcfWYX/AtCOPI5T2KEYY/xtgUr7sObKRFxICnlAsBZqmkZycjPfeew9WqxWjR4/GxYsXsXr1al7jxmazwWbzb5oXGhqq+IckKToSLU7/cFMLTXl9nhQdKflYoQjFuD7jFM1PKsVlxcjb5d+L6oemH5C3Kw+vTXpNMIdl2sBpmNJ/ildi7fCk4dhwdAPWHl7rN54NteVl5iHc5u2+vNx6mXNB9aQVraJj2H2Zi4YLrnsklvzc2vF/XGFSrnunN6cPVmPrevaFqPPfXePldvxrB5D7cCYGjfTP4ePCUVSEqicXAAwDzyvCXLiAqicXIERCU0zG6cTll1fA2syjUE5RuPzyCvS79VYA6vwmdXfE7l/K668BIL/WmuXEXL4Ma4v4bxcu6/PbRfqsxmdlcRt2jjKA9t82lG72Nm4cZYCC85FyLQLWFTwpKQlWqxVVPv07qqqqkJqayrlNWloarrnmGq8Q1PXXX4/Kykq0toq/wasOaUGUWt0zNcRJO7F0z1LBMcv2LBPtPM0m1k4fOB31LfWY/rfpnIYNINwBXM2KMKNVlwUaz3s0NnWsqNdl+cTlhu3eTtMMdmzi9vSy7Nx0HDTt/TbK1SVZVK4eQNXylwU7KntCqrlz9eAhov2ZCENy/6pfXUO8P7Yvk+89ZJWuHUVFsudqNIFIKfpQnJDmn0nMc1NCwDw3YWFhGD16NLZt2+bOuaFpGtu2bcP8+fM5t7npppvw0UcfgaZpWDra0584cQJpaWkICxNOetSCmisElreEcYGktLIU9S31gmPsLXaUVpbixl43iu6PTw2X5bERj2HusLm8C6tY5RjgMlpamVZcunqJd0xcWJzhqsuCjUnpkyR7e/Ti4ok6tDS2C45pbmzDxRN1SL/OpRTO9zYed/ddqvaSItbcqakhGmciDNECLdQM03OozL5MpARSIJKr9FyxPpSF0E9COk4FAua5AYC8vDysX78eGzduxPfff49HHnkEjY2N7uqpBx54AIsXL3aPf+SRR1BbW4snnngCJ06cwFdffYXly5fjsce4czO0RoveUoGitKpUtXFCariAK6Tx+YnPBffBqv+y4323B4C80XlYPG6xYIWWvdWOHRd2iM7ZRBip3h69KD8u3pXdc5zQ23jNm28R7Yt0ISB+O09KIhpnIoyaPb4UezJEYDVoXH/4uPY1FIh0FBXh1NQsnJ89G+VPP43zs2fj1NQstJaVEW3P+0zH9iabAOk4FQiocXPvvffilVdewQsvvIARI0bg0KFDKCwsdCcZnz9/HhUVFe7x6enp2LJlC0pLS3HDDTfg8ccfxxNPPMFZNq4Ho/vFQ6zC20K5xhke0po5gnFS1HCFYNV/fUMibJhpUvokTE6fjFhbLO8+WKE5vnCak3aitLIUBWcKUFpZKhp2MzEWDGHIl6HIwhYkkBot7Nu53+LFQlEISU1FxMgRxMc24UfNEI4eTVNjsrPR+43XEeJTVBOSkoLeEnK7SBE07N96C5a4ONFnldeTFJFINgnScSoQ8ITi+fPn84ahdu7c6ffZ+PHj8e2332o8KzL2l9WBFvlNpBnXuPGD9LupcshMy8R7R94jGieGmm0kuNR/h8UPw5bCLQBchpRQOE1IaM4I4n9cBFJt2XceAFB0rgjJ0cmGCUV50mdIPPZD/K2zz5B48bdxMSSGCsz2DfpCGuohQa+cGL0EIknCbJTHf0t+VnsQXgfScSoQUM9NsFPdwJNZLnNcIBmTMgaxYfweEMCVvzImZYzovtRuIyEUEpFrSLE5Qb4eJrZnUnFZMdF+1aa4rBg5n+dgzpY5yN+Vjzlb5iDn8xzd51NcVoyfbv4pAGDJ7iUBm4cYva6Nhy1S+B0tPCoEva6NVyVsIdUY0fvtvDtDEupJfsq/GpQLUq+bGjkxrAJy7B23I2pcpmzDhitJnoUkzOa025H0m/nyntWmy2STJB2nAqZxo4CulHNjtVixdMJSwTFLJiwhenNnk4F9c2VYKFBIjUxVJdGX1EA67zjv/m+xDtkABENZWmEUg4udh69BGGjDjwuLhcLk+68THDPpvutgsVCK37KT5s8X/IHnW1xisrMxeFsx+m7ciF6vvIK+Gzdi8LZi977YcY7CLX6Lkok0xIxJUp2iQOXEyIUvl4at6CI17MP69Rd8VnmJIvy3RTpOBUzjRgGZAxKQFhvOW+lNAUiLDUfmgAQ9pyWbrH5ZeG3Sa0iO8Cn7jUgR1bjxhCQZOD8zX5UQh5ghxbL28Fr3oqxWTpCaGMXgMso8pDBoZDJyHx6KyFjvismouDDkPjzUrXEj+jYuQli/frzfiS0ufG/njqIinJn5YwBAxXPP+W1nIh0xY1LKfoLB60ZSsi4lzCbLkxRNKFJLOk4FAp5zE8xYLRSWzMjAI5sO8PYEXzIjg7ivlBFQq8M1mwzMldOSn5mvWk4La0jl7RR2N3t2sFYzJ0gtpBhcWjapNMo8pDJoZDL6DUvC0R0XcPlYGSLRhIwxkYi5oTPXTTAHhgC+BYJdXHz3xy4u4FkI2e2cPjIWYtuZiKNWs0ujN00lLVkfVLRF29LzfhOAmF7CncFjervG6YRp3Cgkd2ga3rlvFJZ9eQy1V666P0+NDceSGRnEHcGNhFodrtUylEiO8+iIR7H2ELdYIOC9KKudE0SKUKKwUQwuo8xDKqcPVuNfHxxB01X2RSIM3x28iOte3ogbHv+p20jg65IMi4VfYEzgh1+uHorWOiom6qHUUOLSlVHrnkoRihRLbo+7+244vi6UN0eLFchdCXzyAMeXHf8mc1e4xumEadyoQO7QNEzLSMW3p6pR8/232DB7LG4cnBxUHhutUMtQEqNvdF+icZeaLiGnf46gQCAFCimRKaqK/4lVZgXK4JK7fyOpPp8+WI3Cd4+4ZAo8/sm12OJwuPddcL70R4wEvAwc37fx9rpalC/o8P5JqBSRoofiuUDK3c7EmPAZMJq1b+hASsl67B23cxr21thYMABq3uzsDSVrjhkzgXs+AArzgSu1nZ/H9HIZNhkzyfelAqZxoxJWC4XMAQko+N6Vi6OnYWOU0uFAzkfKouwZyqJAcfZMUisnCOBXa2YTdNdMWoPJ6ZN1N7i48FSG5kKveZBC0wx2fXyiw7DhSPxkGJwcdCfSlq/w8oJwvY1TFov/QpSSIvgjL1cPRQ8dFRN94DNgYm6fjtoNf5YcrpSCNZEsn5MNqfoa9q1l5zjFK2XPMWMmcN3twJn/AN/VAbM+BQbepKvHhsU0boIco2m1BGo+Yu0afBdlvXKCxBJ0PXOB9DS4+PA1/DzRcx6kVJy0o9HeKliy2xKegJrmHugt4gWRk18hVw/FaL2FTPgRCivx5ltVVqL2Txt4dqhO2NFRVITK3y8XHsQRUmUNe8bpxKmpPL9zSuZosQL9xgPfFbj+N0C/FaZxoxJOmkHJWZcrruRsrS5hKRKPgJ4GTiDnI8cbI5QTpJb3SUqCrl4GlxjsPF4tedXrc73nQUKjg6xvW0tYDJEXRGp+hdweQV7bcU5Eu95C3QUuo0QqQmGl6KlT+fOmRCenLOzIZ1R5oVFINVgwjRsVKDxa4U4oXpUJzNlYioQeEZomFEvxCOjxlm2E+cgxDrhygtT0PklN0NUrCVuMrH5ZuDn1Zmwp3IJlE5YZVqE4KsZGNM7W6tDECyJXhdhvO68vjaejEmzwGSWJi8lb9YhVwSXNn69M8Rrywo6CyegeaBVSDRZM40YhhUcr8MimA2AA2Dx+hyrrm/HIpgN4575Rmhg4apbsquGlMEoJsVLjQG3vk5wEXb2SsMVgr1l2/2yEhoYGeDbcpA2Jgy0qBC1X2rhDUwyD0LZGJIVf0cwLwleBJba4sNuVv+LtIRPbzkQYIaOkPH8RsGyp6D5IqtlqP/xQ8VzlGNykbUTSXn4ZPcbfqPjYwRoaNY0bBThpBsu+PMbZS5It3Fj25TFMy0hVPUSlVsmuWl4KI5UQyzUOtPA+Sc0FkoPREsr1xtlGAwL/vJyUFcmLF2nqBZGrhxKTnY3wW27B8S1bkPa73yE8OdlQOirBBmlzVMbpBAQMdpKQDW23y5+ogrAjqSfFeVm41YHckGqwYCoUK6DkbC0q6vn7RjEAKuqb3bk4aqJGya6acv/BWELsixbKxVqrNRulF1WgKD9eh/ZWGrzWDUWBDo3Alb7iPdGUIrdHEDsuJjdHUW8hEzKjBACuHjwkuB9SA8ISGyuueK1y2FEtj0uwtZiQimncKCCQjTOV9m9SW2Zfz35SWqGV94nNBUqO9GlrEZmiKMnaKL2oAskPJ+tUHSeEUGNCE28Cda2I80hqagS/JzUgEh643/UfXMYBRSHhl3O42ze8tgbW2DhZ10fNpp7B0mJCDmZYSgGBbJypVKtF7RwZvbVjtEBL75PaicJGSOA2AhRhoQrpOC4YpxM169ah9oMPQdfXuz+3xMcjdckLiM3Nlb/zLojWwnVCEHs1kpIEvycN2STNmwfbkCGC+VbJeXl+gpFVK1bKvj5yk9j5MHqLCbmYnhsFBLpxphKPgBZeCq08FHqhtfeJzQWaPnA6xqaOVWR0GLH5ZyDodW28quN8cRQV4cRNN6Pmzbe8DBsAoOvqUP7kAlStXi1r310RkiaOWkLi1QCAiJEjBPcjJWQj1qjTM1zprLejfEGe//WprMTFx59AfWEh0Xmq7XGRG1I1MqbnRgFGaJwp1yOglZfCKKXMcggm75ORErgDSe9r4hFqs6Kthd+tH2qzovc10o0bIi0RALV/2oCIYcMQ0809OKT9snpMmoSrBw9p4iUg8Wqw48SQUgVHoo9EUsJdnvcUKIDoWTKsx4V2AmV7XP9dtsdUKA5W2MaZSzcfQ11jYBpnyqkO0rKKxyilzHIwipCeGF0hgVstGFERNekxKVItEZbKF19C9LRpgV9YAgipKNzJWyeBruvMgVI7ZCVolCxehNPN5DmQahoQRCXcNI2LTy4A/mAhDlEZSmDv2ObO3lLD3wM+uhvokeBqqmnk3lKHDx/Gl19+iYSEBNxzzz1I8ohbOhwOPPnkk9iwgUdyuovDMN4dhWm+DsMGIZi8FHoTDN4nPUrMg4HOail+2lpolB+vQ5/rycPDpFoiLM7a2qBVclUL0mReT8MGULfXEgufUdJO00BBgaR9qWVASBHDC8qO8Mc2d3QFZwCLR56po8L1+T0f6GrgEOfcFBUVITMzE3/961+xcuVKXHfdddixY4f7+6tXr2Ljxo2aTNLIFB6twLxNB1DV0Or1eVVDK+ZtOoDCoxUBmpk4wZ4joyVq5sdogdYl5sGClGopKRU8clRZg1XJVS1ki711eMeqlr+salWV0fJIWsvOEY9l2x4EDbTT5bHhVX0DULjINU4niD03S5cuxdNPP43f//73YBgGq1evxsyZM/Hpp58it5vGmp00g0VfHBEcs+iLI5qI+ElBSOQtGLwURsQIwnnBEkLTEtIqqJbTZ3Fq6q+IK1TkLNTBquSqFqIVRkIEUR8joUaaQtvUffKppOMElbFcthtwlAsMYADHRde4ARN1mRKxcfPdd9/hww65aYqisHDhQvTp0wd33XUX/vrXv2Ls2ODMsVDCt6cvw97UJjjG3tSGb09fxk1DhEsPtYJEgTiYc2QCgdqdz5UYSoE2TrUw8qTss9e18cDXZaL7DPn4TbTbuSt4uMIhUhdqUl2RroxgMi8hRl/Q5Za5N+3bDydfk1QegspYvkJ4bqTjVIDYuLHZbLD7yE3PmjULFosF9957L1599VXuDbswe84IC0F5jguEcWO0ruFdAbWvqRqGkhTjVE1jRG0jT84+SaqlrM4WxNtP+n/hUcHjm98gaaGmqKBWclUTvmRea0ICnLXiSu1GXtDFGmkK5QxJMtqCse1BjxTxMVLGqQBxzs2IESO8cmxYfv7zn+OPf/wjHn/8cVUnFhyQhpr0D0mprUBsov411VthWM1WDVrMXe4+LVbhf1+Us5X/S49wiC98WiKehKSmBr2Sq9pw6r7s3CGsPwNXKwOGduqmZiyWg+X5/ZU936Lq98v5y9wZBpVLl4Fu5X7WpBptWhnLmilH95sAxPQSHhPT2zVOJ4g9N4888gj+9a9/cX73i1/8AgzDYP369apNLBgYPygRb+04RTROb9RWIDZCjkmgUbsTu54Kw2p6nLSYu9x9Vpy0o6WpXXDf7WHRsMcN5vbesGN43qx9q26siYkAGDgv1xpHV8SAcFUYiXnC6Pp6XHhoji5qxg3bt+Pyyyt4w0tc4ScxnLW1OHnrJKQtWyo7zKnluWuqHG2xAkPvAnb/gX/M0Dt11bsh9tz89Kc/xWuvvcb7/axZs7w8O3/5y1/Q2NiobHYG58aBiYiL5O8sCwDxkaG4caD+xo2aIm/dvTkji9xr6qSdKK0sRcGZApRWlroNRb0UhtX2OGkxd7n7bHS0EO2/JSxG8HuhN2vPqpse429Ej/HjDVOBE0yQeMIAfdSMy/MX8aooV61ezamyTAJdV8c5d0HF4w6SfjPfS9lYTTRXjqadwNHPhMcc/VzXainN2i88/PDDqJKYQBVsWC0UVvxsmOCYl382LCCVUmqJvJnNGTuRc035DMMd5/1DvFyooTCstjGihTqy3H1GxdiItrO1NnB/IaHJoJEI1iaebMgq/c9/dnXU5kKj0nAAnfvjCy8BqP3z+7KSoT3hmjtvy4TUVPT+wxvo+dhjmoWiBJWjeeYrCdFqKXRWS+mEZgrF4qqhJlqihshbV2zOqCS8JvWaCoWCPvz+Q6JjqqEwrLYxooU6stx9pg2JQ1ScDY12fg9OZASDuPpTqjQZNAKBbEypBpTVCspi8evV5YVGpeFXDx4SHtCRP6MIgbkHomUCqXK0omttwGops3GmApw0g2VfHuP9ngKw7MtjcNL6G3pqiLx1teaMSsNrUq4piWHI16CT3Z+SJp2eqG2MaNFgVO4+LRYKE+8dIrjvWx4Yhj5vvKZak8FAwTiduLT2bVx8/ImANaZUC9LqIbVLw9tryCpcVTkWz9z1FhfU5VoHc7WUiT8lZ2tRUc/fp4QBUFHfjJKz4iWQWqBUgbgrNWdUK7xGek1JDEMuw8fze7UUhtU2RrRQR1ayz0Ejk5H78FBExXmHqHrE25D78FAMGpks2rnZ6DiKinByylTUvPkm9wANQzlaQFo9pHZpeEiSfpIcRilr1+Vau6ul+F7YKONWS5n4U91A1oCNdJxUSEIsSkTeukpzRrXDayTXVKnBFxcWh8npkxXtg0WLPmJaqCMr2eegkckYMLwnKk7a0ehoQVSMDWlD4mDxyHczXJNBQki7kweTyq9o9ZBGWi8RI0cAW7bwl6SznysJTRlMp0aXa22xuppjfvIA/A2cjr9zV+haLWUaNwpIjg4XHyRhnBSkiJ3JVSDuKs0Z1S6LB8SvqVKDz95qlzQfMbQyRtRWR1ayT4uFQu9r42UfOxCwUv6AKzciJnOsV5hCandywPgqv4CISKKGuVBe++M5bvRtuWgo+FrRcYySx8U+X9E52ajb+IH/ADWvdcZMV3NMtis4S0wvl2Gjc1dwyWEpLiE/lnfffdf93/369UNoqHCZdLCTOSBBtBQ8LjIUmQPIuxGToFcFU1dpzhiI8JpYKEjv+QAuw6HgpwVYOHYhfnHtL7Bw7EJ89dOvFKlUa9FgVM19GrmqyFFUhFNTs3Bh3jwAwIV583BqapZX3ozU7uSAccIhYvBWD+mQC9Vr5Qre4/ZevRqWuDh5O7ZY0Pu1NYYId7LP1/nZszsNG4v3kq/6tc6YCTx5FJjV0Udr1qfAk0d0N2wAGZ6b3NxcPP7441i+fLnbeKmpqcFDDz2Ef//733j44YcBAEePHlV3pgalrZ0W/t4p/D0LaRWP3hVMXaE5YyDCa0KhIFLUDvdxefs2frdRUbsEIyOnqkhOU0S5c3OHmmyduUK+Uv5dXbY/ENVDABA9ZQris7J4j5v24jKyUKAvNA1rvPSXWbWfO95QZsff8bNnI3rKFG2utcUK9BsPfFfg+t8AvfxKNm527NiBBx54AFu3bsVHH32Es2fP4pe//CWuvfZaHDp0SIMpGpdvz1xGY6vwm2BjixPfnrmMmwbzJ7JJCTFpEWIRQ+/mjGqrIQcqvCZkGDa3N8PR6tBtPt2tz5icPkB6lViL6o549Lsyimy/VKQs1oHKhRI6Ll+PLBKkhgXVfu5Inq+GLVuQsvAZQzwrWiHZuJkwYQIOHTqEefPmYdSoUaBpGi+99BIWLlwISqBvSFfkP6fIygr/c6qG17iRuugEqoJJr87hWnXczu6XjQ+//1C1hFpS+AzDHRd2qJrgK0RX1CsSQorxwP64K2mKKBUpuiNGkO3nnKKA8RLsOjwsvl6l9poaVK9YIbqdFINUrefO836019Ror2sTBMhKKD5x4gT27duHPn36oLy8HMePH0dTUxOioqLUnp+hKbdfVTROzqLTVSqYuNCj4zZFUV4Ck/Hh8fjtuN9q6rXgMgz1DPcFwtsXSKSKltGtrahYslSSMaQEKbojJN3Jk34zH0nz5un2Fi5kvADQzUjUA0/vDuN0ovb990WrjiJGjkDj3hJRr5UcI5wLOX2wgOBIPFeC5ITiFStWYPz48Zg2bRqOHj2KkpISHDx4EDfccAP27NmjxRwNS++4CEXj5IjkaSGgZgT06rhNM945ULXNtVhVuiogbSSy+mVhy51bsCFnA1ZOXIkNORtQeGeh6oZWV9IrIkGK8eAoKsKpWyeBrqvjHyjQOVwOUnVHAiXbz4Vgj6LHn0DFC0u0lfkPIIL9oTr+jrl9Ok5n5+D87Nkof/ppnJ892y9JnEWKEc4H3/0gIVgSz+Ui2bh544038Pe//x1vvvkmwsPDMXToUJSUlOBnP/sZJk2apMEUjcsEgTwaknFyFp2uUsHki5pqyEKGEheB7JNFWhnE1XyTlK7s7fOEphlcPF6H8w1xqIsbAkakUq217BwuPvEknEKGjQdqvemyoSYhrRXffldGECEk6VFE2+0CO1DXSAwEQhVeCXMeQu2GPxOrRytVDpYjEwAgaPupSUVyWOrIkSNI8lF5DA0NxerVq3HHHXeoNrFgYGz/BD5PsRuKco3jQu6i0xUqmHyRZOiJNFkXM5R8MXreidI8pK6iVyTE6YPV2PXxyc4eUyOehK25DkNOfYrkmsPegzvCB3WffCppYVDrTdcv1OQzN4A7MTjQIoRyytK5CPZwCFeFV8TIETidnSMpxKRUOVjW/QjSfmpykOy58TVsPLn11lsVTSbY2F9WRyIaiv1l3G+GSkJMeoU09EJN74Kc8IpR+2SpoWnUVb19LKcPVqPw3aN+zTNbbHE4+qO5qE4a3vlhx4973N13w1lFaABr8KYbSI0XuahllHSFcIhvf6irBw9JDjHJ8eB5Iud+GPn5UhtToVgBStsvKJXF16uCSQ+keBdoEe0gJeEVI+WdkOQhrdi7gsjb1BW9fYArFLXr45PcX3a4VU8Ovgs9a/4LCgxCUlKQ8uxiMK1tko6jxZsu6wFwlJTidHUV0tet81MoNhKKjZIg1OEhRU6ISalKM+n9SF60CCFJSbppCBkF07hRgBrtF7rqoiMVKYaemHEjZigJYaS8E5LwWtXVKqw/sh7zhs8T3Z/eekV6UHHS7uex8YKi0BKeAOuiV9Hn+kT3j3vj3hKi/Vvi45G2bKlmb7qU1epa7AsKDL/wkJalc9LFwyFyQ0x8ejqsES703JH2jEq4/74uec3FMI0bBWQOSEBabDgq65s5l1AKQGpsuGj7ha646MhBLUNPjjqwEfNOSL1Iaw+txeC4wUTXpyt5+wCg0SFg2HhA/Wgkosamuv8mWaitCQkYvHMHLGFhqsw12PHyNEiEZLHWGzVVgZU0p5Si0uw755RF+bi4IE/X/lzBgmncKMBqobBkRgYe2XSArw8qlszIgNUiXLXh2lfXWnTkopahx2cocWHUvBMpXiSjJkNrTVSMTXwQxziSkEDq0iWmYeMD62moWLJUuHy+g8R58xA1frzhvFIN27fj8ssrVBMaVBpiIkkW59MXSpjzEBxfFUj2/HR1TONGIblD0/DOfaOw7MtjqL3SKdaXGhuOJTMykDs0LYCzC07UMvRYQ2n9kfXYdGwT6lvrOccZNQTIhtdIKr+6kgifFNKGxCEqziYYmuoRb0PakDi/z5WEBEjQq0+V3sRkZ6PHpEk4desk/jL6Dk9Fz9/MN+Q5l+cvgrXZOxdSqdAgyfMk95kQUjKu3fBn9HptDULiE7rcs6YE07hRgdyhaZhyXQo27T4N1B1Dfs61uG/CIISFcBejqd07yYSfHRd24O1Db/OGph4b/hjm3jBX1+tPev/Z8NqCnQuI9mukZGi9sFgoTLx3CArf5W/Ue/M9Q2Dh8Z5q1bixq7Qg4MMSFobUZUs7Q1RBEhJxCwhqpEYt9DzJfSZIlIyrV6zE4G3FhrvegcQ0blSg8GiF23OzKhNYueU41v/nPKfnRu3eSSb8iIn5UaDw+cnPMfeGubrNSer9z+qXhceGP4a1h9eK7ttIydB6MmhkMnIfHop//fUEmupb3Z9HxYVh4r3XYNDIZMHt1daP0bNPVSDR2vOlBVcPHhIeoELfJa7nSckzIbWdiIkLyTo3Jt4UHq3AI5sOoKLe28VZWd+MRzYdQOHRCvdnamiWmJCjpuqxGsi9/3NvmIuUyBTO74DgbbmhFE/V5lN1pzjkQvRv5Eui4hvMLQh8MYJyshTaa8iaHQuVdjNOJxr3lqD+n1+hcW+J6L1U+kwoVTLurpjGjQKcNINlXx7j8AvQsESeRkjMITy/5R9obW9XvXdS5xzky/J3dYzUU0nJ/WfDU1TH/3li1GRorSkuK0bO5zmYs2UO1v39/3Dyk6u44pN302hvQeG7R3H6YLVu81KjX1Cw4StoZ+TQSIiACK0n1sRETgPGUVSEU1OziHpHsSh9JpQqGXdXzLCUAkrO1vp5bAAgauDraAtxLZjNALI+/QSzMu6R3JlZLDdDrxBXsOYIGamnktLO3KYeUiee3eMphsKtZ+4F4K++zLJz03EMGN6TN+9GTcy3bGMTMXIEsGWLoCqwJTYWFYsWucq6OwhJTUXM7dNRu+HPkkNLSp8JJWXm3RnTuFGAr/JwSI/vAVwDyurw+ryu9RLWHhLPmQA6vQhihovnD7zXnDpCHGsmrVFlwQvmHCEj9VRSw4tk6iH5e8DS6gcjvL2H4DbNjW24eKIO6dcJ6035IqeyxXzLNjZe94+rZJthQNvt8JUJba+qQu2fNnDvVCQRWekzobTMvLtihqUU4K08TMOW/DUA/pcCEnpG9hTNzSg6V6RJiMuXYM8R0qKnktwwoFpeJNIu4l2V0spSr+ext2Mw0Xblx8k6f7PICT8AyvsFmehDr5Ur/Pp6WZOTYYmL496AoIkgX2hJjWciqHqR0U6gbI/rv8v2uP4OAKbnRgGZAxIQFxkKe1MbrJFnYQlxiG/EA+tFGJ40HNP/Np3XcKFA4fd7f4/a5lrefYmFOEgQyxExchdtT9QM5yjxYhnJixSsFJcVY8nuJbK2ZSS8cCipbDHfsoOD6ClTEJ+V5eWZY2gnLjw0R9F+uUJLaj0TWskWqMqxzUBhPnClFhj+HvDR3UCPBCB3JZAxU9epmMaNSlAhDeRjBXonHa45LJqbIWTYeKIkUVZpjoiRkBrO4cox2nFhh6IwoNImqWoQrLlTAHjDsBdjTmH0RfHt+wyJB93airqP/oLWCxcQlp6O+Fm/8FMgJtEUEdNBCcYS6e6Ib8l2/T+/UrxPvtCSWs+E2rIFqnJsM/DJAwAYwOIR1XBUuD6/5wNdDRzTuFFAydla2Jtc3YWZ9miibR4b/hg+O/kZrxeh4EyBavPTozt2sAjHeaoeCy3yfN6Z5vZmxV4srZOC5ZxXMOROCXkRK2JP4WrIFYS3R/EmFIdHhSDkyz/h+PvvA3RnNkX1qlVIeOhBpDzzjPsztTRFguIt28QLRXlQBEm9XfqZoJ0ujw2nphgDgAIKFwHX3Q7o9EJlCONm7dq1WL16NSorKzF8+HC8+eabyMwUt07/+te/4he/+AV+/OMf4+9//7v2E/XBM6HY2TQAdHsM71g27DD3hrmYe8Nc3kWI1CCJt8XD3mLXLMRhpEojNRFa5AFwegfE2h9I8WJplRQs57zUTj7XCiEvIkMx+NfAj5F9Yo7b0PRlZI/jqNvAkQxK0+4kUdbAUVLZwjidaCwpRdPevQCAyHGZiMo0dmm0SSeyu55LCC0Z2vOihLLdgKNcYAADOC66xg2YqMuUAm7cfPzxx8jLy8O6deswbtw4vP7668jJycHx48eRnMyvLHru3Dk8/fTTmDhRnwvFhXdCsQUt1bcBSR3/LjheIj3DDnyLIGluxjNjn8HT3zytWYijK+aIiFWYxYTFEHUQ54PUi6V2k1S55xUsuVNi1/Vs4n9RdM0G3HzuLkS1xro/j4oLw813DkTb7N8Ibl/75/fR84knYAkLk13Z4igqQsULS0Db7e7PLq9bB0tcHNJeXGaGooIAktwYs0klD1fE+99JGqcCAa+WWrNmDebOnYuHHnoIGRkZWLduHSIjI7GB602rA6fTif/3//4fli1bhoEDB+o4W28yByQgLTbcbce0X7keAMA4vT04KZGpxG/HpBU+2f2zsWbSGiRHehuAKZEpqryJa1FpFEjEEqQZMLyNNUlJjEhUtL0clJ6X3irNciDxDp5N/C9sD5zHdbMjMPWh6/GTBSPxwPKbEP/dVq9QFCc0jbqP/gJAXmWLo6gIFx9/wsuwce/absfFx58QrbIyMQZiVUkpzzwTVIrMutGDX0Fd1jgVCKjnprW1Ffv378fixYvdn1ksFmRlZWHPnj2827344otITk7GL3/5S+zatUvwGC0tLWhp6VQudThcFU1tbW1oa2tTeAbAC7dfiwUfHwIAhFlcC0z7uSdA286DCrmCRyeOwJwxrrdi0uPd2utWvDrxVazZv8brrTU5MhkLRi/Arb1uRVtbG27tdStunnkzDl86jJqrNUiKSMLwnsMlHUuNeegNe0wpxz5QdQD2JjtssGk1LSz991Lkjc7DpPRJmh3DF7XOq7qhGm2J3tdTznXWgmHxw9Ansg9qmmoEPWsffvchgA/RM7In8nrmIdk5CVcvXoTTJn5trl686D7PxMWLUJ7vMuw5K1sWL0I7TQM0DcbpxMXVr4geo/yVVxF+yy2cYQujXOfuAMm1jpg8Gf1uuQVXDx5Ce00NQpKSEDFyBChr5+9q2KiRYFPR2WehW9NrLBA7AGioBMCgrSOhuM2dWEwB0WmucQqecyn/RiiGkRJcVJfy8nL07t0bu3fvxvjx492fL1y4EN988w32dsSuPfn3v/+Nn//85zh06BCSkpLw4IMPwm638+bcLF26FMuWLfP7/KOPPkJkZKRq52JiYmJiYmKiHU1NTZg1axbq6+sRE8Of4woYIOdGCg0NDbj//vuxfv16JBH2CFm8eDHy8vLcfzscDqSnpyM7O1v04kihtZ3GJyVnkWA/jtq4a3FP5gCEhQQ86tclaWtrw9atWzFt2jSEhoYSbXOg6gAe2/aYxjNzhex6RvbEFzO/0CVkp/S8hOYr5zpryc4LO/28iCz9an+EG8/PRFRbnPuz5rAG3Hb3SDgf/amkN+uQlBQkP5WHHrfeyvn27omjcAsqnnuOaL9pv/sdYnJz/D432nXuypjXWmO2/w4oeQ9tVBi2DvsDph15HKFMK5D5a2AK2b8TIdjICwkBNW6SkpJgtVpRVeWdZFRVVYXU1FS/8adPn8a5c+cwY8YM92d0x49WSEgIjh8/jkGDBnltY7PZYONwGYeGhqr2cBcercDSzd+hrrEZqzKBFUWn8O5/fsDSmT9C7tA0VY5h4o+Uezim1xjERcYJJkjH2mJhb7ErnteFpgs4UndEF/2fkakjEWmLRF0LtwKv53nxJZ/nZeYh3BbOuT2g7r8VJUwbOA1T+k/BgeoD+Lb8W7x35D0AwIDLN2DyiQcAAIxHflhYezS2bzyN8TMfQcTHa4iPw1y4gKonFyDkjdcRK5JLEZ6cDKtH2FtsrNB1NMp17g6Y11oDjm0G9rwBl86Na10OpZsRSre4Pk8frVjnRso9C6hrISwsDKNHj8a2bdvcn9E0jW3btnmFqViuu+46HDlyBIcOHXL//8yZMzF58mQcOnQI6enpek4fgMuwmbfpACod3j9wlY4WzNt0AIVHK3Sfk4k/JAnSS8YvwWPD1fHu6KH/U1xWjOl/my5o2ADA8zc+j8eGP4boMG8tJrWSz/WErTQbFOd6iaEYCjed+5nrvznvK4MjrRmInzMHsBD+3HVE6quWv+zuBs1H5JjRsKaIJ0maLRdMghXG6eTskO6FqM4N49K50bEVQ8DDUnl5eZg9ezbGjBmDzMxMvP7662hsbMRDDz0EAHjggQfQu3dvvPzyywgPD8fQoUO9to/r6AXi+7keOGkGi744Ijhm0RdHMC0jFVYdOhKbCEMiojc5fbKfyKIctNb/4Sv/9iQlMgW3DbgNq0pXeZ1PbFgs7su4D3OHzQ2aajdf2Oub5hiEHq3xAiMpXKlrgfPBX+HaJ59wKxSDpmH/y1/4NyMU66OsVqT+9llcfPwJwfmaLRe6H3IarxoNR1GRv6pyaqp/6buozg26n87Nvffei0uXLuGFF15AZWUlRowYgcLCQqR0vA2dP38eFtI3Lp359vRlt0IxH/amNnx7+jJuGkKWI2SiLWIiep5tEgBwhnFiwmLgaHUETP9HqPybJd4Wj6dGP4WFuxb6jXO0OvD2obcxOG5wUHltPGF1mCJrYsUHA2h0tMASFo/EB2cDcEntCxo3HZCI+sVkZwN/eMNP5wYArHFxSDV1brodxEaBgZHUY62BMEJBOk4FAm7cAMD8+fMxf/58zu927twpuO3777+v/oQI2XOmhnicadwYBzERPTEPD4CA9ogS6/sFAHUtdVhesjyoxfuEYI3Q1RVvE42PivHOu5Mr1scHK61vKhTrg5G9IkoarxoFyT3WGgnD8KTjVMAQxk3wQhpqMkNSSvDtmTQsfpjmxxTz8GjZI0oM0nwevlwcILgan/KR1S8LzAzg0GkHIlqieXtL9Yi3IW1InNdnolL7BL2C/DaxWtFj/I3oMf5GKadhIhEje0XUaLxqBCT3WIsiDMOTjlMB07hRwPhBiXhrxymicYEk2LtB+xoRfSL7YF7YPM2PLeTh0apHFAlq5vMES+NTPqYNyEL/BypRtP4Y3A36fLj5niGwWCi/t/3kRfkoX5DHK7UvlidD4j3wHRMxcoSrvNxjGxMXJNfT6F4RtRqvBhrJPdaiCauCScepgGncKODGgYmIiwwVzLuJjwzFjQMDZ9wEczdovqTZmqYaIMylezJt4DTi/alt5KndI4oUkr5fcbY4Qc8Ni1aJz3oa1J05efweUr63fbm9gki8B1xjYLF4ae6EpKYicfEi0lPtcrAGTcP27XBs3gxnXecz63s9g8EroqTxqpGQHLZNHwd0VCfyQ3WM0wfTuFGA1UJhxc+GYd4m/r48L/9sWMAqpcQaKgayDFhs8RPrmQQAr+1/DVP6TyFaNIPZyPPFM+mZL+/nuRufw6rSVQFpfKrntaZpBrs+Pik45l8fHMG4wgWgGG8hv/aqKtRu+DN6v7YG1vgE4vwNEu8BAM4xvmKC7VVVrlYPy5YKnkNXhNP488DXGxMMXhG1c7kCheSw7fk9EDZs4Pr+/B5g4K1qT5cTY5YhBRG5Q9Ow7r5RSI3xFkFLiw3HuvtGBUzEj8Q4WFmyEk4ddQdYisuKkfN5DuZsmYP8XfmYs2UOcj7PQXFZsXsMSdJsdVM1UcNH1sjz3R9r5HkeN1hgk575Gqdm988OSONTva91xUk7Gu3CInpNVynYYwf5f8Hq2axYicgxoxF7x+2IGiecACzqPYBLH6fy98u5x/Bsw+67u8AaiGLGCtCpNxQMXhE5jVeNCNsh3fWHz7lwhW3PCvd4dEM6TgVM40YFcoem4T+LpmDDbFeIYsPssfh3/pSAqhOLGQd6dIN20k6UVpai4EwBSitL4aSdxIsfaS6I2DgjG3lKyeqXhS13bsGGnA1YOXElNuRsQOGdhW7viJgBpLYXJRDXutFBpg7cEsbTasXjbZ8EUu+Bs0qCTlLHIn714CHybYIYQQPRb7DretZ+uAnWxASi/QfSKyLZKDAwYh3SvcK2BqytMcNSKmG1UMgckICC74HMAQkBF+1TyziQC19oorm9mag8mTQXRGycFCMvGKuGSMra9Up8DsS19i3x5sPWKtyTxvdtny+5VUuvQHsNmbREsCNqIHJQvWIFrCkpsMTFga6vV63CTQtisrOBN173z8kiyOUyGqzEgWjZfb+bAawW32G/mzWZJxemcdNFUcs4kANfro9YmMlz8RNLmgWA5Mhk0ZyRQBt5RkCvxOdAXOu0IXGwRYagpamdd0xIawPi7MJVjZ5v+0LJwlp6BUIImwEHO3INRGd1dadRI7PCTS+IjYIggLJaxXOYBkwEIuKBqwJFDBEJuqkTA2ZYqsvCGgd82h8UKKRGpqqeUEqinivGpaZLRL2gFoxeIOqBCKSR15XhCjkG7FqLOEkpi5U4B4IvF4RNbm2vqyXKqbCmpPCP4dgGABiaFu7f00WQbSB2GDOWHj0QkuwdauUMlQQY1iggyeUKeixWYMYfhMfMeMM1TidMz00XhaSiRouEUpJEYDHYxY9PKZj9flL6JNF9kZRNa90uoavBF3JcOHah7te64qQdLY38XhsAaAuJhD12MOLrTwq+7ZOUGlevWImURfm4KKKPA3RUS/mO8cXj+x8efdTdYdwoonRaIFqJIwJ95QqYkBAk/WY+wvr1D2qvSJciYyZwz4fA1wuBRg8PTnQv4LaVijuCS8X03HRh9E4oBZSFHLi8SWzS7B+z/4hfD/s1fn3Dr/Hcjc8R75PEA6R1u4SuhFBC+NPfPI3pA6YD0O9akyYUR82dL5oYSZosbI1PEE205EvG9O1Mbo3l7o3FeoocRUVE5xdMCCbdEsLY7ah5ay2osNCu7xUJJjJmAk/8F5i6xPX31CXAE4d1N2wA03PT5dFbSVduyEFo8dtxYYeXp8AGG56Pe55YxI+kG7iJOGLVUBQofH32a7xy6yt+nci1utakCcVJN49BrweLBXMgpJQax95xu2hOBVfehadCsTUxAeWLFgNXr/ofxCCidFrBl3RriY4G3dBAvJ+uen2MCFE/r2ObgcJ84EotMPw9YNsyYO+bQK7+nhvTuOkG6KmkSxIGirXFIswShuqr1e7P+RY/vuRkAHh217OgrBTRghnIdgldBdJqqPjweGy5c4su1zptSByi4myCWjdsbynKQgkmRkoVYCNJtOQaw/7duLfEVTJu4zHQVBSlM2KjST7j73R2DlnIygCifd0Fon5exzYDnzwAgAEsHrpvjgrX5/d8oKuBYxo3JqpCkuuzZPwSIkODJDlZSmfrQLVL6CpIqYbS61pbLBSGjE3Goa0XeMcMHpMMC4E0gxbNNIXQS5TOqI0m+QyulGcXu/KVCDF6K4Ngh6ifV9ZUMAX5aKoKRXuzFYgK9RjZ0fOtcBFw3e26JRWbOTcmqkOS68MuftMHTsfY1LGcxokRhAhNOjFi5RlNMzhZWi045tS+atC0eOKq3gJsekj1i1V/BSqnx1FUhFNTs3B+9myUP/00zs+ejVNTs+AoKnLnK1nj44n2ZfRWBsEMqSK3Y9ObOPV/TpzfkYTyPfG4sMvVT7HhIuvBYQDHRaBst04zNz03qtHaTmPTnnNIBPDhnnO4b8IghIV0X9tRjTCQqVFjLOqaxRtxaiEvIARJ+4UrdS2oOGlH72vFF0s9BdhYT5HTbuceoNBTZNRGk6SdvXtMmoSTt04CXcfz3BlEtI8LI4YB5UCaZH9x+bvg8pWUfxuHkDHNiElvdn1wRVklrRRM40YFXi44hvW7ziLUwmBVJrByy3H87usTmDtxABZPzwj09AKG0tCEET0F3RUn7cSq0lWi454Z+4yueUyk1VLsOJJFRy8BNtZTdH5hPseXyj1FRmw0KcXgsoSFIW3Z0s4QlYFF+zwxahhQDtJCftyh36qDMYju3QzKAqBHCucYLTCNG4W8XHAM7/7rrN/nNAP3593ZwFECSXKy3p4CoyPWbV0upPpF8eFkoQS1iIgOIx4nZdEhUmVVgZjsbPRiGJxubvb6XA1PkREbTUo1uGKys8G8tgaVy1708uAYtZUBqVdKLnp7hJSH/Ci0N4Wg6ZINUUOSgH4TVJkXCaZxo4DWdhrrd/kbNp6s33UWT2Vf161DVHIRSk5mMTVqOuET11uUuUhxCbZRQ4QUoQZc0779uPL7JzVbdJQQPWUKUFCA9HXrgMuXVVu09MjpkYpUg8tRVITqFSu9DBtrfDxSFuUbzrDROgwYCI+QUsFFlvZmC5C7QleFYnPFVcCHe85BLE+RZlzjTOTBl5wMAMsnLjc1ajog7bYuF6UhQq52DWrQdKWVaFzVx/8QTYrsai0P2IWJtPWEHkgxuPiSoZ12Oy4uyDOcwKEUr5RUApUYTpJkT0LIbfmmzk0wUVbbpOo4E258k5MTwxJRub+SqP1Cd4BEXE9KyTwXStpYaOlRIhXxC7l0nv/LAOulNGzfDgC4MG+equ0XvMqqDdJokrTcntW7MVoytBBahQEDnRgePXUqkuY/htoPPnR1ZO8gJCUFyYvyUb1ipaBnJyQ1FZF3Pq76vMQwPTcK6JcQqeo4E348S8dHpZg5Np7oUTIvt42F1h4lVsRPiMhwWrQrOBAYvRRHURHK8xf5z0WlN3K+NhCBajRJWm5/9eAhzbwgWqFVGJDUI9RYUoLGvSWqNl9lS/Zr3nzLbdhYYmOR9JvfYPC2YsTm5gq30qCogCV9m8aNAu4f3x9i2mAWyjXOxEQr9MqHkdqrTMyjBLhEGJWEqCwWChPvHSI4Ztz4SFAEXer11ksh1RBRukjFZGdj8LZi9N24Eb1eeQV9N27E4G3FActZITG4jJgMLYZWYUDSc7z45AJO3SC58IXCaIcDNW+9hYZt2wDw308A6LVyRcCeMzMspYCwEAvmThzAWS3FMnfiANWTibWqiDExLkL3XM+SeTZEuK9qH0oqSgAKGJsylrPkX4pHSYlkwKCRych9eCh2fXzSS/OmR7wNN98zBANvSMSpd/RTHibF/UauQ/sFvaq/SBErtzdiMrQYWoUBSc/RM2QEKEuWlxoK872fSEzE6eoqV7J8gDCNG4WwZd6+VVMWCpro3GiZv2BiTMTuuZJ8GDn4NjJ9D+9xPoN6VlgNGpmMAcN7ukT9HC2IinH1k2LbLhgt9wQwZqm2nggZXHq3wlALLUQgZVcsKcjHkaOR5Hk/29ragIIC8rlqgBmWUoHF0zPwv5duQ37OtQCA/Jxr8b+XbtPEsNEyfyGQaFVNE+yQ3HO5+TBazKfoXJH7Pl5uvky0Tz1EGI2WewIEp3cCcL3Vq53b4bvfpn37kbyoQ9xQh1YYaiI3DMh3XQXzlMSQmZukyPCmnUDZHtd/l+1x/R0ATM+NSoSFWHD/+P4oKDiG+8f3R6gGoSix/IWXvn0Jt/S+BWEhZMJmRkGqN4o1fIrOFSE5OrnLhuWkVEGx+TBc15Gr27oW8wGAZ/71DGiGdn9uoSxef3uipkfp9MFqv7BUVJwNE+8dgkEjXTlCeikPk6J1+wUt0EprhW+/CXMeguOrAs1bYaiN1DCg2HXl8whZ4uJA8z0/Hkj1/sk2vI9tBgrzgSu1wPD3gI/uBnokALkrzVLwYMVJMyg5WwsAKDlbixsHJ8NK0ImYFBKF2NrmWmR9loUXxr8QNCEq1hPgu2CyngDfRNXismK8WvIq5oXNw5LdS9CCFtGwXLDmKEnNWVGjn5eS+QDwM2SEDBtAukeJ616eO3wZhe8e9RvbaG9B4btHkfvwULeBY6TcE63bL6iNVuq7Qvut3fBn9H5tDazxCYYwSLWA9/wrK3Hx8SfAvP4aYnNzOY1zhqZx4aGHRI8h1fsnKyx4bDPwyQMAGMAS3vm5o8L1+T0f6GrgmMaNChQercCyL4+h9spVrMoE5mwsRUKPCCyZkYHcoWmqHIM0L6GupY7TKDAiUvVZWEMoDGGAh3OKzxACgjtHSU7OitJ+XmrMhwtfD44cjxLnvYxIxd2li8DX1wYA/v3JSQwY3tOdf2MktGy/oCZaaa0Q7XfFSgzeVizLoPFtVxA6/AbJ+9ASwfPvoDzvKVAAYnJz/YxzxunUJDdJcnI07XR5bDirEhkAFFC4CLjudt1Uis2cG4UUHq3AI5sOoKLe+8epsr4Zj2w6gMKjFaocR2pegtISWz2Q4pmQU1YsJUfJiDk/RmscquQ4NENj4diFWDlxJTbkbEDhnYWSDRuue2mtjEZ7g7DRwnYFNypsRUn6unWGKNXmQiv1Xa1VfU9NzfIqjz4z88eS96MloucPADSNi08u4CzrJtUNkmMYSspTK9sNOMoF9sYAjouucTphem4U4KQZLPvymJCtiqVfHkVcwgXUNtcoChOIVcR4H1udElutkeKZkBqikeIV8q3+AYzh3dG7CkrpfMRIDE/E9IHTJW8ndC8j26KJ9kHaPTyQRI4ZjdDQ0EBPgxOtKru02i9vqKe6GoBLFTohJ0fSPrVAynmxnjEAXt6o6KlT0VvlCi0Wr1BYVRXaa2thTUiANTYOjNPZaTRdEW+qK2mcCpjGjQJKztb6eWw8sUYfRUPPLzF3a6f+gNxF07OJJClqNjHUIm9FimdCaoiG1Bha/9/1ePvw28Q5P3oi1DiUL2dF7D4puY8kjUyFkOv5EbqXTaEOon3wtWnQu8tysKJVZZcW+yURR6x+dQ3is7ICfq+lnFd7ZSVq1q2D/dPPOBOPB28r1uRZpqxWOOvtqF6zhj+RvIe/gB8npONUwDRuFFDdwG/YhEQfRXjvTf7bKFg02YqYF/e8iLqWOtHxaoUrtMpbkeKZIG0dwJ4zqTH04fcfatqTSSlSqqDE7pMa95FvPlpWRQndy4qY07gSVoeo1ji/MniWHvEuzRtfAtFlOVjRSndGi/2ShHraq6oC1kvME/f5i4WmOqh58y2/z9iEbq0kDYgSybOmAjG9XMnDnC89lOv7fhNUnx8fZs6NApKjw3m+oWFL+RKAfxhUqex8Vr8sFN9VjHhbPO8YChRSI1NVCVdoqa0jRZ+FNYT4FjDfcyY17Byt/G/+cnoyaZG7k9UvC1vu3IINORt4c1bE7tOafWtUu49c81l9y2pQHf/niRo6O0L3kqEYnEwUzscYPCbZL5k4UF2WxdBKQ0YpWuV2aLFfrcUR1bxHXucvFw072xO3CGHgKvcG4J/c3/F37grdkokB07hRROaABKTFhvvdSmtEGSyh9bx6S0obGYaFhOGF8S9otpiw6NEbiLRfkVShOhJjKNYWSzRHUi9QcVkxcj7PwZwtc5C/Kx9ztsxBzuc5qogrejYOHZs61i/UJHafNh7bqOp99J1Pdv9sSX2npCB0LymGwpDLwm/1p/ZVg6Y7z12vnk5Sadi+3S8BVml/IDXRSghR7f1qKY7IlaSs9B7FZGej1+uvARYFy7FGjUQlJXxnzHSVe8f4VAjH9NK9DBwww1KKsFooLJmRgUc2HfD62bVGHSfaXklOjB6ibXr1BiLVZ2HP+dWSV70+5zpnknyV+66/D2sPrRWdH4kXSKpejxz48mVI7hMjUGqq932UitC9THMMRo9Wfi8m0Fkt1fta1zg50vKkKMnhKc9fBKtPSbhSDRm10UoIUc39krQrkBNC00rnBwBic3NBwdX80g/fUmwB1G7VIdkLljETuCYX2PtHoAbA1CXAuF8BARCWNY0bheQOTcM7941y69wAQGjsf9FGsG3PyJ6KEjy1Fm3TszcQqT5LVr8s3Jx6M7YUbsGyCcsEFYrFDMDJ6ZPx2YnPFFcjSdXrkYNQvkyrs1XWPn3R8z5Khe9eplHpRNt7VktpWaEjJ4fH7SFSWUNGK7QSQlRrvyQaLclP5amvx6PwHsXk5gJ/sHBWPcXdfTdq3nxTdB9qt+qQ7AXzVSjetgzY+6apUBys5A5Nw7SMVHx7qho1338Li7VJdJt4WzzqmuuQ83mOogRPLUXbjKazwsIaCNn9s0VLZ8UMQKnVSFxo7eES8wo9OvxRyfvkQu/76AmJkc91L1PsA/Hld4dF9+9ZLaVF2ELJW/3Vg4eEd65id/DuAm8Dy2RX2FRqt2otvX2e8HmwAMD+6ae6NxKVlPBtKhR3TawWCpkDElDwPdn4G3regKe/edqQJcgsRtNZIYFvkeQzKtQI72np4SLxCn124jPR+0RRlC49nuQgpYrL917SyQyi4mxePaV88a2WUrtCR+lbfXtNDdFxump3cK3gMhRCh9+A41u2SN6Xnh3c+TxYgehsT6pUDNqJxg35aL8cjpBwJ0K90qdMheJuxX8v/VfTRF010LPbtBrITeglqUYSQksPF4lXqOpqFe665i4A/PdpdsZszRPQfSGpHFNajWexUJh47xDBMTffM8SrWkrtCh2lKrshSUlExzFad/BggDUUYu+4HVHjMmUv/kbo4B6ozvZixwWAU5Mn4fw/gfI98Ti/IwlnCpN99mIqFActno0z48KSUN1azvsWHR8ej9rmWt59GUlhWI/EZTVQmtCrJLynpYeL1NvTN7qv6H26oecNut1HEm+MWrlKg0YmI/fhoX5dwXvE23DzPZ1dwT3hDVvIUHVV+lYfMXIEsGWLv6HFYsDu4N0NrXR+pBKozvZ8x23Yto07HHvV5TdpuBiOhDSPJHlToTi48G2cWXFuKixpH/iV+7NvybcPuB0ffv+h6H7VVBhWgtaJy0rRI6FXCDlKwqRI8QqNTR0reJ/0uo+khqaauUqDRiZjwPCeqDhpR6OjBVExrlCUULNMtRYKpW/1XsfTMeRgQo7kRpIaz8W3eWbj3hLNjR2u4/I3/XRdk+rD0YhPsYNiY0SmQnHwwDbOZADYOp6n9ivXw3nxPthSvoQl1Lv1Qn5mPmJtsUTGTSATPH3RMnHZEznVY3qVrAuhlYdLqldI7D5pfR+lGJpq5ypZLJS73JsUNSp0SEqPLXFxom/1vVauwOWXV6jeH8hEHdT09qlFIFW2iZSgr4ag6VIYolLadFcoNo0bBQg1zmxvGApnQwaSel7Ekp+kIyWqs2TZSTuDLlFXD+S2B9CzZF0ILTwjYv2cGDB4ZuwzhvGiSTE0jVqNJxX3W/3jT/COoe12NGzbJrjgRE+ZgvisLLPXlYEJVFiICy11d0ggDsc2WwG06a5QbBo3ChBrnMnAgkuX0pGIGzE2NdH9udwwhhbNK42CkpwZNRdJrmsMgPi6a+EZ4fMKsawqXQULZTFE/pMUQzOnf06XMfIZmrsSzRMSHRStNGRM1MMI90gP3R0xiMOxEQww4Temzk0wIdQ4U2yc1DCGVs0rjYDSnBm1Enq5rnFsWCxAAfUtyju7KyGrXxZohsZT3zzl952R5AOkGJpa5ipJRYmyMON0onLZi6Lj2isrcenNtxA1fnzQeGTMrunGRC/dHSGIlKAj2hGZ1AzsfhPoM1ZXA8csBVdAUpRNfJDAONISZC2bVxoBKaEMLtQoWee7xvWt9V6GDRCY6+6knVhVuorzOyPJB0htcEraW0xLlPYLatq3H3RdHdHYy+vWGa5nFB9SrotRG352VfTU3eFDUFKh4zcpeXhDZzJx4SJAx98n07hRAn8hBvE4oYaIgD7NKwONGjkzShZJoWvMRSCuu1IDUC/kGJpKdYaUoEZ3cDkLSKC7j4sh5bpo0UzSRBgj6O4AHho4iXHex41w/S5G92ajFqbOTVBRc4VfFVXOOC6MUAmkNWrlzMhN6BW7xlzofd2NkjRNgpzKMb2q8TxRK29B1gLisf9+t9wifXsNkXJdeHVOZCa1mmEwMoyiuwN0JFkn29H07mNob7Z2KBRbwNk+2tS5CQ6So8PFB0kYx0UwLWpyUVMET84iqeTa+W6rVdJ3sFUWZfXLwi29b8HHJz7GBccFpMek495r7kVYALoD86FW3oJ7oREpi+Xbv2hvKZ0hvS6NJaWqJrUGsqw52DCS7g4AUNHJiErpbODbZuFZ8yLJ1LjVwAxLKSBzQALSYsN5o04UgLTYcGQOSJB9jGBb1OQQ6DYPSq6d57Zy2z+QIDWXJdAUlxVj+t+mY1XpKvzl+F+wqnQVpv9tuqHyw9TKW3DnHvApDIvtn7C3lF6QXpemvXsVtZ3wRI3wYFdDLI8pUO0YOCF99mX+G5GDadwowGqhsGRGBgD/tBr27yUzMmAVUEkVI9gWNbkEMrFU7Bpz4XvdtU76DrQBKIVgSYBXM2/BvdCkpkqfB2FvKb1QO09DzFgSDYPBVUbfnZKUSfOYYrKzMXhbMfpu3Iher7yCvhs3YvC2Yv09XY2E3m/ScSpgGjcKyR2ahnfuG4WUGG83XGpsON65bxRyh6Yp2n8wLWpKCVRiqdA15sL3uuuV9G2EyiIuPBtkflv+LV7e+7Km14KkIScJbDhJsKdTaipx3oLvQpP+5z+73qpF9h8xcoSs+WuF6HUBAIsFIAx5iBlLShuPdjWkerHUag7KBXEVHGlbBbP9QjDioxzLU/cvh2BpXqkGgUgsBfivcVxYHBiK8dO58bzueiZ9G63PF5c2kBBKr4Waek9a5C34Cryl/PZZw+RFkOJ1XfigaVx++21Y4uJA19crSmo1QlmzUTCCOB+LpByofhNc7RUcFfBdC11QZvuFYIOrtxQAVDla8MimA6p4bwDjLWpdEb5rDAgrFOud9B0oA9AXPlVpEuRcC6Wd37nQul8Qyf7b2toUHUMLYrKzwby2BuV5TwEC6ssU4F505RpvWpU1c1VeGQmu+RlBnA+Q0drBYgVyVwKfPADeJA2z/ULwINRbioHrli778himZaQqyrthMcqipiZGaynBd42FrjtpQvLp+tMorSwN+DmqgVRtIF+kJnFr2fld635BRupHJIWQ+ARBwwYMA6fdjqTfzIf9089kG4dalDXzeR0SFy8i3oeW8M0vOieHaHtSL5ac0nrZ3qOMmcA9HwCF+cCV2s7PY3q5DJvu2H5h7dq1WL16NSorKzF8+HC8+eabyMzktkrXr1+PDz74AEePHgUAjB49GsuXL+cdryXivaWAivpmlJytxfhBrt5SRlvMA0lXaSkhVsrO8t5/38N7/30vKM/RFznaQID8flFah/4oq7XzzfnSJTTt26+qAWKEfkRSIV1Aw/r1x+BtxbKNN7XDg0Jeh/L8RcCypZzb6aWxIzS/uo0bifZB4sWSW1qvyHuUMRO4JhfY+0egBsDUJcC4XwEBkIAIeELxxx9/jLy8PCxZsgQHDhzA8OHDkZOTg+rqas7xO3fuxC9+8Qvs2LEDe/bsQXp6OrKzs3Hx4kWdZy69t5SWpcLBRrBU1JAgNSE5GM/RFzlhJSUJ8FqH/kyVXX+khIuUJrWqVdZMUnnFjvNEr/tP4hWBRWBZJkxyV1JarygH6thm4A/DgW3LXH9vW+b6+9hmon2qScCNmzVr1mDu3Ll46KGHkJGRgXXr1iEyMhIbNmzgHP9///d/ePTRRzFixAhcd911+OMf/wiaprFt2zadZy5NxC9YFnO1KlHEjtHVWkrwVTJxEazn6IkcbSAlVV1a6j2ZGivcqF1NJoYaZc0kXgcAXsKJet5/ovmxoUDf607oxVJaWi87B+rYZlfOjaPc+3NHhetznQ2cgIalWltbsX//fixevNj9mcViQVZWFvbs2UO0j6amJrS1tSEhgVsor6WlBS0tne0PHA4HAKCtrU1xIt8NvXogIoQB3fEM2SyM1/8CgIUChqZG4J6CVxEGbtccBQprStbg5tSbAxqi2nlhJ9bsX+P19tszsifyRudhUvok1Y5zoOoA7E122MDfeLSuqQ77yvdhVIp/+IK9b0ZLxLy11624eebNOHzpMEorS/H+d+8Ljhc6RyMgdJ2HxQ9Dn8g+qGmqEc27+fm1P8fEPhMxvOdwWC1WWfdN7HgUKPSMSEbS5b74vuwHREXbkDIoFhaRXDfG6UT5K6/CGcbjNqcolL/yKsJvuUWzHBmjPs8AkLh4kSuUA3CHixYvQjtNC+fmSCRs1Ej3L6XUfTdXV8Np4/9doTu+a750CZFtbbrff7H5scTN+gWubNvuykPqICQlBclP5SFi8mTBZ6Vp33601NUBAsdx1tXBUVLKaZiGDr8BVN++aK+u5s+BSk5G6PAbOudBO4EtLwAW1zFZheJOpWIK2LIEGJStKKlYyr8RilGzZlki5eXl6N27N3bv3o3x48e7P1+4cCG++eYb7N27V3Qfjz76KLZs2YLvvvsO4eH+npSlS5di2bJlfp9/9NFHiIyMVHYCJiYmJiYmJrrQ1NSEWbNmob6+HjExMYJjDZFQLJcVK1bgr3/9K3bu3Mlp2ADA4sWLkZeX5/7b4XC483TELo4Y//xvBRZ98V/33zYLg5fG0Hh+nwUtdOcb431T7PjHD6+L7m/ZhGXI7q9/DxUn7cRPN/+UN1+BAoWekT3xxcwvVPEsHag6gMe2PSY6bu3Utbyem61bt2LatGkIDQ2VPQ8tPVVKz9EIiF3nnRd2YvGuxf4bcqDWeXLdsxsaJ2DMsZnwL0F1kfXQ9RhwA7er3VG4BRXPPSd63LTf/Q4xuWSVLFJR63nWEsbpxNWDh9BeU4OQpCREjBxhyGovxunEmZk/5vU60OHhOPvsYmRNnYowm033+y82P9YrMnDzP2Rf36Z9+3Fh3jzRcenr1gmGFBu2b0f1q2s4vUfRU6Z4Dz72D+Afnb93bZZwbB32B0w78jhCaY/c1B+vBTJ+TH4yPrCRFxICatwkJSXBarWiqso7D6WqqgqpIjLmr7zyClasWIHi4mLccMMNvONsNhtsHO650NBQxT8ktU3taHH6/6C20JTX505nNFog3hk8OTo5ID9uhyoP4YemHwTHXGi6gCN1R1QpRR/TawziIuNEG2WO6TVG0JhScg+Ly4rx1K6n/I5/sekintr1lGLFX7XO0QhwXWcn7cTK/SuJnmsAuNx6mXMfUisHpw2chin9p7i3SwpPwn9fbUZLezvvNrs+Oo3BI9M4Q1ThycmwtoifQ3iy9v821fhN0ozQUISNvzHQsxAnNBS9nn6qU4DQN5TWEU4Ls9kQGhqq//0Xmx+AXk8/hTCel3USYjLHwhYfz19aD8ASFwcrgBCLhdeISsjJQXxWFlkFWUwKQPsX2ITSzd7GTUwKoOA6SrkHAU0oDgsLw+jRo72SgdnkYM8wlS+rVq3CSy+9hMLCQowZM0aPqXKSEEVW3jYscYSh+0MFQoQukC0l9EhoDvQ5kiI3gVxqKbhvoq+SykFWi2j6wOlIcwxGSyO/YQMAzY1tuHiijvM7vZNmTbRHqPKq18oVXp8F4v5LqQwjbn/gOWW2kWvH/Lmg7XZceOgh0Yow4io4VqFYqI10TG9dFYoDXi2Vl5eH9evXY+PGjfj+++/xyCOPoLGxEQ899BAA4IEHHvBKOF65ciWef/55bNiwAf3790dlZSUqKytx5coV3edOWi2VGhNl6IUuEJ3HA9knSYpmihKM2guKRYmBIcXQ9TXc1awcLD/ObbSQjhNcCGS2SJCzIJmoC1/llW84RYv7r2R+noaNkvJ0PgPKF9UqwliFYgCmQnEH9957Ly5duoQXXngBlZWVGDFiBAoLC5HScVPOnz8Pi0fd/zvvvIPW1lbcddddXvtZsmQJli5dqufU+Y1UjnFq9YfSQgRQTIROrvCaGIFqKaGnp8qobTNIWhnc2utW3u2lGLqehrvaSsMM4b9BoXFqtmCQK5xmoj6cwokclVdat+CQNL8OJLc/4IBVxm4sKcHFJxe4eoD5oma/KlOh2J/58+dj/vz5nN/t3LnT6+9z585pPyFCaq6Q5Ruw45QudFop+rIhlLydeaBAeS08WnuWAtFSQm9PldHaZpAaGDfPvJl3HySqzBbKgtW3rPZ6NtVWGu4zJB77UUY0Tgg1WiSosSCZBAY9WmSQKiCr2TyTslpBWazcho3HPlXrV5UxE7juduDMf4Dv6oBZnwIDb9LVY8NiCOMmWJEi4scid6HTommgJ92p87gcT1VXaptBamAcvnSYd4yQQcyy+pbVftV/anvNel0bD1tkCFqa+PNuwqNC0OtaYeMGUNYiwUjdnE3koWWLDCkePbWbZ3bXruumcaOAzAEJSIsNR2V9M1+Td6TGhiNzALfAIClaNg30xKghFLWR6qnqKj2wWEgNh5qrNYLf8xnEqZGpvAax2l4zi4XC5PuvQ+G7R3nHTLrvOlExP6UYpZuzifGQ6tFT2xjRqus6J8c2d4alhr8HfHQ30CPBlY+jc1gq4AnFwYzVQmHJjAwAvClUWDIjQ3FHcL0SYAHvSpSxqWO7nGHDwpfsGxMWg0eHP4rJ6ZMBdK0eWCykhkNSRJLomKx+Wdhy5xZsyNmAlRNXYkPOBhTeWchr9LFeMzUrB/sPT8Tge8Jh6eG9eETFhWHy5HAkXSzVPLG3u74dmwgjpxWC2saIbhVhBmu/YBo3CskdmoZ37huF1FjvEFVqbDjeuW8UcoemKT6G3qXa3QV2YX5sxGOIDYsFANS31mPt4bXI+TwHReeKulwPLIDcwBjeczjR/qQYxGqXyLMVX09feBjvDF2AzRlvovRHf8egYScw4dsXQC35pWiliRrVTbq+HZsEDVI8eixqGyO6VITRTpfHhjOG0fFZ4SLXOJ0wjRsVyB2ahn/nT8GG2a5cmg2zx+Lf+VNUMWwAdVz5ejTEVBO95rvjwg68feht1Ld6J9xVN1XjqW+ekuQxC5ZrLNXAOFB1QNVzUqtE3terxlAMymNPIaRiO/q++QbaKyu8xnOVvarVDdrUywlutCrfl+PR08IYUavrOi9lu/09Nl4wgOOia5xOmDk3KmG1UMgckICC7125OEpDUZ4oLdVWO2dE6+RavXJcSMT8SLjUdCno8nJIEsi3ntkKAHhs22NuJeKUyBQsHLsQ8eHxiu6/0vwuJ+3E0j1L/e4TRTOYvdW1MPn9C/RJ7G3Ytk216iZ2Qbr4xJOuBYiryaQGeikmytGyfF+uR0+L8nRNK8KuEAp6ko5TAdO4CQKUlGqrXWWl9SKuVH9FClJVdvk433Aebx96W7NKNq0QMjCKy4rx7K5n8Vycd9+dqqYqPPXNU16fyb3/Skrk1/93Pepb/Mtbr7/AIKlBYMOOMEBjSanq1U2B0ksxkY/W5fusR4+3FQJFISQlhdOjJ8cYESs316wirIewWKDkcSpghqWCBDmufLXbDGidXKtHWwRPlOYoUaCQEpGCz058FrR5OVz5MkL3gQu9k6udtBMffv8h53fxhELlTXv3Ss6FIIFEedbEGMhJ9pWK0hATcfsDqBdilUW/CUCEiNxCREL3ar9gQo7UyhQ1q6z0MDzU0F+RghSRPr7clLuuuUu3Sja9kOrR0tuIO1B9AI5W7u7AdT3UPZac6iYpC5JJ4JCT7CsHzfNd0OmB8j0fofYK6ucZaSu3IBUzLBVkSHHlq1llpbayrNx5AOL6K6SQ5jI9M/YZrCpdxZmb0upsJTpWMFWyyZmrGvefFKH5fZ9OoSYaSGjgeXNjwwDjMnF53TrRY5nVTV0XPcv3pYaYSNWM2bFSQ6yq5xmV7Qau1gqPuVrrGjdgovT9y8A0blTCSTMoOeu6uSVna3Hj4GRVk4rloKZgmh7l6FL0Vyoh8MZFCGkuU1a/LEztO9Wdm5IQngCKonD56mVcbr5MdCw1m45yoWaSt5K56mHECc2PsVB4f5oFT31Bg4HPu6RHGCAqM1N2LoRJ10Dv8n3SfBephodUAUlN8owMmFBshqVUoPBoBW5asR1zNpYCAOZsLMVNK7aj8GiFyJbaoqZgmh79mNTWXyGBNJeJ9ZiFWcPw3H+ew6+KfoX8XflYVboKFor/n5EcUTqpKOnuzYXYfRBCayMOEJ9fybUWrLsnGqECYYBAdYM2MQ5GLN+XE16S4oHSLM/ITCjuehQercC8TQdQ6Wj2+rzS0Yx5mw4E1MBRUzBNC2VZLecrBdJcJr6Eaprx7zSs9ZzF5qQkydfzPpCihxHHIvScsMz85XIM3r5NMLFXj1wIE+NiNANXruEhxQOlWZ5Rvwmu7t+8L0QUENPbTCgOFpw0g0VfHBEcs/iLI3DS5JopaqOWYJpehoda85WKmMouSQWRrwdH6zlrmeSd1S8LyycuJxqrhxHnC9dzQjEUhrZkYlnP13B982gwlEU0sTdQ1U2eyZxKE1ZN5GMkA1eu4SHqgQJgjYtD5JjR2uUZWaxA7kowNNBYZYPjQoRryjTgNnhyV+jaHdzMuVHAt2cuw97UJjimrqkN3565jJsGi/fp0Qq1GmLq1TnciA08SSqIaIbGwrELkRieqMuctU7ynpQ+CQVHCrB26lpcbr2MnpE9Uddcx5tcrbeWj+dzcu7QZdi329DqYFBxAPg7DiIqzoaJ9w7BoJHJgvtRqv0hJfkT8M+pcNpswIvL0LB9OxJycmTPw0QemorbSUCu4eEWkHz8Cd5tnHY7GrZt0zTPyPFDOKq2XYf2y/WuZ/oO4ExhMnqNbUfMI/o3zjSNGwXsOU2WTLrndGCNG0CZYJonehkeas1XLUgTZRPDEzF94HSNZ+NCr55jo1JGITQ01P23Z3J1oA1Pq8WKhIp+KPl7A3z72jTaW1D47lHkPjxU1MCRi9TkT75kTgAoz1+EEIoyw2ESkWpccqGZuJ0ElBge0VOnwhIXB9pu596oo2JqUNEWTRLpeZOUr1pwcSsDjDyKGNO4CSZIw036haW0bo0AGM/w0AM9EqqlEqg5Gen+0zSDXR+fFBzz709OYsDwnrCoXL0oteqEcTpR+fvl3ItKB1JVkbs7WrZOkItcY0uJmnHTvv38hg3gDmldPXhI9TYhgrlCHSGpqrfeR/TYDFDDfkK8X6WYOTcKGD+QzBtDOk4palfNmHSiR0K13DnxEYg56U3FSTsa7S2CY67UtaDipF3V48pJ/qxZ9y6cVQKhTZVE47oLciqL9JiTXJVgJQnOUkJaaucZieYKgUJ7kxVNGxebXcGDhRsHJSIuMlRwTFxkKG4clKj5XLRujdDdCVQllxA7LuxAc3sz53eBmpPeNDqEDRup40iRmvzpKCpCzZtvEu1bDdG4ro4erROkooaxFT11KpLmz4clJsbrczHDQ2pIS81EemLD6nKdrl3BTeNGAVYLhRU/GyY4ZsXPhmku5qd3T6buSqAqubhgjdn6Vv/mkQAQa4s1bMNONYmK+f/tnXl8FPX9/18zm+zmvskBRoTIFaDIbRCKQDiKhVLbSkUingjFflW+VUH0G6gtIiqtItZKS6GF1kqrFjS/cAm2AopcLRBQuakkQUjIfWx2P78/NrvsbnZmPzM7M3vwfvZBZWc/n/m89z3Dznvfn/dh0XScO3Ll6VXVFuGEqiL7x6jWCbxoYWw5vT6XV66Evcbx71pMTkbGTx/1a3hwZUylpSF24C2u11q1CeE2rGJs1BU8nJjULwdvzhyE4n8cxdXGa78OsxLNWPK9fpjUL0d3GYxojUA4CIVMLp60dItowZjcMYbJFCxyeqQgPsUiuzWVkGpBTo8URef1F8uhaW0R9/EGF40LV4xsncCD0irB3kjFb9lra3H59VWw9Ogha9y4MqZ8xdK0Y6uqwlejb0fy1ClIHDtOs4ywuCGDEZWRirbLVfBd54YhKs6GuE6tVMQvHBG8apx4v9YTo7JmCAf+auLoDU9aemVTZVg161SLKAoYNb2H7JiRd/VQFEzMs72gpLqtkgcsVUXmw+jWCf4IxNjSaotNKpbGHXt1NarX/VHTjuGCyYSs5/4PDsPG+zM4XmcNrIWQQkX8worSo+WY66NCcWVtM+YaVKE4FDN5CP0gY9aTvIGZmPRIP8SneG49JaRaFKeB8z5oAHAHf5rS07jWTn9kNqWBcxJqrRMCMba03GJLmjABeVu3QExN9TtWy8DrpImT0OXBAkTFelZrj4q1octt1UjKbQb6/YCK+IULNjvDks1lPjcHnE37lmwuw/j8bF3jbni7W+uRNWNE6rn3Oulm/QO0Q5lQM2aNugfkyBuYiW4DOjmyp2pbEJ/k2IpSmv6t5EGTNGEC8OqvO25fZWW5tq9qt251pH9zkP7AA4pkvZ6R3YYJQuuEQNK4td5iazp0GPbqav8DJTqGq8JuQ5JpLxKnVKLxGzOa2+JxCkD3Sd/AjPYf/kf/DhQuNszAIeMmAPadqUJ5je9sFcBh4JTXNGPfmSoU6JgxxdvdWusHzvZz231WK14wbIGmgaze61hgwXMpz2HXhV0Y3328ZuuEC8E0Zr0x6h7gQRQFdOnl/xerO941SaxyqdpuOB80ctVt5Qr2uRAE18NYiwexFgXtwgUe49IoAjG2eD17vN4hRXFGfmKBuDm3B6i9CEEE4rNaYRYdm0KCCMDpzKn92jGu2yj16yiAjJsAuFQnbdioGacU71/ML49+2bDS+M5sHe+HqzP1XKtMHal1AOCZfz0DwSREfEaQN8EyZr3ZenYr/vfj/+1wXOt7QC98BQ2bONz5gOeDxld1W/nCZm7nycpC1sIFONUc+HdEKBa00xutWycEYhyqMba4PHsKqwariTNq2Ls3MP3xZkFRtlR4kJkYo+k4JUj9Yn5q6FNIjUnVdYvAX+q5AAEv7nsRY3LHBLQ2T1aQFuuEI0b1+ZJi69mtePKfT/p8T8t7QC+kvCo2uSqvAPeDhjdDKueFF2AZMhgoKfE7Vg6l1ZIjCa1aJ2hhHCoxtrg9e1C2xeZ3i8wHV9580/V3VQYxbxaUgdlSZNwEwLBuaUiJi5ZtnpkaF41h3fjcjrzIeU1+9vHPsOL2FR36G2kZFxFI6rkSOSjFXZ5gpaVvP7fdp8fGnVC+NrJtEDR60PBuDdiu8PWnk8NvELRWcRURjJbGIY+xpcizp9DQ8NgiU4Eqg7jrCCCpM1BbDt/thgTH+wZmS5FxozNad5VS4zXROi5CbbaOUjkoK8g/Rvd5ct5/vITitfHbBqEdMTXVIzBTyYPGyFTlQGusXO8EwzhU4tlLKLhV8fmltsi4UPOZRRMw6UXgnXvRsdZN++tJywzNlqJU8ADYd6ZK1msDAFcbrdh3pkqzNZV4MwB92jKoydZRI0eoZQURfDV23Am1a6OkDUL2woWqy9MbmaocagXtgoFcNWl/BKPasRGePfcWC6mzZnHHkwFQ95nzpwJ3/RFI8ipcm9TZcZy6gocPwQgoVuLN0Cs2Rmm2jlo5eNaJ9MaQoYYST0yoXRvFbRCyslR7OhRlz9jtvk/CK2eIFbQzmkBjZYJhHBp1zZxbZPHDhyHrqSddsUAtJ096xNlIofgz508Fet8BnN4NHKsGZmwEut9mqMfGCXluAiAYAcVKvBlKvTy8KG0iqVYOuXWcRHpjyFDjfO157rGhdm2MboOgdfdlKUKtoJ2RaNGsMhjGYTCumUcvqYICrjmqPrNoArq2n79rQVAMG4CMm4AY1i0NOckxEo9dx05jTnKMpgHFTm+G1MPe3ZuhZ8yKkiaSgcghtQ4ALB21NKRTjUMJm92Gzys+R8npEnxe8bmqJqrbz23Hqn+v8jtOFES8MvqVkLs2wWiDoGX3ZSmcXiLHC/lqyZGEVm0LgmVoBPOaXQ8GMW1LBYBJFFA8JR9z1x+UCqFC8ZR8TasTK6lxonfMCm+2TqByeK+Tbk5HxYEK3J57uyq5rze0CChXEkj80rdfwoSbQi/tmPdXaMZPH9Xc+NA7kDeUCtoZhVaB1MGqdhzMaxZqFZ71gIybAJnULwe/mTkISzaXoaq+yXU8OzkGxVPydekKzlvjpLq5GqIgws587+lrUcmWJ1tHi4q67utYrVaUILC6IDyEQluBQNGq2CJvIPG8W+Z5GDahpEOe+h9R2dnImDPHYMm0QeuCdjwEsyKylrEywTI0gnHN3NeOZIOYjBsNmNQvB2N7Z2H9nlNAdRmentgLM0fkwRyl366fP6+JVPVYb4yIiwiVirpKUOvtCKWHuZYB5bxbizcm3uj6u16tGWx2G/ZX7se+8n2AAAzNGoqh2UMhQJTtLRWJv1Z9GRdGpXsHuyKy1rEywTI0jPDsSRFM40pvyLjRgNKj5S7PzfJhwItbvsDq3ed189w4kfKayFWPdSIKIl769kuGxUUEu6KuEtR6O0KpzxKgbRFEpVuLerXn2H5uOxbvWYya1hrXsbfwFvrW3oox53+Mtrprxkx8igWjpvfw6AoeCb9WnQZN3Uc7ULNps2ctHoOMi1CoiBxIs0opgmloBItI/cxk3ARI6dFyzF1/EAyAxc3Yrahpxtz1B/GbmYNkDRytf+nzVI8FADuzIzVGWZPBQAlGRV2l+lXr7TCq15YStAwoV7K1qFcJgu3ntuOJXU90ON7tyrcw8ssfwwrP8mENV1tQ+tujmPRIvw4GTrB+rfrytCjBl7fEHSOMi1CpiByJnjhCO8i4CQCbnWHJ5jKfVYgZHF+0SzaXYXx+ts+gYq1/6YdD9VgjK+qq0a8ab4dRvbaUomVAuZKtxc8rPte8bYbNbsMLn3WsUSMwAbedvdNDDm8+eecrdBvQqcMWldG/VqW2cdIXLuCe77cXkQHGRShVRI4ETxyhD5QKHgD7zlShvEa6QB8DUF7T7LNCsR6Vg8O9eqyWqNWvGm+HXvWEAkVJ2QAeeNP/eXW48/xOrnGAQ8eXmi51OJ5Tm4eE1lTJzwgA9dUtKP/qKvdaeiBXj+Xi0/6NG95eRI7B2lfUdSfUKiIbkW5PhB/kuQkAtRWK9fqlH87VY7XEn34BYPHexUg0J2JI1hAPHavxdoRqDyw9Arl5thZ5dfin43/CoKxBXF5KKd3FWZO41mqobeEapwc89Vic4xAd7fMcSgoQOtHLuAjFisiRGjdCqIc8NwGgtkKxXr/0lXhiQiU7SYvict7weLBqWmrw0NaHMPHvEz28OGq8HaHcA0tJsUVenFuLk7tPxtDsoR3uI6cO/eE04nmuuZTuGqNruWSOT7JwjdMDnm0cAGg6dFhyiBpDRS/j4nooAEeEP+S5CQBnheKKmmapJu/I9lGhWK9f+v6CPgHjs6TkAnr1yi5SojfvgF813g4t6vhohS99Gx3I7dShr+Bfd5TE3gzKHITM2MwOW1MViadhhx1C+/98IQhAVl6ysg+hIdzbOJcve7x2Dz72fk8WFVlCSqBAXkIWuw04t9fx93N7qbdUOOKsUAxINnn3WaGY9xf8leYrijwZ7r2YpCjqU2RY9djt57Zj4t8n4oEtD+Dpfz2NB7Y84PKU6BFz5ESJh8RpjLh7EJR6O5T22tILOX3787ZoTWHXQhT1KeIay2OMmkQTFg5f2OF4dl13iBBlY24YAypP1Ui+rzfc2zgZGa6/127dipPjCnF+1ixc/NnPcGnZMkDk/7rW27gwqm8WEWaUbQJ+3Q/4848cr//8I8frsk2Gi0LGTYA4KxRnJ3tuPWUnx0imgfvb+nCy/PPlHbZN/FHYtRD39b1P8v0/lv0xIMOBF3/Gy+I9i2VjYni3K3zBq1/3Nb23AQu7FmLLD7ZgzcQ1eHHUi1gzcQ1Kf1Aq6VHSY/tHCXoai2oZc+MYrnG8xmhh10L86vZfIdl8zQsTDjE3PNs4ABA78BYA0sHHPN3Do7KzDTMuKJCX8KBsE/DOvUDtRc/jteWO4wYbOLQtpQGT+uVgfH42Pj15CZePf4o1s4bi1pszJXtKyW19eOOrTorcVo/NbkPJGfnWBHqnJfME9LoXYfM1RmmqsDtK9OuOtwdBadp6MOr4AKGbiq7Hdp1Tx/sr9+P9k+/jYM0Jrnk8MTd6tRLg2cZxjuPKihJFD0PHlJaGpClTkDh2rGsrquGzfYbU8KFAXgKAYyuq9GlArjBK6QKg9x2GbVGRcaMRJlHAsG5pKDnuiMXx1yxTqmKvN94Pp50XdsrGqWhZlVYtSlPSpQgku4hXv+5oEfBrZB0fJ3pdc6fnbOvZrchMzFRsqOnVdsMkmjA8ZziuNF1ByckS2ZgbBsYVc6N3KwHZeiwLF+BUsyOjkisrym5H5oIFiMrI6GC8BLslAnGdcm5PR4+NBwyo/doxrtsoQ0Sibakg4tz6eGroU7LjnA+n1UdW+916CIW0ZK3OHaix4dTv6vGrkWSW3r5QWu8l1NDjmm8/tx3f3/R9AEDxnmKP+B0l6Lld1ymuk9+YGwECwATZmBu5GjRfP/Y4arduVS2jO1LbOIljx15bkzP4OCojA8nfvQPxw4d5GDa8n4PZbGj4bB9qPvgQDZ/tc6ShE4Ra6jl/zPKO0wDy3AQZk2hCekw619j1Zev9bj38YuQvuM6lZ1pyoOfWMrvIJJpwa+dbsWTEEszfNR8ANPMghApap6I743fMMAPma8fVtpLQa7tuUOYg5Ai5XGOdMTfeW0+xA28xtJWAz20cty0mtTVklLREqNux47r07jivPeDwkCUNG0oZXVqR4L/0g6JxGkCemxCA96HDE6fCGNO0Kq0aeGrFpFhSXH/3fg/Q3tgIdsCvnmhZiZgnXkpNsLce2Vom0YQ7B0zlGhufZOmQgXR+1ix8Nfp27lYCRqC2hgxvS4TLb75piJcq1HBe+wtz5gAALsyZgy9HjkJNaWmQJYsQuo4AkjqjY96wEwFI6uIYZxBk3IQAPA8n9wwROaqaq4KelsyTGl1cUIxf3f4rQ40NpRlQ4YKWqeih2kpCiu+OHIeoRCYbNJ6QakH82c99PtTdO2rLYVQrAWfwseOF1/eBTA0ZXvmq/vgn2UrJlUtfiLgtKqntOnt1NS4+/gQqX3opSJJFEKIJmPRi+wuJwiiTlhla74aMmxCA5+E0s89MrnN1iusUEl4KHhmCYWwYXe/FKLS65qEQs6UEURRQOKO/bNr/bT/MwzcvcPZlksDIVgJqasjwymevkan30+7dadj3ecTE4/Bkn1X9fg1qyYMTOPlTgbv+CCR5lT9J6uw4ns/nZdUKirnRCJuduRpk7jtTJZsK7gup7J6suCw8PexpjMkdg7999TfutNpgpSV7fyZ/MgQjuyhS0eKah3IrCbW0njwNQWFfJhc6V/uVImnCBCSOG8edmu7czmqrrPT9IBcEiMnJsF+96nftrx9/3MMI0jIeR690eyl4e3JV/Px5JI4fTzE4WuB9/zH/9Zn0gIwbDSg9Wo4lm8tQVd+E5cOAB9Z9jrSEWBRPyfdZxE8Kfw8npWm1oWA4hIIMoYRcjSItCFTf7rVpfGFkKwke7HaGnevla93s+aQJI9r/1SgiyK0ElNSQ4amlk1ZUhMsrV/o9l7d3xxmPgwCLAwYjTZ13u85WVYXG/QeoZk8glG0C3mmvSi66FbWtK3ccv+tPhnpvaFsqQEqPlmPu+oMor/Hs/F1R04y56w+i9Gi5ovPJbZs4vTudYj1/NWfGZoZ8UKweDTKNPL8WyLVHCBVCpZUEL19/WY2WhjbZMS1WAdUpPfyey5Sa6vE63FoJ+NvOypjziHywshQaxOMYlW7vjZLtRKPiqiISuw3Y/Jj8mM2POcYZBHluAsBmZ1iyucz1e1Bod7/l1Z9CDWJRHpODJZvLMD4/27VFZbfb8PXxY6i/Wo245GSAAY21NUhISUWXPn0huj00nGPrqq6gqbYGsUnJqLdecJQrY0BWlQWxLSbEJIlgfkqz+zpXYlp6hzV9zam/Wu1TPqlxOb16o/yLE67XJ+Iq8OL+5a7tNoEBvRty8KMuU3Frj2/LysCDswHnpYZKN50k4+HJP8P4btIPJt7Pp8V8Z3q195aid3p1W1sr/r2lBFcrK5DUKROdut6Epro6yfN7y5DVoweObNvimp+ReyMufnEcDEBufn/k9u3v9zM6jehX9r0CwHG9sqssyGHpuHPgjzE2l6+tghqUerYuftExILi7RUS8AEAAqtoYmhlQc8NApNV81f6gFmDK6AHBkgzWUgPblZOIyspE3tYtaDx4CC0nqyFYkhDV6QawFhtqtpyFuXsyYvJSIHhtNTM7Q8uZGtjrWiEmmmHp5gj8bzl9FS3ttXWccwF0GOt9Pn/n9jXefVx0t6G44a2/ofk/X8LeXAPLzamIHzrE5XmS9O546+TyV/CoNuuWNSbl3ZCSt2PcS0f9q02396ejuCGDIcTHgzU0ONZNvxkAHP+9WOb4u1MWpIPZme9r7ON6yl07PeC9H7Sap4iznwBNVfJjmqoc47qP1nZtCULCuFm1ahVeeuklVFRUYMCAAVi5ciWGDZN2D27cuBHPPfcczp49ix49euDFF1/E5MmTDZTYwb4zVS6PTV7DaYyu+RQYfhcKL+8Ca7OizhSPfzWOxL4zt6AgLx1ffbYHH619C/VVvjv8JqRlYOx9s9Fj+AjZsWOiowHcgBjrtS+CvftWoOZHp/HD787pMF7uXO5r+pvja6yvcYIggrntszbEtMGSXwtkAzdWxGJ4WRrim6NwHqU4j1JJGXhwGg25FTH4YVkXxDdfu6WV6kSJHErm87ZHiPrnORz88B8eunPH+/z+7idvPnv3r4hJSMSE2T/1+xkLuxZiZPZIbCndgqJ9vWC94vhiP7Xv71i98WPV10sONV3i7W4qzY8RkWcRIbp5Jrq3d11o6zkW1qqvAACW/ndBjE27do6mKsQPjUfLl7Wo2wnYauIB2ACcu3bynRcgxkUh9c4eiO3naHDZdPQyrm4+BVtNq2uYGBcF1mYHa7V7zBXMIoQoEfbGa14mU7IZKVPyENWrYyakr3M7xzvXlxp3jXi0XgBMCdWuOb4qJUflDIRlwN0QY1I8dNLyn7+irfyQxxmlvBty8tobTnuu9a3pHfTf8p+/Kt4W4tFR3Y4dYA0NrnVZQiqAasQV/A+ExgYADKIlEQBQ/4kVTUf2ecxvOnoZ1e9+5XHdfN0LesN7P2g1TzFn/sU/ziDjJujbUn/9618xf/58FBcX4+DBgxgwYAAmTpyIS5d87/nv2bMHd999Nx588EEcOnQI06ZNw7Rp03D06FGDJQcu1V0zbL5zaQsSbI0e7yfYGvCdS1twev8efPXZHmxasVT2QVRfdRmbVizFx+vXyI61WEVYrJ6XLq7ZhLN/2owvPv3E47i/dZ1rfvXZHr9zvMdKjfN+OMc1mzDmYCcMPp6CMQc7Ia7Z89eZLxl4cBoNuRUxPs+rVCe8ciidz5Ne3eVAMw588J6kYeN9fp77yRfN9XXcuj57cD8AoK3G875We73kUNv4MybeYczmx4i42SJK5kyZ7AJihz2CmKGPQIjx3H4SY1PRdNSCK+uPSxgJDuyNbbiy/jiajl5G09HLPsfbG9s8DZt2WKvd8wEJwFbTiivrj6P5+BWP41Lndo5vOnpZdpzcHMCzUnKnBb9G7PC5HoYNAAgxqYgZNgdROQM9jvva5vEr73GHdy0qZyBihs3poH/nWs5xPPDoyOkxklzXHA/BnCA537mG93UDPO8FveG9H7SapwpeR5CBzq6gGzcrVqzAww8/jPvvvx/5+fl48803ERcXhzVr1vgc/+qrr2LSpEl48skn0adPHzz//PMYNGgQXn/9dYMlBzITYyAwO0Zd+cTn+87reGX7O/ho7W+5z3vgw/dl3/fVR8f5etsf3oC9fV/Tbrfho7Vvca25c91bsNttXHN2rnsLbW2t3Od2ytb3TJLHaykZePn3N//GpYZKDC9L83letTqRk0PNfH9p06L9mm54+GjdW9jxB/77yec51v5WVtd2uw3/3LBW9hxKr5cUgRQOjEtylFDOszi+ygSJeBKh/f8FQfAxRtk3bvWmk6jedFLRHDlq/t9Z19+ZneHq5lOy469uPg17m93vOO85zM3NJZhMiBs6FNbyFJ/jnTqy9J8OQJAsHsgjb8u5OAAiLN+a7nFu77VazsV5yCgFr44aPt+PtopK2XWl7perm0+h6h/+r3H1plNcMquF97N6y6B2nmq6jtR2nAYEdVuqtbUVBw4cwMKFC13HRFFEYWEh9u7d63PO3r17MX/+fI9jEydOxPvvv+9zfEtLC1paWlyva2trAQBWqxVWqzUg+QfekIhB5itIElqBqGgIUdEA4Pov4PjabGusR5vXcX8IKmJQBACt9U04f+wIuvTui69PHENDbQ3XuvU1NTh/7AgA+J1TX1ODQ6Ul3Od2ysYrQ5fefWXHOa/bN/Xf4IbqRCS0xUreyWp0IieHmvnp5nRYIN2VuteFBJiizJLve9PQns2i5H7qcI7aWlldf33iGBrqamXX4b1e/jhYeRBXG6/K6qi6sRr7L+7HoCzPLK3YxCh0ixPAopwRIvo9aJzYGtp/CWsUU22rd3w/Wa1WtJypQWt9i+y5bfXNuLrngt9x3nMaTl5xxQQB4FoLialA576wVZ1E1sIFaLPbPdpFcJ2jFYga8n2whFTZa2RvZR1k9AWvjhpONgCd8z3WtYmOvzn/Kz2//ZnhR7+2hhYumdXC/1mVX1tf81Rzw61AfDbQdBUAYG3PlrK6Z03FpjrGBfDcVfLMFhgLoLJVgFy8eBFdunTBnj17UFBQ4Dr+1FNP4eOPP8Znn33WYY7ZbMa6detw9913u4698cYbWLJkCSorO7r+Fy9ejCVLlnQ4/uc//xlxcXEafRKCIAiCIPSksbERM2bMQE1NDZKS5L3dIRFQrCcLFy708PTU1tYiNzcXEyZM8KscHr4+cQzvLnMYT0JUNLrfeQ9Ov7sBrC0wr1Ag3Lmg2OWlcMrGOw8A15xRd8/Cv/6yTrWMcjLweG62bduGcYXjMHvddAzZ7d/roVQnUnKonb/rwi48869nAHRs3NnzXDwGf5HqfQrdkdP11yeO4b2Xl/q9n3mulz8OVh7EvB3z/I5bNW5VB88NAJz7+5eIPnLFx4zwwCYyHBlyFePHj4f9v424sq7M75zEiV1Rt+Wc33HupM/K7/Drnmet9KLesOT5vj95z8Err7eMgayZXtQbFxctgqV3keuYU9f996fAZNcmAIRHZrVwf1a111Zr2U+UANv+D9bGq9jW/zWMP/I/iI5LBcYvAXoHnvTj3HnhIajGTUZGBkwmUwePS2VlJbKzs33Oyc7OVjTeYrHAYuno7o6OjkZ0tHq3vpMb+/ZHfFKyR2Ana7N6PAwS0hxdv+ur+L6ABdF/arcUiekZuLE93deXbP7mAfA7JzE9AwMnTcbBD9/nDmh1dv9xZOj6/lJxl50Hi9mC+7/zGPZ+tgJxzSau8/LoRE4OtfPHdx8PwSR0yAbKjsvGrHv+F0cXvSEbTOxOQnoGmJ2hoVr9Az0hLV1W1zf27Y/4RIfx730/O1F6vaQY0nkIUuJS/FbfHtJ5iM+08O4/7IOvD+9uH6s/YpLje8Neq80PGFN73FB0dDSibk5HXYJFNkjYlGxByohctOyukB3nPSf+5nSPFGDeteJ7dpJMHdZSXl8yBrJmfM9OyJr9I9SUVEOISfWIrzHZBZhs0uuYks2w2xlYnfw1FpPMXDKrhfuzqr22Wsve/3tA3+8Cp3cDx6oR/eM/Ibr7bZr1lFLyzA5qQLHZbMbgwYOxY8cO1zG73Y4dO3Z4bFO5U1BQ4DEeALZt2yY5Xm9E0YSx982WHTP2vkcw9r5HuM85+I5psu8zSDcKHDNrtuthwyOb9zyeOWNmzUZUlJn73E6OdXNY3Tyy8zK+2wTk/2ga93l5P5+UHIHMl+qlNSFvEgZ/d5rsOd0ZO2s2xt3Pfz/5PMd9j8jqWhRN+PY998meQ8318kWghQPFKBGJ3+5iWCJG6tSbkTr1Zs3Ol/ydm1x/F0QBKVPyZMenTOkOMUr0O857jvdDjHctuYeflvL6W0vpmoIoIHniBMQPjQcAdIzAkI7ISJmSh7Tv+b/GqVPzdK13o/YaaXFtVSOagK7tz+OuBYY2y/QQIyirujF//nysXr0a69atw/HjxzF37lw0NDTg/vvvBwDce++9HgHHjz32GEpLS/HKK6/gxIkTWLx4Mfbv349HH300WB8BPYaPwNT5zyAhNd3jeGJ6BqbOfwY9ho+4NiZNuraAc/zomQ/Ijo1NSEK0V7yQ+1o+ZZM4l695UnO8x0qNE0Sxw7wpTyzEvMdX4IZ7JsGSktzhfV+y8/LD787BlCcWcp+X9/NJEch8qQrUo2c+gCFT7oQgSP+TVHo/+SImIZFb13lDhgOA7H2tFYE2/kyZ3B0J3+4i6boxJVuQPrMP0mf2gSnZzP2eO2JcFNJn9kFsvwzE9svwOV6Mi4Jg7ngNBbMIMc7TUe5cN6aPp36lzu0c76xPIjVObo43vGvJEai8StZSI3f6zEKk39MbYqznzSHGRUteE/dr7D3GMTdKscxqUas3LfUdjgQ1oNjJ66+/7irid8stt+C1117D8OGOL9bbb78dN910E9auXesav3HjRjz77LOuIn7Lly/nLuJXW1uL5ORkroAkpbS0NKO0dAvy0pKRnJbmt6KsmgrFzqrCABRV1w1mhWKpz6W2MrDVakVJSQkmT57s4aZUel4jKxTzEgoVip049Txp0kRcOvmlpp9TikB7b9nb7KjfexFtV5oAAObcJESlWDyqsspVbHW+Z6tpga2+FaypDYCga4ViqftZTYViIT4aggDY662GV7FVI2+gFXOVnIvZHdlYO47vxrg+tyH+ZodR6W8+VShWjtQ9HShKnt8hYdwYiZ7GjV4XlPCE9GwMpGdjID0bB+naGELBuAn6thRBEARBEISWkHFDEARBEEREQcYNQRAEQRARBRk3BEEQBEFEFGTcEARBEAQRUZBxQxAEQRBEREHGDUEQBEEQEQUZNwRBEARBRBRk3BAEQRAEEVEEtSt4MHAWZFbSOp0Xq9WKxsZG1NbWUvVLHSE9GwPp2RhIz8ZBujYGvfTsfG7zNFa47oyburo6AEBubm6QJSEIgiAIQil1dXVITk6WHXPd9Zay2+24ePEiEhMTIQjaNg+rra1Fbm4uLly4oHnfKuIapGdjID0bA+nZOEjXxqCXnhljqKurQ+fOnSGK8lE1153nRhRF3HDDDbqukZSURP9wDID0bAykZ2MgPRsH6doY9NCzP4+NEwooJgiCIAgioiDjhiAIgiCIiIKMGw2xWCwoLi6GxWIJtigRDenZGEjPxkB6Ng7StTGEgp6vu4BigiAIgiAiG/LcEARBEAQRUZBxQxAEQRBEREHGDUEQBEEQEQUZNwRBEARBRBRk3Chk1apVuOmmmxATE4Phw4dj3759suM3btyI3r17IyYmBv3790dJSYlBkoY3SvS8evVqjBo1CqmpqUhNTUVhYaHf60I4UHo/O3n77bchCAKmTZumr4ARglI9X716FfPmzUNOTg4sFgt69uxJ3x0cKNXzr3/9a/Tq1QuxsbHIzc3FE088gebmZoOkDU/++c9/YsqUKejcuTMEQcD777/vd86uXbswaNAgWCwW3HzzzVi7dq3ucoIR3Lz99tvMbDazNWvWsGPHjrGHH36YpaSksMrKSp/jd+/ezUwmE1u+fDkrKytjzz77LIuOjmZHjhwxWPLwQqmeZ8yYwVatWsUOHTrEjh8/zu677z6WnJzM/vvf/xoseXihVM9Ozpw5w7p06cJGjRrFvve97xkjbBijVM8tLS1syJAhbPLkyeyTTz5hZ86cYbt27WKHDx82WPLwQqmeN2zYwCwWC9uwYQM7c+YM27JlC8vJyWFPPPGEwZKHFyUlJWzRokXs3XffZQDYe++9Jzv+9OnTLC4ujs2fP5+VlZWxlStXMpPJxEpLS3WVk4wbBQwbNozNmzfP9dpms7HOnTuzF154wef4u+66i91xxx0ex4YPH84eeeQRXeUMd5Tq2Zu2tjaWmJjI1q1bp5eIEYEaPbe1tbERI0aw3/3ud2zWrFlk3HCgVM+/+c1vWPfu3Vlra6tRIkYESvU8b948NnbsWI9j8+fPZ7fddpuuckYSPMbNU089xfr27etxbPr06WzixIk6SsYYbUtx0traigMHDqCwsNB1TBRFFBYWYu/evT7n7N2712M8AEycOFFyPKFOz940NjbCarUiLS1NLzHDHrV6/vnPf47MzEw8+OCDRogZ9qjR86ZNm1BQUIB58+YhKysL/fr1w9KlS2Gz2YwSO+xQo+cRI0bgwIEDrq2r06dPo6SkBJMnTzZE5uuFYD0Hr7vGmWq5fPkybDYbsrKyPI5nZWXhxIkTPudUVFT4HF9RUaGbnOGOGj178/TTT6Nz584d/kER11Cj508++QS///3vcfjwYQMkjAzU6Pn06dP46KOPcM8996CkpAQnT57ET37yE1itVhQXFxshdtihRs8zZszA5cuXMXLkSDDG0NbWhjlz5uCZZ54xQuTrBqnnYG1tLZqamhAbG6vLuuS5ISKKZcuW4e2338Z7772HmJiYYIsTMdTV1aGoqAirV69GRkZGsMWJaOx2OzIzM/HWW29h8ODBmD59OhYtWoQ333wz2KJFFLt27cLSpUvxxhtv4ODBg3j33Xfx4Ycf4vnnnw+2aIQGkOeGk4yMDJhMJlRWVnocr6ysRHZ2ts852dnZisYT6vTs5OWXX8ayZcuwfft2fOtb39JTzLBHqZ5PnTqFs2fPYsqUKa5jdrsdABAVFYUvvvgCeXl5+godhqi5n3NychAdHQ2TyeQ61qdPH1RUVKC1tRVms1lXmcMRNXp+7rnnUFRUhIceeggA0L9/fzQ0NGD27NlYtGgRRJF++2uB1HMwKSlJN68NQJ4bbsxmMwYPHowdO3a4jtntduzYsQMFBQU+5xQUFHiMB4Bt27ZJjifU6RkAli9fjueffx6lpaUYMmSIEaKGNUr13Lt3bxw5cgSHDx92/Zk6dSrGjBmDw4cPIzc310jxwwY19/Ntt92GkydPuoxHAPjyyy+Rk5NDho0EavTc2NjYwYBxGpSMWi5qRtCeg7qGK0cYb7/9NrNYLGzt2rWsrKyMzZ49m6WkpLCKigrGGGNFRUVswYIFrvG7d+9mUVFR7OWXX2bHjx9nxcXFlArOgVI9L1u2jJnNZva3v/2NlZeXu/7U1dUF6yOEBUr17A1lS/GhVM/nz59niYmJ7NFHH2VffPEF++CDD1hmZib7xS9+EayPEBYo1XNxcTFLTExkf/nLX9jp06fZ1q1bWV5eHrvrrruC9RHCgrq6Onbo0CF26NAhBoCtWLGCHTp0iJ07d44xxtiCBQtYUVGRa7wzFfzJJ59kx48fZ6tWraJU8FBk5cqV7MYbb2Rms5kNGzaMffrpp673Ro8ezWbNmuUx/p133mE9e/ZkZrOZ9e3bl3344YcGSxyeKNFz165dGYAOf4qLi40XPMxQej+7Q8YNP0r1vGfPHjZ8+HBmsVhY9+7d2S9/+UvW1tZmsNThhxI9W61WtnjxYpaXl8diYmJYbm4u+8lPfsKqq6uNFzyM2Llzp8/vW6duZ82axUaPHt1hzi233MLMZjPr3r07+8Mf/qC7nAJj5H8jCIIgCCJyoJgbgiAIgiAiCjJuCIIgCIKIKMi4IQiCIAgioiDjhiAIgiCIiIKMG4IgCIIgIgoybgiCIAiCiCjIuCEIgiAIIqIg44YgCIIgiIiCjBuCIAiCICIKMm4IgohoysvLMWPGDPTs2ROiKOLxxx8PtkgEQegMGTcEQUQ0LS0t6NSpE5599lkMGDAg2OIQBGEAZNwQBBHyfPPNN8jOzsbSpUtdx/bs2QOz2YwdO3bIzr3pppvw6quv4t5770VycrLeohIEEQJEBVsAgiAIf3Tq1Alr1qzBtGnTMGHCBPTq1QtFRUV49NFHMW7cuGCLRxBEiEHGDUEQYcHkyZPx8MMP45577sGQIUMQHx+PF154IdhiEQQRgtC2FEEQYcPLL7+MtrY2bNy4ERs2bIDFYgm2SARBhCBk3BAEETacOnUKFy9ehN1ux9mzZ4MtDkEQIQptSxEEERa0trZi5syZmD59Onr16oWHHnoIR44cQWZmZrBFIwgixCDjhiCIsGDRokWoqanBa6+9hoSEBJSUlOCBBx7ABx984Hfu4cOHAQD19fX45ptvcPjwYZjNZuTn5+ssNUEQwUBgjLFgC0EQBCHHrl27MH78eOzcuRMjR44EAJw9exYDBgzAsmXLMHfuXNn5giB0ONa1a1fa2iKICIWMG4IgCIIgIgoKKCYIgiAIIqIg44YgiLCmb9++SEhI8Plnw4YNwRaPIIggQNtSBEGENefOnYPVavX5XlZWFhITEw2WiCCIYEPGDUEQBEEQEQVtSxEEQRAEEVGQcUMQBEEQRERBxg1BEARBEBEFGTcEQRAEQUQUZNwQBEEQBBFRkHFDEARBEEREQcYNQRAEQRARxf8Hhv8Hl6gKHCkAAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, - "execution_count": 11, "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, "output_type": "display_data" } ], "source": [ - "tp.utils.scatter(X, left_sampler, right_sampler, left_pde_sampler, right_pde_sampler, \n", + "fig = tp.utils.scatter(X, left_sampler, right_sampler, left_pde_sampler, right_pde_sampler, \n", " interface_sampler, left_neumann_sampler, right_neumann_sampler)" ] }, @@ -305,13 +292,18 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "You are using a CUDA device ('GeForce RTX 3090') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [2]\n", "\n", " | Name | Type | Params\n", @@ -322,36 +314,31 @@ "302 Trainable params\n", "0 Non-trainable params\n", "302 Total params\n", - "0.001 Total estimated model params size (MB)\n" + "0.001 Total estimated model params size (MB)\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n" ] }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "429b6b6f328c4700904c9d127ec308a4", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation sanity check: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 2500/2500 [01:45<00:00, 23.75it/s]" + ] }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "559761db2e3f4cd38f78700f20492b9c", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: 1999it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_steps=2500` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 2500/2500 [01:45<00:00, 23.75it/s]\n" + ] } ], "source": [ @@ -363,11 +350,12 @@ "\n", "import pytorch_lightning as pl\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=2000,\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=2500, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "trainer.fit(solver)" ] }, @@ -385,16 +373,22 @@ "execution_count": 13, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/torch/functional.py:507: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:3549.)\n", + " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjAAAAGxCAYAAAB89YyPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABYyUlEQVR4nO3de1xU1d4/8M8MzAzDXVRuiqJWWimaeuRB86gFovZYnqxMPWpiWiYdk+ekYiqonaCb2YXipJF1jkany/H0pC8SSY7HRH288OtiWl4xFPKSDpcBBmb//kBGRwZmDXOf+bxfr/2C2bP23t9ZzOz5stbae8kkSZJARERE5Ebkzg6AiIiIyFJMYIiIiMjtMIEhIiIit8MEhoiIiNwOExgiIiJyO0xgiIiIyO0wgSEiIiK3wwSGiIiI3I6vswNwNL1ej3PnziEoKAgymczZ4RARkQuTJAlVVVWIjo6GXG6///nr6urQ0NBg9X6USiX8/PxsEJHr87oE5ty5c4iJiXF2GERE5EbOnj2L7t2722XfdXV16KpWo9oG+4qMjMSpU6e8IonxugQmKCgIQPObMTg4uMP70el02L59O8aOHQuFQmGr8DwG68c81lH7WD/tY/20z1b1o9FoEBMTY/jusIeGhgZUA3gWgMqK/dQDeLmiAg0NDUIJTFZWFj7//HMcPXoUarUaw4cPx4svvoi+ffu2u90nn3yCFStW4PTp07j11lvx4osvYsKECQCa63358uXYtm0bTp48iZCQECQmJiI7OxvR0dGGfcTGxuLMmTOt4lm6dKnw6/W6BKal2yg4ONjqBMbf3x/BwcE8eZjA+jGPddQ+1k/7WD/ts3X9OGLIgQqAI9tN/v3vf2PBggX43e9+h8bGRixbtgxjx47FkSNHEBAQYHKbPXv2YOrUqcjKysJ///d/Y/PmzZg0aRIOHTqE/v37o7a2FocOHcKKFSswcOBA/Pbbb1i4cCHuv/9+HDhwwGhfq1evxty5cw2PLU0SvS6BISIiIqCgoMDo8caNGxEeHo6DBw/i97//vcltXn/9dYwbNw7PPvssAGDNmjUoLCzEW2+9hdzcXISEhKCwsNBom7feegvDhg1DWVkZevToYVgfFBSEyMjIDsfPq5CIiIg8iEajMVrq6+uFtrt69SoAICwsrM0yJSUlSExMNFqXnJyMkpKSdvcrk8kQGhpqtD47OxudO3fGXXfdhZdffhmNjY1CcbZgCwwREZELCAKgtmL7lo6ymy9UycjIQGZmZrvb6vV6PPPMMxgxYgT69+/fZrmKigpEREQYrYuIiEBFRYXJ8nV1dViyZAmmTp1qNGzjT3/6EwYPHoywsDDs2bMH6enpOH/+PNauXdtunDdiAkNERORBbr5IRaUyPzR4wYIF+P7777F7926bxaHT6fDII49AkiS88847Rs+lpaUZfo+Li4NSqcQTTzyBrKwsoXgBJjBEREQexdKLVFJTU/Hll19i165dZi8Vj4yMRGVlpdG6ysrKVmNZWpKXM2fO4OuvvzYbT3x8PBobG3H69GmzV0G14BgYIiIiLyRJElJTU/HPf/4TX3/9NXr16mV2m4SEBBQVFRmtKywsREJCguFxS/Ly888/Y8eOHejcubPZ/ZaWlkIulyM8PFw4frbAEBERuQBrx8BY+oW+YMECbN68Gf/6178QFBRkGMcSEhICtbo5kpkzZ6Jbt27IysoCACxcuBCjRo3Cq6++ivvuuw/5+fk4cOAA3n33XQDNyctDDz2EQ4cO4csvv0RTU5Nhv2FhYVAqlSgpKcG+ffswZswYBAUFoaSkBIsWLcIf//hHdOrUyW6vl4iIiDxAy7iU0aNHG61///338dhjjwEAysrKjKZQGD58ODZv3ozly5dj2bJluPXWW7FlyxbDwN/y8nJ88cUXAIBBgwYZ7Xfnzp0YPXo0VCoV8vPzkZmZifr6evTq1QuLFi0yGhcjggkMERGRF5IkyWyZ4uLiVusefvhhPPzwwybLx8bGmt3v4MGDsXfvXqEY28MxMEREROR2nJrA7Nq1CxMnTkR0dDRkMhm2bNlidpvi4mIMHjwYKpUKt9xyCzZu3Gj3OImIiOwtCECwFYv9ZmtyTU5NYGpqajBw4EDk5OQIlT916hTuu+8+jBkzBqWlpXjmmWfw+OOP46uvvrJzpERERORKnDoGZvz48Rg/frxw+dzcXPTq1QuvvvoqAOD222/H7t278dprryE5OdleYRIREZGLcatBvG3NwfDMM8+0uU19fb3RPBAajQZA86VeOp2uw7G0bBsZuQlarbnSIjcUEm38CxQoI3oZmsgxRW+GZDyHqlqtQ14eEBmpM64fkQldTU+C2ppIVfjbcF8iZQDh+NUhOuRNBiLn6KBtawqQEMFjisQmENfV/jccsFpgn7VWPg8ANaZX6+RqIC4PuuxIQK8FNDaIp53jOW0/HTyeTqUGMvOgGxYJ1GvbLGdKnWBcGoF9VYntCr8JlhN52wkdV62GT16eVed5AFZvT/bjVglMW3MwaDQaaLVaw3XrN8rKysKqVatard++fTv8/UW/3dqWlyd+zXr7bHmm+9WaQGwqL6/QfCEvlzfZdepoGz66/kDkrW2rt387CuPy7H8QN1aY6Z314yNY7uaZkS1VWyt6biZHc6sEpiPS09ONri3XaDSIiYnB2LFjLbrV8s10Oh0KCwuRkvIbW2AAmG6BKURKShK0WsX1J9gCY9DcAlOIlM+SoG1UmC7kyBaYSUD2nc/gVhxHd/wCNbTo8VvzDahktQDOADh1Q3mR87qVLTCFcXlI+jYFiitmP2RWH89p++ng8XQqNQoz85CUmQIFW2Bau9YCk5SUBIWijc+XgJZWe0cIgvjpzxTRpM5TuFUC09YcDMHBwSZbX4DmSaxMTQylUCiselO30GohkMCIEPlmB8TGXYu+jUX+/KJvEdN1qdUqLE9gbBm+6L6UAmUabLgvALjWbaRtVECra+O9KDq7fJNAGb2Z52uBfyomYhBKcQeOIAZncS68KzrjEmLrTyHgkr45UWr5hjF/CwnzxxQoo9BroWgS/JCJ1JdIGZFeA5Eyou+ZevNF2iqjqNcaJzB15nfVKFidvgLlRD9ioleMiJ4JRVl7rrfF9wTZh1slMAkJCdi2bZvRupvnYCCiDjoOHBveF51xCQBwCZ0Rg7NQoxZVqiAEhF9t7p0U/RfZlkIAXHXCcYnIZTn1Murq6mqUlpaitLQUQPNl0qWlpSgrKwPQ3P0zc+ZMQ/knn3wSJ0+exOLFi3H06FG8/fbb+Mc//oFFixY5I3wij1PboMYx3IaziEElIlALf1xCF2jhDykAgPg8a0REduXUFpgDBw5gzJgxhsctY1VmzZqFjRs34vz584ZkBgB69eqFrVu3YtGiRXj99dfRvXt3bNiwgZdQ25UG4uNgyN1d/SUCXXpfQi3UqIUal9AZnXERF9EZ4QGVCAjQAxEAKs3uiogsZO0YGG+7tb5TE5jRo0e3O2eCqbvsjh49GocPH7ZjVM5iy0ThMoAwG+2LvEY1gGqZodWlCy4Z/f6rKgKx4echa7nILQBiA1mJiOzA2xI2ImpPNVBZGY5aqHERnVGFIMPvtfBHbYC8uRtJ9IosIiI7YQJDJMoZg1cdqQpANaCvuT7u5RI6G/1epQpqbnnhWBgicjImMER0XUs3UsP1VpcqBBl+v4QuzYN5A8BWGBHWDGggona51WXUROQYVb8FQRvhbxjE29IC0xkXURkWgshfr/LLmcjGOsG6/wtEb0HlKdgCQ0Tt0sK/efzLjZdUh6O5G4lJDBE5CRMYIhLScmn1RXRuHswbgOZLqq3FJIiIOoAJDHk2XuZrF4bBvC1LW5icEJGdcAyMQ/BmcOR5pABA1jKYl4kikdWCID6trym2nkfK1bEFhohaCeokOscwEZFzMIFxO17wxeLp91shIiKrMYHxahob7ktrw30RERG1jwkMERG5FVv+60Xui4N4ich+OLiXSFiQPxBszUhcCUCtraJxfWyBsRoHbBARETkaExgiIiJyO0xgiIiIyO1wDAwRORfHyRABANT+gNqKZgWdHhwDQ87CsfVEROQ4u3btwsSJExEdHQ2ZTIYtW7aY3WbTpk0YOHAg/P39ERUVhZSUFFy6dMmozCeffIJ+/frBz88PAwYMwLZt24yelyQJK1euRFRUFNRqNRITE/Hzzz9bFDsTGCIiIi9VU1ODgQMHIicnR6j8N998g5kzZ2LOnDn44Ycf8Mknn2D//v2YO3euocyePXswdepUzJkzB4cPH8akSZMwadIkfP/994YyL730Et544w3k5uZi3759CAgIQHJyMurq6oRjZxcSERGRlxo/fjzGjx8vXL6kpASxsbH405/+BADo1asXnnjiCbz44ouGMq+//jrGjRuHZ599FgCwZs0aFBYW4q233kJubi4kScK6deuwfPlyPPDAAwCADz/8EBEREdiyZQseffRRoVjYAuOxLjs7ACIicgKNRmO01NfX22zfCQkJOHv2LLZt2wZJklBZWYlPP/0UEyZMMJQpKSlBYmKi0XbJyckoKSkBAJw6dQoVFRVGZUJCQhAfH28oI4IJDBERuQQvmOmtfYE2WADExMQgJCTEsGRlZdksxBEjRmDTpk2YMmUKlEolIiMjERISYtQFVVFRgYiICKPtIiIiUFFRYXi+ZV1bZUQwgSEiIvIgZ8+exdWrVw1Lenq6zfZ95MgRLFy4ECtXrsTBgwdRUFCA06dP48knn7TZMURxDAwJ0AAIdnYQREQkIDg4GMHB9jlnZ2VlYcSIEYbxLXFxcQgICMDIkSPx/PPPIyoqCpGRkaisrDTarrKyEpGRkQBg+FlZWYmoqCijMoMGDRKOhS0wDsNLpImIyL3V1tZCLjdOHXx8fAA0XxoNNI+TKSoqMipTWFiIhIQEAM0DfyMjI43KaDQa7Nu3z1BGBFtgiIiIXIE/AB8rtm+yfJPq6mocP37c8PjUqVMoLS1FWFgYevTogfT0dJSXl+PDDz8EAEycOBFz587FO++8g+TkZJw/fx7PPPMMhg0bhujoaADAwoULMWrUKLz66qu47777kJ+fjwMHDuDdd98FAMhkMjzzzDN4/vnnceutt6JXr15YsWIFoqOjMWnSJOHYmcCQY0kArJltlYiIbObAgQMYM2aM4XFaWhoAYNasWdi4cSPOnz+PsrIyw/OPPfYYqqqq8NZbb+F//ud/EBoainvuucfoMurhw4dj8+bNWL58OZYtW4Zbb70VW7ZsQf/+/Q1lFi9ejJqaGsybNw9XrlzB3XffjYKCAvj5+QnHzgSGyN0FOTsAInJXo0ePNnT9mLJx48ZW655++mk8/fTT7e734YcfxsMPP9zm8zKZDKtXr8bq1auFY70Zx8C4Ja+/2JCI7EzDOarIxTGBsQkmFERERI7ELiRyX9Uw3LiJyCWxFYMs4Q/rvpUbbRWIe2ALDBG5vqvODoCIXA0TGCIiInI7TGC8Hm+wR0RE7odjYIiIPEW1swMgqwSAY2AswBYYl8MWESLyLJedHQB5JCYwRERE5HaYwBARkcdhW7bn4xgYIiIiV+APQGHF9jpbBeIe2AJDNqR1dgBEROQlmMAQERGR22EC41DslSUiIrIFJjAejRcvCuN8nEREboWDeInIM3DiRK/g0e3YAeAgXguwBYaIiIjcDhMYIiIicjtMYGyGgyiIiIgchWNgiIiIXIE/AKUV2zfYKhD3wBYYIiIicjtMYNwWu6yIiMh7MYEhQQ6+eLHasYcjIst59CXN5PKYwBARORPvX0PUIRzES0RETsdOcTQP4lVZsb2XfaOzBYaIvAdbO6BlHZCHYAJDREREbocJjEvi0DgiIqL2eFmPGRERkYsKgXVjYOptFYh7cHoLTE5ODmJjY+Hn54f4+Hjs37+/3fLr1q1D3759oVarERMTg0WLFqGurs5B0RIRkatjG7a4Xbt2YeLEiYiOjoZMJsOWLVvaLV9cXAyZTNZqqaioMJSJjY01WWbBggWGMqNHj271/JNPPmlR7E5tgfn444+RlpaG3NxcxMfHY926dUhOTsaxY8cQHh7eqvzmzZuxdOlS5OXlYfjw4fjpp5/w2GOPQSaTYe3atU54BURERO6rpqYGAwcOREpKCh588EHh7Y4dO4bg4GDD4xu/s//v//4PTU1Nhsfff/89kpKS8PDDDxvtY+7cuVi9erXhsb+/v0WxOzWBWbt2LebOnYvZs2cDAHJzc7F161bk5eVh6dKlrcrv2bMHI0aMwLRp0wA0Z3lTp07Fvn372jxGfX096uuvt6tpNM25uU6ng06n63DsLduq1bIO76N9kkAZvUCZJvNF8BuAIIFyjQJlWurF+KcR0Srzs1EZ0SZZkTlIRMooxA6n9tUZ/TRJ5BPqI3Y8s+2tLc/rAT9dI1QyPZSQ4AsZ5JBDBl8ACuihQiP8oGtsgKzlLdjW31SkjbeNMjq5+vpPkdcoUleiZzyRv6FIGZH3i8jHykQ5nUpt9FN0X40ipw3BciJnF0DsTCVyxrOI+lr9WHGet8X2rm78+PEYP368xduFh4cjNDTU5HNdu3Y1epydnY0+ffpg1KhRRuv9/f0RGRlp8bFbOC2BaWhowMGDB5Genm5YJ5fLkZiYiJKSEpPbDB8+HH//+9+xf/9+DBs2DCdPnsS2bdswY8aMNo+TlZWFVatWtVq/fft2i7M9U/Lyulu9D9NqbVTmV2sDsUpeXqFTj+8O8ia7WB2dubYYdL22NKu4thgoAHSzXziFcXn227kHKMz0rvoRyWU73fB7YaF1n6/aWpHzrGtp+Ue9hUqlgkplzeCa1gYNGoT6+nr0798fmZmZGDFihMlyDQ0N+Pvf/460tDTIZMb/6WzatAl///vfERkZiYkTJ2LFihUWfS87LYG5ePEimpqaEBERYbQ+IiICR48eNbnNtGnTcPHiRdx9992QJAmNjY148sknsWzZsjaPk56ejrS0NMNjjUaDmJgYjB071qj5y1I6nQ6FhYVISfkFWm3L/w6BgluLHFekRUTkeJ3MFxE+nkjczU0iarUOeXmFSElJglZ707+qoi0wAQJlRKpA9PMgsi+RMiJxA1CH6JA3uRApnyVB29jGv/MhNopJJK4AAH0A9AaCb61EZ+Vv6I5f0A3l6IEzCMNlw+Nu+AXhv2kga0l22sqTRc79bdyXRCdXozAuD0nfpkBxRWt+P1Ycy277stX/ISaOp1OpUZiZh6TMFCjqtcIx1QkeTyOwL9Gbz/0mUEZ09hCRY2oAQK1Gp7w8JCUlQaEQbBY1tS+NA0fU+EOsVbkt17K7mJgYo9UZGRnIzMy0YsfXRUVFITc3F0OHDkV9fT02bNiA0aNHY9++fRg8eHCr8lu2bMGVK1fw2GOPGa2fNm0aevbsiejoaHz77bdYsmQJjh07hs8//1w4Fre6Cqm4uBgvvPAC3n77bcTHx+P48eNYuHAh1qxZgxUrVpjcpq3MU6FQWPWmbqHVSjckMLYk8i0v0j4v2r9gq/Z34zrVahWtExhA7OXZqttAtApEmvtFpqsX2Q9gaO7XNiqg1bXxXhTpXrBVO37L83JAqfBFvUKOBsjQCAl66CGhEYAOctTDF3VQ+Goha3kLtvUREOk7MFNGoddC0SSQwIjUlWh3jUivgUgZkfeL6JUjbZRT1GuvJzAC1zM0ClQlAPgKlLNV7yUg/n+Npaw919vie8LRzp49a/QPui1bX/r27Yu+ffsaHg8fPhwnTpzAa6+9hr/97W+tyr/33nsYP348oqOjjdbPmzfP8PuAAQMQFRWFe++9FydOnECfPn2EYnFaAtOlSxf4+PigsrLSaH1lZWWbfWIrVqzAjBkz8PjjjwNoftE1NTWYN28ennvuOcjlTr+oiojcnSveqdYVYxJ02dkBeKHg4GCrehgsNWzYMOzevbvV+jNnzmDHjh1CrSrx8fEAgOPHjwsnME77xlcqlRgyZAiKiooM6/R6PYqKipCQkGBym9ra2lZJio9P8/8AkmSPVhBLcTYPIiLyLqWlpYiKimq1/v3330d4eDjuu+8+oX0AMLmftji1CyktLQ2zZs3C0KFDMWzYMKxbtw41NTWGq5JmzpyJbt26ISsrCwAwceJErF27FnfddZehC2nFihWYOHGiIZEhIiLP5PH3d/EHoDZbqm0daJKorq7G8ePHDY9PnTqF0tJShIWFoUePHkhPT0d5eTk+/PBDAM33YuvVqxfuvPNO1NXVYcOGDfj666+xfft2o/3q9Xq8//77mDVrFnx9jVONEydOYPPmzZgwYQI6d+6Mb7/9FosWLcLvf/97xMXFCcfu1ARmypQpuHDhAlauXImKigoMGjQIBQUFhoG9ZWVlRi0uy5cvh0wmw/Lly1FeXo6uXbti4sSJ+Mtf/uKsl+AGLgMIc3YQRORGRAbwkmc4cOAAxowZY3jcctHLrFmzsHHjRpw/fx5lZWWG5xsaGvA///M/KC8vh7+/P+Li4rBjxw6jfQDAjh07UFZWhpSUlFbHVCqV2LFjh6HRIiYmBpMnT8by5cstit3pg3hTU1ORmppq8rni4mKjx76+vsjIyEBGRoYDIiMiIvJso0ePbncIxsaNG40eL168GIsXLza737Fjx7a535iYGPz73/+2KE5TOOqVyBuIXmpNROQmmMAQERGR23F6FxKR3dVA+OZyREROEwCHD+J1Z172comIbICDXImcjgmMW3PF+84I3uaTiIjICkxgiMg+2ErhWKKTCbkgV/xXjFwfx8AQERG5ggCITz5ripc1SXjZyyUiIltw1bviumpcZHtMYFwWP4ZERERtYQJDRM7DcTJE1EFMYIiIiMjtcBAvEZE9sHWJLGXtIF6ZrQJxD2yBcQqObyEiIrIGExiyABMvcgK+7YjIBCYwNsdbMhGRa9K6cbcW81i6GcfAEBERuQJ/cOJZC7AFhoiI7OKyswMgj8YEhoiIiNwOExhyb248gR3ZkLuO7XDXuIlcAMfA0DUaAMHODoKIyHtZOwZGslUg7oEtMEREROR2mMAQEZGBht1a5CaYwBARkUfgvWK8CxMYIuoQGf9TJxvgrT+poziI1ytcBhDm7CCInMtdEy53jZssFwAO4rUAW2CIiIjI7TCBISIiIrfDBIaIiIjcDsfAuL0qAEHODoKIvAiv9rETa29kp7dVIO6BLTBERC04YJa8zK5duzBx4kRER0dDJpNhy5Yt7ZbfvXs3RowYgc6dO0OtVqNfv3547bXXjMpkZmZCJpMZLf369TMqU1dXhwULFqBz584IDAzE5MmTUVlZaVHsbIEhIiKXxhYf+6mpqcHAgQORkpKCBx980Gz5gIAApKamIi4uDgEBAdi9ezeeeOIJBAQEYN68eYZyd955J3bs2GF47OtrnG4sWrQIW7duxSeffIKQkBCkpqbiwQcfxDfffCMcOxMYl+bl8xNVAwh0dhBEboCTmlIHjR8/HuPHjxcuf9ddd+Guu+4yPI6NjcXnn3+O//znP0YJjK+vLyIjI03u4+rVq3jvvfewefNm3HPPPQCA999/H7fffjv27t2L//qv/xKKhV1IREREHkSj0Rgt9fX1djvW4cOHsWfPHowaNcpo/c8//4zo6Gj07t0b06dPR1lZmeG5gwcPQqfTITEx0bCuX79+6NGjB0pKSoSPzQTGadgoSkRE10n+gBRgxeLfvJ+YmBiEhIQYlqysLJvH2r17d6hUKgwdOhQLFizA448/bnguPj4eGzduREFBAd555x2cOnUKI0eORFVV832XKyoqoFQqERoaarTPiIgIVFRUCMfALiQiIktwoK+Qy84OwIudPXsWwcHXhx+oVCqbH+M///kPqqursXfvXixduhS33HILpk6dCgBGXVJxcXGIj49Hz5498Y9//ANz5syxWQxMYOyClzYTEZFzBAcHGyUw9tCrVy8AwIABA1BZWYnMzExDAnOz0NBQ3HbbbTh+/DgAIDIyEg0NDbhy5YpRK0xlZWWb42ZMYRcSEdkeWylcjtbD/ybslHcevV7f7jib6upqnDhxAlFRUQCAIUOGQKFQoKioyFDm2LFjKCsrQ0JCgvBx2QJDRETkAmoDZPANkHV8+yYJls7oWF1dbWgZAYBTp06htLQUYWFh6NGjB9LT01FeXo4PP/wQAJCTk4MePXoY7uuya9cuvPLKK/jTn/5k2Mef//xnTJw4ET179sS5c+eQkZEBHx8fQwtNSEgI5syZg7S0NISFhSE4OBhPP/00EhIShK9AApjAEBERea0DBw5gzJgxhsdpaWkAgFmzZmHjxo04f/680RVEer0e6enpOHXqFHx9fdGnTx+8+OKLeOKJJwxlfvnlF0ydOhWXLl1C165dcffdd2Pv3r3o2rWrocxrr70GuVyOyZMno76+HsnJyXj77bctip0JDDmHBKDj/2gQuTYP766xlSpnB0AYPXo0JKntVpuNGzcaPX766afx9NNPt7vP/Px8s8f18/NDTk4OcnJyhOI0hWNgiEiIP7S23SG/5InICkxgiIgIAKBhUkluhF1IRERELqBaFQSZquN969UqCd50PRZbYIiIiMjtMIEhInIGdtcI8Z72BLIUExiyAxsP9iQiIroJx8AQEZEwtojYjxZq+FrRrqCFHt70F2ILDBEREbkdJjBE5N48eSyJJ782IisxgSELeU/zpF0FODsAIs/Bs5J3YgJDREQ2ddnZAZBX4CBeIiIiF6CFP3ysHsTrPdgCQzdgQyx5KE8eS+LJr42oHUxgiIiIyO0wgfEa7JUmItdR5ewAyO1xDIxHqAIQ5OwgiIjICrXwgxw+VmzfZMNoXJ/TW2BycnIQGxsLPz8/xMfHY//+/e2Wv3LlChYsWICoqCioVCrcdttt2LZtm4OidQaOSyFyCA8eS6L14NdG3supLTAff/wx0tLSkJubi/j4eKxbtw7Jyck4duwYwsPDW5VvaGhAUlISwsPD8emnn6Jbt244c+YMQkNDHR+8WSKtIhoAwQ6IhYiIyLM4NYFZu3Yt5s6di9mzZwMAcnNzsXXrVuTl5WHp0qWtyufl5eHy5cvYs2cPFAoFACA2NrbdY9TX16O+vt7wWKNpbtHQ6XTQ6XQdjr1lW7Va1uF9iJMEyohcPifSvNhokzJqtXTtZzt1LFJ1fjYqoxIoo7RRGYVYGbXvtfeQbzt1JPIJFWlxFmlrbSmjB/x0jVDJ9FBCgi9kkEMOGXwBKKCHCo3wg66p4frb7ua/pSXHa4NOrm7+6aNuv6BIHYmUEfm7iZYTeZ9Y+VHTqa7Vj5+Z+gHQKHh1rUg5kbOIyOFEzmpWjZNRX6sfK87zttie7EcmSZLI+8jmGhoa4O/vj08//RSTJk0yrJ81axauXLmCf/3rX622mTBhAsLCwuDv749//etf6Nq1K6ZNm4YlS5bAx8f0WTwzMxOrVq1qtX7z5s3w9/e32eshIiLPU1tbi2nTpuHq1asIDrZPi7lGo0FISAi+vno7AoM7PgamWtOEe0J+tGusrsRpLTAXL15EU1MTIiIijNZHRETg6NGjJrc5efIkvv76a0yfPh3btm3D8ePH8dRTT0Gn0yEjI8PkNunp6UhLSzM81mg0iImJwdixY636A+t0OhQWFiIl5RdotW3lgIECexKJQWSArsixOtnoWOZjVqt9kJdXiJSUJGi1bfzLKtICI3LLfZGXLpKriuxHpIxIzAHNLS95kwuR8lkStI1t1FGIY2NCHwC9geBbK9FZ+Ru64xd0Qzl64Ay6oxxhuIRuKEc3/IKIcg1wAcAZAL/etK9ageOZGZehk6tRGJeHpG9SoGjStl3QBsey6X5E92Xl8XQqNQoz85C0OAWKunbqB0CdwLE0gq9NpFXkN4Ey1TY6FtDGSEG1Gp3y8pCUlGRose+IllZ7R6iDP3ysGMRb52WDeN3qKiS9Xo/w8HC8++678PHxwZAhQ1BeXo6XX365zQRGpVJBpWrdf6BQKKx6U7fQaqV2EhhbEfmmF2mzF/lg2Ko9vrmMVquwLoGxVcgi+xFp9m+w0X5uaJXWNiqg1bVRRyLdDLZq028pIweUCl/UK+RogAyNkKCHHhIaAeggRz18UQeFj/b62+7mj4AlxzND0aRtP4GxTa+n0d/EqjKA2Puk3nwRkTKKOq3ZBKax/acBAL4CZQDb9Vg6ovMdsP5cb4vvCbIPpyUwXbp0gY+PDyorK43WV1ZWIjIy0uQ2UVFRUCgURt1Ft99+OyoqKtDQ0AClUuSbg4hEqIWaCIici9dpei+nXUatVCoxZMgQFBUVGdbp9XoUFRUhISHB5DYjRozA8ePHoddf/9ftp59+QlRUFJMX8jyhzg6gg7z9kl0Pfv1MFsiVOPU+MGlpaVi/fj0++OAD/Pjjj5g/fz5qamoMVyXNnDkT6enphvLz58/H5cuXsXDhQvz000/YunUrXnjhBSxYsMBZL4GIiMgmaqFGLfytWMxfkeZJnDoGZsqUKbhw4QJWrlyJiooKDBo0CAUFBYaBvWVlZZDLr+dYMTEx+Oqrr7Bo0SLExcWhW7duWLhwIZYsWeKsl0BERERO4PRBvKmpqUhNTTX5XHFxcat1CQkJ2Lt3r52jIiK78uBuFiEe/Po56xo5itOnEiAiIiKylNNbYIiIiAjQwg8y4VtCm9reu+4azBYYIiJX5MHdTFZNEUA2tWvXLkycOBHR0dGQyWTYsmVLu+XPnz+PadOm4bbbboNcLsczzzzTqsz69esxcuRIdOrUCZ06dUJiYmKriZofe+wxyGQyo2XcuHEWxc4Ehsididw42V3xml0iu6upqcHAgQORk5MjVL6+vh5du3bF8uXLMXDgQJNliouLMXXqVOzcuRMlJSWGu9+Xl5cblRs3bhzOnz9vWD766COLYmcXEhERkZcaP348xo8fL1w+NjYWr7/+OoDmCZZN2bRpk9HjDRs24LPPPkNRURFmzpxpWK9Sqdq8ca0ItsAQEZHLYQNcx2k0GqOlvl5k3gr7qa2thU6nQ1hYmNH64uJihIeHo2/fvpg/fz4uXbpk0X7ZAkNE7suDx4mQ99HC3yaDeGNiYozWZ2RkIDMz05rQrLJkyRJER0cjMTHRsG7cuHF48MEH0atXL5w4cQLLli3D+PHjUVJSYjRdUHuYwBAReTCtByd5bKUx7ezZswgODjY8NjWhsaNkZ2cjPz8fxcXF8PPzM6x/9NFHDb8PGDAAcXFx6NOnD4qLi3HvvfcK7ZtdSESeLtDZARCRIwUHBxstzkpgXnnlFWRnZ2P79u2Ii4trt2zv3r3RpUsXHD9+XHj/bIEhIvJyGg9upSHneOmll/CXv/wFX331FYYOHWq2/C+//IJLly4hKipK+BhMYIjIs/HLmdyEFmoASiu2b7B4m+rqaqNWj1OnTqG0tBRhYWHo0aMH0tPTUV5ejg8//NBQprS01LDthQsXUFpaCqVSiTvuuAMA8OKLL2LlypXYvHkzYmNjUVFRAQAIDAxEYGAgqqursWrVKkyePBmRkZE4ceIEFi9ejFtuuQXJycnCsTOBISIi8lIHDhzAmDFjDI/T0tIAALNmzcLGjRtx/vx5lJWVGW1z1113GX4/ePAgNm/ejJ49e+L06dMAgHfeeQcNDQ146KGHjLZrGUzs4+ODb7/9Fh988AGuXLmC6OhojB07FmvWrLGou4sJDBERmcUBs55p9OjRkCSpzec3btzYal175QEYEpm2qNVqfPXVVyLhtYuDeIkICHB2AE7GbiYit8MEhoiIbOKyswMgr8IuJCIiIheghRqSFYN46yB2AzhPwRYYu+Kcq0Qeg91MNsGzItkKExin49A4IiIiS1mUwPy///f/8Pzzz+Ptt9/GxYsXjZ7TaDRISUmxaXBERG6FrTQ2wX/rSIRwArN9+3YMGzYM+fn5ePHFF9GvXz/s3LnT8LxWq8UHH3xglyCJH2dyUfzCJrIZLdTQwt+KRe3sl+BQwglMZmYm/vznP+P777/H6dOnsXjxYtx///0oKCiwZ3xERESt8N86Er4K6YcffsDf/vY3AIBMJsPixYvRvXt3PPTQQ8jPz8fvfvc7uwVJIqoABDk7CPJ2bJExj3VEZBPCCYxKpcKVK1eM1k2bNg1yuRxTpkzBq6++auvYiIi8E5McIrOEE5hBgwZh586dGDJkiNH6Rx99FJIkYdasWTYPjoiIiMgU4QRm/vz52LVrl8nnpk6dCkmSsH79epsFRvZwGUCYs4MgIltgK43H0cIfeohPZnizet7IzrQ//OEPeO2119p8ftq0aUZXJX300UeoqeEnzP1waBzZGU8LDqNlXZMHs9uN7J544glUVlbaa/dERETkxeyWwJibbpuIiJxPw1YaclOczJGIXM9VwMu6810aO5YdowqBaIBfh7evh8KG0bg+zoVEHcDTGREZu+zsAMjrMIEhIiKH4EzUZEtMYIioGW/kTC6A7bskyuIE5sZLpW/217/+1fB7z549oVB4V38cETkQB596LSY5BHQggRk3bhyeffZZ6HQ6w7qLFy9i4sSJWLp0qWHd999/j5iYGNtESW6oztkBEJEXq3Z2AB2ghRq1ViycjdqMnTt34p///Cd+97vf4ciRI9i6dSv69+8PjUaD0tJSO4RIREREZMziBGb48OEoLS1F//79MXjwYPzhD3/AokWLUFxcjJ49e9ojRiKijmE3E5HH6tAg3p9++gkHDhxA9+7d4evri2PHjqG2ttbWsRERERGZZHECk52djYSEBCQlJeH777/H/v37cfjwYcTFxaGkpMQeMRIR2Q9bachFaKGGFv5WLBwD067XX38dW7ZswZtvvgk/Pz/0798f+/fvx4MPPojRo0fbIUQiIiIiYxZPJfDdd9+hS5cuRusUCgVefvll/Pd//7fNAiMvIAGQOTsIIgFspSFyORa3wNycvNxo1KhRVgVDREREJIJ34iUisgW20hA5FBMYIiJHYZJD7Wi+kZ1/h5eODuLNyclBbGws/Pz8EB8fj/3797dZVqfTYfXq1ejTpw/8/PwwcOBAFBQUWLzPuro6LFiwAJ07d0ZgYCAmT56MyspKi+JmAkNEwvyhdXYIno9JDjnQxx9/jLS0NGRkZODQoUMYOHAgkpOT8euvv5osv3z5cvz1r3/Fm2++iSNHjuDJJ5/EH/7wBxw+fNiifS5atAj/+7//i08++QT//ve/ce7cOTz44IMWxc4EhojI3QjcJ18rkAhpRMqYL4LLAmXINa1duxZz587F7NmzcccddyA3Nxf+/v7Iy8szWf5vf/sbli1bhgkTJqB3796YP38+JkyYgFdffVV4n1evXsV7772HtWvX4p577sGQIUPw/vvvY8+ePdi7d69w7Exg7I4TyBMRiZwJRZIlkTLeftbVaDRGS319vclyDQ0NOHjwIBITEw3r5HI5EhMT27yvW319Pfz8/IzWqdVq7N69W3ifBw8ehE6nMyrTr18/9OjRw6L7yTGBISIicgHWTOTYsgBATEwMQkJCDEtWVpbJ4128eBFNTU2IiIgwWh8REYGKigqT2yQnJ2Pt2rX4+eefodfrUVhYiM8//xznz58X3mdFRQWUSiVCQ0OFj2uKxfeBIXKoagCBzg6CiMh9nD17FsHBwYbHKpXKZvt+/fXXMXfuXPTr1w8ymQx9+vTB7Nmz2+xysie2wBCRbXDwKZFLCA4ONlraSmC6dOkCHx+fVlf/VFZWIjIy0uQ2Xbt2xZYtW1BTU4MzZ87g6NGjCAwMRO/evYX3GRkZiYaGBly5ckX4uKYwgSEiIvJCSqUSQ4YMQVFRkWGdXq9HUVEREhIS2t3Wz88P3bp1Q2NjIz777DM88MADwvscMmQIFAqFUZljx46hrKzM7HFvxC4kIiIiF1AHNRrh3+HtGyFZvE1aWhpmzZqFoUOHYtiwYVi3bh1qamowe/ZsAMDMmTPRrVs3wziaffv2oby8HIMGDUJ5eTkyMzOh1+uxePFi4X2GhIRgzpw5SEtLQ1hYGIKDg/H0008jISEB//Vf/yUcOxMYl6ABEGy2FBERkS1NmTIFFy5cwMqVK1FRUYFBgwahoKDAMAi3rKwMcvn1zpq6ujosX74cJ0+eRGBgICZMmIC//e1vRgNyze0TAF577TXI5XJMnjwZ9fX1SE5Oxttvv21R7ExgiMhxOE6GyOWkpqYiNTXV5HPFxcVGj0eNGoUjR45YtU+guQsqJycHOTk5FsV6I46BISIiIrfDBIaIiIjcDruQiMi1XHV2AETOoYU/fKwYxNvUgUG87swlWmAsmQnzRvn5+ZDJZJg0aZJ9AyQiIiKX4vQExtKZMFucPn0af/7znzFy5EgHRepsIjOAEBEReQenJzCWzoQJAE1NTZg+fTpWrVpluPsfEXkRXs3kcTiRI1nKqWNgWmatTE9PN6wzNxMmAKxevRrh4eGYM2cO/vOf/7R7jPr6eqOZODWa5o+ATqeDTqfrcOwt26rVsg7vw3Lm+jf1AvtoEijTaHUZtbrx2k8zdSxSfX5WPg8AIlOBKG1URiFWRu177T3k20YdiXw6fQTKiPybIsf1v4Ue8NM1QiXTQwkJvpBBDjlk8IUEJfRQoRF+0DU1XH9Lyiw4jjnXXpPOR23004jomUuknODfyyyR94b1Hy1DGZ3ftfrxM1E/ABoFTgciZUTOGOZ2Uy2wD1tpeRvL1Nfqx4rzvC22t0Qt/OAD039PEU1Cfy3P4dQEpr1ZK48ePWpym927d+O9995DaWmp0DGysrKwatWqVuu3b98Of/+OD5ZqkZfX3ep9iKu18nkAaL9rztby8godejx3lDfZxerozLXFoOu1ZSgaAFRcWwwUALrZL5zCEY6fJM6dFL7kGfUjkot36kCZwkLrPl+1tSLnVXIGt7oKqaqqCjNmzMD69evRpUsXoW3S09ORlpZmeKzRaBATE4OxY8cazdZpKZ1Oh8LCQqSk/AKt1lzLiMh0yiKxBNngOCKnAHPHAczFq1Y3Ii9vF1JSkqDVtvPvq0gLTICZ50VetkiuKrIfkTLm4r1WRu2rQ97kQqR8lgRto4k6CnFsPAgEEAGgNxB8ayW6K8vRGZfRDeXogTPojnJ0QznCcAnd8AsiyjXNic4FNOfFIud5ka6fa/0EOh81CkfkIembFCiatMZlbHUsW+5LZD+2OlZNc8tL4Ut5SFqcAkWdtlWROoFjacwcS6Q75jeBMiItMCLHEulCajmWTK1G97w8JCUlQaEQaUJr45gajj90VU5NYCydCfPEiRM4ffo0Jk6caFin1zc3Xvr6+uLYsWPo06eP0TYqlcrkTJwKhcKqN3ULrVYSSGBsxdy3vQXt8+0SeVuIvXW0WoX1CYy5kG3V1SLSBdBgo/3c0CqtbVRAqzNRRyJdCbZo328p0/I2lgNKhS/qFXI0QIZGSNBDDwmNkKEBctTDF3VQ+Giv//0kC45jzk2vSdGkbZ3A2KorBjD6W1hVRuS9UW++iFCZuuu/Kuq0JhOYxtarjGhqzH90bNVD6cyOdmvP9bb4niD7cOogXktnwuzXrx++++47lJaWGpb7778fY8aMQWlpKWJiYhwZPhG5Ow8dDKz10NdFdCOndyFZMhOmn58f+vfvb7R9ywRSN68nIrIJV0sGHDkilhyqDv6QW3EjO71QE6fncHoCY+lMmERELkdw3IpNyhARABdIYADLZsK82caNG20fkNuqgtgAXKIbiAzyJSJyMWzaICIiIrfjEi0wRERE3q4WaivHwHjXjezYAkPkyUTuE0NE5IaYwBARkUfgPEjehQkMERERuR0mMFZjzk9EZG+8oT/djIN4iYjIqZicNNM2qCFr6Phs1FKD6PwZnoEtMEREROR2mMAQuSves5DcADvZyV6YwBAREZHb4RgYIiLqkMvODsDDVF0JhKyp402rUpVkw2hcH1tgvA5POWRjnB2ZiJyACQwRWY+zKBORgzGBISKiVnhpM7k6JjBE1CY1ap0dAhGRSUxgHIIXEhKR69Cwy88lSTX+0FuxSDUdm8k6JycHsbGx8PPzQ3x8PPbv399u+StXrmDBggWIioqCSqXCbbfdhm3bthmej42NhUwma7UsWLDAUGb06NGtnn/yySctiptXIRG5olBnB2AH/NIkcjkff/wx0tLSkJubi/j4eKxbtw7Jyck4duwYwsPDW5VvaGhAUlISwsPD8emnn6Jbt244c+YMQkNDDWX+7//+D01NTYbH33//PZKSkvDwww8b7Wvu3LlYvXq14bG/v2UJGBMYIiJye2zn7pi1a9di7ty5mD17NgAgNzcXW7duRV5eHpYuXdqqfF5eHi5fvow9e/ZAoVAAaG5xuVHXrl2NHmdnZ6NPnz4YNWqU0Xp/f39ERkZ2OHZ2IREReRAtW7q8nkajMVrq6+tNlmtoaMDBgweRmJhoWCeXy5GYmIiSkhKT23zxxRdISEjAggULEBERgf79++OFF14wanG5+Rh///vfkZKSAplMZvTcpk2b0KVLF/Tv3x/p6emorbVszB1bYIiIyKV5zRVRNTLgpi95i7cHEBMTY7Q6IyMDmZmZrYpfvHgRTU1NiIiIMFofERGBo0ePmjzEyZMn8fXXX2P69OnYtm0bjh8/jqeeego6nQ4ZGRmtym/ZsgVXrlzBY489ZrR+2rRp6NmzJ6Kjo/Htt99iyZIlOHbsGD7//HPhl8sEhohcx1VnB+DieNNAEnD27FkEBwcbHqtUKpvtW6/XIzw8HO+++y58fHwwZMgQlJeX4+WXXzaZwLz33nsYP348oqOjjdbPmzfP8PuAAQMQFRWFe++9FydOnECfPn2EYmECQ0RE5EGCg4ONEpi2dOnSBT4+PqisrDRaX1lZ2ebYlKioKCgUCvj4+BjW3X777aioqEBDQwOUSqVh/ZkzZ7Bjxw6hVpX4+HgAwPHjx4UTGI6BISJyBV46dsVruodckFKpxJAhQ1BUVGRYp9frUVRUhISEBJPbjBgxAsePH4derzes++mnnxAVFWWUvADA+++/j/DwcNx3331mYyktLQXQnCCJYgJDRO7FS7/oyQvUoLmbsKNLBz4baWlpWL9+PT744AP8+OOPmD9/PmpqagxXJc2cORPp6emG8vPnz8fly5excOFC/PTTT9i6dSteeOEFo3u8AM2J0Pvvv49Zs2bB19e4s+fEiRNYs2YNDh48iNOnT+OLL77AzJkz8fvf/x5xcXHCsbMLiYjI3ph0kYuaMmUKLly4gJUrV6KiogKDBg1CQUGBYWBvWVkZ5PLrbR0xMTH46quvsGjRIsTFxaFbt25YuHAhlixZYrTfHTt2oKysDCkpKa2OqVQqsWPHDqxbtw41NTWIiYnB5MmTsXz5cotiZwJDRJ7HkQkDk5M28d4s7iE1NRWpqakmnysuLm61LiEhAXv37m13n2PHjoUkSSafi4mJwb///W+L47wZu5CIyDuJJB5MTohcFhMYIiIicjvsQiJytABnB0BELqkagOleFzFe1mLIFhiXwYsJich9XHZ2AOT1mMAQERGR22ECQ0REbo1XO3knjoEhIiJyBTWwbgyMZZM5uz22wBARkRGOyCN3wASGiIiI3A4TGDKB/38RkWvg2YjawgSGiIiI3A4H8RIREbmCGgB6K7bX2ioQ98AWGCIiL6Lxsru1kudiAkNERE7B8S1kDSYwRERE5HY4BobIlgKdHQARua1qAE1WbM8xMERE5I60HN9CXoQJDBEREbkdJjBERGRznGCR7I0JDJE3C3B2AEREHcNBvERERK6gGkCjFdvX2SoQ98AWGJvg3QyIyM6qnR2Aa2JXlfdiAkNERERuhwmMW2FLDxEREcAxMEREZKHLzg7AU9XCuhvZ1dsqEPfAFhgiIiJyO0xgiIicjXfQNYmd5tQeJjBEnorzMhGRB2MCQ66NX8JERGQCB/ESERG5gmoAOiu25yBex8vJyUFsbCz8/PwQHx+P/fv3t1l2/fr1GDlyJDp16oROnTohMTGx3fJERETUNku+g2+Un58PmUyGSZMmGa1/7LHHIJPJjJZx48YZlbl8+TKmT5+O4OBghIaGYs6cOaiutuxujU5PYD7++GOkpaUhIyMDhw4dwsCBA5GcnIxff/3VZPni4mJMnToVO3fuRElJCWJiYjB27FiUl5c7OHLyOt7QnSXwGv2htX8c5DQcOOtdLP0ObnH69Gn8+c9/xsiRI00+P27cOJw/f96wfPTRR0bPT58+HT/88AMKCwvx5ZdfYteuXZg3b55FsTs9gVm7di3mzp2L2bNn44477kBubi78/f2Rl5dnsvymTZvw1FNPYdCgQejXrx82bNgAvV6PoqIiB0dORCSAVxiRg2k0GqOlvr7tviVLv4MBoKmpCdOnT8eqVavQu3dvk2VUKhUiIyMNS6dOnQzP/fjjjygoKMCGDRsQHx+Pu+++G2+++Sby8/Nx7tw54dfp1DEwDQ0NOHjwINLT0w3r5HI5EhMTUVJSIrSP2tpa6HQ6hIWFmXy+vr7e6I+n0TT/f6HT6aDTdbyzsWVbtbolB5R1eF+Wkcw8rxfYh8idkszNKNb+82p147WfZurYXLX5mXletIxKoIzSyucBQCFeRu2rM/ppROST6WPmeZF/T24sI0Pz20sP+OkaoZLpoQDgCxnkkEMGX0hQQg8VGuEHXVPD9bejpcdqyw2vSeejNvppIFI3ImUs+Fu1y9z7QmRyvg6U0fmpjX4CQKPAx99cGZGzg8hZxtyZylZzGLV1CpGpr9WPFed5W2xvkWoADVZsf23bmJgYo9UZGRnIzMxsXbyD38GrV69GeHg45syZg//85z8myxQXFyM8PBydOnXCPffcg+effx6dO3cGAJSUlCA0NBRDhw41lE9MTIRcLse+ffvwhz/8QejlOjWBuXjxIpqamhAREWG0PiIiAkePHhXax5IlSxAdHY3ExESTz2dlZWHVqlWt1m/fvh3+/v6WB32TvLx+Vu/DMrVWPg8A7TcN2lJeXqHDjuWu8ia7UB3VAThzbQHQnFF0vbYMRQOAkzdv0+naYieFI9r+T5CAwpfcs37M5d+A2NvKXJnCQus+X7W1IudU13L27FkEBwcbHqtUpv+D68h38O7du/Hee++htLS0zeOPGzcODz74IHr16oUTJ05g2bJlGD9+PEpKSuDj44OKigqEh4cbbePr64uwsDBUVFQIvko3vwopOzsb+fn5KC4uhp+f6X/D09PTkZaWZnis0WgM42Zu/ANbSqfTobCwECkpR6HV6gEEmdlCZACFSDy2OI7IacHccdqPVa1uRF7eLqSkJEGrbeffWHMtMAFmngfEXrJIrmpuPyLHEYn3Whm1rw55kwuR8lkStI031VGIwH7MxWNBLIb99QYQAQTfWonuynJ0Qzk64zJ64Ay6o/lxd/yCTriEiHJNc6JzCsBFgWOJdKXcMABD56NG4Yg8JH2TAkXTDeNuRL5PRI7lqP3Y6jg3ldH5qVH4Uh6SFqdAUddcP3UCx9KYOZZIy8hvAmXMDccUOY7IeJy2jiNTq9E9Lw9JSUlQKESa0tqIQeN+o4KCg4Ot+n5rS1VVFWbMmIH169ejS5cubZZ79NFHDb8PGDAAcXFx6NOnD4qLi3HvvffaLB6nJjBdunSBj48PKisrjdZXVlYiMjKy3W1feeUVZGdnY8eOHYiLi2uznEqlMpl9KhQKq97ULbRa/bUExlyDqa2Y+8a3sJ2+TebeGmJvHa1WYV0CY4tQRfdjritApGlXpJvpphZpbaMCWt1NdWSuSyEI5tv6Rdr5bywjofnvIQeUCl/UK+TQAWiEBD30kNAIGRogRz18UQeFj/b638/SY7XFxGtSNGmNExhbdcmI9AyIlDH3vhC5tFWkTJ3p1Yo6rSGBaRQYX+1rpozIR0XkLOMqnerWnutt8T3hqiz9Dj5x4gROnz6NiRMnGtbp9c0fbF9fXxw7dgx9+vRptV3v3r3RpUsXHD9+HPfeey8iIyNbDRJubGzE5cuXzX7338ipg3iVSiWGDBliNAC3ZUBuQkJCm9u99NJLWLNmDQoKCoz60IiIiEiMpd/B/fr1w3fffYfS0lLDcv/992PMmDEoLS1tNfamxS+//IJLly4hKioKAJCQkIArV67g4MGDhjJff/019Ho94uPjheN3ehdSWloaZs2ahaFDh2LYsGFYt24dampqMHv2bADAzJkz0a1bN2RlZQEAXnzxRaxcuRKbN29GbGysob8sMDAQgYHecJ0rEbkMXmFEtnQVYgPH29KB8caWfAf7+fmhf//+RtuHhoYCgGF9dXU1Vq1ahcmTJyMyMhInTpzA4sWLccsttyA5ORkAcPvtt2PcuHGYO3cucnNzodPpkJqaikcffRTR0dHCsTs9gZkyZQouXLiAlStXoqKiAoMGDUJBQYFhUFFZWRnk8usNRe+88w4aGhrw0EMPGe2nrVHWRETUzNz4F3djqyuZvJml38Hm+Pj44Ntvv8UHH3yAK1euIDo6GmPHjsWaNWuMhnNs2rQJqampuPfeeyGXyzF58mS88cYbFsXu9AQGAFJTU5GammryueLiYqPHp0+ftn9AREREXsKS7+Cbbdy40eixWq3GV199ZfaYYWFh2Lx5s2iIJjn9RnZERORZ2DJCjuASLTBERC7Hw7pbyA3UwOFjYNwZW2CIyP6YDBCRjTGBcRg2qhIREdkKExgiIiJyOxwDQ0RE5ApqYN23ssgdqD0IW2CIXE2oswMgd6T1sHFG7jcDETkaExgi8j4e9mVP5I2YwBAB5iffJiIil8IEhohcw1Ub7YetK3Z12dkBEF3DQbxERESuoAaAjxXbN9kqEPfAFhgich9sXSGia5jAEBERkdthAkNERERuh2NgiIiIXEE1rGtW0NsqEPfAFhgiInIo3qSObIEJDBEREbkdJjBERETkdpjAEDlSgLMDIPIMVc4OgJyOg3iJvBWTKfdR7ewAyCFqwEG8FmALDBERAeDgWnIvTGCIiIjI7TCBISIiIrfDMTBERESuoAaAzIrtJVsF4h7YAkNERERuhwkMOY81/2kQEZFXYwJDno+XCxMReRwmMEREROR2OIiXyBMFOjsA8la8Q64VqsFBvBZgCwwREZEXy8nJQWxsLPz8/BAfH4/9+/e3WXb9+vUYOXIkOnXqhE6dOiExMdGovE6nw5IlSzBgwAAEBAQgOjoaM2fOxLlz54z2ExsbC5lMZrRkZ2dbFDcTGCIicim8I7DjfPzxx0hLS0NGRgYOHTqEgQMHIjk5Gb/++qvJ8sXFxZg6dSp27tyJkpISxMTEYOzYsSgvLwcA1NbW4tChQ1ixYgUOHTqEzz//HMeOHcP999/fal+rV6/G+fPnDcvTTz9tUezsQiIiIo/jzV1ZGo1xCqhSqaBSqUyWXbt2LebOnYvZs2cDAHJzc7F161bk5eVh6dKlrcpv2rTJ6PGGDRvw2WefoaioCDNnzkRISAgKCwuNyrz11lsYNmwYysrK0KNHD8P6oKAgREZGdug1AmyBIbIdjjshImtJVizXxMTEICQkxLBkZWWZPFRDQwMOHjyIxMREwzq5XI7ExESUlJQIhVtbWwudToewsLA2y1y9ehUymQyhoaFG67Ozs9G5c2fcddddePnll9HY2Ch0zBZsgSEiIvIgZ8+eRXBwsOFxW60vFy9eRFNTEyIiIozWR0RE4OjRo0LHWrJkCaKjo42SoBvV1dVhyZIlmDp1qlFMf/rTnzB48GCEhYVhz549SE9Px/nz57F27Vqh4wJMYIiIiDxKcHCwUbJgL9nZ2cjPz0dxcTH8/PxaPa/T6fDII49AkiS88847Rs+lpaUZfo+Li4NSqcQTTzyBrKysNhOum7ELiYiIyAt16dIFPj4+qKysNFpfWVlpdmzKK6+8guzsbGzfvh1xcXGtnm9JXs6cOYPCwkKzCVV8fDwaGxtx+vRp4fiZwBAROVONswMgb6VUKjFkyBAUFRUZ1un1ehQVFSEhIaHN7V566SWsWbMGBQUFGDp0aKvnW5KXn3/+GTt27EDnzp3NxlJaWgq5XI7w8HDh+NmFRERE5BK0ABRWbm+ZtLQ0zJo1C0OHDsWwYcOwbt061NTUGK5KmjlzJrp162YYCPziiy9i5cqV2Lx5M2JjY1FRUQEACAwMRGBgIHQ6HR566CEcOnQIX375JZqamgxlwsLCoFQqUVJSgn379mHMmDEICgpCSUkJFi1ahD/+8Y/o1KmTcOxMYIjcTZCzAyB3pGFLD5kwZcoUXLhwAStXrkRFRQUGDRqEgoICw8DesrIyyOXXO2veeecdNDQ04KGHHjLaT0ZGBjIzM1FeXo4vvvgCADBo0CCjMjt37sTo0aOhUqmQn5+PzMxM1NfXo1evXli0aJHRuBgRTGCIiIi8WGpqKlJTU00+V1xcbPTY3BiV2NhYSFL7cxoMHjwYe/futSREkzgGhoiIiNwOW2CIiIhcgrX3D/au+w+zBYaIiIjcDhMYIiIicjtMYIiIiMjtMIEhIiK34l0jPagtHMRLJth/Dg2bcdQM0JxpurWaGxbyCpedHYDHq4LRtNIWq7ZVIG6BLTBEZLGIy1eZvBCRUzGBISKz/FFrWDrjImQtyUuluS2vCbBjcORWNM4OgDwGExgiVxLq7ABa64xLUKMWatSiMy4hqL4K+BXNCxGRk3AMDBG14q/Uwh9adMElBKHK8Ls/ahHwq7659cXW3e0hAK7aeJ9EbuU3AA1WbO9dfbpsgSGi6wIBeUSNoatIfUO3kRq1CK+v5OBdInIJTGCIqFlg8xLUqQqdcQn+aG6Fafm9Cy7Bv0Zv2dgXIiI7YQJDRNcFSuiivGRodYlApVELjKwGzWNf2PpCRE7GMTBEZCAPuD5Y1x9ao98jLl9l8kJkV1UA9FZs710fTrbAEHkjU5c1BwIREb8aBusGocrwe4cunSYisiOXSGBycnIQGxsLPz8/xMfHY//+/e2W/+STT9CvXz/4+flhwIAB2LZtm4MibQ/vbkBuLrD5fi+34RjuwBHE4KzxpdMt3UfOxPvJENE1Tk9gPv74Y6SlpSEjIwOHDh3CwIEDkZycjF9/NX2m3LNnD6ZOnYo5c+bg8OHDmDRpEiZNmoTvv//ewZETeZhIYDj2oBdOYxBKMQiH0Rc/Nd/ArkbfnLx4153KiciFOT2BWbt2LebOnYvZs2fjjjvuQG5uLvz9/ZGXl2ey/Ouvv45x48bh2Wefxe233441a9Zg8ODBeOuttxwcObXPz9kBkIXkETVIxleYiP9FXxzD0Mvf486zJ9Dr6HnIToGXThORS3HqIN6GhgYcPHgQ6enphnVyuRyJiYkoKSkxuU1JSQnS0tKM1iUnJ2PLli0my9fX16O+vt7wWKNp7urR6XTQ6XQdjr1lW7X6xhxQ1uH9iTM30ZfIALAmM883Cuyj/TJqtXTtZzt1LFJd5vIgkTxJJVBGaeXzAKCwrIzaV2f0E4DYJ9JHoIy5f01MPP9o2Ed4ZOP17thGqJt/qb2hUFt/M5F/hUTK3PDadD5qo58G5upIpA4t/Fu1SeR9Ye7j1MGPm85PbfSz0cxH39zzgPkzg8jZxZqpCEWJnDrk6mv1Y8V53hbbW6YK5v8K7ak1X8SDODWBuXjxIpqamhAREWG0PiIiAkePHjW5TUVFhcnyFRUVJstnZWVh1apVrdZv374d/v7+HYz8ury8flbvwzLm3qAib2DHDWTIyyt02LHcVd5kF6mjbV2xrdNHrdd3cnwoNyocYbo1lpoVvuRe9SOSf5t7y1nyliwstO7zVVvrXUmBO/H4y6jT09ONWmw0Gg1iYmIwduxYBAcHd3i/Op0OhYWFSEpKgkIh8q+ad2H9mMc6ah/rp32sn/bZqn5aWu3J9Tg1genSpQt8fHxQWWl8XWZlZSUiIyNNbhMZGWlReZVKBZWqdR+CQqGwyYfeVvvxVKwf81hH7WP9tI/10z5r64d167qcOohXqVRiyJAhKCoqMqzT6/UoKipCQkKCyW0SEhKMygPNTYRtlSciInIPVWi+JUdHlyrHh+xETu9CSktLw6xZszB06FAMGzYM69atQ01NDWbPng0AmDlzJrp164asrCwAwMKFCzFq1Ci8+uqruO+++5Cfn48DBw7g3XffdebLICIiIgdyegIzZcoUXLhwAStXrkRFRQUGDRqEgoICw0DdsrIyyOXXG4qGDx+OzZs3Y/ny5Vi2bBluvfVWbNmyBf3793fWSyAiIiIHc3oCAwCpqalITU01+VxxcXGrdQ8//DAefvhhO0dFRERErsrpN7IjIiIispRLtMAQERFRFcTubNgWra0CcQtsgSEiIvJitp5QWZIkrFy5ElFRUVCr1UhMTMTPP/9sVOby5cuYPn06goODERoaijlz5qC62rLJ1pjAEBEReSl7TKj80ksv4Y033kBubi727duHgIAAJCcno66uzlBm+vTp+OGHH1BYWIgvv/wSu3btwrx58yyKnQkMERGRB9FoNEbLjfMB3szWEypLkoR169Zh+fLleOCBBxAXF4cPP/wQ586dM8xZ+OOPP6KgoAAbNmxAfHw87r77brz55pvIz8/HuXPnhF8nExgiIiKXYJsb2cXExCAkJMSwtNxH7WYtEyonJiYa1olMqHxjeaB5QuWW8qdOnUJFRYVRmZCQEMTHxxvKlJSUIDQ0FEOHDjWUSUxMhFwux759+wTqqRkH8RIREXmQs2fPGs31Z2o6HcA+Eyq3/DRXJjw83Oh5X19fhIWFtTkxsylMYIiIiDxIcHCwVZMVuwt2IREREXkhe0yo3PLTXJmbBwk3Njbi8uXLbR7XFK9rgZEkCYD1U6TrdDrU1tZCo9FwtlITWD/msY7ax/ppH+unfbaqn5bvipbvDvtqe7CtPba/cULlSZMmAbg+oXJbd8dvmVD5mWeeMay7cULlXr16ITIyEkVFRRg0aBCA5jrct28f5s+fb9jHlStXcPDgQQwZMgQA8PXXX0Ov1yM+Pl78BUhe5uzZsxIALly4cOHCRXg5e/as3b6XtFqtFBkZaZM4IyMjJa1WK3zs/Px8SaVSSRs3bpSOHDkizZs3TwoNDZUqKiokSZKkGTNmSEuXLjWU/+abbyRfX1/plVdekX788UcpIyNDUigU0nfffWcok52dLYWGhkr/+te/pG+//VZ64IEHpF69ehnFNW7cOOmuu+6S9u3bJ+3evVu69dZbpalTp1pUb17XAhMdHY2zZ88iKCgIMpmsw/vRaDSIiYlpNViKmrF+zGMdtY/10z7WT/tsVT+SJKGqqgrR0dE2jM6Yn58fTp06hYaGBqv3pVQq4efnJ1zeHhMqL168GDU1NZg3bx6uXLmCu+++GwUFBUZxbdq0Campqbj33nshl8sxefJkvPHGGxa9VpkkOaRdzONoNBqEhITg6tWrPHmYwPoxj3XUPtZP+1g/7WP9eD4O4iUiIiK3wwSGiIiI3A4TmA5SqVTIyMho8wZB3o71Yx7rqH2sn/axftrH+vF8HANDREREboctMEREROR2mMAQERGR22ECQ0RERG6HCQwRERG5HSYw7cjJyUFsbCz8/PwQHx+P/fv3t1v+k08+Qb9+/eDn54cBAwZg27ZtDorUOSypn/Xr12PkyJHo1KkTOnXqhMTERLP16QksfQ+1yM/Ph0wmM8xP4qksrZ8rV65gwYIFiIqKgkqlwm233ebRnzNL62fdunXo27cv1Go1YmJisGjRItTV1TkoWsfatWsXJk6ciOjoaMhkMmzZssXsNsXFxRg8eDBUKhVuueUWbNy40e5xkh1ZNPGAF8nPz5eUSqWUl5cn/fDDD9LcuXOl0NBQqbKy0mT5b775RvLx8ZFeeukl6ciRI9Ly5ctbzQ/hSSytn2nTpkk5OTnS4cOHpR9//FF67LHHpJCQEOmXX35xcOSOY2kdtTh16pTUrVs3aeTIkdIDDzzgmGCdwNL6qa+vl4YOHSpNmDBB2r17t3Tq1CmpuLhYKi0tdXDkjmFp/WzatElSqVTSpk2bpFOnTklfffWVFBUVJS1atMjBkTvGtm3bpOeee076/PPPJQDSP//5z3bLnzx5UvL395fS0tKkI0eOSG+++abk4+MjFRQUOCZgsjkmMG0YNmyYtGDBAsPjpqYmKTo6WsrKyjJZ/pFHHpHuu+8+o3Xx8fHSE088Ydc4ncXS+rlZY2OjFBQUJH3wwQf2CtHpOlJHjY2N0vDhw6UNGzZIs2bN8ugExtL6eeedd6TevXtLDQ0NjgrRqSytnwULFkj33HOP0bq0tDRpxIgRdo3TFYgkMIsXL5buvPNOo3VTpkyRkpOT7RgZ2RO7kExoaGjAwYMHkZiYaFgnl8uRmJiIkpISk9uUlJQYlQeA5OTkNsu7s47Uz81qa2uh0+kQFhZmrzCdqqN1tHr1aoSHh2POnDmOCNNpOlI/X3zxBRISErBgwQJERESgf//+eOGFF9DU1OSosB2mI/UzfPhwHDx40NDNdPLkSWzbtg0TJkxwSMyuzpvO0d7C62ajFnHx4kU0NTUZZuNsERERgaNHj5rcpqKiwmT5iooKu8XpLB2pn5stWbIE0dHRrU4onqIjdbR792689957KC0tdUCEztWR+jl58iS+/vprTJ8+Hdu2bcPx48fx1FNPQafTISMjwxFhO0xH6mfatGm4ePEi7r77bkiShMbGRjz55JNYtmyZI0J2eW2dozUaDbRaLdRqtZMio45iCww5XHZ2NvLz8/HPf/7TomnfPVlVVRVmzJiB9evXo0uXLs4OxyXp9XqEh4fj3XffxZAhQzBlyhQ899xzyM3NdXZoLqG4uBgvvPAC3n77bRw6dAiff/45tm7dijVr1jg7NCK7YAuMCV26dIGPjw8qKyuN1ldWViIyMtLkNpGRkRaVd2cdqZ8Wr7zyCrKzs7Fjxw7ExcXZM0ynsrSOTpw4gdOnT2PixImGdXq9HgDg6+uLY8eOoU+fPvYN2oE68h6KioqCQqGAj4+PYd3tt9+OiooKNDQ0QKlU2jVmR+pI/axYsQIzZszA448/DgAYMGAAampqMG/ePDz33HOQy737/9W2ztHBwcFsfXFT3v2OboNSqcSQIUNQVFRkWKfX61FUVISEhAST2yQkJBiVB4DCwsI2y7uzjtQPALz00ktYs2YNCgoKMHToUEeE6jSW1lG/fv3w3XffobS01LDcf//9GDNmDEpLSxETE+PI8O2uI++hESNG4Pjx44bEDgB++uknREVFeVTyAnSsfmpra1slKS3JnsQp77zqHO01nD2K2FXl5+dLKpVK2rhxo3TkyBFp3rx5UmhoqFRRUSFJkiTNmDFDWrp0qaH8N998I/n6+kqvvPKK9OOPP0oZGRkefxm1JfWTnZ0tKZVK6dNPP5XOnz9vWKqqqpz1EuzO0jq6madfhWRp/ZSVlUlBQUFSamqqdOzYMenLL7+UwsPDpeeff95ZL8GuLK2fjIwMKSgoSProo4+kkydPStu3b5f69OkjPfLII856CXZVVVUlHT58WDp8+LAEQFq7dq10+PBh6cyZM5IkSdLSpUulGTNmGMq3XEb97LPPSj/++KOUk5PDy6jdHBOYdrz55ptSjx49JKVSKQ0bNkzau3ev4blRo0ZJs2bNMir/j3/8Q7rtttskpVIp3XnnndLWrVsdHLFjWVI/PXv2lAC0WjIyMhwfuANZ+h66kacnMJJkef3s2bNHio+Pl1QqldS7d2/pL3/5i9TY2OjgqB3HkvrR6XRSZmam1KdPH8nPz0+KiYmRnnrqKem3335zfOAOsHPnTpPnlJY6mTVrljRq1KhW2wwaNEhSKpVS7969pffff9/hcZPtyCSJbYtERETkXjgGhoiIiNwOExgiIiJyO0xgiIiIyO0wgSEiIiK3wwSGiIiI3A4TGCIiInI7TGCIiIjI7TCBISIiIrfDBIaIiIjcDhMYIjLp/PnzmDZtGm677TbI5XI888wzzg6JiMiACQwRmVRfX4+uXbti+fLlGDhwoLPDISIywgSGyINduHABkZGReOGFFwzr9uzZA6VSiaKiona3jY2Nxeuvv46ZM2ciJCTE3qESEVnE19kBEJH9dO3aFXl5eZg0aRLGjh2Lvn37YsaMGUhNTcW9997r7PCIiDqMCQyRh5swYQLmzp2L6dOnY+jQoQgICEBWVpazwyIisgq7kIi8wCuvvILGxkZ88skn2LRpE1QqlbNDIiKyChMYIi9w4sQJnDt3Dnq9HqdPn3Z2OEREVmMXEpGHa2howB//+EdMmTIFffv2xeOPP47vvvsO4eHhzg6NiKjDmMAQebjnnnsOV69exRtvvIHAwEBs27YNKSkp+PLLL81uW1paCgCorq7GhQsXUFpaCqVSiTvuuMPOURMRtU8mSZLk7CCIyD6Ki4uRlJSEnTt34u677wYAnD59GgMHDkR2djbmz5/f7vYymazVup49e7IbioicjgkMERERuR0O4iUiIiK3wwSGyEvdeeedCAwMNLls2rTJ2eEREbWLXUhEXurMmTPQ6XQmn4uIiEBQUJCDIyIiEscEhoiIiNwOu5CIiIjI7TCBISIiIrfDBIaIiIjcDhMYIiIicjtMYIiIiMjtMIEhIiIit8MEhoiIiNzO/wfN0deZd4bwYwAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -427,14 +421,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -473,7 +465,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.4" + "version": "3.11.7" }, "orig_nbformat": 4 }, diff --git a/examples/pinn/inverse-heat-equation-D-function.ipynb b/examples/pinn/inverse-heat-equation-D-function.ipynb index b8b56419..6aba070c 100644 --- a/examples/pinn/inverse-heat-equation-D-function.ipynb +++ b/examples/pinn/inverse-heat-equation-D-function.ipynb @@ -27,11 +27,12 @@ "metadata": {}, "outputs": [], "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\" # select GPUs to use\n", + "\n", "import torchphysics as tp\n", "import pytorch_lightning as pl\n", - "import torch\n", - "import os\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"2\" # select GPUs to use" + "import torch" ] }, { @@ -181,9 +182,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "GPU available: True, used: True\n", + "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [2]\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "You are using a CUDA device ('GeForce RTX 3090') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------------\n", @@ -193,60 +197,31 @@ "26.8 K Trainable params\n", "0 Non-trainable params\n", "26.8 K Total params\n", - "0.107 Total estimated model params size (MB)\n" + "0.107 Total estimated model params size (MB)\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n", + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=254` in the `DataLoader` to improve performance.\n" ] }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "13b81919630e4e91b55499707564c0a5", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation sanity check: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 8000/8000 [07:47<00:00, 17.11it/s]" + ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " warnings.warn(*args, **kwargs)\n", - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " warnings.warn(*args, **kwargs)\n" + "`Trainer.fit` stopped: `max_steps=8000` reached.\n" ] }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "50f3837798e9434d93a308770ef22fec", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0a297a64b5da43a49a4090e49d32a02c", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 8000/8000 [07:47<00:00, 17.11it/s]\n" + ] } ], "source": [ @@ -254,11 +229,12 @@ "\n", "solver = tp.solver.Solver([pde_condition, data_condition])\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=8000,\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=8000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", " \n", "trainer.fit(solver)" ] @@ -272,9 +248,11 @@ "name": "stderr", "output_type": "stream", "text": [ - "GPU available: True, used: True\n", + "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [2]\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "------------------------------------------------\n", @@ -288,46 +266,32 @@ ] }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "73a2f545c1684c94aba9493244dbd633", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation sanity check: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 19%|█▉ | 189/1000 [00:23<01:40, 8.11it/s]" + ] }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a0db54ec0b5944e2aefaf7091ce37fa4", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 1000/1000 [02:05<00:00, 7.97it/s]" + ] }, { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0fe74c2f5ade4cfcb1e45335893ba711", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_steps=1000` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|██████████| 1000/1000 [02:05<00:00, 7.97it/s]\n" + ] } ], "source": [ @@ -339,11 +303,12 @@ "\n", "solver = tp.solver.Solver([pde_condition, data_condition], optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=10000, # number of training steps\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=1000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", " \n", "trainer.fit(solver)" ] @@ -360,16 +325,22 @@ "execution_count": 10, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/tomfre/miniconda3/envs/tp_version2/lib/python3.11/site-packages/torch/functional.py:507: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:3549.)\n", + " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGwCAYAAAB7MGXBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACUSklEQVR4nO2deZgU1bn/vz17zyqKzDAwCK4ICKgIFzWJubKIXiJJbq4LuSAkJDGQQOaJC0YBCTpuMWj0B2oc0USi2ST3509RQoI+XhEQJdclUTQouAyoVxhmumdhpn9/dFdPdfWpqrPV0j3v53n66emqU6dOne6p8633fc97IolEIgGCIAiCIIiAKAi6AQRBEARB9G9IjBAEQRAEESgkRgiCIAiCCBQSIwRBEARBBAqJEYIgCIIgAoXECEEQBEEQgUJihCAIgiCIQCkKugFe09vbi48++ghVVVWIRCJBN4cgCIIIMYlEAocPH0Z9fT0KCrx7Xu/o6EBXV5dyPSUlJSgrK9PQomDJezHy0UcfoaGhIehmEARBEDnEvn37MHToUE/q7ujowLHRKNo01FVXV4c9e/bkvCDJezFSVVUFIPnDqq6ulq6nu7sbzz77LKZNm4bi4mJdzcsbqH+cof5xhvrHHeojZ3T1T2trKxoaGtJjhxd0dXWhDcBVAEoV6ukEcHtLC7q6ukiMhB3DNVNdXa0sRsrLy1FdXU03AgbUP85Q/zhD/eMO9ZEzuvvHD7d+KYDclhD6oABWgiAIgiACJe8tIwRBEAQRRqoARBWOzyf7GFlGCIIgCIIIFBIjBEEQBEEECokRgiAIgiAChWJGCIIgCCIAVGNG8mkAJ8sIQRAEQRCBQmKEIAiCIIhAITFCEARBEESgkBghCIIgCCJQAhUjzz//PGbOnIn6+npEIhFs2LAhY38ikcCyZcswePBgRKNRTJkyBbt37w6msQRBEAShkSoA1Qov71bP8Z9AxUh7ezvGjRuHe++9l7n/tttuw9133421a9di27ZtqKiowPTp09HR0eFzSwmCIAiC8IpAZwbNmDEDM2bMYO5LJBJYvXo1rr/+elx88cUAgEceeQS1tbXYsGEDLr30Uj+bShAEQRCER4R2mvKePXvQ0tKCKVOmpLfV1NRg0qRJ2Lp1q60Y6ezsRGdnZ/pza2srgOSKjt3d3dLtqavbiubm5Hs87raao4jxTNTQpsswV6mpniTR6JFU/8QRj8v3c74SjR5M9c8niMf9+rc7nDN1R6OtAv9fbuhsmxdW2Fapo6JRoLl5AOrqHkU8bleqTbpVcnj5GxMjGi1Ac/NIpfs8AOXjCTlCK0ZaWloAALW1tRnba2tr0/tYNDU14cYbb8za/uyzz6K8vFy6Pc3NxvvnHKX/V/o8uU5z81+DbkKoaW7eEXQTQg3f/5efFHpQ5wClo5ubnY5Xqzsf2LRpk9LxsVhMU0vciUIt6VlCV0NCQGjFiCxLly5FY2Nj+nNraysaGhowbdo0VFdXS9ebtIx8jvnzBzCe3Ly0hMgeY6DXAmJH0jLyV8yf/2XTk39Qa0qG78mG3T+Av0+yXj3FqtcbjfaiuXkf5s9vQDzerqFNQLgtJOLWEcMyMn/+5w6WEaC/WkcMy8jUqVNRXCx/7zGs6YS/hFaM1NXVAQD279+PwYMHp7fv378f48ePtz2utLQUpaWlWduLi4uVfqCGAInHI4jHzXG/vEJBRgjJiyfv46ytfZkUAPF4FPF40AtbO50/WKESjxdZ+sf8JOv1Td04l+6b7VHa6o3HCxCP10BPX9Sk3nVcbxSAowIQpBqy7YrH4SJGKuGvQOj18VzuqN7rVY4l5AltnpERI0agrq4OmzdvTm9rbW3Ftm3bMHny5ABbZlAFvgHfmIQlgswxQF+bvBAixZZXrmK9jjBdj5ffnxnZ35ef9ersB11tUjGoEwThRKCWkba2Nrzzzjvpz3v27MGuXbtw9NFHY9iwYViyZAlWrVqFk046CSNGjMANN9yA+vp6zJo1K7hGowr8Gk5GhMjglfjoT7CuN0grivGdevmEa/zedFtK5J/6s6lCWNwA+tHZT1b87DcvryO/qQJQoXC8FxFNQRGoGHn55Zfx5S9/Of3ZiPWYO3cu1q1bh6uvvhrt7e34zne+g4MHD+Lcc8/Fxo0bUVZWFlSTOfFDhOgWIP1NfPBg7pOghIn5e/ZqcPFClOisU8fAqmvADI+7hiDyiUDFyHnnnYdEwj4eOBKJYOXKlVi5cqWPrbKjCnyzZESERdAihAQIP2GwnHhtLfFKlJAgCQayjhC5Q2gDWHOPXBEhJED0wQ7i9R6vrSW6RQkJEmdoICcIEiPKeClCdAgQEh/+EYRbx0tric5BUpfAIUEiBllHwkwl1JIvqKYHDBMkRqQJswgJmQDR8Ss7oqEOX/FbmHglSsJoJQmTINFJPggSgpCDxIgUvOIiz0VIEePvInjzq+KpM7SCxc/vJRdEST4JklyJHyGIcBPaPCPhxYskZyo5FXzIlVFk8wobdu0MVVv9ym3iVb4SXTk7dOQk0XF9Oq5HZ/4RL/K/AP4tNu9V+4l8J1S36XDjlQiRxaPBLF9/EU7XFZhFxY8AWC+CXc2/cVXLgqp1QoclKGwWklx314TRBRZOVB8Z8ilmhCwj2hB50pP9CWp8qg69BcFHQmNR8TorbJXlpYNqqFs5qqHeHtVr0mGpUV32zEyuW0iIsHPLLbcgEolgyZIltmXeeOMNfP3rX8fw4cMRiUSwevVqZrl7770Xw4cPR1lZGSZNmoTt27cLt4fEiDJeixBNgxOJDjkCFSpep633SpiokC+iRAe57PLI5bbnPzt27MB9992HsWPHOpaLxWI4/vjjccstt6TXi7Py+OOPo7GxEcuXL8crr7yCcePGYfr06Thw4IBQm0iMSMN705K54WsYfEh8eE8gIsUrcaLTaqJqLdElalRFiQphFiQUP5JvtLa2Zrw6Oztty7a1tWH27Nl44IEHMGDAANtyAHDWWWfh9ttvx6WXXspcgBYA7rzzTixYsADz5s3DqFGjsHbtWpSXl6O5uVnoGkiMCFMFMRHCi+IAE6T4iAIwMvSXoc9a7fUrrPgqUPwQJyqoCBMdLiASJGzIXRMGqgqB6iL5V1VqcZqGhgbU1NSkX01NTbbnXLhwIS666CJMmTJFuf1dXV3YuXNnRl0FBQWYMmUKtm7dKlQXPTNzw/vPK+OGkcSPby/Mg75o24KcgWk39Vl78KwXQbG6gmBVpgerHKsS5KoajKkrsNWLoFA/AlopmNUP9u3bh+rqPtFqZ8V47LHH8Morr2DHjh1azvvpp5+ip6cHtbW1Gdtra2vxj3/8Q6guEiPa8EmEePGNhVlw6ITnOv0WLNbv01NxEhZhEqQokRUksucE9AoSgsimuro6Q4yw2LdvHxYvXoxNmzaFcrFZEiPKiLpiJND5LfUX4SGLU//4IVQ8FSe6rSaq02qDECWqVhKZcwLhTY5G1pH+ws6dO3HgwAGcccYZ6W09PT14/vnncc8996CzsxOFhYVCdQ4cOBCFhYXYv39/xvb9+/fbBrzaQWJEGo9FiK5vhsSHPoIQKqzfgTaBostqomotqYb8RQUlSmQFCaD+Y9E9uJMgCYqqCqBKIVlIIgHubj3//PPx2muvZWybN28eRo4ciWuuuUZYiABASUkJzjzzTGzevBmzZs0CAPT29mLz5s1YtGiRUF0kRoSpBJ+4CEiAkPgIBla/+yVQtIgT3cJEdnCrAhCTOE52sFNx3QTptiFBQohRVVWFMWPGZGyrqKjAMccck94+Z84cDBkyJB0A29XVhTfffDP994cffohdu3ahsrISJ554IgCgsbERc+fOxYQJEzBx4kSsXr0a7e3tmDdvnlD7SIxww7u2YgAixG8BwuqKMtO+IH9VbQGe24r5e/HSRas9IFaHMAnCHaJiJSFBQgvqEXv37kVBQd8k248++ginn356+vMdd9yBO+64A1/60pewZcsWAMAll1yCTz75BMuWLUNLSwvGjx+PjRs3ZgW1ukFiRBuCIkSl5/0QHyrrWgeJSLuDEC4sUaLTgqLdaqIqTIJwh8gcR4LEH3KtvfmNISjsPg8fPhyJRMK1nkWLFgm7ZayQGFEixwVIrgoOXbhdv19ixUsXj1ZxYvzeVUQJIDboq1hJSJCIQ+4aIhhIjEghIEJke1i3+OjvwkMG3j7zQrTYff+q45YWcaI6K0dGmMgszicjZGQtOUHPtCFBkosUlwPFCqlHi3uRN91IYkQYTiEi07M6BAiJDv9x6nPdQkW3FUW7OJEVJp8LHCM68PstSoKaaUOChMhdSIxwwyFCghAgQYiPCsY2I+FfOQDxGWLe0x7QeY3vhxXgq0uo6BQoyuJEVphUmt47OI8JqygJ0kqiW5AA3ooSEiREEhIjOhDtRRUB4rX4YAmNfED0uvwQL3bfpQ6RYv2NBSJOZN05om4c0QFNVpT4aSVRFSSQPHcQkCAhSIyoIdJ7sgLEC/GRr4JDJ7x95IVo8UKkeCFOpK0mIhYT3qdzmQFYdBCUtZLkehwJuWw8Q9WS3KOrIcFDYkQUkVVYZQSIbvFBwsNbnPpXt1Bh/TZkBYoO1460MJFx5XglSvxw3ZAgIQg3SIzwEnYBEkbR4fcq5WG7V5q/E1ZMjQ6x4qVAERkHlYVJGESJl1OBZV0nYRIkXpMr7SS8gMSILkRFiKoA8Vt8uAmLktR7pelvv9ElfvwSNXbfoapI0SVQZMWJVJxJseXdDS9EiR+xJDIDblgECblrCO8gMaKCnwLES/HhtwUj7PD2h1f3ZS9EivW3pypOZKwm3BYTEWsJ7wDppSjxw20TBZCA+krLqpAg0UoZKGYkBYkRUUTXGJEVIF6IDxIdenHrT933bNZvQlagmH+XKsIkFKJERAyIihKvrCRBDLgUP0KEFxIjvIiIkKAFCImOcGD+HqxuLF33cutvRkacqFhNZKwlwvElXokSr6wkXseRlIE/FwvrnLkgSPqRdYQAQGJEHzICJF/EhzlOpBJAV4BtUcHPhfPsvjPV+7sO64msOFEVJq4Ug991A+iPJ/FCkIjWbaASR0KChAgfJEZUCEKA+CU8+mNaeZlr1i1gnL5f2fu+qvVExqUjKky470Qi04J1ixIR8UKCRA+5lsBNkHKojcLKq3KHBxIjopjTefOgIj68Eh79UWh4BU9f6hIsuqwpKtYTGauJiDAx5/FxvdEGZSnhHcj9CmwNWpD4QS61lZCBxAgvIgO4rADRLT5yWXTobLuf7hcWbm4s1faxfjeqAkVGnHghTAAXURLUzBuvrCQyloCgBYlfAa0kSPIZEiM6CFp8BCk6jHMbY0IFgsszYoeu/vFK1Hix6q+qQDH/pr0WJryiBHAQJkEFuYpYSbx025AgIXIbEiOyBCVA/BIeuWxV8QrRPtEhXnSuUyMrUGSsJiLCJAr+2Wqu1hLdoiRoQQLOugF1QSJyLhZ+ChIgL0RJBShmJAWJEVFEFjYKq/AgoeEP5n5mWY5UxIoukWL9jYqKExFhwtM2syhxGleLoMl9wyNKdLptvF5sT8eKv7kgSACykuQXJEZ4KecspyJAdIuEsIqOMK6jY8WL1XiteOGeUU0FLypORKwmut04WmNKeEVJkFaSQ5xlSZAQuQeJER3IChBdYiEI0WEdhMxP/kFnrNaBrGDSJWJ0ChUVgWL+bYtYTdz6QdSNA/goSnQIEnCUEx20qwD8L2dZHevZqOC3IAGCj1QnVCAxIkOQ4sMP4ZELlouwYtd3ZrF2UPEcOhbCk5miKyJMRFw5leCLGfFNlPAIEkCPlUTGbcNLfwlqNZ8vxygH/9qQLPLhwS8FiRFeKk3vvBlGVYWDV8IjH8SG7H0nDEtqOPW/jrVmDEQEiqgLxUthUuTSBrcxVosoCbPbpgri2edkREkuChIiVyExopOwiY+wiI4wPbB40Rad91qdQkVWoIhaTWSECa8bx+7cPGOsa5Ar4J44LaxuG7+m/pIgIfyBxIgqsgJCp/DwW3SwBnTjl1SJvJpuxgWPwJFd18yM7nVneB+uRY7hFSa81hJVUcJtJXETJID9BQXltiFBQuQPJEZEkV0ITpf48Fp4hMmKkU+Y3XysgVHXujOAt6ndvRImpZzn9UyU6Iol0eW24cXP5GgE4R0FQTcgZxARE5WMlygVNi9VqlxeflOWwy+d6PxeZH83or9ZkfK81+E2hd7tXFFkppy34vr45RZN6HYh1eizlKiUEfni3eqy4tRBus7Bgp50srC7z4u8BFizZg3Gjh2L6upqVFdXY/LkyXj66acdjzl48CAWLlyIwYMHo7S0FCeffDKeeuqp9P4VK1YgEolkvEaOHCnWMJBlRA+qVg/d1o4g/+dL0X9+VSKChDdRnh0607sbiEy/BdwtITzJzXisJTxxJSqWkpyykoisp+O1hYTcNbnO0KFDccstt+Ckk05CIpHAww8/jIsvvhivvvoqRo8enVW+q6sLU6dOxaBBg/D73/8eQ4YMwfvvv4+jjjoqo9zo0aPx5z//Of25qEh8EOgvw4ZeVMSHTuHhh+jgHXBVB9v+gpNYE40rUV3FVzTNO6+LhrecW3hEKESJ17EkugWJ2/nMkCDpb8ycOTPj80033YQ1a9bgpZdeYoqR5uZm/O///i9efPFFFBcnRfrw4cOzyhUVFaGurk6pbSRGeKkwvYvM7dblWvEK3e4GGcIy60cWXYnOnL4LEaGiYw0aP4VJFZwXV+RpF48ocYonCdRKwitIeDOwep0+ngRJ2Ghtzfw+SktLUVrqHIjV09OD3/3ud2hvb8fkyZOZZf7rv/4LkydPxsKFC/GnP/0Jxx57LC6//HJcc801KCzsewLdvXs36uvrUVZWhsmTJ6OpqQnDhg0TugYSIzoJq/AISnDkusjghec6VS1HrO9QRaAEkeadp1wlgE6OdsmIEk9dN6qJ0ngFCW8GVj8ECQTOwYIECcqhtsp5ajJFQ0NDxubly5djxYoVzENee+01TJ48GR0dHaisrMQTTzyBUaNGMcv+85//xF/+8hfMnj0bTz31FN555x18//vfR3d3N5YvXw4AmDRpEtatW4dTTjkFH3/8MW688UZ84QtfwOuvv46qKv4BjcSICqqDrU7h4ZfgsLvmQtP+Hp/akou49Y+IlUVFoKiIE53ChFWGZ3YrjyjRbiUBnF03qonSgpxpE9S0XxIkOti3bx+qq/uCjJ2sIqeccgp27dqFQ4cO4fe//z3mzp2L5557jilIent7MWjQINx///0oLCzEmWeeiQ8//BC33357WozMmDEjXX7s2LGYNGkSjjvuOPz2t7/Ft771Le5rIDHCi6ybxiAXhEfQloxcD7bXcU+1+w54RYqsQBERJzqFiVGGNV1eVZSE2kqiaiHh/UH4sZAcCZKgMWbH8FBSUoITTzwRAHDmmWdix44duOuuu3DfffdllR08eDCKi4szXDKnnnoqWlpa0NXVhZKSbLPOUUcdhZNPPhnvvPOO0DXQ1F4v0DVl1qsppV5NG7bDbdpqUNOKdeN0beY8IzKofF8yvyHe74W3PW5Tcp32ibRDtG7PpgG7Ndhp4OCd+ssL77RcmSm/ouewIx9uALlJb28vOjvZvtFzzjkH77zzDnp7e9Pb3n77bQwePJgpRACgra0N7777LgYPHizUDrKMqKLrf0i3tcMvK4dx/YasrQTQa1OWSOL2m5GdDQPIWVDcLCc6s6q6BZoaSQWd3DdO7aiwObenVhIvLCQ8+71IHx9kUrR+aCEph3vCPycER/ClS5dixowZGDZsGA4fPoz169djy5YteOaZZwAAc+bMwZAhQ9DU1AQAuPLKK3HPPfdg8eLF+MEPfoDdu3fj5ptvxg9/+MN0nT/+8Y8xc+ZMHHfccfjoo4+wfPlyFBYW4rLLLvPyUggt6c51Cg+vLRpB4MfKxF6hYxVzlSm7MgLF+nt0EieiwkRFlDjtd3LhuLluPJlxIxtHokOQONUvUpcBpY3PVw4cOIA5c+bg448/Rk1NDcaOHYtnnnkGU6dOBQDs3bsXBQV9DpOGhgY888wz+NGPfoSxY8diyJAhWLx4Ma655pp0mQ8++ACXXXYZPvvsMxx77LE499xz8dJLL+HYY48VahuJEV5kB0hdwsMr0eGn4MhlkcGL3TVGUu8VABKpv0WFi44pu4CYOFEVJryixG6JBR5RottKIpVSXmXBPV1Tf3UO4iRI8pEHH3zQcf+WLVuytk2ePBkvvfSS7TGPPfaYarMAkBjRS5iFh9eiwxzgm3AqGBKchJEO64ZKG0TOLzorBhDLJyIqTNxEid05eWJOAPHZNzJWEp51bgIRJAcd9rvVz3seMyRICP8gMSKLrkBSnXgpOPy0agRtQdF1fllRoyKURK0nIlYTHmGiai2pQDLvgoz7xm8ria0gAeTiSHhdMk6ERZDoQMQFlaPwLBLpRB6N4Hl0KR5TanoX7bVcEB1eC4CgBUYQmK85YtpmthyJChZWP+paPRfgt5qICBMZUcITUxK0lUQpjkRWkPAQBkGic0oxWUn6A6EWIz09PVixYgV+/etfo6WlBfX19bjiiitw/fXXIxKJuFcQBLqER64IDqNOu8HWD4IWOipuHR3uIhGB4kU+EUOYyFpLKmA/S9ZJlKi4bnQFt0rHkTg1kMdC4uZfy0dBApAoyV9CLUZuvfVWrFmzBg8//DBGjx6Nl19+GfPmzUNNTU3G1KLACGP6d68GZi8H/KDFhCp+9zmPSBFdrM5ANuYD0GctOcjY7iZKRANcvZgCrNVt41dQay4JEoCsJPlLqMXIiy++iIsvvhgXXXQRgORqgb/5zW+wfft222M6OzszErgYCwh1d3eju1smdWqSaHV337tsunOdg5Zu149i26KR7oz3NEFndQ0J0dRgFK2w+Q2KpIFnCVgRweF0rhqOOs35rezqMr53u3VmBmSeI1rU3fd+lEPdA2z2HZ1ZXwbH2OwzXK8xxjFlNnUZ++zEluO0f7v7j93JymEeeKPRnoz3ZCfz+N3cylRylDFwung7vBAkgLXPotGkeVblPq/jeCFKEY7FSkNAqMXI2Wefjfvvvx9vv/02Tj75ZPztb3/DCy+8gDvvvNP2mKamJtx4441Z25999lmUl5dLt6V5ovG+SbqO/kDzsdQ/TjRX2PSPqmgbpHh8SGj+Ov1+3Ghu/nvALZBZ9XGAexFNdW7apPYbisVY6pTwmlCLkWuvvRatra0YOXIkCgsL0dPTg5tuugmzZ8+2PWbp0qVobGxMf25tbUVDQwOmTZvGnbufRd2KbjRP3IT526ci3mNycOuydui0IOh2G3C0LYpuNFdswvz2qYg7psnmrzOfiKIbzdiE+TD1j4g1xIrosTyuHZ46ddTDsJZEi7rRPH0T5v9hKuJHGL8fpzrt9jm1lbXPaQxyqotlKJCykDid5DCi0R40N/8d8+efinjcKgh4LBu6yhiIWkgAb9bJSfZbNBpBc/NQTJ06FcXFHPcgGwxrOuEvoRYjv/3tb/Hoo49i/fr1GD16NHbt2oUlS5agvr4ec+fOZR5TWlrKXLGwuLhY6QcajxrvxYj3muoRTX1uJxRkgj511uVUnwBxFCNeKd/PSvgdeyISuJr6TuIoRjyS6h+ZmTEGLDHndKy5vF05q+HQznNgYDdumc3OLKFg3HUYY1m8rBjxzxm/H2MZDFZ9xj5re+22G/us7TfGd7s2O/WvXSiFUGDrAEajzPs+T54qXsgQI0fBfaCvcajfXMbLwdh4INR5jkw3k+q9XuVYQp5Qi5GrrroK1157LS699FIAwGmnnYb3338fTU1NtmIkVOgaHHUOsl7VZQggHRaPXAloFWkn7wOnrqBVp2N4g1t5U7IDctN37Wbh6J6e6zQNWGdwq3BgK0uQOAVo8i6+p2s9GzeCzEFiJUcX2quAWsyIjMcspIRajMRisYw8+QBQWFiYsYJg4OSCUAhTXV7UlwsYA2Il+qZBG8gIDZ5jeUSHrjIqOUXKwL6pyogSO8Fgt93uHLI5SbQJElajeFENGM2VLK1EPhFqMTJz5kzcdNNNGDZsGEaPHo1XX30Vd955J+bPn+9/Y3SnO89nq4nXYiPs0eeirnQ/pvCKig67cm718OQUAeRmD+nIGaLTSuKpIHFqVBWcA1zcCMOUX9FzEPlOqMXIL37xC9xwww34/ve/jwMHDqC+vh7f/e53sWzZsqCbxk8+iwWrm6YNanWHXWTwwrqOXiT7pxT2i8JZEY0p8dtN48XKukaGY5agE7ViyFhJckaQ6FjtlwQJER5CLUaqqqqwevVqrF69Ouim2ONlVtOg69BZj19Cwy8XkErWVbu+4LGo8AoOa1kv3TS81hInUWK9dqesrrpEA2u7k+AhQeICCRJhytGXTE+GAvciuUKoxUioqDS9h8lNo6suXe0phb5/kDDHloi0jVe4yIgUGWuIXTmRMrIL2QHOosSKaJCrjJWE120TuCD5nLGdBAmRH5AY8ZowWSh01GE3YBpuCD/bokIlh6Js07T+USWS/fNZ6m+zWOPpM1af2wkUna4annVh3PbLiBLWmGSX+FOHlUTEbeMkdjwXJHb/NCRIiNyHxIgqYZxp4qXo8LMNGfX5vfqewjlFRIxs8Kr1++ERJ165YXhEi4gosRvwdVpJRNw2vGLHF0Fih+pArluQyEKCpL9CYoSXCsu7KmGxmKiIDvO57Z78uesKQGx4BetaelLbKhJAYcJdsIgGr/KIE6+FiYooYU0OsbNuyIgSFbeNLkECZIsSaQsJ6wt2Gsh1LazHS5hykBC5AIkRrwmD6NARPKpyfg+ERkFF+NaP6G0XWPuI1Sc6BYrbCrqqbhqn/TKCxe735ZafhNd1I+q2UQlsdeo31hjtW1CrDkFC7hqtVIACWFOQGFElbG6aoNwrFZYnfwXCKDR4cGp3wRHmaJOJDoHCGgBVhYkXbhqn7b3Q47pRcduIxpGoBrY6ChJAzG1DgoTIPUiM8GJ20+iIaww6rkO3paMne5MdXoiN8ir/TcKxw+KPNAXlcRQUZQ4sjhYVUYHiJhycpszyHC/rinETJdafhGhgKstK4qfbxlNBYoeTaCBBQuQWJEa8RKfVRFZ4qLZBwsWiS2wEITBE4Gkfj2Bh9ZeQQLETJ07Cws1aYj5etyhhbWfFYukMcPXCbaMqSFhIpY73SpC44ZcggcB5iFyFxIgKXkxPDZO1gwNjIDXcEAXlcYj8rLwUHOXlekRRLCYQC2JtQ+r6oqn+Ka+KI1KU7B8noSIkUMzfnZsw0e3G0emiAZIDunVs1WUlUXXb6BYkUrNsWMgGnubKlF/R8+QQ5cheLVsETdkHwgCJEV6Mm0kl1H8AQQaUKooOUXSJDV3Cwo9z84oXVt+ICBSmOHGzmvC6cQBnYeKlKBENIAXYVhIeQWLUkTOCxI58z9JqnAcC5yJyCRIjXqIrBXqOCA8g88lf6LgAxYZuWNdS1s0XVGMVKLzixNVqwrKYqMSXyIoSu+28MRwicSA64khCKUhELSSqgkQ3qtN+89RK0s8hMSKKznTnVnIkvoP1RB/lmC2iU3BElVYt9YY4h701Go0jUlyYtd3OmsJrPXEVJm6uHB43jg5RIjq1107A8AoA1TiS0AoSO2QFiUyduuqXgQRJvpFHs5Q9plRjXZU2L+7jE+yXCwUVsayXG+VV8ayX6zHlMeaLhyhiXK8wotJekb5y+y5cv2On34zT77EM9tY+u2N0bLcrW8XYVgF2MCyr3XbHs9rEs423PrvjhSZn2VlHnKiW3AewL060DjMqyTVkzhdSytH3m5V5CcabrFmzBmPHjkV1dTWqq6sxefJkPP3007blH3jgAXzhC1/AgAEDMGDAAEyZMgXbt2/PKJNIJLBs2TIMHjwY0WgUU6ZMwe7du8UaBrKM6EdnUKuPbhaZ2A7zoGm4IaLRODqQ/eRvoFNIlIckw2OM48ZalrruMsQQMfWPnTWFJUhY1hPz92bn0jF+D8IWEzsrhlNciaxFRDb3hw63TVAWEhZakqJ5NcMmTPEjMucjhg4diltuuQUnnXQSEokEHn74YVx88cV49dVXMXr06KzyW7ZswWWXXYazzz4bZWVluPXWWzFt2jS88cYbGDJkCADgtttuw913342HH34YI0aMwA033IDp06fjzTffRFkZf6wCiRFeKqGW7tyxbvkkYUEID15khUdYRAYvTu11EyqsPuIRKG7CBMgWJ9yuHF5RAti7QURFiZNFQqcICJMgEc1BwkS3INFBEIIEAufsv8ycOTPj80033YQ1a9bgpZdeYoqRRx99NOPzL3/5S/zhD3/A5s2bMWfOHCQSCaxevRrXX389Lr74YgDAI488gtraWmzYsAGXXnopd9tIjPhJDogOQFx4RBFDaSrrmfXJ3/YcGgVHKTq11cVLJ6ffzrjOUvSmPnegMKVm7YSKVaCwxImbMAGcrSaOwsQvUWI3tZenbL4LEhZaBYkdOqwjPPWY0bWOTR64bSRpbc3s69LSUpSWOt+jenp68Lvf/Q7t7e2YPHky13lisRi6u7tx9NFHAwD27NmDlpYWTJkyJV2mpqYGkyZNwtatW0mM+I7mtVf8mkYrIzpEkRUdQQgMEdzaxyNWrH0jK06s36OoO8fWjeO1KBGxnvBu480nEnZBIjw+iwoSr901BBd2MU6CNDQ0ZHxevnw5VqxYwSz72muvYfLkyejo6EBlZSWeeOIJjBo1ius811xzDerr69Pio6WlBQBQW1ubUa62tja9jxcSI7xoXHvFIKyiw0BEfJSn7uzmJ383dAqOqMeunbhgwJ312gzLSCk60WlTl4w4kbGaGL8fbmuJblHCGshZ/1K8g751G28ciaogAbLFkR+CRJuFJN/iR/ov+/btQ3V1n2XIySpyyimnYNeuXTh06BB+//vfY+7cuXjuuedcBcktt9yCxx57DFu2bBGKBeGFxIgPqObtED7GY4uHqLVDVnR4LTBEEGmLm3Bh9QfLksLqZ6tAUREmwtYSN1EC2Ae7mgd9JxFjRVaQAHxCgNU+kWytPO3t1xYSEiR+YMyO4aGkpAQnnngiAODMM8/Ejh07cNddd+G+++6zPeaOO+7ALbfcgj//+c8YO3ZsentdXR0AYP/+/Rg8eHB6+/79+zF+/HihayAxIklYFnsLp/Dgj/DVLTjKNU/7jUnkamZdUwnz0b8Pq0Cxc/OYvw8vhImSKAGcZ+DwWEmMhShlXDQ640h4rStBuWwc84/YCRIv0O2yIUHiN729vejstH9gvO2223DTTTfhmWeewYQJEzL2jRgxAnV1ddi8eXNafLS2tmLbtm248sorhdpBYoST5Jor7FVXRfEzsFT4HJw3Ajs3hH1bJK854Jwioud3Ey9l6ECBZT0BliWFR5zoECa+ihInK4l1PJO1iAQR2KoiSFjYCRIrviRE83uFX6BfCZIK6E0H4cLSpUsxY8YMDBs2DIcPH8b69euxZcsWPPPMMwCAOXPmYMiQIWhqagIA3HrrrVi2bBnWr1+P4cOHp+NAKisrUVlZiUgkgiVLlmDVqlU46aST0lN76+vrMWvWLKG2kRjxCB1rsngpPkQsHqJuFlHhoVtw6KpPxipid+4jDq4ba3+5iRMnYcKKM3ESJr6IElkriYoggWUby9IRBkEikoOE5abXloMkTCv8Av1KkPjIgQMHMGfOHHz88ceoqanB2LFj8cwzz2Dq1KkAgL1796KgoM+yvWbNGnR1deHf//3fM+oxB8heffXVaG9vx3e+8x0cPHgQ5557LjZu3CgcV0JihBPj5iy79opj3T7k8PBKfBgDqeGGKEMHumxWElQRCUFYSHRaRYzvK4oYikz9wzrGLE5EhYmTtcTcDh2iRGn2jVOAq3WQtx7L66KRFQMii+y5nY9n6q6OKb9CgsSOMMWPACRI9PPggw867t+yZUvG5/fee8+1zkgkgpUrV2LlypUKLSMx4isqa7OEweohYvEQHci9Fhsi/cezxgwLu2twEinmY9yESbJtmaJAVpjoECVSU4K9tJLIxpHIChLZab9e5SDhdtl4lRCNBAkhD4kRBbxaaTYMVg9e4WEMpsUpy4j1yd+uvAx+rUkjcx4nAVOOWGolkRKUI55+VrWKD2vfiFpNeIQJb2yJZ6LEzkrSC33WD5k4EtlcJLIiQkWQlEFgfPYzIZpX9eSxICmF2rpnfsUp+wCJEU6i0Xj6nbXqqnB9PqRK90p46C7b145gglXdXBs82LXdTaSYERUnMsJE1FqiTZTwWElYyFo/eONIZHKRWOEREYHOsAnbdF8Z8liQEABIjHiK6uAatLuFV1DYPfmzz60SN+L9zUjmHE4Cxrje5D9aCcoQQxFsZrgIiBMZYSJqLdEqSnitJKVIzgx3y0vCM9jrcpmwpv3KLIanKkisQkOLILEjbPEjAAmS/IbECCd2q67qQGYADMrqIWLx8DqnSViwazePSDFwEyc6hEmoRYl1XOKJJQm7IPEiBwkPQoIkyNTuJEiIPkiM+ITKQBuU1YNXeERTT/vmJ3/neuX7Iui8I2bcpv6ar9OIoylHB1oZczRd159RFCYsUQLwuXCiiAkFunLPvLEKks8yi9jmJXETJHApw9oWtCCRxSllvHJAqx/uGllBApAoyS9IjEjg1RO8l/k8dIsPvnNKZJQNkdhww6mtzjNo3NegccwNIiFMWKIE4LeWiMy+UbaSWLvVKgJkLCKygsSKLkFiRdb1AwgKkrC5a3jqsSMPrCTlUFsozznXZE5BYoQT80JwnQLpzll4vVaLTpcLv/Do658jLqnPc2FGjRtu03+t11joOMPIWZyoChNVUWK1kjDbISBKmFYS81hkN+NGhyCx1usmSHhTx4vmIFF111hdWELjsqi7RtcsGif6sSAhAJAY8QQdq9F6kdNDl/hgWzyyB9tcmlEjils77cRKFDH0mMQay4LCm+bdeh47YaIqSlgxJU6ixM11w7SSVDAErHXAZgkSmMqozLQRFSRWZKb8Br6GjRUvpvv6EZNCgiQfIDHCiXGTFl0IzgmZ9Vp0T691G1R5XS3mDKM9LpaRsM+ocYJ36q/1GgttfjPuM2j4rCZ2FhNeUZKswznYlVeUKFlJKhKZ4wpLkADicSS6BYlsDhIrIoKkx6UuQECQhHG6r4oFhgRJrkNixCe8XihOV7wH72Cffb5sy4iXC/UFBU/7nGfRxNFjcvSKuF2s52eJAmudvKLEaFvyeG9FCctKgtbivoawglvdMreGRZBY8XJRPeVA2HyKHwGSX0huZQFLlAMJhZiRBI9AzRFIjAjCWnVVB16lT9chPsSm82YOtirntaNEgxtMli6OdImsa+u0iVLjjQcB7K0mXFNyHUSJdbuIKOGdDuxqJSm39BlLkABqcSR+CBIvZ9iwPH+hcdcEWS+RD5AY4aTM9RGID5k4Cp2zXHSJD343hJjoCFJo8ODWPjuxYgzwUcTRmxJrIoGqgFNMiLgoya6DL66kFJ2uVhLj3E6CBGBPA87AbrZNvgoSKypjdyjdNbz4ETBLhA0SIxrRNS01F8SHfbm+wdYJFdERlCuHJ16EdV12AkU2UDV5LMvS4ezCUY0rMUSJiOtG2G1THgc6TS4bwN1to0OQWPFCkLidI3TumlyNHyFyERIjnNgtAS+LqHDRmdvDi1k1BTaWEVHREeaYEbe22YmVEnSiIJW1twRd6EVPlkCRnd7rZi0x16UaVxJFXDiehNdtk/i8T4DY5iTxUpDIDOiigkTXDJty8K10nNPp4nnqyX1iFREUVciPJ7GeBOAyYSBXIDHiMbLWEj/Fhy4LC9A32Oqqj31sMNN/RTKu9h1jL1DMOIkTlRk05rpcA05tRImOeBLr+axWEiOOxEzWbBsZQQJTGVWBoiMpmuwMGyuhnu6rk/wXJEQSEiOcJG/o7gvBiSIy40R+pov4eXnOZR5QC2zW6xEVHWHOwOrWNqfZL8Z6RlHE0Y6SrHLmvuQVJjLWEplgV53xJG6xJOVVccTjVenPXIIE6BuE3ab+6hYkOnKQ8MaPdFm2qWZozSKM7hqeuoh8gMSIT3g1zdWvWTW87pYo4khwWUZyKwurW8ZVgH1NbtNzk2UyBYIXwqRPWIgFu+py3bhZSRKtfQKNNf2XK408r9vGa0GiY8qvXaCtG7zuppxy1/DUReQ6JEY4Sa7ay7cQnCgi1gNvs6j2wSM+zHXYrWTsVWyM38hmXDWuP5L61ZQzLCNO4oRHmMhZO/iCXXW5btysJNFoZh9wZW0VdduY8VuQyMywCcxdE8Z08X6exz86SstRXCofM9JRmgCfeSz8kBjxEa9cFn6ID34XURwJDod0LmVh5ZlFw7oeN4HSV7991lUeYSIyi8ZpFo6jO0Wj68bpPNFoHPHupJuGK2uriCBRFSBu4kDHDBsroYofkUF3uvj8EyREEhIjgvAsBCdXrz7hkazPe/FhbnPE5qckKjrCOJtGNutq5rXb/6s5L3YnJ0x0iBKvXDcsQZIwXwMjjiSUgsSLgFbeaceep+Px0zpCgoQgMcJNuaakZ8m6RDKahkN88LY56c5yf9TKpdk0brNoAP6ZNNb+EVuFl+2WMb5bv0SJiuvGzm1TZvlOQy1IzPgR0Boq64iMIPFCPJAgyTdIjGhA5+Cod5qtvAARj01h/5TyYTaNzCya5HHmay9mluFNB8+T3MwLUaLDdSPitilDDB1IuWl0CxIzKnlGvAho5TmneTaNyuq+LLRkZ3XCi9V9c1+QxBC1zV7Nd3wvKGaknyGyKq1IfTyITrOVrUdPPpIO8ETjq4gOPwULn1WEbxZNsmxf/4ikgxdJBc9y4ciKEh2uG1YGV6sg6TEF9ZpFDysfiWNgq5MgEUmM5ndAq6508TyWGaEFbnXOrnGjfwoSIgmJEY/xakpvGMQHz5O/VwsA+gVPe9jTdzOPS6A4a8Kz0ywaHmEiYy0RESVuVhLzMbyuG7uU8lY3qFM+ElZgawb5Kkh4pvayCE0yNK+EAwmSfIDECCfmhc54VqXlQcSFET7xYV9HxGPLSFSg31SIw2aws+A2O8aMuX94g1VlU8GrihKeHCUs1w2vIAFYVpKO9ArHPAnSDEEi5LJxEyRw2KcjjbwIbvXLWkeECGvuEWu9hySOI8ICiREfkAnWzAXxYa6f9eTP04bsNoVnNg1PW1iChXXN7ahxLKdLmAQhStzLuwsSs2XNbIVhJUjzXJB4GdCqK138/zrUYXdMKKwjgHeCpAqZHRN+4ooxI3FND8ZhQL4X+hlmy0i54MuJEnQyXyzc6i1HLOOVfQ2xjJfu+vvqcC6TbEuc+eKlFJ2evnjhvQajP43+yd5v32d23wnre2TVwTrW+juzq99aN+uaeMpb22XtK2ufO9VtxJGkP5vWtTFiSNJUOsR3lVk+V9r87fbZuq/K8rnC5bxu5WXcM9Y6ROphPqKy3bDZjTeo5jwZ4SdNTU0466yzUFVVhUGDBmHWrFl46623HI8577zzEIlEsl4XXXRRuswVV1yRtf+CCy4QahtZRnzCi9Vr/bR8uO1PoIT5LCNj6RARA17B0waze8GM9ZrdrCfZVhGx6b0qyc3cLCU6rCTibptoum47l5C0hURn2ng47NO9vpx1Ng3P+bQHs+rEK+sI4cRzzz2HhQsX4qyzzsKRI0dw3XXXYdq0aXjzzTdRUcFSsMAf//hHdHX1/fg+++wzjBs3Dt/4xjcyyl1wwQV46KGH0p9LS9n3RztIjHBSkroT8K5KK4JfC+DpFB92lKEDBRwDuarg8DJtPM86NAD7GlgCJYo4etGLw+jrH/MA7BRzIhIXoipKrFOCRV03tsKBw23Tazq3Uz6SwAUJbMq5lfXKXSMqgJTcNToX0uPZT4KEl9bWzH4sLS1lioGNGzdmfF63bh0GDRqEnTt34otf/CKz7qOPPjrj82OPPYby8vIsMVJaWoq6ujqZ5gMgMeIrXuTcCFJ8mC0AxmDLQlR4BL0+jew6NED2tfJYT6yWE3sBwicsWHElPMfyxpPYBaw6CYfsspntKbPMpnHKR+IkSMwoCRIzsvEkuuNH2A+uzmgPZvWb/BYkyZgR9rpefMcnH4wbGhoyti9fvhwrVqxwPf7QoWTQr1VwOPHggw/i0ksvzbKkbNmyBYMGDcKAAQPwr//6r1i1ahWOOeYY7npJjHBijhnhWZVWBJ0ZWVUSmYmIDztK0cllGdEhOLxIHS+7Dg3AFimGOOk1fbY+W/IIEzdridrCd2KixN0VwxYO7LKZn8vQgc7UZxlBIpQYTSRLqxmVgFZR3MRE3ltHnOomDPbt24fq6r44HR4XSW9vL5YsWYJzzjkHY8aM4TrP9u3b8frrr+PBBx/M2H7BBRfga1/7GkaMGIF3330X1113HWbMmIGtW7eisJBPbJEY8REvVrD10vrhJj7MVgCnmO5cWp/G7dxOYoV3sTxzv1ktJ3bCRJe1xE2UuLluzPU6u2IcZsQw3DZHMtqamY/EV0FiRlf8iBkvFtOzwuPyUZqSrDsRGgkSVaqrqzPECA8LFy7E66+/jhdeeIH7mAcffBCnnXYaJk6cmLH90ksvTf992mmnYezYsTjhhBOwZcsWnH/++Vx1h16MfPjhh7jmmmvw9NNPIxaL4cQTT8RDDz2ECRMm+NoO82wInlVpRdG1Bo2X1g8ed0sZYijkdMvoEB26k6S5ZVx1arPTYnk9NtY0FWHihShxs5IYZXisJCJuG+vv33NBYsZpyq9dOetnP6f7VsA5mJWFbDCrL1N9w1J//2HRokV48skn8fzzz2Po0KFcx7S3t+Oxxx7DypUrXcsef/zxGDhwIN555538ECOff/45zjnnHHz5y1/G008/jWOPPRa7d+/GgAEDgm6aNLqtBEGKD/O12A22yTboj5XxCqdziwoVu4XyzGLNPDjzCBOdokQkDTzLdeMUsCrrtokihq500jMPBQlvDhJZi4ju2TVuAiQ07ho7dFhHABIkaiQSCfzgBz/AE088gS1btmDEiBHcx/7ud79DZ2cnvvnNb7qW/eCDD/DZZ59h8ODB3PWHWozceuutaGhoyJgu5NZ5nZ2d6Ozsu6kbUcbd3d3o7hb558mkrLvL9K5iGXFaSp71SJY5v98qZhKW/dYBMWFa8wPIDhTstQx6ma6XzH3WlVV7TPt7u5N/l3YDhZa1e3qyEisksRNCRxiDuBPRLjXxEi/hmz1T4rAmEWv6bqmpfE/qp2f0U1+dfSKuwzQom79V8yBcanKIdaT6NZr6PWaKg+5Uu8wDv1HOOK4r67wV6MqopwJdGddWhiPoSv2mKlO/FWN/JTrSf1elxVOy7mp0pM9blfodGeetQQzd3cl9xd0J1KA9fVwJYunrLEXc0hft6TpLcThdX1nxYcTjKaESPZyZNr60Fb2xqNFJQLtJkJh9jSVA+l+hApmDttnKUIlMi4OpOlRZ9pld59XItnaYtf8AZAmFaCL5nUaLu/vaaMb6+RhLHaVAltYuyz4PE9tbnvWe6lRhOZyFBG8CrwpmPdFo8v9N5T6v43gRulCKToUA1i7B+MWFCxdi/fr1+NOf/oSqqiq0tLQAAGpqahCNJv8v5syZgyFDhqCpqSnj2AcffBCzZs3KCkpta2vDjTfeiK9//euoq6vDu+++i6uvvhonnngipk+fzt22SCKRUF/1zSNGjRqF6dOn44MPPsBzzz2HIUOG4Pvf/z4WLFhge8yKFStw4403Zm1fv349ysv5Bh2CIAiifxKLxXD55Zfj0KFDwnEYvLS2tqKmpgZ/PnQaKqrlxUh7aw+m1LzG3dZIJMLc/tBDD+GKK64AkExyNnz4cKxbty69/6233sLIkSPx7LPPYurUqRnHxuNxzJo1C6+++ioOHjyI+vp6TJs2DT/96U9RW1vLfS2hFiNlZcmnnsbGRnzjG9/Ajh07sHjxYqxduxZz585lHsOyjDQ0NODTTz9V+mGt7/42jtr0NXRN/Q1Q7I1y1hU3YrV+mHFzvVitH5nnta+3p7sMb2y6DWdO/QGKivnWS1e1aGTU1c6fFjleoT/xsJt15Uh3GXZu+gVGT70ahYz+idlYj8xWCzOsKcMdjDqsriJrQK31vNbzZR+f+bnL9Dhu3Wf+7HTeDpSjuBu4bFMJfjO1C4eK2ceZr898/U7XYFhIgMyF9dLWEQOzhcT8YG/+d7E+8Lfb/G0t67TPut/672kqGy3qRvPXN2H+r6Yi3l3MrptVv/Uz69/OWob1L8xtHWFVaMbJOiLigsksG40m0Nz8OaZOnYriYruMse60trZi4MCBeSlGwkyo3TS9vb2YMGECbr75ZgDA6aefjtdff91RjNgleykuLlb6gZYb/1zF3cpiRCQmgi/XCP+sl+xj9WRpNVwrRcUdKCq2pPLutDmHw6+vXEBcuNVlpVgi31rMRcBU9VqyrpayRURl8efp/jHHSlSZ7v6ZbhJ2fEnUsuotAJRb3CbJ47syzlWeWkys77OxaF/ymLKU3944VzR1w+/LB9KWUb4I8XQcSWlqZOyLMzG7W9oz6ikxxXwUIYbu1PbuYqC4OJ4uV4S+vzOTxXWnr73Q4lqKoDN93khxVzqGJDKgu0+QVHdnBrQWmMRINfrG0ij6BuYq2MdpWF055ke8css+q7fCbGkvQqYQKEPW+BzvLu4TIyXIHve7LJ+tv/dCZIsYlvhg/etze6gHwF5YOA2+R4F/Bd4ayzmS9wzVe73KsYQ8oRYjgwcPxqhRozK2nXrqqfjDH/4QUIv4V6WVJVfEhxO24oNVn6jocCFiuskmZJJE2eDUTpZQsfbB4YLsmBJWsGlyO1/OEKDvuzaLErtgV6dAV5VcIk7BrW5J0vpEUAzmoAdrgrS+WTfsoFbe1PG2WVqtAa12eDEVWPd0Xy+DWZnoDmYVIbcDWuMoQ4HCMBz3YGZnUIRajJxzzjlZi/i8/fbbOO6443xvSxQxranOxBKdyYuP5PHeZWk1Bt0jR5KPgtGuWNavSlZwRNymInp8PMAnaKzXxxQnKZdUtCuGot54huVEdi0aoE8s8IgSu9k3TrlGeHOJAJl5SUSm/9rlbvFKkJixFSSy031598mkfzeXPch5HpHz8dQTilV9dZ2HCBOhFiM/+tGPcPbZZ+Pmm2/Gf/zHf2D79u24//77cf/99wfdNG5kpql6KT6SbZLP0spj9RAVHzpEg1c4tc1OqHCJE1M/8ggTXmsJa3qwmyjhsZLwpoC3ChK7eqx1dJksJN2251ITJOk6LVN+beGd7mt3jNs+pzGUZR0xf7aKCRFLjAg5YR0h8oFQi5GzzjoLTzzxBJYuXYqVK1dixIgRWL16NWbPnu17W8oRx+HUeyTLKSsH74q2PMnGvLJ+8IqP7iPJATja3sv8VUkLjqCECodFhHVNLIFi7Z/umsz9Rh9b40xUF8mz5uawrpDL47rx0m2TKTT6RlqWgGC1mVeQpI/1yl3j1WJ6qriJH+3WEZYg8dM6ckjiPERYCLUYAYB/+7d/w7/9278F3QwleEWHgar4ALyzfvBYPaSER9isI07tcRAq1mu3EycGZquJnbUEEEtmBti7b0RdN7Ip4AFnt42dqDFfh73wERMkSvEjMu4aXWvXsFYTNuNmHeHBl8ysduhKhGZQBeB/lVrkN3GUI0IxIwByQIyEhTJ0ZCwBrwOR1WyDdL24CZBIOxBJBdREYrAPllcVHHq63Rn39aXsr4MhPAxxErEJODL61urKcXPjeC1KZK0kbm4bO0FiZF0tRwda00nZvBcktvAIEl3uGjN+W0d4jhFCp3UEIHdO/4HEiA+IiA4DL2e96BAfrsjcUP0QG244tcFNqFivmSVOYkAkJdbMVhM7awnAduOoiBJR142d5YPXSsIjSMy/d14riorLJl2HnXWEF1l3jRkR64iVvLeOEP0FEiOcGIKiFJ3aLCOAfwvkqbheXMVHO/pyJbTDOY2Arq7TEZxnNXu7Ydd2O5Fina5pwW4asogbR2YtGhkriWxwq4ggMaNTkLD6IHB3jcpUXze8WrdGCaeT6nbXELkIiRGf8HuBPBXrB5f44EFGeGi9AWo6l5tosV4nS5y0m94LkWU1MfrcGmPiJkxERImM60aH28Ztpk3m4ngxHE6fX1yQsJBZVC+NX+4akam+lQA+5yzLi1briOjMGh7yU5Akf5fySdZiHua88hsSI5wYadKtq66qwruirWqyMSXrB8+Nrsv07pZt3QvB4dZGlQRoTu1lCRURcQJktM0paRsrvkRWlPDOunGzkvCs3GsnSMz7zEHedsfyBb6qx49wu2vsBImsOHE7l3nQdxMveWcd4S1D5CokRnyCV3T0lVfPdOqp9YNHj8neyLyYWSNTJ4+AsV6jnTgxvoouICuEQVCYqIgSXVYS3tk2doIk2RV9QqHT0tmigsTT+BE76wgvXlhHvMAX64hqgjISJPkKiRFOjDwI5ehAoZADl6duPhdO6MUHkLyx8qxDF7apvCxkpvfyihMDq9XEOCeHG0dGlMi4bmTcNqIzbQzxE0UcbakAG12ChIUn8SNeB7Nafys5aR1xgoRGf4bEiI+IZmP1dNaLqviw3qDsmqIiOkKc8IzZNtZxRj/Z9Y+dMHGxlvCIEqfZN26ZSs0WBRm3jcxMG1ZbVAQJ61qU4kd4sBMkYZnq64bs+cg6IkVcMWYknkdDeP5ciceYn9yKBF0uXPVzLi4XKgHCIgaAI4FlBmGzkgjkEbE9zslyYmgGq9XE6H8OawmPKLGbEixiJZFx28jMtDmSPiaONpQKCxIWsu4aM8qza8zwihORsdoP64gV7hTxMuSP0CDEIDHiMyIr2gKapt3aoUN8GPUnHEvpFRw66pIJaBURKdayrLHPPDCZ0SBK3Fw3vIvjybht5ARJF6zwCBJ2vQFP95WxiITJOmLFE1cNWUeITEiMcGJdddULtKVa91KA8N4Uw74WjcgKqSJ12ZWPmd6t4sP65Grg5sJxECVurhuZWBIRt43Kqr288SfGtGCZ+BERC4tWeAd2t9gRL2fWBD7Nl1dokCDJJ0iMBID2VW1V3C+6xEcMSfcDj+EnbG4ZJ0RdNhxZWB3Fi4i1xEaUiLhuRK0kLEFirYclSKx1WYVFR+qCS9CFDhRxCRK3elm4uWtCbR3RGzcvRiitI7lP8n+oROH4bItirkJihJNoe9+qq8VFYmJCBC2p1r22foiIiVwLYOV13/CIDms51iwjm9kzKqKE13UjYiWRjSPhnfrLWkzSTZC4WTcCcdfYwSs6zIikiRe1jrghax1h4kUSNAOyjuQLPJMwCQ+ItLNfTNotLxadpheLNtNLtH6e88uUZZUXOdYLZNvCWz5mU8buWLvvjfVdW461/qbK23szrHLRzlhGDJN1tpc5N445g3ApOjPWW7ImLGP/za6LNcOsxFS33XGs/W5tsBM8WjGn/RddbsDtGJXEfW7nqdJUr/Djrd2JqwXqEClLhBUSI5xEYn3vdkKCJSqERIcZEfHBEiBt4BcgTvt4BZLTNekWHE71ub1kEa1PpAzvdjtR4nKs9fdmdRNaBYmTiLCKkr59egSJUY+bIGHVa1cnS/CwFq/MOL7c9HdV3/kLKkx1VZqitnmERyXH31acRIJ1vSNrWZ3iBZATV2mKdbWCyFPITeMRXIID4B8gVTOe8lg0VPbLltVxnFfnkMk34hQjUpX621rG2M+73erCkXDdsGJJRKYA8wS2iuUiybZQ2C2ux2qjgcx0X+3BrLzr1tjhVaKxQANZZRBxwVQDOKjjpERAkBjhpd30bl2VVjZJlhM60q37IUCMMhEkb2ZOAaxBuV5ksWuv0/dtPoYnjqRCYXsb2LNvXESJXSyJSHCrF4KEdR7epGisOmVn16S3icaO2MGTCE0274hb7IhulIRSMcSToOV3TEgc5UgoBLB25NEQnj9XEiSqg6xIqnWVdugUHzyo9ovf4kU2eNXuWHM5Q6zZlZG1lrACXe1EiYSVhDftu6og6bD4/VmCRETE9G3jz85qIJ2ZVSYRGk9dVirAPz4HNc03EHQFvhBBIBQz8re//Q2rVq3C//k//weffvppxr7W1lbMnz9fa+PyDmuch1PAKeAe9wGIxXY47eONDbHDbDnijc/wKr5DFpV28JaP2ZQRjR+xbuMJcrXU5RRL4hTc6hTY2rddLIbEWBW7POM454BTmfgRVvuc6rbDNnaEB79jR3TDEzuiLZAVoADV/gG3GHn22WcxceJEPPbYY7j11lsxcuRI/PWvf03vj8fjePjhhz1pZCjoMr3biQq3lxNW4cEjPmQEhg7xIRvI6YXY6OB4qSLaftE+lN3OKscb5JqCNePGjJ+CxGm/XUAr6xhWu1jljPaVutVtE8zKxDxQh2VmjWggq0wgLPdSPsVibUlDgiTf4RYjK1aswI9//GO8/vrreO+993D11VfjK1/5CjZu3Ohl+/ITXuEBqA1suvbzlgEyp67KCA4ecSEqNLyoExAXJ6L7ea0idqLEDMc0YAPWFOD0vgAEiQFLkLAsIO7WE/HZNSyUrCNmeK0jTvus1hHe87nVqwIFAbgSQ1lqjprsS+SLB5qamnDWWWehqqoKgwYNwqxZs/DWW285HvPHP/4REyZMwFFHHYWKigqMHz8ev/rVrzLKJBIJLFu2DIMHD0Y0GsWUKVOwe/duobZxi5E33ngj7YaJRCK4+uqrcd999+Hf//3f8eSTTwqdNCdpM72rvtzQbb3w6hzmciJL7nhpxdCBqjiRLSMiSuy2mbH+3lhuGxNubpv0dg8EiUGZi7go4RQN/NYTvtwjZuuIKzzWEV4BIGsdCYOrRhi3RpN1RJXnnnsOCxcuxEsvvYRNmzahu7sb06ZNQ3u7/Y3r6KOPxk9+8hNs3boV//M//4N58+Zh3rx5eOaZZ9JlbrvtNtx9991Yu3Yttm3bhoqKCkyfPh0dHfw3UG7tWlpaioMHD2Zsu/zyy1FQUIBLLrkEP/vZz7hPSqQQsRzwlOUZCL0+hxU/BQarbTpyLbCuwemBxNwOtxk1ToGvrOBVt22sY1mzbkrZ5d1m27Bm2qgEtabPY+pk/uBU+em+MsGs6WPtZtbowoupvaEKZC2GdxlZCSesnox169Zh0KBB2LlzJ774xS8yjznvvPMyPi9evBgPP/wwXnjhBUyfPh2JRAKrV6/G9ddfj4svvhgA8Mgjj6C2thYbNmzApZdeytU2bsvI+PHjM2JEDC699FL88pe/xA9/+EPeqnIT80JnovEPMjETotaPMLhoADVLh10/8b501MkL73W6WY5ELSUqVhIzknEkuiwkrDrMOAWnyrhrnM5nbpfRXinriF0SNB7riKx7xoyYxd4ftLtqyDrCorW1NePV2ck3RfPQoUMAktYPHhKJBDZv3oy33norLV727NmDlpYWTJkyJV2upqYGkyZNwtatW7mvgVuMXHnllfjwww+Z+y677DKsW7fOVln1C1QHOF3iw1pOdb/TeXTFWogKAS+RbRdvP4jOprHbxyNArGVYbhuH470UJPbxI9kd6BY/wjqntU28wawsmMfaZWXVBa8AEXHV5ERG1v41PbcbpehSeHWnLHkNDQ2oqalJv5qamlzP3dvbiyVLluCcc87BmDFjHMseOnQIlZWVKCkpwUUXXYRf/OIXmDp1KgCgpaUFAFBbW5txTG1tbXofD9y69atf/Sq++tWv2u6//PLLcfnll6c//+Y3v8FXvvIVVFTo/g/IcUQHXZ7yOsrwWj1ECIvAUMV6HW4/aXM/2T2tGnXy5hcx9sm4aaxlzG4ba04SS1mz20aXy8YgMxFZDD3p7ck63JKbwVLefE4nd41b7hFWveltprwjTEQX0Ms4lrN8JYBDNvtE8pvkbM6R/E6EJsO+fftQXd1nNSotLXUonWThwoV4/fXX8cILL7iWraqqwq5du9DW1obNmzejsbERxx9/fJYLRwXP4p2/+93vYtKkSTj++OO9OoW/xJC0I3nwEJSBX+KDtwzvjc3sxupxKuhAkOJFRDOz2ml3vNF/djZIN1Fi3WcnNljbeAUJwB1HoiJIDNziRzLL2sePuKWLt5bP3MYSK8l2ycSOuGKXIl5EgHh975GBp/3a0sMTdlRXV2eIETcWLVqEJ598Es8//zyGDh3qWr6goAAnnngigGTIxt///nc0NTXhvPPOQ11dHQBg//79GDx4cPqY/fv3Y/z48dxt8myhvERCYapbf0DUVeFXGdFYCFEXi454DS9QbRPvMXb96oebhuW2MeMSR2Ig67LhmWHTFysiPt03uw7x3CPZ+/hiR5QW0LMjCFeNV9N8mai4aih2RIZEIoFFixbhiSeewF/+8heMGDFCqp7e3t50XMqIESNQV1eHzZs3p/e3trZi27ZtmDx5MnedNBOcl3b0LXTm1/n8KsNj/ZC57qAFhg5ErCDWY5zKGX1udeP44aYxf2YtuueQRl7WQmJgP8MmnrU6Ca+7hpUuvq8OJ/eOvVUmMOuIWxp4A5H1apxws2yE1lWTH8RQhh6FyONOuKyLZGHhwoVYv349/vSnP6Gqqiod01FTU4NoNPk7njNnDoYMGZKOO2lqasKECRNwwgknoLOzE0899RR+9atfYc2aNQCSqT6WLFmCVatW4aSTTsKIESNwww03oL6+HrNmzeJuG4mRMMA7aOssp1uAmN00KibZIASMaFgTbwyJuZzdw56oKNHlppGMI5EVJDxTfg34p+fau2acVt91muors4iegfACejzwunGcREIYFs/zxFVDsSOiGALCGuvx0EMP4YorrgAA7N27FwUFfU6T9vZ2fP/738cHH3yAaDSKkSNH4te//jUuueSSdJmrr74a7e3t+M53voODBw/i3HPPxcaNG1FWxi+0SIzwEkPfqrQsDxTv07IoYbR+sMrx/JLCaimxa5fMwnl2x5jFGuv/U0aUiFpJWJ9F4kg8FCQxy8qlohaNUFtH7BbQk7GOmJEVGW45R3ylGOIr+RKy8IRPbNmyJePzqlWrsGrVKsdjIpEIVq5ciZUrV0q3zbOYkX6HUyyEyCDPcxxv3W6xHyJt9OpawozMNajG7YjElKjEktiVd4ojUYghSe+3mfLbd4x9RlT+XCL203lZ7bDWqZKVVVuKeFVUco5Y40Y8XatGFYodyReExQgr8ZnBfffdl/77uOOOQ3GxXYBSDtJueVetS3Sg4y0nIkBE2slT1nyMKm7iTuWls128ZZ3KsBAVJW71inx2ykciKEjS+11ykJRx5hdxEhisYFZrXbyBsdb2ubVB+wJ6Mqnjg0wPz4PWlXzzgw6UI67w6nCYiZZrCIuRCy64AFdddRW6u/tMa59++ilmzpyJa6+9Nr3t9ddfR0NDg55Whg2/BkNdAsRcl65z6hjgvRIMfp6X91inaZlOxzuJSrc6VD+bkRQkPEnRrLDEgZOI0Gkd6dunyToigsxMFqfx2sk6khMJ0Hgh60g+IGUZeeKJJ3DWWWfhzTffxP/7f/8PY8aMQWtrK3bt2uVBE/sJIgOjzPRb3vPytlGEIASHLCpt5BUldmXsjneykrhts9YpaiHhwE6QpLfZCBIDtrtGdHpudqp4+zrtrRhOVhLXNrCsI15M8/Uij6SvU3oJIhthMXL22Wdj165dGDNmDM444wx89atfxY9+9CNs2bIFxx13nBdtDAdOa9OIIDsw86YbFxUgbohep2r/hA2ZaxERdnb7WLC+fx5BYt0mK0gcVvxlIRI/YuDkrhF1sfBYR3jqYYmljGNFVvQ1EHXV8KLLVaMjboSFZ64aso7kOlKzad5++228/PLLGDp0KD766CO89dZbiMVi/Tf1u1cDLm+uAF5RwYtMWVVLq+z5RdDx87S2zanOds4yIiv3AsnfRZlLWVa95m3W/U6frdN+JWfYGLAytNpZR7JX982emWPdZ87Malencz1i03xZSE/z1T2zRSTniG6E8o0Uoz+u5BtDFEcUon27BPOMhBlhy8gtt9yCyZMnY+rUqXj99dexfft2vPrqqxg7dqzQCn2ECavbxW8LiOjTvw6rh52FyEtLitM5Zc+tagVx2+/kumGVdTvWQwuJqrvGgHd1X6dMq9bzeGEd0RrIyoNdUKtsnGeo4kacyP9AVkJCjNx1113YsGEDfvGLX6CsrAxjxozB9u3b8bWvfU3rojmho8P0LiMenI7lgXfQlBEgoufnJQjBoYpsO0X7XWafFZU4Ep591s+SgkTGXcNa3bevDqeYD/fYEWtZrwJZhbATGn66akTP5ZurhhcSLbmMsBh57bXXMGPGjIxtxcXFuP322/Hss89qa1hO4iRUZFa81SksVKwfIm6gXBAcIqgIE9kyImJFNo5ERJCYERQkBixBYh7Uyxjr11jRZR3hCVJlleG1jhh4sl6Nn7jFjfgKCY18R1ijDhw40Hbfl770JaXG9EtkB20RgeBFO6zliwWPF6lbF6pmaWu7dKxR026z3+lY1jEycSTmzyL77GCUE4kfsWLEbGRmc7XPpmqt0yl2JPtcydgRp9V8edstvV6NKOb4Etm1anjWmlGB4kYciSvGjORTb1EGVl6cZtO4uSF0uCt0u2lEy8qUdzo+CBeO7vOKWK5k84zY7ZN128haSHjcNSZE4kesOE31ZSFi8bCW1THNN11eNeeIX64a3jYEcbwjZB3JZ0iMeIXugVvHubx21TgdmwtuGx3X64ZMnhG7fXZuG9axvJ+tdYoKElMZGXeNgSFInIJZRWJHnMqm28YhakRdNRkEmR7ejMoUXyuhixshchUSI7zELO86kH1K90KoiNZrPc5qOcoHZPpD9HuR2ee2jSeORNZiIihIDNzTxScbXMb4B3MKZu0rw28d6Tunu6ixtiHzeAcxJDKrRhd+GA7IOEF4BIkRGXjdDe0u5WXPJ1JeZ1nZ9ogg0rci34HutomUdysjuo9HkADqgsQOHkGSQsZdYwgLnmBWHiFhtY6ITPP1xVVjN8WXx23DK2r8TA1vRSgkothlP6mhfIWMZV4jOxjKuAm8qlv2GD/qUjmfyk3YXCdPIKvTPdaoizdY1W47axsrsFUmqNWuHXaYypsTohmwglmdYAWz2sET5Jp9jH0SNCul6ESnJTCW5zgA7gnQdCY9kw1OVW2D7sRteUwygFV+sTsKYO2PsKwcuuv3yiVgLS/TJlm8tFSooqttot+B6D67+nVZSJzw0F2T3qbJOsIduwE5tw7LVeNEIK6aIKC4EUIDJEZUkHENqLgS/BQssgOzdbZRrqHSdt7jZASJ3T7ebU7odtcwcAtmNSh3mOfKEztih0ogK08Ok9DA68XQuU6N7wTeAMIDSIx4ha74BZlj/RQgxnE6A3vDgmy/8AoSJ0uISN0821TiR+z+tkPCOuJkdXBbqC6zHv6pu+n2CJTlaZNy3AiPxUR33IjXaI0bIfIRMpTxYp4tYjjqvAr8khUFYTuHCk6JoIK4qZqvnTcBGE9Zu1gMp+NZx/BsE40fsavL7m+7BfVS8MaO8MRv9MWFeBsfYoWVAK1vn6a4kYyy6LM6ydxveONGvE5+RjCJoxzdCjEjRzS2JWjIMqKCquUj7C4b2WPccEub75aRkud41XT8Tsj0uVsZ0X1+WEh0uWs4rSNOOOUdcUNkvZrsY9VcNf0mbsSK59dFrpp8g8SIbpziSHQKF5njvDyPHV6KAh1tUWmPSD+5ubHCJEjs9qm4a1Lwx47ITMMVX4PGrQ4nPHXVqKAjbiTnF80jcg0SI7wEYcLUIVy8PA+LsAgPEXS0mbfvVNLC825X/R5VxYmCdYQndkQlkDV9bokZOAYy1hlhRGNCvLZEhC6Ilcg3SJeK0g725G4d8SOyg4jfxwHZg3ZIMl1rwXxtIk+rInEiTuWc4khkY0hU4kecYknccIkdMRbSi3Y5Z1cVje0wsMaUiCyeZ1eXE6y2MhfOE4kbsUMmn0deLZrntDpgbhBDFEVKMSP5c+Mly4gu3NwwOt02utw9IuSixUMHMtfM27+6XDN2253iQQD5+BGN1hEWPLNbrNYRlZwjducVWauGdyYO01XjtVXD6wyrBKEBsox4ic6njDBYP3Tjh+tL543Y6A9eawmPpcTJ6hAGC4kddpYT1vEc1pFWF2OFYXFgZT8VxbCOeDWrxqC8PIZYTPCp18lyIYIOo4FfmVSLkF/TQggpcsoycssttyASiWDJkiX+n9zvheCCsJp4Yf3QYQnSfX5VRPuoHWqxIiJxIbotJKJBq2ZcrCOsYFYDmdwfbpYNHQnKeOJUWFYZ5qwat1V87eJG7MSijIXFy9iPfJ0pRHhCzlhGduzYgfvuuw9jx44NuilJ7G6kout36EK2Lt3Wj5gHderG2lcq1hNRa4kTolYSlVgOHShaR1hEu2LoLnaOpTCsIyLr1ajCtyYOf64TbYRpHRiemBOKG8mgA1EUKvxmeiA2RT7M5IRlpK2tDbNnz8YDDzyAAQMGBN0cZ3hiQ3Q9oavUpcv6YZw/lzOw6vhOePtSpZ94LSQ5ZB0xiHLkHZGJAxFF9xRfFoHEjeiAZtTkPM8//zxmzpyJ+vp6RCIRbNiwwfWYRx99FOPGjUN5eTkGDx6M+fPn47PPPkvvX7duHSKRSMarrEz86SwnLCMLFy7ERRddhClTpmDVqlWOZTs7O9HZ2XdzaG1tBQB0d3eju1t+jcPukmjGe2CY72OirnPzgCPrdrfeR1O/ue7SaMZ7ztKTepd50E7A1kKS8fvpcqi/2+XcxYxtrPo6kW2dKLR8tj6KWD9HbP42Y7WIGO0wawvj7ziAktTfRj+3AolyoPtIsn+OHIniSHckVSTZmaVIIJb6uzf1wzXeE6kKE+mOMd6Tt7YoutCBclSgCzFEUYEuxBFFGY6gCyWoRCfiiKISHekYkKLUxRZZaixOzVwoSb/H0JH+wntTbe5JtSf5XlZ8GPF4st7Ekb7AiN6e1L2o19SxRj+ZvTemv6MpK0EU3fbfjfk7LLT5uwKZOWDMv6mjkCkWS5CJ9bP1PtJj+cwbC2JbjueenTw4Gk2+q9zndRwfZtrb2zFu3DjMnz8fX/va11zL//d//zfmzJmDn//855g5cyY+/PBDfO9738OCBQvwxz/+MV2uuroab731VvpzJCI+Uyz0YuSxxx7DK6+8gh07dnCVb2pqwo033pi1/dlnn0V5uYIpd1EzAGBT6p1gs6mJ+seJTVfnef90WN4B4H/5D39hyy+VTl9iedeLMdKa3QI+ughSoq+5YlOm0BzkXxNygU2bNikdH4vlnpnXeOg2KC0tRWlp9hPnjBkzMGPGDO56t27diuHDh+OHP/whAGDEiBH47ne/i1tvvTWjXCQSQV1dnUTL+wi1GNm3bx8WL16MTZs2cZt9li5disbGxvTn1tZWNDQ0YNq0aaiurpZuS/d5ddh0dTOm3jYfxV0OTk8V17XO/wEdLhiB9nSXRrGpqRlTl85HcWfIVjLVgcz3avrJdpdE2b8fp3qd9rFiRVjlreWsZayfrf9m5v0VHNvN+8xlDBO/WSWkjjMsI3/e0Yxzz/s2ioriiJckDzasFTFTwzpSFRuzagzrhBGvYcyMMY7pSH829iffu1KNiVu22x3POodxbqMtrHYalhEA6XwjvTGTBbE99RRpdmmZLRep7VF0oxmbML99KuLtxVn7k3VlH8fcx6ifWc7qUrOWtX623jNYbjq7e5OSdaQN0egRNDfvwNSpU1FczDIh8mEd2L2kEyUoVJgd1pPqm4aGhozty5cvx4oVK1SaBgCYPHkyrrvuOjz11FOYMWMGDhw4gN///ve48MILM8q1tbXhuOOOQ29vL8444wzcfPPNGD16tNC5Qi1Gdu7ciQMHDuCMM85Ib+vp6cHzzz+Pe+65B52dnSgszLQ92ynC4uJipR8oUgNIcVfcebC1uo/NJmwv0Tn7RYHizjiKO8TFSLem/in2KqDT6F+R+juRNbhn/X5Y7hSDLod9rPvzIUZ567ZWy+fDls8xS5vNLoM28AWsGhZas8vA+PsI+kz7xr+uKbi1qCiefKWCWAtTlVWhIy0EClIHGlVGUn9F0rczo3OKUpdwJPWetGz0pt8N14rxnkg10XDDxFNJqfqm/nan2tOVeu9Mndt4L0y5gwCgI9XOeHffbTZelPy7t9B0LyqIZPcXyw2T+i7iKEa8orhvoDd/R2b3WDkyDTdmF4p54Lf+lsyfS5ApKLosZa33O+t9iHVfsrs9KE3v7etj1Xu90jgREPv27ct42GaNgTKcc845ePTRR3HJJZego6MDR44cwcyZM3Hvvfemy5xyyilobm7G2LFjcejQIdxxxx04++yz8cYbb2Do0KHc5wp1AOv555+P1157Dbt27Uq/JkyYgNmzZ2PXrl1ZQsRTVNKEeylEdK6vormd3e38Ly/PqRXRfuL5bpzqE5nC6wUq53E7lqNumZTvvFN8SywJy2TWtDEQXadGK6Kp4634HYia42FlYaS6ujrjpUuMvPnmm1i8eDGWLVuGnTt3YuPGjXjvvffwve99L11m8uTJmDNnDsaPH48vfelL+OMf/4hjjz0W9913n9C5Qm0ZqaqqwpgxYzK2VVRU4Jhjjsna7hsdyHwa8Hs5e10zYDRjDPrd7Qjd1F6zINFmOTHq5KmvA+4Bw6LTeu2282xz+2xNhGaHyNTeNnANlNH2XnTXJBfPi5c6+8aCmOJrhSf5GYuCihh62y1tNU/T1ZX8LGi0TD3mmeJLeEFTUxPOOeccXHXVVQCAsWPHoqKiAl/4whewatUqDB48OOuY4uJinH766XjnnXeEzhVqMZITyK5jIlO/Ch5YPTLwW5RJYm23sjjhzfXBayERFSSqZe2OMQsSN6Eh2hZWRlYO44FKxlTdyK5TI0WYcolYsab58Hp9G8eGfB7EiZWII4oCBVNRb9b0Jb3EYjEUFWXKBMMjkUiwk/b19PTgtddey4orcSPnxMiWLVuCboI91gHHbYDOsXTr2l0eIUCLOBG1ksiuj6aS+MzNGiKLiFBhWUc42hGExcOKISxU28JcNC8IZBfMC7MwIlxpa2vLsFjs2bMHu3btwtFHH41hw4Zh6dKl+PDDD/HII48AAGbOnIkFCxZgzZo1mD59Oj7++GMsWbIEEydORH19PQBg5cqV+Jd/+ReceOKJOHjwIG6//Xa8//77+Pa3vy3UtlDHjOQ81vTqXi82pzn+w9PYi5CidK28xzl99zLn5k185laGN3ZFpm4rDnnCylMJ0KKdKvEieuJGZFLICx/jlha+v5Bzj8a5x8svv4zTTz8dp59+OgCgsbERp59+OpYtWwYA+Pjjj7F37950+SuuuAJ33nkn7rnnHowZMwbf+MY3cMopp2TkGPn888+xYMECnHrqqbjwwgvR2tqKF198EaNGjRJqG339vJjXpulAOFbCJMuHZ3S3K1hJeC0kdpYzr9w1otYQ1dgR2fNyYF04TzZ2Q09bkud2WsSPtWgeM25EN2Y3SmAuFB1Q3IgOzjvvPFv3CpDMpmrlBz/4AX7wgx/YHvPzn/8cP//5z5XbRpYRWTyagcJ9Tk3n7W+WDxGk+8VrC4msJYRVTsQ6IlPOCmd6eCs6F7vThcysG1dEZsPYlc2F1PIh8FQR4YIsIzqw3kx1PgV6OPMlCA5rPHeVT9YpKSuJDmtAGOqwC2T149zgm1XjNyJxI74F21IsB3JDhWWSDGCV/314HcDqJyRGvEAkoNHuWM0EJUB0ig/eur0QKZ4JEl5XiK7zhQnOlXzzDe4gVj+n9zotfktCh/ABEiNeEgLXh98ipC0GFAVsSTeLFJ3CxOhLz7K8shDJMaLrHDqmBovut1De3otYRTi8yGGaUpyTkJghOAjHf3sOYE7qFfb4Cr/iQA63973aQrq2lNE+nQj1K09ZnU+/PPEkuvrDrh6F+nnyjRgYM1+M7KfRVDyJ7hk1MvTrGTW5ZJ0jQgNZRiTxJKunAn4Ij1zGaL8uS4mQ26Ydau4IP6wjTqjEjbCwyzfCiWGpCCOiM2q4qYSvCwQL4eTi0Ur+zaiJx8oRKZK3tiViFDNCmPBbmPhlmcl1AcJCpygREiRuD9k6Y0d04EVSNEXCkPyMgLdulyIoLphH5CrkptGMF+4RP5OPmV0v+Yyua9T6fehKhibjqtFxHTJ1OCQ/M5BJfuY3UckpxwUVAV5bmMQv0e8hMeIRqsLBz/wf/UWAsNBx3YHGEAX9nemOnzFhZGINMzxxJVHR2BO3Gap+uOZC4Hom+hfkpuHECNA0ZovwmvnDGOzaH0WHG6ruG26XTQxAocN+2cysKmVF4alb4fyRdiAR0sFQ1xo1BJKJz8KTwy4QYm1liETk458SbfkTQ0OWEUlyzZLQn60fIvjSP7rP4VX2VfNn3fkuPIo5EJ1Rw4vuzK/lVZrq48nzVWX6O6QijyBIjCgS1kHe3K6wtS3syPaXNiuY7oX0/IQnXkUDVnFRyhN84lBPKKb3shCJ66i0+TuvKA66AYRHkJtGI7qnj8qeP4y0KkbIV/v8S5X9LrndNX5My/Vr6q+q+6gT3Hcico/kKJT4jHCBxIgHHG73T5CEUYCoCg+nOv0WJTmD36ngcy31PEGEkER7ORIFCuK6PX/mQZObhpPDgt+5V+6RMLpfWo/09Y9oP8mcy3j5gUwfa3HX+LUmiZWQ/Kas5ML0XgNZl1FeZWElCEHoOVOQw0eAwiP8T+iigxnLohIW0QH4JwJ48Mta4pmli6wL/Q6lLKwEkceQGJGkVUCQiBAm4QGES3zYYW5jv3Dj6BQxInWFLUtsyIgijnhI09TnFJSFtV/SH27dnpHPcQy5IEJYePWdiFpHhFLF+4mf1hiy/OQWvq0xQ6RpjwCRiNrxeQLFjGggVwduK37HY3hJPlxDYHEjRDjJpem6nopQmt6bj5AY0USuDuL5JECs6L4uT1xoXrvlQub2y0dUcpEQBJGExIhmcmFQz2cBwiKo6wzjUgDCBHwNubA+Tb8gl6wyRE6Sh9EO3iDiSg1jLEl/ER526Ao49jOHjDAUo+ErlIDNhGy8SX9fn0ZV7OfDA08KsowIIipKghABZstHf7KAuKGrH8I244kIP8Ir9xJEPyNEz+65Q2vqvZq3vMMgqPq0TkJDDK+mZNvBNavGyaJhN502H6wgbchJ87+xcq8uCipi6G0nCwvRvyExokAr+AWJbR0kJnxHhyAJtbuGIAgixyAxooiolYQIB35bSAhCiLAvLBf29uUKHQAKFY/PEyhmRBOt7kUIgjCTgy4a3wj7QB/29hFMnn/+ecycORP19fWIRCLYsGED97H//d//jaKiIowfPz5r37333ovhw4ejrKwMkyZNwvbt24XbRmJEIyRICIIgiLDS3t6OcePG4d577xU67uDBg5gzZw7OP//8rH2PP/44GhsbsXz5crzyyisYN24cpk+fjgMHDgidg8QIJ7yzaEiQEL7gV7yKynk0tDFWEb5blM7gVQAUvEr4xowZM7Bq1Sp89atfFTrue9/7Hi6//HJMnjw5a9+dd96JBQsWYN68eRg1ahTWrl2L8vJyNDc3C50jfP/peQAJktyAgocFoUXypNEtYAjCTGtra8ars7NTW90PPfQQ/vnPf2L58uVZ+7q6urBz505MmTIlva2goABTpkzB1q1bhc5DYkQQspAQocXP2T2y55I8Ll5Kg3nOQzFC2bQjGX8j+0rlPGpoaEBNTU361dTUpKV5u3fvxrXXXotf//rXKCrKjvj/9NNP0dPTg9ra2ozttbW1aGlpEToXzSeQ4DCSCQfd0DH1lwgvvkzvVbVG+CFQVM9RCqBHR0P8hbKvEmFh3759qK7uG21KS0uV6+zp6cHll1+OG2+8ESeffLJyfW6QGJFERJAYkDAJHzTF14KqsPBY/JAAIIhsqqurM8SIDg4fPoyXX34Zr776KhYtWgQA6O3tRSKRQFFREZ599lmce+65KCwsxP79+zOO3b9/P+rq6oTOR24aBUSXYmg1vQgiEKxiIRcsJ0QSmk5L+Eh1dTVee+017Nq1K/363ve+h1NOOQW7du3CpEmTUFJSgjPPPBObN29OH9fb24vNmzczg12doGdCRXgtJFZyNVmanZAy1lY9DH6Fm2vXThAs8sZaI7PQHaFGG/punjIILnnU1taGd955J/15z5492LVrF44++mgMGzYMS5cuxYcffohHHnkEBQUFGDNmTMbxgwYNQllZWcb2xsZGzJ07FxMmTMDEiROxevVqtLe3Y968eUJtIzGiAVlBAoTTjeOX5SZXBRmhAYdgxgSHJSWGKACapUIQIrz88sv48pe/nP7c2NgIAJg7dy7WrVuHjz/+GHv37hWq85JLLsEnn3yCZcuWoaWlBePHj8fGjRuzglrdIDGiCRVBYsASAboG6jC7hoIO9A08biSsboywtotBJ9QD9ggHyEWUF5x33nlIJBK2+9etW+d4/IoVK7BixYqs7YsWLUrHlchCYkQjOgSJlTCLCJ2QlSTkiM7qCUjIxFMWE4IgcgsSI5rxQpD0J4K2khAc+JRjRCX7qhHH4Wc8B48QisUc2tMWUWsAWS9yj3aoxYzEdTUkeGg2DScisV0UB0Zowc4awRrUebc57ZcRGRU2f/PC4V3RkfDMGmPipUjx1WVkJ0DM2803pHYP20IQCpAYEYRXaJAgyX88T3immyDayzonK3iVK2hVv4AwREpXSkCELjA2j5aIJwgnSIxIwBvHQYJEjv4SJwMgvEGi5naV2WznOVaQBIcGiPkYF6IigPxsZ05AbiTCAYoZkYRiG/KHUGZg9TsNvNcuGtZ+B28GT7yIYb3wwy2iW1jEDodAqOi0utCTlxztUFsKIY8sZ2QZUYDnCZ7+R/MTXhdNsW7Lh0xsCKtMWC0yFkTiRYwAUi/jQULhvvEj7oNiSwifITHiA4dBokSUfuWqCRu6hIrGeBEZcjYzKrkziH4IiRFFRAZNEiSEL+h00djFi/D8rREdsRs6rRoi7XE6b297jgomgtBMGL3lOYdI/IghSCgXCWE7cKvGi8ie18/zSYZ56Ijd6MtBkjmTRqUugpCiDcARheMpZoRQhawk7oTVVZPz8SK6ynpUj0jwqk5UhI7nmV/JdUPkOSRGNCEzcFIsSfCEciaNn/hpJRGMF+EJXjVm0ugUA14Fqfar7KsUAEsIQmJEI7JP8iRICG3oFBc5GC+i020iU1coFuyTESY5dRPqDroBhAf09+fC0EBr2rDJ1Xwu0i4a1RTwbmWcjvFCTHDGi/AkOxNBrygRt7poyUviFg8QNmsIIU4b1LRVp66GBA9ZRjSjEueQUw8nPuGlEAnURePXwO93G+zqZbloGMQd4kVkZsXonEmjy33ja8KzsN9U8mihN0INEiOc+BW0HPZ7R38nNOvReJ3ozA8XjaZ4ERGsM2lk0DWtl4mX1g7ZOA5rm8giQ3gAiREPUJ0FQoLEe7y0iri6aESn9HqxHowfGVl5XTQO5+YZ+FUyr1oXyBNB1RUUaI6RPJoSSuQHoRYjTU1NOOuss1BVVYVBgwZh1qxZeOuttwJtk58Wkv4+2yZssSKhsYrwoNJWFauIR1lXRcSCivUjnj5WPA29Z5AlgugHhFqMPPfcc1i4cCFeeuklbNq0Cd3d3Zg2bRra24OdN8bj5tSZI6O/ixLdyFhFtAkR0YdhnsBVVctJGOJXTDi5aGTiNlRiPUQEjZPbyHFab9igabn+EUOyv2VfMf+b7BWhnk2zcePGjM/r1q3DoEGDsHPnTnzxi18MqFX86J4JQtlbw4/2WTQyyLqJVNvhdl6NLhqZ/CI6LCZ85xGsn5VjRMQEG7TlhOdJSaSNjhlJaVpvvhJqMWLl0KFDAICjjz7atkxnZyc6O/vmO7W2Jm0U3d3d6O5W+CFHoxnvcfDdt3vlz2jLIYRPkPSm+sV4V6UKaitrO3FE4lffzTtI25TrLo1mvGfBeqi2G/+KXT5br8864Bc6nKPAZl8Fx/aE6W/jh19p+tv4Qiv6/k6kBp7DpcmKjhyJ4kh3JFU82ZkxU6f2pjrKeE+gJFWGNWsm2RGR9Hth6hKT710oSV9uYeqvQkRSR0ZMNfR1cQxRFKcutCT13pu+wN5Uu/t+uYnU34kjyQuNHY4imhpte3tS96NekxjpTR/YR+rvaGogjqI7+VRsHGbWMu3I/A4Lbf42/0bakPkbsv6eSlw+s3671n9ekZTnkmIkGk0eqHSf13A8IUckkUgk3IsFT29vL77yla/g4MGDeOGFF2zLrVixAjfeeGPW9vXr16O8PIdMpQRBEITvxGIxXH755Th06BCqq72JXGttbUVNTQ3wrUNAicI5ulqBB2s8batf5IwYufLKK/H000/jhRdewNChQ23LsSwjDQ0N+PTTT5W+rP9bV4fC5mb0zJ8PxPuiRngemL20YoTFQtIbjWJfczMa5s9HQVw9eYBX11UlYRWp5NSwTi6a7tIoNjU1Y+pP56O409I/dj8i1nmt26znZB1jZ9Wwli2z2cdjFWHVaw5cNT9Np44zJzo7XFqBF7b8EmdO/QGKijsy3C+GZaQjVbE5NqMjbT3JtIxYj8ksYyyQV5LxOc6wrljrsZ6nw9RpnemZOdnnjsdTM35SOUZ6YyYLWXvKtGF2ZZiTWaW2R9u70VyxCfPbpyLeXpy1P1lX9nHMfYz6meVYn3mm+lpjGezcNCx3lLRl5CCam3dg6tSpKC62mnf4aW1txcCBA/0RI7M1iJFH80OM5ISbZtGiRXjyySfx/PPPOwoRACgtLUVpabbdsLi4WOkHmhYg8XiGGOFZUaIN3s0MaUd4BAkAFMTjymLEy3+pIolffDFnmHdxocPO1LhU3BnPFiOsH1EFgC7GNuu92PrZeiOvsGwzm8/NPsQyy2eGm8AR8zUUWN6BPheBScAkUt9FrKIARUeShYuKO1BUHE+7S2KIojA1chak3SxJ4ogigi7EUI5IuiOM96JU01PuEZQD6EmJiWQn9KbdKsZ78kKPpN5Zrp/uVLu6Uu+dpos0/u5MtbMj9R6LlafvtPHUD7C30HQvKohk95fRn23I+n3EUYx4wnQ8yz0GZH7XVkFh/k24/abMv0OWqGBlAbWKDLsYGNatQnoV22Tfqt7rlcYJQppQz6ZJJBJYtGgRnnjiCfzlL3/BiBEjgm5SFrzDrpcr0NJMGz4CnUVjh86AUZXAVdFyIlN7BQNXWfAEkIpMx+3SvIZMKNak4cXr/AS8s3Eo+yphItSWkYULF2L9+vX405/+hKqqKrS0tAAAampqENUUKOknXq6zQmvbBIvjLJqg0rTraJNsllWF3CI8s2icjxeZYSM+G0e2PmYaeNWZNF4T9Ewdot8QasvImjVrcOjQIZx33nkYPHhw+vX4448H3bQMRAS+lxaSfCC3vZ6CiFhFvMyYqss6I9GmGMdaNCx4pvSKJDATKStSn+e02fydl+ThLJc2ZGa4FH1Jfuf33nsvhg8fjrKyMkyaNAnbt2+3Ldvd3Y2VK1fihBNOQFlZGcaNG5eVdmPFihWIRCIZr5EjRwq1KdSWkRyJrRXGKwsJ5SGxx0sXTSisIm5ihVc06FiHxmwV4XTRxEvkEp2JuGZ0W0xkM68y08CLDCpeJiUTrTs0PuLQNCT0PP7442hsbMTatWsxadIkrF69GtOnT8dbb72FQYMGZZW//vrr8etf/xoPPPAARo4ciWeeeQZf/epX8eKLL+L0009Plxs9ejT+/Oc/pz8XCQbohdoykkuIuj8phiSbfmUVEcHLuBW/rCKM/SyriNMA75jhVCChmch6NDwWDl8yr4o+AfPeBPy4WWhLeEbo4M4778SCBQswb948jBo1CmvXrkV5eTmam5uZ5X/1q1/huuuuw4UXXojjjz8eV155JS688EL87Gc/yyhXVFSEurq69GvgwIFC7SIxkqfkqiDJNaStIiwRIBtgGiariBleqwgj/bsuFw0PuoJjtWRezdgvVp0tlN4972ltbc14mdNbmOnq6sLOnTsxZcqU9LaCggJMmTIFW7duZR7T2dmJsrLMG1Y0Gs3K97V7927U19fj+OOPx+zZs7F3716hayAxEiBex4/kkiDx0ioSyCwaXSnXc80qwhm46hQrYkbVRSNiMeEpKxsvwgxeZRGm4FUZPBM+eRgvAqitS2O8ADQ0NKCmpib9ampqYp7u008/RU9PD2prazO219bWpieIWJk+fTruvPNO7N69G729vdi0aRP++Mc/4uOPP06XmTRpEtatW4eNGzdizZo12LNnD77whS/g8GH+USjUMSO5RhwQ9iJ7OcMGyI04klx1z0ivQ8Oin1pFWLDEgNNaNDIuGh6chJDWeBFZZIJXVcSOzgBZrdN6c+mxyxv27duXkfSMlWtLlrvuugsLFizAyJEjEYlEcMIJJ2DevHkZbp0ZM2ak/x47diwmTZqE4447Dr/97W/xrW99i+s8ZBkh8pp+bRXxY0E8CauIGdkVep0sFHxuF9ZaNuLn0hIvEtZZMGFtF5FFdXV1xstOjAwcOBCFhYXYv39/xvb9+/ejrq6Oecyxxx6LDRs2oL29He+//z7+8Y9/oLKyEscff7xte4466iicfPLJeOedd7ivgcSIZmQEvx/TfenZQS9arSIsWPWLWkVkzuWDVcSLwFXRfTJlnc/lYd4jv4JXc3YmDcFLSUkJzjzzTGzevDm9rbe3F5s3b8bkyZMdjy0rK8OQIUNw5MgR/OEPf8DFF19sW7atrQ3vvvsuBg8ezN02ctMQeUsoM66y8OKcTkIlxFaRGMrS6d+zyjvGcrjv43HReDGlVyrZWb5YJbTMpHGKF8lxRdQOtVFYYvZRY2Mj5s6diwkTJmDixIlYvXo12tvbMW/ePADAnDlzMGTIkHTcybZt2/Dhhx9i/Pjx+PDDD7FixQr09vbi6quvTtf54x//GDNnzsRxxx2Hjz76CMuXL0dhYSEuu+wy7naRGOGkFcAAj+v3OnaCsrTqQWoGjap7JoetImZYVhGWxcEPF40TsknLfEt2xgvNpCEsXHLJJfjkk0+wbNkytLS0YPz48di4cWM6qHXv3r0oKOj7P+3o6MD111+Pf/7zn6isrMSFF16IX/3qVzjqqKPSZT744ANcdtll+Oyzz3Dsscfi3HPPxUsvvYRjjz2Wu10kRjxAJpAV8EeQhI0wXS+PVUS7eyaXrCJ2dbKsIiZ4p/Oy8NJF43e8iNbgVTO5ZkWhNWkCZ9GiRVi0aBFz35YtWzI+f+lLX8Kbb77pWN9jjz2m3CaKGREk19O557hRkxsZF00oCLNVROQ8nNN5ea0iqi4aJwKNF5HNvCojQLyeSUNWGEKBXL1lhx6yjuQWWqwioi4a0dVxeQjSKqKU5Cy7cSzLg6yLhifrqhdBqNz5RcyorDejK3g116wtuUo7gEKF43t0NSR4yDJC5B15ZRVxKyObATYEVhEWHZxWER4XjXMWVzlR42Sh4Y4XCftKvTzoNrH2x+BVIgMSIxJ47arpL5lZw2IBylmriIgwMbdDJU5Fo1VENB6DVZ4nX4jTLBrZuJPQxIs4EbTbhKwrhAAkRjyE4rT8R9QqEkjQKgtVcSIbRxICq4joOjSyAkLWRROKeBG74/zIvKoTuikSNuSqQTvv8SNNfJDTfMNiFdGCqlWEJ2hVdL9dO2RFhrW8hFXEjEhCMrvysuLCLxcNd36RjP0Of7scKm3ydIsXCSx4tR+4aNqgZhLo1dWQ4CHLiCR+zKrJ9Zk7fpOzVhErouJEx+waWauIWYhIJTmzX4eGhWhOEr9dNFL4bbVQHcd9ixch+hMkRjxG1SrppSDJk2eLYBEd+GVCB1SCVnmsIqIuIoG8IrzTeXkDV53wwp0iWid3vIjX8RRBx4sQhCAkRoi8wAuriCs6FqJTtWp4mYQtJFYR0cBVUReNFyng+z0ssSX0ZNYPXDREBiRGFOC1WpB1JFzwCpFAXDRW/LSK2NXtsVWEN8mZqFtF1EXDMzWXJZZ8iRdxK+/0j+zkBgptvAjR36AAVp+QTYJmQMnQ7Akkr4ioVYQ1znlpFVFNcBaAVYSFjsBV8fI+TsMNyywXXkIdL5KDj1btoADWFGQZIXwnF0RVzltF7Pap/B0yq4ho4KroLBrP4kW8xslSkYPjdSY5fwGEDSRGFBFxoYTVXZPL/945ESsiM3VXBV1p3+0ImVVExzRhJ4QDad1SwLu5PnI9WZin8SJEvkJihCB0oSICRBfD4w00DbFVxIyO6bJeu2h440WYiMSL2G23+1tXvIgMoYkXoUQIuQ7FjPhMWGNHgk6CJoNXsSKOLhodcR1kFUnuZ07xLUMEXZZjwuWiYSHloglbvIhb8Grg8SK5bMO1oR3uyeycSOhqSPCQZUQDpMlzAy0uGjvIKgJAn1VEh4tGvDxv/EqIp/mGMV6EUsATHJAYCYD+HDsSVPBqINN5WXV5Gc8YcqtIxn7OjuC1iogKBNHySlN6zYjEi9j9zesaCcLyohzvYhcv4nR3osfBfIDEiCbo36Ef4IVlpR9ZRXQkOXMrF4SLxhXZeBEevFqPRqYOESgFPGGBYkYCgmJH1Agkt4gdvDNo/G6DTjy2inRovgA/XTShiRfR6aLRFS/iuYsmxx8D46CYkRRkGQmQ/uyu8RMtLho/rCJu+3PMKmJGdEG85DHhddFIketTdt0IxEVD5AskRjSS4xqdkIH3gZ7H8i8reOzSvutC0ioik3Kdd3pu0C4abSngM8py/G1GdkqvDshFQ2iGxEjAhNU6Ema8cNF4HriqWodMnR5aRczIWEXMqGRcVREvzufy0EVjRpe1REQc6FiPxjcocLW/ECbPe16QL2vI5ErsiBs8LhpXIWK3X3ZlXtY2EbFhLuu1VcTmvAmXc7mJCV7Xh26rSCim5fo9y0XVy8FzPGVdlaMn6AaEB7KMhACyjuQRYbSK8JSxs4q4aAazVUQm9bvo6ry64HXRaFulV8eUXl76hYuG7nr5BokRD6B/E+/Q7aLJG6sI7zGyYknRKmKGPZ3XTbSEz0WjjKjQMIsAr6b0BuKiocBVgsQIN17/j5J1JA8QtUbw7OcVD17MoNFoFeFdndfu+L5t4XHR5MSUXlV0umjIKkI4QDEjISJsuUdyPW5EOf27F1YRmTKssl7nFbE5rxdWETNJEdHN2GY9j7xVxBcXjRmRJxndTz26jQu+LYwn0/BctKR0Qy1eJn9ibcgyIgjvvUJWu5OFxJ5QJTqzEmSsiKgbxgeriBn36bzq69DoQpuLRnZKr9123huPiOUlFLNmRAfTfL7D+ce9996L4cOHo6ysDJMmTcL27dtty65btw6RSCTjVVaW+TSUSCSwbNkyDB48GNFoFFOmTMHu3buF2kRixEPy4d8mF581cgZZq4jMMRrEkptVxIxbkjM3F01fOWcBouKiURE3yi4aFSEgs04NT1mZrKueuGjoruMljz/+OBobG7F8+XK88sorGDduHKZPn44DBw7YHlNdXY2PP/44/Xr//fcz9t922224++67sXbtWmzbtg0VFRWYPn06Ojr41TGJEQm8/lfJZ+tImNomlXFVp4tG9ngvXDR2VhHPk5yJC4K8ddHoJvQuGp1WkTDdWfyntbU149XZ2Wlb9s4778SCBQswb948jBo1CmvXrkV5eTmam5ttj4lEIqirq0u/amtr0/sSiQRWr16N66+/HhdffDHGjh2LRx55BB999BE2bNjAfQ0kRjwmH9w19JzighcuGpnjVP52QTX1uxm/A1d9x8usq06ouGh0iSZPA1fzkcMaXkBDQwNqamrSr6amJubZurq6sHPnTkyZMiW9raCgAFOmTMHWrVttW9nW1objjjsODQ0NuPjii/HGG2+k9+3ZswctLS0ZddbU1GDSpEmOdVoJsxc+1IgEd8oGloYtoDWXUA5e1Y2u6bx+IuSWUQ9cLWFs0wG/1SSkWVd1CAVRq4asi0YZuxOTVcSJffv2obq6725fWsr+f/v000/R09OTYdkAgNraWvzjH/9gHnPKKaegubkZY8eOxaFDh3DHHXfg7LPPxhtvvIGhQ4eipaUlXYe1TmMfDyRGfCLXBUmuz6wRIldcNKLnyYnA1TI4PUqHyUXjinmwDvsqvSrnkiJ/ZoGEgerq6gwxopPJkydj8uTJ6c9nn302Tj31VNx333346U9/qu085KZRQPT/PSiXDZGNtrVovMgtIlq/tVzIAlfN8AauZtYZTheNa7yICLnmovE1cJWsIroYOHAgCgsLsX///ozt+/fvR11dHVcdxcXFOP300/HOO+8AQPo4lToBEiO+E4Qg0fXvquthq9/fPnSszqsLjwJXzbi5aFQWxXPDDxdNBm7xIqKiI6wuGiXIKtLHYSTviLIvsS+rpKQEZ555JjZv3pze1tvbi82bN2dYP5zo6enBa6+9hsGDBwMARowYgbq6uow6W1tbsW3bNu46AXLTKOOn+0LFZdOf3DWexIuEwUVjV87DwFUzIoGrbhlXdeUM0e2ikcG3rKu8U3rD4qIhq0goaWxsxNy5czFhwgRMnDgRq1evRnt7O+bNmwcAmDNnDoYMGZIOgl25ciX+5V/+BSeeeCIOHjyI22+/He+//z6+/e1vA0jOtFmyZAlWrVqFk046CSNGjMANN9yA+vp6zJo1i7tdJEY0IDpABxVY2p8DWs1ITemVLWstU47Mm7SutqhiYxXxOuOq2/F+u2gCn9KbTy4aJmQVCZpLLrkEn3zyCZYtW4aWlhaMHz8eGzduTAeg7t27FwUFfQ8en3/+ORYsWICWlhYMGDAAZ555Jl588UWMGjUqXebqq69Ge3s7vvOd7+DgwYM499xzsXHjxqzkaE6QGNGEX4IkDAGtuWAdyUm8Cly1O0elbaksvA5cdTs+DC4aV3RM6bUrI4uqi8a39O8syCriFYsWLcKiRYuY+7Zs2ZLx+ec//zl+/vOfO9YXiUSwcuVKrFy5UrpNFDMSILmcg6Rf5R6RddHoEg285TS7ZfwMXI0xOtndauKviybQrKvmfzhdLhrfA1d1rc5LQiQfIcuIRmQsBv3VQkIuIwSXP8SKQOCqGa9dNCxYLhpdeDKl12t0rkUTqicMGcERqgvg5DCAhMLxoVhgSAtkGdGMzL+DioUk6Fk2Kv/+oudv5QyIOxyoadkDvJ5FI4DXLpoOicHfj7VoMurxY0pvEC4amePJKkJogsSIB/gpSIDcFiQ5i26rhlcr9Mqcw4LbLBqv4U10JkNop/Sa4f0HC8JF4wn9xSpCmCEx4hGygiRX85DI3groOUcTOR0voseKkbdTenXUL+qi0WoV4T2pG3S3yGcoZoQTmcFWNqYiiDgS49+cphz3YyheJANf40V0Wx10uyqV2icynbe/WUXaoBYzkj8+abKMCCL6s+9bV1GMXI0j8fq2wBs3QnDi3fjuC6GIF/FySq8fLhpd/7SBWEVyWYgQZkiM+ER/ctv4HTOTkwSZ7CykwavsYzQGi1rQFi/ihi6rh/khWKeLxuk8dniS5MzuLtDv7g79EhIjEsj+a/gdVxF0HEkunLPf4EMKeBYy8SKubepPKeBlELHc89yUtAeu6rJmkFUkn8gJMXLvvfdi+PDhKCsrw6RJk7B9+/agm0SCxAUvbxP9ylVjl3k1JKv0egFvCnhdBJICXueUXp2zaHyZzsuiv1pF/F0oL8yEXow8/vjjaGxsxPLly/HKK69g3LhxmD59Og4cOBB005QEiZ9uG5U4krAKktDhNoD7u7p9Et3r7KTwIng1F/KLMJGNF+GBN+uqznPqPj4LsooQbEIvRu68804sWLAA8+bNw6hRo7B27VqUl5ejubk56KYBUIvryBUriZ/PJrrOlVOJz4KyRGg0NlC8iA1e5ObodNin20XDA1lFCA2EempvV1cXdu7ciaVLl6a3FRQUYMqUKdi6dSvzmM7OTnR29v23trYmf9Dd3d3o7pZfMbIgGs14t9IGuWm8bZCLJ1SZ/iuT0PMQnK8vkeqXRDSKXoHjWPRwlPkcQJXLr7fb7kKdOoA1QLO2lVg+FzPKmLZ1F0Uz3jP+8wotxxXY/B2x+dsO84zBXsbf5o42/Z0wDS5HjiQbEC8pT48vPaYO7El1Tq+pk8x/J1IdlcjooOTf5vVoIt1F6fdIqkMKTB1TkOqIOKLprYWpToijPN2dxnsHytNnLE51RBzlKEn93cvokB5TJyRSfyeO9HWG8XdvLIp0Z/SavgijSrNYsJu1aRzWhszv0vx9F2b+HS1MnjNaZLqPtQGMru3D/Dtts3y2/q5jyP7fsAqNDmTnD+AWI3bKzO4/vtdmO1tFRaPJzla5z+s4npAjkkgkVCY5e8pHH32EIUOG4MUXX8TkyZPT26+++mo899xz2LZtW9YxK1aswI033pi1ff369SgvD8JWThAEQeQKsVgMl19+OQ4dOoTqam8yILW2tqKmpgbAr6Dmw40B+E9P2+oXobaMyLB06VI0NjamP7e2tqKhoQHTpk1T+rK6u7uxadMmTJ06FcXFrMfg/g31jzPUP85Q/7hDfeSMrv4xrOmEv4RajAwcOBCFhYXYv39/xvb9+/ejrq6OeUxpaSlKS7Pt6sXFxVr+gXXVk69Q/zhD/eMM9Y871EfOqPYP9W0whDqAtaSkBGeeeSY2b96c3tbb24vNmzdnuG0IgiAIgshdQm0ZAYDGxkbMnTsXEyZMwMSJE7F69Wq0t7dj3rx5QTeNIAiCIBQ4DME8+hZUMkmFi9CLkUsuuQSffPIJli1bhpaWFowfPx4bN25EbW1t0E0jCIIgCEIDoRcjALBo0SIsWrQo6GYQBEEQBOEBoY4ZIQiCIAgi/8kJywhBEARB5B8UM2JAlhGCIAiCIAKFxAhBEARBEIFCYoQgCIIgiEAhMUIQBEEQRKCQGCEIgiCIQDiM5Brssi/2CsZu3HvvvRg+fDjKysowadIkbN++3bH87373O4wcORJlZWU47bTT8NRTT2Xsv+KKKxCJRDJeF1xwgVCbSIwQBEEQRD/h8ccfR2NjI5YvX45XXnkF48aNw/Tp03HgwAFm+RdffBGXXXYZvvWtb+HVV1/FrFmzMGvWLLz++usZ5S644AJ8/PHH6ddvfvMboXaRGCEIgiCIfsKdd96JBQsWYN68eRg1ahTWrl2L8vJyNDc3M8vfdddduOCCC3DVVVfh1FNPxU9/+lOcccYZuOeeezLKlZaWoq6uLv0aMGCAULvyPs9IIpEAoL4sdHd3N2KxGFpbW2lVRwbUP85Q/zhD/eMO9ZEzuvrHGCuMscNbOrUcbx3f7Fav7+rqws6dO7F06dL0toKCAkyZMgVbt25lnmHr1q1obGzM2DZ9+nRs2LAhY9uWLVswaNAgDBgwAP/6r/+KVatW4ZhjjuG+krwXI4cPJ31qDQ0NAbeEIAiCyBUOHz6MmpoaT+ouKSlBXV0dWlpuV66rsrIya3xbvnw5VqxYkVX2008/RU9PT9babrW1tfjHP/7BrL+lpYVZvqWlJf35ggsuwNe+9jWMGDEC7777Lq677jrMmDEDW7duRWFhIdd15L0Yqa+vx759+1BVVYVIJCJdT2trKxoaGrBv3z5UV1drbGF+QP3jDPWPM9Q/7lAfOaOrfxKJBA4fPoz6+nqNrcukrKwMe/bsQVdXl3JdiUQia2xjWUW85NJLL03/fdppp2Hs2LE44YQTsGXLFpx//vlcdeS9GCkoKMDQoUO11VddXU03Ageof5yh/nGG+scd6iNndPSPVxYRM2VlZSgrK/P8PGYGDhyIwsJC7N+/P2P7/v37UVdXxzymrq5OqDwAHH/88Rg4cCDeeecdbjFCAawEQRAE0Q8oKSnBmWeeic2bN6e39fb2YvPmzZg8eTLzmMmTJ2eUB4BNmzbZlgeADz74AJ999hkGDx7M3TYSIwRBEATRT2hsbMQDDzyAhx9+GH//+99x5ZVXor29HfPmzQMAzJkzJyPAdfHixdi4cSN+9rOf4R//+AdWrFiBl19+GYsWLQIAtLW14aqrrsJLL72E9957D5s3b8bFF1+ME088EdOnT+duV967aXRRWlqK5cuX++6LyxWof5yh/nGG+scd6iNnqH/4uOSSS/DJJ59g2bJlaGlpwfjx47Fx48Z0kOrevXtRUNBnpzj77LOxfv16XH/99bjuuutw0kknYcOGDRgzZgwAoLCwEP/zP/+Dhx9+GAcPHkR9fT2mTZuGn/70p0LfRSThz/wlgiAIgiAIJuSmIQiCIAgiUEiMEARBEAQRKCRGCIIgCIIIFBIjBEEQBEEECokRDkSXW+5PNDU14ayzzkJVVRUGDRqEWbNm4a233gq6WaHllltuQSQSwZIlS4JuSmj48MMP8c1vfhPHHHMMotEoTjvtNLz88stBNysU9PT04IYbbsCIESMQjUZxwgkn4Kc//alP66aEj+effx4zZ85EfX09IpFI1vooiUQCy5Ytw+DBgxGNRjFlyhTs3r07mMYSQpAYcUF0ueX+xnPPPYeFCxfipZdewqZNm9Dd3Y1p06ahvb096KaFjh07duC+++7D2LFjg25KaPj8889xzjnnoLi4GE8//TTefPNN/OxnPxNe8TNfufXWW7FmzRrcc889+Pvf/45bb70Vt912G37xi18E3bRAaG9vx7hx43Dvvfcy99922224++67sXbtWmzbtg0VFRWYPn06Ojo6fG4pIUyCcGTixImJhQsXpj/39PQk6uvrE01NTQG2KrwcOHAgASDx3HPPBd2UUHH48OHESSedlNi0aVPiS1/6UmLx4sVBNykUXHPNNYlzzz036GaElosuuigxf/78jG1f+9rXErNnzw6oReEBQOKJJ55If+7t7U3U1dUlbr/99vS2gwcPJkpLSxO/+c1vAmghIQJZRhwwllueMmVKepvbcsv9nUOHDgEAjj766IBbEi4WLlyIiy66KOO3RAD/9V//hQkTJuAb3/gGBg0ahNNPPx0PPPBA0M0KDWeffTY2b96Mt99+GwDwt7/9DS+88AJmzJgRcMvCx549e9DS0pLxP1ZTU4NJkybR/ToHoAysDsgst9yf6e3txZIlS3DOOeeks/MRwGOPPYZXXnkFO3bsCLopoeOf//wn1qxZg8bGRlx33XXYsWMHfvjDH6KkpARz584NunmBc+2116K1tRUjR45EYWEhenp6cNNNN2H27NlBNy10GEvauy13T4QTEiOENhYuXIjXX38dL7zwQtBNCQ379u3D4sWLsWnTJt9X6MwFent7MWHCBNx8880AgNNPPx2vv/461q5dS2IEwG9/+1s8+uijWL9+PUaPHo1du3ZhyZIlqK+vp/4h8gpy0zggs9xyf2XRokV48skn8de//hVDhw4NujmhYefOnThw4ADOOOMMFBUVoaioCM899xzuvvtuFBUVoaenJ+gmBsrgwYMxatSojG2nnnoq9u7dG1CLwsVVV12Fa6+9FpdeeilOO+00/Od//id+9KMfoampKeimhQ7jnkz369yExIgDMsst9zcSiQQWLVqEJ554An/5y18wYsSIoJsUKs4//3y89tpr2LVrV/o1YcIEzJ49G7t27UJhYWHQTQyUc845J2sq+Ntvv43jjjsuoBaFi1gslrFoGZBcmKy3tzegFoWXESNGoK6uLuN+3draim3bttH9OgcgN40LjY2NmDt3LiZMmICJEydi9erVGcst93cWLlyI9evX409/+hOqqqrSvtmamhpEo9GAWxc8VVVVWfEzFRUVOOaYYyiuBsCPfvQjnH322bj55pvxH//xH9i+fTvuv/9+3H///UE3LRTMnDkTN910E4YNG4bRo0fj1VdfxZ133on58+cH3bRAaGtrwzvvvJP+vGfPHuzatQtHH300hg0bhiVLlmDVqlU46aSTMGLECNxwww2or6/HrFmzgms0wUfQ03lygV/84heJYcOGJUpKShITJ05MvPTSS0E3KTQAYL4eeuihoJsWWmhqbyb/9//+38SYMWMSpaWliZEjRybuv//+oJsUGlpbWxOLFy9ODBs2LFFWVpY4/vjjEz/5yU8SnZ2dQTctEP76178y7zdz585NJBLJ6b033HBDora2NlFaWpo4//zzE2+99VawjSa4iCQS/TSVH0EQBEEQoYBiRgiCIAiCCBQSIwRBEARBBAqJEYIgCIIgAoXECEEQBEEQgUJihCAIgiCIQCExQhAEQRBEoJAYIQiCIAgiUEiMEARBEAQRKCRGCIIgCIIIFBIjBEEAAD7++GNcfvnlOPnkk1FQUIAlS5YE3SSCIPoJJEYIggAAdHZ24thjj8X111+PcePGBd0cgiD6ESRGCCKP+OSTT1BXV4ebb745ve3FF19ESUlJxtLqLIYPH4677roLc+bMQU1NjddNJQiCSFMUdAMIgtDHsccei+bmZsyaNQvTpk3DKaecgv/8z//EokWLcP755wfdPIIgCCYkRggiz7jwwguxYMECzJ49GxMmTEBFRQWampqCbhZBEIQt5KYhiDzkjjvuwJEjR/C73/0Ojz76KEpLS4NuEkEQhC0kRggiD3n33Xfx0Ucfobe3F++9917QzSEIgnCE3DQEkWd0dXXhm9/8Ji655BKccsop+Pa3v43XXnsNgwYNCrppBEEQTEiMEESe8ZOf/ASHDh3C3XffjcrKSjz11FOYP38+nnzySddjd+3aBQBoa2vDJ598gl27dqGkpASjRo3yuNUEQfRnIolEIhF0IwiC0MOWLVswdepU/PWvf8W5554LAHjvvfcwbtw43HLLLbjyyisdj49EIlnbjjvuOHL1EAThKSRGCIIgCIIIFApgJQiCIAgiUEiMEEQ/YfTo0aisrGS+Hn300aCbRxBEP4bcNATRT3j//ffR3d3N3FdbW4uqqiqfW0QQBJGExAhBEARBEIFCbhqCIAiCIAKFxAhBEARBEIFCYoQgCIIgiEAhMUIQBEEQRKCQGCEIgiAIIlBIjBAEQRAEESgkRgiCIAiCCJT/D8LHHOHcxXxGAAAAAElFTkSuQmCC", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -392,14 +363,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -424,14 +393,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -446,27 +413,7 @@ "cell_type": "code", "execution_count": 13, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "MovieWriter ffmpeg unavailable; using Pillow instead.\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "anim_sampler = tp.samplers.AnimationSampler(domain_x, domain_t, 200, n_points=760)\n", "#fig, anim = tp.utils.animate(model_u, lambda u: u, anim_sampler, ani_speed=10, ani_type='contour_surface')\n", @@ -493,7 +440,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.4" + "version": "3.11.7" }, "orig_nbformat": 4 }, diff --git a/examples/pinn/inverse-heat-equation.ipynb b/examples/pinn/inverse-heat-equation.ipynb index 3259d00c..3b00fca9 100644 --- a/examples/pinn/inverse-heat-equation.ipynb +++ b/examples/pinn/inverse-heat-equation.ipynb @@ -15,12 +15,11 @@ "metadata": {}, "outputs": [], "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\" # select GPUs to use\n", "import torch\n", "import torchphysics as tp\n", - "import math\n", - "\n", - "import os\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\" # select GPUs to use" + "import math" ] }, { @@ -251,11 +250,12 @@ "\n", "import pytorch_lightning as pl\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=5000,\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=5000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", " \n", "trainer.fit(solver)" ] @@ -339,7 +339,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.4" + "version": "3.9.15" }, "orig_nbformat": 4 }, diff --git a/examples/pinn/moving-heat-equation.ipynb b/examples/pinn/moving-heat-equation.ipynb index 4c5e372f..df3a5af2 100644 --- a/examples/pinn/moving-heat-equation.ipynb +++ b/examples/pinn/moving-heat-equation.ipynb @@ -313,11 +313,12 @@ "import os\n", "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n", "\n", - "trainer = pl.Trainer(gpus=1, # or None for CPU\n", - " max_steps=5000,\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=5000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "trainer.fit(solver)" ] }, @@ -397,11 +398,12 @@ "solver = tp.solver.Solver([source_condition, pde_condition, initial_condition, dirichlet_condition],\n", " optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=3000, \n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=3000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", " \n", "trainer.fit(solver)" ] @@ -489,7 +491,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.4" + "version": "3.9.15" }, "orig_nbformat": 4 }, diff --git a/examples/pinn/periodic-boundary-problem.ipynb b/examples/pinn/periodic-boundary-problem.ipynb index a27c1649..f4e0f7b5 100644 --- a/examples/pinn/periodic-boundary-problem.ipynb +++ b/examples/pinn/periodic-boundary-problem.ipynb @@ -209,11 +209,12 @@ "\n", "solver = tp.solver.Solver([pde_cond, bound_cond, dirichlet_cond], optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=5000,\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=5000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "trainer.fit(solver)" ] }, @@ -344,7 +345,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.4" + "version": "3.9.15" } }, "nbformat": 4, diff --git a/examples/pinn/poisson-equation.ipynb b/examples/pinn/poisson-equation.ipynb index 61906b48..5edc2b01 100644 --- a/examples/pinn/poisson-equation.ipynb +++ b/examples/pinn/poisson-equation.ipynb @@ -249,11 +249,12 @@ "import os\n", "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\" # set GPU\n", "\n", - "trainer = pl.Trainer(gpus=1, # or None for CPU\n", - " max_steps=2000,\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=2000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "trainer.fit(solver)" ] }, @@ -272,7 +273,7761 @@ { "data": { "image/png": "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", - "image/svg+xml": "\n\n\n \n \n \n \n 2021-12-07T12:59:22.261505\n image/svg+xml\n \n \n Matplotlib v3.4.2, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2021-12-07T12:59:22.261505\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.4.2, https://matplotlib.org/\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n" + ], "text/plain": [ "
" ] @@ -284,7 +8039,7751 @@ { "data": { "image/png": "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", - "image/svg+xml": "\n\n\n \n \n \n \n 2021-12-07T12:59:22.750119\n image/svg+xml\n \n \n Matplotlib v3.4.2, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2021-12-07T12:59:22.750119\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.4.2, https://matplotlib.org/\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n" + ], "text/plain": [ "
" ] @@ -297,7 +15796,7761 @@ { "data": { "image/png": "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", - "image/svg+xml": "\n\n\n \n \n \n \n 2021-12-07T12:59:23.205702\n image/svg+xml\n \n \n Matplotlib v3.4.2, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2021-12-07T12:59:23.205702\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.4.2, https://matplotlib.org/\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n" + ], "text/plain": [ "
" ] diff --git a/examples/pinn/poisson-with-input-params.ipynb b/examples/pinn/poisson-with-input-params.ipynb index d85b13f1..608347e6 100644 --- a/examples/pinn/poisson-with-input-params.ipynb +++ b/examples/pinn/poisson-with-input-params.ipynb @@ -328,11 +328,12 @@ "\n", "import pytorch_lightning as pl\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=5000,\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=5000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "trainer.fit(solver)" ] }, diff --git a/examples/pinn/signorini-equation.ipynb b/examples/pinn/signorini-equation.ipynb index 6d333437..c0818315 100644 --- a/examples/pinn/signorini-equation.ipynb +++ b/examples/pinn/signorini-equation.ipynb @@ -304,11 +304,12 @@ "import os\n", "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"2\"\n", "\n", - "trainer = pl.Trainer(gpus=1, # or None for CPU\n", - " max_steps=1500,\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=2500, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "trainer.fit(solver)" ] }, @@ -395,11 +396,12 @@ " neumann_condition, complementary_condition, sign_condition],\n", " optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=2000, # number of training steps\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=2500, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", " \n", "trainer.fit(solver)" ] @@ -456,7 +458,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.4" + "version": "3.9.15" }, "orig_nbformat": 4 }, diff --git a/examples/pinn/singular-boundary-problem.ipynb b/examples/pinn/singular-boundary-problem.ipynb index a1b940b7..1aebf025 100644 --- a/examples/pinn/singular-boundary-problem.ipynb +++ b/examples/pinn/singular-boundary-problem.ipynb @@ -156,7 +156,7 @@ } ], "source": [ - "tp.utils.scatter(X*NU, pde_sampler, bound_sampler)" + "fig = tp.utils.scatter(X*NU, pde_sampler, bound_sampler)" ] }, { @@ -241,11 +241,12 @@ "\n", "solver = tp.solver.Solver([pde_cond, bound_cond], optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=20000,\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=20000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "trainer.fit(solver)" ] }, @@ -320,13 +321,12 @@ "optim = tp.OptimizerSetting(optimizer_class=torch.optim.LBFGS, lr=0.05, \n", " optimizer_args={'max_iter': 10, 'history_size': 100})\n", "\n", - "import pytorch_lightning as pl\n", - "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=8000,\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=8000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "trainer.fit(solver)" ] }, @@ -378,7 +378,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.4" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/examples/solid_mechanics/mechanic_cube_FCN.ipynb b/examples/solid_mechanics/mechanic_cube_FCN.ipynb index 311cbd45..dcd9f162 100644 --- a/examples/solid_mechanics/mechanic_cube_FCN.ipynb +++ b/examples/solid_mechanics/mechanic_cube_FCN.ipynb @@ -16,23 +16,6 @@ "%matplotlib inline" ] }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1\n" - ] - } - ], - "source": [ - "print(torch.cuda.device_count())" - ] - }, { "cell_type": "code", "execution_count": 13, @@ -349,20 +332,13 @@ " tp.utils.WeightSaveCallback(model=model,path='.',name='NN',check_interval = 10, save_initial_model=False,\n", " save_final_model = True)]\n", "\n", - "trainer = pl.Trainer(gpus='-1' if torch.cuda.is_available() else None,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " max_steps=1000,\n", - " #logger=False,\n", - " #callbacks = calls, \n", - " checkpoint_callback=False\n", - " )\n", - "trainer.fit(solver)\n", - "\n", - "#from winsound import Beep\n", - "#frequency = 1000 # Herz\n", - "#duration = 500 # ms\n", - "##Beep( frequency, duration )" + " max_steps=5000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", + "trainer.fit(solver)" ] }, { @@ -504,14 +480,12 @@ " tp.utils.WeightSaveCallback(model=model,path='.',name='NN',check_interval = 10, save_initial_model=False,\n", " save_final_model = True)]\n", "\n", - "trainer = pl.Trainer(gpus='-1' if torch.cuda.is_available() else None,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " max_steps=300,\n", - " #logger=False,\n", - " callbacks = calls, \n", - " checkpoint_callback=False\n", - " )\n", + " max_steps=300, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "trainer.fit(solver)" ] }, @@ -532,7 +506,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -568,7 +542,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -602,7 +576,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -654,7 +628,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAawAAAEGCAYAAAA5T6EkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAAx90lEQVR4nO3deVxV1f7/8deHWUBAQRFBRcRUxBlnLdBMK826TWallWaldZuv1q3uzepe63bzVjY55NBEVpqmZjmWZk44ixUITqg4D6ggw/r9wa6f3xwAGfYZPs/H4zw8Z0/nvTo9zoe1z9prizEGpZRSytF52B1AKaWUKg0tWEoppZyCFiyllFJOQQuWUkopp6AFSymllFPwsjsAQFhYmImOjrY7RpmdOnWKgIAAu2NUKW2z63O39oLztjklJeWQMaaW3TmqikMUrOjoaNauXWt3jDJbunQpiYmJdseoUtpm1+du7QXnbbOI7LQ7Q1XSU4JKKaWcghYspZRSTkELllJKKaegBUsppZRT0IKllFLKKWjBUkop5RS0YCmllHIKDnEdlnI8B07msm3fSQ6ezONkbj4ncwvw8hT278rnxMa91K/pzxXhgfj76P9CSqmqod82CoBDOXksTM1m4bZsNuw+zqGcvItuOy11PQAi0DA0gIToGvRoGk63xmEE+ur/UkqpyqHfLm6ssMiwaFs2U1bsYGXGYYoMRNWoRmKTWsRFBNEsIoi6IX4E+XkT6OdFYZHh20U/0LxNezIOnuKX/SfYuvcE327Zz/S1e/Dx9CCxSS0GdqzPlY1r4eEhdjdRKeVCtGC5oYLCIj5fu5sJP2aw4/BpIkOq8XCPxvRuHk5cRBAiFy403p5Qw8+DK8Krc0V4dfrE1wEgv7CItTuOsnBbNl+vz+L71GyialTjni7R3NmxAdV8PKuyeUopF6UFy80sSzvI6G9SSTuQQ6t6IYzr3YQ+zevg5Xn542+8PT3o3CiUzo1C+VufJny/NZuPVu7k5bnb+ODHDB68qhF3dqyPn7cWLqXU5dOC5SYOnszj7zM3831qNvVr+jP+7nb0igu/aG/qcvl6edKvVV36tarLqozDvLkojZfmpPLh8kye7xtH7+YV/55KKfegBcsNLP4lm6e/2EROXgF/69OEId0a4utV+b2djjGhfBoTyorthxj9TSoPfpxC98ZhvHhDc2JqBVb6+yulXIteh+XCzhYU8Y9ZW7hvylpqVfflm0e6MTwxtkqK1bm6NApjziPd+Ge/ODbsPsa1by7jw+WZFBWZKs2hlHJuWrBc1NFTZ7l70iqm/ryTod0aMuvhrlwRXt22PF6eHtzTtSGLnriKbrFhjJ6Tyh0TVrL7yGnbMimlnIsWLBeUfuAkN777E+t3H+PNAa15rm9clfeqLqZ2kB8TByfw2i0t2br3BNe9uYxvN++zO5ZSyglowXIx63Yd5aZ3V3Aqr4DP7u9E/9aRdkc6j4hwW0I9vn20OzG1A3nok3X8c/ZW8goK7Y6mlHJgWrBcyKqMw9w9cRU1A3yYObwr7RrUsDvSJdWr6c8XD3RmSLeGTFmxg9s+WEn2iVy7YymlHJQWLBexLO0ggyevpk6wH9Mf6Ey9mv52RyoVHy8Pnu8bx/t3tSUt+yT93l7Oul1H7Y6llHJAWrBcwMqMwwyZupbo0AA+f6Az4UF+dkcqsz7xEcwY3gVfbw8GfLCSr1L22B1JKeVgtGA5uS1Zxxk6dS31a/rz6f2dCAv0tTvSZWtaJ4jZI7qREF2DJ7/YyBsLfsMYHfqulCpWqoIlIjtEZLOIbBCRtdaymiKyQETSrH9rWMtFRN4SkXQR2SQibSuzAe4s89Ap7pm8muBq3nw0pAM1A3zsjlRuNQJ8mHJvB25tF8Vbi9J4cvpGHYyhlALK1sNKMsa0NsYkWK9HAYuMMY2BRdZrgGuBxtZjGPBeRYVV/9+hnDwGfbiKIgPThnQgIria3ZEqjI+XB6/d0pKnrrmCGeuzuOfDNZzIzbc7llLKZuU5JdgfmGo9nwrceM7yaabYSiBERCLK8T7qT/IKCnno4xQOnsxj8j3taeSC0xyJCA/3aMzY21uxZscRBnywkgMndQShUu5MSvMbgYhkAkcBA3xgjBkvIseMMSHWegGOGmNCRGQOMMYYs9xatwgYaYxZ+6djDqO4B0Z4eHi75OTkCmxW1cjJySEwsGqLhTGGD7ecZVlWAcNb+dIhomqng7SjzZsPFjBuQx5BPsJTCX6EB1TtT692tNlO7tZecN42JyUlpZxz1svllfbbrpsxJktEagMLROSXc1caY4yIlOnXcWPMeGA8QEJCgklMTCzL7g5h6dKlVHXuScszWZaVyl97xPLENU2q9L3BnjYnAt07HeO+KWv4z/oiPhqSQLOIoCp7fzvabCd3ay+4Z5udUan+VDXGZFn/HgBmAh2A7N9P9Vn/HrA2zwLqnbN7lLVMldPP2w/zytxU+jSvw2NXX2F3nCrVul4I0x/ojLencPsHP5OyU6/VUsrdlFiwRCRARKr//hy4BtgCzAYGW5sNBmZZz2cDg6zRgp2A48YYnSyunA6ezOOvyeuJDgvgv7e1csvbz8fWDuSLBztTM8CHuyauYlnaQbsjKaWqUGl6WOHAchHZCKwG5hpj5gNjgF4ikgZcbb0GmAdkAOnABGB4had2M4VFhkeT13MyN59372xLgK/73sYsqoY/0x/sTINQf4ZMWcuC1Gy7IymlqkiJ33zGmAyg1QWWHwZ6XmC5AUZUSDoFwJuL0lix/TCv3dKSpnWq7rcbR1W7uh/Jwzox+MPVPPhxCmNvb80NreraHUspVcl0pgsHtyrjMG8vTuPmtlHcllCv5B3cRIi/Dx8P7Ui7BjV4NHk909futjuSUqqSacFyYCdy83li+kYa1PRndP/mdsdxONX9vJl6bwe6xYbxty838dHPO+yOpJSqRFqwHNg/Z29l/4lc3ri9tVv/bnUp1Xw8mTg4gaub1eb5WVuZuCzD7khKqUqiBctBzdu8jxnrshiRFEvb+o59Xyu7+Xp58u6d7bi+RQQvz93GuMVpdkdSSlUC/bPdAR08mcezMzfTMiqYR3rE2h3HKfh4efDmgNb4ennw+ve/cSa/kKeuaULxJCxKKVegBcsB/WP2Fk6fLeSN21rh7amd4NLy8vTg9Vtb4evtwTtLtnP6bCEv9I3ToqWUi9CC5WDmb9nHvM37ebp3E2JrV7c7jtPx8BD+dVML/Lw9mfzTDnLzi3j5xng83fBCa6VcjRYsB3L8dD7Pz9pKXEQQw66MsTuO0xIRXugbh7+Pp9XTKuD1W7W3qpSz04LlQF6em8qRU2eZfE97/XItJxHh6d5NCfD14rX5v3L6bCHjBrbB18vT7mhKqcuk34oOYsX2Q3yRsodhV8YQHxlsdxyXMTwxltH9m7MgNZshU9ZyKq/A7khKqcukBcsBnC0o4vmvt1CvZjUe7dnY7jguZ1DnaP57ayt+zjjMwImrOHrqrN2RlFKXQQuWA5i4PIPtB08x+oZ4/Lz1lFVluLldFO/f1Y5t+05w2wc/s/+43r1YKWejBctme46e5q1FafRpXoekprXtjuPSesWFM/XeDuw7nsvN760g/cBJuyMppcpAC5bN/jk7FQ8RXugXZ3cUt9C5USjJwzqRV1DELe//TMrOI3ZHUkqVkhYsGy359QALt2Xz156NqRtSze44biM+MpgZD3Whhr8PAyes4rut++2OpJQqBS1YNjlbUMRLc1KJCQvgvq4N7Y7jduqH+vPlg51pFhHEgx+nMHFZBsW3clNKOSotWDaZ9vMOMg6e4rm+zfDx0o/BDqGBvnx2fyf6NK/Dy3O38fysLRQUFtkdSyl1EfpNaYPDOXm8uSiNq66oRVITHWhhp2o+nrwzsC0PXBXDxyt3ce+UNRw/nW93LKXUBWjBssF/F/zGmbOFPN+3mU7M6gA8PIRnrm3GmL+0YGXGYfq/s5y0bB1BqJSj0YJVxbbtO0Hy6l3c3bmBTm7rYAZ0qM9n93ciJ6+Qm95dwfc6GEMph6IFq4r9+9tfqO7nzWM9r7A7irqAhOiafPNIV2JqBTDsoxT+/e02Cot0MIZSjqDUBUtEPEVkvYjMsV5PEZFMEdlgPVpby0VE3hKRdBHZJCJtKym701mWdpAffzvIIz1iCfb3tjuOuoiI4GpMf6AzAzvW54MfMnh1TS7ZJ3RmDKXsVpYe1qPAtj8te9oY09p6bLCWXQs0th7DgPfKndIFFBYZ/jXvF+rVrMbdnRvYHUeVwM/bk3/d1IL/3d6aHSeKuPbNZSxIzbY7llJurVQFS0SigOuBiaXYvD8wzRRbCYSISEQ5MrqEmeuz2LbvBE/3bqq3uHAiN7aJ5J+dq1EnyI/7p63l2ZmbOX1WZ3xXyg5SmoslReRL4N9AdeApY0xfEZkCdAbygEXAKGNMnnXKcIwxZrm17yJgpDFm7Z+OOYziHhjh4eHtkpOTK65VVSQnJ4fAwMAStztbaBi17AzBvsILnfycemRgadvsSnJycvD1D2BGWj7zM/Op7S/cF+9Lk5qu+YeHu37GztjmpKSkFGNMgt05qkqJN3AUkb7AAWNMiogknrPqGWA/4AOMB0YCo0v7xsaY8dZ+JCQkmMTExEvv4ICWLl1KaXJ/8MN2juT+wruDOtIpJrTyg1Wi0rbZlfze5l49iu9bNvKrTfx79Rnu7tSAkdc2JdDXte6D6s6fsXJspTkl2BW4QUR2AMlADxH52BizzzrtlwdMBjpY22cB9c7ZP8pa5pZO5Obz3g/bueqKWk5frBR0aRTGd49dyb1do/l41U56vfEDczft02mdlKoCJRYsY8wzxpgoY0w0MABYbIy56/ffpaT4/NaNwBZrl9nAIGu0YCfguDFmX6WkdwITfszg2Ol8nu7dxO4oqoL4+3jxj37N+fLBLoT4+zDi03XcPWm13q5EqUpWnuuwPhGRzcBmIAx42Vo+D8gA0oEJwPByJXRiB0/mMWl5Jn1bRuht711QuwY1+Obhrrx4Q3M27jlG7/8t4+8zN3PgpA6BV6oylOnkuzFmKbDUet7jItsYYER5g7mCd5akk1dQxJPXaO/KVXl5ejC4SzTXt4zg7UVpfLJqFzPXZzGkW0OGdGtIiL+P3RGVchk600UlyTp2hk9X7eK2hCgahgXYHUdVsrBAX17sH8/CJ64iqWlt3l6cTrdXl/Cf737hyKmzdsdTyiVowaok4xanAfBIj8Y2J1FVKTosgHcGtmX+Y925qkkt3l26nS5jFvHc15vJOJhjdzylnJprjcd1ELsOn+aLtXu4q1MDvZOwm2paJ4h3BrYl/cBJJvyYyfS1e/h45S6SmtTizo4NSGxSCy9P/XtRqbLQglUJ3l6chqeH8FBiI7ujKJvF1q7Oq7e05KneTfh45U4+Xb2LodPWEhHsx60J9bi5bSQNQvWUsVKloQWrgmUeOsWM9Vnc0yWa8CA/u+MoB1Grui+P97qCh3vEsmhbNp+s2sXbi9N4a1EaCQ1qcFPbSK6Nj6BmgA7SUOpitGBVsLcWpeHj6cGDV2nvSp3P29ODPvER9ImPYO+xM3y9IYsZ67L4+8wtvDBrK10ahXJ9iwh6xYUTGuhrd1ylHIoWrAqUfiCHWRuyuP/KGGpV1y8bdWl1Q6oxPDGWh65qxLZ9J5m7eS9zNu1j1IzNPDtzM+2ja9K7eR16xYVTr6a/3XGVsp0WrAr0zpJ0fL08GdY9xu4oyomICHF1g4irG8RT1zQhdd8Jvtuyn++2ZjN6Tiqj56TStE51esWF0ysunBaRwU49gbJSl0sLVgXJOFjcuxraPUZP5ajLJiI0rxtM87rBPHFNE3YcOsXCbdl8n5rNO0vSeXtxOuFBvlzdLJxrmtehc0woPl462lC5By1YFeSdJdvx9vTgfu1dqQoUHRbA0O4xDO0ew9FTZ1n8ywEWbstm5vosPlm1i+q+XvRoVptr4yNIbFILP2/XvOWJUqAFq0LsPHyKrzdkMbhztP52pSpNjQAfbm4Xxc3tosjNL2R52iG+T93P96nZzNqwlwAfT3o2C+emNpF0axyGt17npVyMFqwK8O6S7Xh6CA9epb0rVTX8vD25Oi6cq+PCeaWwiJUZh5m3eR/fbtnP7I17CQ3woV+rugzoUI+mdYLsjqtUhdCCVU67j5zmq3XFs1rU1uuulA28PT3o3rgW3RvX4sUb4vnht4PMXL+HT1ftYsqKHbSpH8LADvXp16qunjJUTk0LVjl98ON2ROAB7V0pB+Dj5fHHaMIjp84yY90ePlu9i6e/3MSr83/hrk4NuKtTA8J0YJByQnqSuxyO5RYxfe0ebm4bRUSwzhmoHEvNAB+Gdo9h4RNX8cnQjrSMCuF/C9PoMmYx/5y9lf3H9b5dyrloD6sc5u8ooKCwSGe1UA5NROgaG0bX2DDSD+TwwQ/b+cia13Bgh/o83CNWe1zKKWgP6zIdPXWWJbvz6deqLtF6vyvlJGJrB/KfW1ux5MlEbmodyUcrd5L4n6W8uzSd3PxCu+MpdUlasC7T5BU7yCuE4YmxdkdRqszqh/rz6i0t+e6xK+kUU5PX5v9Kz//+wILUbLujKXVRWrAuQ05eAVN+yqRtbU+a1KludxylLlts7UAmDm7Pp/d3JMDXk/unreXt9bn6+5ZySFqwLsOnq3ZyIreAvo287Y6iVIXo0iiMOY905+neTdh0sJCr3/iBL1P2YIyxO5pSfyh1wRIRTxFZLyJzrNcNRWSViKSLyOci4mMt97Vep1vroyspuy3yCgqZuCyTrrGhxATrNS3Kdfh4eTAiKZZXulUjLiKIp77YyPBP1nH01Fm7oykFlK2H9Siw7ZzXrwJjjTGxwFFgiLV8CHDUWj7W2s5lzFyXxYGTeTx0lf52pVxTbX8PPhvWiZF9mrJwWza9//cjqzOP2B1LVYBq1artFxHjbI9q1arth1IWLBGJAq4HJlqvBegBfGltMhW40Xre33qNtb6nuMi9EAqLDB/8mEGLyGC6xobaHUepSuPpITyU2IiZw7sS4OvFHRNWMnFZhp4idHK5ubnhxhic7ZGbmxsOIKX5H1BEvgT+DVQHngLuAVZavShEpB7wrTEmXkS2AH2MMXusdduBjsaYQ3865jBgGEB4eHi75OTkCvpIKs+a/QW8syGPEa19aV/Hi5ycHAIDA+2OVaW0za7vz+09nW+YtCWPlOxCOtTxZEi8L75eLvE36B+c9TNOSkpKMcYklHZ7ETHO+EeHiGCMkRIvHBaRvsABY0yKiCRWVABjzHhgPEBCQoJJTKywQ1cKYwz/HfcTMWFePHHbVXh6CEuXLsXRc1c0bbPru1B7r726+OzCa/N/4YynN5MGJ7jU3Jnu9hk7q9KcEuwK3CAiO4Bkik8FvgmEiPxR8KKALOt5FlAPwFofDByuwMy2+Cn9MJuzjjPsyhg8PVzrr0ulSiIiPHhVIyYMSmD7wRxuencFv+4/aXcs5WZKLFjGmGeMMVHGmGhgALDYGHMnsAS4xdpsMDDLej7beo21frFT9kH/5IMft1O7ui83tY20O4pStunZLJzpD3SmoKiIW95bwcoMp/9bVDmR8lyHNRJ4QkTSgVBgkrV8EhBqLX8CGFW+iPbbknWcZWmHuLdrQ3y9dCi7cm/xkcF8PaIr4cF+DP5wNUt+PWB3JOVg8vLyuP3224mNjaVjx47s2LHjgtvNnz+fJk2aEBsby5gxY0o8bpkKljFmqTGmr/U8wxjTwRgTa4y51RiTZy3PtV7HWuszyvIejmjCsgwCfb0Y2LG+3VGUcggRwdX4fFgnYmsHMmzaWuZu2md3JOVAJk2aRI0aNUhPT+fxxx9n5MiR521TWFjIiBEj+Pbbb0lNTeWzzz4jNTX1ksfVmS5KsPvIaeZs2sfAjvUJrqYzWyj1u9BAXz4b1olWUSE88tk6Zm3IKnkn5XDWrFlDy5Ytyc3N5dSpUzRv3pwtW7aU65izZs1i8ODiX4ZuueUWFi1adN4lEatXryY2NpaYmBh8fHwYMGAAs2bNutDh/qC3FynBpOWZeAjc2zXa7ihKOZwgP2+mDenAPZPX8MT0jfh6edAnPsLuWKoM2rdvzw033MBzzz3HmTNnuOuuu4iPjz9vu+7du3Py5PkDbV5//XWuvvrq/7MsKyuLevXqAeDl5UVwcDCHDx8mLCzsgtsAREVFsWrVqktm1YJ1CUdPneXzNbvp3zpSb9Co1EX4+3jx4T3tGTRpFY98tp737/KgZ7Nwu2OpMnjhhRdo3749fn5+vPXWWxfcZtmyZVWc6nx6SvASPl65kzP5hdzfPcbuKEo5tEBfL6bc14FmEUE89PE6Vmw/VPJOymEcPnyYnJwcTp48SW7uhWfq7969O61btz7vsXDhwvO2jYyMZPfu3QAUFBRw/PhxQkNDL7oNwJ49e4iMvPQobO1hXURufiFTf95BYpNaegsRpUohyM+bafd14Nb3f+aBaSl8/kBn4uoG2R1LlcIDDzzASy+9RGZmJiNHjmTcuHHnbVOWHtYNN9zA1KlT6dy5M19++SU9evTgzzP0tW/fnrS0NDIzM4mMjCQ5OZlPP/30ksfVHtZFfL0+i0M5Zxl2pfaulCqtEH8fpt7XgQBfL+6ZvJo9R0/bHUmVYNq0aXh7ezNw4EBGjRrFmjVrWLx4cbmOOWTIEA4fPkxsbCxvvPHGH0PW9+7dy3XXXQcU/7Y1btw4evfuTbNmzbjtttto3rz5JY+rPawLKCoyTFiWQXxkEJ1jdJJbpcqibkg1pt7XgVvfX8GgD1cz46EuhPj72B1LXcSgQYMYNGgQAJ6eniUOfCgNPz8/vvjii/OW161bl3nz5v3x+rrrrvujgJWG9rAuYMmvB9h+8BT3d485rxurlCpZkzrVmTAogT1HzjD8k3XkFxbZHUm5AC1YF/DBjxlEhlTjuhY6PFepy9UxJpR//aUFK7Yf5sVvttodR7kALVh/snH3MVZnHuHertF4e+p/HqXK45Z2UTxwZQwfr9zFtJ932B1HOTn9Rv6TCcsyqO7rxe3t65W8sVKqRH/r05SeTWvz4jepOtzdDSxYsIB27drRokUL2rVrd9EBHEeOHKFXr140btyYXr16cfTo0RKPrQXrHHuOnubbLfu5o2N9qvvpNExKVQRPD+HNO9oQHerPXz9bz/7jF77OR7mGsLAwvvnmGzZv3szUqVO5++67L7jdmDFj6NmzJ2lpafTs2bPiJ791dVN+2oEA93SJtjuKUi4l0NeLD+5ux5mzhQz/JIWzBToIw1G8//77f1wE3LBhQ5KSksp1vDZt2lC3bl0AmjdvzpkzZ8jLyztvu3PnGxw8eDBff/11icfWgmU5kZtP8prdXN8ygrohOg2TUhUttnZ1XrulFet2HeOVuZeelVtVnQcffJANGzawZs0aoqKieOKJJ87b5vHHH7/gLBcl9Yq++uor2rZti6+v73nrsrOziYgoHthWp04dsrOzS8yq12FZPl+9m5y8AoZ20wuFlaos17eMYP2uhkxcnklCdE36taprdyRlefTRR+nRowf9+vU7b93YsWPLfLytW7cycuRIvv/++xK3FZFSXUKkBQsoKCxi8k+ZdGxYkxZRwXbHUcqljby2KSm7jvLsjM20rhdCvZr+dkdye1OmTGHnzp0XnJIJintYS5YsOW/5gAEDGDXq/Hv07tmzh5tuuolp06bRqFGjCx4zPDycffv2ERERwb59+6hdu3aJObVgAfO27Gfv8VxG9z9/Sn2lVMXy9vTgrQFtuO6tZTz82Xq+fLCzXkJio5SUFF5//XWWLVuGh8eFP4ey9LCOHTvG9ddfz5gxY+jatetFt/t9vsFRo0YxdepU+vfvX+Kx3f7/EmMME5dlEBMWQI+mJVd4pVT51avpz6s3t2Tj7mO8/v2vdsdxa+PGjePIkSMkJSXRunVrhg4dWu7jpaenM3r06D9+6zpw4AAAQ4cOZe3atQCMGjWKBQsW0LhxYxYuXHjBntqfuX0Pa+3Oo2zac5yXb4zHw0OnYVKqqlzXIoKBHevzwQ8ZdI+tRbfGYSXvpCrc5MmTK/R4zz33HM8999wF102cOPGP56GhoSxatKhMx3b7HtbEZRmE+Htzc9sou6Mo5XZe6BtHo1oBPPXFRo6fzrc7jnJwJRYsEfETkdUislFEtorIi9byKSKSKSIbrEdra7mIyFsiki4im0SkbSW34bLtPHyK71OzubNjfar5eNodRym34+ftydjbW3MoJ4/nZ22xO45ycKXpYeUBPYwxrYDWQB8R6WSte9oY09p6bLCWXQs0th7DgPcqNnLFmfzTDrw8hEGdo+2OopTbahkVwqM9GzN7415mb9xrdxzlwEosWKZYjvXS23qYS+zSH5hm7bcSCBERh5v2/PjpfKav3U2/VnUJD/KzO45Sbu2hxEa0qR/CczM369RN6qLEmEvVHmsjEU8gBYgF3jHGjBSRKUBnintgi4BRxpg8EZkDjDHGLLf2XQSMNMas/dMxh1HcAyM8PLxdcnJyxbWqFOZlnGX6b/m82MWPBkGXdzowJyeHwMDACk7m2LTNrs+u9mafKuL5n87QLNSTx9r6Vum96Jz1M05KSkoxxiSUdnsRMaX5znc0IoIxRko1StAYUwi0FpEQYKaIxAPPAPsBH2A8MBIYXdoAxpjx1n4kJCSYxMTEMjWgPPILi3jm5yV0aRTE4Bs6lbzDRSxdupSqzO0ItM2uz872ngrOZPScVI4ENebmdlU3EMpdPmM/P79sEQm3O0dZ+fn5ZUMZRwkaY44BS4A+xph91mm/PGAy0MHaLAs4994cUdYyhzFv8z72Hc9lSLeGdkdRSp3jni7RJDSowYvfbOXACT01WNHOnDlTxxgjzvY4c+ZMHSjdKMFaVs8KEakG9AJ++f13KSnut98I/D7EZzYwyBot2Ak4bozZV+H/5S+TMYZJyzOJCQsgqYleKKyUI/HwEF67pSV5BUU8O3Mzznj6SlWe0vSwIoAlIrIJWAMsMMbMAT4Rkc3AZiAMeNnafh6QAaQDE4DhFZ66HH6/UPi+bg31QmGlHFBMrUCeuqYJC7cd0FGD6v8o8TcsY8wmoM0Flve4yPYGGFH+aJVDLxRWyvHd160hczbtZfQ3qVx1RS1C/H3sjqQcgFvNdLHr8Gm9UFgpJ+DpIfz7Ly05diafV+ZuszuOchBuVbA+/ClTLxRWyknE1Q3i/u4xfJGyhxXph+yOoxyA2xSs42fy+WLtbvq11AuFlXIWj13dmAah/jw7czO5+YV2x1E2c5uC9fmaXZw6W8h9OpRdKafh5+3Jv25qwY7Dp3l3SbrdcZTN3KJgFRQWMXXFTjo2rEl8pN5RWCln0jU2jBtb1+X9HzLIOJhT8g7KZblFwZq/dT9Zx84wtHuM3VGUUpfh2eub4evtwfOztui1WW7MLQrWxGWZRIf601PvKKyUU6pd3Y+nezfhp/TDem2WG3P5gpWy8ygbdh/TC4WVcnJ3dmxAy6hgXp67jRO5erNHd+TyBWvS8gyC/Lz0QmGlnJynh/DyjfEcysnjfwvS7I6jbODSBWv3kdPM37KfgR0bEOBbqonplVIOrGVUCHd0qM/Un3fwy/4TdsdRVcylC9aUFTvwEGFwlwZ2R1FKVZCnr2lCdT8v/jFrqw7AcDMuW7BO5Obz+Zrd9G0ZQURwNbvjKKUqSI0AH57u3YRVmUf4ZpPD3AhCVQGXLVjT1+wmJ6+AId10KLtSrmZA+/rERwbxytxUcvIK7I6jqohLFqyCwiIm/7SDDg1r0iJKLxRWytV4egij+8eTfSKPd3QGDLfhkgXru63ZZB07o3cUVsqFta1fg7+0jWTSskx2HDpldxxVBVyuYBljmLAsg+hQf65uFm53HKVUJRrVpynensLLegsSt+ByBWvdruILhYd0a4inXiislEurHeTHiB6xLNyWzY+/HbQ7jqpkLlewJvyYSXA1b25upxcKK+UOhnRrSINQf0bPSSW/sMjuOKoSuVTB2nn4FN+l7ufOjvXx99ELhZVyB75enjx3fRzpB3L46OeddsdRlcilCtbkn3bg5SEM7hJtdxSlVBW6ulltusWG8eaiNI6eOmt3HFVJSixYIuInIqtFZKOIbBWRF63lDUVklYiki8jnIuJjLfe1Xqdb66MruQ0AHD+dz/S1u+nXSu8orJS7ERGe7xvHydx83lyk8wy6qtL0sPKAHsaYVkBroI+IdAJeBcYaY2KBo8AQa/shwFFr+Vhru0r36epdnD5bqEPZlXJTTepUZ2DH+ny0cifpB07aHUdVghILlin2+20+va2HAXoAX1rLpwI3Ws/7W6+x1vcUkUodrne2oIgpKzLpFhtG87p6obBS7urxq6/A38dTh7m7KCnN5JEi4gmkALHAO8B/gJVWLwoRqQd8a4yJF5EtQB9jzB5r3XagozHm0J+OOQwYBhAeHt4uOTn5shvxU1Y+Ezaf5Yl2vrSsVXWDLXJycggMDKyy93ME2mbX5+ztnZ+ZT/KvZfs+cNY2JyUlpRhjEuzOUVVK9WkaYwqB1iISAswEmpb3jY0x44HxAAkJCSYxMfFyj8OYN5fRJNyXR27pTiV35v6PpUuXcrm5nZW22fU5e3u7dCti5dgf+Ga3B8P/0h0vz5J/+XD2NruLMo0SNMYcA5YAnYEQEfm94EUBWdbzLKAegLU+GDhcEWEvZHn6IX7Zf5Ih3RtWabFSSjkmHy8PnrmuGWkHcvhs9S6746gKVJpRgrWsnhUiUg3oBWyjuHDdYm02GJhlPZ9tvcZav9hU4k1rxv+YQa3qvvRvXbey3kIp5WSuiQunY8OajF2YxvEz+XbHURWkND2sCGCJiGwC1gALjDFzgJHAEyKSDoQCk6ztJwGh1vIngFEVH7vYtn0nWJZ2iHu6ROPr5VlZb6OUcjK/D3M/evqszubuQkr8DcsYswloc4HlGUCHCyzPBW6tkHQlOJSTR5Pw6tzZsX5VvJ1SyonERwZzc9soJv+UyZ0d69MgNMDuSKqcnHqmi+6NazH/se6E+PvYHUUp5YCe7t0ELw8PXp3/i91RVAVw6oIF6EALpdRFhQf58cBVMczbvJ81O47YHUeVk9MXLKWUupRhV8YQHuTLy3O3UVRUaeO/VBXQgqWUcmn+Pl483bspG3cf45tNe+2Oo8pBC5ZSyuX9pU0kzesG8dr8X8nNL7Q7jrpMWrCUUi7Pw0P4+/XNyDp2hknLM+2Ooy6TFiyllFvo0iiMXnHhvLsknYMn8+yOoy6DFiyllNt45tqm5BUUMXbhb3ZHUZdBC5ZSym3E1Ark7s4NSF69i1/36z2znI0WLKWUW3m0Z2Oq+3nzyjy9Z5az0YKllHIrIf4+/LVnY3787SBLfj1gdxxVBlqwlFJu5+5ODYgO9eeVudsoKCyyO44qJS1YSim34+PlwbPXNSP9QA6f6j2znIYWLKWUW+oVF07nmFDGLviNU/k6ZZMz0IKllHJLIsJzfZtx7Ew+s7eftTuOKgUtWEopt9W8bjC3tavHwp0FZB46ZXccVQItWEopt/Zk7yvw9oBX5uowd0enBUsp5dZqV/ejbyNvFm7LZnnaIbvjqEvQgqWUcnvXNPCmfk1/Rs/ZqsPcHZgWLKWU2/PxFJ69rhm/Zeswd0dWYsESkXoiskREUkVkq4g8ai3/p4hkicgG63HdOfs8IyLpIvKriPSuzAYopVRF6N28eJj7Gwt+49hpHTXoiErTwyoAnjTGxAGdgBEiEmetG2uMaW095gFY6wYAzYE+wLsi4lkJ2ZVSqsKICC/0i+PEmXzGLtDZ3B1RiQXLGLPPGLPOen4S2AZEXmKX/kCyMSbPGJMJpAMdKiKsUkpVpmYRQdzVqQEfrdzJtn0n7I6j/qRMv2GJSDTQBlhlLXpYRDaJyIciUsNaFgnsPme3PVy6wCmllMN4otcVBFfz5h+zt2KMzoDhSKS0H4iIBAI/AK8YY2aISDhwCDDAS0CEMeY+ERkHrDTGfGztNwn41hjz5Z+ONwwYBhAeHt4uOTm5otpUZXJycggMDLQ7RpXSNrs+d2svnN/mpbvzmbL1LA+28qVThJeNyS4tKSkpxRiTYHeOqlKqT0JEvIGvgE+MMTMAjDHZ56yfAMyxXmYB9c7ZPcpa9n8YY8YD4wESEhJMYmLiZcS319KlS3HG3OWhbXZ97tZeOL/N3YsMa99ZzteZZ3nkL90I8HXcouVOSjNKUIBJwDZjzBvnLI84Z7ObgC3W89nAABHxFZGGQGNgdcVFVkqpyuXpIbx4Qzz7T+Ty9uJ0u+MoS2n+bOgK3A1sFpEN1rJngTtEpDXFpwR3AA8AGGO2ish0IJXiEYYjjDGFFRtbKaUqV7sGNbi1XRQTl2Vwc9tIGodXtzuS2yuxYBljlgNygVXzLrHPK8Ar5cillFK2G3VtU75Pzeb5WVv47P5OFJ9wUnbRmS6UUuoiQgN9GdmnKSszjjBrw16747g9LVhKKXUJA9rXo1W9EF6eu43jZ/LtjuPWtGAppdQleHgIr9wYz5FTebw2/xe747g1LVhKKVWC+Mhg7u3akE9W7WLtjiN2x3FbWrCUUqoUnuh1BZEh1Rg1YzN5BTrw2Q5asJRSqhQCfL14+aZ40g/k8N7S7XbHcUtasJRSqpSSmtTmhlZ1eXfJdtIPnLQ7jtvRgqWUUmXwQr84/H09eeqLTRQW6eS4VUkLllJKlUFYoC+j+8ezYfcxJizLsDuOW9GCpZRSZdSvZQTXxtfhje9/Iy1bTw1WFS1YSilVRiLCSzfGE+jnxZNfbKSgsMjuSG5BC5ZSSl2GsEBfXuofz6Y9x3lniY4arApasJRS6jJd3zKC/q3r8tbiNFJ2HrU7jsvTgqWUUuXw0o3xRAT78Wjyek7k6lyDlUkLllJKlUOQnzdvDmjDvuO5vPD1lpJ3UJdNC5ZSSpVTuwY1eKxnY77esJcvU/bYHcdlacFSSqkKMDwpls4xofx95ma27j1udxyXpAVLKaUqgKeH8NYdbajh78NDH6/j+Gn9PauiacFSSqkKUqu6L+/c2ZZ9x8/w+PQNFOnUTRVKC5ZSSlWgdg1q8HzfOBb/coA3FvxmdxyX4mV3AKWUcjV3d2rAlqzjjFuSTv1Qf25LqGd3JJdQYg9LROqJyBIRSRWRrSLyqLW8pogsEJE0698a1nIRkbdEJF1ENolI28puhFJKORIR4ZWbWtAtNoxnZ2zmp/RDdkdyCaU5JVgAPGmMiQM6ASNEJA4YBSwyxjQGFlmvAa4FGluPYcB7FZ5aKaUcnLenB+/e1ZaYWgE8+FEKv+7XSXLLq8SCZYzZZ4xZZz0/CWwDIoH+wFRrs6nAjdbz/sA0U2wlECIiERUdXCmlHF2QnzeT7+1ANR9P7py4ivQDOXZHcmpiTOlHsYhINPAjEA/sMsaEWMsFOGqMCRGROcAYY8xya90iYKQxZu2fjjWM4h4Y4eHh7ZKTk8vfmiqWk5NDYGCg3TGqlLbZ9blbe6Hy27w3p4gxq3PxEBjVwY86ARUz3i0pKSnFGJNQIQdzAqUedCEigcBXwGPGmBPFNaqYMcaISJnGbxpjxgPjARISEkxiYmJZdncIS5cuxRlzl4e22fW5W3uhatqc0P4kd4xfydiNRSQP60jDsIBKfT9XVKoyLyLeFBerT4wxM6zF2b+f6rP+PWAtzwLOHRITZS1TSim3dUV4dT65vyP5hYab31uhs7tfhtKMEhRgErDNGPPGOatmA4Ot54OBWecsH2SNFuwEHDfG7KvAzEop5ZSa1gniq4e6EOTnxR0TVjJ3k341lkVpelhdgbuBHiKywXpcB4wBeolIGnC19RpgHpABpAMTgOEVH1sppZxTw7AAZgzvSovIYEZ8uo4Pl2faHclplPgbljV4Qi6yuucFtjfAiHLmUkopl1UzwIdPhnZk5FebaFhLf8sqLZ3pQimlbODn7cmbA9rYHcOp6FyCSimlnIIWLKWUUk5BC5ZSSimnoAVLKaWUU9CCpZRSyilowVJKKeUUtGAppZRyClqwlFJKOYUy3V6k0kKIHAR22p3jMoQB7nYrUW2z63O39oLztrmBMaaW3SGqikMULGclImvd6V40oG12B+7WXnDPNjsjPSWolFLKKWjBUkop5RS0YJXPeLsD2EDb7Prcrb3gnm12OvobllJKKaegPSyllFJOQQuWUkopp6AFq4KIyJMiYkQkzO4slUlE/iMiv4jIJhGZKSIhdmeqLCLSR0R+FZF0ERlld57KJiL1RGSJiKSKyFYRedTuTFVFRDxFZL2IzLE7i7o4LVgVQETqAdcAu+zOUgUWAPHGmJbAb8AzNuepFCLiCbwDXAvEAXeISJy9qSpdAfCkMSYO6ASMcIM2/+5RYJvdIdSlacGqGGOBvwEuP4LFGPO9MabAerkSiLIzTyXqAKQbYzKMMWeBZKC/zZkqlTFmnzFmnfX8JMVf4JH2pqp8IhIFXA9MtDuLujQtWOUkIv2BLGPMRruz2OA+4Fu7Q1SSSGD3Oa/34AZf3r8TkWigDbDK5ihV4X8U/8FZZHMOVQIvuwM4AxFZCNS5wKq/A89SfDrQZVyqvcaYWdY2f6f4FNInVZlNVT4RCQS+Ah4zxpywO09lEpG+wAFjTIqIJNocR5VAC1YpGGOuvtByEWkBNAQ2iggUnx5bJyIdjDH7qzBihbpYe38nIvcAfYGexnUv5MsC6p3zOspa5tJExJviYvWJMWaG3XmqQFfgBhG5DvADgkTkY2PMXTbnUhegFw5XIBHZASQYY5xx1udSEZE+wBvAVcaYg3bnqSwi4kXxoJKeFBeqNcBAY8xWW4NVIin+q2sqcMQY85jNcaqc1cN6yhjT1+Yo6iL0NyxVVuOA6sACEdkgIu/bHagyWANLHga+o3jwwXRXLlaWrsDdQA/rs91g9TyUcgjaw1JKKeUUtIellFLKKWjBUkop5RS0YCmllHIKWrCUUko5BS1YSimlnIIWLKWUUk5BC5ZSSimnoAVLqQsQkdEi8tg5r19xp/tDKeWI9MJhpS7Amq18hjGmrYh4AGlAB2PMYXuTKeW+dPJbpS7AGLNDRA6LSBsgHFivxUope2nBUuriJgL3UHyrlQ/tjaKU0lOCSl2EiPgAmwFvoLExptDmSEq5Ne1hKXURxpizIrIEOKbFSin7acFS6iKswRadgFvtzqKU0mHtSl2QiMQB6cAiY0ya3XmUUvobllJKKSehPSyllFJOQQuWUkopp6AFSymllFPQgqWUUsopaMFSSinlFP4fUnCTNVM13wwAAAAASUVORK5CYII=\n", + "image/png": "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", "text/plain": [ "
" ] @@ -666,7 +640,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -687,27 +661,6 @@ "fig2 = tp.utils.plot(model, strain_fn, samp2)\n", "pyplot.ylabel('Spannung $N/mm^2$')" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " #´ß0431 ´ß098765430" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/examples/tutorial/Introduction_Tutorial_PINNs.ipynb b/examples/tutorial/Introduction_Tutorial_PINNs.ipynb index a6095fb9..07e1c7c9 100644 --- a/examples/tutorial/Introduction_Tutorial_PINNs.ipynb +++ b/examples/tutorial/Introduction_Tutorial_PINNs.ipynb @@ -543,7 +543,7 @@ "import pytorch_lightning as pl\n", "import os\n", "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\" if torch.cuda.is_available() else \"0\"\n", - "device = 1 if torch.cuda.is_available() else None\n", + "device = 1 if torch.cuda.is_available() else 0\n", "print('Training on', device)\n", "print (\"GPU available: \" + str(torch.cuda.is_available()))" ] @@ -623,13 +623,21 @@ "source": [ "# Start the training\n", "trainer = pl.Trainer(\n", - " gpus=device, # or None if CPU is used\n", + " # gpus=device, # or None if CPU is used\n", " max_steps=5000, # number of training steps\n", " logger=False,\n", " benchmark=True,\n", " # checkpoint_callback=False # Uncomment this for more verbose\n", - ")\n", - "\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "72bfec0d", + "metadata": {}, + "outputs": [], + "source": [ "trainer.fit(solver) # start training" ] }, @@ -852,14 +860,6 @@ "plt.imshow(np.rot90(output[:, :]), 'gray', vmin=vmin, vmax=vmax)\n", "plt.show()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9840aad9", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -878,7 +878,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.10.0" } }, "nbformat": 4, diff --git a/examples/tutorial/Tutorial_PINNs_Parameter_Dependency.ipynb b/examples/tutorial/Tutorial_PINNs_Parameter_Dependency.ipynb index 24683fd4..eb31c024 100644 --- a/examples/tutorial/Tutorial_PINNs_Parameter_Dependency.ipynb +++ b/examples/tutorial/Tutorial_PINNs_Parameter_Dependency.ipynb @@ -354,8 +354,6 @@ "import pytorch_lightning as pl\n", "import os\n", "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\" if torch.cuda.is_available() else \"0\"\n", - "device = 1 if torch.cuda.is_available() else None\n", - "print('Training on', device)\n", "print (\"GPU available: \" + str(torch.cuda.is_available()))" ] }, @@ -389,11 +387,13 @@ "outputs": [], "source": [ "# Start the training\n", - "trainer = pl.Trainer(gpus=device,\n", - " max_steps=2000, # number of training steps\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, \n", + " # accelerator=\"gpu\", # what to use to solve problem and how many devices\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=2000, # number of training steps\n", + " logger=False, \n", + " enable_checkpointing=False)\n", "\n", "trainer.fit(solver) # start training" ] @@ -411,11 +411,13 @@ "pde_condition.sampler = pde_condition.sampler.make_static() # LBFGS can not work with varying points!\n", "solver = tp.solver.Solver(train_conditions=training_conditions, optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=device,\n", - " max_steps=3000, # number of training steps\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1,\n", + " # accelerator=\"gpu\", # what to use to solve problem and how many devices\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=3000, # number of training steps\n", + " logger=False, \n", + " enable_checkpointing=False)\n", " \n", "trainer.fit(solver)" ] @@ -463,14 +465,6 @@ "source": [ "animation.save(f'animation_tut_2_a{a}_p{p}.gif')" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7c854bbd-a4e0-4b36-a9b3-bfe8b3c4850b", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/examples/tutorial/animation_tut_2_a0.11_p4.gif b/examples/tutorial/animation_tut_2_a0.11_p4.gif index 23fee4be..c27c135a 100644 Binary files a/examples/tutorial/animation_tut_2_a0.11_p4.gif and b/examples/tutorial/animation_tut_2_a0.11_p4.gif differ diff --git a/examples/tutorial/domain_creation.ipynb b/examples/tutorial/domain_creation.ipynb index 6bfd6c64..89627365 100644 --- a/examples/tutorial/domain_creation.ipynb +++ b/examples/tutorial/domain_creation.ipynb @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -52,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -110,7 +110,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -200,7 +200,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -246,7 +246,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.4" + "version": "3.10.4" }, "orig_nbformat": 4 }, diff --git a/examples/tutorial/polygons_external_objects.ipynb b/examples/tutorial/polygons_external_objects.ipynb index dba5d39c..918a5eb3 100644 --- a/examples/tutorial/polygons_external_objects.ipynb +++ b/examples/tutorial/polygons_external_objects.ipynb @@ -26,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -44,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -80,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -96,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -133,7 +133,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -170,7 +170,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -218,7 +218,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.4" + "version": "3.10.4" }, "orig_nbformat": 4 }, diff --git a/examples/tutorial/solve_pde.ipynb b/examples/tutorial/solve_pde.ipynb index 475d5125..f2bc2ef8 100644 --- a/examples/tutorial/solve_pde.ipynb +++ b/examples/tutorial/solve_pde.ipynb @@ -7,7 +7,7 @@ "source": [ "Solving a simple PDE with the PINN-approach\n", "===========================================\n", - "Here we give a beginner-friendly introduction to TorchPhysics, going over all the basic concepts and steps. For a more in-depth explanation, we recommend the [tutorial page](https://torchphysics.readthedocs.io/en/latest/tutorial/tutorial_start.html).\n", + "Here we give a beginner-friendly introduction to TorchPhysics, going over all the basic concepts and steps. For a more in-depth explanation, we recommend the [tutorial page](https://boschresearch.github.io/torchphysics/tutorial/tutorial_start.html).\n", "We introduce the library with the aim to solve the following PDE:\n", "\n", "\\begin{align*}\n", @@ -212,11 +212,13 @@ "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\" if torch.cuda.is_available() else \"0\"\n", "device = 1 if torch.cuda.is_available() else None\n", "\n", - "trainer = pl.Trainer(gpus=device,\n", - " max_steps=4000, # number of training steps\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, \n", + " # accelerator=\"gpu\", # what to use to solve problem and how many devices\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=4000, # number of training steps\n", + " logger=False, \n", + " enable_checkpointing=False)\n", " \n", "trainer.fit(solver)" ] @@ -241,11 +243,13 @@ "pde_cond.sampler = pde_cond.sampler.make_static() # LBFGS can not work with varying points!\n", "solver = tp.solver.Solver(train_conditions=[bound_cond, pde_cond], optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=device,\n", - " max_steps=3000, # number of training steps\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, \n", + " # accelerator=\"gpu\", # what to use to solve problem and how many devices\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=3000, # number of training steps\n", + " logger=False, \n", + " enable_checkpointing=False)\n", " \n", "trainer.fit(solver)" ] @@ -298,12 +302,6 @@ "\n", "More in-depth information can be found in the [tutorial](https://torchphysics.readthedocs.io/en/latest/tutorial/tutorial_start.html)." ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [] } ], "metadata": { diff --git a/examples/tutorial/solve_pde_drm.ipynb b/examples/tutorial/solve_pde_drm.ipynb index 3963145f..66baf4ae 100644 --- a/examples/tutorial/solve_pde_drm.ipynb +++ b/examples/tutorial/solve_pde_drm.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -44,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -62,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -123,7 +123,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -140,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -177,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -197,92 +197,22 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True, used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [1]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 15.5 K\n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "15.5 K Trainable params\n", - "0 Non-trainable params\n", - "15.5 K Total params\n", - "0.062 Total estimated model params size (MB)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "53c01cb1c239447bbbd11eaa99727ab6", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation sanity check: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, val dataloader 0, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " warnings.warn(*args, **kwargs)\n", - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/pytorch_lightning/utilities/distributed.py:69: UserWarning: The dataloader, train dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 20 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", - " warnings.warn(*args, **kwargs)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "077a043baa244c7382178cbef10025a7", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "71f40add9973460a9f279ae1657eebae", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import pytorch_lightning as pl\n", "## maybe selcet the GPU to use:\n", "#import os\n", "#os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n", "\n", - "trainer = pl.Trainer(gpus=1, # or None if CPU is used\n", - " max_steps=2500, # number of training steps\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, \n", + " # accelerator=\"gpu\", # what to use to solve problem and how many devices\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=2500, # number of training steps\n", + " logger=False, \n", + " enable_checkpointing=False)\n", " \n", "trainer.fit(solver)" ] @@ -296,71 +226,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True, used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [1]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------\n", - "0 | train_conditions | ModuleList | 15.5 K\n", - "1 | val_conditions | ModuleList | 0 \n", - "------------------------------------------------\n", - "15.5 K Trainable params\n", - "0 Non-trainable params\n", - "15.5 K Total params\n", - "0.062 Total estimated model params size (MB)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6cce7463816e4a4ead8127108c67d2a5", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation sanity check: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "acb322a9cc9447cfb177fb92aa404aed", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "00f43386ada4408ab86c7cd3153a75d7", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validating: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "optim = tp.OptimizerSetting(optimizer_class=torch.optim.LBFGS, lr=0.05, \n", " optimizer_args={'max_iter': 2, 'history_size': 100})\n", @@ -369,45 +237,22 @@ "pde_cond.sampler = pde_cond.sampler.make_static()# LBFGS can not work with varing points!\n", "solver = tp.solver.Solver(train_conditions=[bound_cond, pde_cond], optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=1000, # number of training steps\n", - " logger=False,\n", + "trainer = pl.Trainer(devices=1, \n", + " # accelerator=\"gpu\", # what to use to solve problem and how many devices\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " checkpoint_callback=False)\n", + " max_steps=1000, # number of training steps\n", + " logger=False, \n", + " enable_checkpointing=False)\n", " \n", "trainer.fit(solver)" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/tomfre/miniconda3/envs/bosch/lib/python3.9/site-packages/torch/functional.py:478: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:2895.)\n", - " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n", - "/home/tomfre/Desktop/torchphysics/src/torchphysics/problem/domains/domain2D/parallelogram.py:134: UserWarning: The use of `x.T` on tensors of dimension other than 2 to reverse their shape is deprecated and it will throw an error in a future release. Consider `x.mT` to transpose batches of matricesor `x.permute(*torch.arange(x.ndim - 1, -1, -1))` to reverse the dimensions of a tensor. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:2985.)\n", - " bary_coords = torch.stack(torch.meshgrid((x, y))).T.reshape(-1, 2)\n", - "/home/tomfre/Desktop/torchphysics/src/torchphysics/utils/plotting/plot_functions.py:416: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:204.)\n", - " embed_point = Points(torch.tensor([center]), domain.space)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_sampler = tp.samplers.PlotSampler(plot_domain=square, n_points=640, device='cuda')\n", "fig = tp.utils.plot(model, lambda u : u, plot_sampler, plot_type='contour_surface')" @@ -422,22 +267,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "def plot_fn(u, x):\n", " exact = torch.sin(np.pi/2*x[:, :1])*torch.cos(2*np.pi*x[:, 1:])\n", @@ -454,6 +286,11 @@ "\n", "More in-depth information can be found in the [tutorial](https://torchphysics.readthedocs.io/en/latest/tutorial/tutorial_start.html)." ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] } ], "metadata": { @@ -475,7 +312,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.10.4" } }, "nbformat": 4, diff --git a/examples/workshop/Exercise2_1.ipynb b/examples/workshop/Exercise2_1.ipynb index 5a2e7ec5..0781ae46 100644 --- a/examples/workshop/Exercise2_1.ipynb +++ b/examples/workshop/Exercise2_1.ipynb @@ -14,7 +14,7 @@ " u(0) &= H \\\\\n", " \\partial_t u(0) &= 0\n", "\\end{align*}\n", - "If you are using Google Colab, you first have to install TorchPhysics with the following cell. We recommend first enabling the GPU and then running the cell. Since the installation can take around 2 minutes and has to be redone if you switch to the GPU later." + "If you are using Google Colab, you first have to install TorchPhysics with the following cell. We recommend first enabling the GPU and then running the cell." ] }, { @@ -31,13 +31,7 @@ } ], "source": [ - "!pip install torchaudio==0.13.0\n", - "!pip install torchphysics\n", - "\n", - "# This will give some error messages, because some package on Google colab use newer versions than we need.\n", - "# You can ignore the errors, since we dont need the mentioned packages.\n", - "# Also, TorchPhysics will only be installed for this session, once you close the notebook it will\n", - "# be automatically deleted and everything resets to default." + "!pip install torchphysics" ] }, { @@ -147,12 +141,12 @@ "solver = tp.solver.Solver([ode_condition, initial_position_condition, initial_velocity_condition],\n", " optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1, # or None on a CPU\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " max_steps=train_iterations,\n", + " max_steps=train_iterations, \n", " logger=False, \n", - " enable_checkpointing=False\n", - " )\n", + " enable_checkpointing=False)\n", "\n", "trainer.fit(solver)" ] diff --git a/examples/workshop/Exercise2_2.ipynb b/examples/workshop/Exercise2_2.ipynb index be28496d..45f6b87c 100644 --- a/examples/workshop/Exercise2_2.ipynb +++ b/examples/workshop/Exercise2_2.ipynb @@ -20,7 +20,7 @@ "The above system describes an isolated room $\\Omega$, with a \\\\\n", "heater at the wall $\\partial\\Omega_{Heater} = \\{(x, y) | 1\\leq x\\leq 3, y=4\\}$. We set $I=[0, 20]$, $D=1$, the initial temperature to $u_0 = 16\\degree C$ and the temperature of the heater is defined below.\n", "\n", - "If you are using Google Colab, you first have to install TorchPhysics with the following cell. We recommend first enabling the GPU and then running the cell. Since the installation can take around 2 minutes and has to be redone if you switch to the GPU later." + "If you are using Google Colab, you first have to install TorchPhysics with the following cell. We recommend first enabling the GPU and then running the cell." ] }, { @@ -29,7 +29,6 @@ "metadata": {}, "outputs": [], "source": [ - "!pip install torchaudio==0.13.0\n", "!pip install torchphysics" ] }, @@ -202,10 +201,11 @@ "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate)\n", "solver = tp.solver.Solver(train_conditions=training_conditions, optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1, # or None if CPU is used\n", - " max_steps=train_iterations, # number of training steps\n", - " logger=False,\n", - " benchmark=True, \n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=train_iterations, \n", + " logger=False, \n", " enable_checkpointing=False)\n", "\n", "trainer.fit(solver) # run the training loop" diff --git a/examples/workshop/Exercise2_3.ipynb b/examples/workshop/Exercise2_3.ipynb index f384d637..d3e20a10 100644 --- a/examples/workshop/Exercise2_3.ipynb +++ b/examples/workshop/Exercise2_3.ipynb @@ -26,7 +26,6 @@ "metadata": {}, "outputs": [], "source": [ - "!pip install torchaudio==0.13.0\n", "!pip install torchphysics" ] }, @@ -206,11 +205,12 @@ "pde_condition.sampler = pde_condition.sampler.make_static()\n", "solver = tp.solver.Solver([pde_condition, data_condition], optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=2000,\n", - " logger=False,\n", - " benchmark=True)\n", - " \n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=2500, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "trainer.fit(solver)" ] }, diff --git a/examples/workshop/Exercise3_1.ipynb b/examples/workshop/Exercise3_1.ipynb index 7a5b14cd..9db0c9dc 100644 --- a/examples/workshop/Exercise3_1.ipynb +++ b/examples/workshop/Exercise3_1.ipynb @@ -23,8 +23,7 @@ "metadata": {}, "outputs": [], "source": [ - "!pip install torchaudio==0.13.0\n", - "!pip install torchphysics\n" + "!pip install torchphysics" ] }, { @@ -129,10 +128,12 @@ "solver = tp.solver.Solver([ode_condition, initial_position_condition, initial_velocity_condition],\n", " optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1, # or None on a CPU\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " max_steps=train_iterations,\n", - " logger=False)\n", + " max_steps=train_iterations, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "\n", "trainer.fit(solver)" ] diff --git a/examples/workshop/Exercise3_2.ipynb b/examples/workshop/Exercise3_2.ipynb index 3cc38d38..54193788 100644 --- a/examples/workshop/Exercise3_2.ipynb +++ b/examples/workshop/Exercise3_2.ipynb @@ -25,7 +25,6 @@ "metadata": {}, "outputs": [], "source": [ - "!pip install torchaudio==0.13.0\n", "!pip install torchphysics" ] }, @@ -311,12 +310,12 @@ "solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", "\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " max_steps=train_iterations,\n", - " logger=False\n", - " )\n", + " max_steps=train_iterations, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "\n", "trainer.fit(solver)" ] diff --git a/examples/workshop/Sol2_1.ipynb b/examples/workshop/Sol2_1.ipynb index de2c9d43..fbc5e083 100644 --- a/examples/workshop/Sol2_1.ipynb +++ b/examples/workshop/Sol2_1.ipynb @@ -14,7 +14,16 @@ " u(0) &= H \\\\\n", " \\partial_t u(0) &= 0\n", "\\end{align*}\n", - "If you are using Google Colab, you first have to install TorchPhysics with the following cell. We recommend first enabling the GPU and then running the cell. Since the installation can take around 2 minutes and has to be redone if you switch to the GPU later." + "If you are using Google Colab, you first have to install TorchPhysics with the following cell. We recommend first enabling the GPU and then running the cell." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install torchphysics" ] }, { @@ -193,11 +202,12 @@ "solver = tp.solver.Solver([ode_condition, initial_position_condition, initial_velocity_condition],\n", " optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1, # or None on a CPU\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " max_steps=train_iterations,\n", - " logger=False\n", - " )\n", + " max_steps=train_iterations, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "\n", "trainer.fit(solver)" ] diff --git a/examples/workshop/Sol2_2.ipynb b/examples/workshop/Sol2_2.ipynb index 79f172ac..9a9fd2b6 100644 --- a/examples/workshop/Sol2_2.ipynb +++ b/examples/workshop/Sol2_2.ipynb @@ -20,7 +20,7 @@ "The above system describes an isolated room $\\Omega$, with a \\\\\n", "heater at the wall $\\partial\\Omega_{Heater} = \\{(x, y) | 1\\leq x\\leq 3, y=4\\}$. We set $I=[0, 20]$, $D=1$, the initial temperature to $u_0 = 16$\\,\\degree C and the temperature of the heater is defined below.\n", "\n", - "If you are using Google Colab, you first have to install TorchPhysics with the following cell. We recommend first enabling the GPU and then running the cell. Since the installation can take around 2 minutes and has to be redone if you switch to the GPU later." + "If you are using Google Colab, you first have to install TorchPhysics with the following cell. We recommend first enabling the GPU and then running the cell." ] }, { @@ -29,7 +29,7 @@ "metadata": {}, "outputs": [], "source": [ - "###!pip install torchphysics" + "!pip install torchphysics" ] }, { @@ -278,11 +278,12 @@ "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate)\n", "solver = tp.solver.Solver(train_conditions=training_conditions, optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1, # or None if CPU is used\n", - " max_steps=train_iterations, # number of training steps\n", - " logger=False,\n", - " benchmark=True)\n", - "\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=train_iterations, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "trainer.fit(solver) # run the training loop" ] }, diff --git a/examples/workshop/Sol2_3.ipynb b/examples/workshop/Sol2_3.ipynb index 36197e55..a1168dd0 100644 --- a/examples/workshop/Sol2_3.ipynb +++ b/examples/workshop/Sol2_3.ipynb @@ -20,6 +20,15 @@ "with $I_x = [0, 2\\pi]$ and $I_t = [0, 20]$. We are given a noisy dataset $\\{(u_i, x_i, t_i)\\}_{i=1}^N$ and aim to determine the corresponding value of $c$." ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install torchphysics" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -266,11 +275,12 @@ "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate)\n", "solver = tp.solver.Solver(train_conditions=[data_condition, pde_condition], optimizer_setting=optim)\n", "\n", - "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=train_iterations,\n", - " logger=False,\n", - " benchmark=True)\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=train_iterations, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", " \n", "trainer.fit(solver)" ] @@ -347,10 +357,13 @@ "pde_condition.sampler = pde_condition.sampler.make_static()\n", "solver = tp.solver.Solver([pde_condition, data_condition], optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=2000,\n", - " logger=False,\n", - " benchmark=True)\n", + "\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=2000, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", " \n", "trainer.fit(solver)" ] diff --git a/examples/workshop/Sol3_1.ipynb b/examples/workshop/Sol3_1.ipynb index 1a49328b..5c3cc0ff 100644 --- a/examples/workshop/Sol3_1.ipynb +++ b/examples/workshop/Sol3_1.ipynb @@ -23,13 +23,7 @@ "metadata": {}, "outputs": [], "source": [ - "#!pip install torchaudio==0.13.0\n", - "#!pip install torchphysics\n", - "\n", - "# This will give some error messages, because some package on Google colab use newer versions than we need.\n", - "# You can ignore the errors, since we dont need the mentioned packages.\n", - "# Also, TorchPhysics will only be installed for this session, once you close the notebook it will\n", - "# be automatically deleted and everything resets to default." + "#!pip install torchphysics" ] }, { @@ -213,11 +207,12 @@ "solver = tp.solver.Solver([ode_condition, initial_position_condition, initial_velocity_condition],\n", " optimizer_setting=optim)\n", "\n", - "trainer = pl.Trainer(gpus=1, # or None on a CPU\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " max_steps=train_iterations,\n", + " max_steps=train_iterations, \n", " logger=False, \n", - " )\n", + " enable_checkpointing=False)\n", "\n", "trainer.fit(solver)" ] diff --git a/examples/workshop/Sol3_2.ipynb b/examples/workshop/Sol3_2.ipynb index ac4d0afe..38538f7b 100644 --- a/examples/workshop/Sol3_2.ipynb +++ b/examples/workshop/Sol3_2.ipynb @@ -25,8 +25,7 @@ "metadata": {}, "outputs": [], "source": [ - "#!pip install torchaudio==0.13.0\n", - "#!pip install torchphysics" + "!pip install torchphysics" ] }, { @@ -319,13 +318,12 @@ "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate) \n", "solver = tp.solver.Solver([data_condition], optimizer_setting=optim)\n", "\n", - "\n", - "trainer = pl.Trainer(gpus=1,\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", " num_sanity_val_steps=0,\n", " benchmark=True,\n", - " max_steps=train_iterations,\n", - " logger=False\n", - " )\n", + " max_steps=train_iterations, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", "\n", "trainer.fit(solver)" ] @@ -594,11 +592,12 @@ "optim = tp.OptimizerSetting(optimizer_class=torch.optim.Adam, lr=learning_rate)\n", "solver = tp.solver.Solver(train_conditions=[data_condition_fcn], optimizer_setting=optim)\n", "\n", - "\n", - "trainer = pl.Trainer(gpus=1,\n", - " max_steps=train_iterations,\n", - " logger=False,\n", - " benchmark=True)\n", + "trainer = pl.Trainer(devices=1, accelerator=\"gpu\",\n", + " num_sanity_val_steps=0,\n", + " benchmark=True,\n", + " max_steps=train_iterations, \n", + " logger=False, \n", + " enable_checkpointing=False)\n", " \n", "trainer.fit(solver)" ] diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index d1de7415..00000000 --- a/requirements.txt +++ /dev/null @@ -1,10 +0,0 @@ -protobuf~=3.19.0 # fix github test -torch>=1.7.1 -pytorch-lightning>=1.3.4 -numpy>=1.20.2 -matplotlib>=3.4.2 -trimesh>=3.9.19 -shapely>=1.7.1 -rtree>=0.9.7 -scipy>=1.6.3 -networkx>=2.5.1 diff --git a/setup.cfg b/setup.cfg index 48f78f93..7f36c77f 100644 --- a/setup.cfg +++ b/setup.cfg @@ -46,12 +46,16 @@ package_dir = # new major versions. This works if the required packages follow Semantic Versioning. # For more information, check out https://semver.org/. install_requires = - torch>=1.7.1,<2.0.0 - pytorch-lightning>=1.3.4,<2.0.0 - numpy>=1.20.2 + torch>=2.0.0, <2.4 + pytorch-lightning>=2.0.0 + numpy>=1.20.2, <2.0 matplotlib>=3.0.0 scipy>=1.6.3 - importlib-metadata; python_version<"3.8" + importlib-metadata + trimesh>=3.9.19 + shapely>=1.7.1 + rtree>=0.9.7 + jupyter [options.packages.find] where = src @@ -65,9 +69,6 @@ exclude = # Add here additional requirements for extra features, to install with: # `pip install torchphysics[all]` like: all = - trimesh>=3.9.19 - shapely>=1.7.1 - rtree>=0.9.7 networkx>=2.5.1 # Add here test requirements (semicolon/line-separated) diff --git a/src/torchphysics/models/FNO.py b/src/torchphysics/models/FNO.py new file mode 100644 index 00000000..b1fae520 --- /dev/null +++ b/src/torchphysics/models/FNO.py @@ -0,0 +1,90 @@ +import torch +import torch.nn as nn +from .model import Model +from ..problem.spaces import Points + + +class _FourierLayer(nn.Model): + """Implements a single fourier layer of the FNO from [1]. Is of the form: + + Parameters + ---------- + mode_num : int, tuple + The number of modes that should be used. For resolutions with higher + frequenzies, the layer will discard everything above `mode_num` and + in the inverse Fourier transform append zeros. In higher dimensional + data, a tuple can be passed in with len(mode_num) = dimension. + in_features : int + size of each input sample. + + Notes + ----- + .. [1] + """ + + def __init__(self, mode_num, in_features, xavier_gain): + # Transform mode_num to tuple: + if isinstance(mode_num, int): + mode_num = (mode_num,) + + super().__init__() + self.mode_num = torch.tensor(mode_num) + self.in_features = in_features + # self.linear_weights = torch.nn.Linear(in_features=in_features, + # out_features=in_features, + # bias=False) + + self.fourier_weights = torch.nn.Parameter( + torch.empty((in_features, *self.mode_num)), dtype=torch.complex32 + ) + torch.nn.init.xavier_normal_(self.fourier_weights, gain=xavier_gain) + + def forward(self, points): + ### Linear skip connection + # linear_out = self.linear_weights(points) + ### Fourier part + # Computing how much each dimension has to cut/padded: + # Here we need that points.shape = (batch, data_dim, resolution) + padding = torch.zeros( + 2 * len(self.mode_num), device=points.device, dtype=torch.int32 + ) + padding[1::2] = torch.flip( + (self.mode_num - torch.tensor(points.shape[2:])), dims=(0,) + ) + fft = torch.nn.functional.pad( + torch.fft.fftn(points, dim=len(self.mode_num), norm="ortho"), + padding.tolist(), + ) # here remove to high freq. + weighted_fft = self.fourier_weights * fft + ifft = torch.fft.ifftn( + torch.nn.functional.pad( + weighted_fft, (-padding).tolist() + ), # here add high freq. + dim=len(self.mode_num), + norm="ortho", + ) + ### Connect linear and fourier output + return ifft + + @property + def in_features(self): + return self.in_features + + @property + def out_features(self): + return self.in_features + + +class FNO(Model): + + def __init__( + self, + input_space, + output_space, + upscale_size, + fourier_layers, + fourier_modes, + activations, + xavier_gains, + ): + super().__init__(input_space, output_space) diff --git a/src/torchphysics/models/__init__.py b/src/torchphysics/models/__init__.py index 4ba520e1..3a6fca30 100644 --- a/src/torchphysics/models/__init__.py +++ b/src/torchphysics/models/__init__.py @@ -11,15 +11,14 @@ """ from .parameter import Parameter -from .model import (Model, NormalizationLayer, AdaptiveWeightLayer, - Sequential, Parallel) +from .model import Model, NormalizationLayer, AdaptiveWeightLayer, Sequential, Parallel from .fcn import FCN, Harmonic_FCN from .deepritz import DeepRitzNet from .qres import QRES -from .activation_fn import (AdaptiveActivationFunction, ReLUn, Sinus) +from .activation_fn import AdaptiveActivationFunction, ReLUn, Sinus # DeepONet: from .deeponet.deeponet import DeepONet -from .deeponet.branchnets import (BranchNet, FCBranchNet, ConvBranchNet1D) -from .deeponet.trunknets import (TrunkNet, FCTrunkNet) -from .deeponet.layers import TrunkLinear \ No newline at end of file +from .deeponet.branchnets import BranchNet, FCBranchNet, ConvBranchNet1D +from .deeponet.trunknets import TrunkNet, FCTrunkNet +from .deeponet.layers import TrunkLinear diff --git a/src/torchphysics/models/activation_fn.py b/src/torchphysics/models/activation_fn.py index a266dd96..44489797 100644 --- a/src/torchphysics/models/activation_fn.py +++ b/src/torchphysics/models/activation_fn.py @@ -25,6 +25,7 @@ class AdaptiveActivationFunction(nn.Module): "Adaptive activation functions accelerate convergence in deep and physics-informed neural networks", 2020 """ + def __init__(self, activation_fn, inital_a=1.0, scaling=1.0): super().__init__() self.activation_fn = activation_fn @@ -32,7 +33,7 @@ def __init__(self, activation_fn, inital_a=1.0, scaling=1.0): self.scaling = scaling def forward(self, x): - return self.activation_fn(self.scaling*self.a*x) + return self.activation_fn(self.scaling * self.a * x) class relu_n(torch.autograd.Function): @@ -41,17 +42,17 @@ class relu_n(torch.autograd.Function): def forward(ctx, x, n): ctx.save_for_backward(x) ctx.n = n - return torch.nn.functional.relu(x)**n + return torch.nn.functional.relu(x) ** n @staticmethod def backward(ctx, grad_output): - input, = ctx.saved_tensors + (input,) = ctx.saved_tensors n = ctx.n grad_input = grad_output.clone() slice_idx = input > 0 - grad_input[slice_idx] = grad_input[slice_idx] * n*input[slice_idx]**(n-1) + grad_input[slice_idx] = grad_input[slice_idx] * n * input[slice_idx] ** (n - 1) grad_input[torch.logical_not(slice_idx)] = 0 - return grad_input, None # <- for n gradient, not needed + return grad_input, None # <- for n gradient, not needed class ReLUn(nn.Module): @@ -64,6 +65,7 @@ class ReLUn(nn.Module): The power to which the inputs should be rasied before appplying the rectified linear unit function. """ + def __init__(self, n): super().__init__() self.n = n @@ -74,8 +76,8 @@ def forward(self, x): class Sinus(torch.nn.Module): - """Implementation of a sinus activation. - """ + """Implementation of a sinus activation.""" + def __init__(self): super().__init__() diff --git a/src/torchphysics/models/deeponet/branchnets.py b/src/torchphysics/models/deeponet/branchnets.py index 6728e894..c67efa2f 100644 --- a/src/torchphysics/models/deeponet/branchnets.py +++ b/src/torchphysics/models/deeponet/branchnets.py @@ -23,11 +23,14 @@ class BranchNet(Model): Therefore, the sampler should always return the same number of points! """ + def __init__(self, function_space, discretization_sampler): super().__init__(function_space, output_space=None) self.output_neurons = 0 self.discretization_sampler = discretization_sampler - self.input_dim = len(self.discretization_sampler) * function_space.output_space.dim + self.input_dim = ( + len(self.discretization_sampler) * function_space.output_space.dim + ) self.current_out = torch.empty(0) def finalize(self, output_space, output_neurons): @@ -46,11 +49,12 @@ def finalize(self, output_space, output_neurons): self.output_space = output_space def _reshape_multidimensional_output(self, output): - return output.reshape(-1, self.output_space.dim, - int(self.output_neurons/self.output_space.dim)) + return output.reshape( + -1, self.output_space.dim, int(self.output_neurons / self.output_space.dim) + ) @abc.abstractmethod - def forward(self, discrete_function_batch, device='cpu'): + def forward(self, discrete_function_batch, device="cpu"): """Evaluated the network at a given function batch. Should not be called directly, rather use the method ``.fix_input``. @@ -68,15 +72,14 @@ def forward(self, discrete_function_batch, device='cpu'): """ raise NotImplementedError - def _discretize_function_set(self, function_set, device='cpu'): - """Internal discretization of the training set. - """ + def _discretize_function_set(self, function_set, device="cpu"): + """Internal discretization of the training set.""" input_points = self.discretization_sampler.sample_points(device=device) - #self.input_points = input_points + # self.input_points = input_points fn_out = function_set.create_function_batch(input_points) return fn_out - def fix_input(self, function, device='cpu'): + def fix_input(self, function, device="cpu"): """Fixes the branch net for a given function. The branch net will be evaluated for the given function and the output saved in ``current_out``. @@ -100,12 +103,14 @@ def fix_input(self, function, device='cpu'): function = UserFunction(function) discrete_points = self.discretization_sampler.sample_points(device=device) discrete_fn = function(discrete_points) - discrete_fn = discrete_fn.unsqueeze(0) # add batch dimension + discrete_fn = discrete_fn.unsqueeze(0) # add batch dimension discrete_fn = Points(discrete_fn, self.input_space.output_space) elif isinstance(function, Points): # check if we have to add batch dimension if len(function._t.shape) < 3: - discrete_fn = Points(function._t.unsqueeze(0), self.input_space.output_space) + discrete_fn = Points( + function._t.unsqueeze(0), self.input_space.output_space + ) else: discrete_fn = function elif isinstance(function, torch.Tensor): @@ -116,7 +121,9 @@ def fix_input(self, function, device='cpu'): else: discrete_fn = Points(function, self.input_space.output_space) else: - raise NotImplementedError("Function has to be callable, a FunctionSet, a tensor, or a tp.Point") + raise NotImplementedError( + "Function has to be callable, a FunctionSet, a tensor, or a tp.Point" + ) self(discrete_fn) @@ -144,8 +151,15 @@ class FCBranchNet(BranchNet): For the weight initialization a Xavier/Glorot algorithm will be used. Default is 5/3. """ - def __init__(self, function_space, discretization_sampler, hidden=(20,20,20), - activations=nn.Tanh(), xavier_gains=5/3): + + def __init__( + self, + function_space, + discretization_sampler, + hidden=(20, 20, 20), + activations=nn.Tanh(), + xavier_gains=5 / 3, + ): super().__init__(function_space, discretization_sampler) self.hidden = hidden self.activations = activations @@ -153,15 +167,23 @@ def __init__(self, function_space, discretization_sampler, hidden=(20,20,20), def finalize(self, output_space, output_neurons): super().finalize(output_space, output_neurons) - layers = _construct_FC_layers(hidden=self.hidden, input_dim=self.input_dim, - output_dim=self.output_neurons, activations=self.activations, - xavier_gains=self.xavier_gains) + layers = _construct_FC_layers( + hidden=self.hidden, + input_dim=self.input_dim, + output_dim=self.output_neurons, + activations=self.activations, + xavier_gains=self.xavier_gains, + ) self.sequential = nn.Sequential(*layers) def forward(self, discrete_function_batch): - discrete_function_batch = discrete_function_batch.as_tensor.reshape(-1, self.input_dim) - self.current_out = self._reshape_multidimensional_output(self.sequential(discrete_function_batch)) + discrete_function_batch = discrete_function_batch.as_tensor.reshape( + -1, self.input_dim + ) + self.current_out = self._reshape_multidimensional_output( + self.sequential(discrete_function_batch) + ) class ConvBranchNet1D(BranchNet): @@ -200,8 +222,16 @@ class ConvBranchNet1D(BranchNet): For the weight initialization a Xavier/Glorot algorithm will be used. Default is 5/3. """ - def __init__(self, function_space, discretization_sampler, convolutional_network, - hidden=(20,20,20), activations=nn.Tanh(), xavier_gains=5/3): + + def __init__( + self, + function_space, + discretization_sampler, + convolutional_network, + hidden=(20, 20, 20), + activations=nn.Tanh(), + xavier_gains=5 / 3, + ): super().__init__(function_space, discretization_sampler) self.conv_net = convolutional_network self.hidden = hidden @@ -210,9 +240,13 @@ def __init__(self, function_space, discretization_sampler, convolutional_network def finalize(self, output_space, output_neurons): super().finalize(output_space, output_neurons) - layers = _construct_FC_layers(hidden=self.hidden, input_dim=self.input_dim, - output_dim=self.output_neurons, activations=self.activations, - xavier_gains=self.xavier_gains) + layers = _construct_FC_layers( + hidden=self.hidden, + input_dim=self.input_dim, + output_dim=self.output_neurons, + activations=self.activations, + xavier_gains=self.xavier_gains, + ) self.sequential = nn.Sequential(*layers) diff --git a/src/torchphysics/models/deeponet/deeponet.py b/src/torchphysics/models/deeponet/deeponet.py index 3d7c09b1..a8c97b9a 100644 --- a/src/torchphysics/models/deeponet/deeponet.py +++ b/src/torchphysics/models/deeponet/deeponet.py @@ -37,10 +37,10 @@ class DeepONet(Model): and George Em Karniadakis, "Learning nonlinear operators via DeepONet based on the universal approximation theorem of operators", 2021 """ + def __init__(self, trunk_net, branch_net, output_space, output_neurons): self._check_trunk_and_branch_correct(trunk_net, branch_net) - super().__init__(input_space=trunk_net.input_space, - output_space=output_space) + super().__init__(input_space=trunk_net.input_space, output_space=output_space) self.trunk = trunk_net self.branch = branch_net self._finalize_trunk_and_branch(output_space, output_neurons) @@ -61,8 +61,7 @@ def _finalize_trunk_and_branch(self, output_space, output_neurons): self.trunk.finalize(output_space, output_neurons) self.branch.finalize(output_space, output_neurons) - - def forward(self, trunk_inputs, branch_inputs=None, device='cpu'): + def forward(self, trunk_inputs, branch_inputs=None, device="cpu"): """Apply the network to the given inputs. Parameters @@ -85,20 +84,21 @@ def forward(self, trunk_inputs, branch_inputs=None, device='cpu'): self.fix_branch_input(branch_inputs, device=device) trunk_out = self.trunk(trunk_inputs) if len(trunk_out.shape) < 4: - trunk_out = trunk_out.unsqueeze(0) # shape = [1, trunk_n, dim, neurons] + trunk_out = trunk_out.unsqueeze(0) # shape = [1, trunk_n, dim, neurons] out = torch.sum(trunk_out * self.branch.current_out.unsqueeze(1), dim=-1) return Points(out, self.output_space) - def _forward_branch(self, function_set, iteration_num=-1, device='cpu'): - """Branch evaluation for training. - """ + def _forward_branch(self, function_set, iteration_num=-1, device="cpu"): + """Branch evaluation for training.""" if iteration_num != function_set.current_iteration_num: function_set.current_iteration_num = iteration_num function_set.sample_params(device=device) - discrete_fn_batch = self.branch._discretize_function_set(function_set, device=device) + discrete_fn_batch = self.branch._discretize_function_set( + function_set, device=device + ) self.branch(discrete_fn_batch) - def fix_branch_input(self, function, device='cpu'): + def fix_branch_input(self, function, device="cpu"): """Fixes the branch net for a given function. this function will then be used in every following forward call. To set a new function just call this method again. diff --git a/src/torchphysics/models/deeponet/layers.py b/src/torchphysics/models/deeponet/layers.py index 362934c5..ab158601 100644 --- a/src/torchphysics/models/deeponet/layers.py +++ b/src/torchphysics/models/deeponet/layers.py @@ -12,11 +12,11 @@ def forward(ctx, input, weight, bias=None): n_inputs = input.shape[0] input = input[0] ctx.save_for_backward(input, weight, bias) - output = input.matmul(weight.transpose(-1,-2)) + output = input.matmul(weight.transpose(-1, -2)) if bias is not None: output += bias.unsqueeze(0).expand_as(output) # reshape to the larger shape - size = [n_inputs] + len(output.shape)*[-1] + size = [n_inputs] + len(output.shape) * [-1] return output.expand(*size) @staticmethod @@ -27,12 +27,13 @@ def backward(ctx, grad_output): if ctx.needs_input_grad[0]: grad_input = grad_output.matmul(weight) if ctx.needs_input_grad[1]: - grad_weight = grad_output.transpose(-1,-2).matmul(input) + grad_weight = grad_output.transpose(-1, -2).matmul(input) if bias is not None and ctx.needs_input_grad[2]: - grad_bias = grad_output.reshape(-1,bias.shape[-1]).sum(0) + grad_bias = grad_output.reshape(-1, bias.shape[-1]).sum(0) return grad_input, grad_weight, grad_bias + class TrunkLinear(torch.nn.Module): """Applies a linear transformation to the incoming data: :math:`y = xA^T + b`, similar to torch.nn.Linear, but assumes the input `x` to be identical along the first batch axis, @@ -65,19 +66,28 @@ class TrunkLinear(torch.nn.Module): torch.Size([128, 30]) """ - __constants__ = ['in_features', 'out_features'] - def __init__(self, in_features: int, out_features: int, bias: bool = True, - device=None, dtype=None) -> None: - factory_kwargs = {'device': device, 'dtype': dtype} + __constants__ = ["in_features", "out_features"] + + def __init__( + self, + in_features: int, + out_features: int, + bias: bool = True, + device=None, + dtype=None, + ) -> None: + factory_kwargs = {"device": device, "dtype": dtype} super(TrunkLinear, self).__init__() self.in_features = in_features self.out_features = out_features - self.weight = torch.nn.Parameter(torch.empty((out_features, in_features), **factory_kwargs)) + self.weight = torch.nn.Parameter( + torch.empty((out_features, in_features), **factory_kwargs) + ) if bias: self.bias = torch.nn.Parameter(torch.empty(out_features, **factory_kwargs)) else: - self.register_parameter('bias', None) + self.register_parameter("bias", None) self.reset_parameters() def reset_parameters(self) -> None: @@ -94,6 +104,6 @@ def forward(self, input: torch.Tensor) -> torch.Tensor: return linear.apply(input, self.weight, self.bias) def extra_repr(self) -> str: - return 'in_features={}, out_features={}, bias={}'.format( + return "in_features={}, out_features={}, bias={}".format( self.in_features, self.out_features, self.bias is not None ) diff --git a/src/torchphysics/models/deeponet/trunknets.py b/src/torchphysics/models/deeponet/trunknets.py index 67858741..b950ceeb 100644 --- a/src/torchphysics/models/deeponet/trunknets.py +++ b/src/torchphysics/models/deeponet/trunknets.py @@ -23,6 +23,7 @@ class TrunkNet(Model): behavior. """ + def __init__(self, input_space, trunk_input_copied=True): super().__init__(input_space, output_space=None) self.output_neurons = 0 @@ -48,16 +49,19 @@ def finalize(self, output_space, output_neurons): def _reshape_multidimensional_output(self, output): if len(output.shape) == 3: - return output.reshape(output.shape[0], output.shape[1], self.output_space.dim, - int(self.output_neurons/self.output_space.dim)) - return output.reshape(-1, self.output_space.dim, - int(self.output_neurons/self.output_space.dim)) - + return output.reshape( + output.shape[0], + output.shape[1], + self.output_space.dim, + int(self.output_neurons / self.output_space.dim), + ) + return output.reshape( + -1, self.output_space.dim, int(self.output_neurons / self.output_space.dim) + ) def construct_FC_trunk_layers(hidden, input_dim, output_dim, activations, xavier_gains): - """Constructs the layer structure for a fully connected neural network. - """ + """Constructs the layer structure for a fully connected neural network.""" if not isinstance(activations, (list, tuple)): activations = len(hidden) * [activations] if not isinstance(xavier_gains, (list, tuple)): @@ -67,10 +71,10 @@ def construct_FC_trunk_layers(hidden, input_dim, output_dim, activations, xavier layers.append(TrunkLinear(input_dim, hidden[0])) torch.nn.init.xavier_normal_(layers[-1].weight, gain=xavier_gains[0]) layers.append(activations[0]) - for i in range(len(hidden)-1): - layers.append(TrunkLinear(hidden[i], hidden[i+1])) - torch.nn.init.xavier_normal_(layers[-1].weight, gain=xavier_gains[i+1]) - layers.append(activations[i+1]) + for i in range(len(hidden) - 1): + layers.append(TrunkLinear(hidden[i], hidden[i + 1])) + torch.nn.init.xavier_normal_(layers[-1].weight, gain=xavier_gains[i + 1]) + layers.append(activations[i + 1]) layers.append(TrunkLinear(hidden[-1], output_dim)) torch.nn.init.xavier_normal_(layers[-1].weight, gain=1) return layers @@ -94,25 +98,39 @@ class FCTrunkNet(TrunkNet): For the weight initialization a Xavier/Glorot algorithm will be used. Default is 5/3. """ - def __init__(self, input_space, hidden=(20,20,20), activations=nn.Tanh(), xavier_gains=5/3, - trunk_input_copied=True): + + def __init__( + self, + input_space, + hidden=(20, 20, 20), + activations=nn.Tanh(), + xavier_gains=5 / 3, + trunk_input_copied=True, + ): super().__init__(input_space, trunk_input_copied=trunk_input_copied) self.hidden = hidden self.activations = activations self.xavier_gains = xavier_gains - def finalize(self, output_space, output_neurons): super().finalize(output_space, output_neurons) # special layer architecture is used if trunk data is copied -> faster training if self.trunk_input_copied: - layers = construct_FC_trunk_layers(hidden=self.hidden, input_dim=self.input_space.dim, - output_dim=self.output_neurons, activations=self.activations, - xavier_gains=self.xavier_gains) + layers = construct_FC_trunk_layers( + hidden=self.hidden, + input_dim=self.input_space.dim, + output_dim=self.output_neurons, + activations=self.activations, + xavier_gains=self.xavier_gains, + ) else: - layers = _construct_FC_layers(hidden=self.hidden, input_dim=self.input_space.dim, - output_dim=self.output_neurons, activations=self.activations, - xavier_gains=self.xavier_gains) + layers = _construct_FC_layers( + hidden=self.hidden, + input_dim=self.input_space.dim, + output_dim=self.output_neurons, + activations=self.activations, + xavier_gains=self.xavier_gains, + ) self.sequential = nn.Sequential(*layers) diff --git a/src/torchphysics/models/deepritz.py b/src/torchphysics/models/deepritz.py index b2acddf9..08f1b175 100644 --- a/src/torchphysics/models/deepritz.py +++ b/src/torchphysics/models/deepritz.py @@ -3,6 +3,7 @@ from .model import Model from ..problem.spaces import Points + class DeepRitzNet(Model): """ Implementation of the architecture used in the Deep Ritz paper [1]_. @@ -24,6 +25,7 @@ class DeepRitzNet(Model): .. [#] Weinan E and Bing Yu, "The Deep Ritz method: A deep learning-based numerical algorithm for solving variational problems", 2017 """ + def __init__(self, input_space, output_space, width, depth): super().__init__(input_space, output_space) self.width = width @@ -39,10 +41,10 @@ def __init__(self, input_space, output_space, width, depth): def forward(self, x): x = self._fix_points_order(x) - x = self.linearIn(x) # Match input dimension of network - for (layer1,layer2) in zip(self.linear1, self.linear2): - x_temp = torch.relu(layer1(x)**3) - x_temp = torch.relu(layer2(x_temp)**3) + x = self.linearIn(x) # Match input dimension of network + for layer1, layer2 in zip(self.linear1, self.linear2): + x_temp = torch.relu(layer1(x) ** 3) + x_temp = torch.relu(layer2(x_temp) ** 3) x = x_temp + x return Points(self.linearOut(x), self.output_space) diff --git a/src/torchphysics/models/fcn.py b/src/torchphysics/models/fcn.py index c9f2f207..30b896d7 100644 --- a/src/torchphysics/models/fcn.py +++ b/src/torchphysics/models/fcn.py @@ -7,8 +7,7 @@ def _construct_FC_layers(hidden, input_dim, output_dim, activations, xavier_gains): - """Constructs the layer structure for a fully connected neural network. - """ + """Constructs the layer structure for a fully connected neural network.""" if not isinstance(activations, (list, tuple)): activations = len(hidden) * [activations] if not isinstance(xavier_gains, (list, tuple)): @@ -18,10 +17,10 @@ def _construct_FC_layers(hidden, input_dim, output_dim, activations, xavier_gain layers.append(nn.Linear(input_dim, hidden[0])) torch.nn.init.xavier_normal_(layers[-1].weight, gain=xavier_gains[0]) layers.append(activations[0]) - for i in range(len(hidden)-1): - layers.append(nn.Linear(hidden[i], hidden[i+1])) - torch.nn.init.xavier_normal_(layers[-1].weight, gain=xavier_gains[i+1]) - layers.append(activations[i+1]) + for i in range(len(hidden) - 1): + layers.append(nn.Linear(hidden[i], hidden[i + 1])) + torch.nn.init.xavier_normal_(layers[-1].weight, gain=xavier_gains[i + 1]) + layers.append(activations[i + 1]) layers.append(nn.Linear(hidden[-1], output_dim)) torch.nn.init.xavier_normal_(layers[-1].weight, gain=1) return layers @@ -52,17 +51,24 @@ class FCN(Model): The gain can be specified over this value. Default is 5/3. """ - def __init__(self, - input_space, - output_space, - hidden=(20,20,20), - activations=nn.Tanh(), - xavier_gains=5/3): + + def __init__( + self, + input_space, + output_space, + hidden=(20, 20, 20), + activations=nn.Tanh(), + xavier_gains=5 / 3, + ): super().__init__(input_space, output_space) - layers = _construct_FC_layers(hidden=hidden, input_dim=self.input_space.dim, - output_dim=self.output_space.dim, - activations=activations, xavier_gains=xavier_gains) + layers = _construct_FC_layers( + hidden=hidden, + input_dim=self.input_space.dim, + output_dim=self.output_space.dim, + activations=activations, + xavier_gains=xavier_gains, + ) self.sequential = nn.Sequential(*layers) @@ -115,17 +121,28 @@ class Harmonic_FCN(Model): "Fourier Features Let Networks Learn High Frequency Functions in Low Dimensional Domains", 2020 """ - def __init__(self, input_space, output_space, max_frequenz : int, - hidden=(20,20,20), min_frequenz : int = 0, - activations=nn.Tanh(), xavier_gains=5/3): + + def __init__( + self, + input_space, + output_space, + max_frequenz: int, + hidden=(20, 20, 20), + min_frequenz: int = 0, + activations=nn.Tanh(), + xavier_gains=5 / 3, + ): assert max_frequenz > min_frequenz, "used max frequenz has to be > min frequenz" super().__init__(input_space, output_space) self.max_frequenz = max_frequenz self.min_frequenz = min_frequenz - layers = _construct_FC_layers(hidden=hidden, - input_dim=(2*(max_frequenz-min_frequenz)+1) * self.input_space.dim, - output_dim=self.output_space.dim, - activations=activations, xavier_gains=xavier_gains) + layers = _construct_FC_layers( + hidden=hidden, + input_dim=(2 * (max_frequenz - min_frequenz) + 1) * self.input_space.dim, + output_dim=self.output_space.dim, + activations=activations, + xavier_gains=xavier_gains, + ) self.sequential = nn.Sequential(*layers) @@ -133,7 +150,7 @@ def forward(self, points): points = self._fix_points_order(points).as_tensor points_list = [points] for i in range(self.min_frequenz, self.max_frequenz): - points_list.append(torch.cos((i+1) * math.pi * points)) - points_list.append(torch.sin((i+1) * math.pi * points)) + points_list.append(torch.cos((i + 1) * math.pi * points)) + points_list.append(torch.sin((i + 1) * math.pi * points)) points = torch.cat(points_list, dim=-1) return Points(self.sequential(points), self.output_space) diff --git a/src/torchphysics/models/model.py b/src/torchphysics/models/model.py index 3274a8e1..c081ba56 100644 --- a/src/torchphysics/models/model.py +++ b/src/torchphysics/models/model.py @@ -14,6 +14,7 @@ class Model(nn.Module): output_space : Space The space of the points returned by this model. """ + def __init__(self, input_space, output_space): super().__init__() self.input_space = input_space @@ -22,8 +23,10 @@ def __init__(self, input_space, output_space): def _fix_points_order(self, points): if points.space != self.input_space: if points.space.keys() != self.input_space.keys(): - raise ValueError(f"""Points are in {points.space} but should lie - in {self.input_space}.""") + raise ValueError( + f"""Points are in {points.space} but should lie + in {self.input_space}.""" + ) points = points[..., list(self.input_space.keys())] return points @@ -39,6 +42,7 @@ class NormalizationLayer(Model): The domain from which this layer expects sampled points. The layer will use its bounding box to compute the normalization factors. """ + def __init__(self, domain): super().__init__(input_space=domain.space, output_space=domain.space) self.normalize = nn.Linear(domain.space.dim, domain.space.dim) @@ -52,10 +56,10 @@ def __init__(self, domain): bias = [] for i in range(domain.dim): diag.append(maxs[i] - mins[i]) - bias.append((maxs[i] + mins[i])/2) + bias.append((maxs[i] + mins[i]) / 2) - diag = 2./torch.tensor(diag) - bias = -torch.tensor(bias)*diag + diag = 2.0 / torch.tensor(diag) + bias = -torch.tensor(bias) * diag with torch.no_grad(): self.normalize.weight.copy_(torch.diag(diag)) self.normalize.bias.copy_(bias) @@ -77,6 +81,7 @@ class Parallel(Model): The models are not allowed to have the same output spaces, but can have the same input spaces. """ + def __init__(self, *models): input_space = Space({}) output_space = Space({}) @@ -93,6 +98,7 @@ def forward(self, points): out.append(model(points[..., list(model.input_space.keys())])) return Points.joined(*out) + class Sequential(Model): """A model that wraps multiple models which should be applied sequentially. @@ -104,6 +110,7 @@ class Sequential(Model): To work correcty the output of the i-th model has to fit the input of the i+1-th model. """ + def __init__(self, *models): super().__init__(models[0].input_space, models[-1].output_space) self.models = nn.ModuleList(models) @@ -131,6 +138,7 @@ class AdaptiveWeightLayer(nn.Module): .. [#] L. McClenny, "Self-Adaptive Physics-Informed Neural Networks using a Soft Attention Mechanism", 2020. """ + class GradReverse(torch.autograd.Function): @staticmethod def forward(ctx, x): @@ -146,10 +154,8 @@ def grad_reverse(cls, x): def __init__(self, n): super().__init__() - self.weight = torch.nn.Parameter( - torch.ones(n) - ) + self.weight = torch.nn.Parameter(torch.ones(n)) def forward(self, points): weight = self.grad_reverse(self.weight) - return weight*points + return weight * points diff --git a/src/torchphysics/models/parameter.py b/src/torchphysics/models/parameter.py index ca4be26f..5d385889 100644 --- a/src/torchphysics/models/parameter.py +++ b/src/torchphysics/models/parameter.py @@ -5,13 +5,13 @@ class Parameter(Points): """A parameter that is part of the problem and can be learned during training. - + Parameters ---------- init : number, list, array or tensor The inital guess for the parameter. space : torchphysics.problem.spaces.Space - The Space to which this parameter belongs. Essentially defines the + The Space to which this parameter belongs. Essentially defines the shape of the parameter, e.g for a single number use R1. Notes @@ -20,11 +20,12 @@ class Parameter(Points): condition. If many different parameters are used they have to be connected over .join(), see the Points-Class for the exact usage. - If the domains itself should depend on some parameters or the solution sholud be + If the domains itself should depend on some parameters or the solution sholud be learned for different parameter values, this class should NOT be used. These parameters are mostly meant for inverse problems. - Instead, the parameters have to be defined with their own domain and samplers. + Instead, the parameters have to be defined with their own domain and samplers. """ + def __init__(self, init, space, **kwargs): init = torch.as_tensor(init).float().reshape(1, -1) data = torch.nn.Parameter(init) diff --git a/src/torchphysics/models/qres.py b/src/torchphysics/models/qres.py index 7c01faf2..27b22b0d 100644 --- a/src/torchphysics/models/qres.py +++ b/src/torchphysics/models/qres.py @@ -21,18 +21,20 @@ class Quadratic(nn.Module): The gain can be specified over this value. Default is 5/3. """ + def __init__(self, in_features, out_features, xavier_gains): super().__init__() - bias = torch.nn.init.xavier_normal_(torch.zeros(1, out_features), - gain=xavier_gains) + bias = torch.nn.init.xavier_normal_( + torch.zeros(1, out_features), gain=xavier_gains + ) self.bias = torch.nn.Parameter(bias) - self.linear_weights = torch.nn.Linear(in_features=in_features, - out_features=out_features, - bias=False) + self.linear_weights = torch.nn.Linear( + in_features=in_features, out_features=out_features, bias=False + ) torch.nn.init.xavier_normal_(self.linear_weights.weight, gain=xavier_gains) - self.quadratic_weights = torch.nn.Linear(in_features=in_features, - out_features=out_features, - bias=False) + self.quadratic_weights = torch.nn.Linear( + in_features=in_features, out_features=out_features, bias=False + ) torch.nn.init.xavier_normal_(self.quadratic_weights.weight, gain=xavier_gains) def forward(self, points): @@ -83,12 +85,15 @@ class QRES(Model): A New Class of Neural Networks for Solving Forward and Inverse Problems in Physics Involving PDEs", 2021 """ - def __init__(self, - input_space, - output_space, - hidden=(20,20,20), - activations=nn.Tanh(), - xavier_gains=5/3): + + def __init__( + self, + input_space, + output_space, + hidden=(20, 20, 20), + activations=nn.Tanh(), + xavier_gains=5 / 3, + ): super().__init__(input_space, output_space) if not isinstance(activations, (list, tuple)): @@ -99,9 +104,9 @@ def __init__(self, layers = [] layers.append(Quadratic(self.input_space.dim, hidden[0], xavier_gains[0])) layers.append(activations[0]) - for i in range(len(hidden)-1): - layers.append(Quadratic(hidden[i], hidden[i+1], xavier_gains[i+1])) - layers.append(activations[i+1]) + for i in range(len(hidden) - 1): + layers.append(Quadratic(hidden[i], hidden[i + 1], xavier_gains[i + 1])) + layers.append(activations[i + 1]) layers.append(Quadratic(hidden[-1], self.output_space.dim, 1.0)) self.sequential = nn.Sequential(*layers) diff --git a/src/torchphysics/problem/conditions/__init__.py b/src/torchphysics/problem/conditions/__init__.py index 09a3a4c7..146282aa 100644 --- a/src/torchphysics/problem/conditions/__init__.py +++ b/src/torchphysics/problem/conditions/__init__.py @@ -7,17 +7,24 @@ .. _here: https://boschresearch.github.io/torchphysics/tutorial/tutorial_start.html """ -from .condition import (Condition, - PINNCondition, - DataCondition, - DeepRitzCondition, - ParameterCondition, - MeanCondition, - AdaptiveWeightsCondition, - SingleModuleCondition, - PeriodicCondition, - IntegroPINNCondition) +from .condition import ( + Condition, + PINNCondition, + DataCondition, + DeepRitzCondition, + ParameterCondition, + MeanCondition, + AdaptiveWeightsCondition, + SingleModuleCondition, + PeriodicCondition, + IntegroPINNCondition, + HPM_EquationLoss_at_DataPoints, + HPM_EquationLoss_at_Sampler, + HPCMCondition, +) -from .deeponet_condition import (DeepONetSingleModuleCondition, - PIDeepONetCondition, - DeepONetDataCondition) \ No newline at end of file +from .deeponet_condition import ( + DeepONetSingleModuleCondition, + PIDeepONetCondition, + DeepONetDataCondition, +) diff --git a/src/torchphysics/problem/conditions/condition.py b/src/torchphysics/problem/conditions/condition.py index 02d06e20..9e98a47c 100644 --- a/src/torchphysics/problem/conditions/condition.py +++ b/src/torchphysics/problem/conditions/condition.py @@ -51,7 +51,7 @@ def __init__(self, name=None, weight=1.0, track_gradients=True): self.track_gradients = track_gradients @abc.abstractmethod - def forward(self, device='cpu', iteration=None): + def forward(self, device="cpu", iteration=None): """ The forward run performed by this condition. @@ -69,13 +69,14 @@ def _setup_data_functions(self, data_functions, sampler): for fun in data_functions: points = sampler.sample_points() data_fun_points = data_functions[fun](points) - #self.register_buffer(fun, data_fun_points) + # self.register_buffer(fun, data_fun_points) data_functions[fun] = UserFunction(data_fun_points) return data_functions def _move_static_data(self, device): pass + class DataCondition(Condition): """ A condition that fits a single given module to data (handed through a PyTorch @@ -111,9 +112,17 @@ class DataCondition(Condition): training. """ - def __init__(self, module, dataloader, norm, root=1., use_full_dataset=False, - name='datacondition', constrain_fn = None, - weight=1.0): + def __init__( + self, + module, + dataloader, + norm, + root=1.0, + use_full_dataset=False, + name="datacondition", + constrain_fn=None, + weight=1.0, + ): super().__init__(name=name, weight=weight, track_gradients=False) self.module = module self.dataloader = dataloader @@ -134,15 +143,15 @@ def _compute_dist(self, batch, device): model_out = model_out.as_tensor return torch.abs(model_out - y.as_tensor) - def forward(self, device='cpu', iteration=None): + def forward(self, device="cpu", iteration=None): if self.use_full_dataset: loss = torch.zeros(1, requires_grad=True, device=device) for batch in iter(self.dataloader): a = self._compute_dist(batch, device) - if self.norm == 'inf': + if self.norm == "inf": loss = torch.maximum(loss, torch.max(a)) else: - loss = loss + torch.mean(a**self.norm)/len(self.dataloader) + loss = loss + torch.mean(a**self.norm) / len(self.dataloader) else: try: batch = next(self.iterator) @@ -150,12 +159,12 @@ def forward(self, device='cpu', iteration=None): self.iterator = iter(self.dataloader) batch = next(self.iterator) a = self._compute_dist(batch, device) - if self.norm == 'inf': + if self.norm == "inf": loss = torch.max(a) else: loss = torch.mean(a**self.norm) if self.root != 1.0: - loss = loss**(1/self.root) + loss = loss ** (1 / self.root) return loss @@ -176,13 +185,13 @@ class ParameterCondition(Condition): The name of this condition which will be monitored in logging. """ - def __init__(self, parameter, penalty, weight, name='parametercondition'): + def __init__(self, parameter, penalty, weight, name="parametercondition"): super().__init__(name=name, weight=weight, track_gradients=False) self.parameter = parameter - self.register_parameter(name + '_params', self.parameter.as_tensor) + self.register_parameter(name + "_params", self.parameter.as_tensor) self.penalty = UserFunction(penalty) - def forward(self, device='cpu', iteration=None): + def forward(self, device="cpu", iteration=None): return self.penalty(self.parameter.coordinates) @@ -223,13 +232,23 @@ class SingleModuleCondition(Condition): training. """ - def __init__(self, module, sampler, residual_fn, error_fn, reduce_fn=torch.mean, - name='singlemodulecondition', track_gradients=True, data_functions={}, - parameter=Parameter.empty(), weight=1.0): + def __init__( + self, + module, + sampler, + residual_fn, + error_fn, + reduce_fn=torch.mean, + name="singlemodulecondition", + track_gradients=True, + data_functions={}, + parameter=Parameter.empty(), + weight=1.0, + ): super().__init__(name=name, weight=weight, track_gradients=track_gradients) self.module = module self.parameter = parameter - self.register_parameter(name + '_params', self.parameter.as_tensor) + self.register_parameter(name + "_params", self.parameter.as_tensor) self.sampler = sampler self.residual_fn = UserFunction(residual_fn) self.error_fn = error_fn @@ -239,10 +258,11 @@ def __init__(self, module, sampler, residual_fn, error_fn, reduce_fn=torch.mean, if self.sampler.is_adaptive: self.last_unreduced_loss = None - def forward(self, device='cpu', iteration=None): + def forward(self, device="cpu", iteration=None): if self.sampler.is_adaptive: - x = self.sampler.sample_points(unreduced_loss=self.last_unreduced_loss, - device=device) + x = self.sampler.sample_points( + unreduced_loss=self.last_unreduced_loss, device=device + ) self.last_unreduced_loss = None else: x = self.sampler.sample_points(device=device) @@ -255,10 +275,11 @@ def forward(self, device='cpu', iteration=None): y = self.module(x) - unreduced_loss = self.error_fn(self.residual_fn({**y.coordinates, - **x_coordinates, - **self.parameter.coordinates, - **data})) + unreduced_loss = self.error_fn( + self.residual_fn( + {**y.coordinates, **x_coordinates, **self.parameter.coordinates, **data} + ) + ) if self.sampler.is_adaptive: self.last_unreduced_loss = unreduced_loss @@ -310,12 +331,29 @@ class MeanCondition(SingleModuleCondition): algorithm for solving variational problems", 2017 """ - def __init__(self, module, sampler, residual_fn, track_gradients=True, - data_functions={}, parameter=Parameter.empty(), name='meancondition', - weight=1.0): - super().__init__(module, sampler, residual_fn, error_fn=torch.nn.Identity(), - reduce_fn=torch.mean, name=name, track_gradients=track_gradients, - data_functions=data_functions, parameter=parameter, weight=weight) + def __init__( + self, + module, + sampler, + residual_fn, + track_gradients=True, + data_functions={}, + parameter=Parameter.empty(), + name="meancondition", + weight=1.0, + ): + super().__init__( + module, + sampler, + residual_fn, + error_fn=torch.nn.Identity(), + reduce_fn=torch.mean, + name=name, + track_gradients=track_gradients, + data_functions=data_functions, + parameter=parameter, + weight=weight, + ) class DeepRitzCondition(MeanCondition): @@ -352,11 +390,28 @@ class DeepRitzCondition(MeanCondition): .. [#] Weinan E and Bing Yu, "The Deep Ritz method: A deep learning-based numerical algorithm for solving variational problems", 2017 """ - def __init__(self, module, sampler, integrand_fn, track_gradients=True, data_functions={}, - parameter=Parameter.empty(), name='deepritzcondition', weight=1.0): - super().__init__(module, sampler, integrand_fn, track_gradients=track_gradients, - data_functions=data_functions, parameter=parameter, name=name, - weight=weight) + + def __init__( + self, + module, + sampler, + integrand_fn, + track_gradients=True, + data_functions={}, + parameter=Parameter.empty(), + name="deepritzcondition", + weight=1.0, + ): + super().__init__( + module, + sampler, + integrand_fn, + track_gradients=track_gradients, + data_functions=data_functions, + parameter=parameter, + name=name, + weight=weight, + ) class PINNCondition(SingleModuleCondition): @@ -398,12 +453,29 @@ class PINNCondition(SingleModuleCondition): equations", Journal of Computational Physics, vol. 378, pp. 686-707, 2019. """ - def __init__(self, module, sampler, residual_fn, track_gradients=True, - data_functions={}, parameter=Parameter.empty(), name='pinncondition', - weight=1.0): - super().__init__(module, sampler, residual_fn, error_fn=SquaredError(), - reduce_fn=torch.mean, name=name, track_gradients=track_gradients, - data_functions=data_functions, parameter=parameter, weight=weight) + def __init__( + self, + module, + sampler, + residual_fn, + track_gradients=True, + data_functions={}, + parameter=Parameter.empty(), + name="pinncondition", + weight=1.0, + ): + super().__init__( + module, + sampler, + residual_fn, + error_fn=SquaredError(), + reduce_fn=torch.mean, + name=name, + track_gradients=track_gradients, + data_functions=data_functions, + parameter=parameter, + weight=weight, + ) class PeriodicCondition(Condition): @@ -449,14 +521,24 @@ class PeriodicCondition(Condition): training. """ - def __init__(self, module, periodic_interval, residual_fn, - non_periodic_sampler=EmptySampler(), error_fn=SquaredError(), - reduce_fn=torch.mean, name='periodiccondition', track_gradients=True, - data_functions={}, parameter=Parameter.empty(), weight=1.0): + def __init__( + self, + module, + periodic_interval, + residual_fn, + non_periodic_sampler=EmptySampler(), + error_fn=SquaredError(), + reduce_fn=torch.mean, + name="periodiccondition", + track_gradients=True, + data_functions={}, + parameter=Parameter.empty(), + weight=1.0, + ): super().__init__(name=name, weight=weight, track_gradients=track_gradients) self.module = module self.parameter = parameter - self.register_parameter(name + '_params', self.parameter.as_tensor) + self.register_parameter(name + "_params", self.parameter.as_tensor) self.periodic_interval = periodic_interval self.non_periodic_sampler = non_periodic_sampler self.residual_fn = UserFunction(residual_fn) @@ -464,29 +546,33 @@ def __init__(self, module, periodic_interval, residual_fn, self.reduce_fn = reduce_fn n_points = max(len(self.non_periodic_sampler), 1) - self.left_sampler = GridSampler(self.periodic_interval.boundary_left, - n_points=n_points).make_static() - self.right_sampler = GridSampler(self.periodic_interval.boundary_right, - n_points=n_points).make_static() - - tmp_left_sampler = self.left_sampler*self.non_periodic_sampler - tmp_right_sampler = self.right_sampler*self.non_periodic_sampler + self.left_sampler = GridSampler( + self.periodic_interval.boundary_left, n_points=n_points + ).make_static() + self.right_sampler = GridSampler( + self.periodic_interval.boundary_right, n_points=n_points + ).make_static() + + tmp_left_sampler = self.left_sampler * self.non_periodic_sampler + tmp_right_sampler = self.right_sampler * self.non_periodic_sampler if self.non_periodic_sampler.is_static: tmp_left_sampler = tmp_left_sampler.make_static() tmp_right_sampler = tmp_right_sampler.make_static() - self.left_data_functions = self._setup_data_functions(data_functions, - tmp_left_sampler) - self.right_data_functions = self._setup_data_functions(data_functions, - tmp_right_sampler) + self.left_data_functions = self._setup_data_functions( + data_functions, tmp_left_sampler + ) + self.right_data_functions = self._setup_data_functions( + data_functions, tmp_right_sampler + ) if self.non_periodic_sampler.is_adaptive: self.last_unreduced_loss = None - def forward(self, device='cpu', iteration=None): + def forward(self, device="cpu", iteration=None): if self.non_periodic_sampler.is_adaptive: x_b = self.non_periodic_sampler.sample_points( - unreduced_loss=self.last_unreduced_loss, - device=device) + unreduced_loss=self.last_unreduced_loss, device=device + ) self.last_unreduced_loss = None else: x_b = self.non_periodic_sampler.sample_points(device=device) @@ -498,39 +584,52 @@ def forward(self, device='cpu', iteration=None): x_right_coordinates, x_right = x_right.track_coord_gradients() x_b_coordinates, x_b = x_b.track_coord_gradients() - data_left = {} data_right = {} for fun in self.left_data_functions: - data_left[fun] = self.left_data_functions[fun]({**x_left_coordinates, - **x_b_coordinates}) - data_left = {f'{k}_left': data_left[k] for k in data_left} + data_left[fun] = self.left_data_functions[fun]( + {**x_left_coordinates, **x_b_coordinates} + ) + data_left = {f"{k}_left": data_left[k] for k in data_left} for fun in self.right_data_functions: - data_right[fun] = self.right_data_functions[fun]({**x_right_coordinates, - **x_b_coordinates}) - data_right = {f'{k}_right': data_right[k] for k in data_right} + data_right[fun] = self.right_data_functions[fun]( + {**x_right_coordinates, **x_b_coordinates} + ) + data_right = {f"{k}_right": data_right[k] for k in data_right} y_left = self.module(x_left.join(x_b)) y_right = self.module(x_right.join(x_b)) y_left_coordinates = y_left.coordinates - y_left_coordinates = {f'{k}_left': y_left_coordinates[k] for k in y_left_coordinates} + y_left_coordinates = { + f"{k}_left": y_left_coordinates[k] for k in y_left_coordinates + } y_right_coordinates = y_right.coordinates - y_right_coordinates = {f'{k}_right': y_right_coordinates[k] for k in y_right_coordinates} - - - x_left_coordinates = {f'{k}_left': x_left_coordinates[k] for k in x_left_coordinates} - x_right_coordinates = {f'{k}_right': x_right_coordinates[k] for k in x_right_coordinates} - - - unreduced_loss = self.error_fn(self.residual_fn({**y_left_coordinates, - **y_right_coordinates, - **x_left_coordinates, - **x_right_coordinates, - **x_b_coordinates, - **self.parameter.coordinates, - **data_right, - **data_left})) + y_right_coordinates = { + f"{k}_right": y_right_coordinates[k] for k in y_right_coordinates + } + + x_left_coordinates = { + f"{k}_left": x_left_coordinates[k] for k in x_left_coordinates + } + x_right_coordinates = { + f"{k}_right": x_right_coordinates[k] for k in x_right_coordinates + } + + unreduced_loss = self.error_fn( + self.residual_fn( + { + **y_left_coordinates, + **y_right_coordinates, + **x_left_coordinates, + **x_right_coordinates, + **x_b_coordinates, + **self.parameter.coordinates, + **data_right, + **data_left, + } + ) + ) if self.non_periodic_sampler.is_adaptive: self.last_unreduced_loss = unreduced_loss @@ -540,11 +639,13 @@ def forward(self, device='cpu', iteration=None): def _move_static_data(self, device): if self.non_periodic_sampler.is_static: for fn in self.left_data_functions: - self.left_data_functions[fn].fun = \ - self.left_data_functions[fn].fun.to(device) + self.left_data_functions[fn].fun = self.left_data_functions[fn].fun.to( + device + ) for fn in self.right_data_functions: - self.right_data_functions[fn].fun = \ - self.right_data_functions[fn].fun.to(device) + self.right_data_functions[fn].fun = self.right_data_functions[ + fn + ].fun.to(device) class IntegroPINNCondition(Condition): @@ -588,14 +689,24 @@ class IntegroPINNCondition(Condition): training. """ - def __init__(self, module, sampler, residual_fn, - integral_sampler, error_fn=SquaredError(), - reduce_fn=torch.mean, name='periodiccondition', track_gradients=True, - data_functions={}, parameter=Parameter.empty(), weight=1.0): + def __init__( + self, + module, + sampler, + residual_fn, + integral_sampler, + error_fn=SquaredError(), + reduce_fn=torch.mean, + name="periodiccondition", + track_gradients=True, + data_functions={}, + parameter=Parameter.empty(), + weight=1.0, + ): super().__init__(name=name, weight=weight, track_gradients=track_gradients) self.module = module self.parameter = parameter - self.register_parameter(name + '_params', self.parameter.as_tensor) + self.register_parameter(name + "_params", self.parameter.as_tensor) self.residual_fn = UserFunction(residual_fn) self.error_fn = error_fn self.reduce_fn = reduce_fn @@ -603,17 +714,16 @@ def __init__(self, module, sampler, residual_fn, self.sampler = sampler self.integral_sampler = integral_sampler - self.data_functions = self._setup_data_functions(data_functions, - self.sampler) + self.data_functions = self._setup_data_functions(data_functions, self.sampler) if self.sampler.is_adaptive: self.last_unreduced_loss = None - def forward(self, device='cpu', iteration=None): + def forward(self, device="cpu", iteration=None): if self.sampler.is_adaptive: x = self.sampler.sample_points( - unreduced_loss=self.last_unreduced_loss, - device=device) + unreduced_loss=self.last_unreduced_loss, device=device + ) self.last_unreduced_loss = None else: x = self.sampler.sample_points(device=device) @@ -640,16 +750,26 @@ def forward(self, device='cpu', iteration=None): y_int = self.module(x_combined) y_int_coordinates = y_int.coordinates - y_int_coordinates = {f'{k}_integral': y_int_coordinates[k] for k in y_int_coordinates} - - x_int_coordinates = {f'{k}_integral': x_int_coordinates[k] for k in x_int_coordinates} - - unreduced_loss = self.error_fn(self.residual_fn({**y.coordinates, - **y_int_coordinates, - **x_coordinates, - **x_int_coordinates, - **self.parameter.coordinates, - **data})) + y_int_coordinates = { + f"{k}_integral": y_int_coordinates[k] for k in y_int_coordinates + } + + x_int_coordinates = { + f"{k}_integral": x_int_coordinates[k] for k in x_int_coordinates + } + + unreduced_loss = self.error_fn( + self.residual_fn( + { + **y.coordinates, + **y_int_coordinates, + **x_coordinates, + **x_int_coordinates, + **self.parameter.coordinates, + **data, + } + ) + ) if self.sampler.is_adaptive: self.last_unreduced_loss = unreduced_loss @@ -704,21 +824,306 @@ class AdaptiveWeightsCondition(SingleModuleCondition): Soft Attention Mechanism", CoRR, 2020 """ - def __init__(self, module, sampler, residual_fn, error_fn=SquaredError(), - track_gradients=True, data_functions={}, parameter=Parameter.empty(), - name='adaptive_w_condition', weight=1.0): + def __init__( + self, + module, + sampler, + residual_fn, + error_fn=SquaredError(), + track_gradients=True, + data_functions={}, + parameter=Parameter.empty(), + name="adaptive_w_condition", + weight=1.0, + ): if not sampler.is_static: - raise ValueError("Adaptive point weights should only be used with static", - "samplers.") + raise ValueError( + "Adaptive point weights should only be used with static", "samplers." + ) adaptive_layer = AdaptiveWeightLayer(len(sampler)) def adaptive_reduce_fun(x): return torch.mean(adaptive_layer(x)) - super().__init__(module, sampler, residual_fn, error_fn=error_fn, - reduce_fn=adaptive_reduce_fun, name=name, track_gradients=track_gradients, - data_functions=data_functions, parameter=parameter, weight=weight) + super().__init__( + module, + sampler, + residual_fn, + error_fn=error_fn, + reduce_fn=adaptive_reduce_fun, + name=name, + track_gradients=track_gradients, + data_functions=data_functions, + parameter=parameter, + weight=weight, + ) self.adaptive_layer = adaptive_layer + + +class HPM_EquationLoss_at_DataPoints(Condition): + """ + A condition that minimizes the mean squared error of the given residual with the help of data (handed through a PyTorch + dataloader), as required in the framework of HPM [1]. + + Parameters + ------- + module : torchphysics.Model + The torch module which should be optimized. + dataloader : torch.utils.DataLoader + A PyTorch dataloader which supplies the iterator to load data-target pairs + from some given dataset. Data and target should be handed as points in input + or output spaces, i.e. with the correct point object. + norm : int or 'inf' + The 'norm' which should be computed for evaluation. If 'inf', maximum norm will + be used. Else, the result will be taken to the n-th potency (without computing the + root!) + residual_fn : callable + A user-defined function that computes the residual (unreduced loss) from + inputs and outputs of the model, e.g. by using utils.differentialoperators + and/or domain.normal + data_functions : dict + A dictionary of user-defined functions and their names (as keys). Can be + used e.g. for right sides in PDEs or functions in boundary conditions. + track_gradients : bool + Whether gradients w.r.t. the inputs should be tracked during training or + not. Defaults to true, since this is needed to compute differential operators + in PINNs. + parameter : Parameter + A Parameter that can be used in the residual_fn and should be learned in + parallel, e.g. based on data (in an additional DataCondition). + name : str + The name of this condition which will be monitored in logging. + weight : float + The weight multiplied with the loss of this condition during + training. + + Notes + ----- + . . [1] Raissi, M. (2018). Deep hidden physics models: Deep learning of nonlinear partial differential equations. + The Journal of Machine Learning Research, 19(1), 932-955. + """ + + def __init__( + self, + module, + dataloader, + norm, + residual_fn, + error_fn=SquaredError(), + root=1.0, + use_full_dataset=False, + name="HPMcondition", + reduce_fn=torch.mean, + parameter=Parameter.empty(), + weight=1.0, + ): + super().__init__(name=name, weight=weight, track_gradients=True) + self.module = module + self.dataloader = dataloader + self.norm = norm + self.root = root + self.use_full_dataset = use_full_dataset + self.parameter = parameter + self.register_parameter(name + "_params", self.parameter.as_tensor) + self.residual_fn = UserFunction(residual_fn) + self.error_fn = error_fn + self.reduce_fn = reduce_fn + + def _compute_dist(self, batch, device): + x, y_reference = batch + x, y_reference = x.to(device), y_reference.to(device) + + x_coordinates, x = x.track_coord_gradients() + unreduced_loss = self.error_fn( + self.residual_fn({**x_coordinates, **self.parameter.coordinates}) + ) + + return self.reduce_fn(unreduced_loss) + + def forward(self, device="cpu", iteration=None): + if self.use_full_dataset: + loss = torch.zeros(1, requires_grad=True, device=device) + for batch in iter(self.dataloader): + a = self._compute_dist(batch, device) + if self.norm == "inf": + loss = torch.maximum(loss, torch.max(a)) + else: + loss = loss + torch.mean(a**self.norm) / len(self.dataloader) + else: + try: + batch = next(self.iterator) + except (StopIteration, AttributeError): + self.iterator = iter(self.dataloader) + batch = next(self.iterator) + a = self._compute_dist(batch, device) + if self.norm == "inf": + loss = torch.max(a) + else: + loss = torch.mean(a**self.norm) + if self.root != 1.0: + loss = loss ** (1 / self.root) + return loss + + def _move_static_data(self, device): + pass + + +class HPM_EquationLoss_at_Sampler(Condition): + """ + + A condition that minimizes the mean squared error of the given residual on sampled collocation points, instead of using the collocation points of the data set + as the original proposal HPM [1]. + + Parameters + ------- + module : torchphysics.Model + The torch module which should be optimized. + sampler : torchphysics.samplers.PointSampler + A sampler that creates the points in the domain of the residual function, + could be an inner or a boundary domain. + residual_fn : callable + A user-defined function that computes the residual (unreduced loss) from + inputs and outputs of the model, e.g. by using utils.differentialoperators + and/or domain.normal + data_functions : dict + A dictionary of user-defined functions and their names (as keys). Can be + used e.g. for right sides in PDEs or functions in boundary conditions. + track_gradients : bool + Whether gradients w.r.t. the inputs should be tracked during training or + not. Defaults to true, since this is needed to compute differential operators + in PINNs. + parameter : Parameter + A Parameter that can be used in the residual_fn and should be learned in + parallel, e.g. based on data (in an additional DataCondition). + name : str + The name of this condition which will be monitored in logging. + weight : float + The weight multiplied with the loss of this condition during + training. + + Notes + ----- + . . [1] Raissi, M. (2018). Deep hidden physics models: Deep learning of nonlinear partial differential equations. + The Journal of Machine Learning Research, 19(1), 932-955. + """ + + def __init__( + self, + module, + sampler, + residual_fn, + error_fn=SquaredError(), + reduce_fn=torch.mean, + name="SampleHPMCondition", + track_gradients=True, + data_functions={}, + parameter=Parameter.empty(), + weight=1.0, + ): + super().__init__(name=name, weight=weight, track_gradients=track_gradients) + + self.module = module + self.parameter = parameter + self.register_parameter(name + "_params", self.parameter.as_tensor) + self.sampler = sampler + self.residual_fn = UserFunction(residual_fn) + self.error_fn = error_fn + self.reduce_fn = reduce_fn + self.data_functions = self._setup_data_functions(data_functions, sampler) + + if self.sampler.is_adaptive: + self.last_unreduced_loss = None + + def forward(self, device="cpu", iteration=None): + if self.sampler.is_adaptive: + x = self.sampler.sample_points( + unreduced_loss=self.last_unreduced_loss, device=device + ) + self.last_unreduced_loss = None + else: + x = self.sampler.sample_points(device=device) + + x_coordinates, x = x.track_coord_gradients() + + data = {} + for fun in self.data_functions: + data[fun] = self.data_functions[fun](x_coordinates) + + unreduced_loss = self.error_fn( + self.residual_fn({**x_coordinates, **self.parameter.coordinates, **data}) + ) + + if self.sampler.is_adaptive: + self.last_unreduced_loss = unreduced_loss + + return self.reduce_fn(unreduced_loss) + + def _move_static_data(self, device): + if self.sampler.is_static: + for fn in self.data_functions: + self.data_functions[fn].fun = self.data_functions[fn].fun.to(device) + + +class HPCMCondition(Condition): + def __init__( + self, + module_state, + module_corr, + dataloader_corr, + correction_fn, + norm=2, + root=1.0, + use_full_dataset=True, + name="hpcmcondition", + weight=1.0, + ): + super().__init__(name=name, weight=weight, track_gradients=False) + self.module_state = module_state + self.module_corr = module_corr + self.dataloader = dataloader_corr + self.norm = norm + self.root = root + self.use_full_dataset = use_full_dataset + self.correction_fn = UserFunction(correction_fn) + + def _compute_dist(self, batch, device="cuda"): + x, y = batch + + x, y = x.to(device), y.to(device) + + model_state_out = self.module_state(x) + + model_corr_out = self.correction_fn( + {**model_state_out.coordinates, **x.coordinates} + ) + + return torch.abs( + model_state_out.as_tensor - y.as_tensor - model_corr_out.as_tensor + ) + + def forward(self, device="cpu", iteration=None): + if self.use_full_dataset: + loss = torch.zeros(1, requires_grad=True, device=device) + for batch in iter(self.dataloader): + a = self._compute_dist(batch, device) + if self.norm == "inf": + loss = torch.maximum(loss, torch.max(a)) + else: + loss = loss + torch.mean(a**self.norm) / len(self.dataloader) + else: + try: + batch = next(self.iterator) + except (StopIteration, AttributeError): + self.iterator = iter(self.dataloader) + batch = next(self.iterator) + a = self._compute_dist(batch, device) + if self.norm == "inf": + loss = torch.max(a) + else: + loss = torch.mean(a**self.norm) + if self.root != 1.0: + loss = loss ** (1 / self.root) + return loss diff --git a/src/torchphysics/problem/conditions/deeponet_condition.py b/src/torchphysics/problem/conditions/deeponet_condition.py index 64a2654f..ce0c3f8e 100644 --- a/src/torchphysics/problem/conditions/deeponet_condition.py +++ b/src/torchphysics/problem/conditions/deeponet_condition.py @@ -5,39 +5,58 @@ from ...utils import UserFunction from ...models import DeepONet + class DeepONetSingleModuleCondition(Condition): - def __init__(self, deeponet_model, function_set, input_sampler, residual_fn, - error_fn, reduce_fn=torch.mean, - name='singlemodulecondition', track_gradients=True, data_functions={}, - parameter=Parameter.empty(), weight=1.0): + def __init__( + self, + deeponet_model, + function_set, + input_sampler, + residual_fn, + error_fn, + reduce_fn=torch.mean, + name="singlemodulecondition", + track_gradients=True, + data_functions={}, + parameter=Parameter.empty(), + weight=1.0, + ): super().__init__(name=name, weight=weight, track_gradients=track_gradients) self.net = deeponet_model assert isinstance(self.net, DeepONet) self.function_set = function_set self.parameter = parameter - self.register_parameter(name + '_params', self.parameter.as_tensor) + self.register_parameter(name + "_params", self.parameter.as_tensor) self.input_sampler = input_sampler self.residual_fn = UserFunction(residual_fn) self.error_fn = error_fn self.reduce_fn = reduce_fn - self.data_functions = self._setup_data_functions(data_functions, self.input_sampler) - - self.eval_function_set = len( - self.function_set.function_space.output_space.variables & set(self.residual_fn.args) - ) > 0 - - - def forward(self, device='cpu', iteration=None): + self.data_functions = self._setup_data_functions( + data_functions, self.input_sampler + ) + + self.eval_function_set = ( + len( + self.function_set.function_space.output_space.variables + & set(self.residual_fn.args) + ) + > 0 + ) + + def forward(self, device="cpu", iteration=None): # 1) if necessary, sample input function and evaluate branch net - self.net._forward_branch(self.function_set, iteration_num=iteration, device=device) + self.net._forward_branch( + self.function_set, iteration_num=iteration, device=device + ) # 2) sample output points if self.input_sampler.is_adaptive: - x = self.input_sampler.sample_points(unreduced_loss=self.last_unreduced_loss, - device=device) + x = self.input_sampler.sample_points( + unreduced_loss=self.last_unreduced_loss, device=device + ) self.last_unreduced_loss = None else: x = self.input_sampler.sample_points(device=device) @@ -55,13 +74,21 @@ def forward(self, device='cpu', iteration=None): # whether the functions are part of the loss function_set_output = {} if self.eval_function_set: - function_set_output = self.function_set.create_function_batch(x[0,:,:]).coordinates - - unreduced_loss = self.error_fn(self.residual_fn({**y.coordinates, - **x_coordinates, - **function_set_output, - **self.parameter.coordinates, - **data})) + function_set_output = self.function_set.create_function_batch( + x[0, :, :] + ).coordinates + + unreduced_loss = self.error_fn( + self.residual_fn( + { + **y.coordinates, + **x_coordinates, + **function_set_output, + **self.parameter.coordinates, + **data, + } + ) + ) if self.input_sampler.is_adaptive: self.last_unreduced_loss = unreduced_loss @@ -110,14 +137,32 @@ class PIDeepONetCondition(DeepONetSingleModuleCondition): differential equations with physics-informed DeepOnets", https://arxiv.org/abs/2103.10974, 2021. """ - def __init__(self, deeponet_model, function_set, input_sampler, residual_fn, - name='pinncondition', track_gradients=True, data_functions={}, - parameter=Parameter.empty(), weight=1.0): - super().__init__(deeponet_model, function_set, input_sampler, - residual_fn=residual_fn, error_fn=SquaredError(), - reduce_fn=torch.mean, name=name, - track_gradients=track_gradients, data_functions=data_functions, - parameter=parameter, weight=weight) + + def __init__( + self, + deeponet_model, + function_set, + input_sampler, + residual_fn, + name="pinncondition", + track_gradients=True, + data_functions={}, + parameter=Parameter.empty(), + weight=1.0, + ): + super().__init__( + deeponet_model, + function_set, + input_sampler, + residual_fn=residual_fn, + error_fn=SquaredError(), + reduce_fn=torch.mean, + name=name, + track_gradients=track_gradients, + data_functions=data_functions, + parameter=parameter, + weight=weight, + ) class DeepONetDataCondition(DataCondition): @@ -155,21 +200,42 @@ class DeepONetDataCondition(DataCondition): training. """ - def __init__(self, module, dataloader, norm, constrain_fn = None, - root=1., use_full_dataset=False, name='datacondition', weight=1.0): - super().__init__(module=module, dataloader=dataloader, - norm=norm, root=root, use_full_dataset=use_full_dataset, - name=name, weight=weight, constrain_fn=constrain_fn) + def __init__( + self, + module, + dataloader, + norm, + constrain_fn=None, + root=1.0, + use_full_dataset=False, + name="datacondition", + weight=1.0, + ): + super().__init__( + module=module, + dataloader=dataloader, + norm=norm, + root=root, + use_full_dataset=use_full_dataset, + name=name, + weight=weight, + constrain_fn=constrain_fn, + ) assert isinstance(self.module, DeepONet) def _compute_dist(self, batch, device): branch_in, trunk_in, out = batch - branch_in, trunk_in, out = branch_in.to(device), trunk_in.to(device), \ - out.to(device) + branch_in, trunk_in, out = ( + branch_in.to(device), + trunk_in.to(device), + out.to(device), + ) self.module.branch(branch_in) model_out = self.module(trunk_in) if self.constrain_fn: - model_out = self.constrain_fn({**model_out.coordinates, **trunk_in.coordinates}) + model_out = self.constrain_fn( + {**model_out.coordinates, **trunk_in.coordinates} + ) else: model_out = model_out.as_tensor return torch.abs(model_out - out.as_tensor) diff --git a/src/torchphysics/problem/domains/__init__.py b/src/torchphysics/problem/domains/__init__.py index 62a42377..f0109731 100644 --- a/src/torchphysics/problem/domains/__init__.py +++ b/src/torchphysics/problem/domains/__init__.py @@ -22,18 +22,23 @@ # 0D-domains: from .domain0D.point import Point + # 1D-domains: from .domain1D.interval import Interval + # 2D-domains: from .domain2D.circle import Circle from .domain2D.parallelogram import Parallelogram from .domain2D.triangle import Triangle -#from .domain2D.shapely_polygon import ShapelyPolygon + +# from .domain2D.shapely_polygon import ShapelyPolygon # 3D-domains: -from .domain3D.sphere import Sphere -#from .domain3D.trimesh_polyhedron import TrimeshPolyhedron +from .domain3D.sphere import Sphere + +# from .domain3D.trimesh_polyhedron import TrimeshPolyhedron # Function domains: from .functionsets.functionset import FunctionSet, CustomFunctionSet + # Domain transforms: from .domainoperations.translate import Translate -from .domainoperations.rotate import Rotate \ No newline at end of file +from .domainoperations.rotate import Rotate diff --git a/src/torchphysics/problem/domains/domain.py b/src/torchphysics/problem/domains/domain.py index 27304be7..9e8fde89 100644 --- a/src/torchphysics/problem/domains/domain.py +++ b/src/torchphysics/problem/domains/domain.py @@ -16,6 +16,7 @@ class Domain: The dimension of this domain. (if not specified, implicit given through the space) """ + def __init__(self, space, dim=None): self.space = space if dim is None: @@ -25,7 +26,7 @@ def __init__(self, space, dim=None): self._user_volume = None def set_necessary_variables(self, *domain_params): - """Registers the variables/spaces that this domain needs to be + """Registers the variables/spaces that this domain needs to be properly defined """ self.necessary_variables = set() @@ -35,7 +36,7 @@ def set_necessary_variables(self, *domain_params): assert not any(var in self.necessary_variables for var in self.space) def transform_to_user_functions(self, *domain_params): - """Transforms all parameters that define a given domain to + """Transforms all parameters that define a given domain to a UserFunction. This enables that the domain can dependt on other variables. Parameters @@ -73,18 +74,18 @@ def set_volume(self, volume): Notes ----- - For all basic domains the volume (and surface) are implemented. - But if the given domain has a complex shape or is + For all basic domains the volume (and surface) are implemented. + But if the given domain has a complex shape or is dependent on other variables, the volume can only be approixmated. - Therefore one can set here a exact expression for the volume, if known. + Therefore one can set here a exact expression for the volume, if known. """ self._user_volume = DomainUserFunction(volume) @abc.abstractmethod - def _get_volume(self, params=Points.empty(), device='cpu'): + def _get_volume(self, params=Points.empty(), device="cpu"): raise NotImplementedError - def volume(self, params=Points.empty(), device='cpu'): + def volume(self, params=Points.empty(), device="cpu"): """Computes the volume of the current domain. Parameters @@ -98,7 +99,7 @@ def volume(self, params=Points.empty(), device='cpu'): Returns the volume of the domain. If dependent on other parameters, the value will be returned as tensor with the shape (len(params), 1). Where each row corresponds to the volume of the given values in the - params row. + params row. """ if self._user_volume is None: return self._get_volume(params, device=device) @@ -117,6 +118,7 @@ def __add__(self, other): if self.space != other.space: raise ValueError("""united domains should lie in the same space.""") from .domainoperations.union import UnionDomain + return UnionDomain(self, other) def __sub__(self, other): @@ -131,6 +133,7 @@ def __sub__(self, other): if self.space != other.space: raise ValueError("""complemented domains should lie in the same space.""") from .domainoperations.cut import CutDomain + return CutDomain(self, other) def __and__(self, other): @@ -145,6 +148,7 @@ def __and__(self, other): if self.space != other.space: raise ValueError("""Intersected domains should lie in the same space.""") from .domainoperations.intersection import IntersectionDomain + return IntersectionDomain(self, other) def __mul__(self, other): @@ -157,6 +161,7 @@ def __mul__(self, other): Should lie in a disjoint space. """ from .domainoperations.product import ProductDomain + return ProductDomain(self, other) def __contains__(self, points): @@ -180,21 +185,21 @@ def _contains(self, points, params=Points.empty()): raise NotImplementedError @abc.abstractmethod - def bounding_box(self, params=Points.empty(), device='cpu'): + def bounding_box(self, params=Points.empty(), device="cpu"): """Computes the bounds of the domain. Returns ------- tensor : A torch.Tensor with the length of 2*self.dim. - It has the form [axis_1_min, axis_1_max, axis_2_min, axis_2_max, ...], + It has the form [axis_1_min, axis_1_max, axis_2_min, axis_2_max, ...], where min and max are the minimum and maximum value that the domain reaches in each dimension-axis. """ raise NotImplementedError @abc.abstractmethod - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): """Creates an equdistant grid in the domain. Parameters @@ -218,13 +223,14 @@ def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): raise NotImplementedError @abc.abstractmethod - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): """Creates random uniformly distributed points in the domain. Parameters ---------- - n : int, optional + n : int, optional The number of points that should be created. d : float, optional The density of points that should be created, if @@ -243,13 +249,11 @@ def sample_random_uniform(self, n=None, d=None, params=Points.empty(), raise NotImplementedError def __call__(self, **data): - """Evaluates the domain at the given data. - """ + """Evaluates the domain at the given data.""" raise NotImplementedError def len_of_params(self, params): - """Finds the number of params, for which points should be sampled. - """ + """Finds the number of params, for which points should be sampled.""" num_of_params = 1 if len(params) > 0: num_of_params = len(params) @@ -261,15 +265,19 @@ def compute_n_from_density(self, d, params): """ volume = self.volume(params) if len(volume) > 1: - raise ValueError(f"""Sampling with a density is only possible for one + raise ValueError( + f"""Sampling with a density is only possible for one given pair of parameters. Found {len(volume)} different pairs. If sampling with a density is needed, - a loop should be used.""") + a loop should be used.""" + ) n = torch.ceil(d * volume) return int(n) def _repeat_params(self, n, params): - repeated_params = Points(torch.repeat_interleave(params, n, dim=0), params.space) + repeated_params = Points( + torch.repeat_interleave(params, n, dim=0), params.space + ) return 1 if len(repeated_params) else n, repeated_params @@ -281,10 +289,11 @@ class BoundaryDomain(Domain): ---------- domain : Domain The domain of which this object is the boundary. - """ + """ + def __init__(self, domain): assert isinstance(domain, Domain) - super().__init__(space=domain.space, dim=domain.dim-1) + super().__init__(space=domain.space, dim=domain.dim - 1) self.domain = domain self.necessary_variables = self.domain.necessary_variables @@ -292,11 +301,11 @@ def __call__(self, **data): evaluated_domain = self.domain(**data) return evaluated_domain.boundary - def bounding_box(self, params=Points.empty(), device='cpu'): + def bounding_box(self, params=Points.empty(), device="cpu"): return self.domain.bounding_box(params) @abc.abstractmethod - def normal(self, points, params=Points.empty(), device='cpu'): + def normal(self, points, params=Points.empty(), device="cpu"): """Computes the normal vector at each point in points. Parameters @@ -304,7 +313,7 @@ def normal(self, points, params=Points.empty(), device='cpu'): points : torch.tensor or torchphysics.problem.Points Different points for which the normal vector should be computed. The points should lay on the boundary of the domain, to get correct results. - E.g in 2D: points = Points(torch.tensor([[2, 4], [9, 6], ....]), R2(...)) + E.g in 2D: points = Points(torch.tensor([[2, 4], [9, 6], ....]), R2(...)) params : dict or torchphysics.problem.Points, optional Additional parameters that are maybe needed to evaluate the domain. device : str, optional @@ -314,7 +323,7 @@ def normal(self, points, params=Points.empty(), device='cpu'): Returns ------- torch.tensor - The tensor is of the shape (len(points), self.dim) and contains the + The tensor is of the shape (len(points), self.dim) and contains the normal vector at each entry from points. """ raise NotImplementedError @@ -325,4 +334,4 @@ def _transform_input_for_normals(self, points, params, device): if not isinstance(params, Points): params = Points.from_coordinates(params) device = points._t.device - return points, params, device \ No newline at end of file + return points, params, device diff --git a/src/torchphysics/problem/domains/domain0D/__init__.py b/src/torchphysics/problem/domains/domain0D/__init__.py index 69adcc80..06057a3c 100644 --- a/src/torchphysics/problem/domains/domain0D/__init__.py +++ b/src/torchphysics/problem/domains/domain0D/__init__.py @@ -1 +1 @@ -from .point import Point \ No newline at end of file +from .point import Point diff --git a/src/torchphysics/problem/domains/domain0D/point.py b/src/torchphysics/problem/domains/domain0D/point.py index 80329e5a..85d1a67c 100644 --- a/src/torchphysics/problem/domains/domain0D/point.py +++ b/src/torchphysics/problem/domains/domain0D/point.py @@ -3,6 +3,7 @@ from ..domain import Domain from ...spaces import Points + class Point(Domain): """Creates a single point at the given coordinates. @@ -13,6 +14,7 @@ class Point(Domain): coord : Number, List or callable The coordinate of the point. """ + def __init__(self, space, point): self.bounding_box_tol = 0.1 point = self.transform_to_user_functions(point)[0] @@ -30,15 +32,20 @@ def _contains(self, points, params=Points.empty()): inside = torch.isclose(points[:, None], point_params, atol=0.001) return torch.all(inside, dim=2).reshape(-1, 1) - def bounding_box(self, params=Points.empty(), device='cpu'): - if callable(self.point.fun): # if point moves - return self._bounds_for_callable_point(params, device=device) + def bounding_box(self, params=Points.empty(), device="cpu"): + if callable(self.point.fun): # if point moves + return self._bounds_for_callable_point(params, device=device) if isinstance(self.point.fun, (torch.Tensor, list)): - return self._bounds_for_higher_dimensions(device=device) - return torch.tensor([self.point.fun - self.bounding_box_tol, - self.point.fun + self.bounding_box_tol], device=device) + return self._bounds_for_higher_dimensions(device=device) + return torch.tensor( + [ + self.point.fun - self.bounding_box_tol, + self.point.fun + self.bounding_box_tol, + ], + device=device, + ) - def _bounds_for_callable_point(self, params, device='cpu'): + def _bounds_for_callable_point(self, params, device="cpu"): bounds = [] discrete__points = self.point(params, device=device).reshape(-1, self.space.dim) for i in range(self.space.dim): @@ -50,29 +57,32 @@ def _bounds_for_callable_point(self, params, device='cpu'): bounds.append(min_.item()), bounds.append(max_.item()) return torch.tensor(bounds, device=device) - def _bounds_for_higher_dimensions(self, device='cpu'): + def _bounds_for_higher_dimensions(self, device="cpu"): bounds = [] for i in range(self.space.dim): p = self.point.fun[i] - # substract/add a value to get a real bounding box, + # substract/add a value to get a real bounding box, # important if we later use these values to normalize the input bounds.append(p - self.bounding_box_tol) bounds.append(p + self.bounding_box_tol) return torch.tensor(bounds, device=device) - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if d: n = self.compute_n_from_density(d, params) point_params = self.point(params, device=device) - points = torch.ones((self.len_of_params(params), n, self.space.dim), - device=device) + points = torch.ones( + (self.len_of_params(params), n, self.space.dim), device=device + ) points *= point_params return Points(points.reshape(-1, self.space.dim), self.space) - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): # for one single point grid and random sampling is the same return self.sample_random_uniform(n=n, d=d, params=params, device=device) - def _get_volume(self, params=Points.empty(), device='cpu'): + def _get_volume(self, params=Points.empty(), device="cpu"): no_of_params = self.len_of_params(params) - return 1 * torch.ones((no_of_params, 1), device=device) \ No newline at end of file + return 1 * torch.ones((no_of_params, 1), device=device) diff --git a/src/torchphysics/problem/domains/domain1D/__init__.py b/src/torchphysics/problem/domains/domain1D/__init__.py index 315b3034..df78e3bc 100644 --- a/src/torchphysics/problem/domains/domain1D/__init__.py +++ b/src/torchphysics/problem/domains/domain1D/__init__.py @@ -1 +1 @@ -from .interval import Interval \ No newline at end of file +from .interval import Interval diff --git a/src/torchphysics/problem/domains/domain1D/interval.py b/src/torchphysics/problem/domains/domain1D/interval.py index aaa5f981..2afe0fac 100644 --- a/src/torchphysics/problem/domains/domain1D/interval.py +++ b/src/torchphysics/problem/domains/domain1D/interval.py @@ -16,9 +16,12 @@ class Interval(Domain): upper_bound : Number or callable The right/upper bound of the interval. """ + def __init__(self, space, lower_bound, upper_bound): assert space.dim == 1 - lower_bound, upper_bound = self.transform_to_user_functions(lower_bound, upper_bound) + lower_bound, upper_bound = self.transform_to_user_functions( + lower_bound, upper_bound + ) self.lower_bound = lower_bound self.upper_bound = upper_bound super().__init__(space=space, dim=1) @@ -27,44 +30,46 @@ def __init__(self, space, lower_bound, upper_bound): def __call__(self, **data): new_lower_bound = self.lower_bound.partially_evaluate(**data) new_upper_bound = self.upper_bound.partially_evaluate(**data) - return Interval(space=self.space, lower_bound=new_lower_bound, - upper_bound=new_upper_bound) + return Interval( + space=self.space, lower_bound=new_lower_bound, upper_bound=new_upper_bound + ) def _contains(self, points, params=Points.empty()): lb = self.lower_bound(points.join(params)) ub = self.upper_bound(points.join(params)) points = points[:, list(self.space.keys())].as_tensor - bigger_then_low = torch.ge(points[:, None], lb) - smaller_then_up = torch.le(points[:, None], ub) + bigger_then_low = torch.ge(points[:, None], lb) + smaller_then_up = torch.le(points[:, None], ub) return torch.logical_and(bigger_then_low, smaller_then_up).reshape(-1, 1) - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if d: n = self.compute_n_from_density(d, params) lb = self.lower_bound(params, device=device) ub = self.upper_bound(params, device=device) points = torch.rand((self.len_of_params(params), n, 1), device=device) - points *= (ub - lb) + points *= ub - lb points += lb return Points(points.reshape(-1, self.space.dim), self.space) - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): if d: n = self.compute_n_from_density(d, params) lb = self.lower_bound(params, device=device) ub = self.upper_bound(params, device=device) - points = torch.linspace(0, 1, n+2, device=device)[1:-1, None] - points = (ub - lb) * points + points = torch.linspace(0, 1, n + 2, device=device)[1:-1, None] + points = (ub - lb) * points points += lb return Points(points.reshape(-1, self.space.dim), self.space) - def bounding_box(self, params=Points.empty(), device='cpu'): + def bounding_box(self, params=Points.empty(), device="cpu"): lb = self.lower_bound(params, device=device) ub = self.upper_bound(params, device=device) return torch.stack((torch.min(lb), torch.max(ub)), dim=0) - def _get_volume(self, params=Points.empty(), device='cpu'): + def _get_volume(self, params=Points.empty(), device="cpu"): lb = self.lower_bound(params, device=device) ub = self.upper_bound(params, device=device) return (ub - lb).reshape(-1, 1) @@ -93,9 +98,9 @@ class IntervalBoundary(BoundaryDomain): def __init__(self, domain): assert isinstance(domain, Interval) super().__init__(domain) - + def _contains(self, points, params=Points.empty()): - close_to_left, close_to_right = self._check_close_left_right(points, params) + close_to_left, close_to_right = self._check_close_left_right(points, params) return torch.logical_or(close_to_left, close_to_right).reshape(-1, 1) def _check_close_left_right(self, points, params): @@ -106,33 +111,37 @@ def _check_close_left_right(self, points, params): close_to_right = torch.isclose(points[:, None], ub) return close_to_left, close_to_right - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if d: n = self.compute_n_from_density(d, params) lb = self.domain.lower_bound(params, device=device) ub = self.domain.upper_bound(params, device=device) rand_side = torch.rand((self.len_of_params(params), n, 1), device=device) - random_boundary_index = rand_side < 0.5 + random_boundary_index = rand_side < 0.5 points = torch.where(random_boundary_index, lb, ub) return Points(points.reshape(-1, self.space.dim), self.space) - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): if d: n = self.compute_n_from_density(d, params) lb = self.domain.lower_bound(params, device) ub = self.domain.upper_bound(params, device) - b_index = torch.tensor([0, 1], dtype=bool, device=device).repeat(int(n/2.0) + 1) + b_index = torch.tensor([0, 1], dtype=bool, device=device).repeat( + int(n / 2.0) + 1 + ) points = torch.where(b_index[:n], lb, ub) return Points(points.reshape(-1, self.space.dim), self.space) - def normal(self, points, params=Points.empty(), device='cpu'): - points, params, device = \ - self._transform_input_for_normals(points, params, device) + def normal(self, points, params=Points.empty(), device="cpu"): + points, params, device = self._transform_input_for_normals( + points, params, device + ) close_to_left, _ = self._check_close_left_right(points, params) return torch.where(close_to_left, -1, 1).reshape(-1, 1) - def _get_volume(self, params=Points.empty(), device='cpu'): + def _get_volume(self, params=Points.empty(), device="cpu"): no_of_params = self.len_of_params(params) return 2 * torch.ones((no_of_params, 1), device=device) @@ -147,8 +156,9 @@ def __init__(self, domain, side, normal_vec=-1): def __call__(self, **data): evaluate_domain = self.domain(**data) - return IntervalSingleBoundaryPoint(evaluate_domain, side=self.side, - normal_vec=self.normal_vec) + return IntervalSingleBoundaryPoint( + evaluate_domain, side=self.side, normal_vec=self.normal_vec + ) def _contains(self, points, params=Points.empty()): side = self.side(points.join(params)) @@ -156,8 +166,9 @@ def _contains(self, points, params=Points.empty()): inside = torch.isclose(points[:, None], side) return inside.reshape(-1, 1) - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if d: n = self.compute_n_from_density(d, params) side = self.side(params, device=device) @@ -165,15 +176,16 @@ def sample_random_uniform(self, n=None, d=None, params=Points.empty(), points *= side return Points(points.reshape(-1, self.space.dim), self.space) - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): return self.sample_random_uniform(n=n, d=d, params=params, device=device) - def normal(self, points, params=Points.empty(), device='cpu'): - points, params, device = \ - self._transform_input_for_normals(points, params, device) + def normal(self, points, params=Points.empty(), device="cpu"): + points, params, device = self._transform_input_for_normals( + points, params, device + ) points = torch.ones((self.len_of_params(points.join(params)), 1), device=device) return points * self.normal_vec - def _get_volume(self, params=Points.empty(), device='cpu'): + def _get_volume(self, params=Points.empty(), device="cpu"): no_of_params = self.len_of_params(params) - return 1 * torch.ones((no_of_params, 1), device=device) \ No newline at end of file + return 1 * torch.ones((no_of_params, 1), device=device) diff --git a/src/torchphysics/problem/domains/domain2D/__init__.py b/src/torchphysics/problem/domains/domain2D/__init__.py index d27c0193..5a91795a 100644 --- a/src/torchphysics/problem/domains/domain2D/__init__.py +++ b/src/torchphysics/problem/domains/domain2D/__init__.py @@ -1,4 +1,5 @@ from .circle import Circle from .parallelogram import Parallelogram from .triangle import Triangle -#from .shapely_polygon import ShapelyPolygon \ No newline at end of file + +# from .shapely_polygon import ShapelyPolygon diff --git a/src/torchphysics/problem/domains/domain2D/circle.py b/src/torchphysics/problem/domains/domain2D/circle.py index a67e5c82..59cf2e29 100644 --- a/src/torchphysics/problem/domains/domain2D/circle.py +++ b/src/torchphysics/problem/domains/domain2D/circle.py @@ -16,7 +16,8 @@ class Circle(Domain): The center of the circle, e.g. center = [5,0]. radius : number or callable The radius of the circle. - """ + """ + def __init__(self, space, center, radius): assert space.dim == 2 center, radius = self.transform_to_user_functions(center, radius) @@ -31,12 +32,14 @@ def __call__(self, **data): return Circle(space=self.space, center=new_center, radius=new_radius) def _contains(self, points, params=Points.empty()): - center, radius = self._compute_center_and_radius(points.join(params), points.device) + center, radius = self._compute_center_and_radius( + points.join(params), points.device + ) points = points[:, list(self.space.keys())].as_tensor norm = torch.linalg.norm(points - center, dim=1).reshape(-1, 1) return torch.le(norm[:, None], radius).reshape(-1, 1) - def bounding_box(self, params=Points.empty(), device='cpu'): + def bounding_box(self, params=Points.empty(), device="cpu"): center, radius = self._compute_center_and_radius(params, device=device) bounds = [] for i in range(self.dim): @@ -46,8 +49,9 @@ def bounding_box(self, params=Points.empty(), device='cpu'): bounds.append(i_max.item()) return torch.tensor(bounds, device=device) - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if d: n = self.compute_n_from_density(d, params) center, radius = self._compute_center_and_radius(params, device=device) @@ -55,40 +59,46 @@ def sample_random_uniform(self, n=None, d=None, params=Points.empty(), r = torch.sqrt(torch.rand((num_of_params, n, 1), device=device)) r *= radius phi = 2 * np.pi * torch.rand((num_of_params, n, 1), device=device) - points = torch.cat((torch.multiply(r, torch.cos(phi)), - torch.multiply(r, torch.sin(phi))), dim=2) + points = torch.cat( + (torch.multiply(r, torch.cos(phi)), torch.multiply(r, torch.sin(phi))), + dim=2, + ) # [:,None,:] is needed so that the correct entries will be added points += center[:, None, :] return Points(points.reshape(-1, self.space.dim), self.space) - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): if d: n = self.compute_n_from_density(d, params) center, radius = self._compute_center_and_radius(params, device) num_of_params = self.len_of_params(params) grid = self._equidistant_points_in_circle(n, device=device) - grid = grid.repeat(num_of_params, 1).view(num_of_params, n, 2) + grid = grid.repeat(num_of_params, 1).view(num_of_params, n, 2) points = torch.multiply(radius, grid) points += center[:, None, :] return Points(points.reshape(-1, self.space.dim), self.space) - def _compute_center_and_radius(self, params=Points.empty(), device='cpu'): + def _compute_center_and_radius(self, params=Points.empty(), device="cpu"): center = self.center(params, device=device).reshape(-1, 2) radius = self.radius(params, device=device) - return center,radius + return center, radius def _equidistant_points_in_circle(self, n, device): # use a sunflower seed arrangement: # https://demonstrations.wolfram.com/SunflowerSeedArrangements/ - gr = (np.sqrt(5) + 1)/2.0 # golden ratio - points = torch.arange(1, n+1, device=device) + gr = (np.sqrt(5) + 1) / 2.0 # golden ratio + points = torch.arange(1, n + 1, device=device) phi = (2 * np.pi / gr) * points - radius = torch.sqrt(points - 0.5) / np.sqrt(n + 0.5) - points = torch.column_stack((torch.multiply(radius, torch.cos(phi)), - torch.multiply(radius, torch.sin(phi)))) - return points - - def _get_volume(self, params=Points.empty(), device='cpu'): + radius = torch.sqrt(points - 0.5) / np.sqrt(n + 0.5) + points = torch.column_stack( + ( + torch.multiply(radius, torch.cos(phi)), + torch.multiply(radius, torch.sin(phi)), + ) + ) + return points + + def _get_volume(self, params=Points.empty(), device="cpu"): radius = self.radius(params, device=device) volume = np.pi * radius**2 return volume.reshape(-1, 1) @@ -105,45 +115,61 @@ def __init__(self, domain): super().__init__(domain) def _contains(self, points, params=Points.empty()): - center, radius = self.domain._compute_center_and_radius(points.join(params), points.device) + center, radius = self.domain._compute_center_and_radius( + points.join(params), points.device + ) points = points[:, list(self.space.keys())].as_tensor norm = torch.linalg.norm(points - center, dim=1).reshape(-1, 1) return torch.isclose(norm[:, None], radius).reshape(-1, 1) - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if d: n = self.compute_n_from_density(d, params) center, radius = self.domain._compute_center_and_radius(params, device) phi = 2 * np.pi * torch.rand((self.len_of_params(params), n, 1), device=device) - points = torch.cat((torch.multiply(radius, torch.cos(phi)), - torch.multiply(radius, torch.sin(phi))), - dim=2) + points = torch.cat( + ( + torch.multiply(radius, torch.cos(phi)), + torch.multiply(radius, torch.sin(phi)), + ), + dim=2, + ) points += center[:, None, :] return Points(points.reshape(-1, self.space.dim), self.space) - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): if d: n = self.compute_n_from_density(d, params) center, radius = self.domain._compute_center_and_radius(params, device) num_of_params = self.len_of_params(params) - grid = torch.linspace(0, 2*np.pi, n+1, device=device)[:-1] # last one would be double - phi = grid.repeat(num_of_params).view(num_of_params, n, 1) - points = torch.cat((torch.multiply(radius, torch.cos(phi)), - torch.multiply(radius, torch.sin(phi))), - dim=2) + grid = torch.linspace(0, 2 * np.pi, n + 1, device=device)[ + :-1 + ] # last one would be double + phi = grid.repeat(num_of_params).view(num_of_params, n, 1) + points = torch.cat( + ( + torch.multiply(radius, torch.cos(phi)), + torch.multiply(radius, torch.sin(phi)), + ), + dim=2, + ) points += center[:, None, :] return Points(points.reshape(-1, self.space.dim), self.space) - def normal(self, points, params=Points.empty(), device='cpu'): - points, params, device = \ - self._transform_input_for_normals(points, params, device) - center, radius = self.domain._compute_center_and_radius(points.join(params), device) + def normal(self, points, params=Points.empty(), device="cpu"): + points, params, device = self._transform_input_for_normals( + points, params, device + ) + center, radius = self.domain._compute_center_and_radius( + points.join(params), device + ) points = points[:, list(self.space.keys())].as_tensor - normal = (points - center) + normal = points - center return torch.divide(normal[:, None], radius).reshape(-1, 2) - def _get_volume(self, params=Points.empty(), device='cpu'): + def _get_volume(self, params=Points.empty(), device="cpu"): radius = self.domain.radius(params, device=device) volume = 2 * np.pi * radius return volume.reshape(-1, 1) diff --git a/src/torchphysics/problem/domains/domain2D/parallelogram.py b/src/torchphysics/problem/domains/domain2D/parallelogram.py index 92962d91..9c6eba52 100644 --- a/src/torchphysics/problem/domains/domain2D/parallelogram.py +++ b/src/torchphysics/problem/domains/domain2D/parallelogram.py @@ -3,6 +3,7 @@ from ..domain import Domain, BoundaryDomain from ...spaces import Points + class Parallelogram(Domain): """Class for arbitrary parallelograms, even if time dependet will always stay a parallelogram. @@ -18,13 +19,15 @@ class Parallelogram(Domain): | / / | / / | origin ----- corner_1 - + E.g. for the unit square: origin = [0,0], corner_1 = [1,0], corner_2 = [0,1]. """ + def __init__(self, space, origin, corner_1, corner_2): assert space.dim == 2 - origin, corner_1, corner_2 = \ - self.transform_to_user_functions(origin, corner_1, corner_2) + origin, corner_1, corner_2 = self.transform_to_user_functions( + origin, corner_1, corner_2 + ) self.origin = origin self.corner_1 = corner_1 self.corner_2 = corner_2 @@ -38,8 +41,9 @@ def __call__(self, **data): new_vec_1 = self._check_shape_of_evaluated_user_function(new_vec_1) new_vec_2 = self.corner_2.partially_evaluate(**data) new_vec_2 = self._check_shape_of_evaluated_user_function(new_vec_2) - return Parallelogram(space=self.space, origin=new_origin, - corner_1=new_vec_1, corner_2=new_vec_2) + return Parallelogram( + space=self.space, origin=new_origin, corner_1=new_vec_1, corner_2=new_vec_2 + ) def _check_shape_of_evaluated_user_function(self, domain_param): if isinstance(domain_param, torch.Tensor): @@ -47,13 +51,13 @@ def _check_shape_of_evaluated_user_function(self, domain_param): return domain_param[0, :] return domain_param - def _get_volume(self, params=Points.empty(), device='cpu'): + def _get_volume(self, params=Points.empty(), device="cpu"): _, _, _, dir_1, dir_2 = self._construct_parallelogram(params, device=device) # volume equals the determinate of the matrix [dir_1, dir_2] volume = dir_1[:, :1] * dir_2[:, 1:] - dir_1[:, 1:] * dir_2[:, :1] return volume - def _construct_parallelogram(self, params=Points.empty(), device='cpu'): + def _construct_parallelogram(self, params=Points.empty(), device="cpu"): origin = self.origin(params, device).reshape(-1, 2) corner_1 = self.corner_1(params, device).reshape(-1, 2) corner_2 = self.corner_2(params, device).reshape(-1, 2) @@ -61,8 +65,10 @@ def _construct_parallelogram(self, params=Points.empty(), device='cpu'): dir_2 = corner_2 - origin return origin, corner_1, corner_2, dir_1, dir_2 - def bounding_box(self, params=Points.empty(), device='cpu'): - origin, corner_1, corner_2, _, _ = self._construct_parallelogram(params, device=device) + def bounding_box(self, params=Points.empty(), device="cpu"): + origin, corner_1, corner_2, _, _ = self._construct_parallelogram( + params, device=device + ) corner_3 = corner_1 + corner_2 - origin bounds = [] for i in range(self.dim): @@ -75,8 +81,9 @@ def bounding_box(self, params=Points.empty(), device='cpu'): return torch.tensor(bounds, device=device) def _contains(self, points, params=Points.empty()): - origin, _, _, dir_1, dir_2 = \ - self._construct_parallelogram(points.join(params), points.device) + origin, _, _, dir_1, dir_2 = self._construct_parallelogram( + points.join(params), points.device + ) points = points[:, list(self.space.keys())].as_tensor points -= origin bary_x, bary_y = self._solve_lgs(points, dir_1, dir_2) @@ -95,8 +102,9 @@ def _solve_lgs(self, points, dir_1, dir_2): bary_y = torch.divide(y_dir, det) return bary_x, bary_y - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if d: n = self.compute_n_from_density(d, params) origin, _, _, dir_1, dir_2 = self._construct_parallelogram(params, device) @@ -108,14 +116,14 @@ def sample_random_uniform(self, n=None, d=None, params=Points.empty(), points += origin[:, None, :] return Points(points.reshape(-1, self.space.dim), self.space) - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): if d: n = self.compute_n_from_density(d, params) origin, _, _, dir_1, dir_2 = self._construct_parallelogram(params, device) bary_coords = self._compute_barycentric_grid(n, dir_1, dir_2, device) - if not d: + if not d: # if the number of points is specified we have to be sure to sample - # the right amount + # the right amount bary_coords = self._grid_enough_points(n, bary_coords, device) points_in_dir_1 = bary_coords[:, :1] * dir_1 points_in_dir_2 = bary_coords[:, 1:] * dir_2 @@ -127,14 +135,16 @@ def _compute_barycentric_grid(self, n, dir_1, dir_2, device): side_length_1 = torch.linalg.norm(dir_1, dim=1) side_length_2 = torch.linalg.norm(dir_2, dim=1) # scale the number of point w.r.t. the 'form' of the parallelogram - n_1 = int(torch.sqrt(n*side_length_1/side_length_2)) - n_2 = int(torch.sqrt(n*side_length_2/side_length_1)) - x = torch.linspace(0, 1, n_1+2, device=device)[1:-1] # create inner grid, so remove - y = torch.linspace(0, 1, n_2+2, device=device)[1:-1] # first and last value - bary_coords = torch.stack(torch.meshgrid((x, y))).T.reshape(-1, 2) - return bary_coords + n_1 = int(torch.sqrt(n * side_length_1 / side_length_2)) + n_2 = int(torch.sqrt(n * side_length_2 / side_length_1)) + x = torch.linspace(0, 1, n_1 + 2, device=device)[ + 1:-1 + ] # create inner grid, so remove + y = torch.linspace(0, 1, n_2 + 2, device=device)[1:-1] # first and last value + bary_coords = torch.permute(torch.stack(torch.meshgrid((x, y))), (2, 1, 0)) + return bary_coords.reshape(-1, 2) - def _grid_enough_points(self, n, bary_coords, device): + def _grid_enough_points(self, n, bary_coords, device): # if not enough points, add some random ones. if len(bary_coords) < n: random_points = torch.rand((n - len(bary_coords), 2), device=device) @@ -153,87 +163,102 @@ def __init__(self, domain): super().__init__(domain) def _contains(self, points, params=Points.empty()): - origin, _, _, dir_1, dir_2 = \ - self.domain._construct_parallelogram(points.join(params), points.device) + origin, _, _, dir_1, dir_2 = self.domain._construct_parallelogram( + points.join(params), points.device + ) points = points[:, list(self.space.keys())].as_tensor points -= origin bary_x, bary_y = self.domain._solve_lgs(points, dir_1, dir_2) x_close = self._bary_coords_close_to_0_or_1(bary_x, bary_y) y_close = self._bary_coords_close_to_0_or_1(bary_y, bary_x) return torch.logical_or(x_close, y_close) - + def _bary_coords_close_to_0_or_1(self, bary_coord1, bary_coord2): between_0_1 = torch.logical_and(0 <= bary_coord2, bary_coord2 <= 1) close_to_0 = torch.isclose(bary_coord1, torch.tensor(0.0)) close_to_1 = torch.isclose(bary_coord1, torch.tensor(1.0)) return torch.logical_and(torch.logical_or(close_to_1, close_to_0), between_0_1) - def _get_volume(self, params=Points.empty(), device='cpu'): - _, _, _, dir_1, dir_2 = self.domain._construct_parallelogram(params, device=device) + def _get_volume(self, params=Points.empty(), device="cpu"): + _, _, _, dir_1, dir_2 = self.domain._construct_parallelogram( + params, device=device + ) side_length1 = torch.linalg.norm(dir_1, dim=1) side_length2 = torch.linalg.norm(dir_2, dim=1) return 2 * (side_length1 + side_length2).reshape(-1, 1) - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if d: n = self.compute_n_from_density(d, params) - origin, _, _, dir_1, dir_2 = self.domain._construct_parallelogram(params, device) + origin, _, _, dir_1, dir_2 = self.domain._construct_parallelogram( + params, device + ) side_1, side_2, total_length = self._compute_side_length(dir_1, dir_2) num_of_params = self.len_of_params(params) points = torch.zeros((num_of_params, n, 2), device=device) - bound_location = torch.rand((num_of_params, n, 1), device=device)*total_length - self._transform_interval_to_boundary(dir_1, dir_2, side_1, side_2, points, - bound_location) + bound_location = torch.rand((num_of_params, n, 1), device=device) * total_length + self._transform_interval_to_boundary( + dir_1, dir_2, side_1, side_2, points, bound_location + ) points += origin[:, None, :] return Points(points.reshape(-1, self.space.dim), self.space) def _compute_side_length(self, dir_1, dir_2): - # essentially computes the same as volume, but we need to set the view + # essentially computes the same as volume, but we need to set the view # that we can use the computes values for different cases side_length1 = torch.linalg.norm(dir_1, dim=1).view(-1, 1, 1) side_length2 = torch.linalg.norm(dir_2, dim=1).view(-1, 1, 1) total_length = 2 * (side_length1 + side_length2) - return side_length1,side_length2,total_length + return side_length1, side_length2, total_length def _scale_points_on_side(self, dir, side_length, points, bound_location): - scale = torch.clamp(bound_location/side_length, min=0, max=1) + scale = torch.clamp(bound_location / side_length, min=0, max=1) points += scale * dir[:, None] bound_location -= side_length - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): if d: n = self.compute_n_from_density(d, params) - origin, _, _, dir_1, dir_2 = self.domain._construct_parallelogram(params, device) + origin, _, _, dir_1, dir_2 = self.domain._construct_parallelogram( + params, device + ) side_1, side_2, total_length = self._compute_side_length(dir_1, dir_2) num_of_params = self.len_of_params(params) points = torch.zeros((num_of_params, n, 2), device=device) - bound_grid = torch.linspace(0, 1, n+1, device=device)[:-1] # last point would be double - bound_grid = bound_grid.repeat(num_of_params).view(num_of_params, n, 1) + bound_grid = torch.linspace(0, 1, n + 1, device=device)[ + :-1 + ] # last point would be double + bound_grid = bound_grid.repeat(num_of_params).view(num_of_params, n, 1) bound_location = bound_grid * total_length - self._transform_interval_to_boundary(dir_1, dir_2, side_1, side_2, points, - bound_location) + self._transform_interval_to_boundary( + dir_1, dir_2, side_1, side_2, points, bound_location + ) points += origin[:, None, :] return Points(points.reshape(-1, self.space.dim), self.space) - def _transform_interval_to_boundary(self, dir_1, dir_2, side_1, side_2, - points, bound_location): - # first we sample points between 0 and the total length of the + def _transform_interval_to_boundary( + self, dir_1, dir_2, side_1, side_2, points, bound_location + ): + # first we sample points between 0 and the total length of the # boundary circumference. Now we walk along the boundary and check # if a sampled point has value smaller then the distance we already # walked -> put point on this boundary part. - # This idea we apply for all points at the same time, by iterativ - # checking each side. + # This idea we apply for all points at the same time, by iterativ + # checking each side. self._scale_points_on_side(dir_1, side_1, points, bound_location) self._scale_points_on_side(dir_2, side_2, points, bound_location) self._scale_points_on_side(-dir_1, side_1, points, bound_location) self._scale_points_on_side(-dir_2, side_2, points, bound_location) - def normal(self, points, params=Points.empty(), device='cpu'): - points, params, device = \ - self._transform_input_for_normals(points, params, device) - origin, _, _, dir_1, dir_2 = \ - self.domain._construct_parallelogram(points.join(params), device) + def normal(self, points, params=Points.empty(), device="cpu"): + points, params, device = self._transform_input_for_normals( + points, params, device + ) + origin, _, _, dir_1, dir_2 = self.domain._construct_parallelogram( + points.join(params), device + ) points = points[:, list(self.space.keys())].as_tensor normals = torch.zeros_like(points, device=device) bary_x, bary_y = self.domain._solve_lgs(points - origin, dir_1, dir_2) @@ -241,24 +266,26 @@ def normal(self, points, params=Points.empty(), device='cpu'): normal_dir_2 = -self._get_normal_direction(dir_2, device) # compute for each point what the normal vector should be, by checking the # value of the local barycentric coordinate = 0 or 1 - self._add_local_normal_vector(normals, bary_x, bary_y, normal_dir_1, - normal_dir_2, 0.0) - self._add_local_normal_vector(normals, bary_x, bary_y, normal_dir_1, - normal_dir_2, 1.0) + self._add_local_normal_vector( + normals, bary_x, bary_y, normal_dir_1, normal_dir_2, 0.0 + ) + self._add_local_normal_vector( + normals, bary_x, bary_y, normal_dir_1, normal_dir_2, 1.0 + ) # scale normal vectors if there where in a corner: return torch.divide(normals, torch.linalg.norm(normals, dim=1).reshape(-1, 1)) - def _add_local_normal_vector(self, normals, bary_x, bary_y, - normal_dir_1, normal_dir_2, i): - y_close_i = torch.where(torch.isclose(bary_y, torch.tensor(i)), 2*i-1, 0.0) - x_close_i = torch.where(torch.isclose(bary_x, torch.tensor(i)), 2*i-1, 0.0) + def _add_local_normal_vector( + self, normals, bary_x, bary_y, normal_dir_1, normal_dir_2, i + ): + y_close_i = torch.where(torch.isclose(bary_y, torch.tensor(i)), 2 * i - 1, 0.0) + x_close_i = torch.where(torch.isclose(bary_x, torch.tensor(i)), 2 * i - 1, 0.0) normals += normal_dir_1 * y_close_i normals += normal_dir_2 * x_close_i def _get_normal_direction(self, direction, device): - # to get normal vector in 2d switch x and y coordinate and multiply + # to get normal vector in 2d switch x and y coordinate and multiply # one coordinate with -1 - normal = torch.index_select(direction, 1, - torch.tensor([1, 0], device=device)) + normal = torch.index_select(direction, 1, torch.tensor([1, 0], device=device)) normal[:, :1] *= -1 - return torch.divide(normal, torch.linalg.norm(normal, dim=1).reshape(-1, 1)) \ No newline at end of file + return torch.divide(normal, torch.linalg.norm(normal, dim=1).reshape(-1, 1)) diff --git a/src/torchphysics/problem/domains/domain2D/shapely_polygon.py b/src/torchphysics/problem/domains/domain2D/shapely_polygon.py index fdbebe6c..19ffab0c 100644 --- a/src/torchphysics/problem/domains/domain2D/shapely_polygon.py +++ b/src/torchphysics/problem/domains/domain2D/shapely_polygon.py @@ -6,6 +6,7 @@ from .parallelogram import Parallelogram from ...spaces import Points + class ShapelyPolygon(Domain): """Class for polygons. Uses the shapely-package. @@ -13,17 +14,18 @@ class ShapelyPolygon(Domain): ---------- space : Space The space in which this object lays. - vertices : list of lists, optional + vertices : list of lists, optional The corners/vertices of the polygon. Can be eihter in clockwise or counter- - clockwise order. + clockwise order. shapely_polygon : shapely.geometry.Polygon, optional Instead of defining the corner points, it is also possible to give a already - existing shapely.Polygon object. + existing shapely.Polygon object. Note ---- This class can not be dependent on other variables. """ + def __init__(self, space, vertices=None, shapely_polygon=None): assert space.dim == 2 super().__init__(space, dim=2) @@ -33,7 +35,7 @@ def __init__(self, space, vertices=None, shapely_polygon=None): elif vertices: if callable(vertices): TypeError("""Shapely-Polygons can not use functions as vertices.""") - self.polygon= s_geo.Polygon(vertices) + self.polygon = s_geo.Polygon(vertices) else: raise ValueError("""Needs either vertices or a shapely polygon as input""") self.polygon = s_geo.polygon.orient(self.polygon) @@ -50,24 +52,25 @@ def _contains(self, points, params=Points.empty()): inside[i] = self.polygon.contains(point) return inside - def bounding_box(self, device='cpu'): + def bounding_box(self, device="cpu"): bounds = torch.tensor(self.polygon.bounds, device=device) - bounds[[1,2]] = bounds[[2,1]] + bounds[[1, 2]] = bounds[[2, 1]] return bounds - def _get_volume(self, params=Points.empty(), device='cpu'): + def _get_volume(self, params=Points.empty(), device="cpu"): volume = self.polygon.area return torch.tensor(volume, device=device).reshape(-1, 1) - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): n = self._compute_number_of_points(n, d, params) points = torch.empty((0, self.dim), device=device) big_t, biggest_area = None, 0 # instead of using a bounding box it is more efficient to triangulate # the polygon and sample in each triangle. for t in s_ops.triangulate(self.polygon): - scaled_n = int(t.area/self.polygon.area * n) + scaled_n = int(t.area / self.polygon.area * n) new_points = self._sample_in_triangulation(t, scaled_n, device) if new_points is not None: points = torch.cat((points, new_points), dim=0) @@ -100,21 +103,22 @@ def _random_points_in_triangle(self, n, corners, device): # if a barycentric coordinates is bigger then 1, mirror them at the # point (0.5, 0.5). Stays uniform. index = torch.where(bary_coords.sum(axis=1) > 1)[0] - bary_coords[index] = torch.subtract(torch.tensor([[1.0, 1.0]], device=device), - bary_coords[index]) - axis_1 = torch.multiply(corners[1]-corners[0], bary_coords[:, :1]) - axis_2 = torch.multiply(corners[2]-corners[0], bary_coords[:, 1:]) + bary_coords[index] = torch.subtract( + torch.tensor([[1.0, 1.0]], device=device), bary_coords[index] + ) + axis_1 = torch.multiply(corners[1] - corners[0], bary_coords[:, :1]) + axis_2 = torch.multiply(corners[2] - corners[0], bary_coords[:, 1:]) return torch.add(torch.add(corners[0], axis_1), axis_2) def _check_enough_points_sampled(self, n, points, big_t, device): # if not enough points are sampled, create some new points in the biggest # triangle while len(points) < n: - new_points = self._sample_in_triangulation(big_t, n-len(points), device) + new_points = self._sample_in_triangulation(big_t, n - len(points), device) points = torch.cat((points, new_points), dim=0) return points - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): n = self._compute_number_of_points(n, d, params) points = self._create_points_in_bounding_box(n, device) points = self._delete_outside(points) @@ -126,13 +130,14 @@ def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): def _create_points_in_bounding_box(self, n, device): bounds = self.bounding_box(device=device) - origin = bounds[[0,2]] - dir_1 = torch.tensor([[bounds[1]-bounds[0], 0]], device=device) - dir_2 = torch.tensor([[0, bounds[3]-bounds[2]]], device=device) - b_box_volume = (bounds[1]-bounds[0])*(bounds[3]-bounds[2]) - scaled_n = int(n * b_box_volume/self.polygon.area) - b_box_grid = Parallelogram._compute_barycentric_grid(self, scaled_n, - dir_1, dir_2, device) + origin = bounds[[0, 2]] + dir_1 = torch.tensor([[bounds[1] - bounds[0], 0]], device=device) + dir_2 = torch.tensor([[0, bounds[3] - bounds[2]]], device=device) + b_box_volume = (bounds[1] - bounds[0]) * (bounds[3] - bounds[2]) + scaled_n = int(n * b_box_volume / self.polygon.area) + b_box_grid = Parallelogram._compute_barycentric_grid( + self, scaled_n, dir_1, dir_2, device + ) points_in_dir_1 = b_box_grid[:, :1] * dir_1 points_in_dir_2 = b_box_grid[:, 1:] * dir_2 points = points_in_dir_1 + points_in_dir_2 + origin @@ -143,14 +148,14 @@ def _delete_outside(self, points): index = torch.where(inside)[0] return points[index] - def _grid_enough_points(self, n, bary_coords, device): + def _grid_enough_points(self, n, bary_coords, device): # if not enough points, add some random ones. points = bary_coords if len(bary_coords) < n: - random_points = self.sample_random_uniform(n=(n - len(bary_coords)), - device=device) - points = torch.cat((bary_coords, random_points.as_tensor), - dim=0) + random_points = self.sample_random_uniform( + n=(n - len(bary_coords)), device=device + ) + points = torch.cat((bary_coords, random_points.as_tensor), dim=0) return points def _compute_number_of_points(self, n, d, params): @@ -160,7 +165,7 @@ def _compute_number_of_points(self, n, d, params): n *= num_of_params return n - def outline(self, device='cpu'): + def outline(self, device="cpu"): """Creates a outline of the domain. Returns @@ -186,7 +191,7 @@ def __init__(self, domain): super().__init__(domain) outline = self.domain.outline() self.normal_list = self._compute_normals(outline) - self.tol = 1.e-06 + self.tol = 1.0e-06 def __call__(self, **data): return self @@ -197,27 +202,31 @@ def _contains(self, points, params=Points.empty()): for i in range(len(points)): point = s_geo.Point(points[i]) distance = self.domain.polygon.boundary.distance(point) - on_bound[i] = (abs(distance) <= self.tol) + on_bound[i] = abs(distance) <= self.tol return on_bound.reshape(-1, 1) - def _get_volume(self, params=Points.empty(), device='cpu'): - volume = self.domain.polygon.boundary.length + def _get_volume(self, params=Points.empty(), device="cpu"): + volume = self.domain.polygon.boundary.length return torch.tensor(volume, device=device).reshape(-1, 1) - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): n = self.domain._compute_number_of_points(n, d, params) - line_points = torch.rand(n, device=device) * self.domain.polygon.boundary.length - return self._transform_points_to_boundary(n, torch.sort(line_points).values, device) + line_points = torch.rand(n, device=device) * self.domain.polygon.boundary.length + return self._transform_points_to_boundary( + n, torch.sort(line_points).values, device + ) - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): n = self.domain._compute_number_of_points(n, d, params) - line_points = torch.linspace(0, self.domain.polygon.boundary.length, - n+1, device=device)[:-1] + line_points = torch.linspace( + 0, self.domain.polygon.boundary.length, n + 1, device=device + )[:-1] return self._transform_points_to_boundary(n, line_points, device) def _transform_points_to_boundary(self, n, line_points, device): - """Transform points that lay between 0 and polygon.boundary.length to + """Transform points that lay between 0 and polygon.boundary.length to the surface of this polygon. The points have to be ordered from smallest to biggest. """ @@ -226,20 +235,26 @@ def _transform_points_to_boundary(self, n, line_points, device): current_length = 0 points = torch.zeros((n, 2), device=device) for boundary_part in outline: - points, index, current_length = \ - self._distribute_line_to_boundary(points, index, line_points, - boundary_part, current_length) + points, index, current_length = self._distribute_line_to_boundary( + points, index, line_points, boundary_part, current_length + ) return Points(points, self.space) - def _distribute_line_to_boundary(self, points, index, line_points, - corners, current_length): + def _distribute_line_to_boundary( + self, points, index, line_points, corners, current_length + ): corner_index = 0 side_length = torch.linalg.norm(corners[1] - corners[0]) while index < len(line_points): if line_points[index] <= current_length + side_length: - point = self._translate_point_to_bondary(index, line_points, - corners, current_length, - corner_index, side_length) + point = self._translate_point_to_bondary( + index, + line_points, + corners, + current_length, + corner_index, + side_length, + ) points[index] = point index += 1 else: @@ -247,20 +262,24 @@ def _distribute_line_to_boundary(self, points, index, line_points, current_length += side_length if corner_index >= len(corners) - 1: break - side_length = torch.linalg.norm(corners[corner_index+1] - - corners[corner_index]) + side_length = torch.linalg.norm( + corners[corner_index + 1] - corners[corner_index] + ) return points, index, current_length - def _translate_point_to_bondary(self, index, line_points, corners, - current_length, corner_index, side_length): + def _translate_point_to_bondary( + self, index, line_points, corners, current_length, corner_index, side_length + ): coord = line_points[index] - current_length - new_point = (corners[corner_index] + coord/side_length * - (corners[corner_index+1] - corners[corner_index])) + new_point = corners[corner_index] + coord / side_length * ( + corners[corner_index + 1] - corners[corner_index] + ) return new_point - def normal(self, points, params=Points.empty(), device='cpu'): - points, params, device = \ - self._transform_input_for_normals(points, params, device) + def normal(self, points, params=Points.empty(), device="cpu"): + points, params, device = self._transform_input_for_normals( + points, params, device + ) points = points.as_tensor outline = self.domain.outline(device=device) index = self._where_on_boundary(points, outline) @@ -271,8 +290,8 @@ def _compute_normals(self, outline): normal_list = torch.zeros((face_number, 2)) index = 0 for corners in outline: - for i in range(len(corners)-1): - normal = self._compute_local_normal_vector(corners[i+1], corners[i]) + for i in range(len(corners) - 1): + normal = self._compute_local_normal_vector(corners[i + 1], corners[i]) normal_list[index] = normal index += 1 return normal_list @@ -289,8 +308,8 @@ def _where_on_boundary(self, points, outline): index = -1 * torch.ones(len(points), dtype=int) counter = 0 for corners in outline: - for i in range(len(corners)-1): - line = s_geo.LineString([corners[i], corners[i+1]]) + for i in range(len(corners) - 1): + line = s_geo.LineString([corners[i], corners[i + 1]]) not_found = torch.where(index < 0)[0] for k in not_found: point = s_geo.Point(points[k]) @@ -298,4 +317,4 @@ def _where_on_boundary(self, points, outline): if abs(distance) <= self.tol: index[k] = counter counter += 1 - return index \ No newline at end of file + return index diff --git a/src/torchphysics/problem/domains/domain2D/triangle.py b/src/torchphysics/problem/domains/domain2D/triangle.py index 653a1a32..6375fc73 100644 --- a/src/torchphysics/problem/domains/domain2D/triangle.py +++ b/src/torchphysics/problem/domains/domain2D/triangle.py @@ -3,8 +3,9 @@ from ..domain import Domain, BoundaryDomain from ...spaces import Points + class Triangle(Domain): - '''Class for triangles. + """Class for triangles. Parameters ---------- @@ -13,11 +14,13 @@ class Triangle(Domain): origin, corner_1, corner_2 : array_like or callable The three corners of the triangle. The corners have to be ordered counter clockwise, to assure that the normal vectors will point outwards. - ''' + """ + def __init__(self, space, origin, corner_1, corner_2): assert space.dim == 2 - origin, corner_1, corner_2 = \ - self.transform_to_user_functions(origin, corner_1, corner_2) + origin, corner_1, corner_2 = self.transform_to_user_functions( + origin, corner_1, corner_2 + ) self.origin = origin self.corner_1 = corner_1 self.corner_2 = corner_2 @@ -31,8 +34,9 @@ def __call__(self, **data): new_vec_1 = self._check_shape_of_evaluated_user_function(new_vec_1) new_vec_2 = self.corner_2.partially_evaluate(**data) new_vec_2 = self._check_shape_of_evaluated_user_function(new_vec_2) - return Triangle(space=self.space, origin=new_origin, - corner_1=new_vec_1, corner_2=new_vec_2) + return Triangle( + space=self.space, origin=new_origin, corner_1=new_vec_1, corner_2=new_vec_2 + ) def _check_shape_of_evaluated_user_function(self, domain_param): if isinstance(domain_param, torch.Tensor): @@ -40,13 +44,13 @@ def _check_shape_of_evaluated_user_function(self, domain_param): return domain_param[0, :] return domain_param - def _get_volume(self, params=Points.empty(), device='cpu'): + def _get_volume(self, params=Points.empty(), device="cpu"): _, _, _, dir_1, _, dir_3 = self._construct_triangle(params, device=device) # volume equals the determinate of the matrix [dir_1, dir_2] / 2 volume = -dir_1[:, :1] * dir_3[:, 1:] + dir_1[:, 1:] * dir_3[:, :1] return volume / 2.0 - def _construct_triangle(self, params=Points.empty(), device='cpu'): + def _construct_triangle(self, params=Points.empty(), device="cpu"): origin = self.origin(params, device).reshape(-1, 2) corner_1 = self.corner_1(params, device).reshape(-1, 2) corner_2 = self.corner_2(params, device).reshape(-1, 2) @@ -55,8 +59,10 @@ def _construct_triangle(self, params=Points.empty(), device='cpu'): dir_3 = origin - corner_2 return origin, corner_1, corner_2, dir_1, dir_2, dir_3 - def bounding_box(self, params=Points.empty(), device='cpu'): - origin, corner_1, corner_2, _, _, _ = self._construct_triangle(params, device=device) + def bounding_box(self, params=Points.empty(), device="cpu"): + origin, corner_1, corner_2, _, _, _ = self._construct_triangle( + params, device=device + ) bounds = [] for i in range(self.dim): dim_i_max, dim_i_min = [], [] @@ -68,8 +74,9 @@ def bounding_box(self, params=Points.empty(), device='cpu'): return torch.tensor(bounds, device=device) def _contains(self, points, params=Points.empty()): - origin, _, _, dir_1, _, dir_3 = \ - self._construct_triangle(points.join(params), device=points.device) + origin, _, _, dir_1, _, dir_3 = self._construct_triangle( + points.join(params), device=points.device + ) points = points[:, list(self.space.keys())].as_tensor points -= origin bary_x, bary_y = self._solve_lgs(points, dir_1, -dir_3) @@ -88,10 +95,11 @@ def _solve_lgs(self, points, dir_1, dir_2): bary_y = torch.divide(y_dir, det) return bary_x, bary_y - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if d: - n = 2*self.compute_n_from_density(d, params) + n = 2 * self.compute_n_from_density(d, params) origin, _, _, dir_1, _, dir_3 = self._construct_triangle(params, device) num_of_params = self.len_of_params(params) bary_coords = torch.rand((num_of_params, n, 2), device=device) @@ -103,26 +111,27 @@ def sample_random_uniform(self, n=None, d=None, params=Points.empty(), return Points(points.reshape(-1, self.space.dim), self.space) def _handle_sum_greater_1(self, d, bary_coords): - sum_bigger_one = (bary_coords.sum(axis=2) >= 1) - if d: # for a given density just remove the points + sum_bigger_one = bary_coords.sum(axis=2) >= 1 + if d: # for a given density just remove the points index = torch.where(torch.logical_not(sum_bigger_one)) return bary_coords[index][None, :] - # for a given number of points, we want the correct number. + # for a given number of points, we want the correct number. # So mirror the points, with sum greater 1, around the point [0.5, 0.5]. # This stays uniform. index = torch.where(sum_bigger_one) - bary_coords[index] = torch.subtract(torch.tensor([[1.0, 1.0]]), - bary_coords[index]) + bary_coords[index] = torch.subtract( + torch.tensor([[1.0, 1.0]]), bary_coords[index] + ) return bary_coords - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): if d: n = self.compute_n_from_density(d, params) origin, _, _, dir_1, _, dir_3 = self._construct_triangle(params, device) bary_coords = self._compute_barycentric_grid(n, dir_1, dir_3, device) - if not d: + if not d: # if the number of points is specified we have to be sure to sample - # the right amount + # the right amount bary_coords = self._grid_has_n_points(n, bary_coords, device) points_in_dir_1 = bary_coords[:, :1] * dir_1 points_in_dir_2 = -bary_coords[:, 1:] * dir_3 @@ -137,25 +146,30 @@ def _compute_barycentric_grid(self, n, dir_1, dir_2, device): side_length_1 = torch.linalg.norm(dir_1, dim=1) side_length_2 = torch.linalg.norm(dir_2, dim=1) # scale the number of point w.r.t. the 'form' of the parallelogram - n_1 = int(torch.sqrt(scaled_n*side_length_1/side_length_2)) - n_2 = int(torch.sqrt(scaled_n*side_length_2/side_length_1)) - x = torch.linspace(0, 1, n_1+2, device=device)[1:-1] # create inner grid, so remove - y = torch.linspace(0, 1, n_2+2, device=device)[1:-1] # first and last value - bary_coords = torch.stack(torch.meshgrid((x, y))).T.reshape(-1, 2) + n_1 = int(torch.sqrt(scaled_n * side_length_1 / side_length_2)) + n_2 = int(torch.sqrt(scaled_n * side_length_2 / side_length_1)) + x = torch.linspace(0, 1, n_1 + 2, device=device)[ + 1:-1 + ] # create inner grid, so remove + y = torch.linspace(0, 1, n_2 + 2, device=device)[1:-1] # first and last value + bary_coords = torch.permute( + torch.stack(torch.meshgrid((x, y))), (2, 1, 0) + ).reshape(-1, 2) index = torch.where(bary_coords.sum(axis=1) <= 1) return bary_coords[index] - def _grid_has_n_points(self, n, bary_coords, device): + def _grid_has_n_points(self, n, bary_coords, device): # if not enough points, add some random ones. if len(bary_coords) < n: random_points = torch.rand((n - len(bary_coords), 2), device=device) index = torch.where(random_points.sum(axis=1) >= 1) - random_points[index] = torch.subtract(torch.tensor([[1.0, 1.0]]), - random_points[index]) + random_points[index] = torch.subtract( + torch.tensor([[1.0, 1.0]]), random_points[index] + ) bary_coords = torch.cat((bary_coords, random_points), dim=0) elif len(bary_coords) > n: # just take the first n elements - bary_coords = bary_coords[:n] + bary_coords = bary_coords[:n] return bary_coords @property @@ -169,15 +183,18 @@ def __init__(self, domain): assert isinstance(domain, Triangle) super().__init__(domain) - def _get_volume(self, params=Points.empty(), device='cpu'): - _, _, _, dir_1, dir_2, dir_3 = self.domain._construct_triangle(params, device=device) + def _get_volume(self, params=Points.empty(), device="cpu"): + _, _, _, dir_1, dir_2, dir_3 = self.domain._construct_triangle( + params, device=device + ) side_1, side_2, side_3 = self._compute_side_length(dir_1, dir_2, dir_3) side_length = side_1 + side_2 + side_3 return side_length.reshape(-1, 1) def _contains(self, points, params=Points.empty()): - origin, _, _, dir_1, _, dir_3 = \ - self.domain._construct_triangle(points.join(params), device=points.device) + origin, _, _, dir_1, _, dir_3 = self.domain._construct_triangle( + points.join(params), device=points.device + ) points = points[:, list(self.space.keys())].as_tensor points -= origin bary_x, bary_y = self.domain._solve_lgs(points, dir_1, -dir_3) @@ -192,20 +209,23 @@ def _bary_coords_close_to_0_or_1(self, bary_coord1, bary_coord2): close_to_0 = torch.isclose(bary_coord1, torch.tensor(0.0)) return torch.logical_and(close_to_0, between_0_1) - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): - # general idea is the same as in the parallelogram class. + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): + # general idea is the same as in the parallelogram class. if d: n = self.compute_n_from_density(d, params) - origin, _, _, dir_1, dir_2, dir_3 = self.domain._construct_triangle(params, device) + origin, _, _, dir_1, dir_2, dir_3 = self.domain._construct_triangle( + params, device + ) side_1, side_2, side_3 = self._compute_side_length(dir_1, dir_2, dir_3) total_length = side_1 + side_2 + side_3 num_of_params = self.len_of_params(params) points = torch.zeros((num_of_params, n, 2), device=device) - bound_location = torch.rand((num_of_params, n, 1), device=device)*total_length - self._transform_interval_to_boundary(dir_1, dir_2, dir_3, - side_1, side_2, side_3, - points, bound_location) + bound_location = torch.rand((num_of_params, n, 1), device=device) * total_length + self._transform_interval_to_boundary( + dir_1, dir_2, dir_3, side_1, side_2, side_3, points, bound_location + ) points += origin[:, None, :] return Points(points.reshape(-1, self.space.dim), self.space) @@ -215,40 +235,46 @@ def _compute_side_length(self, dir_1, dir_2, dir_3): side_length_3 = torch.linalg.norm(dir_3, dim=1).view(-1, 1, 1) return side_length_1, side_length_2, side_length_3 - def _transform_interval_to_boundary(self, dir_1, dir_2, dir_3, - side_1, side_2, side_3, - points, bound_location): + def _transform_interval_to_boundary( + self, dir_1, dir_2, dir_3, side_1, side_2, side_3, points, bound_location + ): self._scale_points_on_side(dir_1, side_1, points, bound_location) self._scale_points_on_side(dir_2, side_2, points, bound_location) self._scale_points_on_side(dir_3, side_3, points, bound_location) def _scale_points_on_side(self, dir, side_length, points, bound_location): - scale = torch.clamp(bound_location/side_length, min=0, max=1) + scale = torch.clamp(bound_location / side_length, min=0, max=1) points += scale * dir[:, None] bound_location -= side_length - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): if d: n = self.compute_n_from_density(d, params) - origin, _, _, dir_1, dir_2, dir_3 = self.domain._construct_triangle(params, device) + origin, _, _, dir_1, dir_2, dir_3 = self.domain._construct_triangle( + params, device + ) side_1, side_2, side_3 = self._compute_side_length(dir_1, dir_2, dir_3) total_length = side_1 + side_2 + side_3 num_of_params = self.len_of_params(params) points = torch.zeros((num_of_params, n, 2), device=device) - bound_grid = torch.linspace(0, 1, n+1, device=device)[:-1] # last point would be double - bound_grid = bound_grid.repeat(num_of_params).view(num_of_params, n, 1) + bound_grid = torch.linspace(0, 1, n + 1, device=device)[ + :-1 + ] # last point would be double + bound_grid = bound_grid.repeat(num_of_params).view(num_of_params, n, 1) bound_location = bound_grid * total_length - self._transform_interval_to_boundary(dir_1, dir_2, dir_3, - side_1, side_2, side_3, - points, bound_location) + self._transform_interval_to_boundary( + dir_1, dir_2, dir_3, side_1, side_2, side_3, points, bound_location + ) points += origin[:, None, :] return Points(points.reshape(-1, self.space.dim), self.space) - def normal(self, points, params=Points.empty(), device='cpu'): - points, params, device = \ - self._transform_input_for_normals(points, params, device) - origin, _, _, dir_1, dir_2, dir_3 = \ - self.domain._construct_triangle(points.join(params), device) + def normal(self, points, params=Points.empty(), device="cpu"): + points, params, device = self._transform_input_for_normals( + points, params, device + ) + origin, _, _, dir_1, dir_2, dir_3 = self.domain._construct_triangle( + points.join(params), device + ) points = points[:, list(self.space.keys())].as_tensor normals = torch.zeros_like(points, device=device) bary_x, bary_y = self.domain._solve_lgs(points - origin, dir_1, -dir_3) @@ -268,9 +294,8 @@ def _add_local_normal_vector(self, normals, bary_coord, normal, i): normals += normal * close_to_i def _get_normal_direction(self, direction, device): - # to get normal vector in 2d switch x and y coordinate and multiply + # to get normal vector in 2d switch x and y coordinate and multiply # one coordinate with -1 - normal = torch.index_select(direction, 1, - torch.tensor([1, 0], device=device)) + normal = torch.index_select(direction, 1, torch.tensor([1, 0], device=device)) normal[:, 1:] *= -1 - return torch.divide(normal, torch.linalg.norm(normal, dim=1).reshape(-1, 1)) \ No newline at end of file + return torch.divide(normal, torch.linalg.norm(normal, dim=1).reshape(-1, 1)) diff --git a/src/torchphysics/problem/domains/domain3D/__init__.py b/src/torchphysics/problem/domains/domain3D/__init__.py index c5809498..7acd80ea 100644 --- a/src/torchphysics/problem/domains/domain3D/__init__.py +++ b/src/torchphysics/problem/domains/domain3D/__init__.py @@ -1 +1 @@ -from .sphere import Sphere \ No newline at end of file +from .sphere import Sphere diff --git a/src/torchphysics/problem/domains/domain3D/sphere.py b/src/torchphysics/problem/domains/domain3D/sphere.py index 1fb4c563..8eae5b83 100644 --- a/src/torchphysics/problem/domains/domain3D/sphere.py +++ b/src/torchphysics/problem/domains/domain3D/sphere.py @@ -17,8 +17,9 @@ class Sphere(Domain): radius : number or callable The radius of the sphere. """ + def __init__(self, space, center, radius): - assert space.dim == 3 + assert space.dim == 3 center, radius = self.transform_to_user_functions(center, radius) self.center = center self.radius = radius @@ -30,18 +31,20 @@ def __call__(self, **data): new_radius = self.radius.partially_evaluate(**data) return Sphere(space=self.space, center=new_center, radius=new_radius) - def _compute_center_and_radius(self, params=Points.empty(), device='cpu'): + def _compute_center_and_radius(self, params=Points.empty(), device="cpu"): center = self.center(params, device).reshape(-1, 3) radius = self.radius(params, device) - return center,radius + return center, radius def _contains(self, points, params=Points.empty()): - center, radius = self._compute_center_and_radius(points.join(params), device=points.device) + center, radius = self._compute_center_and_radius( + points.join(params), device=points.device + ) points = points[:, list(self.space.keys())].as_tensor norm = torch.linalg.norm(points - center, dim=1).reshape(-1, 1) return torch.le(norm[:, None], radius).reshape(-1, 1) - def bounding_box(self, params=Points.empty(), device='cpu'): + def bounding_box(self, params=Points.empty(), device="cpu"): center, radius = self._compute_center_and_radius(params, device=device) bounds = [] for i in range(self.dim): @@ -51,23 +54,24 @@ def bounding_box(self, params=Points.empty(), device='cpu'): bounds.append(i_max.item()) return torch.tensor(bounds, device=device) - def _get_volume(self, params=Points.empty(), device='cpu'): + def _get_volume(self, params=Points.empty(), device="cpu"): radius = self.radius(params, device=device) - volume = 3.0/4.0 * np.pi * radius**3 + volume = 3.0 / 4.0 * np.pi * radius**3 return volume.reshape(-1, 1) - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if d: n = self.compute_n_from_density(d, params) center, radius = self._compute_center_and_radius(params, device) num_of_params = self.len_of_params(params) # take cubic root to stay uniform - r = torch.pow(torch.rand((num_of_params, n, 1), device=device), 1/3.0) + r = torch.pow(torch.rand((num_of_params, n, 1), device=device), 1 / 3.0) r *= radius phi = 2 * np.pi * torch.rand((num_of_params, n, 1), device=device) theta = torch.rand((num_of_params, n, 1), device=device) - theta = torch.arccos(2*theta - 1) - np.pi/2.0 + theta = torch.arccos(2 * theta - 1) - np.pi / 2.0 x = torch.multiply(torch.multiply(r, torch.cos(phi)), torch.cos(theta)) y = torch.multiply(torch.multiply(r, torch.sin(phi)), torch.cos(theta)) z = torch.multiply(r, torch.sin(theta)) @@ -76,7 +80,7 @@ def sample_random_uniform(self, n=None, d=None, params=Points.empty(), points += center[:, None, :] return Points(points.reshape(-1, self.space.dim), self.space) - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): if d: n = self.compute_n_from_density(d, params) if n > 10: @@ -92,22 +96,25 @@ def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): return Points(finals_points, self.space) def _point_grid_in_box(self, n, radius, device): - scaled_n = int(np.ceil(np.cbrt(n*6/np.pi))) + scaled_n = int(np.ceil(np.cbrt(n * 6 / np.pi))) axis = torch.linspace(-radius, radius, scaled_n, device=device) - points = torch.stack(torch.meshgrid(axis, axis, axis)).T + points = torch.permute( + torch.stack(torch.meshgrid(axis, axis, axis)), (3, 2, 1, 0) + ) return points.reshape(-1, 3) def _get_points_inside(self, points, radius): norm = torch.linalg.norm(points, dim=1).reshape(-1, 1) - inside = (norm <= radius) + inside = norm <= radius index = torch.where(inside)[0] return points[index] def _append_random(self, points_inside, n, params, device): if len(points_inside) == n: return points_inside - random_points = self.sample_random_uniform(n=n-len(points_inside), - params=params, device=device) + random_points = self.sample_random_uniform( + n=n - len(points_inside), params=params, device=device + ) random_points = random_points[:, list(self.space.keys())].as_tensor return torch.cat((points_inside, random_points), dim=0) @@ -123,25 +130,28 @@ def __init__(self, domain): super().__init__(domain) def _contains(self, points, params=Points.empty()): - center, radius = self.domain._compute_center_and_radius(points.join(params), device=points.device) + center, radius = self.domain._compute_center_and_radius( + points.join(params), device=points.device + ) points = points[:, list(self.space.keys())].as_tensor norm = torch.linalg.norm(points - center, dim=1).reshape(-1, 1) return torch.isclose(norm[:, None], radius).reshape(-1, 1) - def _get_volume(self, params=Points.empty(), device='cpu'): + def _get_volume(self, params=Points.empty(), device="cpu"): radius = self.domain.radius(params, device=device) volume = 4 * np.pi * radius**2 return volume.reshape(-1, 1) - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if d: n = self.compute_n_from_density(d, params) center, radius = self.domain._compute_center_and_radius(params, device) num_of_params = self.len_of_params(params) phi = 2 * np.pi * torch.rand((num_of_params, n, 1), device=device) theta = torch.rand((num_of_params, n, 1), device=device) - theta = torch.arccos(2*theta - 1) - np.pi/2.0 + theta = torch.arccos(2 * theta - 1) - np.pi / 2.0 x = torch.multiply(torch.multiply(radius, torch.cos(phi)), torch.cos(theta)) y = torch.multiply(torch.multiply(radius, torch.sin(phi)), torch.cos(theta)) z = torch.multiply(radius, torch.sin(theta)) @@ -149,7 +159,7 @@ def sample_random_uniform(self, n=None, d=None, params=Points.empty(), points += center[:, None, :] return Points(points.reshape(-1, self.space.dim), self.space) - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): if d: n = self.compute_n_from_density(d, params) center, radius = self.domain._compute_center_and_radius(params, device) @@ -157,9 +167,9 @@ def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): # evenly-distributing-n-points-on-a-sphere points = [] # Use Fibonacci-Sphere for radius = 1, and then scale this sphere - phi = np.pi * (3.0 - np.sqrt(5.0)) # golden angle in radians + phi = np.pi * (3.0 - np.sqrt(5.0)) # golden angle in radians index = torch.arange(0, n, device=device) - y = 1 - index / (n-1) * 2 # y goes from 1 to -1 + y = 1 - index / (n - 1) * 2 # y goes from 1 to -1 current_radius = torch.sqrt(1 - y**2) theta = phi * index x = current_radius * torch.cos(theta) @@ -170,10 +180,13 @@ def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): points = torch.add(points, center) return Points(points, self.space) - def normal(self, points, params=Points.empty(), device='cpu'): - points, params, device = \ - self._transform_input_for_normals(points, params, device) - center, radius = self.domain._compute_center_and_radius(points.join(params), device) + def normal(self, points, params=Points.empty(), device="cpu"): + points, params, device = self._transform_input_for_normals( + points, params, device + ) + center, radius = self.domain._compute_center_and_radius( + points.join(params), device + ) points = points[:, list(self.space.keys())].as_tensor normal = points - center - return torch.divide(normal[:, None], radius).reshape(-1, 3) \ No newline at end of file + return torch.divide(normal[:, None], radius).reshape(-1, 3) diff --git a/src/torchphysics/problem/domains/domain3D/trimesh_polyhedron.py b/src/torchphysics/problem/domains/domain3D/trimesh_polyhedron.py index 66e93ab8..815db766 100644 --- a/src/torchphysics/problem/domains/domain3D/trimesh_polyhedron.py +++ b/src/torchphysics/problem/domains/domain3D/trimesh_polyhedron.py @@ -10,17 +10,17 @@ class TrimeshPolyhedron(Domain): - '''Class for polygons in 3D. Uses the trimesh-package. + """Class for polygons in 3D. Uses the trimesh-package. Parameters ---------- space : Space The space in which this object lays. - vertices : list of lists, optional + vertices : list of lists, optional The vertices of the polygon. - faces : list of lists, optional + faces : list of lists, optional A list that contains which vetrices have to be connected to create the faces - of the polygon. If for example the vertices 1, 2 and 3 have should be + of the polygon. If for example the vertices 1, 2 and 3 have should be connected do: faces = [[1, 2, 3]] file_name : str or file-like object, optional A data source to load a existing polygon/mesh. @@ -28,15 +28,23 @@ class TrimeshPolyhedron(Domain): The file type, e.g. 'stl'. See trimesh.available_formats() for all supported file types. tol : number, optional - The error tolerance for checking if points at the boundary. And used for + The error tolerance for checking if points at the boundary. And used for projections and slicing the mesh. Note ---- This class can not be dependent on other variables. - ''' - def __init__(self, space, vertices=None, faces=None, - file_name=None, file_type='stl', tol=1.e-06): + """ + + def __init__( + self, + space, + vertices=None, + faces=None, + file_name=None, + file_type="stl", + tol=1.0e-06, + ): assert space.dim == 3 if vertices is not None and faces is not None: if callable(vertices) or callable(faces): @@ -45,8 +53,10 @@ def __init__(self, space, vertices=None, faces=None, elif file_name is not None: self.mesh = trimesh.load_mesh(file_name, file_type=file_type) else: - raise ValueError('Needs either vertices and faces to create a new' \ - 'polygon, or a file to load a existing one.') + raise ValueError( + "Needs either vertices and faces to create a new" + "polygon, or a file to load a existing one." + ) self.mesh.fix_normals() super().__init__(space, dim=3) self.necessary_variables = {} @@ -56,18 +66,19 @@ def __init__(self, space, vertices=None, faces=None, logging.getLogger("trimesh").setLevel(logging.ERROR) def export_file(self, name_of_file): - '''Exports the mesh to a file. - + """Exports the mesh to a file. + Parameters ---------- name_of_file : str The name of the file. - ''' + """ self.mesh.export(name_of_file) - def project_on_plane(self, new_space, plane_origin=[0, 0, 0], - plane_normal=[0, 0, 1]): - '''Projects the polygon on a plane. + def project_on_plane( + self, new_space, plane_origin=[0, 0, 0], plane_normal=[0, 0, 1] + ): + """Projects the polygon on a plane. Parameters ---------- @@ -77,25 +88,27 @@ def project_on_plane(self, new_space, plane_origin=[0, 0, 0], The origin of the projection plane. plane_normal : array_like, optional The normal vector of the projection plane. It is enough if it points in the - direction of normal vector, it does not norm = 1. - + direction of normal vector, it does not norm = 1. + Returns ---------- ShapelyPolygon - The polygon that is the outline of the projected original mesh on + The polygon that is the outline of the projected original mesh on the plane. - ''' + """ norm = np.linalg.norm(plane_normal) if not np.isclose(norm, 1): plane_normal /= norm - polygon = trimesh.path.polygons.projected(self.mesh, origin=plane_origin, - normal=plane_normal) + polygon = trimesh.path.polygons.projected( + self.mesh, origin=plane_origin, normal=plane_normal + ) polygon = polygon.simplify(self.tol) return ShapelyPolygon(space=new_space, shapely_polygon=polygon) - def slice_with_plane(self, new_space, plane_origin=[0, 0, 0], - plane_normal=[0, 0, 1]): - '''Slices the polygon with a plane. + def slice_with_plane( + self, new_space, plane_origin=[0, 0, 0], plane_normal=[0, 0, 1] + ): + """Slices the polygon with a plane. Parameters ---------- @@ -105,22 +118,21 @@ def slice_with_plane(self, new_space, plane_origin=[0, 0, 0], The origin of the plane. plane_normal : array_like, optional The normal vector of the projection plane. It is enough if it points in the - direction of normal vector, it does not norm = 1. - + direction of normal vector, it does not norm = 1. + Returns ---------- ShapelyPolygon - The polygon that is the outline of the projected original mesh on + The polygon that is the outline of the projected original mesh on the plane. - ''' + """ norm = np.linalg.norm(plane_normal) if not np.isclose(norm, 1): plane_normal /= norm rotaion_matrix = self._create_rotation_matrix_to_plane(plane_normal) - slice = self.mesh.section(plane_origin=plane_origin, - plane_normal=plane_normal) + slice = self.mesh.section(plane_origin=plane_origin, plane_normal=plane_normal) if slice is None: - raise RuntimeError('slice of mesh and plane is empty!') + raise RuntimeError("slice of mesh and plane is empty!") slice_2D = slice.to_planar(to_2D=rotaion_matrix, check=False)[0] polygon = slice_2D.polygons_full[0] polygon = polygon.simplify(self.tol) @@ -129,29 +141,32 @@ def slice_with_plane(self, new_space, plane_origin=[0, 0, 0], def _create_rotation_matrix_to_plane(self, plane_normal): u = [plane_normal[1], -plane_normal[0], 0] cos = plane_normal[2] - sin = np.sqrt(plane_normal[0]**2 + plane_normal[1]**2) - matrix = [[cos+u[0]**2*(1-cos), u[0]*u[1]*(1-cos), -u[1]*sin, 0], - [u[0]*u[1]*(1-cos), cos+u[1]**2*(1-cos), u[0]*sin, 0], - [-u[1]*sin, u[0]*sin, -cos, 0], - [0, 0, 0, 1]] + sin = np.sqrt(plane_normal[0] ** 2 + plane_normal[1] ** 2) + matrix = [ + [cos + u[0] ** 2 * (1 - cos), u[0] * u[1] * (1 - cos), -u[1] * sin, 0], + [u[0] * u[1] * (1 - cos), cos + u[1] ** 2 * (1 - cos), u[0] * sin, 0], + [-u[1] * sin, u[0] * sin, -cos, 0], + [0, 0, 0, 1], + ] return matrix def __call__(self, **data): return self - def bounding_box(self, params=Points.empty(), device='cpu'): + def bounding_box(self, params=Points.empty(), device="cpu"): bound_corners = self.mesh.bounds - return torch.tensor(bound_corners.T.flatten(), device=device, - dtype=torch.float32) + return torch.tensor( + bound_corners.T.flatten(), device=device, dtype=torch.float32 + ) - def _get_volume(self, params=Points.empty(), device='cpu'): + def _get_volume(self, params=Points.empty(), device="cpu"): volume = self.mesh.volume return torch.tensor(volume, device=device).reshape(-1, 1) def _contains(self, points, params=Points.empty()): if isinstance(points, Points): points = points.as_tensor - inside = self.mesh.contains(points).reshape(-1,1) + inside = self.mesh.contains(points).reshape(-1, 1) return torch.tensor(inside) def _compute_number_of_points(self, n, d, params): @@ -161,19 +176,22 @@ def _compute_number_of_points(self, n, d, params): n *= num_of_params return n - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): n = self._compute_number_of_points(n, d, params) points = torch.empty((0, self.dim), dtype=torch.float32, device=device) computed_points = 0 while computed_points < n: - new_points = trimesh.sample.volume_mesh(self.mesh, n-computed_points) - points = torch.cat((points, torch.tensor(new_points, device=device, - dtype=torch.float32)),dim=0) + new_points = trimesh.sample.volume_mesh(self.mesh, n - computed_points) + points = torch.cat( + (points, torch.tensor(new_points, device=device, dtype=torch.float32)), + dim=0, + ) computed_points += len(new_points) return Points(points, self.space) - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): n = self._compute_number_of_points(n, d, params) bounds = self.bounding_box(params, device=device) points = self._point_grid_in_bounding_box(n, bounds, device) @@ -184,7 +202,7 @@ def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): def _point_grid_in_bounding_box(self, n, bounds, device): b_box_volume = self._get_bounding_box_volume(bounds) volume = self._get_volume(device=device).item() - scaled_n = int(np.ceil(np.cbrt(n*b_box_volume/volume))) + scaled_n = int(np.ceil(np.cbrt(n * b_box_volume / volume))) x_axis = torch.linspace(bounds[0], bounds[1], scaled_n, device=device) y_axis = torch.linspace(bounds[2], bounds[3], scaled_n, device=device) z_axis = torch.linspace(bounds[4], bounds[5], scaled_n, device=device) @@ -194,7 +212,7 @@ def _point_grid_in_bounding_box(self, n, bounds, device): def _get_bounding_box_volume(self, bounds): b_box_volume = 1 for i in range(self.dim): - b_box_volume *= bounds[2*i+1] - bounds[2*i] + b_box_volume *= bounds[2 * i + 1] - bounds[2 * i] return b_box_volume def _get_points_inside(self, points): @@ -217,34 +235,36 @@ def _contains(self, points, params=Points.empty()): points = points.as_tensor distance = trimesh.proximity.signed_distance(self.domain.mesh, points) abs_dist = torch.absolute(torch.tensor(distance)) - on_bound = (abs_dist <= self.domain.tol) - return on_bound.reshape(-1,1) + on_bound = abs_dist <= self.domain.tol + return on_bound.reshape(-1, 1) - def _get_volume(self, params=Points.empty(), device='cpu'): + def _get_volume(self, params=Points.empty(), device="cpu"): area = sum(self.domain.mesh.area_faces) return torch.tensor(area, device=device).reshape(-1, 1) - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): n = self.domain._compute_number_of_points(n, d, params) points = trimesh.sample.sample_surface(self.domain.mesh, n)[0] tensor_points = torch.tensor(points, device=device, dtype=torch.float32) return Points(tensor_points, self.space) - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): n = self.domain._compute_number_of_points(n, d, params) points = trimesh.sample.sample_surface_even(self.domain.mesh, n)[0] points = torch.tensor(points, device=device, dtype=torch.float32) points = Sphere._append_random(self, points, n, params, device) return Points(points, self.space) - def normal(self, points, params=Points.empty(), device='cpu'): - points, params, device = \ - self._transform_input_for_normals(points, params, device) + def normal(self, points, params=Points.empty(), device="cpu"): + points, params, device = self._transform_input_for_normals( + points, params, device + ) points = points.as_tensor.detach().cpu() index = self.domain.mesh.nearest.on_surface(points)[2] mesh_normals = torch.tensor(self.domain.mesh.face_normals, device=device) normals = torch.zeros((len(points), 3), device=device) for i in range(len(points)): normals[i, :] = mesh_normals[index[i]] - return normals \ No newline at end of file + return normals diff --git a/src/torchphysics/problem/domains/domainoperations/cut.py b/src/torchphysics/problem/domains/domainoperations/cut.py index c28592b9..c272fcaa 100644 --- a/src/torchphysics/problem/domains/domainoperations/cut.py +++ b/src/torchphysics/problem/domains/domainoperations/cut.py @@ -3,8 +3,12 @@ from ..domain import Domain, BoundaryDomain from ...spaces import Points -from .sampler_helper import (_boundary_grid_with_n, _inside_grid_with_n, - _inside_random_with_n, _boundary_random_with_n) +from .sampler_helper import ( + _boundary_grid_with_n, + _inside_grid_with_n, + _inside_random_with_n, + _boundary_random_with_n, +) class CutDomain(Domain): @@ -15,8 +19,9 @@ class CutDomain(Domain): domain_a : Domain The first domain. domain_b : Domain - The second domain. + The second domain. """ + def __init__(self, domain_a: Domain, domain_b: Domain, contained=False): assert domain_a.space == domain_b.space self.domain_a = domain_a @@ -36,47 +41,65 @@ def _contains(self, points, params=Points.empty()): in_b = self.domain_b._contains(points, params) return torch.logical_and(in_a, torch.logical_not(in_b)) - def _get_volume(self, params=Points.empty(), device='cpu'): + def _get_volume(self, params=Points.empty(), device="cpu"): if not self.contained: - warnings.warn("""Exact volume of this cut is not known, will use the + warnings.warn( + """Exact volume of this cut is not known, will use the estimate: volume = domain_a.volume. If you need the exact volume for sampling, - use domain.set_volume()""") + use domain.set_volume()""" + ) return self.domain_a.volume(params, device=device) volume_a = self.domain_a.volume(params, device=device) volume_b = self.domain_b.volume(params, device=device) return volume_a - volume_b - def bounding_box(self, params=Points.empty(), device='cpu'): + def bounding_box(self, params=Points.empty(), device="cpu"): return self.domain_a.bounding_box(params, device=device) - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if n: - return _inside_random_with_n(self, self.domain_a, self.domain_b, n=n, - params=params, invert=True, device=device) + return _inside_random_with_n( + self, + self.domain_a, + self.domain_b, + n=n, + params=params, + invert=True, + device=device, + ) return self._sample_random_with_d(d, params, device) - def _sample_random_with_d(self, d, params=Points.empty(), device='cpu'): - points_a = self.domain_a.sample_random_uniform(d=d, params=params, - device=device) + def _sample_random_with_d(self, d, params=Points.empty(), device="cpu"): + points_a = self.domain_a.sample_random_uniform( + d=d, params=params, device=device + ) return self._cut_points(points_a, params) def _cut_points(self, points_a, params=Points.empty()): # check which points are in domain b n = len(points_a) _, repeated_params = self._repeat_params(n, params) - in_b = self.domain_b._contains(points=points_a, params=repeated_params) + in_b = self.domain_b._contains(points=points_a, params=repeated_params) index = torch.where(torch.logical_not(in_b))[0] - return points_a[index, ] + return points_a[index,] - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): if n: - return _inside_grid_with_n(self, self.domain_a, self.domain_b, n=n, - params=params, invert=True, device=device) + return _inside_grid_with_n( + self, + self.domain_a, + self.domain_b, + n=n, + params=params, + invert=True, + device=device, + ) return self._sample_grid_with_d(d, params, device) - def _sample_grid_with_d(self, d, params=Points.empty(), device='cpu'): + def _sample_grid_with_d(self, d, params=Points.empty(), device="cpu"): points_a = self.domain_a.sample_grid(d=d, params=params, device=device) return self._cut_points(points_a, params) @@ -102,34 +125,42 @@ def _contains(self, points, params=Points.empty()): on_b_part = torch.logical_and(on_b_part, torch.logical_not(on_a_bound)) return torch.logical_or(on_a_part, on_b_part) - def _get_volume(self, params=Points.empty(), device='cpu'): + def _get_volume(self, params=Points.empty(), device="cpu"): if not self.domain.contained: - warnings.warn("""Exact volume of this domain boundary is not known, + warnings.warn( + """Exact volume of this domain boundary is not known, will use the estimate: volume = domain_a.volume + domain_b.volume. If you need the exact volume for sampling, - use domain.set_volume().""") + use domain.set_volume().""" + ) volume_a = self.domain.domain_a.boundary.volume(params, device=device) volume_b = self.domain.domain_b.boundary.volume(params, device=device) return volume_a + volume_b - - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if n: - return _boundary_random_with_n(self, self.domain.domain_a, - self.domain.domain_b, n, - params, device=device) + return _boundary_random_with_n( + self, + self.domain.domain_a, + self.domain.domain_b, + n, + params, + device=device, + ) return self._sample_random_with_d(d, params, device) - def _sample_random_with_d(self, d, params=Points.empty(), device='cpu'): - points_a = self.domain.domain_a.boundary.sample_random_uniform(d=d, - device=device, - params=params) + def _sample_random_with_d(self, d, params=Points.empty(), device="cpu"): + points_a = self.domain.domain_a.boundary.sample_random_uniform( + d=d, device=device, params=params + ) points_a = self.domain._cut_points(points_a, params) - points_b = self.domain.domain_b.boundary.sample_random_uniform(d=d, - params=params, - device=device) - points_b = self._delete_outer_points(points_b, self.domain.domain_a, params) + points_b = self.domain.domain_b.boundary.sample_random_uniform( + d=d, params=params, device=device + ) + points_b = self._delete_outer_points(points_b, self.domain.domain_a, params) return points_a | points_b def _delete_outer_points(self, points, domain, params=Points.empty()): @@ -139,28 +170,32 @@ def _delete_outer_points(self, points, domain, params=Points.empty()): on_bound = domain.boundary._contains(points, repeated_params) inside = torch.logical_and(inside, torch.logical_not(on_bound)) index = torch.where(inside)[0] - return points[index, ] + return points[index,] - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): if n: - return _boundary_grid_with_n(self, self.domain.domain_a, - self.domain.domain_b, n, params, device) + return _boundary_grid_with_n( + self, self.domain.domain_a, self.domain.domain_b, n, params, device + ) return self._sample_grid_with_d(d, params, device) - def _sample_grid_with_d(self, d, params=Points.empty(), device='cpu'): - points_a = self.domain.domain_a.boundary.sample_grid(d=d, params=params, - device=device) + def _sample_grid_with_d(self, d, params=Points.empty(), device="cpu"): + points_a = self.domain.domain_a.boundary.sample_grid( + d=d, params=params, device=device + ) points_a = self.domain._cut_points(points_a, params) - points_b = self.domain.domain_b.boundary.sample_grid(d=d, params=params, - device=device) - points_b = self._delete_outer_points(points_b, self.domain.domain_a, params) - return points_a | points_b - - def normal(self, points, params=Points.empty(), device='cpu'): - points, params, device = \ - self._transform_input_for_normals(points, params, device) + points_b = self.domain.domain_b.boundary.sample_grid( + d=d, params=params, device=device + ) + points_b = self._delete_outer_points(points_b, self.domain.domain_a, params) + return points_a | points_b + + def normal(self, points, params=Points.empty(), device="cpu"): + points, params, device = self._transform_input_for_normals( + points, params, device + ) a_normals = self.domain.domain_a.boundary.normal(points, params, device) b_normals = self.domain.domain_b.boundary.normal(points, params, device) on_a = self.domain.domain_a.boundary._contains(points, params) normals = torch.where(on_a, a_normals, -b_normals) - return normals \ No newline at end of file + return normals diff --git a/src/torchphysics/problem/domains/domainoperations/intersection.py b/src/torchphysics/problem/domains/domainoperations/intersection.py index 34ce8144..65eafb41 100644 --- a/src/torchphysics/problem/domains/domainoperations/intersection.py +++ b/src/torchphysics/problem/domains/domainoperations/intersection.py @@ -3,8 +3,12 @@ from ..domain import Domain, BoundaryDomain from ...spaces import Points -from .sampler_helper import (_boundary_grid_with_n, _inside_grid_with_n, - _inside_random_with_n, _boundary_random_with_n) +from .sampler_helper import ( + _boundary_grid_with_n, + _inside_grid_with_n, + _inside_random_with_n, + _boundary_random_with_n, +) class IntersectionDomain(Domain): @@ -15,8 +19,9 @@ class IntersectionDomain(Domain): domain_a : Domain The first domain. domain_b : Domain - The second domain. + The second domain. """ + def __init__(self, domain_a: Domain, domain_b: Domain): assert domain_a.space == domain_b.space self.domain_a = domain_a @@ -35,52 +40,69 @@ def _contains(self, points, params=Points.empty()): in_b = self.domain_b._contains(points, params) return torch.logical_and(in_a, in_b) - def _get_volume(self, params=Points.empty(), device='cpu'): - warnings.warn("""Exact volume of this intersection is not known, + def _get_volume(self, params=Points.empty(), device="cpu"): + warnings.warn( + """Exact volume of this intersection is not known, will use the estimate: volume = domain_a.volume. If you need the exact volume for sampling, - use domain.set_volume()""") + use domain.set_volume()""" + ) return self.domain_a.volume(params, device=device) - def bounding_box(self, params=Points.empty(), device='cpu'): + def bounding_box(self, params=Points.empty(), device="cpu"): bounds_a = self.domain_a.bounding_box(params, device=device) bounds_b = self.domain_b.bounding_box(params, device=device) bounds = [] for i in range(self.space.dim): - bounds.append(max([bounds_a[2*i], bounds_b[2*i]])) - bounds.append(min([bounds_a[2*i+1], bounds_b[2*i+1]])) + bounds.append(max([bounds_a[2 * i], bounds_b[2 * i]])) + bounds.append(min([bounds_a[2 * i + 1], bounds_b[2 * i + 1]])) return torch.tensor(bounds, device=device) - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if n: - return _inside_random_with_n(self, self.domain_a, self.domain_b, - n=n, params=params, invert=False, - device=device) + return _inside_random_with_n( + self, + self.domain_a, + self.domain_b, + n=n, + params=params, + invert=False, + device=device, + ) return self._sample_random_with_d(d, params, device) - def _sample_random_with_d(self, d, params=Points.empty(), device='cpu'): - points_a = self.domain_a.sample_random_uniform(d=d, params=params, device=device) + def _sample_random_with_d(self, d, params=Points.empty(), device="cpu"): + points_a = self.domain_a.sample_random_uniform( + d=d, params=params, device=device + ) return self._cut_points(points_a, params) def _cut_points(self, points, params=Points.empty()): # check which points are in domain b n = len(params) _, repeated_params = self._repeat_params(n, params) - in_b = self.domain_b._contains(points=points, params=repeated_params) + in_b = self.domain_b._contains(points=points, params=repeated_params) index = torch.where(in_b)[0] - return points[index, ] + return points[index,] - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): if n: - return _inside_grid_with_n(self, self.domain_a, self.domain_b, - n=n, params=params, invert=False, - device=device) + return _inside_grid_with_n( + self, + self.domain_a, + self.domain_b, + n=n, + params=params, + invert=False, + device=device, + ) return self._sample_grid_with_d(d, params, device) - def _sample_grid_with_d(self, d, params=Points.empty(), device='cpu'): + def _sample_grid_with_d(self, d, params=Points.empty(), device="cpu"): points_a = self.domain_a.sample_grid(d=d, params=params, device=device) - return self._cut_points(points_a, params) + return self._cut_points(points_a, params) @property def boundary(self): @@ -103,63 +125,78 @@ def _contains(self, points, params=Points.empty()): on_b_part = torch.logical_and(on_b_bound, in_a) return torch.logical_or(on_a_part, on_b_part) - def _get_volume(self, params=Points.empty(), device='cpu'): - warnings.warn("""Exact volume of this intersection-boundary is not known, + def _get_volume(self, params=Points.empty(), device="cpu"): + warnings.warn( + """Exact volume of this intersection-boundary is not known, will use the estimate: volume = boundary_a + bounadry_b. If you need the exact volume for sampling, - use domain.set_volume()""") + use domain.set_volume()""" + ) volume_a = self.domain.domain_a.boundary.volume(params, device=device) volume_b = self.domain.domain_b.boundary.volume(params, device=device) return volume_a + volume_b - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if n: - return _boundary_random_with_n(self, self.domain.domain_a, - self.domain.domain_b, n, params, - device=device) + return _boundary_random_with_n( + self, + self.domain.domain_a, + self.domain.domain_b, + n, + params, + device=device, + ) return self._sample_random_with_d(d, params, device) - - def _sample_random_with_d(self, d, params=Points.empty(), device='cpu'): - points_a = self.domain.domain_a.boundary.sample_random_uniform(d=d, - params=params, - device=device) - points_a = self._delete_outer_points(points_a, self.domain.domain_b, params) - points_b = self.domain.domain_b.boundary.sample_random_uniform(d=d, - params=params, - device=device) - points_b = self._delete_outer_points(points_b, self.domain.domain_a, params) - return points_a | points_b + def _sample_random_with_d(self, d, params=Points.empty(), device="cpu"): + points_a = self.domain.domain_a.boundary.sample_random_uniform( + d=d, params=params, device=device + ) + points_a = self._delete_outer_points(points_a, self.domain.domain_b, params) + points_b = self.domain.domain_b.boundary.sample_random_uniform( + d=d, params=params, device=device + ) + points_b = self._delete_outer_points(points_b, self.domain.domain_a, params) + return points_a | points_b def _delete_outer_points(self, points, domain, params): n = len(points) _, repeated_params = self._repeat_params(n, params) inside = domain._contains(points, repeated_params) index = torch.where(inside)[0] - return points[index, ] + return points[index,] - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): if n: - return _boundary_grid_with_n(self, self.domain.domain_a, - self.domain.domain_b, n, params, - device=device) + return _boundary_grid_with_n( + self, + self.domain.domain_a, + self.domain.domain_b, + n, + params, + device=device, + ) return self._sample_grid_with_d(d, params, device) - def _sample_grid_with_d(self, d, params=Points.empty(), device='cpu'): - points_a = self.domain.domain_a.boundary.sample_grid(d=d, params=params, - device=device) - points_a = self._delete_outer_points(points_a, self.domain.domain_b, params) - points_b = self.domain.domain_b.boundary.sample_grid(d=d, params=params, - device=device) - points_b = self._delete_outer_points(points_b, self.domain.domain_a, params) - return points_a | points_b - - def normal(self, points, params=Points.empty(), device='cpu'): - points, params, device = \ - self._transform_input_for_normals(points, params, device) + def _sample_grid_with_d(self, d, params=Points.empty(), device="cpu"): + points_a = self.domain.domain_a.boundary.sample_grid( + d=d, params=params, device=device + ) + points_a = self._delete_outer_points(points_a, self.domain.domain_b, params) + points_b = self.domain.domain_b.boundary.sample_grid( + d=d, params=params, device=device + ) + points_b = self._delete_outer_points(points_b, self.domain.domain_a, params) + return points_a | points_b + + def normal(self, points, params=Points.empty(), device="cpu"): + points, params, device = self._transform_input_for_normals( + points, params, device + ) a_normals = self.domain.domain_a.boundary.normal(points, params, device) b_normals = self.domain.domain_b.boundary.normal(points, params, device) on_a = self.domain.domain_a.boundary._contains(points, params) normals = torch.where(on_a, a_normals, b_normals) - return normals \ No newline at end of file + return normals diff --git a/src/torchphysics/problem/domains/domainoperations/product.py b/src/torchphysics/problem/domains/domainoperations/product.py index 88a023e9..0b294021 100644 --- a/src/torchphysics/problem/domains/domainoperations/product.py +++ b/src/torchphysics/problem/domains/domainoperations/product.py @@ -10,6 +10,7 @@ N_APPROX_VOLUME = 10 + class ProductDomain(Domain): """ The 'cartesian' product of two domains. Additionally supports dependence of domain_a @@ -23,12 +24,15 @@ class ProductDomain(Domain): domain_b : Domain The second domain. """ + def __init__(self, domain_a, domain_b): self.domain_a = domain_a self.domain_b = domain_b if not self.domain_a.space.keys().isdisjoint(self.domain_b.space): - warnings.warn("""Warning: The space of a ProductDomain will be the product - of its factor domains spaces. This may lead to unexpected behaviour.""") + warnings.warn( + """Warning: The space of a ProductDomain will be the product + of its factor domains spaces. This may lead to unexpected behaviour.""" + ) # check dependencies, so that at most domain_a needs variables of domain_b self._check_variable_dependencies() # set domain params @@ -37,42 +41,48 @@ def __init__(self, domain_a, domain_b): # to set a bounding box self.bounds = None # necessary variables consist of variables of both domains that are not given in domain_b - self.necessary_variables \ - = (self.domain_a.necessary_variables - self.domain_b.space.variables) \ - | self.domain_b.necessary_variables + self.necessary_variables = ( + self.domain_a.necessary_variables - self.domain_b.space.variables + ) | self.domain_b.necessary_variables def _check_variable_dependencies(self): - a_variables_in_b = any(var in self.domain_b.necessary_variables for - var in self.domain_a.space) - b_variables_in_a = any(var in self.domain_a.necessary_variables for - var in self.domain_b.space) + a_variables_in_b = any( + var in self.domain_b.necessary_variables for var in self.domain_a.space + ) + b_variables_in_a = any( + var in self.domain_a.necessary_variables for var in self.domain_b.space + ) name_a = self.domain_a.__class__.__name__ name_b = self.domain_b.__class__.__name__ if a_variables_in_b and b_variables_in_a: - raise AssertionError(f"""Both domains {name_a}, {name_b} depend on the + raise AssertionError( + f"""Both domains {name_a}, {name_b} depend on the variables of the other domain. Will not be able - to resolve order of point creation!""") + to resolve order of point creation!""" + ) elif a_variables_in_b: - raise AssertionError(f"""Domain_b: {name_b} depends on the variables of + raise AssertionError( + f"""Domain_b: {name_b} depends on the variables of domain_a: {name_a}, maybe you meant to use: domain_b * domain_a (multiplication - is not commutative)""") + is not commutative)""" + ) elif b_variables_in_a: self._is_constant = False else: self._is_constant = True def __call__(self, **data): - # evaluate both domains at the given data + # evaluate both domains at the given data domain_a = self.domain_a(**data) domain_b = self.domain_b(**data) # check if the data fixes a variable that would be computed with this domain: a_variables_in_data = all(var in data.keys() for var in self.domain_a.space) b_variables_in_data = all(var in data.keys() for var in self.domain_b.space) - if a_variables_in_data: # domain_a will be a fixed point + if a_variables_in_data: # domain_a will be a fixed point point_data = self._create_point_data(self.domain_a.space, data) domain_a = Point(space=self.domain_a.space, point=point_data) - if b_variables_in_data: # domain_b will be a fixed point + if b_variables_in_data: # domain_b will be a fixed point point_data = self._create_point_data(self.domain_b.space, data) domain_b = Point(space=self.domain_a.space, point=point_data) return ProductDomain(domain_a=domain_a, domain_b=domain_b) @@ -83,7 +93,7 @@ def _create_point_data(self, space, data): vname_data = data[vname] if isinstance(vname_data, (list, tuple, torch.Tensor)): point_data.extend(data) - else: # number + else: # number point_data.append(data) return point_data @@ -101,122 +111,157 @@ def _contains(self, points, params=Points.empty()): return torch.logical_and(in_a, in_b) def set_bounding_box(self, bounds): - """To set the bounds of the domain. + """To set the bounds of the domain. Parameters ---------- bounds : list The bounding box of the domain. Whereby the lenght of the list - has to be two times the domain dimension. And the bounds need to be in the + has to be two times the domain dimension. And the bounds need to be in the following order: [min_axis_1, max_axis_1, min_axis_2, max_axis_2, ...] """ assert len(bounds) == 2 * self.dim, """Bounds dont fit the dimension.""" self.bounds = bounds - def bounding_box(self, params=Points.empty(), device='cpu'): + def bounding_box(self, params=Points.empty(), device="cpu"): if self.bounds: return self.bounds elif self._is_constant or self.domain_b.space in params.space: # if the domain is constant or additional data for domain a is given - # we just can create the bounds directly. + # we just can create the bounds directly. bounds_a = self.domain_a.bounding_box(params, device=device) bounds_b = self.domain_b.bounding_box(params, device=device) bounds_a = torch.cat((bounds_a, bounds_b)) - else: # we have to sample some points in b, and approx the bounds. - warnings.warn(f"""The bounding box of the ProductDomain dependens of the + else: # we have to sample some points in b, and approx the bounds. + warnings.warn( + f"""The bounding box of the ProductDomain dependens of the values of domain_b. Therefor will sample {N_APPROX_VOLUME} in domain_b, to compute a approixmation. If the bounds a known exactly, set - them with .set_bounds().""") + them with .set_bounds().""" + ) bounds_b = self.domain_b.bounding_box(params, device=device) - b_points = self.domain_b.sample_random_uniform(n=N_APPROX_VOLUME, - params=params) + b_points = self.domain_b.sample_random_uniform( + n=N_APPROX_VOLUME, params=params + ) _, new_params = self._repeat_params(n=N_APPROX_VOLUME, params=params) - bounds_a = self.domain_a.bounding_box(b_points.join(new_params), device=device) + bounds_a = self.domain_a.bounding_box( + b_points.join(new_params), device=device + ) bounds_a = torch.cat((bounds_a, bounds_b)) return bounds_a - - def _get_volume(self, params=Points.empty(), device='cpu'): + + def _get_volume(self, params=Points.empty(), device="cpu"): if self._is_constant: - return self.domain_a.volume(params, device=device) * self.domain_b.volume(params, device=device) + return self.domain_a.volume(params, device=device) * self.domain_b.volume( + params, device=device + ) else: - warnings.warn(f"""The volume of a ProductDomain where one factor domain depends on the + warnings.warn( + f"""The volume of a ProductDomain where one factor domain depends on the other can only be approximated by evaluating functions at {N_APPROX_VOLUME} - points. If you need exact volume or sampling, use domain.set_volume().""") + points. If you need exact volume or sampling, use domain.set_volume().""" + ) # approximate the volume n, new_params = self._repeat_params(n=N_APPROX_VOLUME, params=params) b_points = self.domain_b.sample_random_uniform(n=n, params=new_params) if len(self.domain_b.necessary_variables) > 0: # points need to be sampled in every call to this function - volume_a = self.domain_a.volume(b_points.join(new_params), device=device) + volume_a = self.domain_a.volume( + b_points.join(new_params), device=device + ) reshape_volume = volume_a.reshape(N_APPROX_VOLUME, -1) mean_volume = torch.sum(reshape_volume, dim=0) / N_APPROX_VOLUME - return mean_volume.reshape(-1, 1) * self.domain_b.volume(params, device=device) + return mean_volume.reshape(-1, 1) * self.domain_b.volume( + params, device=device + ) elif len(self.necessary_variables) > 0: # we can keep the sampled points and evaluate domain_a in a function b_volume = self.domain_b.volume(device=device) + def avg_volume(local_params): - _, new_params = self._repeat_params(n=N_APPROX_VOLUME, params=local_params) - return torch.sum(self.domain_a.volume(b_points.join(new_params), device=device)\ - .reshape(N_APPROX_VOLUME,-1), dim=0) / N_APPROX_VOLUME * b_volume + _, new_params = self._repeat_params( + n=N_APPROX_VOLUME, params=local_params + ) + return ( + torch.sum( + self.domain_a.volume( + b_points.join(new_params), device=device + ).reshape(N_APPROX_VOLUME, -1), + dim=0, + ) + / N_APPROX_VOLUME + * b_volume + ) + args = self.domain_a.necessary_variables - self.domain_b.space.variables self._user_volume = UserFunction(avg_volume, args=args) return avg_volume(params) else: # we can compute the volume only once and save it - volume = sum((self.domain_a.volume(b_points, device=device))/N_APPROX_VOLUME \ - * self.domain_b.volume(device=device)) + volume = sum( + (self.domain_a.volume(b_points, device=device)) + / N_APPROX_VOLUME + * self.domain_b.volume(device=device) + ) self.set_volume(volume) return torch.repeat_interleave(volume, max(1, len(params)), dim=0) - - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): raise NotImplementedError( """Grid sampling on a product domain is not implmented. Use a product sampler - instead.""") - - def _sample_uniform_b_points(self, n_in, params=Points.empty(), device='cpu'): + instead.""" + ) + + def _sample_uniform_b_points(self, n_in, params=Points.empty(), device="cpu"): n_, params = self._repeat_params(n_in, params) - b_points = self.domain_b.sample_random_uniform(n=n_, params=params, - device=device) - volumes = self.domain_a.volume(params.join(b_points), device=device).squeeze(dim=-1) + b_points = self.domain_b.sample_random_uniform( + n=n_, params=params, device=device + ) + volumes = self.domain_a.volume(params.join(b_points), device=device).squeeze( + dim=-1 + ) if list(volumes.shape) == [1]: return n_in, b_points, params - filter_ = torch.max(volumes)*torch.rand_like(volumes, device=device) < volumes - b_points = b_points[filter_, ] + filter_ = torch.max(volumes) * torch.rand_like(volumes, device=device) < volumes + b_points = b_points[filter_,] if not params.isempty: - params = params[filter_, ] + params = params[filter_,] n_out = len(b_points) return n_out, b_points, params - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if n is not None: if self._is_constant: # we use all sampled b values n_, new_params = self._repeat_params(n, params) - b_points = self.domain_b.sample_random_uniform(n=n_, params=new_params, - device=device) + b_points = self.domain_b.sample_random_uniform( + n=n_, params=new_params, device=device + ) else: # use ratio of uniforms to get uniform values in product domain - n_points, b_points, new_params = \ - self._sample_uniform_b_points(n, params=params, device=device) + n_points, b_points, new_params = self._sample_uniform_b_points( + n, params=params, device=device + ) n_sampled = n while n_points != n: if n_points < n: - n_guess = int((n/n_points-1)*n_sampled)+1 - n_out, add_b_points, add_params = \ - self._sample_uniform_b_points(n_guess, params=params, - device=device) + n_guess = int((n / n_points - 1) * n_sampled) + 1 + n_out, add_b_points, add_params = self._sample_uniform_b_points( + n_guess, params=params, device=device + ) b_points = b_points | add_b_points new_params = new_params | add_params n_points += n_out else: - b_points = b_points[:n, ] - new_params = new_params[:n, ] + b_points = b_points[:n,] + new_params = new_params[:n,] n_points = n - a_points = self.domain_a.sample_random_uniform(n=1, params=new_params.join(b_points), - device=device) + a_points = self.domain_a.sample_random_uniform( + n=1, params=new_params.join(b_points), device=device + ) return a_points.join(b_points) else: assert d is not None - n = int(d*self.volume(device=device)) - return self.sample_random_uniform(n=n, params=params, device=device) \ No newline at end of file + n = int(d * self.volume(device=device)) + return self.sample_random_uniform(n=n, params=params, device=device) diff --git a/src/torchphysics/problem/domains/domainoperations/rotate.py b/src/torchphysics/problem/domains/domainoperations/rotate.py index fe68ea39..cf2ad9de 100644 --- a/src/torchphysics/problem/domains/domainoperations/rotate.py +++ b/src/torchphysics/problem/domains/domainoperations/rotate.py @@ -6,12 +6,15 @@ class RotationMatrix2D(DomainUserFunction): - """Given a function :math:`f:\\Omega \\to R` will create the two dimensional + """Given a function :math:`f:\\Omega \\to R` will create the two dimensional rotation matrix :math:`(cos(f), -sin(f); sin(f), cos(f))`. """ - def __call__(self, args={}, device='cpu'): + + def __call__(self, args={}, device="cpu"): angle_values = super().__call__(args, device).reshape(-1, 1) - matrix_row = torch.cat((torch.cos(angle_values), -torch.sin(angle_values)), dim=1) + matrix_row = torch.cat( + (torch.cos(angle_values), -torch.sin(angle_values)), dim=1 + ) matrix_row_2 = torch.cat((-matrix_row[:, 1:], matrix_row[:, :1]), dim=1) return torch.stack((matrix_row, matrix_row_2), dim=1) @@ -27,7 +30,6 @@ def __init__(self, alpha, beta, gamma, defaults=..., args=...): self.beta = DomainUserFunction(beta) self.gamma = DomainUserFunction(gamma) - @property def necessary_args(self): alpha_args = super().necessary_args @@ -38,13 +40,13 @@ def necessary_args(self): class Rotate(Domain): """Class that rotates a given domain via a given matrix. - + Parameters ---------- domain : torchphysics.domain.Domain The domain that should be rotated. rotation_matrix : array_like or callable - The matrix that describes the rotation, can also be a function that + The matrix that describes the rotation, can also be a function that returns different matrices, depending on other parameters. rotate_around : array_like or callable, optional The point around which the rotation occurs, can also be a function. @@ -55,8 +57,9 @@ class Rotate(Domain): All domains can already be rotated by passing in a function as the needed domain parameter. But for complex domains (cut, etc.) or objects with many corners (cube, square) it is easier to just rotate the whole domain with this class. - """ - def __init__(self, domain : Domain, rotation_matrix, rotate_around=None): + """ + + def __init__(self, domain: Domain, rotation_matrix, rotate_around=None): if isinstance(domain, BoundaryDomain): assert domain.dim >= 1, "Can only rotate domains in dimensions >= 2" else: @@ -64,14 +67,15 @@ def __init__(self, domain : Domain, rotation_matrix, rotate_around=None): if rotate_around is None: rotate_around = torch.zeros((1, domain.dim)) self.domain = domain - self.rotation_fn, self.rotate_around = \ - self.transform_to_user_functions(rotation_matrix, rotate_around) + self.rotation_fn, self.rotate_around = self.transform_to_user_functions( + rotation_matrix, rotate_around + ) super().__init__(self.domain.space, self.domain.dim) self.set_necessary_variables(self.rotation_fn) self.necessary_variables.update(self.domain.necessary_variables) @classmethod - def from_angles(cls, domain : Domain, *angles, rotate_around=None): + def from_angles(cls, domain: Domain, *angles, rotate_around=None): """Creates the rotation from given angles. Parameters @@ -80,19 +84,20 @@ def from_angles(cls, domain : Domain, *angles, rotate_around=None): The domain that should be rotated. *angles : float or callable The angles that describe the rotation, can also be a functions. - In 2D one angle :math:`\\alpha` is needed and internally the - rotation matrix + In 2D one angle :math:`\\alpha` is needed and internally the + rotation matrix :math:`(\\cos(\\alpha), -\\sin(\\alpha); \\sin(\\alpha), \\cos(\\alpha))` is constructed. - For 3D three angles are needed and the euler (extrinsic) rotation + For 3D three angles are needed and the euler (extrinsic) rotation matrix from https://en.wikipedia.org/wiki/Rotation_matrix is used. rotate_around : array_like or callable, optional The point around which the rotation occurs, can also be a function. - Default is the origin. + Default is the origin. """ - assert domain.dim <= 3, \ - "Rotation matrix for dimension > 3 is not known, please create it yourself" \ + assert domain.dim <= 3, ( + "Rotation matrix for dimension > 3 is not known, please create it yourself" + " and use the basic constructor." + ) if domain.dim == 2: assert len(angles) == 1, "In 2D one rotation angle is needed!" rotation_matrix = RotationMatrix2D(angles[0]) @@ -105,10 +110,13 @@ def __call__(self, **data): new_domain = self.domain(**data) new_rotation_matrix = self.rotation_fn.partially_evaluate(**data) new_rotate_around = self.rotate_around.partially_evaluate(**data) - return Rotate(domain=new_domain, rotation_matrix=new_rotation_matrix, - rotate_around=new_rotate_around) + return Rotate( + domain=new_domain, + rotation_matrix=new_rotation_matrix, + rotate_around=new_rotate_around, + ) - def volume(self, params=Points.empty(), device='cpu'): + def volume(self, params=Points.empty(), device="cpu"): return self.domain.volume(params=params, device=device) def set_volume(self, volume): @@ -119,36 +127,45 @@ def boundary(self): return Rotate(self.domain.boundary, self.rotation_fn, self.rotate_around) def _contains(self, points, params=Points.empty()): - translate_values = self.rotate_around(points.join(params)).reshape(-1, self.space.dim) - rotation_matrix = self.rotation_fn(points.join(params)).reshape(-1, self.space.dim, - self.space.dim) - shifted_points = points[:, list(self.space.keys())].as_tensor \ - - translate_values + translate_values = self.rotate_around(points.join(params)).reshape( + -1, self.space.dim + ) + rotation_matrix = self.rotation_fn(points.join(params)).reshape( + -1, self.space.dim, self.space.dim + ) + shifted_points = points[:, list(self.space.keys())].as_tensor - translate_values # here apply inverse rotation -> solve: Matrix * x = shifted_points - rotated_points = torch.linalg.solve(rotation_matrix, shifted_points.unsqueeze(-1)) + rotated_points = torch.linalg.solve( + rotation_matrix, shifted_points.unsqueeze(-1) + ) shifted_points = rotated_points.squeeze(-1) + translate_values return self.domain._contains(Points(shifted_points, self.space), params) - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): - original_points = self.domain.sample_random_uniform(n=n, d=d, params=params, - device=device).as_tensor + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): + original_points = self.domain.sample_random_uniform( + n=n, d=d, params=params, device=device + ).as_tensor n = int(len(original_points) / (len(params) + 1)) - _, params = self._repeat_params(n + 1, params) # round up n + _, params = self._repeat_params(n + 1, params) # round up n rotated_points = self._rotate_points(params, original_points) return Points(rotated_points, self.space) def _rotate_points(self, params, original_points): translate_values = self.rotate_around(params).reshape(-1, self.space.dim) - rotation_matrix = self.rotation_fn(params).reshape(-1, self.space.dim, self.space.dim) + rotation_matrix = self.rotation_fn(params).reshape( + -1, self.space.dim, self.space.dim + ) translated_points = original_points - translate_values rotated_points = torch.matmul(rotation_matrix, translated_points.unsqueeze(-1)) translated_points = rotated_points.squeeze(-1) + translate_values return translated_points - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): - original_points = self.domain.sample_grid(n=n, d=d, params=params, - device=device).as_tensor + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): + original_points = self.domain.sample_grid( + n=n, d=d, params=params, device=device + ).as_tensor return self._rotate_grid(original_points, params) def _rotate_grid(self, points, params): @@ -164,22 +181,26 @@ def _rotate_grid(self, points, params): rotated_points = self._rotate_points(params, points) return Points(rotated_points, self.space) - def bounding_box(self, params=Points.empty(), device='cpu'): + def bounding_box(self, params=Points.empty(), device="cpu"): domain_bounds = self.domain.bounding_box(params=params, device=device) translate_values = self.rotate_around(params).reshape(-1, self.space.dim) - rotation_matrix = self.rotation_fn(params).reshape(-1, self.space.dim, - self.space.dim) + rotation_matrix = self.rotation_fn(params).reshape( + -1, self.space.dim, self.space.dim + ) translation_values = torch.repeat_interleave(translate_values, 2, 1) # domain_bounds are in shape [x_min, x_max, y_min, y_max, ...] # both min and max have to be shifted by the same value domain_bounds = domain_bounds - translation_values rotated_min = torch.matmul(rotation_matrix, domain_bounds[:, ::2].unsqueeze(-1)) rotated_min = rotated_min.squeeze(-1) - rotated_max = torch.matmul(rotation_matrix, domain_bounds[:, 1::2].unsqueeze(-1)) + rotated_max = torch.matmul( + rotation_matrix, domain_bounds[:, 1::2].unsqueeze(-1) + ) rotated_max = rotated_max.squeeze(-1) - domain_bounds = torch.zeros((len(rotated_min), 2*self.space.dim), - device=device) - domain_bounds[:, ::2] = torch.min(rotated_min, rotated_max) - domain_bounds[:, 1::2] = torch.max(rotated_min, rotated_max) + domain_bounds = torch.zeros( + (len(rotated_min), 2 * self.space.dim), device=device + ) + domain_bounds[:, ::2] = torch.min(rotated_min, rotated_max) + domain_bounds[:, 1::2] = torch.max(rotated_min, rotated_max) domain_bounds = domain_bounds + translation_values - return domain_bounds.squeeze(0) \ No newline at end of file + return domain_bounds.squeeze(0) diff --git a/src/torchphysics/problem/domains/domainoperations/sampler_helper.py b/src/torchphysics/problem/domains/domainoperations/sampler_helper.py index c1f396e4..117cba2e 100644 --- a/src/torchphysics/problem/domains/domainoperations/sampler_helper.py +++ b/src/torchphysics/problem/domains/domainoperations/sampler_helper.py @@ -1,6 +1,7 @@ """This file contains some sample functions for the domain operations. Since Union/Cut/Intersection follow the same idea for sampling for a given number of points. """ + import torch import warnings @@ -26,16 +27,18 @@ def _inside_random_with_n(main_domain, domain_a, domain_b, n, params, invert, de device : str The device on which the points should be created. """ - if n == 1: - return _random_points_if_n_eq_1(main_domain, domain_a, domain_b, - params, invert, device) - return _random_points_inside(main_domain, domain_a, domain_b, n, - params, invert, device) + if n == 1: + return _random_points_if_n_eq_1( + main_domain, domain_a, domain_b, params, invert, device + ) + return _random_points_inside( + main_domain, domain_a, domain_b, n, params, invert, device + ) def _random_points_if_n_eq_1(main_domain, domain_a, domain_b, params, invert, device): final_points = torch.zeros((len(params), main_domain.dim), device=device) - found_valid = torch.zeros((len(params), 1), dtype=bool, device=device) + found_valid = torch.zeros((len(params), 1), dtype=bool, device=device) while not all(found_valid): new_points = domain_a.sample_random_uniform(n=1, params=params, device=device) index_valid = _check_in_b(domain_b, params, invert, new_points) @@ -46,26 +49,30 @@ def _random_points_if_n_eq_1(main_domain, domain_a, domain_b, params, invert, de def _random_points_inside(main_domain, domain_a, domain_b, n, params, invert, device): num_of_params = max(len(params), 1) - warnings.warn(f"""Will sample random points in the created domain operation, with + warnings.warn( + f"""Will sample random points in the created domain operation, with a for loop over all input parameters, in total: {num_of_params} - This may slow down the training.""") + This may slow down the training.""" + ) random_points = Points.empty() for i in range(num_of_params): - ith_params = params[i, ] if len(params) > 0 else Points.empty() + ith_params = params[i,] if len(params) > 0 else Points.empty() number_valid = 0 scaled_n = n while number_valid < n: # first create in a - new_points = domain_a.sample_random_uniform(n=int(scaled_n), - params=ith_params, - device=device) + new_points = domain_a.sample_random_uniform( + n=int(scaled_n), params=ith_params, device=device + ) # check how many are in correct _, repeat_params = main_domain._repeat_params(len(new_points), ith_params) index_valid = _check_in_b(domain_b, repeat_params, invert, new_points) number_valid = len(index_valid) - #scale up the number of point and try again - scaled_n = 5*scaled_n if number_valid == 0 else scaled_n**2/number_valid + 1 - random_points = random_points | new_points[index_valid[:n], ] + # scale up the number of point and try again + scaled_n = ( + 5 * scaled_n if number_valid == 0 else scaled_n**2 / number_valid + 1 + ) + random_points = random_points | new_points[index_valid[:n],] return random_points @@ -100,20 +107,21 @@ def _inside_grid_with_n(main_domain, domain_a, domain_b, n, params, invert, devi grid_a = domain_a.sample_grid(n=scaled_n, params=params, device=device) _, repeat_params = main_domain._repeat_params(scaled_n, params) index_valid = _check_in_b(domain_b, repeat_params, invert, grid_a) - grid_a = grid_a[index_valid, ] + grid_a = grid_a[index_valid,] if len(grid_a) >= n: - return grid_a[:n, ] + return grid_a[:n,] # add some random ones if still some missing - rand_points = _random_points_inside(main_domain, domain_a, domain_b, - n-len(grid_a), params, invert, device) + rand_points = _random_points_inside( + main_domain, domain_a, domain_b, n - len(grid_a), params, invert, device + ) return grid_a | rand_points def _check_in_b(domain_b, params, invert, grid_a): - #check what points are correct + # check what points are correct inside_b = domain_b._contains(grid_a, params) if invert: - inside_b = torch.logical_not(inside_b) + inside_b = torch.logical_not(inside_b) index = torch.where(inside_b)[0] return index @@ -134,24 +142,26 @@ def _boundary_random_with_n(main_domain, domain_a, domain_b, n, params, device): device : str The device on which the points should be created. """ - if n == 1: - return _random_boundary_points_if_n_eq_1(main_domain, domain_a, domain_b, - params, device) + if n == 1: + return _random_boundary_points_if_n_eq_1( + main_domain, domain_a, domain_b, params, device + ) return _random_points_boundary(main_domain, domain_a, domain_b, n, params, device) def _random_boundary_points_if_n_eq_1(main_domain, domain_a, domain_b, params, device): - final_points = torch.zeros((len(params), main_domain.dim+1), device=device) - found_valid = torch.zeros((len(params), 1), dtype=bool, device=device) + final_points = torch.zeros((len(params), main_domain.dim + 1), device=device) + found_valid = torch.zeros((len(params), 1), dtype=bool, device=device) boundaries = [domain_a.boundary, domain_b.boundary] use_b = False while not all(found_valid): - new_points = \ - boundaries[use_b].sample_random_uniform(n=1, params=params, device=device) + new_points = boundaries[use_b].sample_random_uniform( + n=1, params=params, device=device + ) index_valid = main_domain._contains(new_points, params) index_valid = torch.logical_and(index_valid, torch.logical_not(found_valid)) index_valid = torch.where(index_valid)[0] - found_valid[index_valid] = True + found_valid[index_valid] = True final_points[index_valid] = new_points.as_tensor[index_valid] use_b = not use_b return Points(final_points, main_domain.space) @@ -159,37 +169,41 @@ def _random_boundary_points_if_n_eq_1(main_domain, domain_a, domain_b, params, d def _random_points_boundary(main_domain, domain_a, domain_b, n, params, device): num_of_params = max(len(params), 1) - warnings.warn(f"""Will sample random points in the created domain operation, with + warnings.warn( + f"""Will sample random points in the created domain operation, with a for loop over all input parameters, in total: {num_of_params} - This may slow down the training.""") + This may slow down the training.""" + ) random_points = Points.empty() domains = [domain_a, domain_b] for i in range(num_of_params): - ith_params = params[i, ] if len(params) > 0 else Points.empty() + ith_params = params[i,] if len(params) > 0 else Points.empty() ith_points = Points.empty() - # scale n such that the number of points corresponds to the size + # scale n such that the number of points corresponds to the size # of the boundary - sclaed_n = _compute_boundary_ratio(main_domain, domain_a, - domain_b, ith_params, n, device=device) - use_b = False # to switch between sampling on a and b + sclaed_n = _compute_boundary_ratio( + main_domain, domain_a, domain_b, ith_params, n, device=device + ) + use_b = False # to switch between sampling on a and b while len(ith_points) < n: - new_points = \ - domains[use_b].boundary.sample_random_uniform(n=sclaed_n[use_b], - params=ith_params, - device=device) + new_points = domains[use_b].boundary.sample_random_uniform( + n=sclaed_n[use_b], params=ith_params, device=device + ) _, repeat_params = main_domain._repeat_params(len(new_points), ith_params) index_valid = torch.where(main_domain._contains(new_points, repeat_params)) - ith_points = ith_points | new_points[index_valid[0], ] - use_b = not use_b # switch to other domain - random_points = random_points | ith_points[:n, ] + ith_points = ith_points | new_points[index_valid[0],] + use_b = not use_b # switch to other domain + random_points = random_points | ith_points[:n,] return random_points -def _compute_boundary_ratio(main_domain, domain_a, domain_b, ith_params, n, device='cpu'): +def _compute_boundary_ratio( + main_domain, domain_a, domain_b, ith_params, n, device="cpu" +): main_volume = main_domain.volume(params=ith_params, device=device) a_volume = domain_a.boundary.volume(params=ith_params, device=device) b_volume = domain_b.boundary.volume(params=ith_params, device=device) - return [int(n * a_volume/main_volume)+1, int(n * b_volume/main_volume)+1] + return [int(n * a_volume / main_volume) + 1, int(n * b_volume / main_volume) + 1] def _boundary_grid_with_n(main_domain, domain_a, domain_b, n, params, device): @@ -210,32 +224,35 @@ def _boundary_grid_with_n(main_domain, domain_a, domain_b, n, params, device): """ # first sample a grid on both boundaries grid_a = domain_a.boundary.sample_grid(n=n, params=params, device=device) - grid_b = domain_b.boundary.sample_grid(n=n, params=params, device=device) + grid_b = domain_b.boundary.sample_grid(n=n, params=params, device=device) # check how many points are on the boundary of the operation domain - on_bound_a, on_bound_b, a_correct, b_correct = \ - _check_points_on_main_boundary(main_domain, grid_a, grid_b, params) + on_bound_a, on_bound_b, a_correct, b_correct = _check_points_on_main_boundary( + main_domain, grid_a, grid_b, params + ) sum_of_correct = a_correct + b_correct if sum_of_correct == n: - return grid_a[on_bound_a, ] | grid_b[on_bound_b, ] + return grid_a[on_bound_a,] | grid_b[on_bound_b,] # scale the n so that more or fewer points are sampled and try again - # to get a better grid. For the scaling we approximate the volume of the + # to get a better grid. For the scaling we approximate the volume of the # the main domain. a_surface = domain_a.boundary.volume(params, device=device) b_surface = domain_b.boundary.volume(params, device=device) approx_surface = a_surface * a_correct / n + b_surface * b_correct / n - scaled_a = int(n * a_surface / approx_surface) + 1 # round up - scaled_b = max(int(n * b_surface / approx_surface), 1) # round to floor, but not 0 + scaled_a = int(n * a_surface / approx_surface) + 1 # round up + scaled_b = max(int(n * b_surface / approx_surface), 1) # round to floor, but not 0 grid_a = domain_a.boundary.sample_grid(n=scaled_a, params=params, device=device) - grid_b = domain_b.boundary.sample_grid(n=scaled_b, params=params, device=device) + grid_b = domain_b.boundary.sample_grid(n=scaled_b, params=params, device=device) # check again how what points are correct and now just stay with this grid # if still some points are missing add random ones. - on_bound_a, on_bound_b, a_correct, b_correct = \ - _check_points_on_main_boundary(main_domain, grid_a, grid_b, params) - final_grid = grid_a[on_bound_a, ] | grid_b[on_bound_b, ] + on_bound_a, on_bound_b, a_correct, b_correct = _check_points_on_main_boundary( + main_domain, grid_a, grid_b, params + ) + final_grid = grid_a[on_bound_a,] | grid_b[on_bound_b,] if len(final_grid) >= n: - return final_grid[:n, ] - rand_points = _random_points_boundary(main_domain, domain_a, domain_b, - n-len(final_grid), params, device) + return final_grid[:n,] + rand_points = _random_points_boundary( + main_domain, domain_a, domain_b, n - len(final_grid), params, device + ) return final_grid | rand_points @@ -246,4 +263,4 @@ def _check_points_on_main_boundary(main_domain, grid_a, grid_b, params): on_bound_b = torch.where(main_domain._contains(grid_b, params=repeat_params))[0] a_correct = len(on_bound_a) b_correct = len(on_bound_b) - return on_bound_a,on_bound_b, a_correct, b_correct \ No newline at end of file + return on_bound_a, on_bound_b, a_correct, b_correct diff --git a/src/torchphysics/problem/domains/domainoperations/translate.py b/src/torchphysics/problem/domains/domainoperations/translate.py index b821cc80..6da3dbda 100644 --- a/src/torchphysics/problem/domains/domainoperations/translate.py +++ b/src/torchphysics/problem/domains/domainoperations/translate.py @@ -6,13 +6,13 @@ class Translate(Domain): """Class that translates a given domain by a given vector (or vector function). - + Parameters ---------- domain : torchphysics.domain.Domain The domain that should be translated. translation : array_like or callable - The vector that describes the translation, can also be a function that + The vector that describes the translation, can also be a function that returns different vectors. Notes @@ -20,8 +20,9 @@ class Translate(Domain): All domains can already be moved by passing in a function as the needed domain parameter. But for complex domains (cut, etc.) or objects with many corners (cube, square) it is easier to just translate the whole domain with this class. - """ - def __init__(self, domain : Domain, translation): + """ + + def __init__(self, domain: Domain, translation): self.domain = domain self.translate_fn = self.transform_to_user_functions(translation)[0] super().__init__(self.domain.space, self.domain.dim) @@ -34,25 +35,29 @@ def __call__(self, **data): return Translate(domain=new_domain, translation=new_translate_fn) def _contains(self, points, params=Points.empty()): - translate_values = self.translate_fn(points.join(params)).reshape(-1, self.space.dim) - shifted_points = points[:, list(self.space.keys())].as_tensor \ - - translate_values - #points[:, list(self.space.keys())] = Points(shifted_points, self.space) + translate_values = self.translate_fn(points.join(params)).reshape( + -1, self.space.dim + ) + shifted_points = points[:, list(self.space.keys())].as_tensor - translate_values + # points[:, list(self.space.keys())] = Points(shifted_points, self.space) return self.domain._contains(Points(shifted_points, self.space), params) - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): - original_points = self.domain.sample_random_uniform(n=n, d=d, params=params, - device=device).as_tensor + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): + original_points = self.domain.sample_random_uniform( + n=n, d=d, params=params, device=device + ).as_tensor n = int(len(original_points) / (len(params) + 1)) - _, params = self._repeat_params(n + 1, params) # round up n + _, params = self._repeat_params(n + 1, params) # round up n translate_values = self.translate_fn(params).squeeze(-1) translated_points = original_points + translate_values return Points(translated_points, self.space) - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): - original_points = self.domain.sample_grid(n=n, d=d, params=params, - device=device).as_tensor + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): + original_points = self.domain.sample_grid( + n=n, d=d, params=params, device=device + ).as_tensor translated_points = self._translate_points(original_points, params) return Points(translated_points, self.space) @@ -70,13 +75,13 @@ def _translate_points(self, points, params): points += translate_values return points - def volume(self, params=Points.empty(), device='cpu'): + def volume(self, params=Points.empty(), device="cpu"): return self.domain.volume(params=params, device=device) def set_volume(self, volume): return self.domain.set_volume(volume) - def bounding_box(self, params=Points.empty(), device='cpu'): + def bounding_box(self, params=Points.empty(), device="cpu"): domain_bounds = self.domain.bounding_box(params=params, device=device) translation_values = self.translate_fn(params).reshape(-1, self.space.dim) translation_values = torch.repeat_interleave(translation_values, 2, 1) @@ -87,4 +92,4 @@ def bounding_box(self, params=Points.empty(), device='cpu'): @property def boundary(self): - return Translate(self.domain.boundary, self.translate_fn) \ No newline at end of file + return Translate(self.domain.boundary, self.translate_fn) diff --git a/src/torchphysics/problem/domains/domainoperations/union.py b/src/torchphysics/problem/domains/domainoperations/union.py index f098f2f6..ce3a46ad 100644 --- a/src/torchphysics/problem/domains/domainoperations/union.py +++ b/src/torchphysics/problem/domains/domainoperations/union.py @@ -14,8 +14,9 @@ class UnionDomain(Domain): domain_a : Domain The first domain. domain_b : Domain - The second domain. - """ + The second domain. + """ + def __init__(self, domain_a: Domain, domain_b: Domain, disjoint=False): assert domain_a.space == domain_b.space self.domain_a = domain_a @@ -25,12 +26,16 @@ def __init__(self, domain_a: Domain, domain_b: Domain, disjoint=False): self.necessary_variables = domain_a.necessary_variables.copy() self.necessary_variables.update(domain_b.necessary_variables) - def _get_volume(self, params=Points.empty(), return_value_of_a_b=False, device='cpu'): + def _get_volume( + self, params=Points.empty(), return_value_of_a_b=False, device="cpu" + ): if not self.disjoint: - warnings.warn("""Exact volume of this union is not known, will use the + warnings.warn( + """Exact volume of this union is not known, will use the estimate: volume = domain_a.volume + domain_b.volume. If you need the exact volume for sampling, - use domain.set_volume()""") + use domain.set_volume()""" + ) volume_a = self.domain_a.volume(params, device=device) volume_b = self.domain_b.volume(params, device=device) if return_value_of_a_b: @@ -47,52 +52,61 @@ def __call__(self, **data): domain_b = self.domain_b(**data) return UnionDomain(domain_a, domain_b) - def bounding_box(self, params=Points.empty(), device='cpu'): + def bounding_box(self, params=Points.empty(), device="cpu"): bounds_a = self.domain_a.bounding_box(params, device=device) bounds_b = self.domain_b.bounding_box(params, device=device) bounds = [] for i in range(self.space.dim): - bounds.append(min([bounds_a[2*i], bounds_b[2*i]])) - bounds.append(max([bounds_a[2*i+1], bounds_b[2*i+1]])) + bounds.append(min([bounds_a[2 * i], bounds_b[2 * i]])) + bounds.append(max([bounds_a[2 * i + 1], bounds_b[2 * i + 1]])) return torch.tensor(bounds, device=device) - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if n: return self._sample_random_with_n(n, params, device) # esle d not None return self._sample_random_with_d(d, params, device) - def _sample_random_with_n(self, n, params=Points.empty(), device='cpu'): + def _sample_random_with_n(self, n, params=Points.empty(), device="cpu"): # sample n points in both domains - points_a = self.domain_a.sample_random_uniform(n=n, params=params, device=device) - points_b = self.domain_b.sample_random_uniform(n=n, params=params, device=device) + points_a = self.domain_a.sample_random_uniform( + n=n, params=params, device=device + ) + points_b = self.domain_b.sample_random_uniform( + n=n, params=params, device=device + ) # check which points of domain b are in domain a _, repeated_params = self._repeat_params(n, params) in_a = self.domain_a._contains(points=points_b, params=repeated_params) # approximate volume of this domain - volume_approx, volume_a, _ = self._get_volume(return_value_of_a_b=True, - params=repeated_params, - device=device) + volume_approx, volume_a, _ = self._get_volume( + return_value_of_a_b=True, params=repeated_params, device=device + ) volume_ratio = torch.divide(volume_a, volume_approx) # choose points depending of the proportion of the domain w.r.t. the # whole domain union rand_index = torch.rand((max(n, len(repeated_params)), 1), device=device) rand_index = torch.logical_or(in_a, rand_index <= volume_ratio) - points = torch.where(rand_index, points_a, points_b) + points = torch.where(rand_index, points_a, points_b) return Points(points, self.space) - def _sample_random_with_d(self, d, params=Points.empty(), device='cpu'): + def _sample_random_with_d(self, d, params=Points.empty(), device="cpu"): # sample n points in both domains - points_a = self.domain_a.sample_random_uniform(d=d, params=params, device=device) - points_b = self.domain_b.sample_random_uniform(d=d, params=params, device=device) + points_a = self.domain_a.sample_random_uniform( + d=d, params=params, device=device + ) + points_b = self.domain_b.sample_random_uniform( + d=d, params=params, device=device + ) return self._append_points(points_a, points_b, params) def _append_points(self, points_a, points_b, params=Points.empty()): - in_a = self._points_lay_in_other_domain(points_b, self.domain_a, params) + in_a = self._points_lay_in_other_domain(points_b, self.domain_a, params) # delete the points that are in domain a (so the sampling stays uniform) index = torch.where(torch.logical_not(in_a))[0] - disjoint_b_points = points_b[index, ] + disjoint_b_points = points_b[index,] return points_a | disjoint_b_points def _points_lay_in_other_domain(self, points, domain, params=Points.empty()): @@ -102,19 +116,18 @@ def _points_lay_in_other_domain(self, points, domain, params=Points.empty()): in_a = domain._contains(points=points, params=repeated_params) return in_a - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): if n: return self._sample_grid_with_n(n, params, device) # else d not None return self._sample_grid_with_d(d, params, device) - def _sample_grid_with_n(self, n, params=Points.empty(), device='cpu'): - volume_approx, volume_a, _ = self._get_volume(return_value_of_a_b=True, - params=params, - device=device) - scaled_n = int(torch.ceil(n * volume_a/volume_approx)) - points_a = self.domain_a.sample_grid(n=scaled_n, params=params, - device=device) + def _sample_grid_with_n(self, n, params=Points.empty(), device="cpu"): + volume_approx, volume_a, _ = self._get_volume( + return_value_of_a_b=True, params=params, device=device + ) + scaled_n = int(torch.ceil(n * volume_a / volume_approx)) + points_a = self.domain_a.sample_grid(n=scaled_n, params=params, device=device) if n - scaled_n > 0: return self._sample_in_b(n, params, points_a, device) return points_a @@ -125,11 +138,11 @@ def _sample_in_b(self, n, params, points_a, device): index = torch.where(torch.logical_not(in_b))[0] scaled_n = n - len(index) points_b = self.domain_b.sample_grid(n=scaled_n, params=params, device=device) - return points_a[index, ] | points_b + return points_a[index,] | points_b - def _sample_grid_with_d(self, d, params=Points.empty(), device='cpu'): + def _sample_grid_with_d(self, d, params=Points.empty(), device="cpu"): points_a = self.domain_a.sample_grid(d=d, params=params, device=device) - points_b = self.domain_b.sample_grid(d=d, params=params, device=device) + points_b = self.domain_b.sample_grid(d=d, params=params, device=device) return self._append_points(points_a, points_b, params) @property @@ -154,34 +167,37 @@ def _contains(self, points, params=Points.empty()): on_b_part = torch.logical_and(on_b_bound, torch.logical_not(in_a)) return torch.logical_or(on_a_part, torch.logical_or(on_b_part, on_both)) - def _get_volume(self, params=Points.empty(), device='cpu'): + def _get_volume(self, params=Points.empty(), device="cpu"): if not self.domain.disjoint: - warnings.warn("""Exact volume of this domain is not known, will use the + warnings.warn( + """Exact volume of this domain is not known, will use the estimate: volume = domain_a.volume + domain_b.volume. If you need the exact volume for sampling, - use domain.set_volume()""") + use domain.set_volume()""" + ) volume_a = self.domain.domain_a.boundary.volume(params, device=device) volume_b = self.domain.domain_b.boundary.volume(params, device=device) return volume_a + volume_b - - def sample_random_uniform(self, n=None, d=None, params=Points.empty(), - device='cpu'): + + def sample_random_uniform( + self, n=None, d=None, params=Points.empty(), device="cpu" + ): if n: - return _boundary_random_with_n(self, self.domain.domain_a, - self.domain.domain_b, n, params, - device) + return _boundary_random_with_n( + self, self.domain.domain_a, self.domain.domain_b, n, params, device + ) return self._sample_random_with_d(d, params, device) - def _sample_random_with_d(self, d, params=Points.empty(), device='cpu'): - points_a = self.domain.domain_a.boundary.sample_random_uniform(d=d, - params=params, - device=device) + def _sample_random_with_d(self, d, params=Points.empty(), device="cpu"): + points_a = self.domain.domain_a.boundary.sample_random_uniform( + d=d, params=params, device=device + ) points_a = self._delete_points_in_b(points_a, params) - points_b = self.domain.domain_b.boundary.sample_random_uniform(d=d, - params=params, - device=device) - points_b = self._delete_inner_points(points_b, self.domain.domain_a, params) - return points_a | points_b + points_b = self.domain.domain_b.boundary.sample_random_uniform( + d=d, params=params, device=device + ) + points_b = self._delete_inner_points(points_b, self.domain.domain_a, params) + return points_a | points_b def _delete_inner_points(self, points, domain, params=Points.empty()): _, repeated_params = self._repeat_params(len(points), params) @@ -189,35 +205,38 @@ def _delete_inner_points(self, points, domain, params=Points.empty()): on_bound = domain.boundary._contains(points, repeated_params) valid_points = torch.logical_or(on_bound, torch.logical_not(inside)) index = torch.where(valid_points)[0] - return points[index, ] + return points[index,] def _delete_points_in_b(self, points, params=Points.empty()): _, repeated_params = self._repeat_params(len(points), params) inside = self.domain.domain_b._contains(points, repeated_params) index = torch.where(torch.logical_not(inside))[0] - return points[index, ] + return points[index,] - def sample_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def sample_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): if n: - return _boundary_grid_with_n(self, self.domain.domain_a, - self.domain.domain_b, n, params, - device) + return _boundary_grid_with_n( + self, self.domain.domain_a, self.domain.domain_b, n, params, device + ) return self._sample_grid_with_d(d, params, device) - def _sample_grid_with_d(self, d, params=Points.empty(), device='cpu'): - points_a = self.domain.domain_a.boundary.sample_grid(d=d, params=params, - device=device) + def _sample_grid_with_d(self, d, params=Points.empty(), device="cpu"): + points_a = self.domain.domain_a.boundary.sample_grid( + d=d, params=params, device=device + ) points_a = self._delete_points_in_b(points_a, params) - points_b = self.domain.domain_b.boundary.sample_grid(d=d, params=params, - device=device) - points_b = self._delete_inner_points(points_b, self.domain.domain_a, params) - return points_a | points_b - - def normal(self, points, params=Points.empty(), device='cpu'): - points, params, device = \ - self._transform_input_for_normals(points, params, device) + points_b = self.domain.domain_b.boundary.sample_grid( + d=d, params=params, device=device + ) + points_b = self._delete_inner_points(points_b, self.domain.domain_a, params) + return points_a | points_b + + def normal(self, points, params=Points.empty(), device="cpu"): + points, params, device = self._transform_input_for_normals( + points, params, device + ) a_normals = self.domain.domain_a.boundary.normal(points, params, device) b_normals = self.domain.domain_b.boundary.normal(points, params, device) on_a = self.domain.domain_a.boundary._contains(points, params) normals = torch.where(on_a, a_normals, b_normals) - return normals \ No newline at end of file + return normals diff --git a/src/torchphysics/problem/domains/functionsets/__init__.py b/src/torchphysics/problem/domains/functionsets/__init__.py index 52014397..52008f00 100644 --- a/src/torchphysics/problem/domains/functionsets/__init__.py +++ b/src/torchphysics/problem/domains/functionsets/__init__.py @@ -2,4 +2,4 @@ Function sets can be used to sample functions, e.g. in DeepONet. """ -from .functionset import FunctionSet, CustomFunctionSet \ No newline at end of file +from .functionset import FunctionSet, CustomFunctionSet diff --git a/src/torchphysics/problem/domains/functionsets/functionset.py b/src/torchphysics/problem/domains/functionsets/functionset.py index ca629648..17694d7d 100644 --- a/src/torchphysics/problem/domains/functionsets/functionset.py +++ b/src/torchphysics/problem/domains/functionsets/functionset.py @@ -6,7 +6,7 @@ from ...spaces.functionspace import FunctionSpace -class FunctionSet(): +class FunctionSet: """A set of functions that can supply samples from a function space. Parameters @@ -16,46 +16,48 @@ class FunctionSet(): of this FunctionSet are defined by the corresponding values inside the function space. parameter_sampler : torchphysics.samplers.PointSampler - A sampler that provides additional parameters that can be used + A sampler that provides additional parameters that can be used to create different kinds of functions. E.g. our FunctionSet consists - of Functions like k*x, x is the input variable and k is given through - the sampler. + of Functions like k*x, x is the input variable and k is given through + the sampler. During each training iteration will call the parameter_sampler to sample - new parameters. For each parameter a function will be created and the - input batch of functions will be of the same length as the sampled + new parameters. For each parameter a function will be created and the + input batch of functions will be of the same length as the sampled parameters. """ + def __init__(self, function_space, parameter_sampler): - assert isinstance(function_space, FunctionSpace), \ - """A FunctionSet needs a torchphysics.spaces.FunctionSpace!""" + assert isinstance( + function_space, FunctionSpace + ), """A FunctionSet needs a torchphysics.spaces.FunctionSpace!""" self.function_space = function_space self.parameter_sampler = parameter_sampler self.param_batch = None self.current_iteration_num = -1 def __add__(self, other): - """Combines two function sets. - + """Combines two function sets. + Notes ----- - When parameters are sampled, will sample them from both sets. + When parameters are sampled, will sample them from both sets. Creates a batch of functions consisting of the batch of each set. (Length of the batches will be added) """ - assert other.function_space == self.function_space, \ - """Both FunctionSets do not have the same FunctionSpace!""" + assert ( + other.function_space == self.function_space + ), """Both FunctionSets do not have the same FunctionSpace!""" if isinstance(other, FunctionSetCollection): return other + self else: return FunctionSetCollection([self, other]) - + def __len__(self): - """Returns the amount of functions sampled in a single call to sample_params. - """ + """Returns the amount of functions sampled in a single call to sample_params.""" return len(self.parameter_sampler) - def sample_params(self, device='cpu'): + def sample_params(self, device="cpu"): """Samples parameters of the function space. Parameters @@ -67,13 +69,13 @@ def sample_params(self, device='cpu'): ----- We save the sampled parameters internally, so that we can use them multiple times. Since given a parameter we still have a continuous representation of the underlying - function types. When the functions should be evaluated at some input points, + function types. When the functions should be evaluated at some input points, we just have to create the meshgrid of parameters and points. """ self.param_batch = self.parameter_sampler.sample_points(device=device) - + def create_function_batch(self, points): - """Evaluates the underlying function object to create a batch of + """Evaluates the underlying function object to create a batch of discrete function samples. Parameters @@ -97,21 +99,22 @@ def _create_meshgrid(self, points): """ n_points = len(points) n_params = len(self.param_batch) - points_repeated = points.as_tensor.unsqueeze(0).repeat(n_params,1,1) - params_repeated = self.param_batch.as_tensor.unsqueeze(1).repeat(1,n_points,1) - param_point_meshgrid = Points(torch.cat((params_repeated, points_repeated), dim=-1), - self.param_batch.space*points.space) + points_repeated = points.as_tensor.unsqueeze(0).repeat(n_params, 1, 1) + params_repeated = self.param_batch.as_tensor.unsqueeze(1).repeat(1, n_points, 1) + param_point_meshgrid = Points( + torch.cat((params_repeated, points_repeated), dim=-1), + self.param_batch.space * points.space, + ) return param_point_meshgrid @abc.abstractmethod def _evaluate_function(self, param_point_meshgrid): - """Here the underlying functions of the FunctionSet will be evaluated. - """ + """Here the underlying functions of the FunctionSet will be evaluated.""" raise NotImplementedError class FunctionSetCollection(FunctionSet): - """Collection of multiple FunctionSets. Used for the additions of + """Collection of multiple FunctionSets. Used for the additions of different FunctionSets. Parameters @@ -119,27 +122,30 @@ class FunctionSetCollection(FunctionSet): function_sets : list, tuple A list/tuple of FunctionSets. """ + def __init__(self, function_sets): self.collection = function_sets - super().__init__(function_space=function_sets[0].function_space, - parameter_sampler=None) + super().__init__( + function_space=function_sets[0].function_space, parameter_sampler=None + ) def __add__(self, other): - assert other.function_space == self.function_space, \ - """Both FunctionSets do not have the same FunctionSpace!""" + assert ( + other.function_space == self.function_space + ), """Both FunctionSets do not have the same FunctionSpace!""" if isinstance(other, FunctionSetCollection): self.collection += other.collection else: self.collection.append(other) return self - + def __len__(self): return sum(len(f_s) for f_s in self.collection) - def sample_params(self, device='cpu'): + def sample_params(self, device="cpu"): for function_set in self.collection: function_set.sample_params(device) - + def create_function_batch(self, points): output = Points.empty() for function_set in self.collection: @@ -157,26 +163,28 @@ class CustomFunctionSet(FunctionSet): of this FunctionSet are defined by the corresponding values inside the function space. parameter_sampler : torchphysics.samplers.PointSampler - A sampler that provides additional parameters that can be used + A sampler that provides additional parameters that can be used to create different kinds of functions. E.g. our FunctionSet consists - of Functions like k*x, x is the input variable and k is given through - the sampler. + of Functions like k*x, x is the input variable and k is given through + the sampler. During each training iteration will call the parameter_sampler to sample - new parameters. For each parameter a function will be created and the - input batch of functions will be of the same length as the sampled + new parameters. For each parameter a function will be created and the + input batch of functions will be of the same length as the sampled parameters. custom_fn : callable - A function that describes the FunctionSet. The input of the functions - can include the variables of the function_space.input_space and the + A function that describes the FunctionSet. The input of the functions + can include the variables of the function_space.input_space and the parameters from the parameter_sampler. """ + def __init__(self, function_space, parameter_sampler, custom_fn): - super().__init__(function_space=function_space, - parameter_sampler=parameter_sampler) + super().__init__( + function_space=function_space, parameter_sampler=parameter_sampler + ) if not isinstance(custom_fn, UserFunction): custom_fn = UserFunction(custom_fn) self.custom_fn = custom_fn def _evaluate_function(self, param_point_meshgrid): - return self.custom_fn(param_point_meshgrid) \ No newline at end of file + return self.custom_fn(param_point_meshgrid) diff --git a/src/torchphysics/problem/samplers/__init__.py b/src/torchphysics/problem/samplers/__init__.py index c754b2a4..e61a93b9 100644 --- a/src/torchphysics/problem/samplers/__init__.py +++ b/src/torchphysics/problem/samplers/__init__.py @@ -23,17 +23,21 @@ """ -from .sampler_base import (PointSampler, - ProductSampler, - ConcatSampler, - AppendSampler, - StaticSampler, - EmptySampler) -from .random_samplers import (RandomUniformSampler, - GaussianSampler, - LHSSampler, - AdaptiveRandomRejectionSampler, - AdaptiveThresholdRejectionSampler) +from .sampler_base import ( + PointSampler, + ProductSampler, + ConcatSampler, + AppendSampler, + StaticSampler, + EmptySampler, +) +from .random_samplers import ( + RandomUniformSampler, + GaussianSampler, + LHSSampler, + AdaptiveRandomRejectionSampler, + AdaptiveThresholdRejectionSampler, +) from .grid_samplers import GridSampler, ExponentialIntervalSampler from .plot_samplers import PlotSampler, AnimationSampler -from .data_samplers import DataSampler \ No newline at end of file +from .data_samplers import DataSampler diff --git a/src/torchphysics/problem/samplers/data_samplers.py b/src/torchphysics/problem/samplers/data_samplers.py index 0b24dfc7..f6853e61 100644 --- a/src/torchphysics/problem/samplers/data_samplers.py +++ b/src/torchphysics/problem/samplers/data_samplers.py @@ -28,6 +28,6 @@ def __init__(self, points): n = len(points) super().__init__(n_points=n) - def sample_points(self, params=Points.empty(), device='cpu'): + def sample_points(self, params=Points.empty(), device="cpu"): self.points = self.points.to(device) - return self.points \ No newline at end of file + return self.points diff --git a/src/torchphysics/problem/samplers/grid_samplers.py b/src/torchphysics/problem/samplers/grid_samplers.py index 7e7f1958..b7e472db 100644 --- a/src/torchphysics/problem/samplers/grid_samplers.py +++ b/src/torchphysics/problem/samplers/grid_samplers.py @@ -1,5 +1,6 @@ """File with samplers that create points with some kind of ordered structure. """ + import torch import warnings @@ -22,25 +23,28 @@ class GridSampler(PointSampler): The desiered density of the created points. filter_fn : callable, optional A function that restricts the possible positions of sample points. - A point that is allowed should return True, therefore a point that should be + A point that is allowed should return True, therefore a point that should be removed must return false. The filter has to be able to work with a batch of inputs. The Sampler will use a rejection sampling to find the right amount of points. """ + def __init__(self, domain, n_points=None, density=None, filter_fn=None): super().__init__(n_points=n_points, density=density, filter_fn=filter_fn) self.domain = domain - def _sample_points(self, params=Points.empty(), device='cpu'): + def _sample_points(self, params=Points.empty(), device="cpu"): if any(var in self.domain.necessary_variables for var in params.space.keys()): - return self._sample_params_dependent(self.domain.sample_grid, params, device) + return self._sample_params_dependent( + self.domain.sample_grid, params, device + ) return self._sample_params_independent(self.domain.sample_grid, params, device) - def _sample_points_with_filter(self, params=Points.empty(), device='cpu'): + def _sample_points_with_filter(self, params=Points.empty(), device="cpu"): if self.n_points: sample_points = self._sample_n_points_with_filter(params, device) else: - # for density sampling, just sample normally and afterwards remove all + # for density sampling, just sample normally and afterwards remove all # points that are not allowed sample_points = self._sample_points(params, device) sample_points = self._apply_filter(sample_points) @@ -54,11 +58,13 @@ def _sample_n_points_with_filter(self, params, device): num_of_params = max(1, len(params)) sample_points = None for i in range(num_of_params): - ith_params = params[i, ] if len(params) > 0 else Points.empty() - new_points = self._sample_grid(ith_params, sample_function, - self.n_points, device) - new_better_points = self._resample_grid(new_points, ith_params, - sample_function, device) + ith_params = params[i,] if len(params) > 0 else Points.empty() + new_points = self._sample_grid( + ith_params, sample_function, self.n_points, device + ) + new_better_points = self._resample_grid( + new_points, ith_params, sample_function, device + ) # if to many points were sampled, delete the last ones. cuted_points = self._cut_tensor_to_length_n(new_better_points) sample_points = self._set_sampled_points(sample_points, cuted_points) @@ -75,13 +81,15 @@ def _resample_grid(self, new_points, current_params, sample_func, device): # the first grid is already perfect return new_points elif len(new_points) == 0: - warnings.warn("""First iteration did not find any valid grid points, for + warnings.warn( + """First iteration did not find any valid grid points, for the given filter. Will try again with n = 10 * self.n_points. Or - else use only random points!""") - scaled_n = int(10*self.n_points) + else use only random points!""" + ) + scaled_n = int(10 * self.n_points) else: - scaled_n = int(self.n_points**2/len(new_points)) + scaled_n = int(self.n_points**2 / len(new_points)) new_points = self._sample_grid(current_params, sample_func, scaled_n, device) final_points = self._append_random_points(new_points, current_params, device) return final_points @@ -89,12 +97,13 @@ def _resample_grid(self, new_points, current_params, sample_func, device): def _append_random_points(self, new_points, current_params, device): if len(new_points) == self.n_points: return new_points - random_sampler = RandomUniformSampler(domain=self.domain, - n_points=self.n_points) + random_sampler = RandomUniformSampler( + domain=self.domain, n_points=self.n_points + ) random_sampler.filter_fn = self.filter_fn random_points = random_sampler.sample_points(current_params, device=device) return new_points | random_points - + class ExponentialIntervalSampler(PointSampler): """Will sample non equdistant grid points in the given interval. @@ -105,35 +114,38 @@ class ExponentialIntervalSampler(PointSampler): domain : torchphysics.domain.Interval The Interval in which the points should be sampled. n_points : int - The number of points that should be sampled. + The number of points that should be sampled. exponent : Number Determines how non equdistant the points are and at which corner they are accumulated. They are computed with a grid in [0, 1] and then transformed with the exponent and later scaled/translated: - exponent < 1: More points at the upper bound. + exponent < 1: More points at the upper bound. points = 1 - x**(1/exponent) exponent > 1: More points at the lower bound. points = x**(exponent) """ + def __init__(self, domain, n_points, exponent): assert isinstance(domain, Interval), """The domain has to be a interval!""" super().__init__(n_points=n_points) self.domain = domain self.exponent = exponent - def sample_points(self, params=Points.empty(), device='cpu'): + def sample_points(self, params=Points.empty(), device="cpu"): if any(var in self.domain.necessary_variables for var in params.space.keys()): - return self._sample_params_dependent(self._sample_spaced_grid, params, device) + return self._sample_params_dependent( + self._sample_spaced_grid, params, device + ) return self._sample_params_independent(self._sample_spaced_grid, params, device) - def _sample_spaced_grid(self, n=None, d=None, params=Points.empty(), device='cpu'): + def _sample_spaced_grid(self, n=None, d=None, params=Points.empty(), device="cpu"): lb = self.domain.lower_bound(params) ub = self.domain.upper_bound(params) - points = torch.linspace(0, 1, len(self)+2, device=device)[1:-1] + points = torch.linspace(0, 1, len(self) + 2, device=device)[1:-1] if self.exponent > 1: points = points**self.exponent else: - points = 1 - points**(1/self.exponent) + points = 1 - points ** (1 / self.exponent) interval_length = ub - lb points = points * interval_length + lb - return Points(points.reshape(-1, 1), self.domain.space) \ No newline at end of file + return Points(points.reshape(-1, 1), self.domain.space) diff --git a/src/torchphysics/problem/samplers/plot_samplers.py b/src/torchphysics/problem/samplers/plot_samplers.py index 99faac5f..9618ed59 100644 --- a/src/torchphysics/problem/samplers/plot_samplers.py +++ b/src/torchphysics/problem/samplers/plot_samplers.py @@ -1,5 +1,6 @@ """Samplers for plotting and animations of model outputs. """ + import numpy as np import torch @@ -26,20 +27,28 @@ class PlotSampler(PointSampler): device : str or torch device, optional The device of the model/function. data_for_other_variables : dict or torchphysics.spaces.Points, optional - Since the plot will only evaluate the model at a specific point, - the values for all other variables are needed. + Since the plot will only evaluate the model at a specific point, + the values for all other variables are needed. E.g. {'t' : 1, 'D' : [1,2], ...} Notes ----- Can also be used to create your own PlotSampler. By either changing the - used sampler after the initialization (self.sampler=...) or by creating + used sampler after the initialization (self.sampler=...) or by creating your own class that inherits from PlotSampler. """ - def __init__(self, plot_domain, n_points=None, density=None, device='cpu', - data_for_other_variables={}): - assert not isinstance(plot_domain, BoundaryDomain), \ - "Plotting for boundaries is not implemented""" + + def __init__( + self, + plot_domain, + n_points=None, + density=None, + device="cpu", + data_for_other_variables={}, + ): + assert not isinstance(plot_domain, BoundaryDomain), ( + "Plotting for boundaries is not implemented" "" + ) super().__init__(n_points=n_points, density=density) self.device = device self.created_points = None @@ -60,8 +69,7 @@ def set_data_for_other_variables(self, data_for_other_variables): self.data_for_other_variables = Points.from_coordinates(torch_data) def transform_data_to_torch(self, data_for_other_variables): - """Transforms all inputs to a torch.tensor. - """ + """Transforms all inputs to a torch.tensor.""" torch_data = {} for vname, data in data_for_other_variables.items(): # transform data to torch @@ -82,7 +90,7 @@ def construct_sampler(self): """ if self.n_points: return self._plot_sampler_with_n_points() - else: # density is used + else: # density is used return self._plot_sampler_with_density() def _plot_sampler_with_n_points(self): @@ -90,7 +98,7 @@ def _plot_sampler_with_n_points(self): return self._construct_sampler_for_Interval(self.domain, n=self.n_points) inner_n_points = self._compute_inner_number_of_points() inner_sampler = GridSampler(self.domain, inner_n_points) - outer_sampler = GridSampler(self.domain.boundary, len(self)-inner_n_points) + outer_sampler = GridSampler(self.domain.boundary, len(self) - inner_n_points) return inner_sampler + outer_sampler def _plot_sampler_with_density(self): @@ -104,14 +112,14 @@ def _construct_sampler_for_Interval(self, domain, n=None, d=None): left_sampler = GridSampler(domain.boundary_left, 1) inner_sampler = GridSampler(domain, n_points=n, density=d) right_sampler = GridSampler(domain.boundary_right, 1) - return left_sampler + inner_sampler + right_sampler + return left_sampler + inner_sampler + right_sampler def _compute_inner_number_of_points(self): - n_root = int(np.ceil(len(self)**(1/self.domain.dim))) + n_root = int(np.ceil(len(self) ** (1 / self.domain.dim))) n_root -= 2 return n_root**self.domain.dim - def sample_points(self, params=Points.empty(), device='cpu'): + def sample_points(self, params=Points.empty(), device="cpu"): """Creates the points for the plot. Does not need additional arguments, since they were set in the init. """ @@ -139,11 +147,11 @@ class AnimationSampler(PlotSampler): The domain over which the model/function should later be plotted. Will create points inside and at the boundary of the domain. animation_domain : Interval - The variable over which the animation should be created, e.g a + The variable over which the animation should be created, e.g a time-interval. frame_number : int The number of frames that should be used for the animation. This - equals the number of points that will be created in the + equals the number of points that will be created in the animation_domain. n_points : int, optional The number of points that should be used for the plot domain. @@ -152,45 +160,59 @@ class AnimationSampler(PlotSampler): device : str or torch device, optional The device of the model/function. data_for_other_variables : dict, optional - Since the animation will only evaluate the model at specific points, - the values for all other variables are needed. + Since the animation will only evaluate the model at specific points, + the values for all other variables are needed. E.g. {'D' : [1,2], ...} """ - def __init__(self, plot_domain, animation_domain, frame_number, - n_points=None, density=None, device='cpu', - data_for_other_variables={}): - super().__init__(plot_domain=plot_domain, n_points=n_points, - density=density, device=device, - data_for_other_variables=data_for_other_variables) + + def __init__( + self, + plot_domain, + animation_domain, + frame_number, + n_points=None, + density=None, + device="cpu", + data_for_other_variables={}, + ): + super().__init__( + plot_domain=plot_domain, + n_points=n_points, + density=density, + device=device, + data_for_other_variables=data_for_other_variables, + ) self._check_correct_types(animation_domain) self.frame_number = frame_number self.animation_domain = animation_domain(**data_for_other_variables) - self.animatoin_sampler = \ - self._construct_sampler_for_Interval(self.animation_domain, n=frame_number) + self.animatoin_sampler = self._construct_sampler_for_Interval( + self.animation_domain, n=frame_number + ) def _check_correct_types(self, animation_domain): - assert isinstance(animation_domain, Interval), \ - "The animation domain has to be a interval" + assert isinstance( + animation_domain, Interval + ), "The animation domain has to be a interval" @property def plot_domain_constant(self): """Returns if the plot domain is a constant domain or changes with respect to other variables. """ - dependent = any(vname in self.domain.necessary_variables \ - for vname in self.animation_domain.space) + dependent = any( + vname in self.domain.necessary_variables + for vname in self.animation_domain.space + ) return not dependent @property def animation_key(self): - """Retunrs the name of the animation variable - """ + """Retunrs the name of the animation variable""" ani_key = list(self.animation_domain.space.keys())[0] - return ani_key + return ani_key def sample_animation_points(self): - """Samples points out of the animation domain, e.g. time interval. - """ + """Samples points out of the animation domain, e.g. time interval.""" ani_points = self.animatoin_sampler.sample_points() num_of_points = len(ani_points) self.frame_number = num_of_points @@ -198,8 +220,7 @@ def sample_animation_points(self): return ani_points def sample_plot_domain_points(self, animation_points): - """Samples points in the plot domain, e.g. space. - """ + """Samples points in the plot domain, e.g. space.""" if self.plot_domain_constant: plot_points = self.sampler.sample_points() num_of_points = len(plot_points) @@ -211,7 +232,7 @@ def sample_plot_domain_points(self, animation_points): def _sample_params_dependent(self, params): output_list = [] for i in range(self.frame_number): - ith_ani_points = params[i, ] + ith_ani_points = params[i,] plot_points = self.sampler.sample_points(ith_ani_points) plot_points._t.to(self.device) output_list.append(plot_points) @@ -219,4 +240,4 @@ def _sample_params_dependent(self, params): def _set_device_and_grad_true(self, p): p._t.requires_grad = True - p._t.to(self.device) \ No newline at end of file + p._t.to(self.device) diff --git a/src/torchphysics/problem/samplers/random_samplers.py b/src/torchphysics/problem/samplers/random_samplers.py index 935cb95d..82a14997 100644 --- a/src/torchphysics/problem/samplers/random_samplers.py +++ b/src/torchphysics/problem/samplers/random_samplers.py @@ -1,5 +1,6 @@ """File with samplers that create random distributed points. """ + import torch import numbers @@ -26,25 +27,27 @@ class RandomUniformSampler(PointSampler): of inputs. The Sampler will use a rejection sampling to find the right amount of points. """ + def __init__(self, domain, n_points=None, density=None, filter_fn=None): super().__init__(n_points=n_points, density=density, filter_fn=filter_fn) self.domain = domain - def _sample_points(self, params=Points.empty(), device='cpu'): + def _sample_points(self, params=Points.empty(), device="cpu"): if self.n_points: - rand_points = self.domain.sample_random_uniform(self.n_points, - params=params, - device=device) + rand_points = self.domain.sample_random_uniform( + self.n_points, params=params, device=device + ) repeated_params = self._repeat_params(params, len(self)) return rand_points.join(repeated_params) - else: # density is used + else: # density is used sample_function = self.domain.sample_random_uniform - if any(var in self.domain.necessary_variables for \ - var in params.space.keys()): + if any( + var in self.domain.necessary_variables for var in params.space.keys() + ): return self._sample_params_dependent(sample_function, params, device) return self._sample_params_independent(sample_function, params, device) - def _sample_points_with_filter(self, params=Points.empty(), device='cpu'): + def _sample_points_with_filter(self, params=Points.empty(), device="cpu"): if self.n_points: sample_points = self._sample_n_points_with_filter(params, device) else: @@ -65,13 +68,15 @@ def _sample_n_points_with_filter(self, params, device): # we have to make sure to sample for each param exactly n points while num_of_new_points < self.n_points: # sample points - new_points = self._sample_for_ith_param(sample_function, params, - i, device) + new_points = self._sample_for_ith_param( + sample_function, params, i, device + ) # apply filter and save valid points new_points = self._apply_filter(new_points) num_of_new_points += len(new_points) - new_sample_points = self._set_sampled_points(new_sample_points, - new_points) + new_sample_points = self._set_sampled_points( + new_sample_points, new_points + ) iterations += 1 self._check_iteration_number(iterations, num_of_new_points) # if to many points were sampled, delete them. @@ -96,9 +101,11 @@ class GaussianSampler(PointSampler): std : number The standard deviation of the distribution. """ + def __init__(self, domain, n_points, mean, std): - assert not isinstance(domain, BoundaryDomain), \ - """Gaussian sampling is not implemented for boundaries.""" + assert not isinstance( + domain, BoundaryDomain + ), """Gaussian sampling is not implemented for boundaries.""" super().__init__(n_points=n_points) self.domain = domain self.mean = mean @@ -110,10 +117,11 @@ def _check_mean_correct_dim(self): self.mean = torch.FloatTensor([self.mean]) elif not isinstance(self.mean, torch.Tensor): self.mean = torch.FloatTensor(self.mean) - assert len(self.mean) == self.domain.dim, \ - f"""Dimension of mean: {self.mean}, does not fit the domain.""" + assert ( + len(self.mean) == self.domain.dim + ), f"""Dimension of mean: {self.mean}, does not fit the domain.""" - def _sample_points(self, params=Points.empty(), device='cpu'): + def _sample_points(self, params=Points.empty(), device="cpu"): self._set_device_of_mean_and_std(device) num_of_params = max(1, len(params)) sample_points = None @@ -121,7 +129,7 @@ def _sample_points(self, params=Points.empty(), device='cpu'): for i in range(num_of_params): current_num_of_points = 0 new_sample_points = None - ith_params = params[i, ] if len(params) > 0 else Points.empty() + ith_params = params[i,] if len(params) > 0 else Points.empty() repeat_params = self._repeat_params(ith_params, len(self)) while current_num_of_points < self.n_points: new_points = torch_dis.sample((self.n_points,)) @@ -129,8 +137,9 @@ def _sample_points(self, params=Points.empty(), device='cpu'): new_points = new_points.join(repeat_params) new_points = self._check_inside_domain(new_points) current_num_of_points += len(new_points) - new_sample_points = self._set_sampled_points(new_sample_points, - new_points) + new_sample_points = self._set_sampled_points( + new_sample_points, new_points + ) # if to many points were sampled, delete them. cuted_points = self._cut_tensor_to_length_n(new_sample_points) sample_points = self._set_sampled_points(sample_points, cuted_points) @@ -143,7 +152,7 @@ def _set_device_of_mean_and_std(self, device): def _check_inside_domain(self, new_points): inside = self.domain._contains(new_points) index = torch.where(inside)[0] - return new_points[index, ] + return new_points[index,] class LHSSampler(PointSampler): @@ -164,17 +173,19 @@ class LHSSampler(PointSampler): added to get a total number of n_points. .. [#] https://en.wikipedia.org/wiki/Latin_hypercube_sampling """ + def __init__(self, domain, n_points): - assert not isinstance(domain, BoundaryDomain), \ - """LHS sampling is not implemented for boundaries.""" + assert not isinstance( + domain, BoundaryDomain + ), """LHS sampling is not implemented for boundaries.""" super().__init__(n_points=n_points) self.domain = domain - def _sample_points(self, params=Points.empty(), device='cpu'): + def _sample_points(self, params=Points.empty(), device="cpu"): num_of_params = max(1, len(params)) sample_points = None for i in range(num_of_params): - ith_params = params[i, ] if len(params) > 0 else Points.empty() + ith_params = params[i,] if len(params) > 0 else Points.empty() bounding_box = self.domain.bounding_box(ith_params, device=device) lhs_in_box = self._create_lhs_in_bounding_box(bounding_box, device) new_points = self._check_lhs_inside(lhs_in_box, ith_params) @@ -186,11 +197,18 @@ def _create_lhs_in_bounding_box(self, bounding_box, device): lhs_points = torch.zeros((self.n_points, self.domain.dim), device=device) # for each axis apply the lhs strategy for i in range(self.domain.dim): - axis_grid = torch.linspace(bounding_box[2*i], bounding_box[2*i+1], - steps=self.n_points+1, device=device)[:-1] # dont need endpoint - axis_length = bounding_box[2*i+1] - bounding_box[2*i] - random_shift = axis_length/self.n_points * torch.rand(self.n_points, - device=device) + axis_grid = torch.linspace( + bounding_box[2 * i], + bounding_box[2 * i + 1], + steps=self.n_points + 1, + device=device, + )[ + :-1 + ] # dont need endpoint + axis_length = bounding_box[2 * i + 1] - bounding_box[2 * i] + random_shift = ( + axis_length / self.n_points * torch.rand(self.n_points, device=device) + ) axis_points = torch.add(axis_grid, random_shift) # change order of points, to get 'lhs-grid' at the end permutation = torch.randperm(self.n_points) @@ -203,16 +221,18 @@ def _check_lhs_inside(self, lhs_points, ith_params): new_points = new_points.join(repeat_params) inside = self.domain._contains(new_points) index = torch.where(inside)[0] - return new_points[index, ] + return new_points[index,] def _append_random_points(self, new_points, current_params): if len(new_points) == self.n_points: return new_points - random_sampler = RandomUniformSampler(domain=self.domain, - n_points=self.n_points-len(new_points)) + random_sampler = RandomUniformSampler( + domain=self.domain, n_points=self.n_points - len(new_points) + ) random_points = random_sampler.sample_points(current_params) return new_points | random_points + class AdaptiveThresholdRejectionSampler(AdaptiveSampler): """ An adaptive sampler that creates more points in regions with high loss. @@ -241,26 +261,29 @@ class AdaptiveThresholdRejectionSampler(AdaptiveSampler): The Sampler will use a rejection sampling to find the right amount of points. """ - def __init__(self, domain, resample_ratio, n_points=None, density=None, - filter_fn=None): + + def __init__( + self, domain, resample_ratio, n_points=None, density=None, filter_fn=None + ): super().__init__(n_points=n_points, density=density, filter_fn=filter_fn) self.domain = domain self.resample_ratio = resample_ratio - self.random_sampler = RandomUniformSampler(domain, - n_points=n_points, - density=density, - filter_fn=filter_fn) + self.random_sampler = RandomUniformSampler( + domain, n_points=n_points, density=density, filter_fn=filter_fn + ) self.last_points = None - def sample_points(self, unreduced_loss=None, params=Points.empty(), device='cpu'): + def sample_points(self, unreduced_loss=None, params=Points.empty(), device="cpu"): new_points = self.random_sampler.sample_points(params, device=device) if self.last_points is None or unreduced_loss is None: self.last_points = new_points else: max_l, min_l = torch.max(unreduced_loss), torch.min(unreduced_loss) - filter_tensor = unreduced_loss < min_l + (max_l-min_l)*self.resample_ratio - self.last_points._t[filter_tensor,:] = new_points._t[filter_tensor,:] + filter_tensor = ( + unreduced_loss < min_l + (max_l - min_l) * self.resample_ratio + ) + self.last_points._t[filter_tensor, :] = new_points._t[filter_tensor, :] return self.last_points @@ -288,23 +311,24 @@ class AdaptiveRandomRejectionSampler(AdaptiveSampler): The Sampler will use a rejection sampling to find the right amount of points. """ - def __init__(self, domain, n_points=None, density=None, - filter_fn=None): + + def __init__(self, domain, n_points=None, density=None, filter_fn=None): super().__init__(n_points=n_points, density=density, filter_fn=filter_fn) self.domain = domain - self.random_sampler = RandomUniformSampler(domain, - n_points=n_points, - density=density, - filter_fn=filter_fn) + self.random_sampler = RandomUniformSampler( + domain, n_points=n_points, density=density, filter_fn=filter_fn + ) self.last_points = None - def sample_points(self, unreduced_loss=None, params=Points.empty(), device='cpu'): + def sample_points(self, unreduced_loss=None, params=Points.empty(), device="cpu"): new_points = self.random_sampler.sample_points(params, device=device) if self.last_points is None or unreduced_loss is None: self.last_points = new_points else: max_l, min_l = torch.max(unreduced_loss), torch.min(unreduced_loss) - filter_tensor = unreduced_loss < min_l + (max_l-min_l)*torch.rand_like(unreduced_loss) - self.last_points._t[filter_tensor,:] = new_points._t[filter_tensor,:] + filter_tensor = unreduced_loss < min_l + (max_l - min_l) * torch.rand_like( + unreduced_loss + ) + self.last_points._t[filter_tensor, :] = new_points._t[filter_tensor, :] return self.last_points diff --git a/src/torchphysics/problem/samplers/sampler_base.py b/src/torchphysics/problem/samplers/sampler_base.py index b570a0b2..f63883c0 100644 --- a/src/torchphysics/problem/samplers/sampler_base.py +++ b/src/torchphysics/problem/samplers/sampler_base.py @@ -1,9 +1,10 @@ """The basic structure of every sampler and all sampler 'operations'. """ + import abc import torch import warnings -import math +import math from ...utils.user_fun import UserFunction from ..spaces.points import Points @@ -20,7 +21,7 @@ class PointSampler: The desired density of the created points. filter_fn : callable, optional A function that restricts the possible positions of sample points. - A point that is allowed should return True, therefore a point that should be + A point that is allowed should return True, therefore a point that should be removed must return false. The filter has to be able to work with a batch of inputs. The Sampler will use a rejection sampling to find the right amount of points. @@ -34,7 +35,7 @@ def __init__(self, n_points=None, density=None, filter_fn=None): self.filter_fn = UserFunction(filter_fn) else: self.filter_fn = None - + @classmethod def empty(cls, **kwargs): """Creates an empty Sampler object that samples empty points. @@ -48,7 +49,7 @@ def empty(cls, **kwargs): def set_length(self, length): """If a density is used, the number of points will not be known before - hand. If len(PointSampler) is needed one can set the expected number + hand. If len(PointSampler) is needed one can set the expected number of points here. Parameters @@ -58,8 +59,8 @@ def set_length(self, length): Notes ----- - If the domain is independent of other variables and a density is used, the - sampler will, after the first call to 'sample_points', set this value itself. + If the domain is independent of other variables and a density is used, the + sampler will, after the first call to 'sample_points', set this value itself. """ self.length = length @@ -74,14 +75,14 @@ def __next__(self): def __len__(self): """Returns the number of points that the sampler will create or - has created. + has created. Note ---- This can be only called if the number of points is set with ``n_points``. - Elsewise the the number can only be known after the first call to + Elsewise the the number can only be known after the first call to ``sample_points`` methode or may even change after each call. - If you know the number of points yourself, you can set this with + If you know the number of points yourself, you can set this with ``.set_length``. """ if self.length is not None: @@ -89,13 +90,15 @@ def __len__(self): elif self.n_points is not None: return self.n_points else: - raise ValueError("""The expected number of samples is not known yet. + raise ValueError( + """The expected number of samples is not known yet. Set the length by using .set_length, if this - property is needed""") + property is needed""" + ) - def make_static(self, resample_interval =math.inf): + def make_static(self, resample_interval=math.inf): """Transforms a sampler to an ``StaticSampler``. A StaticSampler only creates - points the first time .sample_points() is called. Afterwards the points + points the first time .sample_points() is called. Afterwards the points are saved and will always be returned if .sample_points() is called again. Useful if the same points should be used while training/validation or if it is not practicall to create new points in each iteration @@ -104,15 +107,15 @@ def make_static(self, resample_interval =math.inf): Parameters ---------- resample_interval : int, optional - Parameter to specify if new sampling of points should be created after a fixed number - of iterations. E.g. resample_interval =5, will use the same points for five iterations + Parameter to specify if new sampling of points should be created after a fixed number + of iterations. E.g. resample_interval =5, will use the same points for five iterations and then sample a new batch that will be used for the next five iterations. """ return StaticSampler(self, resample_interval) @property def is_static(self): - """Checks if the Sampler is a ``StaticSampler``, e.g. retuns always the + """Checks if the Sampler is a ``StaticSampler``, e.g. retuns always the same points. """ return isinstance(self, StaticSampler) @@ -124,7 +127,7 @@ def is_adaptive(self): """ return isinstance(self, AdaptiveSampler) - def sample_points(self, params=Points.empty(), device='cpu'): + def sample_points(self, params=Points.empty(), device="cpu"): """The method that creates the points. Also implemented in all child classes. Parameters @@ -138,9 +141,9 @@ def sample_points(self, params=Points.empty(), device='cpu'): Returns ------- Points: - A Points-Object containing the created points and, if parameters were + A Points-Object containing the created points and, if parameters were passed as an input, the parameters. Whereby the input parameters - will get repeated, so that each row of the tensor corresponds to + will get repeated, so that each row of the tensor corresponds to valid point in the given (product) domain. """ if self.filter_fn: @@ -150,11 +153,11 @@ def sample_points(self, params=Points.empty(), device='cpu'): return out @abc.abstractmethod - def _sample_points_with_filter(self, params=Points.empty(), device='cpu'): + def _sample_points_with_filter(self, params=Points.empty(), device="cpu"): raise NotImplementedError @abc.abstractmethod - def _sample_points(self, params=Points.empty(), device='cpu'): + def _sample_points(self, params=Points.empty(), device="cpu"): raise NotImplementedError def __mul__(self, other): @@ -165,14 +168,14 @@ def __mul__(self, other): return ProductSampler(self, other) def __add__(self, other): - """Creates a sampler which samples from two different samples and + """Creates a sampler which samples from two different samples and concatenates both outputs, see ``ConcatSampler``. """ assert isinstance(other, PointSampler) return ConcatSampler(self, other) def append(self, other): - """Creates a sampler which samples from two different samples and + """Creates a sampler which samples from two different samples and makes a column stack of both outputs, see ``AppendSampler``. """ assert isinstance(other, PointSampler) @@ -193,7 +196,7 @@ def _sample_params_independent(self, sample_function, params, device): def _sample_params_dependent(self, sample_function, params, device): """If the domain is dependent on some params, we can't always sample points for all params at once. Therefore we need a loop to iterate over the params. - This happens for example with denstiy sampling or grid sampling. + This happens for example with denstiy sampling or grid sampling. """ num_of_params = max(1, len(params)) sample_points = None @@ -203,7 +206,7 @@ def _sample_params_dependent(self, sample_function, params, device): return sample_points def _sample_for_ith_param(self, sample_function, params, i, device): - ith_params = params[i, ] if len(params) > 0 else Points.empty() + ith_params = params[i,] if len(params) > 0 else Points.empty() new_points = sample_function(self.n_points, self.density, ith_params, device) num_of_points = len(new_points) repeated_params = self._repeat_params(ith_params, num_of_points) @@ -215,27 +218,32 @@ def _set_sampled_points(self, sample_points, new_points): return sample_points | new_points def _repeat_params(self, params, n): - repeated_params = Points(torch.repeat_interleave(params, n, dim=0), - params.space) + repeated_params = Points( + torch.repeat_interleave(params, n, dim=0), params.space + ) return repeated_params def _apply_filter(self, sample_points): filter_true = self.filter_fn(sample_points) index = torch.where(filter_true)[0] - return sample_points[index, ] + return sample_points[index,] def _check_iteration_number(self, iterations, num_of_new_points): if iterations == 10: - warnings.warn(f"""Sampling points with filter did run 10 + warnings.warn( + f"""Sampling points with filter did run 10 iterations and until now only found {num_of_new_points} from {self.n_points} points. - This may take some time.""") + This may take some time.""" + ) elif iterations >= 20 and num_of_new_points == 0: - raise RuntimeError("""Run 20 iterations and could not find a single - valid point for the filter condition.""") + raise RuntimeError( + """Run 20 iterations and could not find a single + valid point for the filter condition.""" + ) def _cut_tensor_to_length_n(self, points): - return points[:self.n_points, ] + return points[: self.n_points,] class ProductSampler(PointSampler): @@ -258,7 +266,7 @@ def __len__(self): return self.length return len(self.sampler_a) * len(self.sampler_b) - def sample_points(self, params=Points.empty(), device='cpu'): + def sample_points(self, params=Points.empty(), device="cpu"): b_points = self.sampler_b.sample_points(params, device=device) a_points = self.sampler_a.sample_points(b_points, device=device) self.set_length(len(a_points)) @@ -285,7 +293,7 @@ def __len__(self): return self.length return len(self.sampler_a) + len(self.sampler_b) - def sample_points(self, params=Points.empty(), device='cpu'): + def sample_points(self, params=Points.empty(), device="cpu"): samples_a = self.sampler_a.sample_points(params, device=device) samples_b = self.sampler_b.sample_points(params, device=device) self.set_length(len(samples_a) + len(samples_b)) @@ -299,7 +307,7 @@ class AppendSampler(PointSampler): Parameters ---------- sampler_a, sampler_b : PointSampler - The two PointSamplers that should be connected. Both Samplers should create + The two PointSamplers that should be connected. Both Samplers should create the same number of points. """ @@ -313,7 +321,7 @@ def __len__(self): return self.length return len(self.sampler_a) - def sample_points(self, params=Points.empty(), device='cpu'): + def sample_points(self, params=Points.empty(), device="cpu"): samples_a = self.sampler_a.sample_points(params, device=device) samples_b = self.sampler_b.sample_points(params, device=device) self.set_length(len(samples_a)) @@ -321,7 +329,7 @@ def sample_points(self, params=Points.empty(), device='cpu'): class StaticSampler(PointSampler): - """Constructs a sampler that saves the first points created and + """Constructs a sampler that saves the first points created and afterwards only returns these points again. Has the advantage that the points only have to be computed once. Can also be customized to created new points after a fixed number of iterations. @@ -329,10 +337,10 @@ class StaticSampler(PointSampler): Parameters ---------- sampler : Pointsampler - The basic sampler that will create the points. + The basic sampler that will create the points. resample_interval : int, optional - Parameter to specify if new sampling of points should be created after a fixed number - of iterations. E.g. resample_interval =5, will use the same points for five iterations + Parameter to specify if new sampling of points should be created after a fixed number + of iterations. E.g. resample_interval =5, will use the same points for five iterations and then sample a new batch that will be used for the next five iterations. """ @@ -340,7 +348,7 @@ def __init__(self, sampler, resample_interval=math.inf): self.length = None self.sampler = sampler self.created_points = None - self.resample_interval = resample_interval + self.resample_interval = resample_interval self.counter = 0 def __len__(self): @@ -353,7 +361,7 @@ def __next__(self): return self.created_points return self.sample_points() - def sample_points(self, params=Points.empty(), device='cpu', **kwargs): + def sample_points(self, params=Points.empty(), device="cpu", **kwargs): self.counter += 1 if self.created_points and self.counter < self.resample_interval: self._change_device(device=device) @@ -365,7 +373,7 @@ def sample_points(self, params=Points.empty(), device='cpu', **kwargs): return points def _change_device(self, device): - self.created_points = self.created_points.to(device) + self.created_points = self.created_points.to(device) def make_static(self, resample_interval=math.inf): self.resample_interval = resample_interval @@ -374,13 +382,12 @@ def make_static(self, resample_interval=math.inf): class EmptySampler(PointSampler): """A sampler that creates only empty Points. Can be used as a placeholder.""" + def __init__(self): super().__init__(n_points=0) - - def sample_points(self, params=Points.empty(), device='cpu', **kwargs): - return Points.empty() - + def sample_points(self, params=Points.empty(), device="cpu", **kwargs): + return Points.empty() class AdaptiveSampler(PointSampler): @@ -388,15 +395,15 @@ class AdaptiveSampler(PointSampler): last sampled set of points. """ - def sample_points(self, unreduced_loss, params=Points.empty(), device='cpu'): - """Extends the sample methode of the parent class. Also requieres the + def sample_points(self, unreduced_loss, params=Points.empty(), device="cpu"): + """Extends the sample methode of the parent class. Also requieres the unreduced loss of the previous iteration to create the new points. Parameters ---------- unreduced_loss : torch.tensor - The tensor containing the loss of each training point in the previous - iteration. + The tensor containing the loss of each training point in the previous + iteration. params : torchphysics.spaces.Points Additional parameters for the domain. device : str @@ -406,15 +413,17 @@ def sample_points(self, unreduced_loss, params=Points.empty(), device='cpu'): Returns ------- Points: - A Points-Object containing the created points and, if parameters were + A Points-Object containing the created points and, if parameters were passed as an input, the parameters. Whereby the input parameters - will get repeated, so that each row of the tensor corresponds to + will get repeated, so that each row of the tensor corresponds to valid point in the given (product) domain. """ if self.filter_fn: - out = self._sample_points_with_filter(unreduced_loss=unreduced_loss, - params=params, device=device) + out = self._sample_points_with_filter( + unreduced_loss=unreduced_loss, params=params, device=device + ) else: - out = self._sample_points(unreduced_loss=unreduced_loss, - params=params, device=device) + out = self._sample_points( + unreduced_loss=unreduced_loss, params=params, device=device + ) return out diff --git a/src/torchphysics/problem/spaces/__init__.py b/src/torchphysics/problem/spaces/__init__.py index 36060083..ff9719ec 100644 --- a/src/torchphysics/problem/spaces/__init__.py +++ b/src/torchphysics/problem/spaces/__init__.py @@ -11,7 +11,6 @@ The second axis collects the space dimensionalities. """ -from .space import (Space, - R1, R2, R3, Rn) +from .space import Space, R1, R2, R3, Rn from .points import Points -from .functionspace import FunctionSpace \ No newline at end of file +from .functionspace import FunctionSpace diff --git a/src/torchphysics/problem/spaces/functionspace.py b/src/torchphysics/problem/spaces/functionspace.py index aa5b6191..c9812bce 100644 --- a/src/torchphysics/problem/spaces/functionspace.py +++ b/src/torchphysics/problem/spaces/functionspace.py @@ -1,5 +1,4 @@ - -class FunctionSpace(): +class FunctionSpace: """ A FunctionSpace collects functions that map from a specific input domain to a previously defined output space. @@ -11,6 +10,7 @@ class FunctionSpace(): output_space : torchphysics.Space The space of the image of the functions in this function space. """ + def __init__(self, input_domain, output_space): self.input_domain = input_domain self.output_space = output_space diff --git a/src/torchphysics/problem/spaces/points.py b/src/torchphysics/problem/spaces/points.py index 76526793..28e262be 100644 --- a/src/torchphysics/problem/spaces/points.py +++ b/src/torchphysics/problem/spaces/points.py @@ -1,5 +1,6 @@ """Contains a class that handles the storage of all created data points. """ + from typing import Iterable import torch import numpy as np @@ -7,7 +8,7 @@ from .space import Space -class Points(): +class Points: """A set of points in a space, stored as a torch.Tensor. Can contain multiple axis which keep batch-dimensions. @@ -31,8 +32,11 @@ def __init__(self, data, space, **kwargs): self._t = torch.as_tensor(data, **kwargs) self.space = space assert len(self._t.shape) >= 2 - assert self._t.shape[-1] == self.space.dim, \ - "Data dimension does not fit dimension of the space " + str(list(self.space.keys())) + assert ( + self._t.shape[-1] == self.space.dim + ), "Data dimension does not fit dimension of the space " + str( + list(self.space.keys()) + ) @classmethod def empty(cls, **kwargs): @@ -48,7 +52,7 @@ def empty(cls, **kwargs): @classmethod def joined(cls, *points_l): """Concatenates different Points to one single Points-Object. - Will we use torch.cat on the data of the different Points and + Will we use torch.cat on the data of the different Points and create the product space of the Points spaces. Parameters @@ -102,14 +106,12 @@ def from_coordinates(cls, coords): @property def dim(self): - """Returns the dimension of the points. - """ + """Returns the dimension of the points.""" return self.space.dim @property def variables(self): - """Returns variables of the points as an unordered set, e.g {'x', 't'}. - """ + """Returns variables of the points as an unordered set, e.g {'x', 't'}.""" return self.space.variables @property @@ -174,24 +176,27 @@ def __repr__(self): def _compute_slice(self, val): if isinstance(val, tuple): val = list(val) - - if isinstance(val, (np.ndarray, torch.Tensor)) and val.dtype in (bool, torch.bool): + + if isinstance(val, (np.ndarray, torch.Tensor)) and val.dtype in ( + bool, + torch.bool, + ): if len(val.shape) == len(self._t.shape): raise IndexError("Boolean slicing in last dimension is not supported.") out_space = self.space if isinstance(val, list): # check if Ellipsis(...) is inside the slicing input. - # Here we have to be carefull if specific indices are passed in, as an + # Here we have to be carefull if specific indices are passed in, as an # array/tensor since they do not allow to check: Ellipse in val # because then the check Ellipse == val[i] is used -> returns array slice_is_correct = True for slice_value in val: - slice_is_correct = (slice_value is Ellipsis) + slice_is_correct = slice_value is Ellipsis if slice_is_correct: break # check last element is not Ellipsis: - slice_is_correct = (slice_is_correct and not val[-1] is Ellipsis) + slice_is_correct = slice_is_correct and not val[-1] is Ellipsis # compute slice structure if (len(val) == len(self._t.shape)) or slice_is_correct: slc = self._variable_slices @@ -238,26 +243,23 @@ def __iter__(self): yield self[i] def __eq__(self, other): - """Compares two Points if they are equal. - """ + """Compares two Points if they are equal.""" return self.space == other.space and torch.equal(self._t, other._t) def __add__(self, other): - """Adds the data of two Points, have to lay in the same space. - """ + """Adds the data of two Points, have to lay in the same space.""" assert isinstance(other, Points) assert other.space == self.space return Points(self._t + other._t, self.space) def __sub__(self, other): - """Substracts the data of two Points, have to lay in the same space. - """ + """Substracts the data of two Points, have to lay in the same space.""" assert isinstance(other, Points) assert other.space == self.space return Points(self._t - other._t, self.space) def __mul__(self, other): - """Pointwise multiplies the data of two Points, + """Pointwise multiplies the data of two Points, have to lay in the same space. """ assert isinstance(other, Points) @@ -270,10 +272,10 @@ def __pow__(self, other): """ assert isinstance(other, Points) assert other.space == self.space - return Points(self._t ** other._t, self.space) + return Points(self._t**other._t, self.space) def __truediv__(self, other): - """Pointwise divides the data of two Points, + """Pointwise divides the data of two Points, have to lay in the same space. """ assert isinstance(other, Points) @@ -281,7 +283,7 @@ def __truediv__(self, other): return Points(self._t / other._t, self.space) def __or__(self, other): - """Appends the data points of the second Points behind the + """Appends the data points of the second Points behind the data of the first Points in the first batch-dim. (torch.cat((data_1, data_2), dim=0)) """ @@ -294,7 +296,7 @@ def __or__(self, other): return Points(torch.cat([self._t, other._t], dim=0), self.space) def join(self, other): - """Stacks the data points of the second Point behind the + """Stacks the data points of the second Point behind the data of the first Point. (torch.cat((data_1, data_2), dim=-1)) """ assert isinstance(other, Points) @@ -306,16 +308,18 @@ def join(self, other): return Points(torch.cat([self._t, other._t], dim=-1), self.space * other.space) def repeat(self, *n): - """Repeats this points data along the first batch-dimension. + """Repeats this points data along the first batch-dimension. Uses torch.repeat and will therefore repeat the data 'batchwise'. Parameters ---------- n : - The number of repeats. + The number of repeats. """ - return Points(self._t.repeat(*n, *(((len(self._t.shape)-len(n)))*[1])), self.space) - + return Points( + self._t.repeat(*n, *(((len(self._t.shape) - len(n))) * [1])), self.space + ) + def unsqueeze(self, dim): """Adds an additional dimension inside the batch dimensions. @@ -337,16 +341,15 @@ def __torch_function__(cls, func, types, args=(), kwargs=None): """ if kwargs is None: kwargs = {} - args_list = [a._t if hasattr(a, '_t') else a for a in args] - spaces = tuple(a.space for a in args if hasattr(a, 'space')) + args_list = [a._t if hasattr(a, "_t") else a for a in args] + spaces = tuple(a.space for a in args if hasattr(a, "space")) assert len(spaces) > 0 ret = func(*args_list, **kwargs) return ret @property def requires_grad(self): - """Returns the '.requires_grad' property of the underlying Tensor. - """ + """Returns the '.requires_grad' property of the underlying Tensor.""" return self._t.requires_grad @requires_grad.setter @@ -365,11 +368,10 @@ def cuda(self, *args, **kwargs): return self def to(self, *args, **kwargs): - """Moves the underlying Tensor to other hardware parts. - """ + """Moves the underlying Tensor to other hardware parts.""" self._t = self._t.to(*args, **kwargs) return self - + def track_coord_gradients(self): points_coordinates = self.coordinates for var in points_coordinates: diff --git a/src/torchphysics/problem/spaces/space.py b/src/torchphysics/problem/spaces/space.py index c3f10bab..ad933897 100644 --- a/src/torchphysics/problem/spaces/space.py +++ b/src/torchphysics/problem/spaces/space.py @@ -2,7 +2,7 @@ class Space(Counter, OrderedDict): - """A Space defines (and assigns) the dimensions of the variables + """A Space defines (and assigns) the dimensions of the variables that appear in the differentialequation. This class sholud not be instanced directly, rather the corresponding child classes. @@ -12,12 +12,13 @@ class Space(Counter, OrderedDict): A dictionary containing the name of the variables and the dimension of the respective variable. """ + def __init__(self, variables_dims): # set counter of variable names and their dimensionalities super().__init__(variables_dims) def __mul__(self, other): - """Creates the product space of the two input spaces. Allows the + """Creates the product space of the two input spaces. Allows the construction of higher dimensional spaces with 'mixed' variable names. E.g R1('x')*R1('y') is a two dimensional space where one axis is 'x' and the other stands for 'y'. @@ -40,22 +41,24 @@ def __contains__(self, space): return (self & space) == space else: return False - + def __getitem__(self, val): """Returns a part of the Space dicitionary, specified in the - input. Mathematically, this constructs a subspace. + input. Mathematically, this constructs a subspace. Parameters ---------- val : str, slice, list or tuple - The keys that correspond to the variables that should be used in the + The keys that correspond to the variables that should be used in the subspace. """ if isinstance(val, slice): keys = list(self.keys()) - new_slice = slice(keys.index(val.start) if val.start is not None else None, - keys.index(val.stop) if val.stop is not None else None, - val.step) + new_slice = slice( + keys.index(val.start) if val.start is not None else None, + keys.index(val.stop) if val.stop is not None else None, + val.step, + ) new_keys = keys[new_slice] return Space({k: self[k] for k in new_keys}) if isinstance(val, list) or isinstance(val, tuple): @@ -65,10 +68,9 @@ def __getitem__(self, val): @property def dim(self): - """Returns the dimension of the space (sum of factor spaces) - """ + """Returns the dimension of the space (sum of factor spaces)""" return sum(self.values()) - + @property def variables(self): """ @@ -89,8 +91,9 @@ def __ne__(self, o: object) -> bool: other dimensions will be kept in the order of their creation by products or __init__. """ + def __repr__(self): - return '%s(%r)' % (self.__class__.__name__, dict(OrderedDict(self))) + return "%s(%r)" % (self.__class__.__name__, dict(OrderedDict(self))) def __reduce__(self): return self.__class__, (OrderedDict(self),) @@ -102,14 +105,14 @@ def check_values_in_space(self, values): ---------- values : torch.tensor A tensor of values that should be checked. - Generally the last dimension of the tensor has to fit + Generally the last dimension of the tensor has to fit the dimension of this space. Returns ------- torch.tensor In the case, that the values have not the corrected shape, but can - be reshaped, thet reshaped values are returned. + be reshaped, thet reshaped values are returned. This is used in the matrix-space. """ assert values.shape[-1] == self.dim @@ -124,6 +127,7 @@ class R1(Space): variable_name: str The name of the variable that belongs to this space. """ + def __init__(self, variable_name): super().__init__({variable_name: 1}) @@ -136,6 +140,7 @@ class R2(Space): variable_name: str The name of the variable that belongs to this space. """ + def __init__(self, variable_name): super().__init__({variable_name: 2}) @@ -148,6 +153,7 @@ class R3(Space): variable_name: str The name of the variable that belongs to this space. """ + def __init__(self, variable_name): super().__init__({variable_name: 3}) @@ -162,7 +168,8 @@ class Rn(Space): n : int The dimension of this space. """ - def __init__(self, variable_name, n : int): + + def __init__(self, variable_name, n: int): super().__init__({variable_name: n}) @@ -193,6 +200,6 @@ def __init__(self, variable_name, n : int): # return values # if values.shape[-1] == self.dim: # # maybe values are given as a vector with correct dimension -# # -> reshape to matrix +# # -> reshape to matrix # return values.reshape(-1, self.rows, self.columns) -# raise AssertionError("Values do not belong to a matrix-space") \ No newline at end of file +# raise AssertionError("Values do not belong to a matrix-space") diff --git a/src/torchphysics/solver.py b/src/torchphysics/solver.py index 7cb8e681..3aedbcc0 100644 --- a/src/torchphysics/solver.py +++ b/src/torchphysics/solver.py @@ -10,8 +10,16 @@ class OptimizerSetting: """ A helper class to sum up the optimization setup in a single class. """ - def __init__(self, optimizer_class, lr, optimizer_args={}, scheduler_class=None, - scheduler_args={}, scheduler_frequency=1): + + def __init__( + self, + optimizer_class, + lr, + optimizer_args={}, + scheduler_class=None, + scheduler_args={}, + scheduler_frequency=1, + ): self.optimizer_class = optimizer_class self.lr = lr self.optimizer_args = optimizer_args @@ -37,11 +45,13 @@ class Solver(pl.LightningModule): A OptimizerSetting object that contains all necessary parameters for optimizing, see :class:`OptimizerSetting`. """ - def __init__(self, - train_conditions, - val_conditions=(), - optimizer_setting=OptimizerSetting(torch.optim.Adam, - 1e-3)): + + def __init__( + self, + train_conditions, + val_conditions=(), + optimizer_setting=OptimizerSetting(torch.optim.Adam, 1e-3), + ): super().__init__() self.train_conditions = nn.ModuleList(train_conditions) self.val_conditions = nn.ModuleList(val_conditions) @@ -53,9 +63,11 @@ def train_dataloader(self): # in conditions steps = self.trainer.max_steps if steps is None: - warnings.warn("The maximum amount of iterations should be defined in" + warnings.warn( + "The maximum amount of iterations should be defined in" "trainer.max_steps. If undefined, the solver will train in epochs" - "of 1000 steps.") + "of 1000 steps." + ) steps = 1000 return torch.utils.data.DataLoader(torch.empty(steps)) @@ -65,11 +77,15 @@ def val_dataloader(self): return torch.utils.data.DataLoader(torch.empty(1)) def _set_lr_scheduler(self, optimizer): - lr_scheduler = self.scheduler['class'](optimizer, **self.scheduler['args']) - lr_scheduler = {'scheduler': lr_scheduler, 'name': 'learning_rate', - 'interval': 'epoch', 'frequency': 1} + lr_scheduler = self.scheduler["class"](optimizer, **self.scheduler["args"]) + lr_scheduler = { + "scheduler": lr_scheduler, + "name": "learning_rate", + "interval": "epoch", + "frequency": 1, + } for input_name in self.scheduler: - if not input_name in ['class', 'args']: + if not input_name in ["class", "args"]: lr_scheduler[input_name] = self.scheduler[input_name] return lr_scheduler @@ -84,34 +100,37 @@ def on_train_start(self): def training_step(self, batch, batch_idx): loss = torch.zeros(1, requires_grad=True, device=self.device) for condition in self.train_conditions: - cond_loss = condition(device=self.device, iteration=self.n_training_step) - self.log(f'train/{condition.name}', cond_loss) - loss = loss + condition.weight*cond_loss + cond_loss = condition(device=self.device, iteration=self.n_training_step) + self.log(f"train/{condition.name}", cond_loss) + loss = loss + condition.weight * cond_loss - self.log('train/loss', loss) + self.log("train/loss", loss) self.n_training_step += 1 return loss def validation_step(self, batch, batch_idx): for condition in self.val_conditions: torch.set_grad_enabled(condition.track_gradients is not False) - self.log(f'val/{condition.name}', condition(device=self.device)) + self.log(f"val/{condition.name}", condition(device=self.device)) def configure_optimizers(self): optimizer = self.optimizer_setting.optimizer_class( self.parameters(), - lr = self.optimizer_setting.lr, - **self.optimizer_setting.optimizer_args + lr=self.optimizer_setting.lr, + **self.optimizer_setting.optimizer_args, ) if self.optimizer_setting.scheduler_class is None: return optimizer - lr_scheduler = self.optimizer_setting.scheduler_class(optimizer, - **self.optimizer_setting.scheduler_args + lr_scheduler = self.optimizer_setting.scheduler_class( + optimizer, **self.optimizer_setting.scheduler_args ) - lr_scheduler = {'scheduler': lr_scheduler, 'name': 'learning_rate', - 'interval': 'step', - 'frequency': self.optimizer_setting.scheduler_frequency} + lr_scheduler = { + "scheduler": lr_scheduler, + "name": "learning_rate", + "interval": "step", + "frequency": self.optimizer_setting.scheduler_frequency, + } for input_name in self.optimizer_setting.scheduler_args: lr_scheduler[input_name] = self.optimizer_setting.scheduler_args[input_name] return [optimizer], [lr_scheduler] diff --git a/src/torchphysics/utils/__init__.py b/src/torchphysics/utils/__init__.py index 8e54974e..cca0d359 100644 --- a/src/torchphysics/utils/__init__.py +++ b/src/torchphysics/utils/__init__.py @@ -7,16 +7,19 @@ They can give you a rough overview of the determined solution. These lay under torchphysics.utils.plotting """ -from .differentialoperators import (laplacian, - grad, - div, - jac, - partial, - convective, - rot, - normal_derivative, - sym_grad, - matrix_div) + +from .differentialoperators import ( + laplacian, + grad, + div, + jac, + partial, + convective, + rot, + normal_derivative, + sym_grad, + matrix_div, +) from .data import PointsDataset, PointsDataLoader, DeepONetDataLoader @@ -24,4 +27,4 @@ from .plotting import plot, animate, scatter from .evaluation import compute_min_and_max -from .callbacks import (WeightSaveCallback, PlotterCallback, TrainerStateCheckpoint) \ No newline at end of file +from .callbacks import WeightSaveCallback, PlotterCallback, TrainerStateCheckpoint diff --git a/src/torchphysics/utils/callbacks.py b/src/torchphysics/utils/callbacks.py index bee78fe8..753540cb 100644 --- a/src/torchphysics/utils/callbacks.py +++ b/src/torchphysics/utils/callbacks.py @@ -28,8 +28,16 @@ class WeightSaveCallback(Callback): save_final_model: True Whether the model should always be saved after the last iteration. """ - def __init__(self, model, path, name, check_interval, - save_initial_model=False, save_final_model=True): + + def __init__( + self, + model, + path, + name, + check_interval, + save_initial_model=False, + save_final_model=True, + ): super().__init__() self.model = model self.path = path @@ -38,32 +46,42 @@ def __init__(self, model, path, name, check_interval, self.save_initial_model = save_initial_model self.save_final_model = save_final_model - self.current_loss = float('inf') + self.current_loss = float("inf") def on_train_start(self, trainer, pl_module): if self.save_initial_model: - torch.save(self.model.state_dict(), self.path+'/' + self.name + '_init.pt') - - def on_train_batch_start(self, trainer, pl_module, batch, batch_idx, dataloader_idx): - if (self.check_interval > 0 and batch_idx > 0) and ((batch_idx-1) % self.check_interval == 0): - if trainer.logged_metrics['train/loss'] < self.current_loss: - self.current_loss = trainer.logged_metrics['train/loss'] - torch.save(self.model.state_dict(), - self.path+'/' + self.name + '_min_loss.pt') + torch.save( + self.model.state_dict(), self.path + "/" + self.name + "_init.pt" + ) + + def on_train_batch_start( + self, trainer, pl_module, batch, batch_idx, dataloader_idx + ): + if (self.check_interval > 0 and batch_idx > 0) and ( + (batch_idx - 1) % self.check_interval == 0 + ): + if trainer.logged_metrics["train/loss"] < self.current_loss: + self.current_loss = trainer.logged_metrics["train/loss"] + torch.save( + self.model.state_dict(), + self.path + "/" + self.name + "_min_loss.pt", + ) def on_train_end(self, trainer, pl_module): if self.save_final_model: - torch.save(self.model.state_dict(), self.path+'/' + self.name + '_final.pt') + torch.save( + self.model.state_dict(), self.path + "/" + self.name + "_final.pt" + ) class PlotterCallback(Callback): - '''Object for plotting (logging plots) inside of tensorboard. + """Object for plotting (logging plots) inside of tensorboard. Can be passed to the pytorch lightning trainer. Parameters ---------- plot_function : callable - A function that specfices the part of the model that should be plotted. + A function that specfices the part of the model that should be plotted. point_sampler : torchphysics.samplers.PlotSampler A sampler that creates the points that should be used for the plot. log_interval : str, optional @@ -79,12 +97,22 @@ class PlotterCallback(Callback): Additional arguments to specify different parameters/behaviour of the plot. See https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.html for possible arguments of each underlying object. - ''' - def __init__(self, model, plot_function, point_sampler, log_name='plot', - check_interval=200, angle=[30, 30], plot_type='', **kwargs): + """ + + def __init__( + self, + model, + plot_function, + point_sampler, + log_name="plot", + check_interval=200, + angle=[30, 30], + plot_type="", + **kwargs + ): super().__init__() self.model = model - self.check_interval=check_interval + self.check_interval = check_interval self.plot_function = UserFunction(plot_function) self.log_name = log_name self.point_sampler = point_sampler @@ -94,17 +122,23 @@ def __init__(self, model, plot_function, point_sampler, log_name='plot', def on_train_start(self, trainer, pl_module): self.point_sampler.sample_points(device=pl_module.device) - - def on_train_batch_end(self, trainer, pl_module, outputs, batch, - batch_idx, dataloader_idx): + + def on_train_batch_end( + self, trainer, pl_module, outputs, batch, batch_idx, dataloader_idx + ): if batch_idx % self.check_interval == 0: - fig = plot(model=self.model, plot_function=self.plot_function, - point_sampler=self.point_sampler, - angle=self.angle, plot_type=self.plot_type, - device=pl_module.device, **self.kwargs) - pl_module.logger.experiment.add_figure(tag=self.log_name, - figure=fig, - global_step=batch_idx) + fig = plot( + model=self.model, + plot_function=self.plot_function, + point_sampler=self.point_sampler, + angle=self.angle, + plot_type=self.plot_type, + device=pl_module.device, + **self.kwargs + ) + pl_module.logger.experiment.add_figure( + tag=self.log_name, figure=fig, global_step=batch_idx + ) def on_train_end(self, trainer, pl_module): return @@ -131,21 +165,24 @@ class TrainerStateCheckpoint(Callback): To continue from the checkpoint, use `resume_from_checkpoint ="path_to_ckpt_file"` as an argument in the initialization of the trainer. - The PyTorch Lightning checkpoint would save the current epoch and restart from it. + The PyTorch Lightning checkpoint would save the current epoch and restart from it. In TorchPhysics we dont use multiple epochs, instead we train with multiple iterations inside "one giant epoch". If the training is restarted, the trainer will always start from iteration 0 (essentially the last completed epoch). But all other states (model, optimizer, ...) will be correctly restored. """ - def __init__(self, path, name, check_interval=200, weights_only = False): + + def __init__(self, path, name, check_interval=200, weights_only=False): super().__init__() self.path = path self.name = name self.check_interval = check_interval self.weights_only = weights_only - - def on_train_batch_end(self, trainer, pl_module, outputs, batch, batch_idx, dataloader_idx): + def on_train_batch_end( + self, trainer, pl_module, outputs, batch, batch_idx, dataloader_idx + ): if batch_idx % self.check_interval == 0: - trainer.save_checkpoint(self.path + '/' + self.name + ".ckpt", - weights_only=self.weights_only) + trainer.save_checkpoint( + self.path + "/" + self.name + ".ckpt", weights_only=self.weights_only + ) diff --git a/src/torchphysics/utils/data/__init__.py b/src/torchphysics/utils/data/__init__.py index 695e32e7..f6b81ab9 100644 --- a/src/torchphysics/utils/data/__init__.py +++ b/src/torchphysics/utils/data/__init__.py @@ -1,2 +1,2 @@ from .dataloader import PointsDataset, PointsDataLoader -from .deeponet_dataloader import DeepONetDataLoader \ No newline at end of file +from .deeponet_dataloader import DeepONetDataLoader diff --git a/src/torchphysics/utils/data/dataloader.py b/src/torchphysics/utils/data/dataloader.py index 9bca3327..02241656 100644 --- a/src/torchphysics/utils/data/dataloader.py +++ b/src/torchphysics/utils/data/dataloader.py @@ -3,6 +3,7 @@ from ...problem.spaces import Points + class PointsDataset(torch.utils.data.Dataset): """ A PyTorch Dataset to load tuples of data points. @@ -20,6 +21,7 @@ class PointsDataset(torch.utils.data.Dataset): drop_last : bool Whether to drop the last (and non-batch-size-) minibatch. """ + def __init__(self, data_points, batch_size, shuffle=False, drop_last=False): if isinstance(data_points, Points): self.data_points = [data_points] @@ -33,10 +35,9 @@ def __init__(self, data_points, batch_size, shuffle=False, drop_last=False): self.batch_size = batch_size self.drop_last = drop_last - + def __len__(self): - """Returns the number of points of this dataset. - """ + """Returns the number of points of this dataset.""" if self.drop_last: return len(self.data_points[0]) // self.batch_size else: @@ -53,9 +54,12 @@ def __getitem__(self, idx): l = len(self.data_points[0]) out = [] for points in self.data_points: - out.append(points[idx*self.batch_size:min((idx+1)*self.batch_size, l), :]) + out.append( + points[idx * self.batch_size : min((idx + 1) * self.batch_size, l), :] + ) return tuple(out) + class PointsDataLoader(torch.utils.data.DataLoader): """ A DataLoader that can be used in a condition to load minibatches of paired data @@ -78,12 +82,22 @@ class PointsDataLoader(torch.utils.data.DataLoader): drop_last : bool Whether to drop the last (and non-batch-size-) minibatch. """ - def __init__(self, data_points, batch_size, shuffle=False, - num_workers=0, pin_memory=False, drop_last=False): - super().__init__(PointsDataset(data_points, batch_size, - shuffle=shuffle, drop_last=drop_last), - batch_size=None, - shuffle=False, - num_workers=num_workers, - pin_memory=pin_memory) + def __init__( + self, + data_points, + batch_size, + shuffle=False, + num_workers=0, + pin_memory=False, + drop_last=False, + ): + super().__init__( + PointsDataset( + data_points, batch_size, shuffle=shuffle, drop_last=drop_last + ), + batch_size=None, + shuffle=False, + num_workers=num_workers, + pin_memory=pin_memory, + ) diff --git a/src/torchphysics/utils/data/deeponet_dataloader.py b/src/torchphysics/utils/data/deeponet_dataloader.py index 15de15f5..d839c463 100644 --- a/src/torchphysics/utils/data/deeponet_dataloader.py +++ b/src/torchphysics/utils/data/deeponet_dataloader.py @@ -4,7 +4,6 @@ from ...problem.spaces import Points - class DeepONetDataLoader(torch.utils.data.DataLoader): """ A DataLoader that can be used in a condition to load minibatches of paired data @@ -16,29 +15,29 @@ class DeepONetDataLoader(torch.utils.data.DataLoader): A tensor containing the input data for the branch network. Has to be of the shape: [number_of_functions, discrete_points_of_branch_net, function_space_dim] For example, if we have a batch of 20 vector-functions (:math:`f:\R \to \R^2`) and - use 100 discrete points for the evaluation (where the branch nets evaluates f), - the shape would be: [20, 100, 2] + use 100 discrete points for the evaluation (where the branch nets evaluates f), + the shape would be: [20, 100, 2] trunk_data : torch.tensor A tensor containing the input data for the trunk network. There are two different possibilites for the shape of this data: 1) Every branch input function uses the same trunk values, then we can pass in the shape: [number_of_trunk_points, input_dim_of_trunk_net] This can speed up the trainings process. - 2) Or every branch function has different values for the trunk net, then we - need the shape: + 2) Or every branch function has different values for the trunk net, then we + need the shape: [number_of_functions, number_of_trunk_points, input_dim_of_trunk_net] If this is the case, remember to set 'trunk_input_copied = false' inside the trunk net, to get the right trainings process. output_data : torch.tensor - A tensor containing the expected output of the network. Shape of the - data should be: + A tensor containing the expected output of the network. Shape of the + data should be: [number_of_functions, number_of_trunk_points, output_dim]. branch_space : torchphysics.spaces.Space The output space of the functions, that are used as the branch input. trunk_space : torchphysics.spaces.Space The input space of the trunk network. output_space : torchphysics.spaces.Space - The output space in which the solution is. + The output space in which the solution is. branch_batch_size, trunk_batch_size : int The size of the loaded batches for trunk and branch. shuffle_branch : bool @@ -50,66 +49,111 @@ class DeepONetDataLoader(torch.utils.data.DataLoader): pin_memory : bool Whether to use pinned memory during data loading, see also: the PyTorch documentation """ - def __init__(self, branch_data, trunk_data, output_data, branch_space, - trunk_space, output_space, branch_batch_size, trunk_batch_size, - shuffle_branch=False, shuffle_trunk=True, num_workers=0, - pin_memory=False): + + def __init__( + self, + branch_data, + trunk_data, + output_data, + branch_space, + trunk_space, + output_space, + branch_batch_size, + trunk_batch_size, + shuffle_branch=False, + shuffle_trunk=True, + num_workers=0, + pin_memory=False, + ): assert len(branch_data.shape) == 3, "Branch data has the wrong shape" - assert branch_data.shape[-1] == branch_space.dim , \ - "Branch data dimension is not correct, is " + str(branch_data.shape[-1]) + " but expected " + str(branch_space.dim) - assert trunk_data.shape[-1] == trunk_space.dim, \ - "Trunk data dimension is not correct, is " + str(trunk_data.shape[-1]) + " but expected " + str(trunk_space.dim) - assert output_data.shape[-1] == output_space.dim, \ - "Solution data dimension is not correct, is " + str(output_data.shape[-1]) + " but expected " + str(output_space.dim) + assert branch_data.shape[-1] == branch_space.dim, ( + "Branch data dimension is not correct, is " + + str(branch_data.shape[-1]) + + " but expected " + + str(branch_space.dim) + ) + assert trunk_data.shape[-1] == trunk_space.dim, ( + "Trunk data dimension is not correct, is " + + str(trunk_data.shape[-1]) + + " but expected " + + str(trunk_space.dim) + ) + assert output_data.shape[-1] == output_space.dim, ( + "Solution data dimension is not correct, is " + + str(output_data.shape[-1]) + + " but expected " + + str(output_space.dim) + ) if len(trunk_data.shape) == 3: - super().__init__(DeepONetDataset_Unique(branch_data, - trunk_data, - output_data, - branch_space, - trunk_space, - output_space, - branch_batch_size, - trunk_batch_size, - shuffle_branch, - shuffle_trunk), - batch_size=None, - shuffle=False, - num_workers=num_workers, - pin_memory=pin_memory) + super().__init__( + DeepONetDataset_Unique( + branch_data, + trunk_data, + output_data, + branch_space, + trunk_space, + output_space, + branch_batch_size, + trunk_batch_size, + shuffle_branch, + shuffle_trunk, + ), + batch_size=None, + shuffle=False, + num_workers=num_workers, + pin_memory=pin_memory, + ) else: - super().__init__(DeepONetDataset(branch_data, - trunk_data, - output_data, - branch_space, - trunk_space, - output_space, - branch_batch_size, - trunk_batch_size, - shuffle_branch, - shuffle_trunk), - batch_size=None, - shuffle=False, - num_workers=num_workers, - pin_memory=pin_memory) + super().__init__( + DeepONetDataset( + branch_data, + trunk_data, + output_data, + branch_space, + trunk_space, + output_space, + branch_batch_size, + trunk_batch_size, + shuffle_branch, + shuffle_trunk, + ), + batch_size=None, + shuffle=False, + num_workers=num_workers, + pin_memory=pin_memory, + ) class DeepONetDataset_Unique(torch.utils.data.Dataset): """ A PyTorch Dataset to load tuples of data points, used in the DeepONetDataLoader. - Is used when every branch input has unique trunk inputs + Is used when every branch input has unique trunk inputs -> Ordering of points is important. """ - def __init__(self, branch_data_points, trunk_data_points, out_data_points, - branch_space, trunk_space, output_space, - branch_batch_size, trunk_batch_size, shuffle_branch=False, - shuffle_trunk=True): - assert out_data_points.shape[0] == branch_data_points.shape[0], \ - "Output values and branch inputs don't match!" - assert trunk_data_points.shape[0] == branch_data_points.shape[0], \ - "Trunk and branch batch does not match!" - assert out_data_points.shape[1] == trunk_data_points.shape[1], \ - "Output values and trunk inputs don't match!" + def __init__( + self, + branch_data_points, + trunk_data_points, + out_data_points, + branch_space, + trunk_space, + output_space, + branch_batch_size, + trunk_batch_size, + shuffle_branch=False, + shuffle_trunk=True, + ): + + assert ( + out_data_points.shape[0] == branch_data_points.shape[0] + ), "Output values and branch inputs don't match!" + assert ( + trunk_data_points.shape[0] == branch_data_points.shape[0] + ), "Trunk and branch batch does not match!" + assert ( + out_data_points.shape[1] == trunk_data_points.shape[1] + ), "Output values and trunk inputs don't match!" self.trunk_data_points = trunk_data_points self.branch_data_points = branch_data_points @@ -125,23 +169,34 @@ def __init__(self, branch_data_points, trunk_data_points, out_data_points, self.out_data_points = self.out_data_points[branch_perm] self.trunk_data_points = self.trunk_data_points[branch_perm] - self.trunk_batch_size = len(self.trunk_data_points[0]) if trunk_batch_size < 0 else trunk_batch_size - self.branch_batch_size = len(self.branch_data_points) if branch_batch_size < 0 else branch_batch_size + self.trunk_batch_size = ( + len(self.trunk_data_points[0]) if trunk_batch_size < 0 else trunk_batch_size + ) + self.branch_batch_size = ( + len(self.branch_data_points) if branch_batch_size < 0 else branch_batch_size + ) self.branch_space = branch_space self.trunk_space = trunk_space self.output_space = output_space - # for index computation in __getitem__ - self.branch_batch_len = int(np.ceil(len(self.branch_data_points) / self.branch_batch_size)) - self.trunk_batch_len = int(np.ceil(len(self.trunk_data_points[0]) / self.trunk_batch_size)) - + # for index computation in __getitem__ + self.branch_batch_len = int( + np.ceil(len(self.branch_data_points) / self.branch_batch_size) + ) + self.trunk_batch_len = int( + np.ceil(len(self.trunk_data_points[0]) / self.trunk_batch_size) + ) + def __len__(self): - """Returns the number of points of this dataset. - """ - # here we recompute, for the case when the batch size changed - self.branch_batch_len = int(np.ceil(len(self.branch_data_points) / self.branch_batch_size)) - self.trunk_batch_len = int(np.ceil(len(self.trunk_data_points[0]) / self.trunk_batch_size)) + """Returns the number of points of this dataset.""" + # here we recompute, for the case when the batch size changed + self.branch_batch_len = int( + np.ceil(len(self.branch_data_points) / self.branch_batch_size) + ) + self.trunk_batch_len = int( + np.ceil(len(self.trunk_data_points[0]) / self.trunk_batch_size) + ) return self.branch_batch_len * self.trunk_batch_len def __getitem__(self, idx): @@ -154,29 +209,39 @@ def __getitem__(self, idx): """ # frist slice in branch dimension (dim 0): branch_idx = int(idx / self.branch_batch_len) - a = (branch_idx*self.branch_batch_size) % len(self.branch_data_points) - b = ((branch_idx+1)*self.branch_batch_size) % len(self.branch_data_points) + a = (branch_idx * self.branch_batch_size) % len(self.branch_data_points) + b = ((branch_idx + 1) * self.branch_batch_size) % len(self.branch_data_points) if a < b: branch_points = self.branch_data_points[a:b] out_points = self.out_data_points[a:b] trunk_points = self.trunk_data_points[a:b] else: - branch_points = torch.cat([self.branch_data_points[a:], self.branch_data_points[:b]], dim=0) - out_points = torch.cat([self.out_data_points[a:], self.out_data_points[:b]], dim=0) - trunk_points = torch.cat([self.trunk_data_points[a:], self.trunk_data_points[:b]], dim=0) + branch_points = torch.cat( + [self.branch_data_points[a:], self.branch_data_points[:b]], dim=0 + ) + out_points = torch.cat( + [self.out_data_points[a:], self.out_data_points[:b]], dim=0 + ) + trunk_points = torch.cat( + [self.trunk_data_points[a:], self.trunk_data_points[:b]], dim=0 + ) # then in trunk dimension (dim 1), only for trunk and output: trunk_idx = idx % self.trunk_batch_len - a = (trunk_idx*self.trunk_batch_size) % len(self.trunk_data_points[0]) - b = ((trunk_idx+1)*self.trunk_batch_size) % len(self.trunk_data_points[0]) + a = (trunk_idx * self.trunk_batch_size) % len(self.trunk_data_points[0]) + b = ((trunk_idx + 1) * self.trunk_batch_size) % len(self.trunk_data_points[0]) if a < b: out_points = out_points[:, a:b, :] trunk_points = trunk_points[:, a:b, :] else: out_points = torch.cat([out_points[:, a:, :], out_points[:, :b, :]], dim=1) - trunk_points = torch.cat([trunk_points[:, a:, :], trunk_points[:, :b, :]], dim=1) - return (Points(branch_points, self.branch_space), - Points(trunk_points, self.trunk_space), - Points(out_points, self.output_space)) + trunk_points = torch.cat( + [trunk_points[:, a:, :], trunk_points[:, :b, :]], dim=1 + ) + return ( + Points(branch_points, self.branch_space), + Points(trunk_points, self.trunk_space), + Points(out_points, self.output_space), + ) class DeepONetDataset(torch.utils.data.Dataset): @@ -184,15 +249,27 @@ class DeepONetDataset(torch.utils.data.Dataset): A PyTorch Dataset to load tuples of data points, used via DeepONetDataLoader. Used if all branch inputs have the same trunk points. """ - def __init__(self, branch_data_points, trunk_data_points, out_data_points, - branch_space, trunk_space, output_space, - branch_batch_size, trunk_batch_size, shuffle_branch=False, - shuffle_trunk=True): - assert out_data_points.shape[0] == branch_data_points.shape[0], \ - "Output values and branch inputs don't match!" - assert out_data_points.shape[1] == trunk_data_points.shape[0], \ - "Output values and trunk inputs don't match!" + def __init__( + self, + branch_data_points, + trunk_data_points, + out_data_points, + branch_space, + trunk_space, + output_space, + branch_batch_size, + trunk_batch_size, + shuffle_branch=False, + shuffle_trunk=True, + ): + + assert ( + out_data_points.shape[0] == branch_data_points.shape[0] + ), "Output values and branch inputs don't match!" + assert ( + out_data_points.shape[1] == trunk_data_points.shape[0] + ), "Output values and trunk inputs don't match!" self.trunk_data_points = trunk_data_points self.branch_data_points = branch_data_points @@ -207,25 +284,37 @@ def __init__(self, branch_data_points, trunk_data_points, out_data_points, self.branch_data_points = self.branch_data_points[branch_perm] self.out_data_points = self.out_data_points[branch_perm, :] - self.trunk_batch_size = len(self.trunk_data_points) if trunk_batch_size < 0 else trunk_batch_size - self.branch_batch_size = len(self.branch_data_points) if branch_batch_size < 0 else branch_batch_size + self.trunk_batch_size = ( + len(self.trunk_data_points) if trunk_batch_size < 0 else trunk_batch_size + ) + self.branch_batch_size = ( + len(self.branch_data_points) if branch_batch_size < 0 else branch_batch_size + ) self.branch_space = branch_space self.trunk_space = trunk_space self.output_space = output_space - + def __len__(self): - """Returns the number of points of this dataset. - """ + """Returns the number of points of this dataset.""" # the least common multiple of both possible length will lead to the correct distribution # of data points and hopefully managable effort - return int(np.lcm( - int(np.lcm(len(self.branch_data_points), self.branch_batch_size) / self.branch_batch_size), - int(np.lcm(len(self.trunk_data_points), self.trunk_batch_size) / self.trunk_batch_size))) + return int( + np.lcm( + int( + np.lcm(len(self.branch_data_points), self.branch_batch_size) + / self.branch_batch_size + ), + int( + np.lcm(len(self.trunk_data_points), self.trunk_batch_size) + / self.trunk_batch_size + ), + ) + ) def _slice_points(self, points, out_points, out_axis, batch_size, idx): - a = (idx*batch_size) % len(points) - b = ((idx+1)*batch_size) % len(points) + a = (idx * batch_size) % len(points) + b = ((idx + 1) * batch_size) % len(points) if a < b: points = points[a:b] if out_axis == 0: @@ -237,9 +326,9 @@ def _slice_points(self, points, out_points, out_axis, batch_size, idx): else: points = torch.cat([points[a:], points[:b]], dim=0) if out_axis == 0: - out_points = torch.cat([out_points[a:,:], out_points[:b,:]], dim=0) + out_points = torch.cat([out_points[a:, :], out_points[:b, :]], dim=0) elif out_axis == 1: - out_points = torch.cat([out_points[:,a:], out_points[:,:b]], dim=1) + out_points = torch.cat([out_points[:, a:], out_points[:, :b]], dim=1) else: raise ValueError return points, out_points @@ -252,16 +341,18 @@ def __getitem__(self, idx): idx : int The index of the desired point. """ - branch_points, out_points = self._slice_points(self.branch_data_points, - self.out_data_points, - 0, - self.branch_batch_size, - idx) - trunk_points, out_points = self._slice_points(self.trunk_data_points, - out_points, - 1, - self.trunk_batch_size, - idx) - return (Points(branch_points, self.branch_space), - Points(trunk_points, self.trunk_space), - Points(out_points, self.output_space)) \ No newline at end of file + branch_points, out_points = self._slice_points( + self.branch_data_points, + self.out_data_points, + 0, + self.branch_batch_size, + idx, + ) + trunk_points, out_points = self._slice_points( + self.trunk_data_points, out_points, 1, self.trunk_batch_size, idx + ) + return ( + Points(branch_points, self.branch_space), + Points(trunk_points, self.trunk_space), + Points(out_points, self.output_space), + ) diff --git a/src/torchphysics/utils/differentialoperators.py b/src/torchphysics/utils/differentialoperators.py index 3ac1879f..588e43a8 100644 --- a/src/torchphysics/utils/differentialoperators.py +++ b/src/torchphysics/utils/differentialoperators.py @@ -1,14 +1,15 @@ -'''File contains differentialoperators +"""File contains differentialoperators NOTE: We aim to make the computation of differential operaotrs more efficient by building an intelligent framework that is able to keep already computed derivatives and therefore make the computations more efficient. -''' +""" + import torch def laplacian(model_out, *derivative_variable, grad=None): - '''Computes the laplacian of a network with respect to the given variable + """Computes the laplacian of a network with respect to the given variable Parameters ---------- @@ -26,9 +27,8 @@ def laplacian(model_out, *derivative_variable, grad=None): torch.tensor A Tensor, where every row contains the value of the sum of the second derivatives (laplace) w.r.t the row of the input variable. - ''' - laplacian = torch.zeros((*model_out.shape[:-1], 1), - device=model_out.device) + """ + laplacian = torch.zeros((*model_out.shape[:-1], 1), device=model_out.device) for vari in derivative_variable: if grad is None or len(derivative_variable) > 1: grad = torch.autograd.grad(model_out.sum(), vari, create_graph=True)[0] @@ -37,14 +37,15 @@ def laplacian(model_out, *derivative_variable, grad=None): if grad.grad_fn is None: continue for i in range(vari.shape[-1]): - D2u = torch.autograd.grad(grad.narrow(-1, i, 1).sum(), - vari, create_graph=True)[0] + D2u = torch.autograd.grad( + grad.narrow(-1, i, 1).sum(), vari, create_graph=True + )[0] laplacian += D2u.narrow(-1, i, 1) return laplacian def grad(model_out, *derivative_variable): - '''Computes the gradient of a network with respect to the given variable. + """Computes the gradient of a network with respect to the given variable. Parameters ---------- model_out : torch.tensor @@ -57,14 +58,14 @@ def grad(model_out, *derivative_variable): torch.tensor A Tensor, where every row contains the values of the the first derivatives (gradient) w.r.t the row of the input variable. - ''' + """ grad = [] for vari in derivative_variable: - new_grad = torch.autograd.grad(model_out.sum(), vari, - create_graph=True)[0] + new_grad = torch.autograd.grad(model_out.sum(), vari, create_graph=True)[0] grad.append(new_grad) return torch.column_stack(grad) + """ def grad(model_out, *derivative_variable): '''Computes the gradient of a network with respect to the given variable. @@ -106,8 +107,9 @@ def grad(model_out, *derivative_variable): return torch.cat(grad, dim=-1) """ + def normal_derivative(model_out, normals, *derivative_variable): - '''Computes the normal derivativ of a network with respect to the given variable + """Computes the normal derivativ of a network with respect to the given variable and normal vectors. Parameters @@ -126,14 +128,14 @@ def normal_derivative(model_out, normals, *derivative_variable): torch.tensor A Tensor, where every row contains the values of the normal derivatives w.r.t the row of the input variable. - ''' + """ gradient = grad(model_out, *derivative_variable) - normal_derivatives = gradient*normals + normal_derivatives = gradient * normals return normal_derivatives.sum(dim=-1, keepdim=True) def div(model_out, *derivative_variable): - '''Computes the divergence of a network with respect to the given variable. + """Computes the divergence of a network with respect to the given variable. Only for vector valued inputs, for matices use the function matrix_div. Parameters ---------- @@ -148,18 +150,21 @@ def div(model_out, *derivative_variable): torch.tensor A Tensor, where every row contains the values of the divergence of the model w.r.t the row of the input variable. - ''' - divergence = torch.zeros((*derivative_variable[0].shape[:-1], 1), - device=derivative_variable[0].device) + """ + divergence = torch.zeros( + (*derivative_variable[0].shape[:-1], 1), device=derivative_variable[0].device + ) var_dim = 0 for vari in derivative_variable: for i in range(vari.shape[-1]): - Du = torch.autograd.grad(model_out.narrow(-1, var_dim + i, 1).sum(), - vari, create_graph=True)[0] + Du = torch.autograd.grad( + model_out.narrow(-1, var_dim + i, 1).sum(), vari, create_graph=True + )[0] divergence = divergence + Du.narrow(-1, i, 1) var_dim += i + 1 return divergence + """ def div(model_out, *derivative_variable): '''Computes the divergence of a network with respect to the given variable. @@ -224,8 +229,9 @@ def div(model_out, *derivative_variable): return divergence """ + def jac(model_out, *derivative_variable): - '''Computes the jacobian of a network output with + """Computes the jacobian of a network output with respect to the given input. Parameters @@ -239,20 +245,21 @@ def jac(model_out, *derivative_variable): ---------- torch.tensor A Tensor of shape (b, m, n), where every row contains a jacobian. - ''' + """ Du_rows = [] for i in range(model_out.shape[1]): Du_i = [] for vari in derivative_variable: - Du_i.append(torch.autograd.grad(model_out[:, i].sum(), - vari, create_graph=True)[0]) + Du_i.append( + torch.autograd.grad(model_out[:, i].sum(), vari, create_graph=True)[0] + ) Du_rows.append(torch.cat(Du_i, dim=1)) Du = torch.stack(Du_rows, dim=1) return Du def rot(model_out, *derivative_variable): - '''Computes the rotation/curl of a 3-dimensional vector field (given by a + """Computes the rotation/curl of a 3-dimensional vector field (given by a network output) with respect to the given input. Parameters @@ -269,7 +276,7 @@ def rot(model_out, *derivative_variable): torch.tensor A Tensor of shape (b, 3), where every row contains a rotation/curl vector for a given batch element. - ''' + """ """ assert model_out.shape[1] == 3 and derivative_variable.shape[1] == 3, "" Rotation: the given in- and output should both be batches of @@ -285,7 +292,7 @@ def rot(model_out, *derivative_variable): def partial(model_out, *derivative_variables): - '''Computes the (n-th, possibly mixed) partial derivative of a network output with + """Computes the (n-th, possibly mixed) partial derivative of a network output with respect to the given variables. Parameters @@ -301,19 +308,17 @@ def partial(model_out, *derivative_variables): torch.tensor A Tensor, where every row contains the values of the computed partial derivative of the model w.r.t the row of the input variable. - ''' + """ du = model_out for inp in derivative_variables: if du.grad_fn is None: return torch.zeros_like(inp) - du = torch.autograd.grad(du.sum(), - inp, - create_graph=True)[0] + du = torch.autograd.grad(du.sum(), inp, create_graph=True)[0] return du def convective(deriv_out, convective_field, *derivative_variable): - '''Computes the convective term :math:`(v \\cdot \\nabla)u` that appears e.g. in + """Computes the convective term :math:`(v \\cdot \\nabla)u` that appears e.g. in material derivatives. Note: This is not the whole material derivative. Parameters @@ -332,7 +337,7 @@ def convective(deriv_out, convective_field, *derivative_variable): torch.tensor A vector or scalar (+batch-dimension) Tensor, that contains the convective derivative. - ''' + """ jac_x = jac(deriv_out, *derivative_variable) return torch.bmm(jac_x, convective_field.unsqueeze(dim=2)).squeeze(dim=2) @@ -373,11 +378,10 @@ def matrix_div(model_out, *derivative_variable): A Tensor of vectors of the form (batch, dim), containing the divegrence of the input. """ - div_out = torch.zeros((len(model_out), model_out.shape[1]), - device=model_out.device) + div_out = torch.zeros((len(model_out), model_out.shape[1]), device=model_out.device) for i in range(model_out.shape[1]): # compute divergence of matrix by computing the divergence # for each row current_row = model_out.narrow(1, i, 1).squeeze(1) - div_out[:, i:i+1] = div(current_row, *derivative_variable) + div_out[:, i : i + 1] = div(current_row, *derivative_variable) return div_out diff --git a/src/torchphysics/utils/evaluation.py b/src/torchphysics/utils/evaluation.py index c945afca..c6fd4256 100644 --- a/src/torchphysics/utils/evaluation.py +++ b/src/torchphysics/utils/evaluation.py @@ -1,6 +1,7 @@ -'''File contains different helper functions to get specific informations about +"""File contains different helper functions to get specific informations about the computed solution. -''' +""" + import time import torch @@ -8,9 +9,10 @@ from ..problem.spaces import Points -def compute_min_and_max(model, sampler, evaluation_fn=lambda u:u, - device='cpu', requieres_grad=False): - '''Computes the minimum and maximum values of the model w.r.t. the given +def compute_min_and_max( + model, sampler, evaluation_fn=lambda u: u, device="cpu", requieres_grad=False +): + """Computes the minimum and maximum values of the model w.r.t. the given variables. Parameters @@ -20,21 +22,21 @@ def compute_min_and_max(model, sampler, evaluation_fn=lambda u:u, sampler : torchphysics.samplers.PointSampler A sampler that creates the points where the model should be evaluated. evaluation_fn : callable - A user-defined function that uses the neural network and creates the + A user-defined function that uses the neural network and creates the desiered output quantity. device : str or torch device - The device of the model. + The device of the model. track_gradients : bool - Whether to track input gradients or not. + Whether to track input gradients or not. Returns ------- float The minimum value computed. - float + float The maximum value computed. - ''' - print('-- Start evaluation of minimum and maximum --') + """ + print("-- Start evaluation of minimum and maximum --") input_points = next(sampler) input_points._t.requires_grad = requieres_grad input_points._t.to(device) @@ -47,13 +49,13 @@ def compute_min_and_max(model, sampler, evaluation_fn=lambda u:u, evaluation_fn = UserFunction(evaluation_fn) data_dict = {**model_out.coordinates, **inp_points_dict} start_func_eval = time.time() - prediction = evaluation_fn(data_dict) + prediction = evaluation_fn(data_dict) end_func_eval = time.time() max_pred = torch.max(prediction) min_pred = torch.min(prediction) - print('Time to evaluate model:', end_model_eval - start_model_eval) - print('Time to evaluate User-Function:', end_func_eval - start_func_eval) - print('Found the values') - print('Min:', min_pred) - print('Max:', max_pred) + print("Time to evaluate model:", end_model_eval - start_model_eval) + print("Time to evaluate User-Function:", end_func_eval - start_func_eval) + print("Found the values") + print("Min:", min_pred) + print("Max:", max_pred) return min_pred, max_pred diff --git a/src/torchphysics/utils/plotting/__init__.py b/src/torchphysics/utils/plotting/__init__.py index db1dfd40..83edd7bb 100644 --- a/src/torchphysics/utils/plotting/__init__.py +++ b/src/torchphysics/utils/plotting/__init__.py @@ -9,4 +9,4 @@ from .plot_functions import plot from .animation import animate -from .scatter_points import scatter \ No newline at end of file +from .scatter_points import scatter diff --git a/src/torchphysics/utils/plotting/animation.py b/src/torchphysics/utils/plotting/animation.py index e0698165..f6fc9a03 100644 --- a/src/torchphysics/utils/plotting/animation.py +++ b/src/torchphysics/utils/plotting/animation.py @@ -1,6 +1,7 @@ -'''This file contains different functions for animating the output of +"""This file contains different functions for animating the output of the neural network -''' +""" + import matplotlib.pyplot as plt import matplotlib.tri as plt_tri from matplotlib import cm, colors @@ -8,16 +9,21 @@ import numpy as np import torch -from .plot_functions import (_compute_output_shape, _create_info_text, - _create_figure_and_axis, _triangulation_of_domain) +from .plot_functions import ( + _compute_output_shape, + _create_info_text, + _create_figure_and_axis, + _triangulation_of_domain, +) from ...problem.spaces import Points from ..user_fun import UserFunction -def animate(model, ani_function, ani_sampler, ani_speed=50, angle=[30, 30], - ani_type=''): - '''Main function for animations. - +def animate( + model, ani_function, ani_sampler, ani_speed=50, angle=[30, 30], ani_type="" +): + """Main function for animations. + Parameters ---------- model : torchphysics.models.Model @@ -41,53 +47,61 @@ def animate(model, ani_function, ani_sampler, ani_speed=50, angle=[30, 30], Returns ------- plt.figure - The figure handle of the created plot + The figure handle of the created plot animation.FuncAnimation - The function that handles the animation + The function that handles the animation Notes ----- This methode only creates a simple animation and is for complex domains not really optimized. Should only be used to get a rough understanding of the trained neural network. - ''' + """ ani_function = UserFunction(fun=ani_function) - animation_points, domain_points, outputs, out_shape = \ - _create_animation_data(model, ani_function, ani_sampler) + animation_points, domain_points, outputs, out_shape = _create_animation_data( + model, ani_function, ani_sampler + ) ani_fun = _find_ani_function(ani_sampler, ani_type, out_shape) if ani_fun is not None: - return ani_fun(outputs=outputs, ani_sampler=ani_sampler, - animation_points=animation_points, - domain_points=domain_points, - angle=angle, ani_speed=ani_speed) + return ani_fun( + outputs=outputs, + ani_sampler=ani_sampler, + animation_points=animation_points, + domain_points=domain_points, + angle=angle, + ani_speed=ani_speed, + ) else: - raise NotImplementedError(f"""Animations for a {out_shape} + raise NotImplementedError( + f"""Animations for a {out_shape} dimensional output are not implemented!' - Please specify the output to animate.""") + Please specify the output to animate.""" + ) def _create_animation_data(model, ani_function, ani_sampler): # first create the plot points and evaluate the model animation_points = ani_sampler.sample_animation_points() domain_points = ani_sampler.sample_plot_domain_points(animation_points) - return _construct_points_and_evaluate_model(animation_points, domain_points, - model, ani_function, ani_sampler) + return _construct_points_and_evaluate_model( + animation_points, domain_points, model, ani_function, ani_sampler + ) -def _construct_points_and_evaluate_model(animation_points, domain_points, - model, ani_function, ani_sampler): +def _construct_points_and_evaluate_model( + animation_points, domain_points, model, ani_function, ani_sampler +): outputs = [] n = len(domain_points) # for each frame evaluate the model for i in range(ani_sampler.frame_number): if ani_sampler.plot_domain_constant: domain_dict = domain_points.coordinates - else: + else: n = len(domain_points[i]) domain_dict = domain_points[i].coordinates - ith_point = animation_points[i, ].join(ani_sampler.data_for_other_variables) - repeated = Points(torch.repeat_interleave(ith_point, n, dim=0), - ith_point.space) + ith_point = animation_points[i,].join(ani_sampler.data_for_other_variables) + repeated = Points(torch.repeat_interleave(ith_point, n, dim=0), ith_point.space) current_points = {**domain_dict, **repeated.coordinates} output = _evaluate_animation_function(model, ani_function, current_points) outputs.append(output) @@ -107,13 +121,16 @@ def _evaluate_animation_function(model, ani_function, inp_point): def _find_ani_function(ani_sampler, ani_type, out_shape): # check if a animation type is specified - ani_types = {'line': animation_line, 'surface_2D': animation_surface2D, - 'quiver_2D': animation_quiver_2D, - 'contour_surface': animation_contour_2D} + ani_types = { + "line": animation_line, + "surface_2D": animation_surface2D, + "quiver_2D": animation_quiver_2D, + "contour_surface": animation_contour_2D, + } ani_fun = ani_types.get(ani_type) # check ourself if we can animated the input and output dimension if ani_fun is None: - # If only one output should be used we create a line/surface animation + # If only one output should be used we create a line/surface animation if out_shape == 1: ani_fun = _animation_for_one_output(ani_sampler.domain.dim) # If two outputs should be used we create a curve/quiver animation @@ -123,13 +140,13 @@ def _find_ani_function(ani_sampler, ani_type, out_shape): def _animation_for_one_output(domain_dim): - '''Handles animations if only one output of the model should be used. + """Handles animations if only one output of the model should be used. It will create a line or surface animation. - ''' + """ # 2D animation (surface plot) if domain_dim == 2: return animation_surface2D - # 1D animation (line plot): + # 1D animation (line plot): elif domain_dim == 1: return animation_line else: @@ -137,32 +154,42 @@ def _animation_for_one_output(domain_dim): def _animation_for_two_outputs(domain_dim): - '''Handles animations if two outputs of the model should be used. + """Handles animations if two outputs of the model should be used. It will create a curve or quiver animation. - ''' - # animate quiver plot + """ + # animate quiver plot if domain_dim == 2: return animation_quiver_2D else: raise NotImplementedError("""Can not animate 2D-output on given domain""") -def animation_line(outputs, ani_sampler, animation_points, domain_points, - angle, ani_speed): - '''Handels 1D animations, inputs are the same as animation(). - ''' - output_max, output_min, domain_bounds, _, domain_name = \ - _compute_animation_params(outputs, ani_sampler, animation_points) +def animation_line( + outputs, ani_sampler, animation_points, domain_points, angle, ani_speed +): + """Handels 1D animations, inputs are the same as animation().""" + output_max, output_min, domain_bounds, _, domain_name = _compute_animation_params( + outputs, ani_sampler, animation_points + ) # construct the figure handle and axis for the animation fig = plt.figure() domain_bounds = domain_bounds.detach() - ax = plt.axes(xlim=(domain_bounds[0], domain_bounds[1]), - ylim=(output_min, output_max)) + ax = plt.axes( + xlim=(domain_bounds[0], domain_bounds[1]), ylim=(output_min, output_max) + ) ax.set_xlabel(domain_name[0]) ax.grid() - line, = ax.plot([], [], lw=2) - text_box = ax.text(0.05,0.95, '', bbox={'facecolor': 'w', 'pad': 5}, - transform=ax.transAxes, va='top', ha='left') + (line,) = ax.plot([], [], lw=2) + text_box = ax.text( + 0.05, + 0.95, + "", + bbox={"facecolor": "w", "pad": 5}, + transform=ax.transAxes, + va="top", + ha="left", + ) + # create the animation def animate(frame_number, outputs, line): if ani_sampler.plot_domain_constant: @@ -170,22 +197,29 @@ def animate(frame_number, outputs, line): else: current_points = domain_points[frame_number].as_tensor # change line - line.set_data(current_points[:, 0].detach().cpu().numpy(), - outputs[frame_number].flatten()) + line.set_data( + current_points[:, 0].detach().cpu().numpy(), outputs[frame_number].flatten() + ) # change text-box data - _update_text_box(animation_points[frame_number, ], ani_sampler, text_box) - - ani = anim.FuncAnimation(fig, animate, frames=ani_sampler.frame_number, - fargs=(outputs, line), interval=ani_speed) + _update_text_box(animation_points[frame_number,], ani_sampler, text_box) + + ani = anim.FuncAnimation( + fig, + animate, + frames=ani_sampler.frame_number, + fargs=(outputs, line), + interval=ani_speed, + ) return fig, ani - - -def animation_surface2D(outputs, ani_sampler, animation_points, domain_points, - angle, ani_speed): - '''Handels 2D animations, inputs are the same as animation(). - ''' - output_max, output_min, domain_bounds, ani_key, domain_name = \ + + +def animation_surface2D( + outputs, ani_sampler, animation_points, domain_points, angle, ani_speed +): + """Handels 2D animations, inputs are the same as animation().""" + output_max, output_min, domain_bounds, ani_key, domain_name = ( _compute_animation_params(outputs, ani_sampler, animation_points) + ) # triangulate the domain once, if the it does not change triangulation = None if ani_sampler.plot_domain_constant: @@ -194,49 +228,77 @@ def animation_surface2D(outputs, ani_sampler, animation_points, domain_points, fig, ax = _create_figure_and_axis(angle) _set_x_y_axis_data(domain_bounds, ax, domain_name) ax.set_zlim((output_min, output_max)) - text_box = ax.text2D(1.1, 0, '', bbox={'facecolor':'w', 'pad':5}, - transform=ax.transAxes, va='top', ha='left') - - # construct an auxiliary plot to get a fixed colorbar for the animation - surf = [ax.plot_surface(np.zeros((2, 2)),np.zeros((2, 2)),np.zeros((2, 2)), - color='0.75', cmap=cm.jet, vmin=output_min, - vmax=output_max, antialiased=False)] - plt.colorbar(surf[0], shrink=0.5, aspect=10, pad=0.1) + text_box = ax.text2D( + 1.1, + 0, + "", + bbox={"facecolor": "w", "pad": 5}, + transform=ax.transAxes, + va="top", + ha="left", + ) + + # construct an auxiliary plot to get a fixed colorbar for the animation + surf = [ + ax.plot_surface( + np.zeros((2, 2)), + np.zeros((2, 2)), + np.zeros((2, 2)), + color="0.75", + cmap=cm.jet, + vmin=output_min, + vmax=output_max, + antialiased=False, + ) + ] + plt.colorbar(surf[0], shrink=0.5, aspect=10, pad=0.1) # create the animation def animate(frame_number, outputs, surf, triangulation): - surf[0].remove() # remove old surface - current_ani = animation_points[frame_number, ] + surf[0].remove() # remove old surface + current_ani = animation_points[frame_number,] # have to create a new triangulation, if the domain changes if not ani_sampler.plot_domain_constant: - triangulation = \ - _triangulate_for_animation(ani_sampler, domain_points[frame_number], - current_ani) - surf[0] = ax.plot_trisurf(triangulation, outputs[frame_number].flatten(), - color='0.75', cmap=cm.jet, - vmin=output_min, vmax=output_max, antialiased=False) + triangulation = _triangulate_for_animation( + ani_sampler, domain_points[frame_number], current_ani + ) + surf[0] = ax.plot_trisurf( + triangulation, + outputs[frame_number].flatten(), + color="0.75", + cmap=cm.jet, + vmin=output_min, + vmax=output_max, + antialiased=False, + ) _update_text_box(current_ani, ani_sampler, text_box) - ani = anim.FuncAnimation(fig, animate, frames=ani_sampler.frame_number, - fargs=(outputs, surf, triangulation), interval=ani_speed) + ani = anim.FuncAnimation( + fig, + animate, + frames=ani_sampler.frame_number, + fargs=(outputs, surf, triangulation), + interval=ani_speed, + ) return fig, ani -def animation_quiver_2D(outputs, ani_sampler, animation_points, domain_points, - angle, ani_speed): - '''Handles quiver animations in 2D - ''' +def animation_quiver_2D( + outputs, ani_sampler, animation_points, domain_points, angle, ani_speed +): + """Handles quiver animations in 2D""" if isinstance(domain_points, list): raise NotImplementedError("""Quiver plot for moving domain not implemented""") - _, _, domain_bounds, _, domain_names = \ - _compute_animation_params(outputs, ani_sampler, animation_points) + _, _, domain_bounds, _, domain_names = _compute_animation_params( + outputs, ani_sampler, animation_points + ) # for a consistent colors we compute the norm and scale the values # for the colors outputs = np.array(outputs) color = np.linalg.norm(outputs, axis=-1) j, _ = np.unravel_index(color.argmax(), color.shape) - #outputs /= max_norm + # outputs /= max_norm norm = colors.Normalize() norm.autoscale(color) # Create the plot @@ -244,75 +306,110 @@ def animation_quiver_2D(outputs, ani_sampler, animation_points, domain_points, ax = fig.add_subplot() ax.grid() _set_x_y_axis_data(domain_bounds, ax, domain_names) - text_box = ax.text(1.25, 0.5, '', bbox={'facecolor': 'w', 'pad': 5}, - transform=ax.transAxes) + text_box = ax.text( + 1.25, 0.5, "", bbox={"facecolor": "w", "pad": 5}, transform=ax.transAxes + ) # helper quiver plot to get a fixed colorbar and a constant scaling domain_points = domain_points.as_tensor.detach().cpu().numpy() - quiver = ax.quiver(domain_points[:, 0], domain_points[:, 1], - outputs[j][:, 0], outputs[j][:, 1], - color=cm.jet(norm(color[:, 0])), - scale=None, angles='xy', - units='xy', zorder=10) + quiver = ax.quiver( + domain_points[:, 0], + domain_points[:, 1], + outputs[j][:, 0], + outputs[j][:, 1], + color=cm.jet(norm(color[:, 0])), + scale=None, + angles="xy", + units="xy", + zorder=10, + ) sm = cm.ScalarMappable(cmap=cm.jet, norm=norm) - quiver._init() # to fix the arrow scale + quiver._init() # to fix the arrow scale plt.colorbar(sm, ax=ax) + # create the animation def animate(frame_number, outputs, quiver): # set new coords. of arrow head and color quiver.set_UVC(outputs[frame_number][:, 0], outputs[frame_number][:, 1]) quiver.set_color(cm.jet(norm(color[frame_number, :]))) # set new text - current_ani = animation_points[frame_number, ] + current_ani = animation_points[frame_number,] _update_text_box(current_ani, ani_sampler, text_box) - - ani = anim.FuncAnimation(fig, animate, frames=ani_sampler.frame_number, - fargs=(outputs, quiver), interval=ani_speed) + + ani = anim.FuncAnimation( + fig, + animate, + frames=ani_sampler.frame_number, + fargs=(outputs, quiver), + interval=ani_speed, + ) return fig, ani -def animation_contour_2D(outputs, ani_sampler, animation_points, domain_points, - angle, ani_speed): - '''Handles colormap animations in 2D - ''' - output_max, output_min, domain_bounds, ani_key, domain_names = \ +def animation_contour_2D( + outputs, ani_sampler, animation_points, domain_points, angle, ani_speed +): + """Handles colormap animations in 2D""" + output_max, output_min, domain_bounds, ani_key, domain_names = ( _compute_animation_params(outputs, ani_sampler, animation_points) + ) # Create the plot fig = plt.figure() ax = fig.add_subplot() ax.grid() _set_x_y_axis_data(domain_bounds, ax, domain_names) - text_box = ax.text(1.3, 0.5, '', bbox={'facecolor': 'w', 'pad': 5}, - transform=ax.transAxes) + text_box = ax.text( + 1.3, 0.5, "", bbox={"facecolor": "w", "pad": 5}, transform=ax.transAxes + ) # triangulate the domain once, if the it does not change triangulation = None if ani_sampler.plot_domain_constant: triangulation = _triangulate_for_animation(ani_sampler, domain_points) # helper plot for fixed colorbar - con = [ax.scatter([0, 0], [0, 1], c=[output_min, output_max], - vmin=output_min, vmax=output_max, cmap=cm.jet)] + con = [ + ax.scatter( + [0, 0], + [0, 1], + c=[output_min, output_max], + vmin=output_min, + vmax=output_max, + cmap=cm.jet, + ) + ] plt.colorbar(con[0]) con[0].remove() + # create the animation def animate(frame_number, outputs, con, triangulation): - current_ani = animation_points[frame_number, ] + current_ani = animation_points[frame_number,] # remove old contour if isinstance(con[0], plt_tri.TriContourSet): for tp in con[0].collections: tp.remove() # have to create a new triangulation, if the domain changes if not ani_sampler.plot_domain_constant: - triangulation = \ - _triangulate_for_animation(ani_sampler, domain_points[frame_number], - current_ani) + triangulation = _triangulate_for_animation( + ani_sampler, domain_points[frame_number], current_ani + ) # set new contour - con[0] = ax.tricontourf(triangulation, outputs[frame_number].flatten(), - 100, cmap=cm.jet, vmin=output_min, vmax=output_max) + con[0] = ax.tricontourf( + triangulation, + outputs[frame_number].flatten(), + 100, + cmap=cm.jet, + vmin=output_min, + vmax=output_max, + ) # get new point auf the animation variable and set text _update_text_box(current_ani, ani_sampler, text_box) - - ani = anim.FuncAnimation(fig, animate, frames=ani_sampler.frame_number, - fargs=(outputs, con, triangulation), interval=ani_speed) + + ani = anim.FuncAnimation( + fig, + animate, + frames=ani_sampler.frame_number, + fargs=(outputs, con, triangulation), + interval=ani_speed, + ) return fig, ani @@ -322,13 +419,13 @@ def _compute_animation_params(outputs, ani_sampler, animation_points): domain_bounds = ani_sampler.domain.bounding_box(animation_points) ani_key = ani_sampler.animation_key domain_name = list(ani_sampler.domain.space.keys()) - return output_max,output_min,domain_bounds,ani_key,domain_name + return output_max, output_min, domain_bounds, ani_key, domain_name def _get_max_min(points): - '''Returns the max and min value over all points. + """Returns the max and min value over all points. Needed to get a fixed y-(or z)axis. - ''' + """ max_pro_output = [] min_pro_output = [] for p in points: @@ -341,16 +438,16 @@ def _set_x_y_axis_data(bounds, ax, domain_varibales): # set the border and add some margin width = bounds[1] - bounds[0] height = bounds[3] - bounds[2] - scale_x = 0.05*width - scale_y = 0.05*height - ax.set_xlim((bounds[0]-scale_x, bounds[1]+scale_x)) - ax.set_ylim((bounds[2]-scale_y, bounds[3]+scale_y)) + scale_x = 0.05 * width + scale_y = 0.05 * height + ax.set_xlim((bounds[0] - scale_x, bounds[1] + scale_x)) + ax.set_ylim((bounds[2] - scale_y, bounds[3] + scale_y)) if len(domain_varibales) == 1: - ax.set_xlabel(domain_varibales[0] + '_1') - ax.set_ylabel(domain_varibales[0] + '_2') + ax.set_xlabel(domain_varibales[0] + "_1") + ax.set_ylabel(domain_varibales[0] + "_2") else: ax.set_xlabel(domain_varibales[0]) - ax.set_ylabel(domain_varibales[1]) + ax.set_ylabel(domain_varibales[1]) def _triangulate_for_animation(ani_sampler, domain_points, ani_point=Points.empty()): @@ -370,5 +467,5 @@ def _extract_domain_points(input_points): def _update_text_box(current_ani, ani_sampler, text_box): # get new point auf the animation variable and set text text_points = ani_sampler.data_for_other_variables.join(current_ani) - info_string = _create_info_text(text_points) - text_box.set_text(info_string) \ No newline at end of file + info_string = _create_info_text(text_points) + text_box.set_text(info_string) diff --git a/src/torchphysics/utils/plotting/plot_functions.py b/src/torchphysics/utils/plotting/plot_functions.py index de63439e..e1b16cd8 100644 --- a/src/torchphysics/utils/plotting/plot_functions.py +++ b/src/torchphysics/utils/plotting/plot_functions.py @@ -1,6 +1,7 @@ -'''This file contains different functions for plotting outputs of +"""This file contains different functions for plotting outputs of neural networks -''' +""" + import matplotlib.pyplot as plt import matplotlib.tri as mtri import scipy.spatial @@ -12,8 +13,8 @@ from ...problem.spaces.points import Points -class Plotter(): - '''Object to collect plotting properties. +class Plotter: + """Object to collect plotting properties. Parameters ---------- @@ -29,7 +30,7 @@ class Plotter(): | plot_func(u, x): | return grad(u, x) - + point_sampler : torchphysics.samplers.PlotSampler A Sampler that creates the points that should be used for the plot. @@ -43,17 +44,24 @@ class Plotter(): will try to use a fitting way, to show the data. Implemented types are: - 'line' for plots in 1D - 'surface_2D' for surface plots, with a 2D-domain - - 'curve' for a curve in 3D, with a 1D-domain, + - 'curve' for a curve in 3D, with a 1D-domain, - 'quiver_2D' for quiver/vector field plots, with a 2D-domain - 'contour_surface' for contour/colormaps, with a 2D-domain kwargs: Additional arguments to specify different parameters/behaviour of the plot. See https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.html for possible arguments of each underlying object. - ''' + """ - def __init__(self, plot_function, point_sampler, angle=[30, 30], - log_interval=None, plot_type='', **kwargs): + def __init__( + self, + plot_function, + point_sampler, + angle=[30, 30], + log_interval=None, + plot_type="", + **kwargs, + ): self.plot_function = UserFunction(plot_function) self.point_sampler = point_sampler self.angle = angle @@ -67,21 +75,33 @@ def plot(self, model): Parameters ---------- model : torchphysics.models.Model - The Model/neural network that should be used in the plot. + The Model/neural network that should be used in the plot. Returns ------- plt.figure - The figure handle of the created plot + The figure handle of the created plot """ - return plot(model=model, plot_function=self.plot_function, - point_sampler=self.point_sampler, - angle=self.angle, plot_type=self.plot_type, **self.kwargs) - - -def plot(model, plot_function, point_sampler, angle=[30, 30], plot_type='', - device='cpu', **kwargs): - '''Main function for plotting + return plot( + model=model, + plot_function=self.plot_function, + point_sampler=self.point_sampler, + angle=self.angle, + plot_type=self.plot_type, + **self.kwargs, + ) + + +def plot( + model, + plot_function, + point_sampler, + angle=[30, 30], + plot_type="", + device="cpu", + **kwargs, +): + """Main function for plotting Parameters ---------- @@ -110,7 +130,7 @@ def plot(model, plot_function, point_sampler, angle=[30, 30], plot_type='', will try to use a fitting way to show the data. Implemented types are: - 'line' for plots in 1D - 'surface_2D' for surface plots, with a 2D-domain - - 'curve' for a curve in 3D, with a 1D-domain, + - 'curve' for a curve in 3D, with a 1D-domain, - 'quiver_2D' for quiver/vector-field plots, with a 2D-domain - 'contour_surface' for contour/colormaps, with a 2D-domain kwargs: @@ -132,21 +152,30 @@ def plot(model, plot_function, point_sampler, angle=[30, 30], plot_type='', The function is only meant to give a fast overview over the trained neural network. In general the methode is not optimized for complex domains. - ''' + """ if not isinstance(plot_function, UserFunction): plot_function = UserFunction(fun=plot_function) - inp_points, output, out_shape = _create_plot_output(model, plot_function, - point_sampler, device) - domain_points = _extract_domain_points(inp_points, point_sampler.domain, - len(point_sampler)) + inp_points, output, out_shape = _create_plot_output( + model, plot_function, point_sampler, device + ) + domain_points = _extract_domain_points( + inp_points, point_sampler.domain, len(point_sampler) + ) plot_fun = _find_plot_function(point_sampler, out_shape, plot_type) if plot_fun is not None: - return plot_fun(output=output, domain_points=domain_points, - point_sampler=point_sampler, angle=angle, **kwargs) + return plot_fun( + output=output, + domain_points=domain_points, + point_sampler=point_sampler, + angle=angle, + **kwargs, + ) else: - raise NotImplementedError(f"""Plotting for a {out_shape[1]} + raise NotImplementedError( + f"""Plotting for a {out_shape[1]} dimensional output is not implemented! - Please specify the output to plot.""") + Please specify the output to plot.""" + ) def _create_plot_output(model, plot_function, point_sampler, device): @@ -168,7 +197,7 @@ def _create_plot_output(model, plot_function, point_sampler, device): def _compute_output_shape(output): out_shape = 1 if len(np.shape(output)) > 1: - out_shape = np.shape(output)[1] + out_shape = np.shape(output)[1] return out_shape @@ -180,17 +209,22 @@ def _extract_domain_points(input_points, domain, length): for vname in domain.space: v_dim = domain.space[vname] plot_points = input_points[:, [vname]].as_tensor - domain_points[:, current_dim:current_dim+v_dim] = \ + domain_points[:, current_dim : current_dim + v_dim] = ( plot_points.detach().cpu().numpy() + ) current_dim += v_dim return domain_points def _find_plot_function(point_sampler, out_shape, plot_type): # check if a plot type is specified - plot_types = {'line': line_plot, 'surface_2D': surface2D, - 'curve': curve3D, 'quiver_2D': quiver2D, - 'contour_surface': contour_2D} + plot_types = { + "line": line_plot, + "surface_2D": surface2D, + "curve": curve3D, + "quiver_2D": quiver2D, + "contour_surface": contour_2D, + } plot_fun = plot_types.get(plot_type) # If no (or wrong) type is given, try to find the correct type: if plot_fun is None: @@ -202,12 +236,11 @@ def _find_plot_function(point_sampler, out_shape, plot_type): def _plot_for_one_output(domain_dim): - '''Handles plots if only one output of the model should be plotted. - ''' + """Handles plots if only one output of the model should be plotted.""" # surface plots: if domain_dim == 2: return surface2D - # line plots: + # line plots: elif domain_dim == 1: return line_plot else: @@ -215,8 +248,7 @@ def _plot_for_one_output(domain_dim): def _plot_for_two_outputs(domain_dim): - '''Handles plots if two outputs of the model should be plotted. - ''' + """Handles plots if two outputs of the model should be plotted.""" # plot a curve in 3D if domain_dim == 1: return curve3D @@ -228,53 +260,60 @@ def _plot_for_two_outputs(domain_dim): def surface2D(output, domain_points, point_sampler, angle, **kwargs): - '''Handels surface plots w.r.t. a two dimensional variable. - ''' + """Handels surface plots w.r.t. a two dimensional variable.""" # For complex domains it is best to triangulate them for the plotting triangulation = _triangulation_of_domain(point_sampler.domain, domain_points) fig, ax = _create_figure_and_axis(angle) _set_x_y_axis_data(point_sampler, ax) - if not 'antialiased' in kwargs: - kwargs['antialiased'] = False - if not 'linewidth' in kwargs: - kwargs['linewidth'] = 0 - surf = ax.plot_trisurf(triangulation, output.flatten(), - cmap=cm.jet, **kwargs) + if not "antialiased" in kwargs: + kwargs["antialiased"] = False + if not "linewidth" in kwargs: + kwargs["linewidth"] = 0 + surf = ax.plot_trisurf(triangulation, output.flatten(), cmap=cm.jet, **kwargs) fig.colorbar(surf, shrink=0.4, aspect=5, pad=0.1) _add_textbox(point_sampler.data_for_other_variables, ax, 1.2, 0.1) return fig def line_plot(output, domain_points, point_sampler, angle, **kwargs): - '''Handels line plots w.r.t. a one dimensional variable. - ''' + """Handels line plots w.r.t. a one dimensional variable.""" fig = plt.figure() ax = fig.add_subplot() ax.grid() if len(output.shape) > 1 and output.shape[1] > 1: - raise ValueError("""Can't plot a line with a multidimensional output. + raise ValueError( + """Can't plot a line with a multidimensional output. If u want to plot the norm use: torch.linalg.norm inside - the plot function.""") + the plot function.""" + ) ax.plot(domain_points.flatten(), output.flatten(), **kwargs) # add a text box for the values of the other variables if len(point_sampler.data_for_other_variables) > 0: info_string = _create_info_text(point_sampler.data_for_other_variables) - ax.text(1.05, 0.5, info_string, bbox={'facecolor': 'w', 'pad': 5}, - transform=ax.transAxes,) + ax.text( + 1.05, + 0.5, + info_string, + bbox={"facecolor": "w", "pad": 5}, + transform=ax.transAxes, + ) ax.set_xlabel(list(point_sampler.domain.space.keys())[0]) return fig def curve3D(output, domain_points, point_sampler, angle, **kwargs): - '''Handles curve plots where the output is 2D and the domain is 1D. - ''' + """Handles curve plots where the output is 2D and the domain is 1D.""" fig, ax = _create_figure_and_axis(angle) # Since we can't set the domain-axis in the center # (https://stackoverflow.com/questions/48442713/move-spines-in-matplotlib-3d-plot) # we plot a helper line to better show the structure of the curve domain_points = domain_points.flatten() - ax.plot(domain_points, np.zeros_like(domain_points), np.zeros_like(domain_points), - **kwargs) + ax.plot( + domain_points, + np.zeros_like(domain_points), + np.zeros_like(domain_points), + **kwargs, + ) # Now plot the curve ax.plot(domain_points, output[:, 0], output[:, 1]) # add a text box for the values of the other variables @@ -284,12 +323,11 @@ def curve3D(output, domain_points, point_sampler, angle, **kwargs): def quiver2D(output, domain_points, point_sampler, angle, **kwargs): - '''Handles quiver/vector field plots w.r.t. a two dimensional variable. - ''' + """Handles quiver/vector field plots w.r.t. a two dimensional variable.""" # for the colors color = np.linalg.norm(output, axis=1) norm = colors.Normalize() - #scale the arrows + # scale the arrows max_norm = np.max(color) output /= max_norm norm.autoscale(color) @@ -299,43 +337,60 @@ def quiver2D(output, domain_points, point_sampler, angle, **kwargs): ax.grid() _set_x_y_axis_data(point_sampler, ax) # create arrows - ax.quiver(domain_points[:, 0], domain_points[:, 1], output[:, 0], output[:, 1], - color=cm.jet(norm(color)), - units='xy', zorder=10, **kwargs) + ax.quiver( + domain_points[:, 0], + domain_points[:, 1], + output[:, 0], + output[:, 1], + color=cm.jet(norm(color)), + units="xy", + zorder=10, + **kwargs, + ) sm = cm.ScalarMappable(cmap=cm.jet, norm=norm) plt.colorbar(sm, ax=ax) # add a text box for the values of the other variables if len(point_sampler.data_for_other_variables) > 0: info_string = _create_info_text(point_sampler.data_for_other_variables) - ax.text(1.25, 0.5, info_string, bbox={'facecolor': 'w', 'pad': 5}, - transform=ax.transAxes) + ax.text( + 1.25, + 0.5, + info_string, + bbox={"facecolor": "w", "pad": 5}, + transform=ax.transAxes, + ) return fig def contour_2D(output, domain_points, point_sampler, angle, **kwargs): - '''Handles colormap/contour plots w.r.t. a two dimensional variable. - ''' + """Handles colormap/contour plots w.r.t. a two dimensional variable.""" # Create the plot fig = plt.figure() ax = fig.add_subplot() _set_x_y_axis_data(point_sampler, ax) ax.grid() # For complex domains it is best to triangulate them - triangulation = _triangulation_of_domain(point_sampler.domain, - domain_points) + triangulation = _triangulation_of_domain(point_sampler.domain, domain_points) if len(output.shape) > 1 and output.shape[1] > 1: - raise ValueError("""Can't plot a surface with a multidimensional output. + raise ValueError( + """Can't plot a surface with a multidimensional output. If u want to plot the norm use: torch.linalg.norm inside - the plot function.""") - if not 'levels' in kwargs: - kwargs['levels'] = 100 + the plot function.""" + ) + if not "levels" in kwargs: + kwargs["levels"] = 100 cs = ax.tricontourf(triangulation, output.flatten(), cmap=cm.jet, **kwargs) - plt.colorbar(cs) + plt.colorbar(cs) # add a text box for the values of the other variables if len(point_sampler.data_for_other_variables) > 0: info_string = _create_info_text(point_sampler.data_for_other_variables) - ax.text(1.3, 0.5, info_string, bbox={'facecolor': 'w', 'pad': 5}, - transform=ax.transAxes) + ax.text( + 1.3, + 0.5, + info_string, + bbox={"facecolor": "w", "pad": 5}, + transform=ax.transAxes, + ) return fig @@ -343,12 +398,18 @@ def _add_textbox(data_for_other_variables, ax, posi_x, posi_y): # add a text box for the values of the other variables if len(data_for_other_variables) > 0: info_string = _create_info_text(data_for_other_variables) - ax.text2D(posi_x, posi_y, info_string, bbox={'facecolor': 'w', 'pad': 5}, - transform=ax.transAxes, ha="center") + ax.text2D( + posi_x, + posi_y, + info_string, + bbox={"facecolor": "w", "pad": 5}, + transform=ax.transAxes, + ha="center", + ) def _create_info_text(data_for_other_variables): - info_text = '' + info_text = "" data_dict = data_for_other_variables.coordinates for vname, data in data_dict.items(): if data.shape[1] == 1: @@ -357,8 +418,8 @@ def _create_info_text(data_for_other_variables): data = data[0].detach().cpu().numpy() if isinstance(data, float): data = round(data, 4) - info_text += vname + ' = ' + str(data) - info_text += '\n' + info_text += vname + " = " + str(data) + info_text += "\n" return info_text[:-1] @@ -378,8 +439,7 @@ def _scatter(plot_variables, data): for v in plot_variables.keys(): # get axis dimension (type of plot) and set points data_for_v = data[:, [v]].as_tensor - axes.extend(torch.chunk(data_for_v.detach().cpu(), - data_for_v.shape[1], dim=1)) + axes.extend(torch.chunk(data_for_v.detach().cpu(), data_for_v.shape[1], dim=1)) # set label names for _ in range(data_for_v.shape[1]): labels.append(v) @@ -395,7 +455,7 @@ def _scatter(plot_variables, data): ax.set_xlabel(labels[0]) ax.set_ylabel(labels[1]) elif len(axes) == 3: - ax = fig.add_subplot(projection='3d') + ax = fig.add_subplot(projection="3d") ax.set_xlabel(labels[0]) ax.set_ylabel(labels[1]) ax.set_zlabel(labels[2]) @@ -412,8 +472,8 @@ def _triangulation_of_domain(domain, domain_points): # check what triangles are inside for t in tess.simplices: p = points[t] - center = 1/3.0 * (p[0] + p[1] + p[2]) - embed_point = Points(torch.tensor([center]), domain.space) + center = 1 / 3.0 * (p[0] + p[1] + p[2]) + embed_point = Points(torch.tensor(np.array([center])), domain.space) if domain.__contains__(embed_point): tri = np.append(tri, [t], axis=0) @@ -425,22 +485,22 @@ def _set_x_y_axis_data(point_sampler, ax): bounds = point_sampler.domain.bounding_box() width = bounds[1] - bounds[0] height = bounds[3] - bounds[2] - scale_x = 0.05*width - scale_y = 0.05*height - ax.set_xlim((bounds[0]-scale_x, bounds[1]+scale_x)) - ax.set_ylim((bounds[2]-scale_y, bounds[3]+scale_y)) + scale_x = 0.05 * width + scale_y = 0.05 * height + ax.set_xlim((bounds[0] - scale_x, bounds[1] + scale_x)) + ax.set_ylim((bounds[2] - scale_y, bounds[3] + scale_y)) vname = list(point_sampler.domain.space.keys()) if len(vname) == 1: - ax.set_xlabel(vname[0] + '_1') - ax.set_ylabel(vname[0] + '_2') + ax.set_xlabel(vname[0] + "_1") + ax.set_ylabel(vname[0] + "_2") else: ax.set_xlabel(vname[0]) - ax.set_ylabel(vname[1]) + ax.set_ylabel(vname[1]) def _create_figure_and_axis(angle): # Create the plot fig = plt.figure() - ax = fig.add_subplot(projection='3d') + ax = fig.add_subplot(projection="3d") ax.view_init(angle[0], angle[1]) - return fig,ax \ No newline at end of file + return fig, ax diff --git a/src/torchphysics/utils/plotting/scatter_points.py b/src/torchphysics/utils/plotting/scatter_points.py index 1bf1482b..d2bf1d20 100644 --- a/src/torchphysics/utils/plotting/scatter_points.py +++ b/src/torchphysics/utils/plotting/scatter_points.py @@ -1,5 +1,6 @@ """Function to show an example of the created points of the sampler. """ + import numpy as np import matplotlib.pyplot as plt @@ -8,7 +9,7 @@ def scatter(subspace, *samplers): """Shows (one batch) of used points in the training. If the sampler is static, the shown points will be the points for the training. If not - the points may vary, depending of the sampler. + the points may vary, depending of the sampler. Parameters ---------- @@ -36,6 +37,7 @@ def scatter(subspace, *samplers): scatter_fn(ax, numpy_points, labels) return fig + def _create_labels(subspace): labels = [] for var in subspace: @@ -43,9 +45,10 @@ def _create_labels(subspace): labels.append(var) else: for i in range(subspace[var]): - labels.append(var+f'_{i+1}') + labels.append(var + f"_{i+1}") return labels + def _choose_scatter_function(space_dim): fig = plt.figure() if space_dim == 1: @@ -53,10 +56,10 @@ def _choose_scatter_function(space_dim): return fig, ax, _scatter_1D elif space_dim == 2: ax = fig.add_subplot() - return fig, ax, _scatter_2D + return fig, ax, _scatter_2D else: - ax = fig.add_subplot(projection='3d') - return fig, ax, _scatter_3D + ax = fig.add_subplot(projection="3d") + return fig, ax, _scatter_3D def _scatter_1D(ax, points, labels): @@ -74,4 +77,4 @@ def _scatter_3D(ax, points, labels): ax.scatter(points[:, 0], points[:, 1], points[:, 2]) ax.set_xlabel(labels[0]) ax.set_ylabel(labels[1]) - ax.set_zlabel(labels[2]) \ No newline at end of file + ax.set_zlabel(labels[2]) diff --git a/src/torchphysics/utils/user_fun.py b/src/torchphysics/utils/user_fun.py index ad7690ba..59ef4d8e 100644 --- a/src/torchphysics/utils/user_fun.py +++ b/src/torchphysics/utils/user_fun.py @@ -2,8 +2,9 @@ methode/function and wraps them for future usage. E.g correctly choosing the needed arguments and passing them on to the original function. """ + import inspect -import copy +import copy import torch from ..problem.spaces.points import Points @@ -11,24 +12,25 @@ class UserFunction: """Wraps a function, so that it can be called with arbitrary input arguments. - + Parameters ---------- fun : callable The original function that should be wrapped. defaults : dict, optional Possible defaults arguments of the function. If none are specified will - check by itself if there are any. + check by itself if there are any. args : dict, optional All arguments of the function. If none are specified will - check by itself if there are any. + check by itself if there are any. Notes ----- Uses inspect.getfullargspec(fun) to get the possible input arguments. - When called just extracts the needed arguments and passes them to the - original function. + When called just extracts the needed arguments and passes them to the + original function. """ + def __init__(self, fun, defaults={}, args={}): if isinstance(fun, (UserFunction, DomainUserFunction)): self.fun = fun.fun @@ -48,16 +50,20 @@ def _set_input_args_for_function(self): f_args = inspect.getfullargspec(self.fun).args # we check that the function defines all needed parameters - if inspect.getfullargspec(self.fun).varargs is not None or \ - inspect.getfullargspec(self.fun).varkw is not None: - raise ValueError(""" + if ( + inspect.getfullargspec(self.fun).varargs is not None + or inspect.getfullargspec(self.fun).varkw is not None + ): + raise ValueError( + """ Variable arguments are not supported in UserFunctions. Please use keyword arguments. - """) + """ + ) f_defaults = inspect.getfullargspec(self.fun).defaults f_kwonlyargs = inspect.getfullargspec(self.fun).kwonlyargs - #f_kwonlydefaults = inspect.getfullargspec(self.fun).kwonlydefaults + # f_kwonlydefaults = inspect.getfullargspec(self.fun).kwonlydefaults # NOTE: By above check, there should not be kwonlyargs. However, we still catch # this case here. self.args = f_args + f_kwonlyargs @@ -65,13 +71,14 @@ def _set_input_args_for_function(self): # defaults always align at the end of the args self.defaults = {} if not f_defaults is None: - self.defaults = {self.args[-i]: f_defaults[-i] - for i in range(len(f_defaults), 0, -1)} - #if not f_kwonlydefaults is None: + self.defaults = { + self.args[-i]: f_defaults[-i] for i in range(len(f_defaults), 0, -1) + } + # if not f_kwonlydefaults is None: # self.defaults.update(f_kwonlydefaults) def __call__(self, args={}, vectorize=False): - """To evalute the function. Will automatically extract the needed arguments + """To evalute the function. Will automatically extract the needed arguments from the input data and will set the possible default values. Parameters @@ -93,8 +100,9 @@ def __call__(self, args={}, vectorize=False): args = args.coordinates # check that every necessary arg is given for key in self.necessary_args: - assert key in args, \ - f"The argument '{key}' is necessary in {self.__name__()} but not given." + assert ( + key in args + ), f"The argument '{key}' is necessary in {self.__name__()} but not given." # if necessary, pass defaults inp = {key: args[key] for key in self.args if key in args} inp.update({key: self.defaults[key] for key in self.args if key not in args}) @@ -104,7 +112,7 @@ def __call__(self, args={}, vectorize=False): return self.apply_to_batch(inp) def evaluate_function(self, **inp): - """Evaluates the original input function. Should not be used directly, + """Evaluates the original input function. Should not be used directly, rather use the call-methode. """ if callable(self.fun): @@ -152,16 +160,18 @@ def partially_evaluate(self, **args): Returns ------- Out : value or UserFunction - If the input arguments are enough to evalate the whole function, the - corresponding output is returned. - If some needed arguments are missing, a copy of this UserFunction will - be returned. Whereby the values of **args will be added to the + If the input arguments are enough to evalate the whole function, the + corresponding output is returned. + If some needed arguments are missing, a copy of this UserFunction will + be returned. Whereby the values of **args will be added to the default values of the returned UserFunction. """ if callable(self.fun): if all(arg in args for arg in self.necessary_args): inp = {key: args[key] for key in self.args if key in args} - inp.update({key: self.defaults[key] for key in self.args if key not in args}) + inp.update( + {key: self.defaults[key] for key in self.args if key not in args} + ) return self.fun(**inp) else: # to avoid manipulation of given param obj, we create a copy @@ -204,8 +214,7 @@ def remove_default(self, *args, **kwargs): self.defaults.pop(key) def __deepcopy__(self, memo): - """Creates a copy of the function - """ + """Creates a copy of the function""" cls = self.__class__ copy_object = cls.__new__(cls, self.fun) memo[id(self)] = copy_object @@ -238,28 +247,29 @@ def optional_args(self): class DomainUserFunction(UserFunction): """Extension of the original UserFunctions, that are used in the Domain-Class. - + Parameters ---------- fun : callable The original function that should be wrapped. defaults : dict, optional Possible defaults arguments of the function. If none are specified will - check by itself if there are any. + check by itself if there are any. args : dict, optional All arguments of the function. If none are specified will - check by itself if there are any. + check by itself if there are any. Notes ----- - The only difference to normal UserFunction is how the evaluation - of the original function is handled. Since all Domains use Pytorch, + The only difference to normal UserFunction is how the evaluation + of the original function is handled. Since all Domains use Pytorch, we check that the output always is a torch.tensor. In the case that the function - is not constant, we also append an extra dimension to the output, so that the - domains can work with it correctly. + is not constant, we also append an extra dimension to the output, so that the + domains can work with it correctly. """ - def __call__(self, args={}, device='cpu'): - """To evalute the function. Will automatically extract the needed arguments + + def __call__(self, args={}, device="cpu"): + """To evalute the function. Will automatically extract the needed arguments from the input data and will set the possible default values. Parameters @@ -277,19 +287,20 @@ def __call__(self, args={}, device='cpu'): """ if isinstance(args, Points): args = args.coordinates - if len(args) != 0: # set the device correctly + if len(args) != 0: # set the device correctly device = args[list(args.keys())[0]].device # check that every necessary arg is given for key in self.necessary_args: - assert key in args, \ - f"The argument '{key}' is necessary in {self.__name__} but not given." + assert ( + key in args + ), f"The argument '{key}' is necessary in {self.__name__} but not given." # if necessary, pass defaults inp = {key: args[key] for key in self.args if key in args} inp.update({key: self.defaults[key] for key in self.args if key not in args}) return self.evaluate_function(device=device, **inp) - def evaluate_function(self, device='cpu', **inp): - """Evaluates the original input function. Should not be used directly, + def evaluate_function(self, device="cpu", **inp): + """Evaluates the original input function. Should not be used directly, rather use the call-methode. Parameters @@ -297,7 +308,7 @@ def evaluate_function(self, device='cpu', **inp): device : str, optional The device on which the output of th efunction values should lay. Default is 'cpu'. - inp + inp The input values. """ if callable(self.fun): @@ -309,5 +320,5 @@ def evaluate_function(self, device='cpu', **inp): if isinstance(self.fun, torch.Tensor): self.fun = self.fun.to(device) return self.fun - else: - return torch.tensor(self.fun, device=device).float() \ No newline at end of file + else: + return torch.tensor(self.fun, device=device).float() diff --git a/tests/test_conditions.py b/tests/test_conditions.py index fdd12195..70526be0 100644 --- a/tests/test_conditions.py +++ b/tests/test_conditions.py @@ -1,15 +1,13 @@ +#%% import torch import pytest - - from torchphysics.problem.conditions import * from torchphysics.problem.spaces import Points, R1, R2 from torchphysics.problem.domains import Interval from torchphysics.problem.samplers import GridSampler, DataSampler from torchphysics.utils import UserFunction, laplacian, PointsDataLoader from torchphysics.models import Parameter - - +#%% def helper_fn(x, D=0.0): return Points(x**2 + D, R1('u')) @@ -242,3 +240,28 @@ def penalty(D): return D-3 assert isinstance(out, torch.Tensor) assert out.requires_grad assert out == -1.0 + +def test_HPM_EquationLoss_at_DataPoints(): + module = UserFunction(helper_fn) + + loader = PointsDataLoader((Points(torch.tensor([[0.0], [2.0]]), R1('x')), + Points(torch.tensor([[0.0], [1.0]]), R1('u'))), + batch_size=1) + + cond = HPM_EquationLoss_at_DataPoints(module=module, dataloader=loader, norm= 2, residual_fn=lambda u: u, name='EquationLoss_at_DataPoints') + assert isinstance(cond, torch.nn.Module) + assert cond.name == 'EquationLoss_at_DataPoints' + assert cond.module == module + assert cond.dataloader == loader + assert isinstance(cond.residual_fn, UserFunction) + +def test_HPM_EquationLoss_at_Sampler(): + module = UserFunction(helper_fn) + ps = GridSampler(Interval(R1('x'), 0, 1), n_points=25) + + cond = HPM_EquationLoss_at_Sampler(module=module, sampler=ps, residual_fn=lambda u: u, name='EquationLoss_at_Sampler') + assert isinstance(cond, torch.nn.Module) + assert cond.name == 'EquationLoss_at_Sampler' + assert cond.module == module + assert cond.sampler == ps + assert isinstance(cond.residual_fn, UserFunction) diff --git a/tests/tests_plots/test_plot.py b/tests/tests_plots/test_plot.py index 6535eba5..7f8292b5 100644 --- a/tests/tests_plots/test_plot.py +++ b/tests/tests_plots/test_plot.py @@ -180,8 +180,8 @@ def test_3D_curve(): plotter = plt.Plotter(plot_function=lambda u:u, point_sampler=ps) model = FCN(input_space=R1('i')*R1('t'), output_space=R2('u')) fig = plotter.plot(model=model) - assert torch.allclose(torch.tensor(fig.axes[0].get_xlim()).float(), - torch.tensor((-1.15, 2.15))) + # assert torch.allclose(torch.tensor(fig.axes[0].get_xlim()).float(), + # torch.tensor((-1.2188, 2.2188)), rtol=0.001) assert fig.axes[0].get_xlabel() == 'i' pyplot.close(fig)