diff --git a/.gitignore b/.gitignore index 24805b29f..3354ebb95 100644 --- a/.gitignore +++ b/.gitignore @@ -73,3 +73,7 @@ _C_flare* **/xml **/dist **egg-info +tutorials/Al* +tutorials/*.txt +tutorials/*.npz +tutorials/*checkpoint* diff --git a/tutorials/sparse_gp_tutorial.ipynb b/tutorials/sparse_gp_tutorial.ipynb new file mode 100644 index 000000000..610a7cd67 --- /dev/null +++ b/tutorials/sparse_gp_tutorial.ipynb @@ -0,0 +1,3805 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "17b6981f-25a2-4ddd-91aa-ea4904347199", + "metadata": {}, + "source": [ + "## Learning many-body force fields on the fly: A tutorial introduction to the FLARE++ code\n", + "### Jonathan Vandermause (jonpvandermause@gmail.com)" + ] + }, + { + "cell_type": "markdown", + "id": "3dd96122-6dea-40a2-b080-64ec4842299c", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "id": "7b4a8630-5df7-4be6-8616-1860b20d8d3d", + "metadata": {}, + "source": [ + "**Learning objectives:**\n", + " * Train many-body sparse Gaussian process models on _ab initio_ force data using the [flare_pp](https://github.com/mir-group/flare_pp) code.\n", + " * Use the uncertainties of the sparse GP to train a force field on the fly using the [flare](https://github.com/mir-group/flare) code." + ] + }, + { + "cell_type": "markdown", + "id": "c484d882-308e-4416-9d40-fe636f51ea67", + "metadata": {}, + "source": [ + "## Introduction" + ] + }, + { + "cell_type": "markdown", + "id": "e2fdf409-c4ca-43ce-bafb-16db431b3f11", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "id": "0c7595d5-3b77-45bc-97c1-5a249afafd0a", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "id": "01f9499c-e133-4de5-8f77-f2f4bcba4b35", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "markdown", + "id": "c9c19d11-bf68-45a4-9d14-cb5c761fca23", + "metadata": {}, + "source": [ + "We can now import everything we'll need for the tutorial." + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "26a415d3-d08e-4f7c-9a88-556ce770189a", + "metadata": {}, + "outputs": [], + "source": [ + "# Import numpy and matplotlib\n", + "import numpy as np\n", + "from numpy.random import random\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib\n", + "\n", + "# Increase the matplotlib font size.\n", + "font = {'size': 22}\n", + "\n", + "matplotlib.rc('font', **font)\n", + "\n", + "# flare++ imports\n", + "from flare.bffs.sgp import SGP_Wrapper\n", + "from flare.bffs.sgp.calculator import SGP_Calculator\n", + "from flare.bffs.sgp._C_flare import B2, NormalizedDotProduct, SparseGP, Structure\n", + "\n", + "# flare imports\n", + "from flare.learners.otf import OTF\n", + "from flare.io import otf_parser\n", + "\n", + "# ASE imports\n", + "from ase import Atoms, units\n", + "from ase.calculators.eam import EAM\n", + "from ase.build import supercells\n", + "from ase.visualize import view\n", + "from ase.md.velocitydistribution import MaxwellBoltzmannDistribution, \\\n", + " Stationary, ZeroRotation\n", + "from ase.build import fcc111, add_adsorbate\n", + "from ase.io import write" + ] + }, + { + "cell_type": "markdown", + "id": "bac8a434-f120-4b8e-bcb0-c4692594c615", + "metadata": {}, + "source": [ + "## Training a many-body force field on static data" + ] + }, + { + "cell_type": "markdown", + "id": "9a084618-f3eb-443d-a6a8-f893ea5e8039", + "metadata": {}, + "source": [ + "Let's start by training a force field \"offline\" on an already existing dataset of _ab initio_ forces." + ] + }, + { + "cell_type": "markdown", + "id": "a2ba851f-4597-4fb1-b83e-873bf88491e9", + "metadata": {}, + "source": [ + "### Training data" + ] + }, + { + "cell_type": "markdown", + "id": "4ae37fa7-f1f5-48bd-a513-f74f0be27597", + "metadata": {}, + "source": [ + "To train our model we'll use the MD17 dataset introduced in Refs. [1-3], which contains energies and forces from _ab initio_ MD trajectories of eight small organic molecules.\n", + "\n", + "[[1] S. Chmiela, A. Tkatchenko, H. E. Sauceda, I. Poltavsky, K. T. Schütt, K.-R. Müller. Sci. Adv. 3(5), e1603015, 2017.](https://advances.sciencemag.org/content/3/5/e1603015)\n", + "\n", + "[[2] K. T. Schütt, F. Arbabzadah, S. Chmiela, K.-R. Müller, A. Tkatchenko. Nat. Commun. 8, 13890, 2017.](https://www.nature.com/articles/ncomms13890)\n", + "\n", + "[[3] S. Chmiela, H. E. Sauceda, K.-R. Müller, A. Tkatchenko. Nat. Commun. 9, 3887, 2018.](https://www.nature.com/articles/s41467-018-06169-2)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "711de343-5dbd-40d5-9d00-754584cbfbe1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2024-09-15 10:32:25-- http://quantum-machine.org/gdml/data/npz/md17_aspirin.npz\n", + "Resolving quantum-machine.org (quantum-machine.org)... 130.149.80.145\n", + "Connecting to quantum-machine.org (quantum-machine.org)|130.149.80.145|:80... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 202398748 (193M)\n", + "Saving to: ‘md17_aspirin.npz’\n", + "\n", + "md17_aspirin.npz 100%[===================>] 193.02M 11.3MB/s in 25s \n", + "\n", + "2024-09-15 10:32:50 (7.80 MB/s) - ‘md17_aspirin.npz’ saved [202398748/202398748]\n", + "\n" + ] + } + ], + "source": [ + "# Download the data.\n", + "! wget http://quantum-machine.org/gdml/data/npz/md17_aspirin.npz" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7c37f836-b24c-4542-8580-50c6aac3325b", + "metadata": {}, + "outputs": [], + "source": [ + "# Load training data.\n", + "data_file = \"md17_aspirin.npz\"\n", + "data = np.load(data_file)\n", + "n_strucs = len(data['E'])\n", + "\n", + "# Define species as ints starting from 0.\n", + "species = data['z']\n", + "species_code = {'6': 0, '8': 1, '1': 2}\n", + "\n", + "coded_species = []\n", + "for spec in species:\n", + " coded_species.append(species_code[str(spec)])\n", + "\n", + "# Define positions, forces, and the unit cell.\n", + "forces = data['F'] # kcal/mol/A\n", + "positions = data['R'] # A\n", + "cell = np.eye(3) * 100\n", + "noa = len(species)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "bb253fd4-2772-4af2-9e49-2dad9cb6d9d7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + "\n", + " ASE atomic visualization\n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \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": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Visualize an aspirin molecule.\n", + "frame = 100000\n", + "structure = Atoms(\n", + " positions=positions[frame],\n", + " numbers=species,\n", + " cell=cell\n", + " )\n", + "view(structure, viewer='x3d')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "7a65be7b-ef3a-4b51-96da-83874297cd2f", + "metadata": {}, + "outputs": [], + "source": [ + "# Choose training and validation structures.\n", + "training_size = 100\n", + "validation_size = 20\n", + "np.random.seed(1)\n", + "shuffled_frames = [int(n) for n in range(n_strucs)]\n", + "np.random.shuffle(shuffled_frames)\n", + "\n", + "training_pts = shuffled_frames[0:training_size]\n", + "validation_pts = shuffled_frames[training_size:training_size+validation_size]" + ] + }, + { + "cell_type": "markdown", + "id": "aa718222-4a5e-4b4f-9c90-3a896c55af55", + "metadata": {}, + "source": [ + "### Training a many-body sparse GP model" + ] + }, + { + "cell_type": "markdown", + "id": "95c3a02c-2ce6-4bcf-9a8e-0d05feb57dce", + "metadata": {}, + "source": [ + "We're now ready to train a sparse GP force field. Our approach follows the Gaussian Approximation Potential framework first introduced in Ref. [4] (see [5] for an excellent introduction), with a multi-element generalization of the Atomic Cluster Expansion [6] used to build rotationally-invariant many-body descriptors of local atomic environments.\n", + "\n", + "[[4] Bartók, A. P., Payne, M. C., Kondor, R., & Csányi, G. (2010). Physical review letters, 104(13), 136403.](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.104.136403)\n", + "\n", + "[[5] Bartók, A. P., & Csányi, G. (2015). International Journal of Quantum Chemistry, 115(16), 1051-1057.](https://onlinelibrary.wiley.com/doi/full/10.1002/qua.24927)\n", + "\n", + "[[6] Drautz, R. (2019). Physical Review B, 99(1), 014104.](https://journals.aps.org/prb/abstract/10.1103/PhysRevB.99.014104)" + ] + }, + { + "cell_type": "markdown", + "id": "e1c6c8eb-779c-4745-86fa-297a08f812c6", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "id": "1837af40-6a99-4914-8d2a-62b97d3fcc29", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "id": "1775c7c3-a59e-4e93-86b0-3d46dd76a218", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "id": "5902effc-6cf1-47ed-9598-641f9d572515", + "metadata": {}, + "source": [ + "To define a sparse GP force field, we need to choose a descriptor $\\vec{d}(\\rho_i)$ of local atomic environments $\\rho_i$ and a kernel $k(\\vec{d}_1, \\vec{d}_2)$ for comparing these descriptors.\n", + "\n", + "We'll use the $B_2$ descriptor from the Atomic Cluster Expansion, which requires us to define:\n", + "\n", + "\n", + "* The cutoff function and radius.\n", + "* The type and number of radial basis functions.\n", + "* The number of spherical harmonics.\n", + "\n", + "These are hyperparameters of the model, and it's generally a good idea to check how different choices of hyperparameters influence model accuracy. Here we'll use values that work well for the MD17 dataset.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1a55e007-bc1f-46b3-874e-4e4a0fcad886", + "metadata": {}, + "outputs": [], + "source": [ + "# Define many-body descriptor.\n", + "cutoff = 3.7 # A\n", + "n_species = 3 # Carbon, Oxygen, Hydrogen\n", + "N = 12 # Number of radial basis functions\n", + "lmax = 3 # Largest L included in spherical harmonics\n", + "radial_basis = \"chebyshev\" # Radial basis set\n", + "cutoff_name = \"quadratic\" # Cutoff function\n", + "radial_hyps = [0, cutoff]\n", + "cutoff_hyps = []\n", + "descriptor_settings = [n_species, N, lmax]\n", + "\n", + "# Define a B2 object.\n", + "B2 = B2(radial_basis, cutoff_name, radial_hyps, cutoff_hyps,\n", + " descriptor_settings)\n", + "\n", + "# The GP class can take a list of descriptors as input, but here\n", + "# we'll use a single descriptor.\n", + "descriptors = [B2]" + ] + }, + { + "cell_type": "markdown", + "id": "baa578ed-2330-4d79-8f03-5512e6c78729", + "metadata": {}, + "source": [ + "Next, we define our kernel function. We'll use a simple normalized dot product kernel:\n", + "\\begin{equation}\n", + "k(\\vec{d}_1, \\vec{d}_2) = \\sigma \\left(\\frac{\\vec{d}_1 \\cdot \\vec{d}_2}{d_1 d_2}\\right)^2.\n", + "\\end{equation}" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "0391c0bf-1bb4-4950-9ae9-c0c5bddd5728", + "metadata": {}, + "outputs": [], + "source": [ + "# Define kernel function.\n", + "sigma = 2.0\n", + "power = 2\n", + "dot_product_kernel = NormalizedDotProduct(sigma, power)\n", + "\n", + "# Define a list of kernels.\n", + "# There needs to be one kernel for each descriptor.\n", + "kernels = [dot_product_kernel]" + ] + }, + { + "cell_type": "markdown", + "id": "bd8ad198-1f66-435f-8d14-f53f501aebfe", + "metadata": {}, + "source": [ + "With the kernel object defined, we can construct a sparse GP object. To do this, we need to choose noise values for each type of label: energies, forces, and stresses (though in this example we'll train on forces only). It's a good idea to initialize these values to the expected error level for each quantity." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "2050d858-926e-41d8-bc0c-a73b19095ea3", + "metadata": {}, + "outputs": [], + "source": [ + "# Define sparse GP.\n", + "sigma_e = 0.12 * noa # Energy noise (in kcal/mol, so about 5 meV/atom)\n", + "sigma_f = 0.115 # Force noise (in kcal/mol/A, so about 5 meV/A)\n", + "sigma_s = 0.014 # Stress noise (in kcal/A^3, so about 0.1 GPa)\n", + "gp_model = SparseGP(kernels, sigma_e, sigma_f, sigma_s)" + ] + }, + { + "cell_type": "markdown", + "id": "f83b659b-659c-4381-9013-9c20e28b6f1d", + "metadata": {}, + "source": [ + "We now compute the descriptors and descriptor gradients of the training and validation structures and assign force labels to the training structures." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "9c3a736e-9049-433c-9c45-c7fd12fe234a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing descriptors of validation points...\n", + "Done.\n", + "Computing descriptors of training points...\n", + "Done.\n" + ] + } + ], + "source": [ + "# Calculate descriptors of the validation and training structures.\n", + "print(\"Computing descriptors of validation points...\")\n", + "validation_strucs = []\n", + "validation_forces = np.zeros((validation_size, noa, 3))\n", + "for n, snapshot in enumerate(validation_pts):\n", + " pos = positions[snapshot]\n", + " frcs = forces[snapshot]\n", + "\n", + " # Create structure object, which computes and stores descriptors.\n", + " struc = \\\n", + " Structure(cell, coded_species, pos, cutoff, descriptors)\n", + " validation_strucs.append(struc)\n", + " validation_forces[n] = frcs\n", + "print(\"Done.\")\n", + "\n", + "print(\"Computing descriptors of training points...\")\n", + "training_strucs = []\n", + "training_forces = np.zeros((training_size, noa, 3))\n", + "for n, snapshot in enumerate(training_pts):\n", + " pos = positions[snapshot]\n", + " frcs = forces[snapshot]\n", + "\n", + " # Create structure object, which computes and stores descriptors.\n", + " struc = \\\n", + " Structure(cell, coded_species, pos, cutoff, descriptors)\n", + "\n", + " # Assign force labels to the training structure.\n", + " struc.forces = frcs.reshape(-1)\n", + "\n", + " training_strucs.append(struc)\n", + " training_forces[n] = frcs\n", + "print(\"Done.\")" + ] + }, + { + "cell_type": "markdown", + "id": "d1c69ba6-0661-4548-95e6-cde2dbe4278a", + "metadata": {}, + "source": [ + "Finally, we train the sparse GP and check its performance on the validation set as more data is added. When we add structures to the GP, we need to choose which environments get added to the sparse set. For simplicity, in this example, we'll add all environments to the sparse set (which is theoretically accuracy-maximizing but may introduce redundancy). In our second example below, we'll use the GP uncertainties to select the sparse environments in an online fashion during molecular dynamics." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "8df7b8c9-a487-4294-9778-15a785289b7a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training the GP...\n", + "Batch 1 MAE: 7.10 kcal/mol/A\n", + "Batch 2 MAE: 4.29 kcal/mol/A\n", + "Batch 3 MAE: 3.17 kcal/mol/A\n", + "Batch 4 MAE: 2.61 kcal/mol/A\n", + "Batch 5 MAE: 2.22 kcal/mol/A\n", + "Batch 6 MAE: 2.02 kcal/mol/A\n", + "Batch 7 MAE: 1.86 kcal/mol/A\n", + "Batch 8 MAE: 1.68 kcal/mol/A\n", + "Batch 9 MAE: 1.57 kcal/mol/A\n", + "Batch 10 MAE: 1.49 kcal/mol/A\n" + ] + } + ], + "source": [ + "# Train the model.\n", + "print(\"Training the GP...\")\n", + "batch_size = 10 # monitor the MAE after adding this many frames\n", + "n_strucs = np.zeros(batch_size)\n", + "mb_maes = np.zeros(batch_size)\n", + "for m in range(training_size):\n", + " train_struc = training_strucs[m]\n", + "\n", + " # Add training structure and sparse environments.\n", + " gp_model.add_training_structure(train_struc)\n", + " gp_model.add_all_environments(train_struc)\n", + "\n", + " if (m + 1) % batch_size == 0:\n", + " # Update the sparse GP training coefficients.\n", + " gp_model.update_matrices_QR()\n", + "\n", + " # Predict on the validation set.\n", + " pred_forces = np.zeros((validation_size, noa, 3))\n", + " for n, test_struc in enumerate(validation_strucs):\n", + " gp_model.predict_SOR(test_struc)\n", + " pred_vals = test_struc.mean_efs[1:-6].reshape(noa, 3)\n", + " pred_forces[n] = pred_vals\n", + "\n", + " # Calculate and store the MAE.\n", + " batch_no = int((m + 1) / batch_size)\n", + " mae = np.mean(np.abs(validation_forces - pred_forces))\n", + " n_strucs[batch_no - 1] = batch_size * batch_no\n", + " mb_maes[batch_no - 1] = mae\n", + " print(\"Batch %i MAE: %.2f kcal/mol/A\" % (batch_no, mae))" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "5899fbd6-81f1-4874-856d-cbed9e86ae34", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the learning curve.\n", + "plt.figure(figsize=(16, 8))\n", + "plt.loglog(n_strucs, mb_maes, label=\"flare++\")\n", + "plt.loglog(1000, 0.0429 * 23, 'g.', markersize=20, label=\"GDML\")\n", + "plt.loglog(1000, 0.0295 * 23, 'r.', markersize=20, label=\"sGDML\")\n", + "plt.title(\"Learning curve\")\n", + "plt.xlabel(\"Number of training structures\")\n", + "plt.ylabel(\"MAE (kcal/mol/A)\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b2785640-0653-4193-b04d-853dd7d2f297", + "metadata": {}, + "source": [ + "### Mapping the trained model" + ] + }, + { + "cell_type": "markdown", + "id": "8de44f0e-a90e-4737-a0ed-9b2475a7e097", + "metadata": {}, + "source": [ + "We can map the trained sparse GP onto a fast quadratic model implemented in lammps with the following lines:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "01f5c6fc-9532-440b-a23f-6d350032b758", + "metadata": {}, + "outputs": [], + "source": [ + "# Write lammps potential file.\n", + "file_name = \"aspirin.txt\"\n", + "contributor = \"Your Name Here\"\n", + "\n", + "# The \"kernel index\" indicates which kernel to map for multi-descriptor models.\n", + "# For single-descriptor models like this one, just set it to 0.\n", + "kernel_index = 0\n", + "\n", + "gp_model.write_mapping_coefficients(file_name, contributor, kernel_index)" + ] + }, + { + "cell_type": "markdown", + "id": "e5825173-1b93-4dd6-80d9-ce9c38985eaf", + "metadata": {}, + "source": [ + "If you click on the Files tab on the left hand side of the screen, you'll see the lammps potential file that we just wrote. This can be used to perform efficient MD simulations in lammps using the custom \"flare\" pairstyle." + ] + }, + { + "cell_type": "markdown", + "id": "eb4ff8d2-2e59-4660-92f0-41190bf8ea26", + "metadata": {}, + "source": [ + "## Learning a many-body force field on the fly" + ] + }, + { + "cell_type": "markdown", + "id": "be3b1daf-e4e6-4bae-850d-62447ebf732e", + "metadata": {}, + "source": [ + "We're now ready to train a force field on the fly. In real applications, you would want to use a DFT code or some other quantum solver to compute reference energies and forces, but here for simplicity our goal will be to re-construct a many-body EAM potential on the fly." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "5cf27ac0-b4d7-4911-96fa-1851867280b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2024-09-15 10:47:17-- https://www.ctcms.nist.gov/potentials/Download/1999--Mishin-Y-Farkas-D-Mehl-M-J-Papaconstantopoulos-D-A--Al/2/Al99.eam.alloy\n", + "Resolving www.ctcms.nist.gov (www.ctcms.nist.gov)... 129.6.13.19\n", + "Connecting to www.ctcms.nist.gov (www.ctcms.nist.gov)|129.6.13.19|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 780452 (762K)\n", + "Saving to: ‘Al99.eam.alloy’\n", + "\n", + "Al99.eam.alloy 100%[===================>] 762.16K --.-KB/s in 0.09s \n", + "\n", + "2024-09-15 10:47:17 (8.60 MB/s) - ‘Al99.eam.alloy’ saved [780452/780452]\n", + "\n" + ] + } + ], + "source": [ + "# Download an aluminum EAM potential from the NIST potential database.\n", + "! wget https://www.ctcms.nist.gov/potentials/Download/1999--Mishin-Y-Farkas-D-Mehl-M-J-Papaconstantopoulos-D-A--Al/2/Al99.eam.alloy" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "9ff97c98-a8d1-4f37-9d2c-472e808f5f96", + "metadata": {}, + "outputs": [], + "source": [ + "# Define modified EAM calculator with null stress.\n", + "from ase.calculators.calculator import all_changes\n", + "class EAM_mod(EAM):\n", + " implemented_properties = [\"energy\", \"forces\", \"stress\", \"stresses\"]\n", + " def calculate(self, atoms=None, properties=['energy'],\n", + " system_changes=all_changes):\n", + " super().calculate(atoms, properties, system_changes)\n", + " self.results['stress'] = np.zeros(6)\n", + " self.results['stresses'] = np.zeros(6)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "7d3fc3fc-52a7-4999-bda5-94e7c830722f", + "metadata": {}, + "outputs": [], + "source": [ + "# Define ASE calculator.\n", + "eam_potential = EAM_mod(potential=\"Al99.eam.alloy\")" + ] + }, + { + "cell_type": "markdown", + "id": "79ad9211-c522-4524-a8cf-b81f233148f4", + "metadata": {}, + "source": [ + "To train a sparse GP on the fly, we follow four basic steps." + ] + }, + { + "cell_type": "markdown", + "id": "1ea3fa89-f9dd-4e5f-a195-dceb27112026", + "metadata": {}, + "source": [ + "### Step 1: Choose the initial structure." + ] + }, + { + "cell_type": "markdown", + "id": "d9720954-105a-4c01-a3f0-66042b268a6f", + "metadata": {}, + "source": [ + "We'll simulate an adatom on an aluminum slab to illustrate what happens when one local environment doesn't resemble any of the others in the structure." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "a2a72795-c4ef-4a8d-8751-44c14a169669", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + "\n", + " ASE atomic visualization\n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \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": [ + "" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create a slab with an adatom.\n", + "atoms = fcc111(\"Al\", (4, 4, 6), vacuum=10.0)\n", + "add_adsorbate(atoms, \"Al\", 2.5, \"ontop\")\n", + "n_atoms = len(atoms)\n", + "\n", + "# Randomly jitter the atoms to give nonzero forces in the first frame.\n", + "jitter_factor = 0.1\n", + "for atom_pos in atoms.positions:\n", + " for coord in range(3):\n", + " atom_pos[coord] += (2 * random() - 1) * jitter_factor\n", + "\n", + "view(atoms, viewer='x3d')" + ] + }, + { + "cell_type": "markdown", + "id": "dd25ea69-af3f-4240-a96a-6c28cc2feaa8", + "metadata": {}, + "source": [ + "### Step 2: Choose molecular dynamics settings." + ] + }, + { + "cell_type": "markdown", + "id": "df739f0d-7fc1-4aa3-a5ec-6ee53c24b565", + "metadata": {}, + "source": [ + "We'll set the initial temperature to 200 K and simulate in the NVE ensemble. In many applications, it's useful to add thermostats and barostats to control temperature and pressure." + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "5e1617ba-3768-4912-bf61-4a20e4dc8bcf", + "metadata": {}, + "outputs": [], + "source": [ + "# Set MD parameters.\n", + "md_engine = \"VelocityVerlet\"\n", + "md_dict = {}\n", + "\n", + "# Set the initial velocity to 300 K.\n", + "temperature = 300 # in K\n", + "MaxwellBoltzmannDistribution(atoms, temperature_K=temperature)\n", + "Stationary(atoms) # zero linear momentum\n", + "ZeroRotation(atoms) # zero angular momentum" + ] + }, + { + "cell_type": "markdown", + "id": "78338421-cfd2-40d3-a1fc-51553a351b6e", + "metadata": {}, + "source": [ + "### Step 3: Choose model settings." + ] + }, + { + "cell_type": "markdown", + "id": "64a9ad05-694a-4ba7-b0e0-0670bf187fab", + "metadata": {}, + "source": [ + "In addition to the quantities we encountered earlier (cutoff, basis set, and noise values), we'll also choose the type of uncertainties we want to compute and choose settings for hyperparameter optimization." + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "126a63fc-3ab6-4bc3-876a-4bf2d6672826", + "metadata": {}, + "outputs": [], + "source": [ + "# Create sparse GP model.\n", + "species_map = {13: 0} # Aluminum (atomic number 13) is species 0\n", + "cutoff = 5.0 # in A\n", + "sigma = 2.0 # in eV\n", + "power = 2 # power of the dot product kernel\n", + "kernel = NormalizedDotProduct(sigma, power)\n", + "cutoff_function = \"quadratic\"\n", + "many_body_cutoffs = [cutoff]\n", + "radial_basis = \"chebyshev\"\n", + "radial_hyps = [0., cutoff]\n", + "cutoff_hyps = []\n", + "n_species = 1\n", + "N = 8\n", + "lmax = 3\n", + "descriptor_settings = [n_species, N, lmax]\n", + "descriptor_calculator = B2(\n", + " radial_basis,\n", + " cutoff_function,\n", + " radial_hyps,\n", + " cutoff_hyps,\n", + " descriptor_settings\n", + ")\n", + "\n", + "# Set the noise values.\n", + "sigma_e = 0.001 * n_atoms # eV (1 meV/atom)\n", + "sigma_f = 0.05 # eV/A\n", + "sigma_s = 0.0006 # eV/A^3 (about 0.1 GPa)\n", + "\n", + "# Choose uncertainty type.\n", + "# Other options are \"DTC\" (Deterministic Training Conditional) or\n", + "# \"SOR\" (Subset of Regressors).\n", + "variance_type = \"local\" # Compute uncertainties on local energies (normalized)\n", + "\n", + "# Choose settings for hyperparameter optimization.\n", + "max_iterations = 20 # Max number of BFGS iterations during optimization\n", + "opt_method = \"L-BFGS-B\" # Method used for hyperparameter optimization\n", + "\n", + "# Bounds for hyperparameter optimization.\n", + "# Keeps the energy noise from going to zero.\n", + "bounds = [(None, None), (sigma_e, None), (None, None), (None, None)]\n", + "\n", + "# Create a model wrapper that is compatible with the flare code.\n", + "gp_model = SGP_Wrapper(\n", + " [kernel],\n", + " [descriptor_calculator],\n", + " cutoff,\n", + " sigma_e,\n", + " sigma_f,\n", + " sigma_s,\n", + " species_map,\n", + " variance_type=variance_type,\n", + " stress_training=False,\n", + " opt_method=opt_method,\n", + " bounds=bounds,\n", + " max_iterations=max_iterations,\n", + ")\n", + "\n", + "# Create an ASE calculator based on the GP model.\n", + "flare_calculator = SGP_Calculator(gp_model)" + ] + }, + { + "cell_type": "markdown", + "id": "5eab7b5f-734f-4c0c-8ed7-cf0b30d259d8", + "metadata": {}, + "source": [ + "### Step 4: Choose on-the-fly settings." + ] + }, + { + "cell_type": "markdown", + "id": "c2a821dc-88f4-4912-8f70-596a55b3820f", + "metadata": {}, + "source": [ + "There are two important choices to make here:\n", + " \n", + "\n", + "* The uncertainty tolerance (defined as `std_tolerance_factor` below) determines when calls to DFT are made. Because we are computing normalized uncertainties on local energies, a reasonable value is around 1%. A higher value will trigger fewer DFT calls but may reduce the accuracy of the model, so in practice it's a good idea to try out a few different values. Note that a positive `std_tolerance_factor` defines the tolerance as a fraction of the noise parameter, while a negative value defines it in absolute terms.\n", + "* `update_style` specifies the strategy for adding sparse environments to the GP. Here we set it to the `threshold` style, which only adds sparse environments if their associated uncertainty is above the defined `update_threshold`. This helps eliminate redundancy from the sparse set." + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "89b2d2d2-5ae9-4d15-8392-10494f27e035", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precomputing KnK for hyps optimization\n", + "Done precomputing. Time: 0.0012540817260742188\n", + "Hyperparameters:\n", + "[2.0e+00 9.7e-02 5.0e-02 6.0e-04]\n", + "Likelihood gradient:\n", + "[ 7.05841547e-01 -3.18601361e+00 -4.57660643e+03 0.00000000e+00]\n", + "Likelihood:\n", + "494.9480193789421\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00015423e+00 9.70000000e-02 -9.49999988e-01 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 6.52839399 -19.20677282 294.52571974 0. ]\n", + "Likelihood:\n", + "-273.3654487317382\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00003954e+00 9.70000000e-02 -2.06361137e-01 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 1.69273383 -19.44356747 1275.19012926 0. ]\n", + "Likelihood:\n", + "142.86681228647507\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00000914e+00 9.70000000e-02 -9.24677412e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 13.20272105 11.63467619 -863.21368959 0. ]\n", + "Likelihood:\n", + "761.8429596348944\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00026825e+00 9.72405914e-02 -2.30211186e-02 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[4.75195265e+00 1.69096654e+01 8.07249808e+03 0.00000000e+00]\n", + "Likelihood:\n", + "658.2722045575649\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001618e+00 9.70065370e-02 -9.62103019e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 9.7126387 30.30598984 870.49548906 0. ]\n", + "Likelihood:\n", + "761.8302538254009\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030828e-02 -9.42327000e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[17.25047285 10.98040125 -3.01926435 0. ]\n", + "Likelihood:\n", + "761.9182619157189\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001617e+00 9.70054904e-02 -9.42401106e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 16.96507695 -12.30385834 1.35743339 0. ]\n", + "Likelihood:\n", + "761.9181749524082\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001286e+00 9.70033420e-02 -9.42334980e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 15.10338254 -12.73747247 -2.02203532 0. ]\n", + "Likelihood:\n", + "761.9179844770781\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030843e-02 -9.42327047e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[15.26988639 -2.60847759 -3.07434153 0. ]\n", + "Likelihood:\n", + "761.9183805102173\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001248e+00 9.70030864e-02 -9.42390008e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 13.90447702 -11.40940668 0.45058965 0. ]\n", + "Likelihood:\n", + "761.9179904216912\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030843e-02 -9.42327107e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[16.87172301 24.22456985 -3.41653885 0. ]\n", + "Likelihood:\n", + "761.9182561779296\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030843e-02 -9.42327047e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[13.94465147 7.68836668 -4.19899578 0. ]\n", + "Likelihood:\n", + "761.9184308728511\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030843e-02 -9.42327047e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[16.75545174 2.94400563 -2.64894734 0. ]\n", + "Likelihood:\n", + "761.9180526900072\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030843e-02 -9.42327047e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[13.94465147 7.68836668 -4.19899578 0. ]\n", + "Likelihood:\n", + "761.9184308728511\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030843e-02 -9.42327047e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[15.9823725 10.12969196 -3.80532143 0. ]\n", + "Likelihood:\n", + "761.9184229670316\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030843e-02 -9.42327047e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[13.94465147 7.68836668 -4.19899578 0. ]\n", + "Likelihood:\n", + "761.9184308728511\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030843e-02 -9.42327047e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[17.0102649 7.36773722 -3.24212323 0. ]\n", + "Likelihood:\n", + "761.9183077395685\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030843e-02 -9.42327047e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[13.94465147 7.68836668 -4.19899578 0. ]\n", + "Likelihood:\n", + "761.9184308728511\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030843e-02 -9.42327047e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[16.51504737 7.50848775 -2.07694264 0. ]\n", + "Likelihood:\n", + "761.9181761683128\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030843e-02 -9.42327047e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[13.94465147 7.68836668 -4.19899578 0. ]\n", + "Likelihood:\n", + "761.9184308728511\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030843e-02 -9.42327047e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 16.66427057 -20.18499704 -3.21002735 0. ]\n", + "Likelihood:\n", + "761.9183307945116\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030843e-02 -9.42327047e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[13.94465147 7.68836668 -4.19899578 0. ]\n", + "Likelihood:\n", + "761.9184308728511\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001248e+00 9.70030885e-02 -9.42413744e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 17.4646482 -20.77038352 1.74350506 0. ]\n", + "Likelihood:\n", + "761.9176321526465\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030843e-02 -9.42327118e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 20.398532 -20.81500316 -1.08144374 0. ]\n", + "Likelihood:\n", + "761.9182880311373\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030843e-02 -9.42327047e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 17.16098164 -17.56511342 -1.78711029 0. ]\n", + "Likelihood:\n", + "761.9180682110841\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030843e-02 -9.42327047e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[12.78251071 30.60964794 -4.1749275 0. ]\n", + "Likelihood:\n", + "761.9180914312271\n", + "\n", + "\n", + "Precomputing KnK for hyps optimization\n", + "Done precomputing. Time: 0.0008220672607421875\n", + "Hyperparameters:\n", + "[ 2.00001246e+00 9.70030843e-02 -9.42327047e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 31.53064181 -1.74044977 -1596.32807826 0. ]\n", + "Likelihood:\n", + "1659.3813170199105\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.01976059e+00 9.70030824e-02 -1.00922826e+00 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ -3.94383537 23.42789641 563.14289769 0. ]\n", + "Likelihood:\n", + "-564.4780289424996\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00186014e+00 9.70030841e-02 -1.02967382e-01 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[-4.25055195e+00 1.67379281e+01 5.13845559e+03 0.00000000e+00]\n", + "Likelihood:\n", + "696.5227041919035\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00006476e+00 9.70030843e-02 -1.20709126e-02 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 1.95173727e+01 -9.89531721e+00 1.48058589e+04 0.00000000e+00]\n", + "Likelihood:\n", + "1637.3142491824178\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001565e+00 9.70030843e-02 -9.58495581e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 28.46718028 -9.90059046 127.33526452 0. ]\n", + "Likelihood:\n", + "1659.5003860885477\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001811e+00 9.70022119e-02 -9.57306384e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 28.58121251 -23.96238718 8.10549393 0. ]\n", + "Likelihood:\n", + "1659.5000662548555\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001621e+00 9.70028863e-02 -9.58225655e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 33.04048316 -84.84999065 104.5511981 0. ]\n", + "Likelihood:\n", + "1659.4981261391158\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001567e+00 9.70030796e-02 -9.58489190e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 27.49888105 -9.64427714 128.15814059 0. ]\n", + "Likelihood:\n", + "1659.499112145032\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001565e+00 9.70030843e-02 -9.58495574e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 33.0692898 -0.61038705 130.59358852 0. ]\n", + "Likelihood:\n", + "1659.4988784234906\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001565e+00 9.70030843e-02 -9.58495581e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 29.75566699 -24.89804285 129.8884656 0. ]\n", + "Likelihood:\n", + "1659.500121587973\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00001565e+00 9.70030843e-02 -9.58495581e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 31.8207739 -43.10326758 130.94654678 0. ]\n", + "Likelihood:\n", + "1659.5003544437113\n", + "\n", + "\n" + ] + } + ], + "source": [ + "# Set up OTF object.\n", + "init_atoms = list(range(n_atoms)) # Initial environments to include in the sparse set\n", + "output_name = 'Al' # Name of the output file\n", + "std_tolerance_factor = -0.01 # Uncertainty tolerance for calling QM\n", + "train_hyps = (0, 2) # Freeze hyperparameter optimization after second QM call\n", + "min_steps_with_model = 10 # Min number of steps between DFT calls\n", + "update_style = \"threshold\" # Strategy for adding sparse environments\n", + "update_threshold = 0.005 # Threshold for determining which sparse environments to add\n", + "force_only = False # Train only on forces or include energies and stresses\n", + "\n", + "otf_params = {\n", + " 'init_atoms': init_atoms,\n", + " 'output_name': output_name,\n", + " 'std_tolerance_factor': std_tolerance_factor,\n", + " 'train_hyps': train_hyps,\n", + " 'min_steps_with_model': min_steps_with_model,\n", + " 'update_style': update_style,\n", + " 'update_threshold': update_threshold,\n", + "}\n", + "\n", + "# Create OTF object.\n", + "timestep = 0.001 # units of ps\n", + "number_of_steps = 500\n", + "test_otf = OTF(\n", + " atoms,\n", + " timestep,\n", + " number_of_steps,\n", + " eam_potential,\n", + " md_engine,\n", + " md_dict,\n", + " flare_calc=flare_calculator,\n", + " force_only=force_only,\n", + " **otf_params,\n", + ")\n", + "\n", + "# Run on-the-fly dynamics.\n", + "test_otf.run()" + ] + }, + { + "cell_type": "markdown", + "id": "1074d8cc-d529-450a-aced-a550af0fccd1", + "metadata": {}, + "source": [ + "### Analyzing the simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "695843a1-af37-404d-a7fc-bb7431170bf0", + "metadata": {}, + "outputs": [], + "source": [ + "# Parse the output file.\n", + "output_file = 'Al.out'\n", + "otf_trajectory = otf_parser.OtfAnalysis(output_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "807816de-ce87-4c15-ac9e-d70e92d6c71b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqEAAAHOCAYAAACo6NBMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC4xElEQVR4nOzdd3xT5fcH8M9N0nTvTXdLWygbZG+UragIoiAoKOLeiqItHYgi+hP06wC3iICKTAEZspfIKpsC3Xumu2mS+/vj5l5autLmZrXn/Xr1Rdre8bS0zcnzPOcchmVZFoQQQgghhBiRxNQDIIQQQgghHQ8FoYQQQgghxOgoCCWEEEIIIUZHQSghhBBCCDE6CkIJIYQQQojRURBKCCGEEEKMjoJQQgghhBBidDJTD4CQxmg0GmRlZcHR0REMw5h6OIQQQgjRAcuyKCsrQ6dOnSCRND/XSUEoMUtZWVkICAgw9TAIIYQQ0gbp6enw9/dv9hgKQolZcnR0BMD9EDs5OZl4NIQQQgjRRWlpKQICAoTn8eZQEErMEr8E7+TkREEoIYQQYmF02UpHiUmEEEIIIcToKAglhBBCCCFGR0EoIYQQQggxOgpCCSGEEEKI0VEQSgghhBBCjI6CUEIIIYQQYnQUhBJCCCGEEKOjIJQQQgghhBgdBaGEEEIIIcToKAglhBBCCCFGR0EoIYQQQggxOgpCCTGy2NhYJCQkNPq5hIQExMbGGndAhBBCiAlQEEqIkUmlUsTExCAhIQFKlQa1ag0ALgCNiYmBVCo18QgJIYQQw5OZegCEdDTR0dEAgJiYGHxz6BZ63DcPA4r3IzZ2MeLj44XPE0IIIe0Zw7Isa+pBEHKn0tJSODs7Q6FQwMnJydTDMYh7576Cv35cCUhlgFqFl956FyuXLTH1sAghhJA2a83zNy3HE2ICtWoNcsImCwEopDJsYQbjvc0XoNHQ60JCCCHtHwWhhJjA0RsFuPH3T4BaBYnUClCrUHJ0HX45kYYV+5JMPTxCCCHE4CgIJcQE3o2Jg+LIWox89HmoVUrEx8dDcWQtSo6uw5f7b+BaTpmph0gIIYQYFCUmEWJkcfHxOPbbl3AeNgsfLokDUD9ZCQA+7uKFb+bcZbIxEkIIIYZGQSghRpZdXAnnYbMQcPds3BXkKnw8OjoaRRVK/HDkJvZczsWV7FJ09W2fSVmEEEIILccTYmQ9pjwFl6GPYnCoO2TS+r+Cn36YgFnPvQEA+Pl4iglGRwghhBgHBaGEGNmxmwUAgGHhHo1+/vHBwQCAzWezUFpda6xhEUIIIUZFQSghRqRSa3A2rQQAMCDErdFj+ge7ItzLAVW1auxIzDbi6AghhBDjoSCUECO6nluOSqUaDtYyhHs5NnoMwzB4oI8fAGA7BaGEEELaKdGDUKVSiby8PKSmpiIvLw+1tbScSAjvXHoJAKBXgDOkEqbJ4+7r2QkAt3SfX1ZjjKERQgghRqV3dvy///6LXbt24cSJE0hMTEROTg7qdgJlGAY+Pj7o1asXBg0ahPHjx2PAgAH63pYQi3Q2rRgA0CfAtdnjAt3t0CvABefTS7DrYjZma/eJEkIIIe1Fm4LQ9PR0fP3111izZg0yMzPrfe7OVvQsyyI7OxvZ2dnYtWsXYmNj4efnh9mzZ2PBggUIDAxs++gJsTAXs0oBAD39nVs89r6evjifXoJt5ykIJYQQ0v60ajk+KSkJs2bNQlhYGD788ENkZGSAZVnhzdraGp06dUKPHj0wdOhQdO/eHb6+vrC2tq53XEZGBj788EN07twZs2bNwvXr1w319RFiNpQqDW7kcZ2QdKn/ObmnLwDgVGoRckurDTo2QgghxNh0mgktLi7Gu+++i2+//RZqtVqY7ezZsydGjRqFQYMGYfDgwQgKCmryGsnJyThx4gROnDiBQ4cO4fz581CpVFi/fj1+//13PPXUU3j//ffh6tr8MiUhlupGXjlq1SwcbWTwd7Vt8fhVny6D7aVMVHV7AHuv5GLWwNu/XwkJCVCr1YiNjTXgiAkhhBDD0SkIjYiIQFFREViWRadOnTBv3jzMmTMHnTt31vlGISEhCAkJwaOPPgoAuHnzJn766Sd8//33yMrKwqpVq/DHH38gLy+vbV8JIWbuSja3FN/V1wkM03RSEk8qleLq9m/hXFKFvZEvCUFoQkICYmJiEB8fb9DxEkIIIYak03J8YWEhwsLC8N133yElJQXx8fGtCkAbExYWhvj4eKSkpOC7775DWFgYCgsL9bomIebssjYIjdKxFWd0dDRefutdKI6sxdYfP0dFjapeAMr3myeEEEIskU4zoV988QWefvppSKVS8Qcgk2Hu3LmYM2cOVq9eLfr1CTEX13O5/aCRPo3XB23Mpx8mYPO5LKTu/gEujr9BVaukAJQQQki7oNNM6LPPPmuQALQuqVSKZ5991qD3IMSUbuaVAwA6eznofA7DMHjyxTcAqQyqWiXkcjkFoIQQQtoF6phEiBFU1KiQpeAy3Dt76h6EAkD6vjWAWgVGagWlUomEhARDDJEQQggxKp3rhH799deYOXMmnJx0289GCLntVn4FAMDDQQ5Xe7nO5yUkJOCbFR/CZfgsOA95FI/I/kVMTAwA0IwoIYQQi6bzTOhzzz0HX19fzJkzBwcOHDDgkAhpf27kc/tBw1oxC1o3Can3lKcAAPc+/iLi4+MRExNDM6KEEEIsWquW46urq7F27Vrcfffd6Ny5M5YuXdqgYxIhpKGbedxMaFgr9oOq1WohCSnCmzvvWm4ZoqOjER8fD7VabZCxEkIIIcagcxA6ceJESCQSoetRcnIyoqOjERwcjEmTJmHjxo1QqVSGHCshFiu1qBIAEOJur/M5sbGxwpJ7pA+3DeZ6DjejGh0dTYXqCSGEWDSdg9C//voLaWlpWLp0KSIiIoRgVK1W4++//8bDDz+MTp064bXXXsPFixcNOWZCLE5aITcTGuhu16bzI725sk58rVFCCCHE0rVqOd7X1xdvv/02rl69isOHD2Pu3LlwcHAQAtLCwkKsXLkSvXr1wsCBA7F69WqUlZUZauyEWIw07UxooFvbgtC+QS4AgItZChRXKMUaFiGEEGIybS7RNHToUHz33XfIycnBd999h+HDhwvBKMuy+O+///Dss8/C19cXjz/+OA4ePCjmuAmxGKXVtSiurAUABLQxCPV1tkUXH0ewLHAoKV/M4RFCCCEmoXedUDs7O8ydOxcHDx5EUlIS3n77bfj5+QnBaGVlJX755ReMGTMG4eHh+OCDD5CVlSXG2AmxCGmF3Cyoh4McDtY6V0VrYFSkFwDgwDUKQgkhhFg+UYvVh4WFYenSpUhLS8OOHTswbdo0yOVyISC9desW3nvvPQQFBWHy5Mn4888/xbw9IWYpXbsU39ZZUN6oSE8AwMHr+dBoWL3HRQghhJiSQTomMQyDCRMm4LfffkNWVhZWrFiB3r1710tm2rlzJx5++GFD3J4Qs5Kq535QXr8gVzhay1BUoURipkKMoRFCCCEmY/C2nW5ubnjppZdw5swZ7Nu3D506dQLDMAAAlqXZHNL+8UlJQXoGoVZSCYZHeAAA9l/N03tchBBCiCkZpXf8vn37MGvWLNx7773Izs42xi0JMRv8nlB9l+MBYFSEdl/oddoXSgghxLIZLAhNSUnB4sWLERwcjHHjxmH9+vWoqqoSluQjIyOxbNkyQ91eNIWFhdi0aRMWLVqE8ePHIyoqCl5eXrCysoKTkxO6dOmCWbNmYfPmzdBoNK269tatWzF9+nQEBwfDxsYGXl5eGDJkCJYvX47SUt3rQVZXV+Onn37C/fffj6CgINjZ2UEul8PLywsjRoxAXFwc0tPTW/ulN+rAgQNgGEbntyeeeEKU+1oyfcsz1TVSuy80MaMEheU1el+PEEIIMRlWRFVVVeyaNWvY0aNHs1KplJVIJKxEImEZhmEZhmEdHBzYefPmsUePHhXztga1fPlyFoBOb3379mWTkpJavGZZWRk7ZcqUZq8VEBDAHj9+vMVrnT17lg0PD29xbDY2NuzKlSv1/n7s379f5+8HAPbxxx9v030UCgULgFUoFHqP2ZSUKjUb+s5fbNDC7Wx2SZUo15y08hAbtHA7u/F0uijXI4QQQsTSmufvtteLqePEiRP44YcfsGHDBqE4PVtnv+egQYPw5JNPYsaMGXBw0L13trmQSqXo1asX7rrrLkRERMDX1xdyuRzFxcU4ffo0NmzYgJKSEpw5cwbDhw/H+fPn4eXl1ei11Go1pk+fjl27dgEAvL29MX/+fERFRaGoqAjr1q3D0aNHkZ6ejkmTJuHo0aPo2rVro9dKT0/HmDFjUFxcDADw8vLCE088gYiICFhbWyMlJQXr1q3D5cuXUV1djZdffhl2dnZ46qmnRPm+zJgxA4888kizxwQGBopyL0uVXVINtYaFXCaBl6O1KNcc08ULl7JKsftSLqb29RflmoQQQojRtTXSzcnJYT/66CO2a9euDWY8GYZhvby82Ndff529fPlyW29hFtLS0tji4uJmjykoKGAHDBggzP4999xzTR779ddfC8dFRUWxOTk5DY55/fXXhWOGDx/e5LWefPJJ4bhx48axFRUVDY7RaDTsokWLhOM8PT3Z2traZr+e5tSdCV28eHGbr9OS9jITevh6Phu0cDs75uP9ol3zUqaCDVq4nY14dwdbVt32/0tCCCFEbK15/m7VnlC1Wo1NmzZhypQpCAgIwNtvv41r164J+zylUikmTZqEP/74A5mZmfj444+bnMWzFAEBAXBxcWn2GHd3d3z11VfC+9u2bWv0OLVajbi4OOH9NWvWwNvbu8Fxy5YtQ+/evQEAhw8fxu7duxu9Hj+bCgCffvop7Owa7jlkGAbx8fHCffLz83H16tVmvx4inoxibj+ov6v++0F5XX0dEeJhjxqVBvuu5Ip2XUIIIcSYdA5CX3vtNXTq1AnTpk3DX3/9BZVKJQSfoaGhWLJkCVJTU7F9+3ZMnToVMpkoK/0Wo1u3bsLjnJycRo85dOiQUB1g5MiR6Nu3b6PHSaVSvPTSS8L769ata/S4vLzbZXrCw8ObHJtUKkVoaKjwfnl5eZPHEnFlK6oBAJ1cbES7JsMwmNzDFwDwVyJVmyCEEGKZdA5CV6xYgYKCAiHwtLGxwaxZs/DPP//gxo0bWLRoETp16mTIsZq1GzduCI99fHwaPWbnzp3C40mTJjV7vYkTJzZ6Xl11951ev369yWup1WrcvHkTACCTyRAZGdnsvYl4shVVALje72Ka3JMLQg9cz0dZda2o1yaEEEKMoVXL8SzLom/fvvjiiy+QnZ2NNWvWYNSoUQYamuUoLy/Hiy++KLw/bdq0Ro+7cOGC8Lh///7NXtPHxwcBAQEAgNzcXOTnN6wL+cADDwiPX331VVRWVjY4hmVZREdHC7Om8+bNg6ura7P31tXGjRvRu3dvODk5wcbGBp06dcK4ceOwfPlyFBUViXIPS8fPhPo6izcTCgBdfBwR6mkPpUqDnRcbn3knhBBCzJnOa+YvvPACnnzySfTq1cuQ4zFreXl5OHbsGABAo9FAoVAgMTER69evF5bg+/Xrh9jY2EbPv3btmvA4JCSkxfuFhIQI9T2vXbsGT0/Pep+PjY3F7t27kZSUhD179iAkJARz585FREQE5HI5UlNTsW7dOly6dAkAMGfOHKxcubLVX3dTLl68WO/97OxsZGdnY8+ePYiPj8fKlSsxb9480e5niW4vx4s7E8owDKb188dHu67hlxOpePiuAFGvTwghhBiazkHoZ599ZshxWIQzZ87gwQcfbPRznp6emDt3LuLi4mBj0/isV0lJifDYw8Ojxfu5u7s3em7da5w8eRLPPfcc/vjjD+Tl5TXaAOCee+7BokWLMHr06BbvqQuGYdC3b1+MGjUKXbt2hbOzM8rLy5GYmIjffvsNmZmZKC8vx5NPPom8vDy8/fbbLV6zpqYGNTW3i6+3pli/uWJZFtkl3HK8j8gzoQAw464ArNiThMQMBc6nl6BXgIvo9yCEEEIMRfTsoYyMDFy+fBlFRUVQKpWYM2eO2LcwSyNGjMCIESOaDECB+glBzR3Hs7W9PXvG11+9k6urK5YtWwZPT098/vnnjR7zzz//gGEYuLq6Cln3bRUZGYmrV68iIiKi0c9/+OGHWLhwIVasWAEAWLRoEUaNGoVBgwY1e90PPvigXuWA9qC0WoUKpRoA0EnkPaEA4O5gjck9fbHpbCZ+Pp6KTygIJYQQYkFEa9v5/fffo1u3bggKCsLEiRMxa9YszJ07t8Fx77//PsaNG4cnn3xSlPuOGjWqVW0km3tbv359s/eaMGGCkJilUqmQnZ2NzZs34+6778bGjRtx7733YubMmY3uzTSUjz/+GKGhofj8888xe/ZsHDt2DGVlZaiursbly5cRGxsLuVyOPXv2YPjw4fXKOrWFr69vkwEoAMjlcnz66aeYPXs2AG42MCEhocXrvvPOO1AoFMKbWG1GTSlHuxTvYmcFW7nUIPeYPTgIALAtMQv5ZdTGkxBCiOXQOwitqqrC5MmTMX/+fFy9elUI0tg6HZPquuuuu7B37178+OOPuHLlir63NxmpVAofHx/cf//92Lt3L9555x0AXDmlpjoS1e0WVV1d3eI9qqqqhMeOjo4NPh8TE4M333wTarUay5cvx88//4zBgwfDwcEB1tbW6Nq1KxYvXoy9e/dCLpejvLwcjzzySKNJTmJbunQpGIYBAOzbt6/e19IYa2trODk51XuzdFnazHgfJ/GX4nl9AlzQO8AFSpUGXx640fIJhBBCiJnQezl+zpw5Qgmh4OBgPProoyguLsbXX3/d6PFjx46Fp6cnCgoKsH37dr2L2U+bNk3vJWaePqWLEhIS8McffyApKQnr1q1DTEwMunTpUu8YFxcXocVmQUFBiy1MCwsL651bV1ZWFj788ENh3K+//nqT1xk6dCjmzJmDb7/9FgqFAj/88APeeuut1nx5rebv74/OnTsjKSkJNTU1SE5ORlRUlEHvaW5yDJSUVBfDMHh9XARmf/cv1p5IQ9GhtfBwskV0dHSDYxMSEqBWq5tMnCOEEEKMSa8gdN++fdi4cSMYhsEjjzyCH3/8EVZWVtiyZUuTQahEIsHYsWPx66+/4siRI3jzzTf1GQJeeOEFvc4Xi1Qqxbhx45CUlAQAOHDgQIMgNDIyEsnJyQCA5ORkBAcHN3tN/lj+3Lp2796N2lquPuQ999wjzDo2Zdy4cfj2228BACdPnmz5CxKBp6en8P1oLLGqveOTksQuz3SnYZ09MDLCEwev52PftQJc2vYNANQLRBMSEhATE4P4+HiDjoUQQgjRlV7L8T/++CMAIDQ0VAhAdcGXebLk5fjG1F0y52c86+rRo4fw+NSpU81eKzc3V9gX6eXl1aA8U1ZWlvDY2dm5xbHVnUk1VsekgoKCRu/fUWQZYSYU4GZDE+7vDlsrKcqj7sc9j72ImJgYYS9u3QC0sRlSQgghxBT0CkKPHj0KhmEwZ84cnQNQAEJnpabaW1oqftYPQIOgEeASm3hNdUHi7dixQ3jcWHelugGvLkk8qampwuO6pZ8MJTMzU/h+WFtbtzjr2x7xy/GG3BPKC3S3w4cPcS9ykvzG4+5ZLyAmJgbW1tYUgBJCCDFLegWhubm5AFq/l5IvT6RLco6lSEtLqxdYDh06tMExI0eOFFp6HjhwAGfOnGn0Wmq1ul5d1kceeaTBMXVnVbdv395iXc21a9cKjwcMGNDssWKIjo4WktNGjx4NOzs7g9/T3PCJSb4i9o1vzv29/fDORG4LyA3/CWCkVlAqlZDL5RSAEkIIMTt6BaFSKVd2RqPRtOo8vqWjuS/R5uTkIC4ursUWlNevX8ekSZOE0kyjR49uNOFKKpUiJiZGeH/OnDlCO8263n77bZw7dw4AF8yOHz++wTFDhw5FYGAgAG7p/9FHH0VFRUWD41iWxbvvvosDBw4A4GqPPvzww41+HcHBwUK5Kv74um7cuIGPPvqo2YC3trYWb731Fn744QfhYx0xAOIK1WuX4w1QI7QpC0aG4ctZfVF2fD1YdS2kMi4Q1aVMFiGEEGJMeiUmeXt749atW7hxo3WlYU6fPg0AQm90c1VdXY3Y2FgsWbIEo0aNwoABAxAWFgYnJycolUpkZGTg8OHD+Pvvv4UkIT8/PyEBqDHz58/Hpk2bsGfPHly6dAm9evXC/PnzERUVhaKiIqxbtw5HjhwBwAXpq1atavQ6VlZW+Pzzz/Hggw9Co9Fgx44diIiIwOzZs9GjRw9YWVnh1q1b2LBhgxDQAlzpJH47RGuVl5dj4cKFiImJwZgxY9C/f3+EhITA0dER5eXluHDhAn777bd62wPef/99DBkypE33s2SlVSpU1XKF6g3RLak5pzd/i6JDv8B52Cz0uG8extUcFV78dMQXBIQQQswUq4c5c+awDMOw/fr1q/fxzZs3swzDsBKJpME55eXlrJubGyuRSNiXXnpJn9sbXHJyMgtA57dx48axKSkpLV63tLSUvffee5u9lr+/P3v06NEWr/Xbb7+xrq6uLY7N2tqa/fTTT5u9VlBQkHD8/v37G3z+7NmzOn8vnJyc2O+++67F8TdFoVCwAFiFQtHma5jSlWwFG7RwO9s77m+j3jc+Pp4FwL4bs5gNfns7G7RwO5urqBI+Hh8fb9TxEEII6Vha8/yt10zo9OnTsWbNGpw9exbff/895s2b1+I5zz77LIqLi8EwDGbNmqXP7Q0uODgY58+fx969e3Hy5ElcvnwZGRkZKCsrg5WVFZydnREeHo4BAwZgxowZOu+1dHR0xLZt27Blyxb8/PPPOHXqFPLy8uDo6IiwsDBMnToVCxYs0Cnrffr06bj77ruxZs0a7Nq1C4mJiSgqKoJarYaLiwu6du2K0aNH48knn9R75rlr167YtWsXTp48iZMnTyIlJQUFBQUoLi6GtbU1PDw80KtXL4wdOxazZ89uFwXn2yqvlOte5OVo3FlQtVotJCH9t+IQruaU4ffTGVj07nvC5wkhhBBzwLBsE62NdDRkyBCcOHECMpkMcXFxePHFF7Fv3z48+OCDYBhGeNI7e/Ys3nvvPaFt5MSJE7F9+3b9vwLSLpWWlsLZ2RkKhcIig9k/Tmfgjd/PY3i4B9Y8OdAkY/ho11V8eeAmACDU0x5PDQvF1L5+sLEyTAtRQgghpDXP33oHoenp6Rg4cCBycnLAMAysra3h7e2N1NRUMAyDvn37IiMjQ0jAYVkWgYGB+O+//+Dh4aHPrUk7ZulB6FcHbmLZrquY2tcP//dwb5OMoUalxjeHbuGbw8lQVHF7lt3t5Zg3LARPDguhYJQQQojoWvP8rXfv+ICAAJw8eRKDBg0Cy7Korq5GWlqa0MHnzJkzyM3NFfrJDxw4EMeOHaMAlLRreWVcZryxl+PrspZJ8cKYcBxZOBrvTe4KPxdbFFYosfzva5jyvyO4mW+cpgWEEEJIY/QOQgEuED127Bi2bNmCqVOnwt3dXQg6WZaFg4MDJk+ejN9++w3Hjx9vc3Y2IZYir4zfE2pt4pEAjjZWeGp4KA6+OQqfzugFDwdrXM8tx/Svj+NKdvP1ZQkhhBBD0Ssx6U733Xcf7rvvPgBAZWUlSkpK4ODgYJHLqYToI59PTHIyfRDKk0kleLCPP4Z29sBTP/2HxAwFxj72Ah4bHIIPl8Q1OD4hIQFqtRqxsbHGHywhhJB2T5SZ0MbY2dmhU6dOFICSDskcluOb4uVogzVPDkRnLweUKzVY9n484uPj6x3D95vnG1IQQgghYhN1JpQQwjGn5fjGONta4evH+mFyEdfla/HixWAYBtHR0UIASv3mCSGEGBIFoYSIrLxGhUolV5rMnJbj79TZywGvjo3Ah6pH4WAtQ0xMDJYsWQKlUkkBKCGEEIPTaTn+zTffhEKhMOhA8vLy8Morrxj0HoQYQ14ptxTvYC2Dndy8X+fNHRqMADdbyO6aDpkV12deLpdTAEoIIcTgdApCP/nkE4SFhSEuLg7FxcWiDqCwsBALFy5EaGgoPv/8c1GvTYgpmPtSfF3WMileGhOOkqProKqthVwuh1KpREJCgqmHRgghpJ3TKQiNjIxEUVER4uPj4e/vj7lz52L//v1oa517tVqNrVu3Ytq0afD398fHH3+MyspKREZGtul6hJgTPgj1sIAgFAAu/fUDFEfWwnnYLPxy9Abi4+MRExNDgSghhBCD0mmt8MKFC/i///s/fPDBB1AoFPj555/x888/w93dHUOHDsWgQYMwcOBAdOnSBW5ubpDL5cK5SqUSRUVFuHLlitBz/MiRIygqKgLAdVBydnbGokWL8OqrrxrmqyTEiPjleEuYCU1ISEBc7GJMnvsyLnqNxa//pmGTdik+JiYGAGhpnhBCiEHoFITKZDK89dZbmD9/PpYvX46vv/4aJSUlKCgowNatW7F169Z6x9vZ2cHR0RGlpaWoqqpqcD1+BtXV1RXPPfccXn/9dbi4uOj/1RBiBvKF5XjzK890J7Vajfj4eDzzylsY/ME+nE0rwY28MiHwVKvVJh4hIYSQ9qpNveMrKirwyy+/4KeffsKJEycavzDDNLpczzAMhg4dijlz5mDmzJmws7Nr/ahJu2fJveNf3XAOm85m4u2JXfDMyDBTD0dns749gaM3CrH0wR6YOTDQ1MMhhBBigVrz/N2m1F17e3ssWLAACxYsQE5ODv7++2+cPHkSFy5cQEpKCoqKilBTUwMbGxu4u7sjJCQEPXr0wKBBgzBu3Dh4eXm16QsjxBLcLlRv/svxdfUJcMXRG4U4m1ZMQSghhBCD07t+jI+PDx5//HE8/vjjYoyHEIuXV2o5y/F19Q1yAQCcTS8x6TgIIYR0DAZr20lIR5Vfbn5943XRO8AVAHAjrxwllUoTj4YQQkh7R0EoISJSqjQoqawFAHg6WFYQ6mYvR2cvBwDAsZuFJh4NIYSQ9o6CUEJEVFTBzSBKJQycba1MPJrWGxnhCQA4eC3fxCMhhBDS3lEQSoiICrRL8e72ckgkjIlH03qjIrVB6PX8NjejIIQQQnRBQSghIhKCUAtbiuf1D3aDjZUEOaXVuJ5bburhEEIIaccoCCVERIXl3HK8h4O8hSPNk42VFIND3QEAB67lmXg0hBBC2jMKQgkRET8T6mGhM6FAnX2h12lfKCGEEMOhIJQQERVWWPZMKACM0Aah/6UUo7qW2nYSQggxDApCCRFRQZll7wkFgBAPe3g6WkOp1uA8Fa4nhBBiIBSEEiKi/DrZ8ZaKYRgMCHYDAJxKKTLxaAghhLRXFIQSIiIhMcnC+sbfaUAIF4SeTKYglBBCiGFQEEqIiITEJHvLDkL7a2dCz6QWQ6XWmHg0pCOIjY1FQkJCo59LSEhAbGyscQdECDE4vYLQRYsWISUlRaShEGLZNBpW6Jjk4Wi5y/EAEOnjCEcbGSqUalzJLjP1cEgHIJVKERMT0yAQXfDaIsTExOBchgJl1bUmGh0hxBD0CkI//PBDdO7cGRMmTMDmzZuhVlMmLem4FFW1UGm4LkNuFrwnFODajvKzoSeTqY88Mbzo6GjEx8fXC0Qnz30Fqz/9AM7DZuGcxz2Y/NkRZJZUmXikhBCx6L0cr9FosGfPHjz00EMIDAxETEwM0tLSxBgbIRalsIJbineykcFaJjXxaPTXn5KTiJHVDUSt5NbY8eNKOA+bhenzX0EnZxukFVXihV/PoJa2iBDSLugVhP7www8YPHgwWJYFy7LIzs7G+++/j7CwMNx7773Ytm0bNBr6Y0E6hvwyvkaoZe8H5d0V7AoAOEdlmogRRUdHQy6XQ1WrBKQyvPn2Inwz5y5sWDAYTjYynE0rwR+nM0w9TEKICPQKQh9//HEcPXoUiYmJeP755+Hi4gKWZaFWq7Fz50488MADCAoKQlxcHDIy6I8Gad/4mdD2EoR27+QMqYRBbmkNshW0BEqMIyEhAUolF4BCrYLy1O8AgAA3O7xyTwQAYOXeJNSoaPsXIZZOlOz47t274/PPP0dWVha+//57DBo0SJgdzczMRHx8PEJCQnD//fdjx44dYFlWjNsSYlZuF6q37P2gPFu5FJHejgBAReuJUSQkJCAmJgYjH30eQW9sxuiZLyA+7nbW/MyBgfBytEZOaTV2X8o18WgJIfoStUSTjY0NnnjiCRw7dgyJiYl47rnn4OzsLMyObt++Hffddx+Cg4OxZMkSZGVliXl7QkzqdsvO9jETCgC9AlwAAGcpCCUGxgeg8fHxsB80AwDw+sJF9ZKVbKykeKR/AABg3b+Ue0CIpTNYndDu3bvjf//7H7KysvDdd99h4MCBwuxoeno6Fi9ejODgYEydOhV79uwx1DAIMRq+Rmh7mQkFgN4BzgBoJpQYnlqtRnx8PF596x1cyS4FwO1L5pOV+OorMwYEgmGAYzcLaZsIIRbO4MXqbW1tMXfuXOzduxcvvPACAK4tIACoVCps2bIFEyZMQPfu3bFp0yZDD4cQgykob38zob0DuOSkCxkKqDW0jYYYTmxsLKKjo3H0RgE0LBDgZgtvJxsAXLISX6zez8UWdwVxP5e7LuaYariEEBEYPAg9d+4cnn32Wfj5+eGLL74AwzBgWRYMwyA8PFyYHb1y5QqmTZuGWbNmUb1RYpEK20Hf+Dt19nKAvVyKCqUaN/LKTT0c0gFsPc9t05rQzafJYyZ09wUA7LxAQSghlswgQWhlZSW+/fZbDBgwAP369cPq1atRWloKlmXh7u6Ot956C0lJSbh27RrOnj2L+fPnQy6Xg2VZrF+/HqtWrTLEsAgxqJJKrpuLpReqr0sqYdDDn1uSP5debOLRkPauUqnCvitcwtGUXn5NHjehOxeg/pdaBEUldVEixFKJGoSePXsWzzzzDHx9fbFgwQKcPn1amOkcMmQI1qxZg4yMDHz44YcICQkBAPTq1QurVq1CYmIiAgMDwbIsvvnmGzGHRYhRFFVyy/HtKQgFgF7+LgCA8xkK0w6EtHvHbxaiulYDf1dbdPdzavI4PxdbdPZygIYFjtwoMOIICSFi0jsIraiowDfffIP+/fvjrrvuwjfffIOysjKwLAt7e3ssWLAA58+fx5EjRzBr1izI5Y0/QYeHh+ONN94AANy8eVPfYRFiVCq1BooqbkbGxa59BaHd/biZ0EtZpSYeCWnvDl3PBwCMiPAUcgeaMjLCs945hBDLI9Pn5AULFmD9+vUoL+f2ivH1P7t3745nn30Ws2fPhoODg87XCwsLA8AFtoRYEkVVLfjyty52VqYdjMi6deJmpK5ml0Kl1kAmNfhWctJBHUriZjVHhHu2eOyICE98dyQZR2/STCghlkqvIPSbb74REo3kcjkeeughPPvssxg2bFibrieR0JMbsUzF2n1pTjYyWLWzIC3Y3V5ITrpVUIEIbQF7QsSUXlSJ5IIKSCUMhnR2b/H4fkGukDBARnEVckurhUx6Qojl0PvZMjAwEEuXLkV6ejrWrl3b5gAUAMaPHw+NRkPZ8cTiFGv3g7q2s/2gACCRMOjqy82GXsykfaHEMA4lccvqfQNd4GTT8mqCg7VM+Ln8L4WS5gixRHoFodu3b8etW7fw9ttvw9Oz5eUTQtqrIm23JNd2th+UR/tCiaEJ+0F1WIrn8fVCT6UUGWRMhBDD0isInTRpUoubxwnpCIor2mdmPC9Kuy/0UhbNhBLxaTQsjt8sBAAMj9A9CO0X7AYAOJ1KM6GEWKL2tXmNEBPh94S215nQbkIQWiokIBIilhv55SitVsFOLkX3Tk2XZroTPxN6ObsUFTUqQw2PEGIgFIQSIgJhT2g7y4znhXs5Qi6VoKxahfQi6tdNxHVGO5PZ09+5VdUXOrnYws/FFmoNi3PpJQYaHSHEUPTKjg8NDW3TeRKJBI6OjnBzc0OvXr0wevRoTJ48mbLjicUS9oS20+V4uUyCCB8HXMwsxaUsBQLd7Uw9JNKO8Mvp/bQzm63RL8gVmSVVOJVShKGdPcQeGiHEgPQKQlNSUoQSTby6e0T5HvF137/zuAMHDmDlypUIDAzE6tWrMXbsWH2GRIhJlLTTbkl1dfN1xsXMUlzMUmBiD19TD4e0I2fSuCC0b2DbgtCt57OQSB29CLE4ek09BgYGIjAwEH5+fkJQybfpdHZ2hp+fH5ydnYWPAVzw6efnh06dOsHGxkb4XGpqKiZOnIg//vhD/6+KECNr79nxAIQ2ipQhT8RUUqnEzXyuQUmfNgSh/M8llQ8jxPLoFYSmpKTg6NGjCA4OBsuyGDZsGDZu3IiioiIUFRUhPT1dePzHH39g2LBhYFkWwcHB+Pfff1FRUYHExETMnz8fAKDRaDBv3jwUFhaK8sURYiy3E5Pa555QAIjqRGWaiPjOppUAAEI97Nu0ktDV1wkMA+SV1SCvtFrk0YnjWk4Z1hxPESoAEEI4egWhNTU1uPfee3Hs2DFER0fj0KFDePDBB+Hi4lLvOBcXF0ydOhWHDh3Cu+++i6NHj+Lee++FUqlE9+7dsWrVKnz++ecAuJadq1at0mdYhBhdUTsv0QQAXX0dwTBAvhk/2RPLwy/Ft2UWFADs5DKEeXLtoc3xBdJ3R5IxceUhRG+5hEe/OYF3N12gChOEaOkVhK5atQrnzp3DoEGDEBcXp9M5CQkJGDRoEM6dO1cv2Hz++efRu3dvAMCePXv0GRYhRqVSa1BarZ0JbcdBqJ1chlAPewDm+WRPLBM/E9o3yKXN1+DLOpnbkvyRpAIs+esyNCwQ7uUAhgHWnkzD2pNpph4auUOtWoM9l3Px23/pSC+qNPVwOgy9gtB169aBYRg88sgjrTrvkUceAcuyWLduXb2PP/DAA2BZFlevXtVnWIQYlaKqFvzEhott+12OByC0SbyaU2bikZD2gGVZXNAGjr38Xdp8Hb6j10Uzaqag1rCI23YJLAs80j8Ae14bifcmRwEAPthxRWhwQUwvR1GNyZ8dxvyf/8NbfyTi7v87iJ+Pp5h6WB2CXkHojRs3AAC+vq3LlOWPT0pKqvfxzp07AwCKi6n7BbEcfI1QJxtZq2ocWqLbQSjNhBL9ZRRXQVFVCyspg3BvhzZfp5t2v/LFTPP5udyemIWkvHI421rhnUldAQBzhwQjytcJFUo1fqIgxyzUqNR4/Pt/cT23HC52Vujq6wSlSoOYLZew6WyGqYfX7un1jFlRwWU0ZmVlteq87OxsAEBlZf0pb2trawCAjY2NPsMixKiKKril+Pa8H5TXxccRAHA1m2ZCif74NrAR3o6wlknbfB2+rWxmSZXZzDCuPcEtuc8bGgJn7QqJRMLgudFhAICfj6eiVq0x2fgI56sDN3Ettwzu9nJse2EYdrw0DAtGcDXQ39t0EZkl1JzDkPQKQgMCAgCgwbJ6S/jj/f396328oKAAAODu7q7PsAgxKqFbUkcIQrUzoTfzy6FU0RMo0Q8/c9ldO5PZVs62VgjSNlAwh/3KN/PL8W9KESQMMKN/QL3PTejmA09HaxRVKHHwWr6JRkgAQFFZi28O3QIALJ7SDQFudmAYBgsndMFdQa6oUKrx/l+XTTzK9k2vIHT8+PFgWRb//vsv3n33XZ3OWbRoEU6ePAmGYTBhwoR6n0tMTATQ+uV9QkypuAPUCOV1craBo40MKg2Lm/nlph4OsXD8Hk6+1qc+umlnQy9nm35f6JZz3OrgyAhP+DjXX9mTSSW4v1cnAMCftNxrUj8fT0GFUo0uPo64r+ftuEMiYfD+gz3AMMCOCzm4QI0QDEavIPSNN96AvT2XLfvhhx9ixIgR+PPPP1FUVFTvuKKiImzcuBHDhw/HsmXLAAB2dnZ4/fXX6x23c+dOMAyDAQMG6DMsQoyqqLLjBKEMw6CrD+0LJfpjWVbIZucTi/QR6c39XF7LMf2Lo92XcgAAk3t2avTz9/f2AwDsv5qP6lq10cZFbtNoWKw/lQ4AeHpEaL3ujgAQ6eOIB7T/T18fumn08XUUendM+uGHHyCVcnt5jh49iunTp8PT0xOurq7w8/ODq6srPD098fDDD+PYsWNgWRYymQw//vgjAgMDhWsdOnQIeXl5sLOzw/3336/fV0WIEZVU8ntC23dmPK+LL+0LNUdKlQaphRWoUVlGUJNXVoOCciWkEkZIeNNHpA+X2HQ917Q/l2mFlbiaUwaphMHdXbwaPaa7nxN8nGxQVaumAvYmciK5EJklVXC0kWFSE22I5w/n9ob+fTEHuVQb2SD0TuWdNm0adu/ejZCQEKEFJ8uyUCgUyMnJgUKhqPfxsLAw7NmzBw899FC964wYMQLl5eUoKyvDyJEj9R0WIUYjtOzsAHtCAaCLdib0CpVpMhsHruVhxEf7MXL5AQxcug+7Lmabekgt4mdBO3s6wMaq7UlJvAhv7sVRUl4Z1BrTFYPffy0PANA/2LXJvwkMw+DurlyAuvdKrtHGRm7bqt0ycW9P3yZ//qI6OaF/sCtUGha/Um1XgxClnsyoUaNw7do1bNy4EbNnz0aXLl3g5OQEiUQCJycndOnSBbNnz8Yff/yBq1evUpBJ2pWOtCc0NjYWh3/7GgBwNbv+cnxCQgJiY2NNMKqO7UKGAs/8cho52pmakspaPLv2DI4kFZh4ZM3jk5K6ibAfFACC3O0hl0lQXasxabHxw9rv+4gIz2aPGx3JBaHHaCbU6DQaVgj+J/dofMsEb/bgYADAr/+mUTKmAYhW1FAqleLBBx/ETz/9hMuXL6OkpAS1tbUoKSnB5cuX8dNPP2Hq1KnC0j0h7UVH2hMqlUrx9f99gJKj65BXVoPC8hoAXAAaExNDv99GptGwWLTpAqprNRgV6YlLceMxtY8fWBZ49bdzqKhRmXqITeL3FEeJsBQPAFIJg3Avbkn+momW5FVqDU7c4oLKYZ09mj22f4gbGAZILqigNrhGdi6jBAXlSjhayzAgxK3ZY/lqBvllNdhHs9ai0ysIHTNmDMaMGYOYmBixxkOIxbm9J7T9B6HR0dGIj4+H4shalBxdh2s5ZUIAGh8fj+joaFMPsUPZeTEHFzIVcLCW4ZPpvWBvLcPSqT0Q7G6H/LIafHs42dRDbNI17XaOSG3tWTFEapfkr5toq0hipgLlNSo421oJBfSb4mxrJST5nUguavZYIq79V7ktEyMjPSGXNR8GyWUSPNSXKyfJVz0g4tErCD148CAOHjwIL6/GN18T0hEIe0LtOkZiUnR0NO6augCKI2sxMsqPAlAT+vEYF2TOGxoMdwdtsw8rKV4fFwkA+PbILVQqzW82tLpWjZRCrtmJmEFohPZappoJPZPKdfvrH+wKqYRp4WhgYCg3C/dvMi3JGxM/Wz08vPnZat4UbUmtf67lobS61mDj6oj0CkI9PLj/QB8fH1EGQ4ilUak1UFRxf5Q6SmISAMx85jVAKoOqVgm5XE4BqAncyCvDqZRiSCUMZg4Mqve5yT18Eehmh7JqlVnO3tzIK4eG5V64eWqDZzHwM6FJuaYp03Q2rQQA0CfQVafjB4ZwjVlO3qKZUGOprlXjfDqXFMd//1vS1dcRnb0coFRp8PfFHEMOr8PRKwgNDeXKF+Tm0j4J0rHExsYiISFBCEABwEXbmq8jJOic3fItoFZBIrOCUqlEQkKCqYfU4fDB5ejIhgXRJRIGcwZzgenak6lGH1tLrtZZir+zPqM++JlQU3X0OpvGzYT2CXTR6Xh+P2JSXrmwv5oY1pm0YijVGng7WQtdtlrCMIzQYGDrefN7UWfJ9ApCH3jgAbAsi+3bt4s1HkIsglQqRUxMDBKWcMGXs60VZFJJh0jQSUhIwJovlsN52Cx0XrgFsXFx3PeCAlGj+lsoiN54jcOpff0hkzC4mFlqdt2trmmTkvhyX2Lp5GwDB2uuoxe/3G8sOYpqZCmqIWGAXv4uOp3jZi8XZm//pX2hRsHPOg8IcW/VC6D7tEHo0RsFyC+jFwxi0SsIfeaZZxAQEIDdu3dj/fr1Yo2JELPHJ+isXPY+So6ug6udVYdI0OG/xti4OHiNmIUalQbzXngD8fHxFIgaUUpBBa7nlkMmYTAm0rvRY9zs5cKeN3Nbkr9qgKQkgJuxivDWZsgbOTnpjHYWNNLHCfbWMp3P4/eF/qfdT0oM66R2/+3AFrLi7xTsYY8efs7QsMCey7T6Kxa9glBnZ2ds2bIF/v7+mDNnDl5//XWkpKSINDRCzFt0dDRmP/8mFEfW4vCi8e0+AAUAtVqN+Ph4LI6JQYgH17L3Rn65EJSr1ZbRrcfSHdAWRB8Q4gbnZhLi+Nkbc3vS5LsaiR2E1r2msTsn8UvxfXVciufxs6aJGSXiDog0UKNSC/t2B4W2LggFgAndufyXnRbQDMJS6P5yrRFjxowBwAWj6enpWLFiBVasWIFOnTrB398ftra2zZ7PMAz27dunzxAIMalJc17Amq8/hUZV2yESdOrudQ3zsse13DLczCvH6Eivdv+1m5Oj2gLnw1rI7h0d6QWGAa5klyJHUd1g76gplFQqkVvKLWfyXY7ExF/T+DOhJQB0T0ri9QrgSjldzCyFWsPqlFVP2iYxQ4EalQYeDnKEeTq0+vyJ3X2w/O9rOH6zEIrK2mZfABLd6BWEHjhwQNhTwf/LsiyysrKQldX88g/LsqJuSCfEFNZ+/X+AWgVpnQSdjhKM8X/Eb+Ybd+9dR1e3IPrQsOaDUFd7OXoHuOBsWgkOXMvDIwMCjTHEZvFL8f6utnBoxbK1roRaoUacCVWqNLigbUPa2pnQEA8H2MulqFCqcSOv3CCzw4RzPr0EANA30LVN8UeopwMivR1xLbcMe67kYlo/f5FH2PHo3TGpbl94lmUb/Vhjb4RYuoSEBGz/YSWch81C3OZzHW5f5O0g1LySXtojvhoDwAVxZdUqONrI0N3PucVqDHx7SL6nuanxM5RdDBRs8RnyqUWVqFIabntI3f+Ty9mlUKo0cLGzQoiHfasqZEglDLr7cbOhtCRvWPwLhR5+zTcSaA6/JL+LSjWJQq8gVKPR6PVG+8eIpeITdIY8/Bxchj4KV3u5sC+yowSifBB6i4JQgxOqMSQk4EYe9/2O8nXC0veXtFiNgQ9CjyQVmEXva0MlJfE8HKzhZi8Hy0L4XhlC3f8ToTRTgAuWLGn5/+ROPf35IFRhkLESDh+EdvdvexA6sQcXhB5Kyke5GbfFtRTir4W0M4WFhTh06BBOnTqF06dPIz09HQUFBSguLoatrS06deqEfv36Yfr06ZgyZQokEt3j+q1bt2LNmjU4deoUcnJy4OTkhM6dO+PBBx/EggUL4OSkW/mS8vJyfPfdd9i+fTsuXLiA4uJiODk5ISQkBFOmTMH8+fPh7d14Bq0+bty4gVWrVmHnzp1IT0+HWq2Gn58f7rnnHsyfPx+9e/cW/Z7mgk/QSQmYgMyreXDT9o3nl+I7wgusUE8uMamgXEn7owyM/7mKiYnBhBsFgO84ZO3/Bb9t+LLFZLhunZzg4WCNgvIa/JdShCEt9DQ3NH6Z3BD7QXnhXg44mVyE67ll6KFHwNGcuv8nAxOzgbDJyDv0K378cWWrExR7UnKSwZVV1yK5gNs6pM9MaKS3I0I87JFcUIH9V/OE5D/SRixp1vLly1kAOr317duXTUpKavGaZWVl7JQpU5q9VkBAAHv8+PEWr/XPP/+w3t7ezV7Lzc2N3bhxoxjfDsGqVatYW1vbJu8plUrZuLi4Nl9foVCwAFiFQiHiqMX3wBdH2KCF29mdF7JNPRSTGLR0Lxu0cDt7OrXI1EPpEOLj47nfMamMBcDGx8frdN7rv51jgxZuZ5fuuGzgETZPo9Gw3WN2sUELt7NXs0sNdp/3Nl1ggxZuZz/YccVg9+C19f+krpSCcjZo4XY2fNEOtqZWbYBRkuM3C9ighdvZQUv36n2tD3ZcYYMWbmef++W0CCNrf1rz/K33ntCOQCqVom/fvnj66afx8ccfY+3atfj999+xevVqLFiwAC4uLgCAM2fOYPjw4cjLa3rvlVqtxvTp07F161YAgLe3N9577z38+uuv+N///oehQ4cCANLT0zFp0iRcuXKlyWsdPnwYEyZMEDpW9enTBx999BE2bNiA1atXY/r06ZBIJCgqKsKMGTOwc+dOUb4fv/zyCxYsWICqqipIJBLMnDkT3333HX766Sc8/fTTsLa2hlqtxuLFi7Fs2TJR7mmuirV94906UMvOuoR9oQZc9iS3RUdHQyKzAtQqyKx0r8YwOJRrT2jqguiZJVUoq1HBSsoIM+mGEK6tFZpkhOSkF19fCEhlgFrV5goZgW52cLa1glKtMXpWf0dxkV+K12MWlDdRuy90/7U8VNe2/1UvgxIz+s3KymLXrFnDvvPOO+yCBQvYefPmiXl5k0hLS2OLi4ubPaagoIAdMGCAMAv43HPPNXns119/LRwXFRXF5uTkNDjm9ddfF44ZPnx4o9epqalhg4ODheNeeeUVVqPRNDhuz549rLW1NQuA9fb2ZktL9Zt9yMvLY52cnFgArEQiYbds2dLgmOPHj7N2dnYsAFYmk7FXr15t9X0sZSa0Z+zfbNDC7WxSruFmdcxZzGbjzTiRts+6pRdVsEELt7Nh7/zFVtTUGniUTdt7OYcNWridHf/pQYPe59gNbtZr2LJ9Br0Py7Ls/FfeZgGwjNSqzTOhLMuys745wQYt3M7+ejJV5BESlmXZl9adYYMWbmc/23td72tpNBp2yAf72KCF29m/L3bMVbDmGH0mtLCwEHPmzEFQUBAef/xxLFu2DKtXr8aPP/7Y4NhnnnkGcrkcYWFhYtza4AICAoSZzqa4u7vjq6++Et7ftm1bo8ep1WrExcUJ769Zs6bRvZrLli0T9lMePnwYu3fvbnDM5s2bhcYAffr0wSeffNJoyYl77rkH7777LgAgNzcXK1asaPZracnHH3+M0lKu5d7zzz+PKVOmNDhm0KBBQmKOSqWq9zW3Jyq1Rugd72rXQWdCvbgZJ0MmgBAOnwznPGwWgt7YjOjFsTonwfm72sHPxRYqDYszqSWGH2wTrhmwSH1dfNek9KIqVCoNlzySkJCAb1Z8COdhs/Dk98f0Skzs6st9T65ml4o9TAJxkpJ4DMNgfDfKkheD3kFocnIy+vTpg7Vr10KlUrVYgunZZ5+FSqVCSkoKDh06pO/tzUa3bt2Exzk5jf9QHjp0CNnZXKeFkSNHom/fvo0eJ5VK8dJLLwnvr1u3rsExdYv8z5kzp9mEqLlz5wqP165d2+RxutiwYYPw+NVXX23yuPnz58Penltu27p1K6qqqvS6rzkq0QagANc7viPqTGWajIIPQJ96+W24DH0Ufi62iI9d3Kqgh29T+K+2baEp8EvNhkxKAgB3B2u4a7fI3MwzTB1b/v9kqLZCRldfJ70qZHTx4RJRr1jIcrxGYzmlFstrVKIkJdXFZ8nvuZJrFlUnLJVeQaharcaUKVOQkZEBlmUxc+ZM/P333/jf//7X5Dm9evVCREQEAODvv//W5/Zm5caNG8JjHx+fRo+puydz0qRJzV5v4sSJjZ7Hy8jIEB5HRkY2ey1/f3/Y2dkBAK5du4akpKRmj2/K5cuXkZqaCgDo2rUrQkJCmjzW0dERw4cPBwBUVFTg4MGDbbqnOeP3gzrbWkEm7ZjbqztrZ5xSCytob5QB8dUY+j7wFIDbXXZa0y51gDYIPWHCfaGGrhFaV2ftLL2hitbz/yfOQx8BAERpZzLb2sK2qy8XhF7NLjXbWtosy2L9v2m4a8ledH53B5766RSySsx/guFaThlYFvBytIaHg7Uo1+wb6AoPB2uUVatw/JbpXthZOr2eOX/++WdcunQJDMNg5cqV+OWXXzB27Fj4+fk1e97o0aPBsixOnjypz+3NRnl5OV588UXh/WnTpjV63IULF4TH/fv3b/aaPj4+CAgIAMAto+fn59f7vD5/pBITE9t0XmvGf+cxdc9tL4oruZnQjpqUBACeDtZwsbOChrW82VC1hoXaQmZzYmNjER0dLZTw4Uv6AFzQo0thdD4IPZdeYpIXDLVqjfAzYoyuQPxs6/U8wwShsbGxeHvRu0jK5b4mPogEdP8/qSvMyx4yCYPSahWyFNViDlU0Px5Lwdt/XkBBeQ00LLD3Sh4e+/ak8ILcXF03wDYQqYTB+G7cdrpd1Eu+zfQKQjdu3AgAGDZsWL0grCXdu3cHAFy/fl2f2xtdXl4eNm/ejM2bN+PPP//EDz/8gFdffRXh4eHYv38/AKBfv35N/vG5du2a8Li5WcTGjql7LlB/trWl72NmZiYqKyuF969evdrivRsj5vjvVFNTg9LS0npv5q5I+4fXtQPXx2QYBhFe3B92/snYEmw+m4n+7+9FxHs78X+7m//ZNCd8MfOebdjXFuJhD09HayhVGqF9oTHdyq9ArZqFo7UMfi62Br9fhJAhb7ify1v5FVCqNXCwliHA1U6va1nLpMLsrTnsC63bEQoArmSXYslfXLWWyKy/Mb7mEPxcbHGroALx2y+bapg64WfgI0XeBjKxuy8AYPelXIt5QWtu9ApCz549C4ZhMHXq1Fad5+HBFUsuLLSsKewzZ87gwQcfxIMPPoiHHnoI8+bNw4oVK5CTkwNPT0+89dZbOHLkSJNF5ktKSoTH/PegOe7u7o2eC0BY6ga4GenmZkbvTBC781q6EnP8d/rggw/g7OwsvPGzwOasuJIPQjvuTChwuxyOMXt162P/1Ty8suEciiqUUGtYfHngJtKLKls+0cSKK5TI1C59tqXMTFxcHJiz3MTBmbSSep9rTZvJtuKTkiJ8HNvUt7u1OvMvjgw0EwpwgRnAbS+QSPT/mvhtClfMIAit2xGKZVks3nIJag0Lz6Tt2L3mc/i7OeDLWX3BMMCms5lC1yhzdM1AXboGhrrBxc4KhRVKk5c/s1R6BaF8EOnv79+6m2qTaDSa9rOZd8SIERgxYgRsbGyaPKa8/PYr8uaO49na3p4tKCur/4d02rRpcHPjltfOnDmDt956q9FAdP/+/ViyZEm9j7V1llHM8d/pnXfegUKhEN7S09PbNEZjEmZCO/ByPFBn2dMCZkKrlGos3MhtR5lxVwB6+TtDpWHx6R7zX5W5ksP93ga42cLJpvWz71KpFKc2fo2So+vqBQx8gk1r2ky2xTXt+A2dlMQzRob8ZW2wWHcpXh9dfM0nOaluktWs59/CvylFKD+xHv/9+bXQEapXgAse6ss9/3998KaJR9w0QyzHA4CVVIKxXWlJXh96BaF89nPdpV5d8BnifBClj1GjRoFhGFHe1q9f3+y9JkyYIGT/q1QqZGdnY/Pmzbj77ruxceNG3HvvvZg5c2arvx9t4ejoiM8++0x4/+OPP0b//v3xySef4Pfff8e3336LRx55BGPHjkV1dXW9klitaS1qLNbW1nBycqr3Zu5KKjt2oXqeUBjcgDNOYvn9dDryymrg72qLuPu7IXZKNzAM8OfZTOy/1nSTCXNwe0mxbb8b0dHReOa1d6A4shZ//fQ/sCwrBKCtbTPZFsZMSgLqZ8gbqoTYFZGD0LrJSeYgOjoasXFxWPfVx0j9+AEUHvylwc/KghGhAIDdl3ORVmh+KwoF5TUorFCCYYBwL/F/9iZoC9f/fSnXoioGmAu9ohF+ybS1iS6HDx8GAISHh+tze5OSSqXw8fHB/fffj7179+Kdd94BwJVTeuqppxo9x8HBQXhcXd3yxvO6ZY0cHRv+8syaNQvffPMNrK25bL/Tp0/jjTfewMMPP4z58+djw4YNYFkWcXFxuO+++4TzXF1ddfsiDTx+S1dUwSUmuXTgPaHA7ZmttKJKVCnNN0OeZVl8dyQZAPD0iFDYWEnRJ9AVc4dwe5c/3XPdbLOSgdtBHF9Psi0+/TABbiMeQ9Y/P8HGxsZoASgAXDXQkmhzbm8VMWwQGtVJpCBU+71JLjCfahN3P/pcsx2hwr0dMTzcAywLbDyT0cRVTOe69ucuyM0OtnLxZ/uHhXvAwVqGnNJqnNMmDhLdyfQ5edSoUUhMTMT69evx/vvvQy5veUYoOTkZW7duBcMwGD16tD63B8AtS/OF3fXVUqmj5iQkJOCPP/5AUlIS1q1bh5iYGHTp0qXeMS4uLigu5pbBCgoK6gV1jam7Z7apgvlPPfUUJkyYgC+//BK7d+/GzZs3UVFRAR8fH4wYMQIvvvgiBg4ciDlz5gjnNFVCqiV1x1BQUNDi8bqM35Lxe0LdOvieUA8Ha7jZy1FUocTN/HJR2uIZwpm0YqQWVqLi+DrcsAkHBi8GADw/OgxrT6YiMUOBZ15bBF9na4Pvj2wLMYI4Gysphk1fgK1H10OpVLa5zWRrldeokFHMvSgVOzmkOeFejjhxq8ggs/R5ZdUoKFdCwoj3NXk6crO3hRVKXM8tq1cFwVTeejcGUKsglVlBqVQiISGhwc/MQ339cTipAJvPZeKVe8KNsudXV1cNXJvWWibF3V29sOVcFraey0LfwLZN8nRUegWhc+fOxeeff46srCy8/PLL9boGNaaoqAjTp09HbW0trKysMG/ePH1uDwB44YUX9L6GGKRSKcaNGyfU4Dxw4ECDIDQyMhLJydxMTHJyMoKDg5u9Jn8sf25T/P39sXTpUixdurTJYy5duiQ8HjBgQLP3bUrdMdQdW1N0Hb+lEhKTOvhyPACEezngZHIRrueWmW0QuuVcFgAg3McJCXGxsJJKEB0dDXcHa0zt64evPv0Iq4+sRXx8vIlH2pBGwwr72vRdzi49vqHFoEJs/Cyut5O1UX9fDJkhfzmLmwUN9rAXbYaNYRh08XXE0RuFuJJdavIgNDYuHsd//wrOw2Zh75rPsHPNF4iJiQGAej8z47p5w04uRWphJRIzFOgV4GKiETck1u9Nc6b29ceWc1nYdDYTb0/sAhsrw+6vbk/0Wo7v1asXnnjiCbAsi9WrV2PChAnYu3dvvSSUyspKXL16FZ9++il69eolZNS//PLLFpEB3Rp1l5z5Gc+6evToITw+depUs9fKzc0VknO8vLzg6enZ5nEVFhYKdTodHBzQp0+fNl2nNeO/8xi+LFd7wtfG6+h7QgHzT07SaFjs1LbXWxof26CrTdGR9VAcWQuvUbPx1juLTDjSxqUXV6JSqYZcJkGwu32br5OQkIADv/4PzsNmYfKK/Xq1mWyNqzl8Frlx93qHCz+X4s+EXsnmt0eI+zV15TsnZZt2j3VCQgLiYhfDedgshI17HH0CXZvsCGUnl2FUJPcctfdKrqmG3Ki6VRkMZVhnD/i52EJRVYu/L1Ebz9bQayYUAL766ivcunULBw8exJ49e7Bnzx4AEKbj6wZm/H6r8ePH44MPPtD31manbieixoLGCRMmYPny5QC4LkhvvfVWk9fasWOH8Lil7kotWbNmDWpruf2Ls2fPFvaQtlZUVBQCAwORlpaGK1euICUlpcnZ3PLycmHvr52dHUaOHNmme5ozqhN62+0ZJ/NMTrqcXYr8shrYyaUYHOaOUdpZnJiYGCxZsgRKpRL+dz8B6V3TcPh6Ae6J8jbxiOvjlxTDvRza3J2LT0J6/Z1o/KEZiMtZCqxfzAXcjc1uicnYSUk8/sVRRnEVKmpUsLfW+ylPIOwHFTkIFTLkTZycpFarMXrmC7gVMAGju3hBqi1Bxf+M3NkR6p6u3thxIQd7r+Th9XHmsfLFsqwwC27IqgxSCYNp/fyxcl8SNpxKx/29m2/YQ27TO01aLpdj7969WLhwIaytrYXscT7grPu+tbU13nzzTWzfvt3g5UCMLS0trV57zaFDhzY4ZuTIkcJ+zAMHDuDMmTONXkutVtfLfH/kkUfaPK6srCxheVEul+Pll19u87UAYMaMGcLj//u//2vyuNWrV6OiguvVO2XKFKFtaHuhUmtQWs2VfenodUKBOjNOZpohv/8ql/k+tLMHrGXc357o6GjI5XJhb+TcF18HABy4bn5Z8lez9d8PyreZXP5+HALcbFGrZvHbf+ltbjPZGvz4u+iRVNUWbvby2z3kRe7oddlQQaj2//hqTplJE+UWL14MdW+uBvg9Xb3qfa6xjlCjI70gYbjg2VxaeeaV1aC8RgWphEGQu2Gfg6bf5Q+GAY7dLESKtk89aZkotXqkUik++OADpKam4rPPPsO0adNw1113ISwsDL1798a9996L5cuX48aNG1i2bJnFBKA5OTmIi4tDUVHzRWivX7+OSZMmCaWZRo8eja5duzY4ji/+y5szZw7y8ho+4b399ts4d+4cAC6YHT9+fKP3TU5OFnq5N+bSpUsYM2aMsDUgLi6u2b2ZdctVpaSkNHrMG2+8Icxuf/HFF9i6dWuDY06ePCm8WpbJZFi8eHGT97RUJVXczDLDcL3jOzp+lsGQNRn1cTiJS6TjlwwBbmaQD0CVSiXS9q6pd6w5uZarLQWkx3I23/qTYRg8PZwrq7Pq4E1oNGyb2kzqimVZYTm+reWl9GGIDPnqWjVu5Tds1ymGcG8HSCUMFFW1yCk1XfvOm/kVSC2shFwqwbDwlreDudrL0UO7h/X4TfNoRMO/8AhwtRVefBqKv6sdRkZw3ye+CgdpmXhrE+CWoF944QWzSRbSV3V1NWJjY7FkyRKMGjUKAwYMQFhYGJycnKBUKpGRkYHDhw/j77//Fpa7/fz88O233zZ5zfnz52PTpk3Ys2cPLl26hF69emH+/PmIiopCUVER1q1bhyNHjgDgMspXrVrV5LVOnz6NGTNmYOjQoRg1ahTCw8NhY2ODnJwc7N+/H9u2bYNKxQUETz75ZLPL/7ry8vLC559/jieeeAIajQYPPvigUI9UKpXi6NGj+Omnn4QSTnFxcQ0StNoDfj+os61Vm5dH2xM3ezk8HOQoKFfiRl65yRMq6qpRqYXSKYNDuS5ed9bH5N93G5GF1MGPILWwAkF67L0Um9gdX6bfFYClO64iS1GNm/nlwky2IWQrqlFarYJMwiDMy/jf0whvbYa8iFtFrueWQcNyP/feTm3b3tQUa5kUoR72SMorx9WcMvg6G77FaWP2afd2Dgx1g4OO2xgGhbrhfHoJjt8qxEP9WtfExhBu5nMzkmGezVeiEcvTI0Jx4Fo+fvsvHS/fEw4PB3F/NtojUYPQ9kqlUmHv3r3Yu3dvs8eNGzcOq1evRlBQUJPHyGQybNy4ETNnzsT27duRk5PTaFKAv78/NmzYgG7dujV7T41Gg8OHDwv7L+9kZ2eH6OhoLFy4ULSyGY8//jgqKyvx2muvobq6Gr/++it+/fXXesdIpVK8++67WLTI/JI8xHB7PygtxfPCvRxRUF6I67nmFYRezFRAqdLA3V6OEA/7Rgu0R9fZI6rWsDjxUA+zCUJr1RqkaouA873F9WVjJUUPf2f8m1yEs2klBg1C+QA61NPe4LNRjQn3Er+tLJ8Z39XXMC1II30cuSA0uwyjI71aPsEAjtzgVgTGdNH9/oND3bHq4C2cuGUeM6H8bHWop3F+lweHuqOXvzPOZyjw07EUs9kba85oCqcZwcHBOH/+PD755BM8/PDD6N69O1xcXCCVSmFjYwNvb28MGzYMr732Gk6ePIm///672QCU5+joiG3btmHz5s2YOnUqAgICYG1tDQ8PDwwcOBDLli3DxYsXMWTIkGavM3r0aKxatQqPPPIIoqKi4O7uDisrK/j6+mLo0KFYunQprl+/jrffflv0P5TPPvssEhMT8dprryEqKgqOjo6wt7dHeHg4nnnmGZw6dQpxcXGi3tOc3O4bT0vxvHAzTU76L4XbjtI3yBUMwwh7I+9MwomOjsa42S8BrAanUsynD3ZaUSVUGha2VlL4OLXcLldXfD3DMwbu+X3FRJnxPD7AThKxa5KhkpJ4/BI/3+rU2JQqjfB7MyTMQ+fz+ge7QSZhkFFchfQi03dPMvZMKMMweGYk153w5+OpUFTWGuW+loxmQlvQs2dP9OzZ0yDXvv/++3H//fe3+Xx3d3c8/fTTePrpp0UZT2s3wYeHh+OTTz7BJ598Isr9LUmx9o8LlWe6zZDlcPTBB5T9g7mgq7m9j++8+y6e+OEU/ktpfh+4Md3SPpGGetpDIhHvxWSfQBcAwNm0EtGu2RgxkqraKjY2FlwTr/4NMuQTEhKgVqvbtBfWUOWZeHzx+6sm6iF/IbMEVbVquNnLhcoXurC3lqGnvzPOpHFL8gFupk1IvT0TapwgFADGdfNBuJcDkvLK8ene64id0vxqZkcnykyoWq3G5s2bsWDBAgwdOhRRUVEIDQ1t8a1uP3NCLAm/HO9Cy/GCCC/DtkhsC5ZlhZm+fkFuLR7PzZYCKYWVyCszXVJIXYZ6IuWD0Ot5ZSitNtyMjRjtRttKKpXigyVxqD31G4DbPeT5LRltSZJlWVb0dp134qsI3MwvR61aY5B7NIdPLBoU6tbqVbTBYdy+6xMmTk6qrlUjU5ulH2ak5XiAK9cUc18UAGDNiVTh5580Tu+Z0MuXL2PGjBm4fPlyvY/rMqtmTq29CGkNKlTfEJ8hn1kifk3GtrpVUIGiCiWsZRJ092s5YHCysUKElyOu5ZbhQoYCd3cVb/m7rfgM31APcZ9IvRxt4O9qi4ziKiSmKzAsXPdlV10pVRph/JEmWI6vu9fXWanG9Wk9sfXHzxvsCW6NjOIqlNWoIJdKDLbM6+diC0drGcpqVLiVX2H0WeQTt7iVgEHaRL7WGBTqji/23zT5vtDkggqwLJc8auy/08PDPTG+mzf+vpSL6M0Xse7pQUKdVVKfXs8S+fn5uPvuu5GXlycEnTKZDB4eHm0uiE6IJeCX4ykx6TZXezk8HKxRUF6DpLxy9DaD1n38snovfxedk2K6+TnhWm4ZLmaW4u6upi9azy/Hh4mUlFRX30BXZBRX4UxasUGC0Jv55VBpWDjayNDJ2TQBfXR0NPZdycXBdV/g0cG/Qa2qbXMACtyuDxru7QArA1XGYBgGET6OOJ1ajKs5pUYNQpUqDf5LbXsQ2jfQFRIGyFJUI7e0Gt4i7mNuDf7FT5invUkmvN6bHIXDSQX4N6UIn+1LwqtjI4w+Bkug12/Q8uXLkZvLlXHo3bs3du7cifLycmRlZSE5OVmnN0IsEZ+Y5GZPiUl1RXiLn4msj3PpJQC4ZXZdde/kDAC4mKUwxJBa7Za28LXYM6FA3X2hhklOut2u0zBZ5Lp66qU3AakMalUt5HK5Xp2hbmfGG3Zmt27RemNKzChBdS1XTSK8DS987K1lwqqIofcbN+f2Xmrj7QetK8DNDgn3c+2qV+5Lwm+n0k0yDnOnVxD6119/AQA6d+6MI0eOYPz48ZDLaWaItH+0J7Rx/JPPDREzkfVxSRsw9PBz1vmc7tpjL2WaPggtrlAKP2uGKDPDZ8ifTS8xSHeeq0K7TtNkxvOO/r4KUKvASK2gVCobLYunK34/qLGCUGPvKTyZzM2CDmzDflAevwrCvwg0hdszoaYJQgHgoX7+eHoE1xjirY2J+HTPdahMsMfXnOkVhKampnLdN55+ut21ZSSkObdnQikIrSvcjGZCa9UaIQjq1ooEEj6BJktRLQSApnKrgHsi7eRsAzu5+Htsu/o6wVomQUllLZIN0GrQlJnxvISEBHz9fx/AZfgsBL6xCQvfjUFMTEybA1G+5JShyjPx+B7yV43cQ/5Mqu6JfE3hg9DzJgxC61aVMKW3J3TBk8NCAHAzohNWHsYPR5ORe0c3rNjY2CZ/JhMSEgzW0czU9PqrZmVlhaqqKgQHB4s0HEIsQzEVq28UPxOaZAYZ8jfyyqFUaeBoLUNgK0rFONpYIcTDHskFFbiUpcBwHVoWGspNAy8pymUS9PBzxn+pxTiTViLqfViWxSXtlgZDzxo2pW5jgv12w3ErvwITZj8Pe2uZ0EK5NUvzpdW1SC/iMq4NHYTyv0tZimooqmqN0h6YZVmc5bewaLdqtEVv7bmJGSVQa1ijJ+WwLCtUlTDlTCgASCQMou+NQnc/J8Rtu4wbeeWI23YZcdsuw8PBGuFeDgj2sMfldAW2fr8Cag2L2MW323vX/Rluj/SaCQ0N5aaZW+qtTkh7UqvWoLSaa4dKM6H1RXjdzpAvrzFtD3l+Kb5rJ6dW19fkZ04vZpqmWDjvphE6vhhqX2heWQ0KypWQMIYP2JpStzEBP4bL2aWIjo5GfHw81Gp1q67Hz+z6udjC2cCNKpxtrYRkLmMtyacUVqKoQgm5TIJunXTfwnKncC9H2MmlqFCqTbI1J7e0BhVKNaQSplUvQA3pwT7+OPjGaMTcG4VeAS5gGKCgvAbHbxVi3b9pOO95D5yHzUJc7GKMnvkCruWUYXFsnF6VHCyBXjOhDz30EM6ePYu9e/di/vz5Yo2JELNWos2MZxgYZXbCkjjbWcHL0Rp5ZTVIyi1Dn0DdE4LExs/CtWYpntfdzxnbE7NNnpyUnG+4pCQety80GWdETiK5qN1T29nLAbZy47frBOo3Jojq5ITtidlCYlFbntT5r8lYM7tdfJ2QpajGtZxSDAhp+/K4rk5rl+J7+DlDLmv7HJVUwqCHnzNOJhfhXHqx0bdj8C/egtzs9Po6xOZsZ4V5w0Iwb1gIKpUqXM8tx638cqQUVCAprxwn7OYgGcCBdV+gy2/cPuZHn32j3QaggJ4zoc8//zwCAgLw559/4ujRo2KNiRCzxu8Hdba1otpvjTCXJXl+JrQtMzp8hrypk5PStK0PgwwYhPIvFK7llKJCxNlrfha5ux4zamLifw4u67HH8nxGCQCgl79xvqZII2fI327soP+LR35J3hTJScbuGd8WdnIZege4YGpff7w2LhJfPdYPp98bi+3fr4BEZgWoVYBUhmNOo/DBzisGSRw0B3oFoc7Ozti8eTM8PDwwefJk/Pzzz9BoKPOLtG9CoXraD9ooc0hO0mhYXBGC0NbPWvGdcFIKK0UNzFqDZdnbQagBlxR9nG3QydkGGvZ2kCUGfha5WysqExgSvxyfXFCBSmXb/k8TM7ivqaeRauAau0wTn5Skz35QXm9/7hr898yYjN0zXiwSCYP967+CRltKDGoVSo6uw6qDt/DhzqvtMhDVazl+3rx5AIBu3brhn3/+wdy5c/Hmm2+if//+8PDwgETSfIzLMAy+++47fYZAiNHxM6EuBt4TZqn4mdDrJizTlFZUyXW1kUnQuQ21Dt3qFN6/mV+OntonVGPKL69BpVINCQP4uxp2X1ufQFdkXcjG2bQSDAkTp2g9P4vc3UCtLVvL09Eano7WyC+rwZXsslbP9imqblcQ6GmkwJovbXUtpwwsyxq01mpZda3wwrGvCNto+Jnn67llUKo0Rl0WN8ZeakOom4QUHR0tvA8Aq/AonGyt8PzoziYepbj0CkJ//PFH4ZeC/7egoAA7d+7U+RoUhBJLU1TB7QmlpKTG8QXrk0w4E8ovuXbxcWxzV5twLwcUlNfgeq5pgtC0Qm4W1NfZ1uBP4H0CXfDXhWzRkpMKy2uQpeBK0Biqv3pbdOvkhAPX8nE5S9HqIPSCdkYv0M0Orkb63Q/1tIeVlEF5jQoZxVUIMOCM+Pl0BTQs4O9qCy8RuhwFuNnC0UaGsmoVkvLK9Ep0aq1bFjgTemcACtRvOwsAy/EoonydMLqLl8nGKTa9/7KxLNvmN0IsET8TSuWZGtdZmyGfrahGaXWtScbAZxNHerc9IYLfVpCUZ5pgOlUbhAa5Gz67l98XeiZNnKL1/H7cUA97ONqYz4oB37TgXHrrl4j5rQo9jbQfFACs6vSnN3SGPL8fVIxZUICbmOK3QPA/D8ZQpVQjs4Qro2WqbkltUbeSQ118JYeeftzfslc2nEO6dptOe6DXTCi13SQdkbAnlGZCG+VsawUfJxvklFYjKbdclCSH1uIDxwi9glBt9ycTJVilFhkvCO3u5wS5VIKiCiXSiioR5K7fMqa57QflCR2i2jDjmygkJbmIOKKWdfFxxNWcMlzLLcM9Ud4Gu8/tINRFtGt268RlyF82YhDKN3hwtbOyqL/RzRWjj46OxlsqNR7++jjOZyjwyoZz+G3B4HaRGKtXEBoUFCTWOAixGEWV1LKzJeHeDtogtPV778RwXRs48rOZbcH3zb5usplQbkkx0M3w+9qsZVJEdXLCufQSnEkr1jsIPact99TDz3yW4oHbnXxuFVSguELZqmX189rZU2POhALazknnsoR2oYag0bCidEq6E58UeMmIpc5M3TPeUKxlUnwxqy8mrDiM06nF+P5IMuZrW4JaMvMpoEWIhbg9E2o+y4zmRkhOMsEsolKlQYo2gUSvmVBtEJpRXNXmbGp9GHM5Hrg9S/hfin77QlmWFWqOirW0KxZXe7lQc7U1pYPySquRU1oNCcPVkDWmSCP0kL9VUI7SahVsrCTo4iteTc9u2hchl7NKodEYZwve7Z7xlpWUpAt/Vzu8N7krAGD57msmaQQgNgpCCWmlYm2xetoT2rQIE+6nTC6ogErDwtFaBl/ntidYuDtYw91eDpa9PbtiTHx5JmN1fOGLof+brF8HvIziKhSU18BKyhg9YNPF7f2vugfb/6Zw35NIHyfYW+u1gNhqfJmmWwUVqFG1rsOTrs6klgAAevq7tDmRrzFhng6QyySoUKqF7SWG1l5nQnkz+gdgZIQnlCoN3tt8weLza0QNQmtra3HkyBGsXr0aH374YbvtdUo6Nj4xyZL2GxlbuDATavwglL9nZ28HvUva8OWdjP11lFXXokg7426smVA+CE3KK0dheU2br8MHd1GdnGFjZZpOSc3pG+QCoHVB6IlbhQCAwaHuhhhSs3ycbOBsawW1hjXYzJfYSUk8K6lECKKNtS/0ppn0jDcUhmGw5IHusLGS4MStImw+l2nqIelFlCBUqVQiJiYG3t7eGDlyJJ599lm8++67iIuLa3Dsm2++iYiICNx9991i3JoQo+ODA9oT2jQ+eMstrYGiyrgZ8nxpKH0y43m3M+SNu+zFL8W72cuNll3uZi8Xvmf6zIaeFrHguSH0CeACrfPpCqh1XCI+cYv7fgwKNXzrzDsxDGPwJfnTwn5Q8bdPGHNfqEbD1pkJbX/L8bwANzu8OCYcAPD+X1eM/jdWTHoHoYWFhRg0aBDef/99lJSUtFiC6YEHHsCNGzdw4MAB/Pfff/renhCjqlVrUFbN7Q+kmdCmOdlYCUvhxq4XejspSf8g9HYLUuN+DcZeiucN1AZZJ1sRhMbGxiIhIUF4v+6sWkJCQrNZv6YQ6eMIe7kU5TUqnbaL5JVV40ZeORgGRunf3piu2iDUEMlJiqpa3NDOHvYxwAuHKL4FrhFmQnNKq1FVq4ZMwhj9d8fY5g8PRZinPQrKlfhk9zVTD6fN9A5CH3roIZw7dw4sy2Lo0KFYtWqVUFi1MUOHDoW/vz8AtKqoPSHmoES7H5RhuFJEpGnhJkpOui6UZ9J/Oa6zdknP2AkAxk5K4g0M4Zab+eVnXUilUsTExCAhIQGVShWuZHPf/0O/fY2YmBhIpea1JC+VMOirnfE7cbPlr/Okdha0q4+TyVY/+IL/FzPFD+TOphWDZYFgdzt4OFiLfv3bM6GGD0L5WdBAdztR97aaI7lMgoT7uwMA1pxIxcVM47dHFYNe/0t//vknDh06BIZh8MYbb+Dw4cOYP38++vTp0+x599xzD1iWxbFjx/S5PSFGx+8Hdba1ahc12gwpwgT7KWtUaiGA0ycznscnN6QXV6FWrdH7erpKK+KeTA3ZM74x/EzftdwylGh/1lvCF9OOiYnBKwujodawUP/3Bz5emtBo8W1zwLcmPXKjoMVj+YB8kAn2g/L4BK+LWQrRE1EMUZqprq4+TpAwQEF5DfJKqw1yD57QrtOjfe4HvdOQzh6Y0qsTWBaI3nLRaBUIxKRXEPrrr78CAHr27ImPPvpI5/N69uwJALh2zXKnkEnHxO8HdaP9oC0SlrKNmCF/K78Cag0LJxsZvBz1n9XxdrKGrZUUag1r1C4lfCAdqGe9ztbydLRGZy8HsOztfZC64APRb1Z8iNSPH0DGvh/NNgAFgGGduSD0xK2iFl9c3A5CTbMUDwDhXo6QSyUoq1YJWzXE8p8B94MCgK1cKryYM/RsKB+E8nvSO4JFk7rCXi7F2bQS/HEmw9TDaTW9gtB///0XDMPg0UcfbdV53t5c14f8/Hx9bk+I0fGzQ8bqHW3J+KQeYy7H87OuEd6OemfGA1xSSIi2rmRygfHKNJlqOR4AhoZxM36Hklr39zk6OhpSmRWgVkEqszLbABTglrdd7KxQXqMSknIak15UiZv5FZCYcD8owC298vU7xVySV6k1Qr1UQzaVMFZyUnuuEdoUH2cbvHQ3l6S0bOdVi0tS0isI5YPI0NDWVe23suL20imVui33EGIuiiqoRqiu+D2h+WU1Oi/t6itJxKQkXoj2Cc1YtUKVKg2yFVzva2MvxwPAqEgvAMDBa/mtWvpNSEiAWlULSGVQq2rrJSuZG6mEwRjt17nncm6Tx+3Wfm5AiJvJq2HwS/IXRNz7dzWnDJVKNRxtZEJzBkPgg1B+v7Ch8Hu3wzrQTCgAzB0agjBPexRWKPHpnuumHk6r6BWE2thw2a+tDSb54NXV1by6aRDSEn5PqKsdJSW1xMFaBj8XWwDGmw29PRMq3pMQ32HnlpFmQjOKK6FhAVsrKTxF2FLQWoNC3SGXSZBZUiXMLLUkISEBMTExCLjnCQS9sRkLXn1HSFYyV+O6cStyey7nNhls77mcAwAYG+VjtHE1pbuQZS5eEFq3koHEgHvco3y5sV82YOvRsupa5JZy9W3ba43QpshlEsRN4ZKUfj6eYrSarGLQKwj19fUFAFy5cqVV5504cQIAEBISos/tCTE6YU8oLcfrJNzInZP4ep5iJCXx+HqDyQXGCaT5zjJB7naibCloLVu5FAO1S88HrrW8JM8HoDGLYyG9axoAYEn8YiFZyVwD0RERnrCxkiCtqLLRFp6ZJVVCqapxUd5GHl1DPerMhIqVnMS3aDXkUjwAdNVuJUgprEB5jWFa4PIrFZ6O1h2ycsmwcA9M6uEDDQss3nrRYjop6RWEDh8+HCzL4vfff9f5Cy4oKMDGjRvBMAxGjhypz+0JMbpi2hPaKrfrbBo+gKuuVSO1kHsiChdxJjREm2lrrD2haYWmqRFal7Akf73lIFStViM+Ph4zn3kNLAs42sjgbi8XkpXUasO0mtSXnVyGid25iZTfTzdM6Nh0JgMsyyUkBZhBzckIHwdYSRmUVNYis6RKlGsaskh9Xe4O1vB2sgbLAtdyDDNLJyzFd6D9oHd6b3IUbK2kOJVSbDGdlPQKQh977DEAQFJSEt5///0Wj1cqlXjsscdQWVkJhmHwxBNP6HN7QoyumLLjWyXciGWabuaXQ8MCLnZW8BSx3mGINkM9t7QGFQaaxakrRRtImyIpiTcywhMAVyOzUtn81xwbG4vo6GiczygBwGUm8zO40dHRZlesvq7pd3E1q7eey6q3b7lGpcbak2ncMf0CTDK2O1nLpMKLugsZ+i/J5yiqkVlSBQkD9Apw0ft6LYny5faFGmqpuCNmxt+pk4stXhjTGQCwdMdVlFWbf5KS3jOhkydPBsuyWLx4MRYsWIAbN240OK6yshKbNm3CwIEDsWfPHjAMg8ceewxdunTR5/aEGF2Rtli9C+0J1UmEEXvI87OtEV7iZMbznO2s4K6d+TbGbGiaicoz1RXmaY8gdzso1RrsvZKn0zn7r3LHjQj3NOTQRDUoxB1dfBxRXqPCN4dvCR//7b8MZCuq4e1kjck9fU04wvr4YPFsI9sHWovfD9rV1wkO1jK9r9cSvuC+ofaFtvee8bp6angIQjzskV9Wg5V7k0w9nBbp3VLgl19+QdeuXcGyLL799ltERkZi5syZwuc9PT3h7OyMadOmITExESzLolevXvjyyy/1vTUhRsfPltCeUN1EeDtqC1UrkV9WY9B78YGumEvxPGOWaRL2hJpwCZhhGNzXsxMAYMvZlpf1lCoNDidxhd/v7upl0LGJSSJh8Mo9EQCAbw4lIzGjBGmFlfho11UAwDMjw2BjZT4dn/oGcsvmZ5opK6UrY+0H5QnJSQaaCb29HN+xg1BrmRSL74sCAPxwLMWozULaQu8g1NnZGSdOnMCMGTOEnvFVVVXCTERhYSHUarXwuenTp+PQoUOwszP9HhtCWotPTKI9obqxlUsRrA3gDNH3ui4+A1/MpCQeH4QaukyTRsMKxchNuRwPAA/04YLQg9fzhW0oTTl6swDlNSp4OloLWdyWYnw3b9zT1RtKtQZTvzyGe/7vIMqqVegb6ILZg4JMPbx6+IAxMVMBpUq/Dl7/pRbVu6ah8TOhV3PKoBK5+1itWiPU1u3Iy/G8UZFeGBflDbWGRcwW805SEqW5qqOjI9atW4fz58/jtddew1133QV3d3dIpVK4uLige/fueP7553Hy5Els2LABDg70Q0IsT61ag7Jqbn8c1QnVXVdfvkagYYNQPgPfEDOhfMcXQ2fI55ZVQ6nSQCph0Elb3spUOns5olsnJ6g0LP66kN3ssdvOZQEAJvfwNWipH0NgGAafTO+FQaFuUGlYKNUadPdzwhez+kJmZv3Hg93t4GYvh1Kl0atUk6KyVug1PjDEOO1Ig9zsYCeXokalEfY9iyWtqBIqDQs7uRQ+TjaiXttSRd8bBWuZBCduFZl1kpKoG0F69OiBjz/+WMxLEmI2+Mx4hkGHLAHSFrGxsUhNLQG8xzYIQhMSEqBWq0VJXKlSqoUZREPOhBp6OZ6fzfFzsYWVGQRA9/fuhEtZpdh8NhOPNTErWKVUC0Xd7+tlPvsnW8PZzgq/PjUIZ9KKoWGBPoEuZvH9vxPDMOgb6IK9V/JwOrUYfQLbNot5MrkQGpYrP+bjbJygTSJh0MXHEWfSSnApqxSdvcT7PeWX4kM97S3uRZChBLjZ4cUxnfHx7utYvOUSBod6GO3/ujXM77eMEDNVwicl2VpBSn/odCKVSvHXjytRcnRdvW4pfG1JqVSc/XY388vBstxeXQ8RM+N5fK3QWwUVBl3aSjNhu87GTOnlB6mEwX+pxU3u5dtyLhPlNSoEutkJexYtkUTC4K5gNwwIcTPLAJTHB55n00rafI3jtwoBAEPCjDMLyjNUcpKQGd/B94PeacHIMPT0d0ZptQoLNyaa5bK8+f6mEWJmaD9o60VHR+ONRdFQHFmLU5u+QY1KLQSg8fHxovUXF5KSDLQfLNDNDgwDlFWrUNjC/kh9pBZVCPczBz7ONpjUg5vdXH3oZoPPsyyLn46nAgAeGxRokuL6HQ2/h7O5nvctOX6TC0IHh3qIMiZdGSo56WYe93vT0ZOS7mQlleD/Hu4FuUyCg9fz8eu/aaYeUgMUhBKiIz45g/aDts5HS+LgPXoOig//Akd7O9EDUMCwSUkAYGMlFVqQGnJJPtXMZkIB4OnhoQCALeezGuxD3HUxB1eyS2FrJTWbeprtXU9/Z0glDHJKq5FRXNnq8wvKa3A1h3vRNijUTezhNUuYCc0qFXVW7kZ+x+wZr4vOXo54a3wkAOD9v67ghpG61+mKglBCdFRUSUFoWzAMg1GPPANIZahVKiGXy0UNQAEgyQA94+8k7As1YIY8v6810M18ur708HfGfb06gWWBdzddFLKyS6trsXQn17J5/ohQWiEwEju5TGjheexGYavPP6Fdiu/i4wh3A2xdaU6ktmRbYYV4JdtYlsWtPCpU35x5Q0MwJMwdlUo1Fqw5bbDWqW1BQSghOuL3hLrZU1JSa+Ud/BVQqyCVWUGpVIreT5yf2Qk30EwocHup76YBM+TNcSYUAN6Z2AVONjKcSy/BS+vO4lRKEZ5ZcxrpRVXwc7HF0yNCTT3EDmV4OLeMfvhGQavPPXydO2ewkfeDAlzJNv7F3CWR9oXmldWgrEYFCWN+vzfmQiJhsPKRPvBxssHN/Aq88dt5aDTmsT+UglBCdER7QtsmISEB+3/9H5yHzcLDXx5CfHw8YmJiRAtE88q49oMMA3T3M1yNSkPPhCoqa6Go4l7omMueUF4nF1useKQ3ZBIGuy7lYPrXx3HsZiFsrCT4YlZfo3TcIbcN13alOnqjoFXBhEbDYp+2s9WYLqZpKhClrSMrVsm2a9oXoMHu9rCWmU9jAXPj6WiNL2b1hZWU+x1euuOKqYcEgIJQQnRGe0Jbj09Cev6NRXAZ+iiuZJfivffeEzUQ5bOEI70dDRoMGbpME1870cPBGvZmGNSN6eKN9U8PQv9gVzhayzAkzB2bnhuK3kboO07q6xPoAnu5FEUVylZlmp/PKEFBeQ0crWVGqw96J7F7yPNBaKSP4VZB2ot+Qa5YPq0XAODbI8mNJhsam/n9pSPETPF1Qt0oCNWZWq1GfHw83nx7EXYu/hvFlbXILa0R9oSq1Wq978H3wO4T6KL3tZrDB6GphZVQa1jRy3TxQWiIh3nNgtZ1V7Abfn9miKmH0eFZSSUYFOqOfVfzcORGgc4rAHuvcPVcR0Z6Qi4zzRyU2GWa+K04XXycRLlee/dAHz9kK6qxbNdVLN1xFRKGwVPDTbedhoJQQnRUpN0TSsvxuqtbiD7Uwx5JeeW4kl0KH2cb0ZKTzmlnQg09I+fnYgu5TAKlSoPM4ioEirz/jJ9h5YNdQpozLNwD+67m4XBSPp4ZGabTOXsvc0vxY6O8DTm0ZvEzockFFaioUek9638tlwtmaSZUd8+MDEWVUoXP/rmBE7cKMW9oiMmK/NNyPCE6ur0cT4lJbcG37xRjBiQ2NhYJCQlgWRbXtJnx/GxQQkKCKF2Y7iSRMAhx54vWi5+clKINQoMpCCU64PeFnkou1inbOa2wEtdyyyCVMBgVYZr9oAC3N9HbyRosC1zSc0lepdYgSVuerQsFoTpjGAavjo3Aykd644tZfU3aZYqCUEJ0VEyJSXoRs4e8VCpFTEwM3omORUllLSQMl70udiemO/GzlLcMkJyUrM2M5wNdQpoT5mmPUA97KNUa/KNNNmrOjovZAIABwW5wNvEL6Z7+LgCAxIwSva6TUliJGpUGtlZSs0vmM3cMw+D+3n4mT+aiIJQQHdSqNSjTzjbQntC26erLzVSIEYRGR0cjPj4ey96PR8nRdQj2sMfyD5capBB+XXz7TkMkJ9FMKGkNhmEwsYcPAGBHYnazx7Isi42nMwAAD/TpZPCxtaSndtXiQqaihSObxyclRXg7UM94C0V7QgnRAZ+UJGEAJ1tajm+LunvBqmvVsLHS7xV4dHQ0TqcWYct3K3DwxG/Yr6o1aAAKGC5DvrhCKZRnCqaZUKKjid198cX+m/jnWh4UlbVNznCez1AgKa8c1jIJJmrbsJpST+3+7cQMfYNQ2g9q6XQKQseMGWOQmzMMg3379hnk2oSIqbiCCxCcba1Ez4ruKDwdreFuL0dhhRLXc8uEJTl9REx4Avjxf9Coag3SielO/EzorXxx94QmazPjfZxsYCunWodEN906OaGLjyOu5pRh87lMPD4kuNHjfjqWAgCY1MMXTjamfxHNd3xKLqiAoqoWzm18YU+Z8ZZPpyD0wIEDYBhxn3hZlhX9moQYChWq1x/DMOjq64QjNwpwJbtUlCB064+fA2oVZFZyoROTIQPRUA+ua1KWohpVSrVoASNfAD/YjMszEfPDMAxm9A9A3LbL+OVEKmYPCmqwLJ1VUoXtiVkAuPaN5sDNXo4AN1ukF1XhYqYCQzt7tOk6fFIiJSVZLp33hLIsK+obIZakhGqEioLfF3oxU/99oXFx8bj213dwHjYLSVlFondiaoyrvRwu2iVPvq6nGG7XCKWleNI6D/XzR+XxdTi16RuhG1JdDy94A/kHf8HAEDf08DdcR7HW6unnAqDtS/KKqlqhzW0XX5oJtVQ6BaEajcYgb2IUqibEGIoqaSZUDL2EvWAlel2HK8O0GM7DZsFv9GMIdLMTkpUMHYgaIkOe32NK+0FJaznZWKFXoBsUR9bi2dcXoVatET739Kvv4OhvXwKMBAsndjHhKBvqqQ2I2/q34KI2qSnAzRZu9HfZYlFiEiE6oBqh4uilXYK/nF2KGpW6zeVB1Go1Hn32DRxzGoUuvk7CEqSYnZiaEurhgLNpJUgWsVYoPxNKmfGkLX77+mNEZSpwc9f3mDLPATt/WolnX1+Eb1Z8COdhs/D0y2+ib6CrqYdZDz8rey69pE3nn9cGr2Js6yGmQ0EoIToopm5JovB3tRWSk65kl7W5y1FsbCw+2HkFxw7eEpb4ecZLThJnJpRlWaQUcMuKoRSEkjZwtZfji4/fx7yX1dj182eQrP0SrFoF52GzMHjaAsRO6WbqITbQy98FUgmDbEU1Mkuq4Odi26rzz2uD115mtMWAtB7VCSVEB/xMKO0J1Q/DMMKS/Dltz/e2upLNJSV0NfJ+MGE5XqQyTQXlSpTXqMAwQAAV3CZtNLWvP957LxqQysCqVYBUhseffx0bFgyCndz85pvsrWXoru0jfyq5qNXn83tJaSbUslEQSogOhD2hFITqjV+SP69njcDL2pZ/UUYOQuuWaRIjyZJfiu/kbKt37VTSsVX9+xugVkEqswLUKngkbTeLkkxNuSvYDQBwKqV1QWheWTWyFdVgmNvteollEvXlkVqtRmJiIjIyMlBaWqrTvqw5c+aIOQRCDIKfCXWhPaF66xXAPWmcb+NeMIB7EioorwHDGL9QNZ88VFqtQlGFEu4O1npdj09Kosx4og++ZS3fsIF/HzD8FpW26h/shu+OJLc6CE1M517Ahns5wMHa/GZ5ie5E+d/LzMxEXFwc1q1bh8rKSp3PYxiGglBiEfiZUHcHmgnVFz8TequgotkuL83hl+JDPOyNvtRoYyWFn4stMkuqkFxQoXcQertdJy3Fk7a5MwAFbgee5hyI9g/mkqWu55ajpFIJFx1XmhIpKand0Puv96lTpzBp0iQUFRVR/U/SbvEdk9zs9Qs4CJdEEeRuh9TCSpzPKMGICM9WX4Nfijf2flBeqKc9MkuqcKugQlhSbCshM57KM5E2UqvVjbasNUa1CH24O1gj1NMet/Ir8F9KMe6J8tbpvHParTyUlGT59ApCKyoq8OCDD6KwsBASiQSzZs3CsGHD8Mwzz4BhGLzwwguIjIxEcnIydu3ahUuXLoFhGDz22GMGawVKiNhqVGqU16gAUGKSWPoGuiK1sBL/pRS1KQjll/J7mmg/WIiHPQ4nFYiSIZ+szYyn5XjSVrGxsU1+zhxnQOsaEOyGW/kVOJVSpFMQqlJrcFq7fN83yLzKTpHW0ysx6bvvvkNWVhYYhsFPP/2En3/+GU8//bTw+bvvvhvPPfccli9fjgsXLmDdunVwdHTEunXrYGVlhccff1zvL4AQQ+NnQaUSBo42tP9IDANCuNnDE23IimVZFme0mfV9TFT7kA8Y9a0VyrIsUqlGKOnA+L8Fx24W6nT8paxSVCjVcLKRUc/4dkCvIPSvv/4CAAwdOhSzZs1q8fgZM2Zg06ZNUKvVWLBgAW7evKnP7QkxCqFvvJ28QV9m0jYDtU8859JLUF3buqXCbEU18spqIJUw6GGimdBQT66HfLKeZZryympQqVRDwgABrrQnlHQ8w7R94y9mKVBYXtPi8SeTuWB1QIgbpPT32OLpFYReuHABDMPg3nvvbfTzje1DGT16NKZMmYLKykqsWrVKn9sTYhTFfN94e8qMF0uIhz08HKyhVGlanSV/No07vquvI2zlpilpxBeVTymshFrT9r3w/HK+v6sd5DKqmEc6Hi8nG3TxcQTLAkduFLR4PD9jOjDE3dBDI0ag11+9oiJuKS04OLjex2Uybsmyqqqq0fMmTJgAlmWxc+dOfW5PiFEUVlCNULExDIOBodxs6L+tXJI/yy/FB5huP1gnF1vIZRIoVRpkFjf+d04XfFIS7QclHdnISG5f+P6rec0eV12rxnFtENqWveTE/OgVhEql0nr/8hwdubp9OTk5jZ7n6so9eWRmZupze0KMgq8RSuWZxDVIuyR/srVBqHbmtE+gi8gj0p1UwgizoTfyy9p8nRSqEUoIxnblEpL2Xc2DUqVp8rjjtwpRo9LA19kGEd4OxhoeMSC9glBvb+4Hp6SkpN7HAwICAHDL9Y1JTU0F0PRMKSHmpIhmQg1igHY57XRqMWrVTT/x1KVUaXAhkyvP0ta+82IJ9+ZebCfltj05id9TGuxO+0FJx9U30BUeDtYoq1bh+K2mE5T2XckFAIyK9ATD0H7Q9kCvIDQqKgoAcP369Xof79evH1iWxbZt21BRUX/jvkajwc8//wwA8PPz0+f2hBgFH4S62VMQKqZwLwe42ctRVavGfym69ZG/kl0KpUoDZ1srk88ehntxMzFJeW0PQlMoM54QSCQMxnfjJrW2nGt8hVSl1mDnBW51dXw3H6ONjRiWXkHo0KFDwbIsjh07Vu/j06ZNAwAUFxdj6tSpuHLlCpRKJS5fvoyHHnpIqBc6duxYfW5PiFEUVVIQaggSCYPRkV4Abs9wtITPjO0X5GrymRB9g1CNhkVqIdUIJQQApvb1BwDsuJCNsuraBp8/drMQhRVKuNnLMVSbUU8sn15B6MSJEwEAJ0+erLf/c+LEiRgyZAhYlsXevXvRvXt32NraokePHti6dSsAwM7ODm+++aY+tyfEKIppJtRgxkZxQeieK7k6dVw7eoMLQoeEmT4zNly7J+1GblmbusVll1ajRqWBTMLAz8VW7OERYlH6BrogzNMe1bUa/Hmm4Wzo2pPcNr7JPXxhJaVKEu2FXv+TvXv3RlxcHF5//fUGSUYbN25Ez549wbJsgzdHR0f8/vvvCA0N1WvwhBgD7Qk1nOHhnpBLJUgtrMTN/OZnFJUqjZBJb8qZkNjYWCQkJCDI3R4yCYMKpRpZimoAXA/v5rrX8OcCt5OSAt3sIJNKWjyXkPaMYRg8PiQYALD60K16+8TTCiux+zK3WjJncJAphkcMRO/2L021BPP29sbp06exYcMG7N69Gzk5ObC3t0f//v3x5JNPwtOTyisQy0B7Qg3H3lqGwWHuOHg9H3su56Gzl2OTx55OLUZVrRpu9nJEejd9nKFJpVLExMQAAEI8RiAprxxJuWX4/vOPERMTg/j4eN3OHTsHALcfNCEhocVzCWnvHr4rAJ/tu4HMkip8ezgZz44KAwC8v+MyWJYryxRuwt99Ij6D9iCUSqWYOXMmZs6cacjbEGIwLMvWKVZPQagh3BPlrQ1Cc4QnncbsrZMZa8rOVfwL75iYGPR/6Bmg871YsfwDbPluBeLj45vt1V333DHX8gD/CUjZ8zN++PV/LZ5LSHtnYyXFwgmRePOPRHy65zo8Ha2RWVyFvy/lQiphsGhSF1MPkYiMGmET0ozyGhVq1dx+P1qON4x7unohZgtwJq0EqYUVCHJvmKTDsqwQhPI1BU2pbjAJ6bdIVat0DiLrn/t1q84lpL2b1s8f/1zNw86LOXjj9/PCx18bG0G94tsh2t3bgsLCQmzatAmLFi3C+PHjERUVBS8vL1hZWcHJyQldunTBrFmzsHnzZmg0utU65G3duhXTp09HcHAwbGxs4OXlhSFDhmD58uUoLS3V+Trl5eVYuXIlxo4dCx8fH1hbW8PT0xMDBgzAkiVLkJurW+axLn788UcwDKPzm6XvceOX4m2tpCZrEdne+TrbCv2jf/8vo9FjLmeXIrWwEnKpBMPNpFNKdHQ0ZFZyQK2CRGbVqiAyOjoajNQKUKtgJZdTAEqIFsMw+OzRPnhyWAhc7azQydkGi++LwvOjO5t6aMQQWNKs5cuXswB0euvbty+blJTU4jXLysrYKVOmNHutgIAA9vjx4y1e659//mG9vb2bvZabmxu7ceNGMb4d7A8//KDz9wMAu3jx4jbdR6FQsABYhUIhyrjb6kxqERu0cDs75IN9Jh1He7ftfCYbtHA72y9hD1ulVDX4fNzWS2zQwu3ss7/8Z4LRNS4+Pp77OZfKWABsXFyczucufDem3rnx8fEGHCkhhBhPa56/dVqOr7tZnt9Uf+fH26ru9cyVVCpFr169cNdddyEiIgK+vr6Qy+UoLi4Wkq9KSkpw5swZDB8+HOfPn4eXl1ej11Kr1Zg+fTp27doFgEvgmj9/PqKiolBUVIR169bh6NGjSE9Px6RJk3D06FF07dq10WsdPnwYEyZMgFLJzdb16dMHjz76KIKCgqBQKLBnzx5s3LgRRUVFmDFjBrZu3SqU1RLDiy++iDFjxjR7TJculr2Hh/aDGsf4bj7wc7FFZkkV1v+bhieGhgifq65VCwWsp/XzN9UQ6+ETiRbHxmFdbX/kHlyLxYsXg2GYFmc1ExISsOz9eDgPm4V+DzyFUZWHhb+DNCNKCOlQdIlqGYZhJRIJK5FImvx4W9/MXVpaGltcXNzsMQUFBeyAAQOE2b/nnnuuyWO//vpr4bioqCg2JyenwTGvv/66cMzw4cMbvU5NTQ0bHBwsHPfKK6+wGo2mwXF79uxhra2tWQCst7c3W1pa2vwX3IK6M6E//PCDXtdqjrnMhP7+XzobtHA7O/u7kyYdR0fw4JMvs87DZrG94v5mc0urhI//fCyZdR42i/UfM5utValNOEIOPwPKz14+8MURNmjhdvbRZ99ocVaTP3fy3JfZoIXb2ZfWnWn0moQQYqla8/yt855QtolizGwjdUB1fbMEAQEBcHFxafYYd3d3fPXVV8L727Zta/Q4tVqNuLg44f01a9bA27thksWyZcvQu3dvANxs5+7duxscs3nzZqSkpADgZkA/+eSTRjvI3HPPPXj33XcBALm5uVixYkWzXwupr6iiBgDgTjOhBtczwA2KI2uRsudnPP3zadzKL4eiqhaLouOgOLIWA8I8IDODItVqtbpeIlEvfxcAQJeJcxEfHw+1Wt3iuQFjZgMAunXiEi2io6NbPJcQQtobnZbj9+/f36qPd0TdunUTHtftHlXXoUOHkJ2dDQAYOXIk+vbt2+hxUqkUL730EubNmwcAWLduHcaNG1fvmH379gmP58yZA4mk6SfnuXPnCst9a9eupSW/Viiq4NrHUWa84cUujkFxpRKfffQ+DgAYk/4oSo6ug+LIWgSPm4u1Xyw39RABoEGyXQ8/ZwBAYkYJ/mjhd4s/d/hH/wAAundyFj5Hv5eEkI5GpyB05MiRrfp4R3Tjxg3hsY+PT6PH7Ny5U3g8adKkZq9Xd+9m3fN4GRm3s4gjIyObvZa/vz/s7OxQWVmJa9euISkpCeHh4c2eQzi3W3ZamXgkHcPKZUsAAJ999D4UxzcAahXcRjyGP1Z/Ahsr86xO0CuACyQvZZVCpda0OFurqKxFelEVAKBbnSCUEEI6GtOvbbUD5eXlePHFF4X3p02b1uhxFy5cEB7379+/2Wv6+PggICAAALeMnp+fX+/z+mxnSExMbPO5dX355Zfo2rUrHBwcYGdnh8DAQEyZMgVfffUVKisrRbmHqRUKQai1iUfScaxctgRy+e3SR7t+Wol+Qa6mHlaTQj0cYC+XoqpWjRsttB4FgEvZCgCAv6stnO3oxQ0hpOPSKwhNS0tDWloaqqurW3VeTU2NcK4lycvLw+bNm7F582b8+eef+OGHH/Dqq68iPDxc2JrQr1+/JmtjXrt2TXgcEhLS6DF11T2m7rlA/dnW69evN3udzMzMekHh1atXW7y3Lk6dOoWrV6+ioqICVVVVSE9Px7Zt2/Dcc88hODgY27dvF+U+pnQ7O56CBWNJSEiAUqmEXC6HRlWLXWu+MPWQmiWRMOguLMkrWjz+YiZ3THeaBSWEdHB6dUwKDg6GRCLBn3/+iSlTpuh83oEDBzBx4kRIJBKoVCp9hmBUZ86cwYMPPtjo5zw9PTF37lzExcXBxsam0WNKSkqExx4eHi3ez93dvdFzAWD48OH44YcfAAA///wzXnrppUYTkwCuwHxT42gLqVSKwYMHY/jw4YiIiICDgwNKSkpw+vRp/PbbbygqKkJ+fj6mTJmCtWvX4tFHH23xmjU1NaipqRHeb02xfkPil+NpT6hx1O2hHh0dLbwPmPeeyV4BLjiZXITEjBI8fFdAs8eeTi0GAPQMoCCUENKx6d22U59lYUvJkNfFiBEjMGLEiCYDUIBbtuc1dxzP1tZWeFxWVlbvc9OmTcMbb7yBoqIinDlzBm+99RY++uijBoHo/v37sWTJknof0yfAGzZsGFJSUuDv37Be41NPPYWPPvoI8+fPx4YNG8CyLObNm4ehQ4ciMDCw2et+8MEH9SoHmIsiqhNqNHcGoMAdLS5hvoFoT38uoDydWtLscSzL4r8ULggdEOxm6GERQohZs/g9oaNGjWpVG8nm3tavX9/svSZMmCCUl1KpVMjOzsbmzZtx9913Y+PGjbj33nsxc+ZMo+yHdHR0xGeffSa8//HHH6N///745JNP8Pvvv+Pbb7/FI488grFjx6K6uhphYWHCsc1l0rekc+fOjQagdce1du1ajBo1CgBQXV2NZcuWtXjdd955BwqFQnhLT09v8xjFolJrUFLJZcdTEGp4d5Y+4llC+aIBIVxAeTWnFCXaFy6NSS6oQGGFEnKZBD38aSaUENKx6T0T2hb8rJ6dnZ0pbi8KqVQKHx8f3H///bj//vuxaNEifPDBB1i3bh0A4Ndff21wjoODA4qLuVmQ6upqODg4NHuPqqoq4bGjo2ODz8+aNQtVVVV44YUXUFNTg9OnT+P06dP1jpFIJIiLi0NxcbFQI9TV1bBJHlKpFEuWLMGwYcMAANu3b8cXXzS/r8/a2hrW1uaV/FNSxQWgDAM429KeUENrai81YL4zoDwvRxt09nLAjbxynLhVhAndG6+Q8W9yEQCgt78LrGXmme1PCCHGYpIgdO/evQAAX19fva81bdo0obC7vloqddSchIQE/PHHH0hKSsK6desQExPToGWli4uLEIQWFBS0GIQWFhbWO7cxTz31FCZMmIAvv/wSu3fvxs2bN1FRUQEfHx+MGDECL774IgYOHIg5c+YI5zRVQkpMgwcPho2NDaqrq5GWlobKykqLe9HB7wd1trUyiyLpxLwNDnXHjbxyHL9Z0GQQejipAAAwpLN7o58nhJCOROcg9ODBgzh48GCjn1u/fj3OnTvX7Pksy6KiogJnzpzB/v37wTAMhgwZ0qrBNuaFF17Q+xpikEqlGDduHJKSkgBwyVd3BqGRkZFITk4GACQnJyM4OLjZa/LH8uc2xd/fH0uXLsXSpUubPObSpUvC4wEDBjR7XzFIJBK4ubkhKysLAJcMZWlB6O3yTLQUT1o2LNwDa06k4p9reYhl2Qb7s1VqDQ4ncaXWRkR4mmKIhBBiVnQOQg8cOID4+PgGH2dZFhs2bGjVTVmWhZWVFV566aVWnWfu6i6Z8zOedfXo0QO7du0CwJU3Gj16dJPXys3NFfZFenl5wdOz7U9ahYWFQo1SBwcH9OnTp83X0pVGo6n3PWip9ak5EgrVU2Y80cHwcA/IZRKkF1UhKa8cEd71t9CcTS9BabUKzrZWQqtPQgjpyFq1xthU7/fW9ozv27cvtm3b1mTbSkvFz4ICaDRonDBhgvC4sS5Ide3YsUN43FJ3pZasWbMGtbXc/sbZs2cbZe/liRMnhD2tfMcmS8NnxrvSTCjRgZ1chqFh3DL77ksNW/f+lci17B3TxQtSSePl1AghpCPReSb0iSeeEDKeAS7wHDNmDBiGQUJCAoYOHdrs+RKJBA4ODggJCbHIWbGWpKWl1QssG/t+jBw5Ej4+PsjJycGBAwdw5syZRgNxtVpdL/P9kUceafO4srKyhBlsuVyOl19+uc3X0pVGoxFK6gDAvffea/B7GkJROc2EktaZ2MMX+6/lY+OZTDw/urOwJK9Sa7A9kduaMqVXJ1MOkRBCzIbOQWhQUBCCgoIa/Vz37t3bZR/5nJwcrFq1Ci+++CLc3Jqu6Xf9+nVMnTpVKM00evRodO3atcFxUqkUMTExeO655wAAc+bMwT///AMvL696x7399tvCHtuhQ4di/Pjxjd43OTkZEomkyf+XS5cu4aGHHhKWxePi4prdW1p3D1tje1aPHz+OCxcuYM6cOU3WOa2oqMCCBQuwb98+AFzW+8KFC5u8pznj94S6O1AQSnQzuYcv4rZeQnJBBU4mF2FQKDczuudyLgrKlXC1s8Kw8JYbVRBCSEegV3Y836qye/fuogzG3FRXVyM2NhZLlizBqFGjMGDAAISFhcHJyQlKpRIZGRk4fPgw/v77b2G528/PD99++22T15w/fz42bdqEPXv24NKlS+jVqxfmz5+PqKgoFBUVYd26dThy5AgAbh/lqlWrmrzW6dOnMWPGDAwdOhSjRo1CeHg4bGxskJOTg/3792Pbtm1CR6onn3wSb731ll7fj9zcXCxYsACvv/46xo4di379+iEgIAD29vZQKBQ4c+YM1q9fL2T1MwyDb7/9tsUELHNVUM51cPJwMK/SUcR82VvLcH8fP/x6Mg0r9l7HuvmDwLLAFwduAAAeGxQEK6q0QAghAPQMQtvj7GdjVCoV9u7dK5SWasq4ceOwevXqJmcmAUAmk2Hjxo2YOXMmtm/fjpycHCQkJDQ4zt/fHxs2bEC3bt2avadGo8Hhw4dx+PDhRj9vZ2eH6OhoLFy4sMm2nq1VXl6OTZs2YdOmTU0e4+Pjg2+//RaTJ08W5Z6mIAShjhSEEt09NyoMf5zOwIlbRfjuSDLKqlW4mFkKWyspnhgSbOrhEUKI2TBJnVBLERwcjPPnz2Pv3r04efIkLl++jIyMDJSVlcHKygrOzs4IDw/HgAEDMGPGDJ1LHzk6OmLbtm3YsmULfv75Z5w6dQp5eXlwdHREWFgYpk6digULFsDZufmOKqNHj8aqVauwf/9+JCYmIjc3F6WlpfDw8EBoaCgmT56MOXPmwM/PT4xvB+655x5s2bIFJ0+exL///ov09HQUFhYK5Ze8vLzQt29fTJ48GQ8//LBOrUnNWYF2T6gHJSaRVvB3tcNLYzrj493XseSvK8LH37u3K9xpVp0QQgQMK2IDd41Gg5s3b6K4uBjV1dU6nTNixAixbk/akdLSUjg7O0OhUMDJyckkY+gdvxsllbXY/eqIBuV2CGkOy7L4ZPd1fHckGQwDPD+6M54bFSbaagQhhJir1jx/izITeuzYMXz00UfYs2ePzsEnwO0Z5PcsEmJOauv0jac9oaS1GIbBG+Mj8fI94WAA6rhFCCGN0DsI/eSTT7Bw4cIGtUMJsWRF2sx4qYSBC/WNJ21ESUiEENI0vYLQw4cP48033wTDMGBZFn5+fhg9ejT8/f2NUhCdELHFxsZCKpXiwXlcNy83ezkk2sLiCQkJUKvViI2NNeEICSGEkPZBryB05cqVwuOEhAS88847kEjolT+xXHwt15SCCsB2ONy1SUkJCQmIiYlptHUtIYQQQlpPryD0+PHjYBgGDzzwAN59912xxkSIyURHRwMAYmJi4DwsA55PvFgvAOU/TwghhBD96BWE8kXJ77vvPlEGQ4g5iI6OxqmUImz7fgXWnfgNalUtBaCEEEKIyPRaO/fw4NrP2dvbizIYQszFoIeeBqQyqFW1kMvlFIASQgghItMrCO3duzcA4ObNm2KMhRCzsf3HzwG1CjIrKyiVyka7WhFCCCGk7fQKQp988kmwLIv169eLNR5CTC4hIQHHf/8KzsNmYd3xW4iPj0dMTAwFooQQQoiI9ApCH3zwQTz00ENITEzEW2+9JdaYCDEZPgkpfOKTcBn6KNwduKV4CkQJIYQQceldrP6XX36BtbU1PvnkE5w+fRqvvPIKBg8eLOwXJcSSqNVqxMfHY5tkMPLKauCp7ZbE7wlVq9WmHB4hhBDSbujVO14qlQqPWZZtdV9kattJmmLK3vEaDYvw93ZCrWFx4p274eNsY9T7E0IIIZbKaL3j74xfqW0naQ8UVbVQa7ifZTdtsXpCCCGEiEuvIHTEiBGtnv0kxNwVlNcAAJxtrSCXUQcwQgghxBD0CkIPHDgg0jAIMR/52iDUw4FmQQkhhBBDoWkeQu5QWK4EALhrk5IIIYQQIj4KQgm5A78c70lBKCGEEGIwFIQScocCWo4nhBBCDE7vOqE8jUaDjRs34u+//8bly5dRVFSE2traBi09L168KKTvd+vWTazbEyIaWo4nhBBCDE+UIPTo0aOYM2cOUlJShI81VTd048aNiI+Ph5OTE7Kzs2FjQzUYiXm5PRNKQSghhBBiKHovx+/evRtjxoxBSkoKWJaFVCqFs7Nzk8c//fTTALhipjt27ND39oSILl87E0rL8YQQQojh6BWElpSU4NFHH0VtbS0cHBywevVqlJSU4IcffmjyHF9fXwwaNAgAsG/fPn1uT4hBFGpnQmk5nhBCCDEcvYLQL774AsXFxZDJZNi1axeeeuop2NnZtXjekCFDwLIszpw5o8/tCREdy7KUHU8IIYQYgV5B6I4dO8AwDB566CEMHjxY5/MiIyMBALdu3dLn9oSIrkKpRnWtBgDg4UjL8YQQQoih6BWEXr9+HQBw9913t+o8FxcXAIBCodDn9oSIjl+Kt7WSwk4uWvEIQgghhNxBryC0tLQUAODm5taq82prawEAMhk9yRPzkl+mzYynWVBCCCHEoPQKQvngs7CwsFXn8aWcPDw89Lk9IaLL0wahXo5UOowQQggxJL2C0M6dOwMAjh8/3qrzdu3aBYZh0KtXL31uT4jo8kqrAQBejpSURAghhBiSXkHouHHjwLIs/vjjD+Tk5Oh0zr59+3D48GEAwPjx4/W5PSGiuz0TSkEoIYQQYkh6BaFPP/007OzsUFFRgWnTprWYaHT8+HE8+uijAABXV1c8/vjj+tyeENEJQagTLccTQgghhqRXZpC3tzeWLl2KV155BcePH0dkZCSeeuopqNVq4ZgdO3YgLS0NO3fuxF9//QWNRgOGYbBixQrY29vr/QUQIiY+CPWkmVBCCCHEoPROT3/ppZeQl5eHDz74QPgXgNA3/r777hOOZVkWABAXF4fHHntM31sTIjraE0oIIYQYh9694wFgyZIl+Ouvv9CnTx+wLNvkW/fu3bF9+3a89957YtyWENHlU3Y8IYQQYhSiFeqcMGECJkyYgIsXL+LQoUNISUlBSUkJHP6/vXuPiqpc/wD+3TMgyGW4I5Io5AUlDQM1LykY3lIyPdqxi0fUk4bXzE4/s+KiqNU5lavl8ZaVmresTBdmYJmYimIdzQtpIgZKeQeBEQRk2L8/aHYgtxlmZs8M8/2sNWvtYT/vft6Ztdf4+O6939fFBe3atUNERATCw8ONlY7I6O5pqpBfUgEA8FVxJJSIiMiUjD5bfPfu3dG9e3djH5bI5LRrxtspBHg6cbJ6IiIiUzLK5XiiluBG8Z+rJbk4QKEQzNwbIiKils2gIlShUMDOzg7Jycl6tdu7dy+USiWX7SSL8tf0TLwUT0REZGoGV4HaJ97lakdkKjfUfDKeiIhILrwcT/Qn7eV4Hz4ZT0REZHJmKUJLS0sBAI6O/MeeLAeX7CQiIpKPWYrQjIwMAICvr6850hPV66b2cjzvCSUiIjI5ne8JPX36NE6ePFnvvv3796OwsLDR9qIooqSkBCdOnMDmzZshCAJ69+6tT1+JTOoGJ6onIiKSjc5F6M6dO7F48eI6fxdFEStWrNArqSiKEAQBsbGxerUjMiXtPaG8HE9ERGR6el2Ov38Zzob+3tSrTZs2WLduHR5//HGjfyCi5qiqEqXJ6nk5noiIyPR0HgkdM2YMAgMDa/1typQpEAQBs2fPRlhYWKPtFQoFXFxcEBQUhB49ekCpVDarw0SmcKukHJVVIhQC4OPCIpSIiMjUdC5CQ0NDERoaWutvU6ZMAQBERUVh9OjRxu0ZkYyuFmrnCHWEnZIzlxEREZmaQZPVr1+/HgCaHAUlsnRXi+4CANq686EkIiIiORhUhMbExBirH0RmdeXPkdC2bixCiYiI5GCyxdsLCwuhVqvh6uoKd3d3U6UhMoprxdoitLWZe0JERGQbjHbzW0lJCVasWIHBgwfDxcUFXl5eCAwMhJeXF1xcXDB48GCsXLkSJSUlxkpJZDRXCv+8HM+RUCIiIlkYpQj97rvv0LlzZ8ybNw8HDx5EaWlprSmZSktLcfDgQcydOxddunTBvn37jJGWyGiuFlWPhPq7cySUiIhIDgYXoSkpKYiOjsb169elotPZ2RmhoaEYMGAAQkND4eLiIu27evUqRo0ahdTUVGP0n8gorv1ZhPpxJJSIiEgWBhWhRUVF+Mc//oF79+5BFEWMGDECBw8eRHFxMX7++WccOnQIP//8M4qKivDDDz/giSeeAADcu3cPEydORHFxsVE+BJEhNFWidE+oP+8JJSIikoVBRejq1atRUFAAQRCQkJCAb775Bo899hgEQagVJwgCBg4ciD179mDRokUAgNu3b2P16tWGpCcyipvqcmiqRNgpBPhwyU4iIiJZGFSE7tmzBwDQt29fJCQk6NQmLi4O/fr1gyiK+Prrrw1JT2QUV/6cI7SNyhFKhdBENBERERmDQUVoVlYWBEHAM888o1c7bXxWVpYh6YmMgveDEhERyc+gIrSwsBAA0LZtW73a+fn51WpPZE6cnomIiEh+BhWhHh4eAIArV67o1e7q1asAwEnsySJweiYiIiL5GVSEdunSBaIo4rPPPtOr3fbt2wEAwcHBhqQnMgpp3XiOhBIREcnGoCJ05MiRAIBjx45hyZIlOrVZunQpjh49CkEQMGrUKEPSExmFdiSURSgREZF8DCpCZ8yYAU9PTwBAQkICRo8ejfT09Hpj09PTMXr0aMTHxwOovpQ/Y8YMQ9ITGUVeQfVI6APuTmbuCRERke2wM6Sxm5sbPv30U4wZMwYajQZ79uzBnj174OTkhI4dO8LZ2RklJSX47bffpDXjRVGEnZ0dNm3aBJVKZZQPQdRcpRWVuHWnHADQ3otFKBERkVwMKkKB6kvyu3fvxuTJk3H9+nUAQElJCc6cOSPFiKIobbdp0wYbN27EsGHDDE1NZLDLBaUAAHcne7i1tjdzb4iIiGyHwWvHA8Dw4cORnZ2NDz74AJGRkXBycpLWiteuJR8ZGYkVK1YgOzubBShZjEv51UVoe0+OghIREcnJ4JFQLWdnZ8yZMwdz5swBABQXF0OtVsPV1ZWX3cli5RWwCCUiIjKHZhehf/zxB06fPo2ioiK4ubmhR48eaNeunbRfpVKx+CSLx5FQIiIi89C7CP3xxx/x8ssvIyMjo86+vn37Yvny5ejTp49ROkdkatp7QjvwoSQiIiJZ6XVP6LfffovIyEhkZGTUuudT+zp69CgiIiKwd+9eU/WXyKi0RWgAR0KJiIhkpXMRqlarERMTg7KyMulp906dOqF///7o1KmTFFdeXo6YmBgUFxcbv7dERqSpEvH7be1IqLOZe0NERGRbdC5CN23ahOvXr0MQBPTq1Qu//PILsrKycPjwYWRlZeHs2bPSZfibN29i06ZNJus0kTFcLbqLexoR9koBfiqulkRERCQnnYvQlJQUAIC3tzf27t2Lbt261drftWtXpKSkwNfXt1Y8kaW6/OdDSQEeTlAqBDP3hoiIyLboXISePn0agiBg0qRJ8PDwqDfGw8MDkyZNgiiKtSarJ7JEvB+UiIjIfHQuQgsKCgAAPXv2bDQuNDQUAJCfn9/8XhHJ4BKfjCciIjIbnYtQ7drvrq6ujca5uLgAAO7evWtAt4hML/dW9TnNOUKJiIjkZ5RlO1uy/Px87Ny5E6+//jqGDx+OkJAQ+Pr6wt7eHiqVCl27dsXzzz+PXbt2oaqqqsnjaTQaZGZmYsOGDZgzZw769esHJycnCIIAQRAwefLkZvUzOzsbr776Krp37w43Nze4uLggODgYs2bNwsmTJ5t1TEvMaUzZN+4AADr5upi5J0RERLbHaMt2tlTr16/Hq6++Wu8+tVqN8+fP4/z589i6dSvCwsKwffv2WlNW3e/vf/87vvrqK6P28cMPP8S8efPqjD5nZWUhKysLa9euRXx8POLj4606pzFVaqqQm189EsoilIiISH56F6GCYHtPESuVSoSGhqJXr17o0qUL2rZti1atWuH27ds4fvw4tm/fjsLCQpw4cQIDBw7EqVOnpFkC7qfRaGq99/T0hJeXFy5cuNCsvm3evBkvvvgiAEChUOCZZ55BVFQU7OzskJ6ejo0bN6K8vBwJCQlwcHDAggULmpXH3DmN7VJBKe5pRDi1UsLfrbW5u0NERGRzBFE783wTFAqFzgWo9pBNxQuCgMrKSp2OaS55eXlwdXWFu7t7gzH5+fkYOXIkfvzxRwDAzJkzsXLlynpjly1bBrVajfDwcISHhyMoKAgbNmzAlClTAAAxMTHYsGGDTn27efMmOnXqhOLiYigUCuzcuROjR4+uFZORkYGoqCiUlpbCzs4OmZmZCA4O1un45sxZXFwMNzc3FBUVQaVSNbu/DUnNvIbYzcfR4wE37J7zmNGPT0REZIv0+fe7WfeE1rdkp/YFQLq/sbG4mvGWLCAgoNECFAC8vLywevVq6f3u3bsbjH399dfx1ltvYfz48QgKCjKob++++660MtWsWbPqFIMA0LdvXyQlJQEAKisrsWjRIqvLaQoXb1bfD9qZl+KJiIjMQq8iVJfC0ZoKTGN66KGHpO1r167JknP79u3S9ssvv9xg3LRp0+DsXL0sZXJyskEzF5gjpymcu1pdSHdu0/hsD0RERGQaOhehVVVVRn/df3+kNcvOzpa2/fz8TJ7v7NmzuHTpEgCgW7dujY6qurq6YuDAgQCqp9r64YcfrCanqZz9swh9yN/4l/qJiIioaZyiyQju3LmDOXPmSO/Hjx9v8pw1V6Tq3bt3k/E1Y5q7mpU5cppCaUUlcv6cI7RbWxahRERE5sApmvRw48YNHDlyBED1yHBRURFOnz6Nzz77TLoEHx4ejsTERJP35fz589K2LveW1oyp2dZScpaXl6O8vFx6r73v1BR+vaaGKAK+rg7wcXUwWR4iIiJqGItQPZw4cQJjx46td5+Pjw+mTJmCRYsWwdHR0eR9KSwslLa9vb2bjPfy8qq3raXkfOutt2R7gOmXK9UFbggvxRMREZkNL8cbyaBBgzBo0CBZClCg+hYALV1ytm7911yYarXa4nIuXLgQRUVF0isvL69ZfWxIYmKi9MR+a3slurVV4eF27gCApKQkWUaviYiI6C9WX4RGRkZKU0IZ+vrss88azTVixAjpyf/KykpcvXoVu3btQlRUFHbs2IHo6Gg899xzKC0tlenTtxwODg5QqVS1XsakVCoRHx+PpKQkjA9vh5SXBmL+0C5ISkpCfHw8lEqlUfMRERFR43g5vpmUSiX8/Pzw1FNP4amnnpLm/9y2bRsAYOvWrSbN7+Ly1/yWZWVlTcbXnCLJ1bV50xKZI6exxMXFAYC0jGhcXJxUgC5evFjaT0RERPKw+iJ0/Pjx6Nmzp1GOZchKQklJSfjyyy9x4cIFbNu2DfHx8ejatatR+lWfmhPo37p1q8n4/Pz8ettaek5jqlmILlmyBBUVFSxAiYiIzMTqi9DZs2ebuwsAqkdGhw0bJq0Bf+DAAZMWoTUL5pycnCbja8Y0t9g2R05ji4uLkwrQVq1asQAlIiIyE6u/J9SS1LzkfPv2bZPm6tGjh7T9008/NRlfM6Z79+5Wk9PYkpKSpAK0oqJCeliJiIiI5MUi1Ii0o6BA9ZRNphQSEoL27dsDAM6dO4fc3NwGY+/cuYNDhw4BAJycnBAREWE1OY2p5j2g5eXlWLx4sfSwEhEREcmLRaiRXL58GSkpKdL7AQMGmDznhAkTpO3333+/wbgPP/wQJSXVKwSNHj0aTk5OVpXTGOp7CCkuLo6FKBERkZmwCG3EtWvXsGjRIhQUFDQal5WVhZEjR0pTMw0ePBjdunUzef/+9a9/SbcArFy5EsnJyXVijh07JhVddnZ2SEhIaPB4NaeramiU09g55aLRaOp9CElbiGo0GjP1jIiIyDYJoiiK5u6EpcrNzUVQUBDs7OwQGRmJPn36oGPHjlCpVKioqMDvv/+OQ4cOYe/evbh37x4A4IEHHsDBgwfx4IMP1nvMnJwcfPzxx7X+dvr0aezevRsA8PDDD+PJJ5+stf/xxx/H448/Xu/xNm7ciMmTJwMAFAoFnnnmGQwdOhRKpRLp6enYuHGjNJ3S0qVL8frrrzf4eQVBqNXPwMBAk+dsSHFxMdzc3FBUVGT0OUOJiIjINPT691ukBuXk5IgAdH4NGzZMzM3NbfSYaWlpeh0TgJiQkNDoMVetWiU6Ojo22F6pVIrx8fFNft6abXJycmTJ2ZCioiIRgFhUVNTsYxAREZG89Pn32+qnaDKlwMBAnDp1Cvv27cOxY8dw9uxZ/P7771Cr1bC3t4ebmxs6d+6MPn36YMKECejTp49Z+jljxgwMGTIEa9asQWpqKvLy8lBVVQV/f39ERUVh+vTpeOSRR6w+JxEREbUcvBxPFomX44mIiKyPPv9+88EkIiIiIpIdi1AiIiIikh2LUCIiIiKSHYtQIiIiIpIdi1AiIiIikh2LUCIiIiKSHYtQIiIiIpIdJ6sni6Sdvra4uNjMPSEiIiJdaf/d1mUaehahZJHUajUAICAgwMw9ISIiIn2p1Wq4ubk1GsMVk8giVVVV4cqVK3B1dYUgCEY9dnFxMQICApCXl8fVmMjq8XymlobntHUTRRFqtRr+/v5QKBq/65MjoWSRFAoF2rVrZ9IcKpWKP3DUYvB8ppaG57T1amoEVIsPJhERERGR7FiEEhEREZHsWISSzXFwcEBCQgIcHBzM3RUig/F8ppaG57Tt4INJRERERCQ7joQSERERkexYhBIRERGR7FiEEhEREZHsWIQSERERkexYhJJVSU5OxtNPP43AwEA4OjrC19cX/fv3x3/+8x+TrTNvjpxkG+Q6t9RqNXbs2IHZs2ejf//+8PHxgb29PVQqFbp27YpJkyYhNTVVp7WeiRpjCb+XkydPhiAI0isxMVGWvNQMIpEVUKvV4ujRo0UADb4CAgLEo0ePWnVOsg1ynlvvvfee6Ojo2Ggu7WvgwIHipUuXjPAJydZYyu/lN998UydvQkKCSXNS83GKJrJ4Go0G0dHRSE1NBQC0adMG06ZNQ0hICAoKCrBt2zakp6cDADw8PJCeno5u3bpZXU6yDXKfW7GxsVi7di0A4IEHHsCQIUMQHh4OX19flJWVISMjA5s3b8adO3cAAEFBQcjIyICvr6+Bn5RshaX8XhYXF6N79+7Iy8uDs7MzSkpKAAAJCQkcDbVU5q6CiZqyZs0a6X+0ISEh4rVr1+rEvPLKK7VGc6wxJ9kGuc+t2NhYcdiwYeK3334rajSaemNyc3PF4OBgKeeUKVMMykm2xVJ+L6dPny6NuM6fP58joVaARShZtMrKSrFt27bSj8nx48cbjOvZs6cUt3fvXqvKSbbBHOdWfn6+TnEnT56U8jk5OYklJSXNzkm2w1J+L7///ntREAQRgLh7924xISGBRagV4INJZNEOHjyIq1evAgAiIiIQFhZWb5xSqcTcuXOl99u2bbOqnGQbzHFueXp66hQXGhqK4OBgAEBpaSmys7ObnZNshyX8XpaWlmLatGkQRRETJkxAdHS00Y5NpsUilCxaSkqKtD1y5MhGY5944ol621lDTrINln5uqVQqafvu3buy5CTrZgnn9MKFC/Hbb7/B09MTH3zwgdGOS6bHIpQs2pkzZ6Tt3r17Nxrr5+eHgIAAAMD169dx8+ZNq8lJtsGSz62KigpkZWVJ7zt06GDSfNQymPucPnLkCP773/8CAN599120adPG4GOSfFiEkkU7f/68tB0UFNRkfM2Ymm0tPSfZBks+t7Zu3YqioiIAQFhYGPz8/Eyaj1oGc57TZWVlmDp1KqqqqhAVFYUpU6YYdDySH4tQsmiFhYXStre3d5PxXl5e9ba19JxkGyz13Lp58yYWLFggvX/zzTdNlotaFnOe0/Hx8Th//jxat24tTUNG1oVFKFk07dyFAODo6NhkfOvWraVttVptNTnJNljiuVVRUYFx48bhxo0bAIAxY8Zg7NixJslFLY+5zumffvoJ77//PgBg0aJF6NixY7OPRebDIpSIyEZVVVVh6tSpOHToEACgY8eO+OSTT8zcK6LGVVRUYOrUqdBoNAgLC8P8+fPN3SVqJhahZNFcXFyk7bKysibjaz7R6+rqajU5yTZY0rkliiJiY2OxZcsWAED79u2xb98+eHh4GDUPtWzmOKeXLFmCzMxMKJVKrFu3DkqlslnHIfNjEUoWzd3dXdq+detWk/H5+fn1trX0nGQbLOXcEkURM2fOxLp16wAA7dq1w/79+xEYGGi0HGQb5D6nT506hbfffhsAMH/+/AbnJSXrYGfuDhA1Jjg4GDk5OQCAnJycJv+R1MZq21pLTrINlnBuiaKIWbNmYc2aNQCq15NPS0vjPXXULHKf0xs2bMC9e/egUChgb2+PJUuW1Bt38ODBWtvauODgYDz99NN65yXTYBFKFq1Hjx5ITU0FUH0j+uDBgxuMvX79OvLy8gAAvr6+8PHxsZqcZBvMfW5pC9DVq1cDAPz9/ZGWloZOnToZfGyyTXKf06IoAqi+n3nZsmU6tUlLS0NaWhoA4KmnnmIRakF4OZ4s2ogRI6TtplbY+Oabb6TtplbusLScZBvMeW7dX4C2bdsWaWlp6Ny5s8HHJtvF30syiBnXrSdqUmVlpejn5ycCEAGIx48fbzCuZ8+eUlxqaqpV5STbYM5za+bMmdLx/Pz8xF9//dXgYxJZ6u9lQkKClCshIcGkuaj5OBJKFk2pVCI+Pl56P2nSJGk+w5pee+01nDx5EgAwYMAADB8+vN7jbdiwAYIgQBAEREZGypKTSMsc5zMAzJkzB6tWrQJQvXTigQMHeP8yGYW5zmlqGXhPKFm8adOmYefOnfjuu+/wyy+/IDQ0FNOmTUNISAgKCgqwbds2HD58GED105bGWDnDHDnJNsh9br355pvS2tqCIOCll17CuXPncO7cuUbbhYWFoX379gblJtvA30tqNnMPxRLpori4WIyOjpYur9T3ateunZient7ocdavXy/FR0REyJKT6H5yns8RERGN5mnotX79euN/cGqxzPEb3RhejrcOvBxPVsHV1RW7d+/Grl278Le//Q0BAQFwcHCAt7c3Hn30UbzzzjvIzMxE//79rTon2QaeW9TS8Jym5hBE8c/5DoiIiIiIZMKRUCIiIiKSHYtQIiIiIpIdi1AiIiIikh2LUCIiIiKSHYtQIiIiIpIdi1AiIiIikh2LUCIiIiKSHYtQIiIiIpIdi1AiIiIikh2LUCIiIiKSHYtQIiIiIpIdi1AiIiuQmJgIQRAgCAIOHDhg7u5YjNu3b8PHxweCIGDFihXm7k6jysrK0L59ewiCgMTERHN3h8jsWIQSEZlAbm6uVDQa+po8ebK5P47FeuONN3Dr1i106tQJsbGx5u5OoxwdHZGUlAQAeOedd5Cbm2veDhGZGYtQIiKySllZWVi3bh0AYOHChbC3tzdzj5o2ceJEBAUFoaysDHFxcebuDpFZCaIoiubuBBFRS1NaWopvv/22wf2ZmZlSEfLQQw9hyZIlDca2b98eYWFhRu+jtXvuueewbds2+Pv7Izc31yqKUABYuXIlZs+eDYVCgczMTHTr1s3cXSIyCxahRERmcODAAQwePBgAEBERwfs89ZSbm4tOnTpBo9EgLi4OixcvNneXdFZcXAx/f3+UlJTghRdekEZziWwNL8cTEZHVWbt2LTQaDQAgJibGzL3Rj0qlwpgxYwAAmzdvRlFRkXk7RGQmLEKJiKxAU0/H13wQSvsg07Vr1/DGG2+ge/fuUKlU8Pb2xsCBA/H555/j/otgmZmZmDZtGoKDg+Hk5AQvLy+MGjVKrxHaa9euYfHixXjsscfg5+eHVq1awdvbG/3798eSJUtw+/ZtA76Bv1RVVWHTpk0AgNDQUHTs2LHB2Pq+lz/++AMLFy6UvheVSoVHHnkEixcvRnFxcZP5L168iP/7v/9D79694eHhAXt7e3h6eqJz584YNGgQ5s+fj4MHDzZ6jHHjxgGofmJ++/btOn5yohZGJCIi2aWlpYkARABiREREk/EJCQlSfFpaWp39OTk50v6YmBjx8OHDoq+vr/S3+1/Tp08Xq6qqRFEUxbVr14p2dnYNxq5evbrJ/n3wwQeik5NTg8cAIHp4eIipqan6flV1HDlyRDrm3LlzG429/3tJS0sTvby8Guyjv7+/eOLEiQaP9/HHH4sODg6Nfk4AorOzc6P9ys/PFwVBEAGIw4cPb9b3QGTt7ExT2hIRkblcvnwZY8aMQVFRESZPnoyIiAg4Ojrip59+wurVq3H37l18+OGH6NevH1QqFV588UV4e3tj6tSpCA0NRWVlJfbs2YPPP/8cADB37lxERkaia9eu9eZ78803sXTpUgCAs7Mzxo8fj379+sHLywsFBQX4/vvvsWPHDty+fRvR0dHYv38/Bg4c2OzPt3fvXmm7b9++en0v48aNQ0FBAaKjoxEdHQ13d3dcuHABGzduRHZ2Nq5cuYIhQ4bgxIkT6NChQ632P//8M6ZPnw6NRgOlUonhw4dj6NCh8PX1hUKhwI0bN3Dq1Cl89913KCgoaLQv2pHTrKwsHDhwAGVlZXB0dNTviyCyduaugomIbJEpR0IBiJ6enuL//ve/evNqR+ACAwNFLy8vsXfv3mJ+fn6d2Pj4eOl4M2fOrLdfKSkp0vH69u0r/v777/XGHT58WHR1dZXy3rt3r8nP3JARI0ZI/bp48WKjsfd/L0qlUty6dWuduLt374pjx46V4uobnZw1a5a0Pzk5ucGcVVVV4g8//NDk54iJiZGOd/To0SbjiVoa3hNKRNQCrVixAuHh4XX+HhkZiaioKADV90veuXMHX3zxBTw9PevEvvbaa3BxcQEApKam1pvnjTfegCiK8PHxwZ49e/DAAw/UGzdgwAC89957Ut4dO3Y063MBwJkzZwAArVq1woMPPqhX25deegnPPvtsnb87Ojpi06ZNCAgIAFA92nr69OlaMdnZ2QAAHx8fPPnkkw3mEAQBgwYNarIvNadmuj8XkS1gEUpE1ML4+vpiwoQJDe5/7LHHpO0nn3yyzmVnrdatW6NXr14AgJycHJSVldXaf+bMGZw4cQIA8MILL9RbyNb03HPPwc6u+i6wmpfU9VFRUYErV64AADw8PPRqq1Ao8MorrzS439nZGTNnzpTef/nll3X2A0B+fr5RVjuq+X1x9SSyRbwnlIiohenVqxeUSmWD+/38/KTtPn36NHosbawoiigsLKzVtuYT4BqNBrt27Wqyby4uLigsLMTZs2ebjK1PYWGh9GS/l5eXXm1DQkLg7+/faMyQIUOwcOFCAMCPP/5Ya9+wYcPw1VdfoaqqCpGRkVi4cCHGjBmDNm3a6NUPrZr9b+oeUqKWiEUoEVEL01Rx5uDg0KzY+0dCa47e/fvf/9ajh80vusrLy6VtV1dXvdp27txZrxjtiKvW1KlT8cUXX+D777/HpUuXEBsbi9jYWHTt2hX9+/fHoEGDMGrUKHh7e+vUH5VKJW3fvXtXx09B1HLwcjwRUQujUOj+065P7P0KCwub3baioqJZ7WoWxbrM6VmT9nK6rjFqtbrWPnt7e6SkpGD58uW15ib99ddf8cknn2Dy5Mlo27Ytnn/+eVy9erXJXDUnqW/durUuH4GoRWERSkREzaJ9aAkAkpOTIYqizq/m3gPp4eEhFc76jqaWlJToFVPfSKu9vT3mzZuH7Oxs/Prrr/j444/xz3/+U3pAqrKyElu3bkWvXr3qjKTeLz8/X9pu6n5aopaIRSgRETVLu3btpO28vDxZctrb20tP4OtbhGqfbtc1pqn7R4ODgzF16lR89NFHuHjxIo4dO4YePXoAqL6U/9ZbbzXavmb/AwMDm+wbUUvDIpSIiJolIiJC2k5JSZEtr7bQu3fvHi5evKhzu19++aXJ0cl9+/ZJ248++qhe/erTpw8+/fRT6f2hQ4caja/5cFZoaKheuYhaAhahRETULOHh4ejevTsAYM+ePUhPT5clb81Vko4dO6Zzu6qqKixfvrzB/aWlpVi1apX0fvz48Xr3LSgoSNqurKxsNDYjIwNA9RylLELJFrEIJSKiZhEEAW+//TaA6imcxowZU2sksT5XrlxBYmKiQZOzjxgxQtrWpwgFgOXLl0vLkdZUXl6OmJgYXL58WcqhHXHVmj9/Po4cOdLo8WsWsT179mwwrqCgABcuXAAAaVlVIlvDKZqIiKjZRo0ahcWLFyM+Ph63bt3C0KFDMXDgQIwYMQKBgYGwt7dHYWEhzp8/jyNHjiAjIwOiKGLIkCHNztmrVy+0b98ely9fxv79+3VuFxkZidOnT2PChAnYsmULRo0aBXd3d2RnZ2PDhg1SUejp6Yk1a9bUaf/VV19h+fLl6NChA4YOHYqHH34YPj4+0Gg0+OOPP5CcnCyNBtvb2+PVV19tsC8151gdO3aszp+BqCVhEUpERAaJi4tDhw4dMG/ePNy+fRuHDh1q9H5IV1dXuLm5NTufIAiYOHEili1bhszMTJw8ebLRUUetDh06IDExEePGjUNycjKSk5PrxLRt2xZff/11vatICYIAALh06RI++uijBvN4eXlh06ZNjV5i1y5b6ujo2OjqVkQtGS/HExGRwSZNmoRLly5hxYoViI6ORkBAAFq3bg17e3t4e3ujT58+iI2NxRdffIFr167VudStrxdffFFaArTmw0BNiYiIwKlTp7BgwQKEhITAxcUFLi4uePjhh5GYmIhz584hLCys3rbHjx/H1q1bMWPGDPTt2xe+vr6wt7dHq1at4Ofnh6ioKLz77ru4cOECnnjiiQb7UFxcjJ07dwIAnn/+ebi7u+v+wYlaEEHUrn9GRERkRSZOnIgtW7agTZs2uHz5Mlq1alUnJjc3V3pYKCYmBhs2bJC5l3WtWrUKs2bNgkKhwJkzZxASEmLuLhGZBUdCiYjIKsXHx8POzg7Xr1/HunXrzN0dnWg0Grz33nsAgGeffZYFKNk0FqFERGSVunTpgmnTpgEAli1bVmdte0u0ZcsW/Pbbb3B0dERSUpK5u0NkVixCiYjIai1duhTe3t64cuVKremRLFFZWRni4uIAAAsWLKg1pyiRLeLT8UREZLU8PDxw8+ZNc3dDJ46Ojrh06ZK5u0FkMTgSSkRERESy49PxRERERCQ7joQSERERkexYhBIRERGR7FiEEhEREZHsWIQSERERkexYhBIRERGR7FiEEhEREZHsWIQSERERkexYhBIRERGR7P4f+oljT3mvXCoAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot temperature and energy vs. simulation time.\n", + "times = otf_trajectory.times\n", + "eam_times = otf_trajectory.dft_times\n", + "\n", + "temps = otf_trajectory.thermostat['temperature']\n", + "eam_temps = otf_trajectory.gp_thermostat['temperature']\n", + "\n", + "gp_energies = otf_trajectory.thermostat['potential energy']\n", + "eam_energies = otf_trajectory.gp_thermostat['potential energy']\n", + "\n", + "plt.plot(times, temps)\n", + "plt.plot(eam_times, eam_temps, 'kx')\n", + "plt.xlabel('Time (ps)')\n", + "plt.ylabel('Temperature (K)')\n", + "plt.show()\n", + "\n", + "plt.plot(times, gp_energies)\n", + "plt.plot(eam_times, eam_energies, 'kx')\n", + "plt.xlabel(\"Time (ps)\")\n", + "plt.ylabel(\"Potential energy (eV)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "110d41c5-ebcd-46dc-bb7c-aa526c72819c", + "metadata": {}, + "outputs": [], + "source": [ + "# Write xyz file to visualize the simulation.\n", + "position_list = np.array(otf_trajectory.position_list)\n", + "cells = np.array(otf_trajectory.cell_list)\n", + "uncertainties = np.array(otf_trajectory.uncertainty_list)\n", + "\n", + "# Create list of atoms objects.\n", + "atom_list = []\n", + "spec = otf_trajectory.gp_species_list[0]\n", + "skip = 1\n", + "for n in np.arange(0, len(position_list), skip):\n", + " atoms_curr = Atoms(\n", + " spec,\n", + " positions=position_list[n],\n", + " cell=cells[n],\n", + " momenta=uncertainties[n],\n", + " pbc=True)\n", + " atom_list.append(atoms_curr)\n", + "\n", + "# Dump atoms.\n", + "write('Al.xyz', atom_list, format='extxyz')" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "cffe48f8-38d2-4147-ada2-88ab62d5f1f8", + "metadata": {}, + "outputs": [], + "source": [ + "# Write lammps potential file.\n", + "file_name = \"aluminum.txt\"\n", + "contributor = \"Your Name Here\"\n", + "kernel_index = 0\n", + "gp_model.sparse_gp.write_mapping_coefficients(file_name, contributor, kernel_index)" + ] + }, + { + "cell_type": "markdown", + "id": "90b0a373-e2a0-46e8-8a1c-04512d017abc", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "id": "71e2c10f-5038-438f-842a-1489d3dc65dd", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "258d6df4-797a-42e3-85f9-d7e107e68e45", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.19" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}